Sorprendentemente, questo semplice compito non sembra esistere già, quindi ...

Il tuo compito è quello di scrivere un programma che accetta come input un'ora di 12 ore e lo converte in "ora militare", o formato di 24 ore.

L'input sarà nella forma:

HH:MM am/pm

Sebbene siano consentite lievi variazioni:

• Lo spazio che separa le am / pm dal resto del tempo è facoltativo.

• L'ultima parte può essere "am" / "pm" o "a" / "p".

• Qualsiasi capitalizzazione va bene.

L'output sarà il tempo immesso, trasformato in formato 24 ore. Può essere un numero o una stringa.

Sia per l'input che per l'output:

• Gli 0 in primo luogo sono opzionali. Gli 0 negli ultimi 3 posti sono obbligatori.

• il delimitatore che separa ore e minuti può essere un ":", "" (uno spazio) o niente.

Altre note:

• La mezzanotte può essere espressa come 0000 o 2400.

• La mezzanotte sarà considerata "am", mentre il mezzogiorno sarà considerato "pm".

Il programma può essere una funzione o un programma completo e dovrebbe restituire il risultato o inviarlo allo stdout. Lo spazio bianco finale è ok.

Esempi (non è necessario supportare tutti i formati):

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

Questo è il codice golf, quindi vince il minor numero di byte. Dato che è così banale da risolvere usando un built-in, sarebbe bello vedere del codice che risolve manualmente questo problema (ma l'uso dei built-in va bene).

Solo per chiarire, non è necessario supportare tutti i formati possibili. Supportare solo un singolo input e un singolo formato di output (a scelta) va bene. Vorrei tuttavia limitare il formato come indicato sopra (che è già abbastanza gratuito). {1134,'pm'}, ad esempio, sarebbe inaccettabile.

V , 21 17 byte

Grazie @DJMcMayhem per 4 byte!

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

Provalo online! Questo prende il formato HH:MMxdove xè o ao pe lo restituisce nel formatoHH:MM

hexdump:

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

Spiegazione:

í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 byte

15XO

Provalo online!

Spiegazione

Funzione integrata: conversione della stringa di data con rilevamento automatico del formato di input e con formato di output 15, che corrisponde a 'HH:MM'. Ciò equivale alla risposta Octave di @ StewieGriffin .

Ottava, 21 17 byte

Risparmiato 4 byte grazie a Luis Mendo. Potrei specificare il formato numero 15 anziché 'HHMM'.

@(c)datestr(c,15)

Spiegazione:

Si tratta di una funzione anonima prendendo una stringa ccome input sul formato: '11:34 AM'. datestrriconosce automaticamente il formato come uno dei formati di data standard e lo emette nel formato numero specificato 15, che è HH:MM.

Poiché il formato di output specificato non ha AMo PMOctave lo converte automaticamente in ciò che si chiama tempo militare.

Provalo online.

Una versione che non utilizza datestrusando 35 byte

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

Spiegazione:

Accetta una stringa di input csul 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

Oppure, un approccio diverso per 37 byte:

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

PowerShell , 23 20 19 byte

date "$args"-f HHmm

Provalo online!

(Se sei su Windows, puoi omettere il get-, per arrivare a 19 byte. Su TIO, a quanto pare richiede il Get-Datenome completo .)

Accetta l'input come stringa $args[0], lo utilizza come input per il Get-Datecmdlet, che lo analizza in un datetimeoggetto .NET . -fViene passato con il parametro ormat di HHmmconvertirlo in tempo militare (la capitale HHspecifica il tempo di 24 ore). L'output è implicito.

Il motore di analisi è abbastanza robusti, ingressi così aggiuntive come 12amo 12:00amposso pure. Divertiti con l'input su TIO e vedi cos'altro funziona.

( Salvato 3 byte grazie a @admalledd ... salvato un altro byte grazie a @briantist )

Python 2, 44 byte

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

Formato di input:, 01:23amopzionale me spazi dopo minuti
Formato di output:123

Pyth, 21 20 byte

Aczd++*12}\pH%sG12PH

Accetta il modulo 01 23acome "01:23". Lo 0 iniziale è facoltativo.
L'output è nel formato 123, con lo 0 iniziale omesso.

In pseudocodice:

                         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

Provalo online!

PHP, 35 32 byte

formato di input: senza distinzione tra maiuscole e minuscole, richiede due punti e il mformato di output hhmm. usa i built-in:

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

