Convertidor de tiempo de 12 horas a 24 horas

27

Sorprendentemente, esta simple tarea ya no parece existir, así que ...

Su tarea es escribir un programa que tome como entrada un tiempo de 12 horas y lo convierta en "hora militar" o en formato de 24 horas.

La entrada tendrá la forma:

HH:MM am/pm

Aunque se permiten ligeras variaciones:

  • El espacio que separa am / pm del resto del tiempo es opcional.

  • La última parte puede ser "am" / "pm" o "a" / "p".

  • Cualquier capitalización está bien.

La salida será el tiempo ingresado, transformado en formato de 24 horas. Puede ser un número o una cadena.

Tanto para la entrada como para la salida:

  • Los 0 en primer lugar son opcionales. Los 0 en los últimos 3 lugares son obligatorios.

  • el delimitador que separa las horas y los minutos puede ser un ":", "" (un espacio) o nada.

Otras notas:

  • La medianoche se puede expresar como 0000 o 2400.

  • La medianoche se considerará "am", mientras que el mediodía se considerará "pm".

Su programa puede ser una función o un programa completo, y debería devolver el resultado o enviarlo a la salida estándar. El espacio en blanco al final está bien.

Ejemplos (no es necesario que admita todos los formatos):

12:00am -> 0000
1200 pm -> 1200
1234Am  -> 00:34
134a    -> 134
01:34PM -> 13 34
1234pm  -> 1234  

Este es el código de golf, por lo que gana el menor número de bytes. Dado que esto es tan trivial de resolver usando un incorporado, sería bueno ver algún código que resuelva esto manualmente (pero el uso de los incorporados está bien).

Solo para aclarar, no es necesario que admita todos los formatos posibles. Está bien admitir solo una entrada y un formato de salida único (de su elección). Sin embargo, me gustaría limitar el formato como se describe anteriormente (que ya es bastante gratuito). {1134,'pm'}, por ejemplo, sería inaceptable.

Carcigenicate
fuente
¿Qué formatos debemos admitir? ¿Solo uno?
redstarcoder
@redstarcoder Sí. Cualquier formato que cumpla con los requisitos anteriores está bien, pero como se señaló anteriormente en los casos de ejemplo, no es necesario que admita todos los formatos. Un único formato de entrada y un único formato de salida están bien.
Carcigenicate
¿nuestros formatos pueden requerir ceros a la izquierda? Por ejemplo, 01:54pm¿funcionaría, pero 1:54pmno lo haría?
FlipTack
Sí. Puede elegir el formato de entrada requerido.
Carcigenicate
¿Se nos permite incluir segundos en nuestra entrada y salida?
12Me21

Respuestas:

8

V , 21 17 bytes

¡Gracias @DJMcMayhem por 4 bytes!

í12:/0:
çp/12
$x

Pruébalo en línea! Esto toma el formato HH:MMxdonde xestá o ao p, y lo devuelve en el formatoHH:MM

Hexdump:

00000000: ed31 323a 2f30 3a0a e770 2f31 3201 2478  .12:/0:..p/12.$x
00000010: 0ae7 612f 2478                           ..a/$x

Explicación:

í12:/0:   | find and replace 12: with 0: (to avoid replacing HH:12)
ç         | on every line
 p/       | that contains a p
   12^A   | increment 12 times (the first number, hours)
$x        | delete the character at the end of the line
nmjcman101
fuente
La entrada siempre estará en la [1-12]derecha? En ese caso, creo que podría hacerlo en ó^12/0lugar decw^R=^R"%12
DJMcMayhem
1
Además, puede usar el "comando global" para aplicar un comando a las líneas que coinciden con una expresión regular, que es más corta que romper una macro. çp/12^Aque es equivalente a :g/p/norm 12<C-a>en vim
DJMcMayhem
Acepté esto porque era la respuesta con la puntuación más baja que dejaba en claro que no estaba usando una función integrada (aunque no prohibí usarla). Si alguien tiene un problema con esta elección, puedo cambiar mi respuesta para que sea justa. Sin embargo, creo que esta respuesta es la más merecida.
Carcigenicate
10

