00:00:00부터 경과한 초 = t라고 할 때

분침의 각도는 도, 시침의 각도는 도 이므로 사이의 각도는 도입니다.

따라서 일 때 둘 사이의 각도가 d도가 됩니다. ()

이 때 (0 <= k < 11, a와 k는 정수)로 놓으면

이므로

360 * 120초는 12시간이므로 하루 중 시침과 분침 사이의 각도가 d도가 되는 시간은 일 때와 그 12시간 후로 2번인 것을 알 수 있습니다

문제에서는 (360 - d)도에 해당하는 시간도 같이 찾아야 합니다. 이에 해당하는 시간은 좌우대칭인 [24시간 - , 12시간 - ]입니다.

따라서 가 11로 나누어떨어지게 하는 k를 찾아 만 계산하면 4개의 시간을 모두 찾을 수 있습니다.

import Data.Set
import Data.List
import Data.Maybe
import Data.Time
import Control.Monad

findTime d = fromList [t, 12*3600 + t, 24*3600 - t, 12*3600 - t]
  where
    t = (120 * a) `div` 11
    a = fromJust $ find ((==0) . (`rem` 11)) [d, d+360..]

render = formatTime defaultTimeLocale "%H:%M:%S" . timeToTimeOfDay  . secondsToDiffTime

main = mapM_ (putStrLn . render)  =<< toAscList . findTime . read <$> getLine

def hmangle(a):
    [hour,minute,second]=[int(x) for x in a.split(':')]
    h=(hour*30+minute/2+second/120)%360
    m=(minute*6+second/10)%360
    angle=abs(h-m)
    if angle<=180:
        return angle
    else:
        return 360-angle

while True:
    count=0
    angle=eval(input("Input angle (0-180): "))
    for hour in range(24):
        hour=str(hour)
        if len(hour)<2:
            hour='0'+hour
        for minute in range(60):
            minute=str(minute)
            if len(minute)<2:
                minute='0'+minute
            for second in range(60):
                second=str(second)
                if len(second)<2:
                    second='0'+second
                time=hour+':'+minute+':'+second
                if hmangle(time)==angle:
                    print(time)
                    count+=1
    if count==0:
        print("None")
    print()

def calcAngle(second, unitSecond):
    second2 = second % unitSecond
    anglePerSec = float(360 / unitSecond)

    angle = 0
    if (0 < second2):
        angle = anglePerSec * second2
    return angle

def getMinuteAngle(second):
    return calcAngle(second, 3600)

def getHourAngle(second):
    return calcAngle(second, 43200)

def getDiffrenceAngle(second):
    hourAngle = getHourAngle(second)
    minuteAngle = getMinuteAngle(second)
    diffAngle = abs(minuteAngle - hourAngle) % 180
    return diffAngle

def printTime(second):
    hour, rest = divmod(second, 3600)
    min, sec = divmod(rest, 60)
    print("{0:02}:{1:02}:{2:02}".format(hour, min, sec))

angle = float(input("Input angle (0-180) : "))

for i in range(0, 86400):
    diffAngle = getDiffrenceAngle(i)    
    if(angle == diffAngle):
        printTime(i)

const Clock = (()=>{
    const Clock = function(h, m, s){
        [this.h, this.m, this.s] = [h, m, s];
    };
    Clock.prototype.getAngle = function(){
        var agH = 30*(this.h%12) + (this.m*60 + this.s)*30/3600,
            agM = 6*this.m + this.s*6/60,
            res = (agM-agH)*(-1)**(agM<agH);

        return res > 180 ? 360-res : res;
    };
    Clock.prototype.print = function(){
        console.log(
            String(this.h).padStart(2,'0') +':'+
            String(this.m).padStart(2,'0') +':'+
            String(this.s).padStart(2,'0')
        );
    };
    Clock.timer = function*(){
        for(let i=0; i<24; i++)
            for(let j=0; j<60; j++)
                for(let k=0; k<60; k++)
                    yield new Clock(i,j,k);
    };

    return Clock;
})();

function solve(a){
    for(let i of Clock.timer())
        i.getAngle() === a && i.print();
}

solve(22);

