Erstaunlicherweise scheint diese einfache Aufgabe noch nicht zu existieren, also ...

Ihre Aufgabe ist es, ein Programm zu schreiben, das eine 12-Stunden-Zeit als Eingabe verwendet und es in "Militärzeit" oder 24-Stunden-Zeitformat umwandelt.

Die Eingabe erfolgt in der Form:

HH:MM am/pm

Obwohl geringfügige Abweichungen zulässig sind:

• Der Abstand zwischen vormittags und nachmittags zum Rest der Zeit ist optional.

• Der letzte Teil kann entweder "am" / "pm" oder "a" / "p" sein.

• Jede Großschreibung ist in Ordnung.

Die Ausgabe ist die eingegebene Zeit, die in das 24-Stunden-Format umgewandelt wird. Es kann eine Zahl oder eine Zeichenfolge sein.

Für die Eingabe und Ausgabe:

• Nullen an erster Stelle sind optional. 0 in den letzten 3 Stellen sind Pflichtfelder.

• Das Trennzeichen zwischen Stunden und Minuten kann ein ":", "" (ein Leerzeichen) oder nichts sein.

Weitere Hinweise:

• Mitternacht kann entweder als 0000 oder 2400 ausgedrückt werden.

• Mitternacht gilt als "Uhr", Mittag als "Uhr".

Ihr Programm kann eine Funktion oder ein vollständiges Programm sein und sollte entweder das Ergebnis zurückgeben oder es an die Standardausgabe ausgeben. Nachgestellte Leerzeichen sind in Ordnung.

Beispiele (Sie müssen nicht jedes Format unterstützen):

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

Das ist Codegolf, also gewinnt die kleinste Anzahl von Bytes. Da es so trivial ist, dies mit einem eingebauten Code zu lösen, wäre es schön, Code zu sehen, der dies manuell löst (die Verwendung von eingebauten Codes ist jedoch in Ordnung).

Um dies zu verdeutlichen, müssen Sie nicht jedes mögliche Format unterstützen. Es ist in Ordnung, nur ein einzelnes Eingabe- und ein einzelnes Ausgabeformat (Ihrer Wahl) zu unterstützen. Ich möchte jedoch das Format wie oben beschrieben einschränken (was schon ziemlich kostenlos ist). {1134,'pm'}Zum Beispiel wäre inakzeptabel.

V , 21 17 Bytes

Danke @DJMcMayhem für 4 Bytes!

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

Probieren Sie es online! Dies übernimmt das Format, HH:MMxin dem xentweder aoder steht p, und gibt es im Format zurückHH:MM

Hexdump:

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

Erläuterung:

í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

Probieren Sie es online!

Erläuterung

Eingebaute Funktion: Datumskonvertierung mit automatischer Erkennung des Eingabeformats und des Ausgabeformats 15, das dem entspricht 'HH:MM'. Dies entspricht der Oktavantwort von @ StewieGriffin .

Oktave, 21 17 Bytes

4 Bytes dank Luis Mendo gespeichert. Ich könnte statt Format 15 angeben 'HHMM'.

@(c)datestr(c,15)

Erläuterung:

Dies ist eine anonyme Funktion eine Zeichenfolge nehmen cals Eingabe an das Format: '11:34 AM'. datestrErkennt das Format automatisch als eines der Standard-Datumsformate und gibt es im angegebenen Format 15 aus HH:MM.

Da das angegebene Ausgabeformat nicht über AModer PMOctave verfügt, wird es automatisch in die von Ihnen als Militärzeit bezeichnete Zeit konvertiert.

Probieren Sie es online aus.

Eine Version, die keine datestr35 Bytes verwendet

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

Erläuterung:

Übernimmt eine Eingabezeichenfolge cfür das Format 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

Oder ein anderer Ansatz für 37 Bytes:

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

PowerShell , 23 20 19 Byte

date "$args"-f HHmm

Probieren Sie es online!

(Wenn Sie unter Windows arbeiten, können Sie das weglassen get-, um auf 19 Byte zu kommen. Bei TIO ist anscheinend der vollständige Get-DateName erforderlich .)