accetta input dal primo argomento della riga di comando.

PHP, 45 byte, nessun built-in

formato di input (h)h:mm a(m)minuscolo, formato di output (h)hmm.

<?=($s=$argv[1])%12+12*($s[6]>a).$s[3].$s[4];

JavaScript (ES6), 40 byte

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

L'input deve essere formattato come: 12:32 am

GNU Coreutils ( 18 16 byte)

Da uno script di shell:

Non accetta spazi bianchi nell'input

A quel punto, puoi anche usare $ 1 e ignorare argomenti aggiuntivi.

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

Originale

Per consentire spazi bianchi nell'input,

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

C #, 46 byte

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

Le stringhe sono prese in input come 12:00 AM

Fare la stessa cosa ma sottostringendo sull'output dalla chiamata predefinita a ToString(Supponendo una cultura di en-GB) è 3 byte più lungo per 49 byte:

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

date, 0 + 8 = 8 byte

In tema di utilizzo dello strumento giusto per il lavoro ...

Accetta input come argomento della riga di comando. Esegui con +%H%M -d(penalità di 8 byte). Non esiste un vero programma qui; l'intero lavoro viene svolto dagli argomenti della riga di comando. (Questa è una buona dimostrazione del perché c'è una penalità per gli argomenti della riga di comando!)

Esempio:

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

Java 7, 138 106 105 104 byte

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

Provalo online!

L'ingresso è delimitato da due punti e ha uno spazio tra il tempo e le am / pm. L'output non è delimitato da due punti.

-1 byte grazie a Kevin Cruijssen

Japt , 14 byte

Ð"1/"+U s sG21

Provalo online!

Funziona solo su Chrome. Ecco una versione che funziona in tutti i browser:

Ð"1/"³+U s sG21

Grazie ancora a ETHproductions per l'aiuto!

Perl, 45 28 37 byte

28 37 byte

(c / o @Dada)

(Codice 36 byte, 1 byte per -pswitch compilatore )

Accetta 0145pmformati di tipo, con am / pm o a / p. Zero iniziali sugli input richiesti.

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

Test:

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

La mia risposta originale

(anche rivisto delicatamente)

(Codice 39 byte, 1 byte per lo -pswitch del compilatore .)

Accetta solo il modulo come 0145p o 0145a e nessun altro e richiede la perl -pmodalità per funzionare.

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

test:

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

Commodore 64 BASIC, 301 byte prima dell'esecuzione, 321 byte utilizzati una volta eseguiti

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

Per inserire questo su un vero Commodore 64, dovrai usare abbreviazioni di parole chiave BASIC, come LE [shift] F per LEFT$, M [shift] I per MID$ecc ... oppure potresti provare CBM PRG STUDIO.

La TI$variabile in Commodore BASIC presenta l'ora nel formato 24 ore come HHMMSS quando viene stampata. Rimuovere lo spazio dopo il numero di riga non salva alcuna memoria poiché Commodore BASIC aggiunge automaticamente lo spazio quando si elenca il programma dopo averlo inserito.

Quando converti un numero in una stringa con STR$, Commodore BASIC aggiungerà nello spazio (quindi se PRINT Avedrai uno spazio prima che venga mostrato il numero), ho rimosso lo spazio di apertura sul numero per convertire la stringa con il RIGHT$comando. È possibile salvare alcuni byte modificando la riga zero in:

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

quindi dovrai dichiarare il tuo tempo di conversione prima di eseguire il programma, come segue:

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

In qualsiasi momento successivo, puoi vedere l'ora corrente con:

? TI$

Java, 171 byte

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

Il formato di input è HH:MM a/pe il formato di output è HHMM. Abusando del fatto che la funzione principale ha una serie di stringhe per dividere l'input in 3 sezioni: ora, minuti e indicatore a / p.

Esempio di input e output:

Input: 01:02 a
Output: 0102

Input: 01:02 p
Output: 13:02

Input: 12:22 p
Output: 0022

Versione non golfata:

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 byte

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

Uso:

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

Ciò potrebbe essere ridotto di alcuni byte se non si utilizzavano due punti come delimitatore.

C (clang) , 94 byte

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

Provalo online!

Sono qui per imparare, quindi sono graditi tutti i suggerimenti su come posso ottimizzare il codice.

@ Johan du Toit Grazie, per aver salvato qualche byte!

