Surpreendentemente, essa tarefa simples parece não existir já, então ...

Sua tarefa é escrever um programa que tenha como entrada um tempo de 12 horas e o converta em "horário militar" ou formato de 24 horas.

A entrada estará no formato:

HH:MM am/pm

Embora pequenas variações sejam permitidas:

• O espaço que separa am / pm do restante do tempo é opcional.

• A última parte pode ser "am" / "pm" ou "a" / "p".

• Qualquer capitalização é boa.

A saída será a hora inserida, transformada em formato de 24 horas. Pode ser um número ou uma string.

Para entrada e saída:

• 0s em primeiro lugar são opcionais. 0s nos últimos 3 lugares são obrigatórios.

• o delimitador que separa horas e minutos pode ser um ":", "" (um espaço) ou nada.

Outras notas:

• A meia-noite pode ser expressa como 0000 ou 2400.

• A meia-noite será considerada "am", enquanto o meio-dia será considerado "pm".

Seu programa pode ser uma função ou um programa completo e deve retornar o resultado ou enviá-lo para o stdout. O espaço em branco à direita está ok.

Exemplos (você não precisa dar suporte a todos os formatos):

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

Isso é código de golfe, então o menor número de bytes vence. Como isso é tão trivial para resolver usando um built-in, seria bom ver algum código que resolve isso manualmente (mas o uso de built-ins é bom).

Apenas para esclarecer, você não precisa oferecer suporte a todos os formatos possíveis. Suportar apenas uma única entrada e um único formato de saída (de sua escolha) é bom. Gostaria, no entanto, de limitar o formato conforme descrito acima (que já é bastante gratuito). {1134,'pm'}, por exemplo, seria inaceitável.

V , 21 17 bytes

Obrigado @DJMcMayhem por 4 bytes!

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

Experimente online! Isso pega o formato HH:MMxonde xé um aou pe o retorna no formatoHH:MM

Hexdump:

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

Explicação:

í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

Experimente online!

Explicação

Função incorporada: conversão de cadeia de datas com detecção automática do formato de entrada e com o formato de saída 15, o que corresponde a 'HH:MM'. Isso é equivalente à resposta Octave de @ StewieGriffin .

Oitava, 21 17 bytes

Guardado 4 bytes graças a Luis Mendo. Eu poderia especificar o formato número 15 em vez de 'HHMM'.

@(c)datestr(c,15)

Explicação:

Esta é uma função anônima tomando uma corda ccomo entrada no formato: '11:34 AM'. datestrreconhece o formato automaticamente como um dos formatos de data padrão e o exibe no número de formato especificado 15, que é HH:MM.

Como o formato de saída especificado não possui AMou o PMOctave o converte automaticamente para o que você chama de horário militar.

Experimente online.

Uma versão que não usa datestrusando 35 bytes

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

Explicação:

Toma uma sequência de entrada cno 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

Ou, uma abordagem diferente para 37 bytes:

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

PowerShell , 23 20 19 bytes

date "$args"-f HHmm

Experimente online!

(Se você estiver no Windows, poderá omitir the get-, para descer até 19 bytes. No TIO, aparentemente, é necessário o Get-Datenome completo .)

Recebe a entrada como uma sequência de caracteres $args[0], usa-a como entrada do Get-Datecmdlet, que a analisa em um datetimeobjeto .NET . Isso é passado com o -fparâmetro ormat de HHmmpara convertê-lo em horário militar (a capital HHespecifica o horário de 24 horas). A saída está implícita.

O mecanismo de análise é bastante robusto, portanto entradas adicionais como 12amou 12:00amsão permitidas também. Brinque com a entrada no TIO e veja o que mais funciona.

( Economizou 3 bytes graças a @admalledd ... salvou outro byte graças a @briantist )

Python 2, 44 bytes

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

Formato de entrada:, 01:23amopcional me espaços após minutos
Formato de saída:123

Pitão, 21 20 bytes

Aczd++*12}\pH%sG12PH

Recebe a entrada do formulário 01 23acomo "01:23". 0 inicial é opcional.
A saída é do formato 123, com o 0 inicial omitido.

No 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

Experimente online!

PHP, 35 32 bytes