00:04:00
11:56:00
12:04:00
23:56:00

#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;

int main()
{
    int angle;
    cin >> angle;
    int hour = 0, minute = 0, second = 0;
    for (; hour < 24; ++hour)
    {
        int s_hour = hour;
        if (hour > 12) s_hour = hour - 12;
        for (minute = 0; minute < 60; ++minute)
        {
            for (second = 0; second < 60; ++second)
            {
                double cal_angle = fabs((double)s_hour * 30 + ((double)1 / 120) * second + minute * 0.5 - (double)minute * 6 - second * 0.1);
                if (cal_angle == (double)angle || cal_angle == 360 - (double)angle)
                {
                    printf("%02d::%02d::%02d\n", hour, minute, second);
                }
            }
        }
    }

    return 0;
}

def hour_deg(sec, mins, hours):
    deg = (360 / 12) * hours + (360 / 12) * (mins / 60) + (0.5 / 60) * sec
    return deg

def min_deg(sec, mins):
    deg = (360 / 60) * mins + (6 / 60) * sec
    return deg

def clock_degree(deg):
    for h in range(0,24):
        for m in range(0,60):
            for s in range(0,60):
                degree = abs(hour_deg(s, m, h) -  min_deg(s, m))
                if degree == deg:
                    print(datetime.time(h,m,s).strftime("%H:%M:%S"))
                else:
                    continue

import datetime

while(True):
    try:
        angle = float(input("각도 입력(0~180°) : "))
        if (angle < 0 and angle > 180):
            print("0~180°를 입력해주세요.")
    except ValueError:
        print("숫자를 입력해주세요.")

    if angle != None:
        break

for i in range(86401) :
    m_angle = (i % 3600) * (1/10)
    h_angle = (i % 43200) * (1/120)

    if abs(m_angle - h_angle) == angle or abs(m_angle - h_angle) == 360 - angle:
        print (datetime.timedelta(seconds=i))

C#

using System;
using System.Text;

namespace CD233
{
    class Program
    {
        static void Main()
        {
            int angle = int.Parse(Console.ReadLine());

            for (int hour = 0; hour < 24; hour++)
            {
                for (int minute = 0; minute < 60; minute++)
                {
                    for (int second = 0; second < 60; second++)
                    {
                        var CurrentTime = new ClockHands(hour, minute, second);
                        if (CurrentTime.GetAngleDifference() == angle)
                        {
                            StringBuilder sb = new StringBuilder();
                            sb.Append($"{hour.ToString().PadLeft(2,'0')}:");
                            sb.Append($"{minute.ToString().PadLeft(2,'0')}:");
                            sb.Append($"{second.ToString().PadLeft(2,'0')}");
                            Console.WriteLine(sb);
                        }
                    }
                }
            }
        }
    }

    class ClockHands
    {
        public int TimeInSeconds { get; }

        // 시침 각도 (00:00:00 기준)
        private double HourHandAngle => ((double)360 / 12 / 60 / 60 * TimeInSeconds) % 360;

        // 분침 각도 (00:00:00 기준)
        private double MinuteHandAngle => ((double)360 / 60 / 60 * TimeInSeconds) % 360;

        public ClockHands(int hour, int minute, int second)
        {
            TimeInSeconds = second + minute * 60 + hour * 60 * 60;
        }

        public double GetAngleDifference()
        {
            double difference = Math.Abs(HourHandAngle - MinuteHandAngle);
            return difference > 180 ? 360 - difference : difference;
        }
    }
}

#파이썬
#맞게 푼건지 모르겠습니다. Creator님이 22도 되는 시간을 올려 놓으셨던데, 이건 맞게 나옵니다

def time(x):        #초로 카운트된 시간을 시:분:초로 출력해주는 함수 (12시간후의 시간도 출력)
    hour=x//3600
    x-=(hour*3600)
    min=x//60
    sec=x%60
    print('%02d:%02d:%02d' % (hour,min,sec))
    print('%02d:%02d:%02d' % (hour+12,min,sec))

a=float(input('각도(0~180)를 입력하시오....'))