Octava, 21 17 bytes

Guardado 4 bytes gracias a Luis Mendo. Podría especificar el formato número 15 en lugar de 'HHMM'.

@(c)datestr(c,15)

Explicación:

Se trata de una función anónima teniendo una cadena ccomo entrada en el formato: '11:34 AM'. datestrreconoce el formato automáticamente como uno de los formatos de fecha estándar y lo emite en el formato número 15 especificado, que es HH:MM.

Dado que el formato de salida especificado no tiene AMu PMOctave lo convierte automáticamente a lo que usted denomina tiempo militar.

Pruébalo en línea.


Una versión que no datestrusa 35 bytes

@(c)[c(1:4)+[1,2,0,0]*(c(5)>97),'']

Explicación:

Toma una cadena de entrada cen el formato 1134am.

@(c)                              % Anonymous function
[c(1:4)                           % First 4 elements of the string
       +[1,2,0,0]                 % Add 1 and 2 to the first to the ASCII-value of the 
                                    first two characters
                 *)c(5)>97)       % if the fifth element is larger than 97 
                                    (the ASCII code for `a`).
                            ,'']  % Implicitly convert to string

O, un enfoque diferente para 37 bytes:

@(c)[c(1:4)+('1200'-48)*(c(5)>97),'']
Stewie Griffin
fuente
7

PowerShell , 23 20 19 bytes

date "$args"-f HHmm

Pruébalo en línea!

(Si está en Windows, puede omitir el get-, para bajar a 19 bytes. En TIO, aparentemente requiere el Get-Datenombre completo ).

Toma la entrada como una cadena $args[0], la usa como entrada al Get-Datecmdlet, que la analiza en un datetimeobjeto .NET . Eso se pasa con el -fparámetro ormat de HHmmconvertirlo a tiempo militar (la capital HHespecifica el tiempo de 24 horas). La salida es implícita.

El motor de análisis es bastante robusto, por lo que también se permiten entradas adicionales como 12amo 12:00amestán permitidas. Juegue con la entrada en TIO y vea qué más funciona.

( Guardado 3 bytes gracias a @admalledd ... guardó otro byte gracias a @briantist )

AdmBorkBork
fuente
Debe ser capaz de eliminar el espacio entre $args[0]y -f, además de quitar las comillas simples alrededor del formato str: date $args[0]-f HHmm. Al menos esto funciona en mi PowerShell ...
añadido el
@admalledd Por el amor de Dios, siempre olvido esas citas. En serio, creo que cada vez que he usado Get-Datecon -f, alguien me ha recordado que no necesita las comillas. Y también es bueno eliminar el espacio, ya que el analizador trata ]el final de un token. ¡Gracias!
AdmBorkBork
5

Python 2, 44 bytes

lambda s:`int(s[:2])%12+12*("p"in s)`+s[3:5]

Formato de entrada: 01:23amopcional my espacios después de minutos
Formato de salida:123

busukxuan
fuente
5

Pyth, 21 20 bytes

Aczd++*12}\pH%sG12PH

Toma la entrada del formulario 01 23acomo "01:23 am". Inicial 0 es opcional.
La salida es de la forma 123, con el 0 inicial omitido.

En pseudocódigo:

                         z = input()
A                        G, H =
 czd                         z.split(" ")       # splits into the form ["1","23p"]
                         (
     +*12}\pH            12*('p' in H) +        # add 12 if 'p' is in the string
             %sG12         int(G) % 12
    +             PH     ) + H[:-1]             # prepend hour to minutes, with a/p removed

Pruébalo en línea!

busukxuan
fuente
4

PHP, 35 32 bytes

formato de entrada: no distingue entre mayúsculas y minúsculas, requiere dos puntos y el mformato de salida hhmm. utiliza incorporados:

<?=date(Hi,strtotime($argv[1]));

toma la entrada del primer argumento de la línea de comando.

PHP, 45 bytes, sin integraciones

formato de entrada en (h)h:mm a(m)minúsculas, formato de salida (h)hmm.

<?=($s=$argv[1])%12+12*($s[6]>a).$s[3].$s[4];
Titus
fuente
44
¿Por qué el voto negativo?
Titus
Solo estoy especulando, pero ¿tal vez es porque usaste PHP y al downvoter no le gusta PHP? : p
bash0r
3

JavaScript (ES6), 40 bytes

a=>(new Date('1/1/1/'+a)+a).slice(16,21)

La entrada debe estar formateada como: 12:32 am

Mwr247
fuente
3

GNU Coreutils ( 18 16 bytes)

De un script de shell:

No acepta espacios en blanco en la entrada

En ese momento, también puede usar $ 1 e ignorar argumentos adicionales.

date -d$1 +%H%M

⇒ echo 'date -d$1 +%H%M' > time24
⇒ sh time24 1:45pm
1345
⇒ sh time24 1:45 pm
0145 # Wrong answer, “pm” ignored because of space

Original

Para permitir espacios en blanco en la entrada,

date -d"$@" +%H%M
BRPocock
fuente
3

C #, 46 bytes

s=>System.DateTime.Parse(s).ToString("HH:mm");

Las cadenas se toman en entrada como 12:00 AM

Hacer lo mismo pero subcadenas en la salida de la llamada predeterminada a ToString(Suponiendo una cultura de en-GB) es 3 bytes más para 49 bytes:

s=>(System.DateTime.Parse(s)+"").Substring(11,5);
TheLethalCoder
fuente
3

date, 0 + 8 = 8 bytes

Sobre el tema de usar la herramienta adecuada para el trabajo ...

Toma la entrada como un argumento de línea de comando. Ejecutar con +%H%M -d(8 bytes de penalización). No hay un programa real aquí; todo el trabajo lo realizan los argumentos de la línea de comandos. (¡Esta es una demostración bastante buena de por qué hay una penalización por los argumentos de la línea de comandos!)

Ejemplo:

$ date +%H%M -d "12:05 am"
0005

fuente
3

Java 7, 138 106 105 104 bytes

String a(String a){return new java.text.SimpleDateFormat("Hmm").format(new java.util.Date("Ja1,0,"+a));}

Pruébalo en línea!

La entrada está delimitada por dos puntos y tiene un espacio entre la hora y las am / pm. La salida no está delimitada por dos puntos.

-1 byte gracias a Kevin Cruijssen

Meter
fuente
Lo más breve posible para Java, el 20% del código son calificadores de paquete.
Magic Octopus Urn
Las reglas establecen que " tanto para la entrada como para la salida: - los 0 en primer lugar son opcionales. Los 0 en los últimos 3 lugares son obligatorios ", lo que significa que puede cambiar HHmma Hmm.
Kevin Cruijssen
@KevinCruijssen buena captura!
Poke
2

Japt , 14 bytes

Ð"1/"+U s sG21

Pruébalo en línea!

Esto solo funciona en Chrome. Aquí hay una versión que funciona en todos los navegadores:

Ð"1/"³+U s sG21

¡Gracias nuevamente a ETHproductions por la ayuda!

Oliver
fuente
2

Perl, 45 28 37 bytes

28 37 bytes

(c / o @Dada)

(Código de 36 bytes, 1 byte para el -pconmutador del compilador )

Acepta 0145pmformatos de tipo, con am / pm o a / p. Se requieren ceros iniciales en las entradas.

s/(..)(.)$//;$_=$_%12+12*(p eq$2).$1

Prueba:

⇒ echo 0145pm | perl -p time24
1345
⇒ echo 0245pm | perl -p time24
1445
⇒ echo 1245pm | perl -p time24
1245
⇒ echo 1245am | perl -p time24
045