formato de entrada: não diferencia maiúsculas de minúsculas, requer dois pontos e o mformato de saída hhmm. usa built-ins:

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

recebe entrada do primeiro argumento da linha de comando.

PHP, 45 bytes, sem built-ins

formato de entrada em (h)h:mm a(m)minúsculas, formato de saída (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)

A entrada deve ser formatada como: 12:32 am

GNU Coreutils ( 18 16 bytes)

De um script de shell:

Não aceita espaço em branco na entrada

Nesse ponto, você também pode usar $ 1 e ignorar argumentos adicionais.

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 espaços em branco na entrada,

date -d"$@" +%H%M

C #, 46 bytes

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

As seqüências de caracteres são obtidas na entrada como 12:00 AM

Fazer a mesma coisa, mas a substring na saída da chamada padrão para ToString(Assumindo uma cultura de en-GB) é de 3 bytes mais para 49 bytes:

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

date, 0 + 8 = 8 bytes

Sobre o assunto de usar a ferramenta certa para o trabalho…

Recebe entrada como um argumento de linha de comando. Corra com +%H%M -d(penalidade de 8 bytes). Não há nenhum programa real aqui; todo o trabalho é realizado pelos argumentos da linha de comando. (Esta é uma demonstração muito boa do porquê há uma penalidade nos argumentos da linha de comando!)

Exemplo:

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

Experimente online!

A entrada é delimitada por dois pontos e tem um espaço entre o horário e o horário da manhã. A saída não é delimitada por dois pontos.

-1 byte graças a Kevin Cruijssen

Japonês , 14 bytes

Ð"1/"+U s sG21

Experimente online!

Isso funciona apenas no Chrome. Aqui está uma versão que funciona em todos os navegadores:

Ð"1/"³+U s sG21

Agradecemos novamente à ETHproductions pela ajuda!

Perl, 45 28 37 bytes

28 37 bytes

(c / o @Dada)

(Código de 36 bytes, 1 byte para a -popção do compilador )

Aceita 0145pmformatos de tipo, com am / pm ou a / p. Zeros à esquerda nas entradas necessárias.

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

Teste:

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

Minha resposta original

(também gentilmente revisado)

(Código de 39 bytes, 1 byte para a -popção do compilador .)

Aceita apenas o formato 0145p ou 0145a, e nenhum outro, e requer que o perl -pmodo funcione.

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

teste:

⇒ echo 0145p | perl -p time24
1345
⇒ echo 1222a | perl -p time24
022
⇒ echo 1234p | perl -p time24
1234

Commodore 64 BASIC, 301 bytes antes da execução, 321 bytes usados ​​uma vez executados

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 inserir isso em um Commodore 64 real, você precisará usar abreviações de palavras-chave BASIC, como LE [shift] F para LEFT$, M [shift] I para MID$etc ... ou você pode tentar o CBM PRG STUDIO.

A TI$variável no Commodore BASIC apresenta a hora no formato de 24 horas como HHMMSS quando impressa. A eliminação do espaço após o número da linha não salva nenhuma memória, pois o Commodore BASIC adiciona o espaço automaticamente de qualquer maneira quando você lista o programa após inseri-lo.

Ao converter um número em uma string com STR$, o Commodore BASIC adicionará no espaço (portanto, se você PRINT Avir um espaço antes que o número seja mostrado), removi o espaço de abertura na conversão de número para string com o RIGHT$comando Você pode salvar alguns bytes alterando a linha zero para:

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

portanto, você precisará declarar seu tempo de conversão antes de executar o programa, da seguinte maneira:

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

A qualquer momento, você poderá ver a hora atual com:

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

O formato de entrada é HH:MM a/pe o formato de saída é HHMM. Abusar do fato de que a função principal possui uma matriz de seqüências de caracteres para dividir a entrada em 3 seções: hora, minuto e indicador a / p.

Exemplo de entrada e saída:

Input: 01:02 a
Output: 0102

Input: 01:02 p
Output: 13:02

Input: 12:22 p
Output: 0022

Versão não destruída:

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

Usar:

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

Isso pode ser reduzido por alguns bytes se não for usado dois pontos 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);}

