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.

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

MATL , 4 bytes

15XO

Pruébalo en línea!

Explicación

Función incorporada: conversión de cadena de fecha con detección automática de formato de entrada y con formato de salida 15, que corresponde 'HH:MM'. Esto es equivalente a la respuesta Octave de @ StewieGriffin .

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),'']

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 )

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

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!

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];

JavaScript (ES6), 40 bytes

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

La entrada debe estar formateada como: 12:32 am

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

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);

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

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

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!

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

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$

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]));
    }
}

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.

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!

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 .

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.

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

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).

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

Pyke, 15 bytes

4<bwӐi%\pQ{i*+

Pruébalo aquí!

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.

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

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

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))))

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.

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).