Mi respuesta original

(también revisado suavemente)

(Código de 39 bytes, 1 byte para el -pconmutador del compilador ).

Acepta solo el formulario como 0145p o 0145a, y ningún otro, y requiere perl -pmodo para funcionar.

s/(..)(..)([ap])/$1%12+12*($3eq"p").$2/e

prueba:

⇒ echo 0145p | perl -p time24
1345
⇒ echo 1222a | perl -p time24
022
⇒ echo 1234p | perl -p time24
1234
BRPocock
fuente
Bienvenido a PPCG. Buena primera respuesta. Puede usar interruptores, pero cuentan en su bytecount (como se explica aquí ). En su caso, eso sería +1 byte (porque solo -pes necesario) si cambia las comillas simples por comillas dobles.
Dada
Gracias. ¿No pudo encontrar las preguntas frecuentes?
BRPocock
Bien, he estado en Perling desde la serie 4 y eso me duele la cabeza, deberías tomarte el crédito y publicarte con esa. ☺
BRPocock
Creo que eso debería cubrirlo ahora?
BRPocock
Cometí un error, esta solución no funcionará cuando los minutos estén entre 0 y 9. Este código funciona entonces: s/(..)(.)$//;$_=$_%12+12*(p eq$2).$1(37 bytes). Y, por cierto, su primera solución puede reducirse un poco: s/(..)(..)([ap])/$1%12+12*($3eq"p").$2/e(40 bytes)
Dada
2

Commodore 64 BASIC, 301 bytes antes de ejecutar, 321 bytes utilizados una vez ejecutados

0 A$="12:34AM":A=VAL(LEFT$(A$,2)+MID$(A$,4,2)):ON-(RIGHT$(A$,2)="AM")+1GOSUB1,2:TI$=A$:PRINTTI$:END
1 ON-(A=>1200ANDA<=1259)GOTO3:A=A+1200:GOTO3
2 ON-(A=>1200ANDA<=1259)GOTO4:ON-(A<=959)GOTO7:RETURN
3 A$=RIGHT$(STR$(A)+"00",6):RETURN
4 A=A-1200:IFA=0THENA$="000000":RETURN
5 IFA<10THENA$="000"+RIGHT$(STR$(A),1)+"00":RETURN
6 A$="00"+RIGHT$(STR$(A),2)+"00":RETURN
7 A$="0"+RIGHT$(STR$(A),3)+"00":RETURN

Para ingresar esto en un Commodore 64 real, necesitará usar abreviaturas de palabras clave BÁSICAS, como LE [shift] F para LEFT$, M [shift] I para MID$etc ... o puede probar CBM PRG STUDIO.

La TI$variable en Commodore BASIC presenta la hora en formato de reloj de 24 horas como HHMMSS cuando se imprime. Eliminar el espacio después del número de línea no ahorra memoria ya que Commodore BASIC agrega el espacio automáticamente de todos modos cuando enumera el programa después de ingresarlo.

Al convertir un número a una cadena con STR$, Commodore BASIC agregará el espacio (así que si PRINT Averá un espacio antes de que se muestre el número), eliminé el espacio de apertura en la conversión de número a cadena con el RIGHT$comando. Puede guardar algunos bytes modificando la línea cero a:

0 A=VAL(LEFT$(A$,2)+MID$(A$,4,2)):ON-(RIGHT$(A$,2)="AM")+1GOSUB1,2:TI$=A$:PRINTTI$:END

por lo tanto, deberá declarar su tiempo de conversión antes de ejecutar el programa, de la siguiente manera:

A$="01:22AM":GOTO 0

En cualquier momento posterior, puede ver la hora actual con:

? TI$
Shaun Bebbers
fuente
Jugar golf de código en máquinas de 8 bits es realmente interesante, ya que muestra cuánto se hace para un programador moderno sin siquiera tener que pensarlo.
Shaun Bebbers
2