for i in range (0,12*3600):
    min_angle=round(((i%3600)/3600)*360,3)
    hour_angle=round((i/3600/12)*360,3)
    diff=round(abs(min_angle-hour_angle),3)
    if diff>180:
        diff-=180    
    if diff==a:
        time(i)

import time
def clock(angle):
    m_hand = 0
    h_hand = 0
    for j in range(1, 24*60*60+1):
        m_hand += 0.1       # 1초마다 분침은 0.1도 이동
        m_hand = 0 if int(m_hand) == 360 else round(m_hand, 1)
        h_hand += 30/3600   # 1초마다 시침은 30/3600도 이동
        h_hand = 0 if int(h_hand) == 360 else h_hand
        diff = abs(h_hand - m_hand) if abs(h_hand - m_hand) <= 180 else 360 - abs(h_hand - m_hand)
        if float('%0.1f' % diff) == angle:
            print('{}'.format(time.strftime('%H:%M:%S', time.gmtime(j))))

if __name__ == '__main__':
    angle = int(input('0 ~ 180도 사이의 각도를 입력: '))
    clock(angle)

모든 각도를 -180~180으로 보정해서 계산하고 두 각도 차이를 계산하는 함수를 만들어서 입력한 각도와 두 침 사이의 각도의 차이를 매 초마다 추적하여 부호가 바뀌는 순간 0을 통과한 것으로 판단합니다.

"""
시침각도(s) = {(180/6)/3600}*s = (30/3600)*s = s/120
분침각도(s) = {(180/6)/300}*s = s/10
"""

def normalAngle(deg):   # 리턴값 범위를 -180<= y <180 으로
    while deg>=180.0:
        deg -= 360.0
    while deg<-180.0:
        deg += 360.0
    return deg

def diffAngle(sec):
    return normalAngle(11*sec/120)  # 분침-시침 기준으로 +/- 부호 부여

Deg = int(input('각도(deg)? '))
MDeg = -Deg
ang_prev = diffAngle(Deg-diffAngle(-1))
mang_prev = diffAngle(MDeg-diffAngle(-1))
for s in range(0, 24*3600):
    ang = normalAngle(Deg-diffAngle(s))
    mang = normalAngle(MDeg-diffAngle(s))
    if (abs(ang_prev)<1.0 and abs(ang)<1.0 and (ang_prev*ang<0.0 or ang==0.0)) or \
       (abs(mang_prev)<1.0 and abs(mang)<1.0 and (mang_prev*mang<0.0 or mang==0.0)) :
        print("{0:02d}:{1:02d}:{2:02d}".format(int(s/3600), int((s%3600)/60), (s%3600)%60))
    ang_prev = ang
    mang_prev = mang

아래는 0을 입력했을 때 출력

각도(deg)? 0 00:00:00 01:05:28 02:10:55 03:16:22 04:21:50 05:27:17 06:32:44 07:38:11 08:43:39 09:49:06 10:54:33 12:00:00 13:05:28 14:10:55 15:16:22 16:21:50 17:27:17 18:32:44 19:38:11 20:43:39 21:49:06 22:54:33

아래는 90을 입력했을 때 출력

각도(deg)? 90 00:16:22 00:49:06 01:21:50 01:54:33 02:27:17 03:00:00 03:32:44 04:05:28 04:38:11 05:10:55 05:43:39 06:16:22 06:49:06 07:21:50 07:54:33 08:27:17 09:00:00 09:32:44 10:05:28 10:38:11 11:10:55 11:43:39 12:16:22 12:49:06 13:21:50 13:54:33 14:27:17 15:00:00 15:32:44 16:05:28 16:38:11 17:10:55 17:43:39 18:16:22 18:49:06 19:21:50 19:54:33 20:27:17 21:00:00 21:32:44 22:05:28 22:38:11 23:10:55 23:43:39

import datetime

min_spd = 360/(60*60)
hr_spd = 360/(12*60*60)

dgr = float(input())
for i in range(1, 24*60*60+1):
    if abs((min_spd*i%360)-(hr_spd*i%360)) == dgr or abs((min_spd*i%360)-(hr_spd*i%360)) == 360 - dgr:
        o = str(datetime.timedelta(seconds = i))
        if len(o)<8:
            o = '0' + o
        print(o)