C, 87 72 byte

15 byte salvati grazie a @Johan du Toit

Chiama f()con una stringa mutabile come argomento, l'input è l'output.

Il formato è HH:MMa/p, dove a/pè minuscolo ao minuscolo p. Non è consentito spazio tra il tempo e lo specificatore 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;}

Provalo su ideone .

tcl, 45 47

Ora usando un built-in:

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

Testabile su http://rextester.com/TSRXI8802 dove è presente uno script che lo esegue dalle 0100 alle 1259pm

SmileBASIC, 67 byte

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

Ingresso: HH:MMa/p

Produzione: HH MM

R, 68 byte

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

Legge l'input da stdin e si presume che sia in uno dei seguenti formati:

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

e l'output è nel formato: [1] "00:00"

Nella maggior parte dei casi l' strptime()output è nel formato: "2017-01-06 12:00:00 CET"dove la data è la data locale. Come tale dobbiamo usare substr()solo per restituire il tempo, tuttavia, se l'input è mezzanotte (es. 12:00am) L'output è solo quello "2017-01-06 CET"che è la ragione per la ifcosa alla fine (ci deve essere qualche soluzione più intelligente).

C, 159 152 byte

#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 di input: 07:30am

Pyke, 15 byte

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

Provalo qui!

Mathematica, 33 byte

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

Funzione anonima. Accetta una stringa come input e restituisce una stringa come output. Funziona con la maggior parte dei formati, incluso hh:mm AM/PM.

JavaScript, 67 byte

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

L'input è come nell'esempio

Haskell, 61 caratteri

Versione breve:

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

Formato di input: HHMM(a/p)dove (a/p)è 'a' o 'p' senza parentesi.

Formato di output: (hs, MM)- una tupla contenente le ore come numero intero e MM ancora come stringa.

Esempio:

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

Versione più lunga (con nomi più utili e una sostituzione 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 comune ( 151 122 byte)

OK, CL non è pensato per essere "conciso" ma sono solo sorpreso che non sia il più prolisso per questo.

Ecco la versione da 122 byte, che richiede input in posizione fissa. 0145pmo 145psono accettabili (con lo spazio iniziale nella prima posizione del personaggio).

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

Più bello ma più grande

Utilizzando solo il Common-Lisppacchetto. Accetta (solo) input sotto forma di ore intere (con o senza inizio 0), :minuti letterali a due cifre e trascinamento opzionale amo pm(solo in minuscolo). Consente spazi bianchi nel tempo e attorno all'AM / PM, ma non direttamente dopo il :.

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

Test:

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 definizione della funzione:

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

De-offuscato:

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

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

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

L'input viene dato senza due punti di separazione, leader obbligatorio 0e utilizzando solo ao pinvece diam o pm, ad esempio 0134aè 01:34. Uscite in tempo militare diretto usando 0000 come mezzanotte. (Potrei salvare alcuni byte se mi è permesso convertire, ad esempio, le 12:30 in2430 , ma dubito che sia accettabile).

Provalo online!

Spiegazione

I due casi iniziali riguardano le "12" ore, poiché am / pm è invertito per 12:

^12(.*)a
00$1

Se l'orario è compreso tra mezzanotte (12) e l'una, modificalo in 00 anziché in 12 e rimuovi il a.

^(12.*)p
$1

Se il tempo è tra mezzogiorno (12 pm) e 13:00, rimuovere la p per ottenere semplicemente l'ora di 24 ore.

Per ogni altra ora:

a
 

Se è l'ora, è sufficiente rimuovere il aper ottenere il tempo di 24 ore.

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

Se l'ora è pm, rimuovere il p. Converti il ​​componente ora in unario, aggiungi 12 e converti in decimale. Lascia invariati i minuti.

Lotto, 40 byte

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

Accetta input come tre argomenti. Presuppone che il secondo argomento abbia zero iniziale se necessario, il terzo argomento è ao p. Funziona trattando il terzo argomento come un nome di variabile indiretta aggiungendolo quindi al numero di ore; il numero di minuti non è interessato, quindi viene emesso direttamente. Se la miscelazione di formati diversi è OK, l'ultimo spazio può essere eliminato per salvare un byte.

(Piuttosto fastidiosamente, questa domanda non è stata visualizzata nella pagina delle domande quando l'ho caricata originariamente e mi sono imbattuta in esso solo perché stavo cercando un'altra domanda.)