Übernimmt die Eingabe als Zeichenfolge $args[0]und verwendet diese als Eingabe für das Get-DateCmdlet, das sie in ein .NET- datetimeObjekt analysiert . -fDies wurde mit dem ormat-Parameter übergeben HHmm, um es in Militärzeit umzuwandeln (die Hauptstadt HHgibt die 24-Stunden-Zeit an). Die Ausgabe ist implizit.

Die Parsing-Engine ist ziemlich robust, so dass zusätzliche Eingaben wie 12amoder 12:00amauch zulässig sind. Spielen Sie mit dem Eingang von TIO und sehen Sie, was sonst noch funktioniert.

( 3 Bytes dank @admalledd gespeichert ... ein weiteres Byte dank @briantist gespeichert )

Python 2, 44 Bytes

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

Eingabeformat:, 01:23amoptional mund Leerzeichen nach Minuten
Ausgabeformat:123

Pyth, 21 bis 20 Bytes

Aczd++*12}\pH%sG12PH

01 23aÜbernimmt die Eingabe des Formulars als "01:23 Uhr". Die anfängliche 0 ist optional.
Die Ausgabe erfolgt in der Form 123, wobei die anfängliche 0 weggelassen wird.

Im Pseudocode:

                         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

Probieren Sie es online!

PHP, 35 32 Bytes

Eingabeformat: Groß- und Kleinschreibung beachten, erfordert Doppelpunkt und mAusgabeformat hhmm. Verwendet integrierte Funktionen:

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

Nimmt Eingaben vom ersten Befehlszeilenargument entgegen.

PHP, 45 Bytes, keine eingebauten

Eingabeformat (h)h:mm a(m)Kleinbuchstaben, Ausgabeformat (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)

Die Eingabe sollte wie folgt formatiert sein: 12:32 am

GNU Coreutils ( 18 - 16 Bytes)

Aus einem Shell-Skript:

Akzeptiert keine Leerzeichen in der Eingabe

In diesem Fall können Sie auch $ 1 verwenden und zusätzliche Argumente ignorieren.

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

Um Leerzeichen in der Eingabe zuzulassen,

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

C #, 46 Bytes

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

Strings werden wie bei der Eingabe übernommen 12:00 AM

Dasselbe tun, aber die Teilzeichenfolge für die Ausgabe des Standardaufrufs an ToString(Angenommen, eine Kultur von en-GB) ist 3 Byte länger für 49 Byte:

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

date, 0 + 8 = 8 Bytes

Zum Thema "Das richtige Werkzeug für den Job"

Nimmt Eingaben als Befehlszeilenargument. Laufen Sie mit +%H%M -d(8-Byte-Strafe). Hier gibt es kein aktuelles Programm. Die gesamte Arbeit wird durch die Befehlszeilenargumente erledigt. (Dies ist eine ziemlich gute Demonstration, warum Befehlszeilenargumente mit einer Strafe belegt werden!)

Beispiel:

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

Probieren Sie es online!

Die Eingabe ist durch Doppelpunkte getrennt und hat ein Leerzeichen zwischen der Uhrzeit und dem Vormittag / Nachmittag. Die Ausgabe ist nicht durch Doppelpunkte getrennt.

-1 Byte dank Kevin Cruijssen

Japt , 14 Bytes

Ð"1/"+U s sG21

Probieren Sie es online!

Dies funktioniert nur in Chrome. Hier ist eine Version, die in allen Browsern funktioniert:

Ð"1/"³+U s sG21

Nochmals vielen Dank an ETHproductions für die Hilfe!

Perl, 45 28 37 Bytes

28 37 Bytes

(c / o @Dada)

(36 Byte Code, 1 Byte für Compiler- -pSwitch)

Akzeptiert 0145pmTypformate mit am / pm oder a / p. Führende Nullen bei Eingaben erforderlich.

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

Prüfung:

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

Meine ursprüngliche Antwort

(auch sanft überarbeitet)

(39 Byte Code, 1 Byte für Compiler- -pSwitch.)

