A new task for you!

You have to create a method, that corrects a given time string.
There was a problem in addition, so many of the time strings are broken.
Time-Format is european. So from "00:00:00" to "23:59:59".


Some examples:

"09:10:01" -> "09:10:01"
"11:70:10" -> "12:10:10"
"19:99:99" -> "20:40:39"
"24:01:01" -> "00:01:01"

If the input-string is null or empty return exactly this value! (empty string for C++)
If the time-string-format is invalid, return null. (empty string for C++)

Have fun coding it and please don't forget to vote and rank this kata! :-) 

I have created other katas. Have a look if you like coding and challenges.

Difficulty: introductory

Starter code:

def time_correct(t):
	

Solutions:
def time_correct(t):
    if not t: return t
    try:
        h, m, s = map(int, t.split(':'))
        if s >= 60: s -= 60; m += 1
        if m >= 60: m -= 60; h += 1
        return '%02d:%02d:%02d' % (h % 24, m, s)
    except: pass

import re


def time_correct(t):
    if not t:
        return t
    
    if not re.match("\d\d:\d\d:\d\d$", t):
        return None
        
    hours, minutes, seconds = [int(x) for x in t.split(':')]
    
    if seconds >= 60:
        minutes += 1
        seconds -= 60
    if minutes >= 60:
        hours += 1
        minutes -= 60
    if hours >= 24:
        hours = hours % 24
    
    return "{0:0>2}:{1:0>2}:{2:0>2}".format(hours, minutes, seconds)

def time_correct(t):
    try:
        if t=="":
            return ""
        if len(t)!=8:
            return None
        h,m,s=[int(x) for x in t.split(":")]
        if s>=60:
            s-=60
            m+=1
        if m>=60:
            m-=60
            h+=1
        if h>=24:
            h=h%24
        return '%02d:%02d:%02d'%(h,m,s)
    except:
        return None

from typing import Union
from re import compile

r = compile(r"(\d\d):(\d\d):(\d\d)")


def time_correct(t: Union[str, None]) -> Union[str, None]:
    if not t:
        return t

    f = r.fullmatch(t)
    if f:
        h, m, s = list(map(int, f.groups()))
        h, m = divmod(h * 3600 + m * 60 + s, 3600)
        m, s = divmod(m, 60)

        return f"{h % 24:02}:{m:02}:{s:02}"


