Conversor de tempo de 12 horas a 24 horas

27

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.

Carcinigenicado
fonte
Quais formatos são necessários para oferecer suporte? Apenas um?
Redstarcoder #
@redstarcoder Sim. Qualquer formato que esteja em conformidade com os requisitos acima está ok, mas conforme observado acima nos casos de exemplo, você não precisa dar suporte a todos os formatos. Um único formato de entrada e um único formato de saída são bons.
precisa saber é
nossos formatos podem exigir zeros à esquerda? Por exemplo, 01:54pmfuncionaria, mas 1:54pmnão?
FlipTack
Sim. Você pode escolher o formato de entrada necessário.
precisa saber é o seguinte
É permitido incluir segundos em nossa entrada e saída?
12Me21

Respostas:

8

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
nmjcman101
fonte
A entrada estará sempre [1-12]correta? Nesse caso, acho que você poderia fazer em ó^12/0vez decw^R=^R"%12
DJMcMayhem
1
Além disso, você pode usar o "comando global" para aplicar um comando às linhas correspondentes a um regex, que é mais curto do que quebrar uma macro. çp/12^Aque é equivalente :g/p/norm 12<C-a>no vim
DJMcMayhem
Aceitei isso porque era a resposta de pontuação mais baixa que deixava claro que não estava usando um incorporado (mesmo que eu não o proibisse). Se alguém tiver algum problema com essa escolha, posso mudar minha resposta para ser justa. Eu acho que essa resposta é a mais merecedora.
Carcigenicate
12

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 .

Luis Mendo
fonte
10

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

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 )

AdmBorkBork
fonte
Deve ser capaz de remover o espaço entre $args[0]e -f, assim como remover as aspas simples em torno do str formato: date $args[0]-f HHmm. Pelo menos isso funciona no meu powershell ...
admalledd
@admalledd Por falar alto, eu sempre esqueço essas citações. Sério, acho que toda vez que useiGet-Date com -falguém me lembrou que você não precisa das aspas. E boa decisão com a remoção do espaço também, já que o analisador trata isso ]como o final de um token. Obrigado!
AdmBorkBork
5

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

busukxuan
fonte
5

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!

busukxuan
fonte
4

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];
Titus
fonte
4
Por que o voto negativo?
Titus
Só estou especulando, mas talvez seja porque você usou PHP e o downvoter não gosta de PHP? : p
bash0r 07/01
3

JavaScript (ES6), 40 bytes

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

A entrada deve ser formatada como: 12:32 am

Mwr247
fonte
3

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
BRPocock
fonte
3

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);
TheLethalCoder
fonte
3

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

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

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

Cutucar
fonte
O mais curto possível para Java, 20% do código sendo qualificador de pacote.
Magic Octopus Urn
As regras declaram isso " Para entrada e saída: - 0s em primeiro lugar são opcionais. 0s nos últimos 3 lugares são obrigatórios. ", O que significa que você pode mudar HHmmpara Hmm.
Kevin Cruijssen
@KevinCruijssen nice catch!
puxão
2

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!

Oliver
fonte
2

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
BRPocock
fonte
Bem-vindo ao PPCG. Ótima primeira resposta. Você pode usar switches, mas eles contam no seu bytecount (como explicado aqui ). No seu caso, isso seria +1 byte (porque -pé necessário apenas ) se você alterar as aspas simples para aspas duplas.
Dada
Obrigado. Não foi possível encontrar essa FAQ, pergunto-me se a equipe do Stack Exchange poderia fixá-la na página de resposta ou algo assim.
BRPocock 6/17/17
OK, eu estou em Perling desde a série 4 e isso faz minha cabeça doer, você deve receber o crédito e postar-se com ela. ☺
BRPocock
Eu acho que deveria cobrir agora?
BRPocock
Cometi um erro, esta solução não funcionará quando os minutos estiverem entre 0 e 9. Esse código funciona então: s/(..)(.)$//;$_=$_%12+12*(p eq$2).$1(37 bytes). E, a propósito, sua primeira solução pode ser aprimorada um pouco: s/(..)(..)([ap])/$1%12+12*($3eq"p").$2/e(40 bytes)
Dada
2

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$
Shaun Bebbers
fonte
Jogar golfe com código em máquinas de 8 bits é realmente interessante, pois mostra o quanto é feito para um programador dos dias de hoje sem precisar pensar nisso.
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]));}}

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]));
    }
}
biscoito
fonte
Eu não tinha visto enumusado para segurar o main. Bom :)
Robert Benson
Você pode omitir um espaço na assinatura do método principal: public static void main (String [] a) {...
staticmethod
2

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.

idrougge
fonte
O delimitador de dois pontos é opcional.
precisa saber é o seguinte
Sim, mas não parece bom.
Idragge
Dado que esse é um desafio para o código de golfe, se você tiver a opção de um programa mais longo com saída bonita ou um programa mais curto com saída mais feia, escolha o último. Ninguém te julgará.
Carcigenicato
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);}

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!

Abel Tom
fonte
Você não precisa testar se b == 'm' e pode torná-lo muito mais curto usando as instruções if inline:printf("%02d:%02d", (a=='p' ? 12 : 0) + (h %12), m);
Johan du Toit
1
@JohanduToit O que eu introduzo é 6: 00pc? :)
Abel Tom
1
Isso causará danos irreparáveis ​​ao continuum espaço-tempo.
Johan du Toit
1
75 bytes
ceilingcat 11/10
2

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 .

owacoder
fonte
você pode salvar alguns bytes usando o seguinte: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 em (p[5]!=97)*12;vez de(p[5]^97?12:0);
roofcat 11/10
2

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.

sergiol
fonte
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

Saída: HH MM

12Me21
fonte
1

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

Billywob
fonte
Eu realmente queria encontrar uma maneira mais curta com lubridate, mas o nome do pacote é muito longo (entre outros problemas).
BLT
1

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

Steadybox
fonte
1

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.

LegionMammal978
fonte
1

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

lhama butt
fonte
Não funciona para 12:00 amou12:00 pm
Herman L
1

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
user3389669
fonte
1

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))))
BRPocock
fonte
1

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.

Gato de negócios
fonte
1

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

Neil
fonte