Akzeptiert nur das Formular wie 0145p oder 0145a und kein anderes und erfordert den perl -pBetriebsmodus.

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

Prüfung:

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

Commodore 64 BASIC, 301 Bytes vor der Ausführung, 321 Bytes werden einmal ausgeführt

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

Um dies auf einem echten Commodore 64 einzugeben, müssen Sie BASIC-Schlüsselwortabkürzungen verwenden, z. B. LE [Umschalt] F für LEFT$, M [Umschalt] I für MID$usw., oder Sie können CBM PRG STUDIO ausprobieren.

Die TI$Variable in Commodore BASIC zeigt die Uhrzeit beim Drucken im 24-Stunden-Format als HHMMSS an. Wenn Sie den Speicherplatz nach der Zeilennummer löschen, wird kein Speicherplatz gespart, da Commodore BASIC den Speicherplatz ohnehin automatisch hinzufügt, wenn Sie das Programm nach der Eingabe auflisten.

Beim Konvertieren einer Zahl in eine Zeichenfolge mit STR$fügt Commodore BASIC das Leerzeichen ein (wenn Sie also PRINT Aein Leerzeichen sehen, bevor die Zahl angezeigt wird), habe ich das Leerzeichen für die Konvertierung der Zahl in eine Zeichenfolge mit dem RIGHT$Befehl entfernt. Sie könnten ein paar Bytes sparen, indem Sie die Zeile Null wie folgt ändern:

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

Daher müssen Sie Ihre Konvertierungszeit wie folgt angeben, bevor Sie das Programm ausführen können:

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

Zu jedem späteren Zeitpunkt können Sie die aktuelle Uhrzeit anzeigen mit:

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

Eingabeformat ist HH:MM a/pund Ausgabeformat ist HHMM. Missbrauch der Tatsache, dass die Hauptfunktion über eine Reihe von Zeichenfolgen verfügt, um die Eingabe in drei Abschnitte zu unterteilen: Stunde, Minute und A / P-Anzeige.

Beispiel für Ein- und Ausgabe:

Input: 01:02 a
Output: 0102

Input: 01:02 p
Output: 13:02

Input: 12:22 p
Output: 0022

Ungolfed-Version:

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

Verwenden:

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

Dies könnte um einige Bytes verkürzt werden, wenn kein Doppelpunkt als Begrenzer verwendet wird.

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

Probieren Sie es online!

Ich bin hier, um zu lernen, also sind alle Tipps, wie ich den Code optimieren kann, willkommen.

@ Johan du Toit Danke, dass du ein paar Bytes gespart hast!

C, 87 72 Bytes

Dank @Johan du Toit 15 Bytes gespart

Rufen Sie f()mit einer veränderlichen Zeichenfolge als Argument auf, die Eingabe ist die Ausgabe.

Das Format lautet HH:MMa/p, wobei a/pentweder Kleinbuchstaben aoder Kleinbuchstaben verwendet werden p. Zwischen der Zeit und dem Meridian-Spezifizierer ist kein Leerzeichen zulässig.

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

Probiere es auf ideone aus .

TCL, 45 47

Jetzt mit einem eingebauten:

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

Testbar unter http://rextester.com/TSRXI8802, wo es ein Skript gibt, das es von 01:00 bis 12:00 Uhr ausführt

SmileBASIC, 67 Bytes

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

Eingang: HH:MMa/p

Ausgabe: HH MM

R, 68 Bytes

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

Liest Eingaben von stdin und es wird angenommen, dass sie in einem der folgenden Formate vorliegen:

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

und die Ausgabe erfolgt im Format: [1] "00:00"

In den meisten Fällen erfolgt die strptime()Ausgabe im Format: "2017-01-06 12:00:00 CET"wobei das Datum das lokale Datum ist. Als solches müssen wir verwenden, substr()um nur die Zeit zurückzugeben. Wenn die Eingabe jedoch Mitternacht ist (z. B. 12:00am), ist die Ausgabe nur "2017-01-06 CET"der Grund für die ifSache am Ende (es muss eine geschicktere Problemumgehung geben).

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