Java, 171 bytes

enum t{;public static void main(String[] a){a=a[0].split("[: ]");System.out.format("%02d%02d",(Long.parseLong(a[0])+(a[2].charAt(0)=='p'?12:0))%24,Long.parseLong(a[1]));}}

El formato de entrada es HH:MM a/py el formato de salida es HHMM. Abusando del hecho de que la función principal tiene una serie de cadenas para dividir la entrada en 3 secciones: hora, minuto e indicador a / p.

Ejemplo de entrada y salida:

Input: 01:02 a
Output: 0102

Input: 01:02 p
Output: 13:02

Input: 12:22 p
Output: 0022

Versión sin golf:

enum t {
    ;

    public static void main(String[] a) {
        a = a[0].split("[: ]");
        System.out.format("%02d%02d", (Long.parseLong(a[0]) + (a[2].charAt(0) == 'p' ? 12 : 0)) % 24, Long.parseLong(a[1]));
    }
}
Galleta
fuente
No había visto enumsolía sostener el main. Nice :)
Robert Benson
Puede omitir un espacio en la firma del método principal: public static void main (String [] a) {...
staticmethod
2

REXX, 33 bytes

arg h':'m a
say h+((a=pm)*12)':'m

Utilizar:

12:34 pm -> 24:34
1:34 pm -> 13:34
1:34 am -> 1:34
0:34 AM -> 0:34

Esto podría acortarse unos pocos bytes si no se usaran dos puntos como delimitador.

idrougge
fuente
El delimitador de colon es opcional.
Carcigenicate
Sí, pero no se ve bien.
idrougge
Dado que este es un desafío de código de golf, si tiene la opción de un programa más largo con una salida bonita, o un programa más corto con una salida más fea, elija el último. Nadie te juzgará.
Carcigenicate
2

C (clang) , 94 bytes

h,m;f(){char a,b;scanf("%d:%d%c%c",&h,&m,&a,&b);printf("%02d%02d",a=='a'?(h%12):(12+h%12),m);}

Pruébalo en línea!

Estoy aquí para aprender, así que cualquier sugerencia sobre cómo puedo optimizar el código es bienvenida.

@ Johan du Toit ¡Gracias por guardar algunos bytes!

Abel Tom
fuente
No tiene que probar si b == 'm' y puede hacerlo mucho más corto usando declaraciones if en línea:printf("%02d:%02d", (a=='p' ? 12 : 0) + (h %12), m);
Johan du Toit
1
@JohanduToit ¿Qué ingreso es 6: 00pc? :)
Abel Tom
1
Eso causará un daño irreparable al continuo espacio-tiempo.
Johan du Toit
1
75 bytes
ceilingcat
2

C, 87 72 bytes

Ahorró 15 bytes gracias a @Johan du Toit

Llame f()con una cadena mutable como argumento, la entrada es la salida.

El formato es HH:MMa/p, donde a/pes minúscula ao minúscula p. No se permite ningún espacio entre el tiempo y el especificador de meridiano.

i;f(char*p){i=atoi(p)%12+(p[5]^97?12:0);*p=i/10+48;p[1]=i%10+48;p[5]=0;}

Pruébalo con ideone .

owacoder
fuente
puede guardar un par de bytes utilizando lo siguiente:i;f(char*p){i=atoi(p)%12+(p[5]^97?12:0);*p=i/10+48;p[1]=i%10+48;p[5]=0;}
Johan du Toit
Sugerir en (p[5]!=97)*12;lugar de(p[5]^97?12:0);
ceilingcat
2

tcl, 45 47

Ahora usando un incorporado:

puts [clock f [clock sc $s -f %I:%M%p] -f %R]

Se puede probar en http://rextester.com/TSRXI8802 donde hay un script que lo ejecuta de 0100 a.m. a 1259 p.m.

sergiol
fuente
2

SmileBASIC, 67 bytes