Experimente online!

Estou aqui para aprender, então qualquer dica sobre como otimizar o código é bem-vinda.

@ Johan du Toit Obrigado, por salvar alguns bytes!

C, 87 72 bytes

Guardado 15 bytes graças a @Johan du Toit

Ligar f() com uma sequência mutável como argumento, a entrada é a saída.

O formato é HH:MMa/ponde a/pé minúsculo aou minúsculo p. Não é permitido espaço entre o tempo e o 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;}

Experimente em ideone .

tcl, 45 47

Agora usando um built-in:

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

Testável em http://rextester.com/TSRXI8802, onde existe um script que o executa das 01:00 às 1259.

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

Saída: HH MM

R, 68 bytes

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

Lê a entrada do stdin e supõe-se que esteja em um dos seguintes formatos:

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

e a saída está no formato: [1] "00:00"

Na maioria dos casos, a strptime()saída está no formato: "2017-01-06 12:00:00 CET"onde a data é a data local. Como tal, precisamos usar substr()para retornar apenas a hora, no entanto, se a entrada for meia-noite (por exemplo 12:00am), a saída é apenas "2017-01-06 CET"a razão para a ifcoisa no final (deve haver alguma solução mais inteligente).

C, 159 152 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*+

Experimente aqui!

Mathematica, 33 bytes

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

Função anônima. Pega uma string como entrada e retorna uma string como saída. Funciona com a maioria dos formatos, inclusive 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))

A entrada é como no exemplo

Haskell, 61 caracteres

Versão curta:

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)onde (a/p)é 'a' ou 'p' sem parênteses.

Formato de saída: (hs, MM) - uma tupla contendo as horas como um inteiro e MM ainda como uma sequência.

Exemplo:

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

Versão mais longa (com nomes mais úteis e uma substituição 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 comum ( 151 122 bytes)

OK, CL não deve ser "conciso", mas estou surpreso que não seja o mais detalhado para este.

Aqui está a versão de 122 bytes, que requer entrada em posição fixa. 0145pmou 145psão aceitáveis ​​(com o espaço à esquerda na primeira posição do caractere).

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

PPRINT:

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

Melhor, mas maior

Usando apenas o Common-Lisppacote. Aceita (apenas) a entrada na forma de horas inteiras (com ou sem avanço 0), :minutos literais de dois dígitos e rastreamento opcional amou pm(somente em minúsculas). Permite espaços em branco ao redor do tempo e em torno do AM / PM, mas não diretamente após o :.

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

Teste:

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 a definição da função:

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

Desfocado:

(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+
$.&

A entrada é fornecida sem dois pontos, separação obrigatória 0e uso apenas aou em pvez de amou pm, por exemplo, 0134aé 01:34. Saídas em tempo militar reto, usando 0000 como meia-noite. (Eu poderia salvar alguns bytes se me permitisse converter, por exemplo, 12h30 em2430 , mas duvido que seja aceitável).

Experimente online!

Explicação

Os dois casos iniciais tratam das "12" horas, uma vez que am / pm é revertido para 12:

^12(.*)a
00$1

Se o horário estiver entre meia-noite (12h) e 1h, altere-o para 00 em vez de 12 e remova o a.

^(12.*)p
$1

Se o tempo estiver entre meio-dia (12h) e 13h, remova op para obter o horário de 24 horas.

Para qualquer outra hora:

a
 

Se for a hora, basta remover o a para obter o tempo de 24 horas.

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

Se a hora for pm, remova o p. Converta o componente da hora em unário, adicione 12 e converta novamente em decimal. Deixe os minutos inalterados.

Lote, 40 bytes

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

Recebe entrada como três argumentos. Assume que o segundo argumento tem zero à esquerda, quando necessário, o terceiro argumento é aoup . Funciona tratando o terceiro argumento como um nome de variável indireta, adicionando-o ao número de horas; o número de minutos não é afetado, apenas a saída direta. Se misturar diferentes formatos estiver correto, o último espaço poderá ser excluído para salvar um byte.

(De maneira irritante, essa pergunta não apareceu na página de perguntas quando a carregei originalmente, e só a encontrei porque estava procurando outra pergunta.)