문제의 조건에서 '1초마다' 시침, 분침, 초침의 위치가 변한다고 하였으니 매초 정각마다 시계 바늘들의 위치를 측정하여야 한다고 판단했습니다. 매초 정각이 아닌 초와 초 사이에 특정한 각도를 이루는 경우는 제외됩니다.

A = int(input())
B = 360-A
secs = 86400

for i in range(secs):
    h = (i/secs*360*2)%360
    m = (i/secs*360*24)%360
    if abs(h-m) in [A, B]:
        hh = i // 3600
        mm = (i - hh*3600) // 60
        ss = i - hh*3600 - mm*60
        print(f'{hh:02}:{mm:02}:{ss:02}')

1을 입력하면 4개의 시각 04:22:00, 07:38:00, 16:22:00, 19:38:00 가 출력됩니다.

while True:
    angle = int(input("각도를 입력하시오"))
    if angle>=0 and angle<=180:
        break
# 초침 = 6도/초 , 분침 = 0.1도/초, 시침 = 분침/12도 / 초
m=0.1
h=0.1/60
time=[]
for s in range(1,86399):
    min=(0.1*s)%360
    hour=(0.1/12*s)%360
    if abs(hour-min)%180==angle:
        time.append(s)
print(time)
for k in time:
    print('{0}:{1}:{2}'.format(k//3600,k%3600//60,k%3600%60))

// Rust

// 현재 시각이 h:m:s일 때, 시침의 각도는 30h+m/2+s/120, 분침의 각도는 6m+s/10이므로,

// 각도 차이가 정수가 되기 위해서는 s=0이고, m = 2(30h+a)/11 또는 2(30h-a)/11 이어야 합니다

fn clock_angle() {

let mut a = 0;

if a > 90 { a = 180 - a;}
let mut result = vec![];
for h in 0..12 {
    let z1 = 2 * (30 * h + a);
    let z2 = 2 * (30 * h - a);
    if z1 % 11 == 0 {
        result.push((h, z1 / 11));
    }
    if a != 0 && z2 % 11 == 0 {
        result.push((h, z2 / 11));
    }
}
for i in 0..result.len() {
    if result[i].1 == 60 {
        result[i].0 += 1;
        result[i].1 = 0;
    }
    if a !=0 {
        result.push((result[i].0+12, result[i].1));
    }
}
println!("{:?}", result);

}

A = 30

import time

for h in range(24):
    for m in range(60):
        for s in range(60):
            hd = (h%12)*360/12 + m*360/12/60 + s*360/12/60/60
            md = m*360/60 + s*360/60/60

            if abs(hd-md) == A or abs(hd-md) == 360-A:
                t1 = str(h) + ':'+str(m) + ':'+ str(s)
                t2= time.strptime(t1, '%H:%M:%S')
                print(time.strftime('%H:%M:%S', t2))             

h = 0;m = 0;s = 0
target_angel = int(input("Enter Angel:"))
time_list = []
in_day = ['AM','PM']
for day in in_day:
   for h in range(12):
      for m in range(60):
         for s in range(60):
            minute = m * 6 + s * 0.1
            hour = minute * 0.5 + h * 30
            if int(minute) > int(hour) and int(minute-hour) < 180 and int(minute-hour) == target_angel:
               time = (str(h),"h",str(m),"m",str(s),"s",day)
               time_list.append(time)
            elif int(hour) > int(minute) and int(hour-minute) >= 180 and int(hour-minute) == target_angel:
               time = (str(h),"h",str(m),"m",str(s),"s",day)
               time_list.append(time)
            else: continue
for j in time_list:
   print(" ".join(j))

def printTime(h, m, s):
    print(" {0:02}:{1:02}:{2:02}".format(h,m,s))


def calHMAngle(h,m):
    cH = h * 30 + m / 2
    cM = m * 6
    angle = abs(cH - cM)
    if angle <= 180:
        return angle
    else:
        return 360 - angle


A = float(input('각도를 입력 하세요(0 ~ 180): '))

for h in range(12):
    for m in range(60):
        if A == calHMAngle(h,m):
            printTime(h,m,0)
            printTime(h+12, m, 0)