INPUT T$P=POP(T$)>"a
TMREAD"00:"+T$OUT,H,M?H MOD 12+12*P,T$[3];T$[4]

Entrada: HH:MMa/p

Salida: HH MM

12Me21
fuente
1

R, 68 bytes

x=substr(strptime(scan(,""),"%I:%M %p"),12,16);`if`(x=="","00:00",x)

Lee la entrada de stdin y se supone que está en uno de los siguientes formatos:

  • 12:00 AM
  • 12:00 am
  • 12:00AM
  • 12:00am

y la salida está en el formato: [1] "00:00"

En la mayoría de los casos, la strptime()salida está en el formato: "2017-01-06 12:00:00 CET"donde la fecha es la fecha local. Como tal, necesitamos usar substr()para devolver solo la hora, sin embargo, si la entrada es medianoche (por ejemplo 12:00am), la salida es solo "2017-01-06 CET"la razón de la ifcosa al final (debe haber una solución más inteligente).

Billywob
fuente
Realmente quería encontrar un camino más corto lubridate, pero el nombre del paquete es demasiado largo (entre otros problemas).
BLT
1

C, 159152 bytes

#define C c[0]
main(i,c)char**c;{scanf("%s",C);i=atoi(C);if(C[5]-97){i+=i-12?12:0;sprintf(C,"%d",i);}else if(i==12)C[0]=C[1]=48;C[2]=58;C[5]=0;puts(C);}

Formato de entrada: 07:30am

Steadybox
fuente
1

Mathematica, 33 bytes

#~DateString~{"Hour24","Minute"}&

Función anónima. Toma una cadena como entrada y devuelve una cadena como salida. Funciona con la mayoría de los formatos, incluidos hh:mm AM/PM.

LegionMammal978
fuente
1

JavaScript, 67 bytes

f=s=>!~s.indexOf`pm`?s.slice(0,5):((+s.slice(0,2)+12)+s.slice(2,5))

La entrada es como en el ejemplo

lhama butt
fuente
No funciona para 12:00 amo12:00 pm
Herman L
1

Haskell, 61 caracteres

Version corta:

c[a,b,c,d,e]=(mod(read[a,b]::Int)12+f e,[c,d])
f 'a'=0
f _=12

Formato de entrada: HHMM(a/p)donde(a/p) es 'a' o 'p' sin paréntesis.

Formato de salida: (hs, MM) - una tupla que contiene las horas como un entero y MM aún como una cadena.

Ejemplo:

> c "1200p"
(12,"00")
> c "1200a"
(0,"00")

Versión más larga (con más nombres útiles y una sustitución hs):

conv [h0,h1,m0,m1,ap] = (mod hs 12 + offset ap, [m0,m1])
    where hs = read [h0,h1] :: Int

offset 'a'=  0
offset  _ = 12
usuario3389669
fuente
1

Lisp común ( 151 bytes)

OK, CL no está destinado a ser "conciso", pero me sorprende que no sea el más detallado para este.

Aquí está la versión de 122 bytes, que requiere una entrada de posición fija. 0145pmo 145pson aceptables (con el espacio inicial en la primera posición de carácter).

