[Question]
  [
Every digital clock contains a small creature that has to advance the time every minute [citation needed]. Due to the popularty of digital clocks and the popularity of catching them in the wild, they are nearly extinct in nature which is why in this challenge we try to automate this task:
Given your string of a given time in the 24h format, the task is to advance this time by one minute.
## Details
* Both the input and output must be strings.
* The time is given as a five character string.
* Both the hour and the minutes are given as a two digit number: if the number is below 10, there will be a leading zero.
* The two numbers are separated by a colon.
## Examples
```
Input    Output
00:00    00:01
00:02    00:03
05:55    05:56
09:59    10:00
12:49    12:50
20:05    20:06
23:59    00:00
```
  
[Answer]
# Microsoft Excel, 9 bytes
```
=A1+"0:1"
```
Input is in cell `A1`.  
Tested on my Mac (Excel for Mac version 16.53) and online at Office.com.
[![enter image description here](https://i.stack.imgur.com/0xtdx.png)](https://i.stack.imgur.com/0xtdx.png)
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + [coreutils date](https://www.gnu.org/software/coreutils/manual/html_node/date-invocation.html), 17
```
date -d$1+min +%R
```
[Try it online!](https://tio.run/##NYlLCoAwDAX3OUUWupJCrGbRegtvUE1AwQ/YgsevVvAtZmDeFOKS72XdFC8NgkljmkPUAfCdnJ@iJjQGq//MEpKikapt9vXAph6znIdmIk8EhRaIPTOQ8@ygtb53YN/OYLtSHg "Bash ‚Äì Try It Online")
This assumes everything is in UTC (such as how TIO appears to be set up). If this is not OK, then 4 bytes must be added:
---
# [Bash](https://www.gnu.org/software/bash/) + [coreutils date](https://www.gnu.org/software/coreutils/manual/html_node/date-invocation.html), 21
```
date -ud$1UTC+min +%R
```
[Try it online!](https://tio.run/##S0oszvhfnpGZk6pQlJqYolCSWlySnFicas2lAAQp@WCqOLVEQVdXQQUm@T8lsSRVQbc0RcUwNMRZOzczT0FbNeh/Sn5e6n8DAysDAy4QacRlYGplasplYGllasllaGRlYsllBBQ35TIyBokAAA "Bash ‚Äì Try It Online")
[Answer]
# x86-16 machine code, ~~61~~ ~~55~~ 54 bytes
```
00000000: be82 008b fe8b d6ad 86c4 9346 56ad 86c4  ...........FV...
00000010: 4037 0430 3d30 367c 1293 4037 0430 3d34  @7.0=06|[[email protected]](/cdn-cgi/l/email-protection)=4
00000020: 327c 03b8 3030 86c4 abb0 305f 86c4 abb8  2|..00....0_....
00000030: 2409 aacd 21c3                           $...!.
```
Listing:
```
BE 0082     MOV  SI, 82H            ; SI point to DOS command line tail 
8B FE       MOV  DI, SI             ; save pointer to beginning of string for later 
8B D6       MOV  DX, SI             ; save pointer to beginning of string for output 
AD          LODSW                   ; load hours digits into AX 
86 C4       XCHG AL, AH             ; endian convert 
93          XCHG AX, BX             ; save hours in BX 
46          INC  SI                 ; skip colon 
56          PUSH SI                 ; save string offset to minutes 
AD          LODSW                   ; load minutes digits into AX  
86 C4       XCHG AL, AH             ; endian convert 
40          INC  AX                 ; add one minute 
37          AAA                     ; BCD Adjust After Addition! 
04 30       ADD  AL, '0'            ; ASCII fix low digit 
3D 3630     CMP  AX, '60'           ; is minutes wrap around? 
7C 13       JL   NO_CARRY_HOUR      ; if not, skip hours 
93          XCHG AX, BX             ; move hours into AX 
40          INC  AX                 ; increment hours 
37          AAA                     ; BCD Adjust After Addition! 
04 30       ADD  AL, '0'            ; ASCII fix low digit 
3D 3234     CMP  AX, '24'           ; rolled over to 24 hours? 
7C 03       JL   NO_CARRY_DAY       ; if not, skip to convert 
B8 3030     MOV  AX, '00'           ; reset hours to '00' 
        NO_CARRY_DAY: 
86 C4       XCHG AL, AH             ; endian convert 
AB          STOSW                   ; write hours string 
B0 30       MOV  AL, '0'            ; reset minutes to '00' 
        NO_CARRY_HOUR: 
5F          POP  DI                 ; minutes string offset to DI 
86 C4       XCHG AL, AH             ; endian convert 
AB          STOSW                   ; write minutes to output string 
B8 0924     MOV  AX, 0924H          ; AL = '$', AH = write string function 
AA          STOSB                   ; write DOS string terminator to end of string 
CD 21       INT  21H                ; write output to console 
C3          RET                     ; return to DOS
```
Thought it would be a more straightforward use of BCD operations, though it gave me a use for the `AAA` instruction so there's that.
Standalone DOS executable. Input via command line, output to console.
[![enter image description here](https://i.stack.imgur.com/Rh9TI.png)](https://i.stack.imgur.com/Rh9TI.png)
### OR...
**21 bytes** if I could take I/O as a packed BCD hex word (`12:59` == `0x1259`), and get to use `AAA`'s bastard step-sibling `DAA`!
```
40          INC  AX             ; increment the time 
27          DAA                 ; decimal adjust packed BCD 
3C 60       CMP  AL, 60H        ; did minutes reach 60? 
7C 0E       JL   DONE           ; if not, do nothing else 
32 C0       XOR  AL, AL         ; otherwise, reset minutes to 0 
86 E0       XCHG AH, AL         ; swap hours and minutes in AL 
40          INC  AX             ; increment the hours 
27          DAA                 ; decimal adjust packed BCD 
3C 24       CMP  AL, 24H        ; did hours reach 24? 
86 E0       XCHG AH, AL         ; real quick, swap hours and minutes back 
7C 02       JL   DONE           ; if less than 24, do nothing else 
32 E4       XOR  AH, AH         ; otherwise, reset hour to 0 
        DONE: 
C3          RET
```
[Answer]
# [PHP](https://php.net/), 35 bytes
```
<?=date("H:i",strtotime($argn)+60);
```
[Try it online!](https://tio.run/##K8go@P/fxt42JbEkVUPJwypTSae4pKgkvyQzN1VDJbEoPU9T28xA0/r/fwMDKwODf/kFJZn5ecX/dd0A)
[Answer]
# [Python 2](https://docs.python.org/2/), 68 bytes
```
def f(s):v=int(s[:2])*60-~int(s[3:]);print'%02d:%02d'%(v/60%24,v%60)
```
[Try it online!](https://tio.run/##JcxBCsIwEAXQvafoJiQjitNpE@iIJ5Hu2tKAxGBjxI1XjxndzOP/DxPfab0HKmWal2YxG3C@@JDMdmUaYe/w@PnHjkc4x0cNWiFNLEcrk08OFfWHrBxCea3@Njct108@xGcyAEUjMqLe/STRsrXiwHaotsS9SHWXnjrpvw "Python 2 ‚Äì Try It Online")
# [Python 3.8](https://docs.python.org/3.8/), ~~65~~ 64 bytes
*-1 byte thanks to @Matthew Willcockson*
```
lambda s:f"{(v:=int(s[:2])*60-~int(s[3:]))//60%24:02}:{v%60:02}"
```
[Try it online!](https://tio.run/##JYpRC4IwFEbf9ytEELYgvN65kRf8JeWDUUNB19BlhNRfXxu9fJzvcNzbDw8rT24Jpr2EqZ@vtz5byeQ736gdrefrmbATBw3H7/9K6oQoSw0F1gT4oX0rNCTKw2sYp3tWUeaWFBs@Wvf0XAgRICbA0iIDRUoxaEg1rEKqG4bRK4Yymh8 "Python 3.8 (pre-release) ‚Äì Try It Online")
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 216 bytes
```
,++++++++>,>>,>+>,++++>,+<<<[-<<-<-<+>>>>>>->-<<<]>>>[<<-]<<[>>----------<+[<-]<[->------<<<+<+[++++++[>-]>[<<[>>-]>>[<----<-->>->>]<]<<------>]>[<----------<+>>->]]<]<<<[->+>+>>+>>+>+<<<<<<<]>--------.>.>>.>>----.>.
```
[Try it online!](https://tio.run/##PU5BCgJBDHtQt3tQPLiUfKT0oIIgCx4E3z8mM7O2hbZpEnr/3F7v5/ext7bYDCxgsY3FIiI9wpmGHg7uUZySePFO7B9hKTB9YqQasWGe8JJKipK@M9xligp6DRFq3g5PEaoT5GzMUXov@jcHd8UK1ZxbO523y/UH "brainfuck ‚Äì Try It Online")
The character `:` is the ASCII character after `9`, so the program uses the one provided to it in the input to check if digits need to be carried, allowing it to avoid creating any large constants.
```
[
Read in the string and set up for the comparisons later. Increment minutes.
Subtract ':' from all characters and copy it elsewhere.
Layout:        Cell #  -1  0 1 2 3 4 5 6
        Cell contents  ':' A B _ _ 1 C D
The central 0 and 1 cells allow all of the conditionals to land near each other,
reducing the amount of travel needed in the worst case.
]
,++++++++>,>>,>+>,++++>,+
<<<[-<<-<-<+>>>>>>->-<<<]
# If minutes are 10: Carry
>>>[<<-]<<[
    >>----------<+
    # If tenminutes are 6: Carry
    [<-]<[
        ->------<<<+<+
        # If hours are not 10: Check for 24:00 rollover
        [
            ++++++
            [>-]>[
                <<[>>-]>>[
                    <----<--
                >>->>]
            <]
            <<------
        # If hours are 10: Carry
        >]>[
            <----------<+
        >>->]
    ]
<]
# Undo modifications from the start and print
<<<[->+>+>>+>>+>+<<<<<<<]
>--------.>.>>.>>----.>.
```
[Answer]
# [Java (JDK)](http://jdk.java.net/), ~~83~~ 49 bytes
```
i->java.time.LocalTime.parse(i).plusMinutes(1)+""
```
[Try it online!](https://tio.run/##nZA/T8MwEMX3fopTpkSobgpioBXslehUNsRwda7hgmNH8TkSQvnswSnpH0a4xfLzPb3fc4UdzqviY9AGvYctsoWv2QziLBag39GWhHtDwFaoPaCm41vTcodypcIm2mCanbRsS8CiQ6vphWuCdNIkXrL1cbP/iWnC3rAGLyjx6BwXUI8Uk@P1DbAtfXaimsg8SWjOwga8M0HYWXg8i5ft0pkDFaBdQQPPn6rYWY0g6tlpNCOfarD1lHKmGhP8lm0Q8ukyu0mSYX0J3n16oVq5ICr@gBVj01OwumqbJst8ledJNjX9k/X2bnX/8D9r/iu1n/XDNw "Java (JDK) ‚Äì Try It Online")
Huge cut-off thanks to Olivier Gr√©goire
[Answer]
# [MATL](https://github.com/lmendo/MATL), 12 bytes
```
YOl13L/+15XO
```
Beaten by Excel... :-D
[Try it online!](https://tio.run/##y00syfn/P9I/x9DYR1/b0DTC//9/dQNTK1NTdQA) Or [verify all test cases](https://tio.run/##y00syfmf8D/SP8fQ2Edf29A0wv@/S8h/dQMDKwMDdS4wbQSiTa1MTUG0pZWpJZA2NLIyAdFGQHmQuJExSBwA).
### Explanation
```
YO     % Implicit input. Convert to date number. The integer part represents date,
       % the fractional part represents time of day
l      % Push 1
13L    % Push 1440 (predefined literal)
/      % Divide. Gives 1/1440, which is 1 minute expressed as fraction of a day
+      % Add
15XO   % Convert to date string with format 15, which is 'HH:MM'
       % Implicit display
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~¬†20¬†~~ 19 [bytes](https://github.com/DennisMitchell/jelly)
```
√òD·πó2·∏£‚Äú√∞<‚Äò≈ípj‚Ç¨‚Äù:√∞·πôi·∏¢
```
A monadic Link that accepts a list of characters and yields a list of characters.
**[Try it online!](https://tio.run/##ATYAyf9qZWxsef//w5hE4bmXMuG4o@KAnMOwPOKAmMWScGrigqzigJ06w7DhuZlp4bii////MjM6NTk "Jelly ‚Äì Try It Online")**
### How?
Surprisingly tricky to get anything below 22 in Jelly, no time-based functionality while parsing, evaluating and then adding leading zeros where needed is expensive, so I went with constructing all strings as a list and getting the next string cyclically.
```
√òD·πó2·∏£‚Äú√∞<‚Äò≈ípj‚Ç¨‚Äù:√∞·πôi·∏¢ - Link: characters, S
√òD                  - digit characters -> "0123456789"
  ·πó2                - Cartesian power 2 -> ["00",...,"99"]
     ‚Äú√∞<‚Äò           - list of code-page indices -> [24, 60]
    ·∏£               - head to -> [["00",..."23"],["00",...,"59"]]
         ≈íp         - Cartesan product -> [["00","00"],...,["23","59"]]
           j‚Ç¨‚Äù:     - join each with colons -> ["00:00",...,"23:59"]
               √∞    - start a new dyadic chain, f(Times, S)
                 i  - first 1-indexed index of S in Times
                ·πô   - rotate Times left by that
                  ·∏¢ - head
```
[Answer]
**Powershell**, **82** or **153** bytes
`get-date ((get-date ($Time=read-host "Enter the time")).addminutes(1)) -uformat %R`
Or, if you want to show the input as well as the output;
```
do {$Time=read-host "Enter the time"
    write-host -nonewline $time `t 
    get-date ((get-date $Time).addminutes(1)) -uformat %R
    } while ($Time)
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 32 bytes
```
T`_d`d0`.9?(:59)?$
T`d`0`(24)?:6
```
[Try it online!](https://tio.run/##FcohDoAwDEZh33NAshnyU1aS1UxygXlKMgQGQbh/GeaJL@853@s@fAybebW9WYNNuQSVHMtA1ZrBAqdYdHUHFKC/TBAVIeR@0syaMnF3IV66fA "Retina 0.8.2 ‚Äì Try It Online") Link includes test cases. Explanation:
```
T`_d`d0`.9?(:59)?$
```
Increment all the digits in `09:59`, `19:59`, `X:59`, `:X9` or just the last digit if nothing else matches. Incrementing `9` automatically rolls over to `0`.
```
T`d`0`(24)?:6
```
Zero out `24:60` and the seconds of `X:60` (X will already have been incremented above so it is correct).
[Answer]
# JavaScript (Chrome / Edge / Node), 50 bytes
Very hackish.
```
s=>(new Date(+new Date([1,s])+6e4)+s).slice(16,21)
```
[Try it online!](https://tio.run/##bc9BC8IgGMbxe59CdlJcm7opTFinvkV0EHOxEI0c9fFtRluR3Z7D7@XPe1F3FfRtvE5b508mDn0M/Q468wB7NRmI13WgZTgiLEyLcEBVsKM2kIqSURS1d8FbU1l/hgMsCJGEFAiBugZp080fwL5AkwEuOV/AvEUGOsm7N6Ap9wsok@0KmOQZYPPVkkg7S7Dmk3h9FJ8 "JavaScript (Node.js) ‚Äì Try It Online")
### Commented
```
s =>              // s = "HH:MM"
  ( new Date(     // generate a date:
      +new Date(  //   generate a timestamp corresponding to:
        [1, s]    //     "1,HH:MM" which is interpreted as
                  //     Mon Jan 01 2001 HH:MM:00
      )           //   end of Date()
      + 6e4       //   add 60000 milliseconds (1 minute)
    )             // end of Date()
    + s           // coerce to a string
  ).slice(16, 21) // extract the updated "HH:MM"
```
[Answer]
# [C#](https://docs.microsoft.com/en-us/dotnet/csharp/), ~~64~~ ~~62~~ 55 bytes
-7 bytes thanks to asherber
```
(x)=>$"{System.DateTime.Parse(x).AddMinutes(1):HH:mm}";
```
[dotnetfiddle!](https://dotnetfiddle.net/ZHEdxy)
## Old version (62 Bytes)
```
(x)=>System.DateTime.Parse(x).AddMinutes(1).ToString("HH:mm");
```
[Answer]
# [Ruby](https://www.ruby-lang.org/) `-pl`, 40 bytes
```
$_="#{Time.gm(1,1,~/:/,$`,$')+60}"[11,5]
```
[Try it online!](https://tio.run/##KypNqvz/XyXeVkm5OiQzN1UvPVfDUMdQp07fSl9HJUFHRV1T28ygVina0FDHNPb/fwMDKwMDLhBpxGVgamVqymVgaWVqyWVoZGViyWUEFDflMjIGivzLLyjJzM8r/q9bkAMA "Ruby ‚Äì Try It Online")
`~/:/` matches the colon in the input (yielding its index, `2`), setting the pre- and post-match regexes `$`` and `$'` to the hour and minute, respectively.
---
# [Ruby](https://www.ruby-lang.org/) `-plaF:`, 35 bytes
*Suggested by @dingledooper*
```
$_="#{Time.gm(1,1,1,*$F)+60}"[11,5]
```
[Try it online!](https://tio.run/##KypNqvz/XyXeVkm5OiQzN1UvPVfDUAcEtVTcNLXNDGqVog0NdUxj//83MLAyMOACkUZcBqZWpqZcBpZWppZchkZWJpZcRkBxUy4jY6DIv/yCksz8vOL/ugU5iW5WAA "Ruby ‚Äì Try It Online")
The array `$F` is formed by automatically splitting the input at the colon.
---
Both versions perform the following operations:
* convert input to a `Time` object,
* add 60 seconds,
* convert to a string of the form `0001-01-dd hh:mm:00 UTC`, where for the 40 byte version `dd` is either `02` or `03` (the latter only when the input is `23:59`); for the 35 byte version it is `01`,
* extract the 11th to 15th characters.
It's somewhat noteworthy that `Time#gm` internally coerces string arguments to integers.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~71~~ 69 bytes
Thanks to dingledooper for the -2.
The only sneaky things were to reuse the input parameter and cache the format string.
```
i,z;f(s){sscanf(s,z="%02d:%02d",&i,&s);printf(z,(i+s/60)%24,++s%60);}
```
[Try it online!](https://tio.run/##RZDBboMwDIbvPIWViTYp2ZbSgtRk9Amq3XbqeqChDEsMJtLuAOLZWcLSLYf8jv37i2X9@KH1NCHvVUkNG4zReWMj3mckFHEh3UX4AvnCMPXVYXMtac8pRuY5FSyMtzyKTGhDNU4P2Oj6VlzgxVyLGs9P1T4IbAd85tjQ7xYLBkMAoKu8g5U5nrKBCCGFIHzW2Gkik8TpTiY7q@tYbp3Gtu7y8WbOv74dDiO3rPmsuj/W2rM2npU6hv/DshLhWan3Cc9SluVGRRXYqGw7iplQYI54UoBR9Ds5gF8BCQ1keyB8djA11@ze/h93I1BTtbe6gPNFwjI0S/be2Lbu7hyDcfoB "C (gcc) ‚Äì Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 18 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
23√ù59√ù√¢T‚Ä∞J':√ΩDIk>√®
```
[Try it online](https://tio.run/##yy9OTMpM/f/fyPjwXFPLw3MPLwp51LDBS93q8F4Xz2y7wytAUlamlgA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9TVmmvpPCobZKCkv1/I@PDc00tD889vCjkUcMGL3Wrw3tdKrPtDq/4r/PfwMDKwIALRBpxGZhamZpyGVhamVpyGRpZmVhyGQHFTbmMjIEiAA).
**Explanation:**
```
23√ù                 # Push a list in the range [0,23]
   59√ù              # Push a list in the range [0,59]
      √¢             # Get the cartesian product of these two lists
       T‚Ä∞J          # Format each integer to a string with potentially leading 0:
       T‚Ä∞           #  Take the divmod-10: [n//10,n%10]
         J          #  And join these pairs of digits together
          ':√Ω      '# Join each inner pair together with ":" delimiter
             D      # Duplicate this list
              Ik    # Get the index of the input in this duplicated list
                >   # Increase it by 1
                 √®  # And use it to index into the list
                    # (after which the result is output implicitly)
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~100~~ 95 bytes
```
from datetime import*
f='%H:%M'
t=lambda s:(datetime.strptime(s,f)+timedelta(0,60)).strftime(f)
```
[Try it online!](https://tio.run/##RYpBCsMgEADvvsJL0G1C2VJaiJB7Ln2ERZcKMYrupa@3sVB6G2Ymv/mV9mtrVFKUzrLnEL0MMafCJ0GLGlYzPJTgZbPx6aysRv@2c@WSO@g6EYydnN/YapzuCNAzfTNByyXsrFkrRIMXBSD@Zja3@TDtAw "Python 3 ‚Äì Try It Online")
-5 thanks to @pandubear
Python is terrible at this...
[Answer]
# [PHP](https://php.net/), 40 bytes
```
fn($s)=>date('H:i',strtotime("$s+1min"))
```
[Try it online!](https://tio.run/##Zc9PD4IgGMfxu6/iGWMT1h8Bo03MurVeRJdWOjkILHj9kXoJ7frbh30fXO/i6eJ6l@EOGoidIdjT5vx6hJbkN6XzrQ/vYIMeWoKw3/BBG0RprLOsffYWcEcQY4oxRGEP6G5QDUUB08SXQvyLMhFSSbkS43RMRKVktRR8Cv8EF@qwFkLJRIjxwaoyTUlFlH@V@XtxvvdjXdDW@Li7fgE "PHP ‚Äì Try It Online")
PHP relative date formatting at its finest, trying to compress it to the max. Should take in account the DST following the locale
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 24 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
‚ïür‚ñ†g√¶‚îúM<√ûm√≤‚ôÄ+‚ñëm‚ïû':u_l=)¬ß
```
[Try it online.](https://tio.run/##y00syUjPz0n7///R1PlFj6YtSD@87NGUOb42h@flHt70aGaD9qNpE3MfTZ2nblUan2OreWj5//9KBgZWBgZKXGDaCESbWpmagmhLK1NLIG1oZGUCoo2A8iBxI2OQOAA)
**Explanation:**
```
‚ïür                       # Push a list in the range [0,60)
  ‚ñ†                      # Take the cartesian product with itself
   g                     # Filter this list of pairs by,
    √¶                    # using the following four characters as inner code-block:
     ‚îú  √û                #  Where the first value of the pair
      M<                 #  Is smaller than 24
         m               # Then map each remaining pair to,
          √≤              # using the following eight characters as inner code-block:
           ‚ôÄ+            #  Add 100 to both integers
             ‚ñë           #  Convert both to a string
              m‚ïû         #  Remove the first character (the "1") from both strings
                ':u     '#  Join this pair with ":" delimiter
                   _     # After the map, duplicate the list of all possible times
                    l=   # Get the index of the string-input in this duplicated list
                      )  # Increase it by 1
                       ¬ß # And use it to (0-based modulair) index into the list
                         # (after which the entire stack is output implicitly as result)
```
[Answer]
# SQL Server, 36 bytes
```
select left(dateadd(n,1,a),5) from t
```
[Try it online (using all of the input values given in the question).](http://sqlfiddle.com/#!18/236eac/2)
[Answer]
# [R](https://www.r-project.org/), ~~46~~ 43 bytes
*-3 bytes thanks to [Jonathan Carroll](https://codegolf.stackexchange.com/users/26763/jonathan-carroll)*
Or **[R](https://www.r-project.org/)>=4.1, 36 bytes** by replacing the word `function` with `\`.
```
function(t)format(strptime(t,h<-"%R")+60,h)
```
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP0@jRDMtvyg3sUSjuKSooCQzN1WjRCfDRldJNUhJU9vMQCdD83@ahpKBgZWBgZKmsgIQgNiGXFBBIyRBY7CgqZWpKUwQyDYDC1pamVpCBQ1BRoEEDY2sTOCCRlamYEEjoCxMO4gN1m5kjNAOdsl/AA "R ‚Äì Try It Online")
---
Without datetime functions:
### [R](https://www.r-project.org/), ~~89~~ 85 bytes
```
function(t,`[`=substr,m=el(t[4,5]:0+1)%%60)sprintf("%02d:%02d",el(t[1,2]:0+!m)%%24,m)
```
[Try it online!](https://tio.run/##TY7LCsMgEEX3/YrWIih1MU5iIAN@SSiEPgKBmpRovt@qJG1nMVyO5w4ucbBxWKd7GOdJBNV3vfXrzYdFOft8idDVylwJLlpy3oD072WcwiAYB3xQXkwVTSvM2sklD2vlZEwSAAEweT6myVkfNoh/sCrQkDE7TLkpsCXTblDnUxlqpPoLkUyBmF73es6ljtWvXn4SPw "R ‚Äì Try It Online")
[Answer]
# [PowerShell](https://github.com/PowerShell/PowerShell), 33 bytes
```
%{'{0:HH:mm}'-f((Date $_)+'0:1')}
```
Input comes from the pipeline.
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfmvbmBgZWCgrqMAZhiBGaZWpqZghqWVqSWIYWhkZQJmGAHVgKWMjEFSNf9Vq9WrDaw8PKxyc2vVddM0NFwSS1IVVOI1tdUNrAzVNWv//wcA "PowerShell ‚Äì Try It Online")
Try it in a PS console (Windows or Core):
```
 '00:00', '00:02', '05:55', '09:59', '12:49', '20:05', '23:59'|%{'{0:HH:mm}'-f((Date $_)+'0:1')}
```
## Explanation
**%** is an Alias for the Cmdlet "ForEach-Object", which accepts input from the pipeline and processes each incoming object inside the ScriptBlock {...}  
**'{0:HH:mm}'** is the output string; {0:HH:mm} is a placeholder for the first argument of the following **-f** format operator. It contains formatting information to print a DateTime object in 24 hour format.  
**-f** is the format operator, which will replace the placeholder with the actual time. Using -f is shorter than calling the .ToString('HH:mm') method.  
**((Date $\_)+'0:1')** does the heavy lifting: It first turns the current string coming in from the pipeline ($\_) into a DateTime object by passing it to the Cmdlet **Get-Date**. The 'Get-' is implicit in PS, so leaving it out saves 4 bytes (Disclaimer: **never** use that in a regular script; it slows things down, because PS will search the path for a matching command as well - each time it's called!).  
Now that there's a DateTime object on the left side, and PS sees an Add operation, it interpretes the '0:1' as timespan of 1 minute (try `[TimeSpan]'0:1'` in a PS console); this is shorter than using the DateTime's object AddMinutes() method.  
The result of the addition is then inserted into the string, output is implicit.
[Answer]
# [Scala](http://www.scala-lang.org/), 52 bytes
```
java.time.LocalTime.parse(_).plusMinutes(1).toString
```
[Try it online!](https://tio.run/##VY7LCoMwEADvfsXiyVyCiU2hAQveW3po7yXVUBQfwUQplH57qvVRcxuY3dnVqSiFbR6FTA0kWXap5TmvOyNBvoysMw2JUvD2AHpRQsXhatq8fkJ8XMkWohfY5JXEp2bI3UZSotUyuCOsyk5PRR0QhE0zrVmhtWxNUAV@GPIw9BHEMfyY@MhzLd3YyLWMM7bYgfeuPXB2mC2ZrmwsoXy3WsqZa@kwv5RHdss0@pfn/72P/QI "Scala ‚Äì Try It Online")
Straightforward approach: parse string as time information via built-in functionality, add one minute to it, output as string
[Answer]
# [Factor](https://factorcode.org/), 56 bytes
```
[ ":"without hhmm>duration 1 minutes time+ duration>hm ]
```
This doesn't run on TIO because the `calendar.parser` vocabulary postdates Factor build 1525 (the one TIO uses) by just a bit. Here's a screenshot of running it in build 1889, the official 0.98 stable release:
[![A screenshot of running the above code in the Factor Listener](https://i.stack.imgur.com/RfXRp.png)](https://i.stack.imgur.com/RfXRp.png)
## Explanation
It's a quotation that takes a string from the data stack as input and leaves a string on the data stack as output. Assuming `"23:59"` is on top of the data stack when this quotation is called...
| Snippet | Comment | Data stack (the bottom is the top) |
| --- | --- | --- |
| 
```
":"without
```
 | Remove the colon | 
```
"2359"
```
 |
| 
```
hhmm>duration
```
 | Parse a 4-digit string into a duration with hours and minutes | 
```
T{ duration f 0 0 0 23 59 0 }
```
 |
| 
```
1 minutes
```
 | Create a duration of one minute | 
```
T{ duration f 0 0 0 23 59 0 }T{ duration f 0 0 0 0 1 0 }
```
 |
| 
```
time+
```
 | Add two durations and/or timestamps | 
```
T{ duration f 0 0 0 23 60 0 }
```
 |
| 
```
duration>hm
```
 | Convert a duration or timestamp to a HH:MM string | 
```
"00:00"
```
 |
 
[Answer]
## Batch, 83 bytes
```
@set/ps=
@set/am=6%s::=*60+1%-99,h=m/60%%24+100,m=m%%60+100
@echo %h:~-2%:%m:~-2%
```
Takes input on STDIN. Explanation:
```
@set/ps=
```
Read in the time.
```
@set/am=6%s::=*60+1%-99,h=m/60%%24+100,m=m%%60+100
```
Batch parses leading `0`s as octal, so to allow hours and minutes to be `08` or `09`, `6` is prefixed to the hours and `1` to the minutes. Additionally, the `:` is changed to `*60+` and the resulting string evaluated. The `6` prefix does not change the overall result because `600` hours is exactly `25` days, while the `1` adds `100` minutes so `99` minutes are subtracted to obtain the desired total number of minutes. The total minutes are then divided back into hours and minutes, but with 100 added so that the last two digits can be extracted.
```
@echo %h:~-2%:%m:~-2%
```
Print the last two digits to get the real hours and minutes again.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 13 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
√ê6e4¬∞√êNi1¬π¬§¬Ø5
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=0DZlNLDQTmkxuaSvNQ&input=IjAwOjAwIg)
[Answer]
# [C (clang)](http://clang.llvm.org/), 63 bytes
```
f(*s){strptime(s,"%R",s);*s=84;mktime(s);strftime(s,8,"%R",s);}
```
[Try it online!](https://tio.run/##VZBNboMwEIX3nGJkCcUmRHJIiAgWPUS3lAUhcWKVP9kkUYW4eqlt3Kj15o3ePH8zdrWp6rK9zjPHgSKjGmQ/iOaCVYj8dxQqwgKVJXvWfC42YTrCXSR5haZZtAM0pWjxoxNnAqMHUN1KCYHKi2xElKaUotBqZDRO49joMY2PWrdRujca6b7xo5316RRqkD2BfIG2DrRzoIMBuAEaFFMHOrgcNSCmQWZJwTxd8U5ikVEGKhcFA7FeLzsD9FKnOEa@guwNUGgThNmefdHpzvOEFoujf6Pqv7D2/gW5cVz9B4jVrbvXZzhdUlj5akU@Wj3AXpa/lydvmr8rXpdXNW@ePw "C (clang) ‚Äì Try It Online")
Thanks to @AZTECCO for the "%R" format!!
[Answer]
# [Julia 1.0](http://julialang.org/), 66 bytes
```
using Dates;f="HH:MM";g(s)=Dates.format(DateTime(s,f)+Minute(1),f)
```
[Try it online!](https://tio.run/##HY6xDsIgFEVn/YoX0uERq6EoQ2nq5NClmz9AIjSYFk2BxL9HYDv3njvcd1yt6n4pRW/dAg8VtB/MSKZJzjMZFvR0rOXFfPZNBSzhaTeNvjX0NFsXg8aO5pDyAjxYB0gYk4yRFirwCkIKUaGXoi/QcXmrwPOmKn4tih4P3926sDokjYfzHRosP2g22r0g/QE "Julia 1.0 ‚Äì Try It Online")
Using libraries because why not and it's still shorter than Python.
[Answer]
# [Julia 1.0](http://julialang.org/), ~~43~~ 42 bytes
```
using Dates
~t="$(Time(t)+Minute(1))"[1:5]
```
[Try it online!](https://tio.run/##LYyxCgIxEAX7/YoQLBIE2US3uMCJha2dnVhcEWQlhsNswOp@PcbD5jEMw3vWxJP7tFYL54c6TxILLDLqjbnyKxqx2wvnKtE4a/XNBbq3nkhRoypzYjFaa0AMiOt6QApEgEOgAZwPhwF89wR@/zO9tgCnnZrfnCVl8z87qmUl274 "Julia 1.0 ‚Äì Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 101 bytes
I was hoping this would be shorter, but I am posting it despite the length because I think it's an interesting way to compute the answer.
This function modifies the input string so the output is the input. I'm not too familiar with the C golfing rules on this but since it's so long I'm neglecting that issue.
This function treats the input as individual characters, where each column has a 'max' value (the first 5 characters in `u`) and a 'reset' value (last 5 characters in `u`). First the last character of the input string is incremented, then from right to left each character is compared to the max. If any character is greater than its max, it is set to the 'reset' value of that column and the column to the left is incremented.
As described so far, this function will reset after 29:59. To make it reset after 23:59 I used `short *a` to check the first two characters at once to see if they equal `"24"` and if they do, set them to `"00"`.
Also note that I had to modify the test code in order to copy input strings into writable memory.
Improvements are welcome, I think I'm out of ideas on this one.
Thanks to att for -22 bytes, a bugfix, and some awesome golfing!
```
c;f(char*x){for(x[c=4]++;~c;)x[--c]+=x[c]>"29:59"[c]&&(x[c]=c-2?48:58);*x<49&&x[1]==52?*x=x[1]=48:0;}
```
[Try it online!](https://tio.run/##rZHNbsIwDMfvfQqrE9Cm7ZaGFkFD4AXQbjuxHoqBEal8qC1TJ@henSWhbJwmTVqkyI7t/PxPjMEb4uWJWOVmX1Qk48jXDm6ygtTuab0vnHqOIko9j38iz0Tt1vMgwNQTKp5ObDZK4pGt3G5XV6YCAzaNhkk8dDnJAqF22O8P2JQmIWUD3li/8f8Cd66C3fra4Hx2SK3uhamIVLqxyNPlv1rV42jU7Rq2iNn0p09CeXN5kDvMj8sVjMtqmcvF42ZiWXJXwTaTO@d9L5cunCwArQRIOU/FyaY0odT2jWXaxkkca2tk@HbIkkhbpvI6zvom/vwymzW@YplFim9W2LL6LWugGW0PxYppyxq0dbRlccXSUkHyViEBROOLbZbne3RiVx/190lBOZRzmXKQnnd9FMChUIC1YxtJnRLEBGzflJmLAGVV4OHDQfTvgmow2LqHY1XenW44Pd9jvoTFKoFep@y5rzvFLW6IxmouXw "C (gcc) ‚Äì Try It Online")
]