def time_correct(t):
    try:
        h, m, s = (int(n) for n in t.split(":") if len(n) == 2)
    except (AttributeError, ValueError):
        return "" if t == "" else None
    s, m = s % 60, m + s // 60
    m, h = m % 60, (h + m // 60) % 24
    return f"{h:02d}:{m:02d}:{s:02d}"

def time_correct(t):
  if not t: return t
  try:
    h, m, s = [int(x) for x in t.split(':') if len(x) == 2]
    if s >= 60: s -= 60; m += 1
    if m >= 60: m -= 60; h += 1
    return f'{h%24:02}:{m:02}:{s:02}'
  except: pass

def time_correct(t):
    if not t :
        return t
    if len(t) != 8:
        return None
    for x in range(8):
        if (x+1) % 3 == 0:
            if t[x] != ':':
                return None
        else:
            if not t[x].isnumeric():
                return None
    hrs, mins, secs = (int(x) for x in t.split(':'))
    mins = mins + secs // 60
    hrs = (hrs + mins // 60) % 24
    mins, secs = mins % 60, secs % 60
    return str(hrs).zfill(2) + ':' + str(mins).zfill(2) + ':' + str(secs).zfill(2)
    
    


import re

def time_correct(t):
    if not t:
        return t
    if re.match(r'\d\d:\d\d:\d\d$', t):
        hours, minutes, seconds = list(map(int, t.split(':')))
        d_minutes, seconds = divmod(seconds, 60)
        d_hours, minutes = divmod(minutes + d_minutes, 60)
        hours = (hours + d_hours) % 24
        return '{:02d}:{:02d}:{:02d}'.format(hours, minutes, seconds)


import re

def time_correct(t):
    if not t:
        return t
    
    if not re.match('^\d\d:\d\d:\d\d$', t):
        return None
    
    h, m, s = map(int, t.split(':'))
    
    o, s = divmod(s, 60)
    o, m = divmod(m + o, 60)
    o, h = divmod(h + o, 24)
    
    return '%02d:%02d:%02d' % (h, m, s)

def time_correct(t):
    if t == "":
        return ""
    
    from re import findall, VERBOSE
    
    try:
        time = findall("""\A
                            (\d{2}):
                            (\d{2}):
                            (\d{2})
                            \Z""", t, VERBOSE)

        hr,mn,sc = [int(x) for x in time[0]]
        
        mn += sc // 60
        sc %= 60
        hr += mn // 60
        mn %= 60
        hr %= 24
        
        return "{:02d}:{:02d}:{:02d}".format(hr, mn, sc)
    except:
        return None

import re

def time_correct(t):
    if t == '':
        return ''
    if not t or not re.search("[0-9][0-9]:[0-9][0-9]:[0-9][0-9]", t):
        return None
    time = list(map(int, t.split(':')))
    for i in range(2, 0, -1):
        time[i-1] += 1 * time[i] // 60
        time[i] = ('0' + str(time[i] % 60))[-2:]
    time[0] = ('0' + str(time[0]%24))[-2:]
    return ':'.join(time)

import re

def time_correct(t):
    if not t : return t
    if not bool(re.match(r"\d{2}:\d{2}:\d{2}$",t)) : return None
    h,m,s=map(int,t.split(":"))
    sec=h*3600+m*60+s
    sec%=(3600*24)
    return "{:02}:{:02}:{:02}".format(sec//3600,(sec%3600)//60,sec%60)

import re

def time_correct(t):
    if not t: return t
    
    m = re.findall(r'^(\d{2}):(\d{2}):(\d{2})$', t)
    if m:
        h, m, s = map(int, m[0])
        if s >= 60:
            m += 1
            s %= 60 
        if m >= 60:
            h += 1
            m %= 60
        h %= 24
        return f"{h:02}:{m:02}:{s:02}"

def time_correct(t):
    if t == '':
        return ''
    try:
        h,m,s = map(int,t.split(':'))
        m += 1 if s>=60 else 0
        s %= 60
        h += 1 if m>=60 else 0
        m %= 60
        h %= 24
        return f'{h:02}:{m:02}:{s:02}'
    except:
        return None

def time_correct(t):
    if t is None:
        return
    if t == "":
        return ""
    if len(t) != 8:
        return
    try:
        h, m, s = [int(i) for i in t.split(':')]
    except:
        return
    if s >= 60:
        s = s - 60
        m = m + 1
    if m >= 60:
        m = m - 60
        h = h + 1
    h = h % 24
    return ':'.join([str(h).rjust(2,'0'), str(m).rjust(2,'0'), str(s).rjust(2,'0')])


def time_correct(t):
    if not t: return t 
    try:
        h, m, s = t.split(':')
        if (len(h) != 2) or (len(m) != 2) or (len(s) != 2) : return None
        h, m, s = list(map(int, t.split(':')))
        if s >= 60: s -= 60; m += 1
        if m >= 60: m -= 60; h += 1
        return '%02d:%02d:%02d' % (h%24, m, s)
    except:
        pass


def time_correct(t):
    if t is None or t == "":
        return t 
    x = [int(string) for string in t.split(":") if string.isnumeric()]
    if len(x) != 3 or t.count(":") != 2:
        return None
    x[1] += x[2]//60
    x[2] %= 60
    x[0] += x[1]//60
    x[1] %= 60
    x[0] %= 24
    return f"{x[0]:02}:{x[1]:02}:{x[2]:02}"
    


import re

def time_correct(t):
    if t == '':
        return ''
    
    if t is None or len(t.split(':')) != 3:
        return None
    
    try:
        p = re.compile('^\d{2}$')
        
        h, m, s = [int(n) for n in t.split(':') if p.search(n)]
        
    except:
        return None
    
    if s >= 60: 
        m += (s // 60)
        s = (s - ((s // 60 ) * 60))
    if m >= 60:
        h += (m // 60)
        m = (m - ((m // 60 ) * 60))
    
    if h == 24:
        h = 0
    elif h > 24:
        h = h % 24
        
    return f"{'0' + str(h) if h < 10 else h}:{'0' + str(m) if m < 10 else m}:{'0' + str(s) if s < 10 else s}"


def time_correct(t):
    if not t:
        return t
    
    t = t.split(':')
    if len(t) != 3 or not all(len(u) == 2 and u.isdecimal() for u in t):
        return None
        
    hr, min, sec = map(int, t)
    min, sec = min + sec // 60, sec % 60
    hr, min = (hr + min // 60) % 24, min % 60
    return f'{hr:02}:{min:02}:{sec:02}'

from re import match
def time_correct(t):
    if not t:return t
    if match("\d{2}:\d{2}:\d{2}",t):
        hour,minute,second=map(int,t.split(":"))
        m,second=divmod(second,60)
        minute+=m
        h,minute=divmod(minute,60)
        hour=(hour+h)%24
        return f"{hour:0>2d}:{minute:0>2d}:{second:0>2d}"

def time_correct(t=None):
    if t=='':
        return ''
    elif t==None or len(t)!=8 or t[2]!=':' or t[5]!=':':
        return None
    elif (t[0:2]+t[3:5]+t[6:]).isdigit():
        if int(t[6:])>=60:
            ts=str(int(t[6:])%60).zfill(2)
            tsp=int(t[6:])//60
        else:
            ts=t[6:].zfill(2)
            tsp=0
        if int(t[3:5])+tsp>=60:
            tm=str((int(t[3:5])+tsp)%60).zfill(2)
            tmp=(int(t[3:5])+tsp)//60
        else:
            tm=str(int(t[3:5])+tsp).zfill(2)
            tmp=0
        if int(t[0:2])+tmp>=24:
            th=str((int(t[0:2])+tmp)%24).zfill(2)
        else:
            th=str(int(t[:2])+tmp).zfill(2)
        return th+':'+tm+':'+ts
    else:
        return None


import re

def time_correct(t):
    #messy
    if not t: return t
    if not re.match(r'^[0-9]{2}:[0-9]{2}:[0-9]{2}$', str(t)): return None
    tl = list(map(int, t.split(':')))
    for i in range(2, 0, -1):
        while tl[i] >= 60:
            tl[i] -= 60
            tl[i-1] += 1
    while tl[0] >= 24:
            tl[0] -= 24
    return ':'.join(["{:02d}".format(te) for te in tl])


def time_correct(t):
    
    try:
        if t == None:
            return None
        
        if t == "":
            return ""
        
        if len(t) < 8:
            return None
        
        for char in t:
            if not (char.isdigit() or char == ':'):
                return None
            
        # get numerical values from string
        times = t.split(':')
        hours = int(times[0])
        minutes = int(times[1])
        seconds = int(times[2])
        
        # correct values
        minutes += seconds // 60        
        seconds = seconds % 60
        hours += minutes // 60       
        minutes = minutes % 60
        hours = hours % 24
        
        #process values into string format
        hours = str(hours) if len(str(hours))==2 else ('0' + str(hours))
        minutes = str(minutes) if len(str(minutes))==2 else ('0' + str(minutes))
        seconds = str(seconds) if len(str(seconds))==2 else ('0' + str(seconds))
        
        return f"{hours}:{minutes}:{seconds}"

    except:
        return None


from re import match
def time_correct(t):
    if not t:
        return t
    elif not match("\d\d\:\d\d\:\d\d", t):
        return None
    fragments = list(map(int, t.split(":")))
    if fragments[2] >= 60:
        fragments[1] += 1
        fragments[2] -= 60
    if fragments[1] >= 60:
        fragments[0] += 1
        fragments[1] -= 60
    fragments[0] %= 24
    return "{:02}:{:02}:{:02}".format(*fragments)

import re
def time_correct(t):
    if not t: return t
    if not re.fullmatch('^\d\d:\d\d:\d\d$',t):
        return None
    
    h,m,s = map(int,t.split(':'))
    return'{:02d}'.format((h+(m+s//60)//60)%24)+':'+'{:02d}'.format((m+s//60)%60)+':'+'{:02d}'.format(s%60)    

import re
def time_correct(t):
    if t == '':
        return ''
    if t and re.search(r'[0-9]{2}:[0-9]{2}:[0-9]{2}', t):
        sec = int(t[-2:])
        min = int(t[3:5])
        hr = int(t[:2])
        if sec > 59:
            sec -= 60
            min += 1
        if min > 59:
            min -= 60
            hr += 1
        if hr > 23:
            hr -= hr//24*24
        return '{:02d}:{:02d}:{:02d}'.format(hr, min, sec)
    return None

def time_correct(t):
    # check for emptiness
    if not t:
        return t
    # check only for the allowed symbols
    for i in t:
        if i not in "1234567890:":
            return None
    # check for length
    slot = t.split(":")
    for k,i in enumerate(slot):
        try:
            if len(slot[k])>2:
                return None
            slot[k]=int(slot[k])
        except ValueError:
            return None
    if len(slot)!=3:
        return None
    # point, you can't iterate, 24 - h, 60 - m,s 
    slot[1] += slot[2]//60 
    slot[0] += slot[1]//60 
    slot[2] = slot[2]%60
    slot[1] = slot[1]%60
    slot[0] = slot[0]%24 
    return ":".join([str(x).zfill(2) for x in slot])
    
    # https://stackoverflow.com/questions/733454/best-way-to-format-integer-as-string-with-leading-zeros


import re
def time_correct(t):
    if t == None: return None
    pattern = r"[0-9][0-9]:[0-9][0-9]:[0-9][0-9]"
    if re.search(pattern, t):
        t = t.split(':')[::-1]
        for i in range(0,2):
            if int(t[i]) > 59:
                t[i+1] = str(int(t[i+1]) + int(t[i]) // 60)
                t[i] = str(int(t[i]) % 60)
        t[2] = str(int(t[2]) % 24)
        return ':'.join(i.zfill(2) for i in t[::-1])
    else:
        if len(t) > 0: return None
        else:
            return t

from re import match
from time import strftime
from time import gmtime
def time_correct(t):
    if not t: return t
    if not match('\d{2}:\d{2}:\d{2}',t): return None
    hrs,mnt,sec = [int(x) for x in t.split(":")]
    total = (hrs * 3600 + mnt * 60 + sec)
    return strftime("%H:%M:%S", gmtime(total))


from re import match

def time_correct(t):
  if not t:
    return t
    
  if not match("^\d{2}\:\d{2}\:\d{2}$", t):
    return None
    
  arr = [int(s) for s in t.split(':')]
  
  for i in range(2, 0, -1):
    if arr[i] > 59:
      arr[i - 1] += arr[i] // 60
      arr[i] = arr[i] % 60
      
  arr[0] = arr[0] % 24
  return ':'.join(str(num).zfill(2) for num in arr)

import re
from datetime import time

def time_correct(t):
    print(t)
    if not t:
        return t
    if not re.match(r"\d\d:\d\d:\d\d", t):
        return None
    H,M,S = [int(item) for item in t.split(":")]
    
    m,s = (M + S//60),S%60
    h,m = (H + m//60)%24,m%60
    
    return str(time(h,m,s))

def time_correct(t):
    if t is None: return None
    if t is '': return ''
    try:
        h,m,s = map(int, t.split(':'))
        m += s // 60
        s = s % 60
        h += m // 60
        m = m % 60
        h =  h % 24
        return '{:02}:{:02}:{:02}'.format(h,m,s)
    except:
        return None

def time_correct(t):
    if t == "": return ""
    if not t: return None
    if len(t.split(":")) != 3: return None
    h, m, s = t.split(":")
    if not h.isdigit() or not m.isdigit() or not s.isdigit(): return None
    if len(h)!=2 or len(m)!=2 or len(s)!=2: return None
    sec = int(s)%60
    min = (int(m) + int(s)//60)%60
    hour = (int(h) + (int(m) + int(s)//60)//60)%24
    return "{:02}:{:02}:{:02}".format(hour, min, sec)

import re
def time_correct(t):
    if t is None or t=='':
        return t
    if not re.match('[0-9][0-9]:[0-9][0-9]:[0-9][0-9]$',t):
        return None
    h,m,s = map(int, t.split(':'))
    if s>59:
        s-=60
        m+=1
    if m>59:
        m-=60
        h+=1
    while h>23:
        h-=24
    return ':'.join(f'{x:02}' for x in [h,m,s])

from re import match

is_valid = lambda s: isinstance(s, str) and bool(match(r'^\d\d:\d\d:\d\d$', s))

def time_correct(sd):
    if sd == '': return sd
    if is_valid(sd):
        h, m, s = list(map(int, sd.split(':')))
        q, r = divmod(s, 60)
        m, s = m + q, r
        q, r = divmod(m, 60)
        h, m = (h + q) % 24, r
        return f'{h:02}:{m:02}:{s:02}'

def time_correct(t):
    if t=='':
        return ''
    elif t:
        l=t.split(':')
        if len(l)==3 and all(i.isdigit() for i in l):
            a,b=divmod(int(l[2]),60)
            l[2]=str(b).zfill(2)
            c,d=divmod(int(l[1])+a,60)
            l[1]=str(d).zfill(2)
            l[0]=str((int(l[0])+c)%24).zfill(2)
            return ':'.join(l)

import re

def time_correct(time_string):
    if time_string in ("", None): return time_string
    if not re.fullmatch(r"\d\d:\d\d:\d\d", time_string): return None
    h, m, s = map(int, time_string.split(":"))
    total_seconds = 3600 * h + 60 * m + s
    final_seconds = total_seconds % 60
    final_minutes = (total_seconds // 60) % 60
    final_hours = (total_seconds // 3600) % 24
    return f"{final_hours:02d}:{final_minutes:02d}:{final_seconds:02d}"

from re import compile

REGEX = compile(r"(\d{2}):(\d{2}):(\d{2})").search

def time_correct(t):
    if not t: return t
    try:
        H, M, S = map(int, REGEX(t).groups())
        q, S = divmod(S, 60)
        q, M = divmod(M+q, 60)
        H = (H+q)%24
        return f"{H:02}:{M:02}:{S:02}"
    except AttributeError:
        pass

def time_correct(t):
    try:
        k = t.split(":")

    except:
        return None
    if t=="":
        return ""
    if len(k)<3:
        return None
    p = []
    res = 0
    for a in k[::-1]:
        if len(str(a))!=2:
            return None
        if len(p)<2:
            try:
                p.append(format((int(a)+res)%60, '02d'))
            except:
                return None
            res = (int(a) + res - int(p[-1]))//60
        else:
            try:
                p.append((format((int(a)+res)%24, '02d')))
            except:
                return None
    return ":".join(p[::-1])

import re
def time_correct(t):
    if t == '':    
        return ""
    if not t:    return 
    if not re.match(r'\d{2}:\d{2}:\d{2}', t):
        return None
    s = int(t[6:])
    m = int(t[3:5])
    h = int(t[:2])
    if s >= 60:
        m += s // 60
        s = s % 60
    if m >= 60:
        h += m // 60
        m = m % 60
    if h >= 24:
        h  = h % 24
    return ':'.join(str(i).zfill(2) for i in [h, m, s])

def time_correct(t):
    if t == "": return ""
    if not t or len(t) != 8 or not (t[0:2] + t[3:5] + t[6:8]).isdigit() or not t[2] + t[5] == "::": return None
    return "%s:%s:%s" %(str((int(t[0:2]) + ((int(t[3:5]) + (int(t[6:8]) // 60)) // 60)) % 24).zfill(2), \
        str((int(t[3:5]) + (int(t[6:8]) // 60)) % 60).zfill(2), str(int(t[6:8]) % 60).zfill(2))

import re

def time_correct(t):
    if t is None or not t:
        return t
    if not re.match(r'^(\d\d:){2}\d\d$', t):
        return None
    seconds = sum(int(c, 10) * 60 ** (2-i) for i, c in enumerate(t.split(':')))
    return '{:02d}:{:02d}:{:02d}'.format(seconds // 3600 % 24, seconds // 60 % 60, seconds % 60)

def time_correct(t):
    print(t)
    if t is not None:
        if not t:
            return ""
        t=t.split(":")
        if sum(1 for x in t if x.isdigit() and len(x)==2) == 3:
            out=[]
            to_add=0
            for i,v in enumerate(t[::-1]):
                v=int(v)+to_add
                if i < 2:
                    to_add=v//60
                    out.append(("0"+str(v%60))[-2:])
                else:
                    out.append(("0"+str(v%24))[-2:])
            return ':'.join(out[::-1])

import re
def time_correct(t):
    if t and re.match(r"\d\d:\d\d:\d\d", t):
        h,m,s = t.split(":")
        seconds = int(s)
        minutes = int(m) + seconds // 60
        hours = int(h) + minutes // 60
        return "%02d:%02d:%02d" % (hours % 24, minutes % 60, seconds % 60)
    return None if t != '' else ''


def time_correct(t):
    import re
    if t==None:
        return None
    if t=="":
        return ""
    r = re.compile('\d\d:\d\d:\d\d')
    if r.match(t) == None:
        return None
    
    sec = int(t[6:])
    mnt = int(t[3:5])
    hr = int(t[0:2])
    
    if sec > 59:
        sec = sec % 60
        mnt += 1
    if mnt > 59:
        mnt = mnt % 60
        hr += 1
    hr = hr % 24
    
    return str(hr).zfill(2)+":"+str(mnt).zfill(2)+":"+str(sec).zfill(2)

def time_correct(t):
    try:
        if t == None: return t
        if t == "": return t
        if len(t) == 8:
            if t.count(":") > 0:
                t = t.split(":")
            if t[0] == "00":
                first = 0
            else:
                first = int(t[0])
            second = int(t[1])
            third = int(t[2])
            if third >= 60:
                third -= 60
                second += 1
            if second >= 60:
                second -= 60
                first += 1
            while first >= 24:
                first -= 24
            return "{}:{}:{}".format(str(first).zfill(2), str(second).zfill(2), str(third).zfill(2))
    except:
        return None

import re

def fmt(t):
    t = f"{t}"
    return t if len(t) == 2 else "0"+t

def time_correct(t):
    if t is None: return None
    if t == "": return ""
    if not re.fullmatch(r"\d{2}:\d{2}:\d{2}", t): return None
    s = sum(int(x)*(60**i) for i,x in enumerate(t.split(":")[::-1]))
    h,m,s = s//3600%24, s//60%60, s%60
    return f"{fmt(h)}:{fmt(m)}:{fmt(s)}"

def time_correct(t):
    if not t:
        return t
    try:
        h,m,s=map(int,t.split(':'))
        if s>=60:
            s-=60
            m+=1
        if m>=60:
            m-=60
            h+=1
        h%=24
        return '{:02d}:{:02d}:{:02d}'.format(h,m,s)
    except:
        return None

def time_correct(time):
    if not time:
        return time
    try:
        hours, minutes, seconds = time.split(':')
    except ValueError:
        return None
    for time in (hours, minutes, seconds):
        if len(time) != 2 or not time.isnumeric():
            return None
    try:
        seconds = int(hours) * 3600 + int(minutes) * 60 + int(seconds)
    except ValueError:
        return None
    hours = seconds // 3600
    seconds -= hours * 3600
    hours %= 24
    minutes = seconds // 60
    seconds -= minutes * 60
    final = []
    for time in (hours, minutes, seconds):
        final.append(str(time).zfill(2))
    return ':'.join(final)

import re

def time_correct(t):
    pattern = r"^[0-9][0-9]:[0-9][0-9]:[0-9][0-9]$"

    if t == "":
        return ""
    elif t == None:
        return None

    if re.match(pattern, t):
        time = t.split(":")

        hour = int(time[0])
        minute = int(time[1])
        second = int(time[2])

        if second >= 60:
            second = second % 60
            carry = 1
            minute = minute + carry
            carry = 0

        if minute >= 60:
            minute = minute % 60
            carry = 1
            hour = hour + carry

        if hour >= 24:
            hour = hour % 24

        hour = str(hour)
        minute = str(minute)
        second = str(second)
        if len(hour) == 1:
            hour = "0" + hour
        if len(minute) == 1:
            minute = "0" + minute
        if len(second) == 1:
            second = "0" + second

        return hour + ":" + minute + ":" + second
    else:
        return None

import re
import datetime as dt
def time_correct(text):
    if not text:
        return text
    try:
        h, m, s = map(int, re.match(r'^(\d{2}):(\d{2}):(\d{2})$', text).groups())
        mo, m = divmod(m - 1, 60)
        return ((dt.datetime.combine(dt.date(1,1,1),dt.time((h + mo)%24, m + 1, 1)) + dt.timedelta(seconds=s - 1))).strftime('%H:%M:%S')
    except AttributeError:
        return None    #your code here

def time_correct( t ):
    if t is None:
        return None
    if t == "":
        return ""
    if t.count( ":" ) != 2 or len( t ) != 8:
        return None
    tt = t.replace( ":", "" )
    if (not tt.isdigit()):
        return None
    h, m, s = int( tt[ 0:2 ] ), int( tt[ 2:4 ] ), int( tt[ 4: ] )
    if s >= 60:
        m += 1
        s %= 60
    if m >= 60:
        h += 1
        m %= 60
    h %= 24
    return "{:02d}:{:02d}:{:02d}".format( h, m, s )


import re

def time_correct(t):
    if not t:
        return t
    
    if not re.match("\d\d:\d\d:\d\d$", t):
        return None
    
    hours,minutes,seconds = t.split(':')
    hours,minutes,seconds = int(hours), int(minutes), int(seconds)
    
    while seconds > 59:
        minutes+=1
        seconds-=60

    
    while minutes > 59:
        hours+=1
        minutes-=60

    
    while hours >= 24:
        hours-=24
    
    return '{:02}:{:02}:{:02}'.format(hours,minutes,seconds)
    


import re

def valid_format(s):
    return bool(re.match('^\d\d:\d\d:\d\d$', s))

def time_correct(t):
    if not t:
        return t
    if not valid_format(t):
        return None
    h, m, s = map(int, t.split(':'))
    total = 3600 * h + 60 * m + s
    s = total % 60
    m = (total // 60) % 60
    h = (total - m * 60 - s) // 3600 % 24
  
    return "{:02d}:{:02d}:{:02d}".format(h, m, s)

import re

def time_correct(t):
    if not isinstance(t, str):
        return None
    if t == '':
        return t
    if not re.match(r'^\d{2}:\d{2}:\d{2}$', t):
        return None
        
    t_tot = sum(60**i * int(e) for i, e in enumerate(t.split(':')[::-1]))
    return f'{t_tot // 3600 % 24:02}:{t_tot // 60 % 60:02}:{t_tot % 60:02}'


from datetime import datetime

def time_correct(t):
    if t == '': return ''
    if not t: return None
    t = t.split(':')
    if len(t) < 3: return None
    
    try:
        t = list(map(int, t))
    except:
        return None

    seco = t[2] % 60
    minu = t[1] % 60 + t[2] // 60
    hour = t[0] % 24 + t[1] // 60

    hour = str(hour % 24 + minu // 60).zfill(2)
    minu = str(minu % 60 + seco // 60).zfill(2)
    seco = str(seco % 60).zfill(2)
    
    return ':'.join([hour, minu, seco])

def time_correct(t):
    if t == '':
       return t
    if not t or len(t.split(':')) != 3 :
        return None
    elif any( (not i.isdigit() for i in t.replace(':', ''))):
        return None
    elif any((len(i) != 2 for i in t.split(':'))): 
        return None
    else:
        h, m, s = list(map(int, t.split(':')))
        if m < 60 and s < 60 and h < 24:
            return t
        else:
            s_1 = s%60
            s_2 = s//60
            m_1 = (s_2 +m)%60
            m_2 = (s_2 + m)//60
            h_1 = h + m_2 if (h + m_2)<24 else (h + m_2)%24
            return '{:02d}:{:02d}:{:02d}'.format(h_1, m_1, s_1)


def time_correct(t):
    if t == "" : return ""
    if not t  or "+" in t: return None
    try:
        h,m,s = map(int,t.split(':'))
    except:
        return None
    m += s//60
    s = s % 60
    h += m //60
    m = m %60
    h = h%24
    return f'{h:02}:{m:02}:{s:02}'

def time_correct(t):
    if not t: return t
    if len(t)!=8 or t[2]!=':' or t[5]!=":" or any(not t[i].isdigit() for i in (0,1,3,4,6,7)): 
        return None
    h,m,s=[int(t[o:o+2]) for o in (0,3,6)]
    if s>59:
        m+=s//60
        s%=60
    if m>59:
        h+=m//60
        m%=60
    h%=24
    return '{:02}:{:02}:{:02}'.format(h,m,s)

import re
def time_correct(x):
    if x==None or x=="":
        return(x)
    x1=0
    x2=0
    for i in x:
        if 48<=ord(i)<=57:
            x1+=1
        elif ord(i)==58:
            x2+=1
    if not(x1==6 and x2==2):
        return(None)
    x=x.split(":")
    s1=int(x[0])
    s2=int(x[1])
    s3=int(x[2])
    s=(s1*3600+s2*60+s3)%86400
    s1=str(s//3600)
    s2=str((s%3600)//60)
    s3=str(s%60)
    if len(s1)==1:
        s1="0"+s1
    if len(s2)==1:
        s2="0"+s2
    if len(s3)==1:
        s3="0"+s3
    return(s1+":"+s2+":"+s3)

def time_correct(t):
    if t == '':
        return ''
    elif t == None:
        return None
    tmp = [0, 0, 0]
    for i in t:
        if '0' <= i <= '9':
            tmp[0] += 1
        elif i == ':':
            tmp[1] += 1
        else:
            tmp[2] += 1
    if not (tmp[0] == 6 and tmp[1] == 2):
        return None
    else:
        tt = list(map(int, t.split(':')))
        tt[1]+=tt[2]//60
        tt[0]+=tt[1]//60
        tt[2]%=60
        tt[1]%=60
        tt[0] -= tt[0]//24 * 24
        return "%02d:%02d:%02d"%(tt[0],tt[1],tt[2])

import time
import re
def time_correct(t):
    if t == "":
        return ""
    else:
        if t is None or not re.match(r"\d{2}:\d{2}:\d{2}", t):
            return None
        else:
            h, m, s = [int(i) for i in t.split(":")]
            return f"{time.strftime('%H:%M:%S', time.gmtime(3600*h + 60*m + s))}"

def time_correct(t):
    if t=='':return t
    try:
        t = t.split(':')
        assert(len(t) == 3)       
        assert(len(t[1])==2)
        assert(len(t[2])==2)
        t = list(map(int, t))
        if t[2] > 59: t[1], t[2] = t[1]+1, t[2]-60
        if t[1] > 59: t[0], t[1] = t[0]+1, t[1]-60
        t[0] %= 24
        t = ["%02d" % _ for _ in t]
        return ':'.join(t)
    except Exception as e: print(e)

import re
def time_correct(t):
    if(t in [None,""]):
        return t
    if(not(re.match(r"\d\d\:\d\d\:\d\d",t))):
        return None

    parts = list(map(int,t.split(':')))
    for i in range(2,0,-1):
        parts[i-1] += parts[i]//60
        parts[i] %= 60
    parts[0] %= 24
    return ":".join("{:02}".format(p) for p in parts)


import re
def time_correct(t):
    if not t: return t
    if not re.match(r"(\d{2}:){2}\d{2}", t): return None
    h, m, s = map(int, t.split(":"))
    t = h * 3600 + m * 60 + s
    h = t // 3600 % 24; t %= 3600
    m = t // 60; t %= 60
    return f"{h:0>2}:{m:0>2}:{t:0>2}"

import re
def time_correct(t):
    if t in ["", None]: return t
    if not re.match(r"(\d{2}:){2}\d{2}", t): return None
    h, m, s = map(int, t.split(":"))
    t = h * 3600 + m * 60 + s
    h = t // 3600 % 24; t %= 3600
    m = t // 60; t %= 60
    return f"{h:0>2}:{m:0>2}:{t:0>2}"

import re
def time_correct(t):
    if t and re.search(r'\d{2}:\d{2}:\d{2}', t): 
        h, m, s = [int(s) for s in t.split(':')]
        m, s = m+(s//60), s%60
        h, m = h+(m//60), m%60
        h = h%24
        return f'{h:02}:{m:02}:{s:02}'
    else:
        return '' if t=='' else None

def time_correct(t):
    if t == "":
        return t

    if not t or ":" not in t or len(t.split(":")) != 3 or any(c.isalpha() for c in t) or any(not c.isdigit() and c != ":" for c in t):
        return None

    h, m, s = (int(i) for i in t.split(":"))

    if s > 59:
        m += 1
        s -= 60

    if m > 59:
        h += 1
        m -= 60

    while h > 23:
        h -= 24

    return ":".join([str(h).rjust(2, "0"), str(m).rjust(2, "0"), str(s).rjust(2, "0")])


def time_correct(t):
    if t == "":
        return ""
    elif t == None:
        return None
    elif len(t) != 8 or len(t.split(':')) != 3 or not all(x.isdigit() for x in t.split(':')):
        return None
    
    t_list = [int(x) for x in t.split(':')]
    if t_list[2] > 59:
        t_list[1] += 1
        t_list[2] -= 60
    if t_list[1] > 59:
        t_list[0] += 1
        t_list[1] -= 60
    while t_list[0] >= 24:
        t_list[0] -= 24
    return '{:02d}:{:02d}:{:02d}'.format(t_list[0],t_list[1],t_list[2])

def time_correct(t):
    if t is None:
        return None
    if t == "":
        return""
    if len(t) < 8:
        return None
    count = 0
    for letter in t:
        if letter not in "0123456789:":
            return None
        if letter in "0123456789":
            count += 1
    if count > 6:
        return None
    x = int(t[-2:])
    y = int(t[3:5])
    z = int(t[:2])
    if x >= 60:
        x = x - 60
        y = y + 1
    if y >= 60:
        y = y - 60
        z = z + 1
    if z >= 24:
        z = z - ((z // 24) * 24)

    if z <= 9:
        z = "0" + str(z)
    if y <= 9:
        y = "0" + str(y)
    if x <= 9:
        x = "0" + str(x)

    return str(z) + ":" + str(y) + ":" + str(x)

def is_valid_int(s):
    if len(s) != 2:
        return False

    try:
        int(s)
        return True
    except ValueError:
        return False

def time_correct(t):

    if t == None: return None
    elif t == "": return ""
    
    t_lst = t.split(':')
    
    if len(t_lst) != 3: return None

    if not is_valid_int(t_lst[0]) or not is_valid_int(t_lst[1]) or not is_valid_int(t_lst[2]):
        return None



    t_lst = [int(val) for val in t_lst]

    seconds = t_lst[2]
    minutes = t_lst[1]
    hours   = t_lst[0]

    if seconds > 59:
        minutes += int(seconds / 60)
        seconds = seconds % 60
    
    if minutes > 59:
        hours += int(minutes / 60)
        minutes = minutes % 60

    if hours >= 24:
        hours = int(hours % 24)
    
    return '{:02d}:{:02d}:{:02d}'.format(hours,minutes,seconds)

import re
def time_correct(t):
    if t == '':
        return t
    if t == None:
        return None
    if re.match('\d\d:\d\d:\d\d$',t):  
        h,m,s = [int(i) for i in t.split(':')]
        if s > 59:
            m += 1
            s -= 60
        if m > 59:
            h += 1
            m -= 60
        while h > 23:
            h -= 24
        return '{:02d}:{:02d}:{:02d}'.format(h,m,s)


time_correct = lambda t: t if not t else '{:02d}:{:02d}:{:02d}'.format(*((lambda q: [(q//3600)%24, (q%3600)//60 ,q%60] ) (sum([a*b for a, b in zip([3600,60,1],map(int, t.split(':')))])))) if __import__('re').match("^\d\d:\d\d:\d\d$", t) else None

import re
def time_correct(t):
    if t == '':
      return ''
    if not t or not re.search("[0-9][0-9]:[0-9][0-9]:[0-9][0-9]", t):
      return None   
    t= t.split(':')
    hour, min, sec = [int(x) for x in t]
    if sec > 59:
        min += (sec / 60)
        sec %= 60
    if min > 59:
        hour += (min / 60)
        min %= 60
    if hour > 23:
        hour %= 24
    return "%02d:%02d:%02d" %(hour, min, sec)


def time_correct(t):
    if t is None or len(t) == 0:
        return t
    nums = t.split(":")
    if len(nums) != 3:
        return None
    for num in nums:
        if not num.isdigit():
            return None
    hour, min, sec = [int(x) for x in nums]
    if sec > 59:
        min += (sec / 60)
        sec %= 60
    if min > 59:
        hour += (min / 60)
        min %= 60
    if hour > 23:
        hour %= 24
    return "%02d:%02d:%02d" %(hour, min, sec)
    


from re import match

def pad(n):
    return "0" + str(n) if n < 10 else str(n)

def time_correct(t):
    if not t: return t
    if not match('\d{2}:\d{2}:\d{2}', t): return None
    h, m, s = map(int, t.split(":"))
    secs = (h * 3600 + m * 60 + s) % (24 * 3600)
    h, m, s = secs // 3600, (secs % 3600) // 60, secs % 60
    return ":".join(map(pad, [h, m, s]))

import re

def time_correct(t):
    if t == None or t == '':
        return t
    t_pattern = re.compile(r'\d\d:\d\d:\d\d')
    if t_pattern.search(t) == None:
        return None
    hours, minutes, seconds = [int(x) for x in t.split(':')]
    if seconds > 59:
        seconds = seconds - 60
        minutes = minutes + 1
    if minutes > 59:
        minutes = minutes - 60
        hours = hours + 1
    if hours == 24:
        hours = 0
    if hours > 24:
        hours = hours%24
    return '{:02}:{:02}:{:02}'.format(hours, minutes, seconds)


    
        


def time_correct(t):
    if t is None: return None
    if t == '': return ''
    if len(t) != 8: return None
    t = t.split(':')
    if len(t) != 3 or sum(1 for v in t if not v.isdigit()) != 0: return None
    t = [int(a) for a in t]
    s = (t[0] * 3600 + t[1] * 60 + t[2]) % (3600 * 24)
    return "%02d:%02d:%02d" % (s // 3600, s % 3600 // 60, s % 60)

from re import match

def time_correct(t):
    if not t:
        return t
    g = match('^(\d{2}):(\d{2}):(\d{2})$', t)
    if g:
        h, m, s = map(int, g.groups())
        m += s // 60
        s %= 60
        h = (h + (m // 60)) % 24
        m %= 60
        return '{:02}:{:02}:{:02}'.format(h, m, s)

def time_correct(t):

    if t == None:
        return None
    elif t == "":
        return ""
    elif len(t) != 8:
        return None
    
    time = t.split(':')
    
    if len(time) != 3:
        return None
    for i in time:
        if i.isdigit() == False:
            return None
    
    sec = [int(time[2]) // 60, int(time[2]) % 60]
    min = [(int(time[1]) + sec[0]) // 60 , (int(time[1]) + sec[0]) % 60]
    hour = [(int(time[0]) + min[0]) % 24]
    
    time = [hour[0], min[1], sec[1]]
    right_time = []
    for time_unit in time:
        if time_unit < 10:
            time_unit = '0' + str(time_unit)
            right_time.append(time_unit)
        else:
            time_unit = str(time_unit)
            right_time.append(time_unit)
    
    result = ':'.join(right_time)
    return result
    


def time_correct(t):
    if not t: return t
    if any([len(t) != 8, t[2] != ":", t[5] != ":", not all(x.isdigit() for x in t.split(":"))]):
        return None
    else:
        n = sum(int(x)*y for x, y in zip(t.split(":"),[3600, 60, 1]))
        return "{:02d}:{:02d}:{:02d}".format((n//3600)%24, n//60 - (n//3600)*60, n%60)



def time_correct(t):
    try:
        h = t.split(":")[0]
        m = t.split(":")[1]
        s = t.split(":")[2]
        
        if h[0]==0: h = h[1]
        if m[0]==0: m = m[1]
        if s[0]==0: s = s[1]
        
        h = int(h)
        m = int(m)
        s = int(s)
        
        while s > 59:
            m += 1
            s -= 60
        while m > 59:
            h += 1
            m -= 60
        while h > 23:
            h -= 24
        
        h = str(h)
        m = str(m)
        s = str(s)
        
        if len(h)==1: h = "0" + h
        if len(m)==1: m = "0" + m
        if len(s)==1: s = "0" + s
        
        return ":".join([h,m,s])
    except:
        return '' if t=='' else None

def time_correct(t):
  try:
    if not t: return t
    if not len(t) == 8: return None
    h, m, s = map(int, t.split(':'))
    s, m = s%60, m + (s - (s%60)) // 60
    m, h = m%60, h + (m - (m%60)) // 60
    h %= 24
    return f'{h:02}:{m:02}:{s:02}'
  except:
    return None

from re import match

def time_correct(t):
    if not t: return t
    if not bool(match(r'\d{2}:\d{2}:\d{2}', t)): return None
    
    h, m, s = map(int, t.split(':'))
    if s > 59: 
        m += s // 60
        s %= 60
    if m > 59: 
        h += m // 60
        m %= 60
    if h > 23:
        h %= 24
    return '{:02d}:{:02d}:{:02d}'.format(h, m, s)

def time_correct(t):
    if t == "":
        return ""
    try:
        if t is None:
            return None
        elif len(t) != 8:
            return None
        else:
            a, b, c = map(int, t.split(':'))
            if c >= 60:
                c -= 60
                b += 1
            if b >= 60:
                b -= 60
                a += 1
            if a >= 24:
                a = a % 24
            return '%02d:%02d:%02d' % (a,b,c)
    except:
        return None

def time_correct(t):
    if len(str(t))==0:
        return ""
    time = str(t).split(':')
    for i in time:
        if len(i)!=2:
          return None  
    if len(time) != 3:
        return None
    else:
        try:
            t = [int(i) for i in time]
        except Exception:
            return None
        while t[2]>59:
            t[1]+=1
            t[2]-=60
        while t[1]>59:
            t[0]+=1
            t[1]-=60
        t[0]=t[0]%24
        t = [str(i) for i in t]
        for i in range(3):
            if len(t[i])==1:
                t[i] = "0"+t[i]
        ans = ':'.join(t)
        return ans
            
            


import re
def time_correct(time):
    if time == None:
        return None
    elif time == '':
        return ''
    pattern = re.compile('[0-9][0-9]:[0-9][0-9]:[0-9][0-9]')
    if pattern.match(time):
        t = time.split(':')
        hours = int(t[0])
        minutes = int(t[1])
        seconds = int(t[2])
        while seconds >= 60:
            seconds -= 60
            minutes += 1
        while minutes >= 60:
            minutes -= 60
            hours += 1
        while hours >= 24:
            hours -= 24
        return str("{:02d}".format(hours)) + ':' + str("{:02d}".format(minutes)) + ':' + str("{:02d}".format(seconds))

import re

def time_correct(s):
    try:
        assert re.match(r"^\d\d:\d\d:\d\d$", s)
        a, b, c = [int(x) for x in s.split(":")]
    except:
        return "" if s == "" else None
    b += c // 60
    a += b // 60
    return ":".join("{:>02}".format(x % y) for x, y in zip([a, b, c], [24, 60, 60]))

def time_correct(t):
    if t == "":
        return ""
    try:
        t = t.split(":")
    except:
        return None
    if len(t) != 3 or not all([i.isdigit() for i in t]):
        return None
    try:
        h, m, s = int(t[0]), int(t[1]), int(t[2])
        
        m = m + s//60
        s = s%60
        h = h + m//60
        m = m%60
        h = h%24
        
        return str(h).zfill(2) + ":" + str(m).zfill(2) + ":" + str(s).zfill(2)
    except:
        return None

def time_correct(t):
    if not t: return t
    time = t.split(":")
    if len(time) != 3 or len(t) != 8: return None
    try:
        time[0] = int(time[0])
    except:
        return None
    try:
        time[1] = int(time[1])
    except:
        return None
    try:
        time[2] = int(time[2])
    except:
        return None
    return "{:02d}:{:02d}:{:02d}".format((time[0]+(time[1]+time[2]//60)//60)%24,(time[1]+time[2]//60)%60,time[2]%60)

def time_correct(t:str):
    returnlst = []
    add = 0 
    number = 0
    if t == '':
        return ''
    if t == None or len(t.split(':')) != 3:
        return None

    for ind,val in [(ind,val) for ind, val in enumerate(t.split(':')[::-1])]:
        try:
            if any(ops in val for ops in ['+','-','/','\\','*','=']): 
                return None
            if len(val) == 2:
                number = int(val)
            else:
                return None
        except ValueError:
            return None
        if ind == 2:
            number += add
            returnlst.append(str(number % 24).zfill(2))
        else:
            number += add
            add = int(number/60)
            returnlst.append(str(number % 60).zfill(2))
    return ':'.join(returnlst[::-1])  

def time_correct(t):
    if t == '':
        return ''
    if t is None:
        return None
    if not __import__('re').match(r'^\d\d:\d\d:\d\d',t):
        return None
    h,m,s = [int(x) for x in t.split(':')]
    while s >= 60:
        s -= 60
        m += 1
    while m >= 60:
        m -= 60
        h += 1
    while h >= 24:
        h -= 24
    return '{:02d}:{:02d}:{:02d}'.format(h,m,s)

def time_correct(t):
    if not t:
        return t
    try:
        h, m, s = map(int, t.split(':'))
    except ValueError:
        return None
    
    m, s = m + s//60, s % 60
    h, m = h + m//60, m % 60
    h = h % 24
    return '{:02d}:{:02d}:{:02d}'.format(h, m, s)

def time_correct(t):
    if t == '':
        return ''
    elif t == None or len(t) != 8 or len(t) == 8 and not (t[:2].isdigit() and t[2] == ':' and t[3:5].isdigit() and t[5] == ':' and t[6:].isdigit()):
        return None
    else:
        h, m, s = int(t[:2]), int(t[3:5]), int(t[6:])
        m = m + s // 60
        s = s % 60
        h = h + m // 60
        m = m % 60
        h = h % 24
        return str(h).zfill(2) + ':' + str(m).zfill(2) + ':' + str(s).zfill(2)


import re
def time_correct(t):
    if t is None or t=="":
        return t
    elif re.match(r'\d{2}:\d{2}:\d{2}',t) is not None:
        v=(int(t[0:2])*3600)+(int(t[3:5])*60)+int(t[6:])
        if v>86400:
            while v>86400:
                v-=86400
        return "{:02d}:{:02d}:{:02d}".format(int(v/3600),int((v%3600)/60),(v%36000)%60)
    else:
        return None


def time_correct(t):
    if not t:
        return t
    try:
        h,m,s = map(int,t.split(':'))
        m += s//60
        s %= 60
        h += m//60
        m %= 60
        h %= 24
        return f'{h:02}:{m:02}:{s:02}'
    except:
        return None

def time_correct(t):
    if not t: return t
    try:
        h, m, s = t.split(':')
        h, m, s = int(h), int(m), int(s)
    except ValueError:
        return None
    m += s//60
    s %= 60
    h += m // 60
    m %= 60
    h %= 24
    fill = lambda n: str(n).zfill(2)
    return '{}:{}:{}'.format(fill(h), fill(m), fill(s))

def time_correct(t):
    if not t:
        return t
    r = [int(i) for i in t.split(':') if i.isdigit() and len(i) == 2]
    if len(r) != 3 or t.count(':') != 2:
        return None
    return '{:02}:{:02}:{:02}'.format((r[0] + (r[1] + r[2]//60)//60) % 24 , (r[1] + r[2]//60)%60, r[2]%60)

import re

def time_correct(t):
    if not t: return t

    pattern = r'\d{2}:\d{2}:\d{2}'
    
    if not re.match(pattern, t): return None

    hours, minutes, seconds = map(int, t.split(':'))

    minutes, seconds = minutes + (seconds // 60), seconds % 60
    hours, minutes = (hours + (minutes // 60)) % 24, minutes % 60

    return '{:0>2}:{:0>2}:{:0>2}'.format(hours, minutes, seconds)