(defun a(x)(let((h(parse-integer(subseq x 0 2)))(m(subseq x 2 4)))(format nil "~a~a" (+(mod h 12)(if(find #\p x)12 0))m)))

IMPRESIÓN:

(DEFUN A (X)
  (LET ((H (PARSE-INTEGER (SUBSEQ X 0 2)))
        (M (SUBSEQ X 2 4)))
    (FORMAT NIL
            "~a~a"
            (+ (MOD H 12) (IF (FIND #\p X) 12 0))
            M)))

Más bonito pero más grande

Usando solo el Common-Lisppaquete. Acepta (solo) la entrada en forma de horas enteras (con o sin letra inicial 0), literal :, minutos de dos dígitos y seguimiento final opcional amo pm(solo en minúsculas). Permite espacios en blanco alrededor de la hora y alrededor de AM / PM, pero no directamente después de :.

(defun a(x)(let*((c(position #\: x))(h(parse-integer(subseq x 0 c)))(m(subseq x(1+ c)(+ 3 c))))(format nil "~a~a" (+(mod h 12)(if(find #\p x)12 0))m)))

Prueba:

GOLF> (a "  1:45 am ")
"1:45"
GOLF> (a "  1:45 pm ")
"13:45"
GOLF> (a " 12:45 am ")
"0:45"
GOLF> (a "12:45p")
"12:45"

pprint la definición de la función:

(DEFUN A (X)
  (LET* ((C (POSITION #\: X))
         (H (PARSE-INTEGER (SUBSEQ X 0 C)))
         (M (SUBSEQ X (1+ C) (+ 3 C))))
    (FORMAT NIL "~a~a"
            (+ (MOD H 12)
               (IF (FIND #\p X)
                   12
                   0))
            M)))

Desfuscado:

(defun 12->24-hour (timestring) 
  "Given a  TIMESTRING with  hours:minutes and a  trailing “am”  or “pm”
   \(lowercase-only), return the 24-hour time without a delimiter as
   a  string \(eg,  \"1:45am\" →  \"0145\"). Spaces  surrounding the
   time or  meridian markers are ignored  \(eg, \" 02:22 pm  \") but
   other junk in the string may cause incorrect behavior."
  (let ((colon (position #\: timestring)))
    (let ((hours (parse-integer (subseq timestring 0 colon)))
          (minutes (subseq timestring (+ 1 colon) (+ 3 colon))))
      (format nil "~a~a"
              (+ (mod hours 12) (if (find #\p timestring) 12 0))
              minutes))))
BRPocock
fuente
1

Retina , 61 60 bytes

^12(.*)a
00$1
^(12.*)p
$1
a

(\d\d)(.*)p
$1$*x12$*x$2
x+
$.&

La entrada se proporciona sin dos puntos de separación, encabezado obligatorio 0y usando solo ao en plugar de amo pm, por ejemplo, 0134aes 01:34 am. Salidas en tiempo militar directo usando 0000 como medianoche. (Podría guardar algunos bytes si se me permite convertir, por ejemplo, a las 12:30 a.m. 2430, pero dudo que sea aceptable).

Pruébalo en línea!

Explicación

Los dos casos iniciales se refieren a las "12" horas, ya que am / pm se invierte por 12:

^12(.*)a
00$1

Si el tiempo es entre la medianoche (12 a.m.) y la 1 a.m., cámbielo a 00 en lugar de a las 12 y quite el a.

^(12.*)p
$1

Si el tiempo es entre el mediodía (12 p.m.) y la 1 p.m., elimine la p para obtener las 24 horas.

Para cualquier otra hora:

a
 

Si es la hora de la mañana, simplemente quítelo apara obtener el tiempo de 24 horas.

(\d\d)(.*)p
$1$*x12$*x$2
x+
$.&

Si la hora es pm, elimine el p. Convierta el componente de hora a unario, agregue 12 y vuelva a convertir a decimal. Deja los minutos sin cambios.

Gato de negocios
fuente
1

Lote, 40 bytes.

@set/aa=0,p=12,h=%1%%12+%3
@echo %h% %2

Toma la entrada como tres argumentos. Asume que el segundo argumento tiene cero a la izquierda donde sea necesario, el tercer argumento es aop . Funciona tratando el tercer argumento como un nombre de variable indirecta, por lo tanto, lo agrega al número de horas; la cantidad de minutos no se ve afectada, por lo que solo se emite directamente. Si mezclar diferentes formatos está bien, se puede eliminar el último espacio para guardar un byte.

(Más bien molesto, esta pregunta no apareció en la página de preguntas cuando la cargué originalmente, y solo me topé con ella porque estaba buscando otra pregunta).

Neil
fuente