Eingabeformat: 07:30am

Pyke, 15 Bytes

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

Probieren Sie es hier aus!

Mathematica, 33 Bytes

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

Anonyme Funktion. Nimmt einen String als Eingabe und gibt einen String als Ausgabe zurück. Funktioniert mit den meisten Formaten, einschließlich 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))

Die Eingabe erfolgt wie im Beispiel

Haskell, 61 Zeichen

Kurzfassung:

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

Eingabeformat: HHMM(a/p)Dabei (a/p)steht entweder 'a' oder 'p' ohne Klammer.

Ausgabeformat: (hs, MM)- Ein Tupel, das die Stunden als Ganzzahl und MM als Zeichenfolge enthält.

Beispiel:

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

Längere Version (mit nützlicheren Namen und einer Ersetzung 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

Common Lisp ( 151 122 Bytes)

OK, CL soll nicht "knapp" sein, aber ich bin nur überrascht, dass es für dieses nicht die ausführlichste ist.

Hier ist die 122-Byte-Version, die eine Eingabe mit fester Position erfordert. 0145pmoder 145psind akzeptabel (mit dem führenden Leerzeichen an der ersten Zeichenposition).

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

Schöner aber größer

Verwenden Sie nur das Common-LispPaket. Akzeptiert (nur) Eingaben in Form von ganzen Stunden (mit oder ohne Führung 0), Literalen :, zweistelligen Minuten und optionalem Nachstellen amoder pm(nur in Kleinbuchstaben). Erlaubt Leerzeichen um die Uhrzeit und um die AM / PM, jedoch nicht direkt nach dem :.

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

Prüfung:

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 die Funktionsdefinition:

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

Enttarnt:

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

Die Eingabe erfolgt ohne trennenden Doppelpunkt, obligatorisches Anführen 0und unter Verwendung von nur aoder panstelle von amoder pm, z 0134a. B. um 01:34 Uhr. Ausgabe in reiner Militärzeit mit 0000 als Mitternacht. (Ich könnte ein paar Bytes einsparen, wenn ich zum Beispiel 12:30 Uhr in konvertieren darf 2430, aber ich bezweifle, dass das akzeptabel ist).

Probieren Sie es online!

Erläuterung

Die ersten beiden Fälle befassen sich mit den "12" Stunden, da am / pm für 12 umgekehrt ist:

^12(.*)a
00$1

Wenn die Zeit zwischen Mitternacht (12 Uhr) und 1 Uhr morgens liegt, ändern Sie sie auf 00 anstelle von 12 Uhr und entfernen Sie die a.

^(12.*)p
$1

Wenn die Zeit zwischen 12.00 Uhr und 13.00 Uhr liegt, entfernen Sie das p, um einfach die 24-Stunden-Zeit zu erhalten.

Für jede andere Stunde:

a
 

Wenn die Zeit abgelaufen ist, entfernen Sie einfach die a, um die 24-Stunden-Zeit zu erhalten.

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

Wenn die Uhrzeit pm ist, entfernen Sie die p. Konvertieren Sie die Stundenkomponente in unär, addieren Sie 12 und konvertieren Sie zurück in dezimal. Lassen Sie die Minuten unverändert.

Batch, 40 Bytes

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

Nimmt die Eingabe als drei Argumente. Angenommen, das zweite Argument hat eine führende Null, wenn nötig, das dritte Argument ist entweder aoder p. Behandelt das dritte Argument als indirekten Variablennamen und addiert es daher zur Anzahl der Stunden. Die Anzahl der Minuten bleibt davon unberührt und wird direkt ausgegeben. Wenn das Mischen verschiedener Formate in Ordnung ist, kann der letzte Speicherplatz gelöscht werden, um ein Byte zu speichern.

(Ziemlich ärgerlich, dass diese Frage nicht auf der Fragenseite angezeigt wurde, als ich sie ursprünglich geladen habe, und ich bin nur darauf gestoßen, weil ich nach einer anderen Frage gesucht habe.)