O dziwo, to proste zadanie nie wydaje się już istnieć, więc ...

Twoim zadaniem jest napisanie programu, który pobiera jako dane wejściowe 12 godzinny czas i konwertuje go na „czas wojskowy” lub 24-godzinny format czasu.

Dane wejściowe będą miały postać:

HH:MM am/pm

Chociaż dopuszczalne są niewielkie różnice:

• Przestrzeń oddzielająca am / pm od reszty czasu jest opcjonalna.

• Ostatnią częścią może być „am” / „pm” lub „a” / „p”.

• Wszelkie wielkie litery są w porządku.

Wyjściem będzie czas wprowadzony, przekształcony do formatu 24-godzinnego. Może to być liczba lub ciąg znaków.

Zarówno dla wejścia jak i wyjścia:

• Zera na pierwszym miejscu są opcjonalne. 0 w ostatnich 3 miejscach jest obowiązkowe.

• ogranicznikiem oddzielającym godziny i minuty może być „:”, „” (spacja) lub nic.

Inne notatki:

• Północ może być wyrażona jako 0000 lub 2400.

• Północ będzie uważana za „przed południem”, a południe za „po południu”.

Twój program może być funkcją lub pełnym programem i powinien albo zwrócić wynik, albo wypisać go na standardowe wyjście. Końcowe białe znaki są w porządku.

Przykłady (nie musisz obsługiwać każdego formatu):

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

To jest kod golfowy, więc wygrywa najmniejsza liczba bajtów. Ponieważ jest to tak trywialne do rozwiązania za pomocą wbudowanego, fajnie byłoby zobaczyć kod, który ręcznie to rozwiązuje (ale użycie wbudowanych jest w porządku).

Właśnie w celu wyjaśnienia, to nie są zobowiązane do wspierania wszelkich możliwych format. Obsługa tylko jednego wejścia i jednego formatu wyjściowego (do wyboru) jest w porządku. Chciałbym jednak ograniczyć format opisany powyżej (który jest już całkiem darmowy). {1134,'pm'}byłoby na przykład nie do przyjęcia.

V , 21 17 bajtów

Dzięki @DJMcMayhem za 4 bajty!

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

Wypróbuj online! Trwa to format HH:MMx, gdzie xjest albo aczy pi zwraca go w formacieHH:MM

Hexdump:

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

Wyjaśnienie:

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

15XO

Wypróbuj online!

Wyjaśnienie

Wbudowana funkcja: konwersja ciągu daty z automatycznym wykrywaniem formatu wejściowego i formatu wyjściowego 15, który odpowiada 'HH:MM'. Jest to równoważne z odpowiedzią Octave @ StewieGriffin .

Oktawa, 21 17 bajtów

Zaoszczędź 4 bajty dzięki Luisowi Mendo. Mógłbym podać format 15 zamiast 'HHMM'.

@(c)datestr(c,15)

Wyjaśnienie:

Jest to anonimowa funkcja biorąc ciąg cjako wkład w formacie: '11:34 AM'. datestrrozpoznaje format automatycznie jako jeden ze standardowych formatów daty i wysyła go w określonym formacie 15, czyli HH:MM.

Ponieważ określony format wyjściowy nie ma AMlub PMOctave automatycznie konwertuje go na tak zwany czas wojskowy.

Wypróbuj online.

Wersja nieużywająca datestr35 bajtów

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

Wyjaśnienie:

Pobiera ciąg wejściowy cw formacie 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

Lub inne podejście do 37 bajtów:

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

PowerShell , 23 20 19 bajtów

date "$args"-f HHmm

Wypróbuj online!

(Jeśli korzystasz z systemu Windows, możesz pominąć get-, aby dostać się do 19 bajtów. W TIO najwyraźniej wymaga to pełnej Get-Datenazwy).

Pobiera dane wejściowe jako ciąg $args[0], wykorzystuje je jako dane wejściowe do polecenia Get-Datecmdlet, które analizuje je w datetimeobiekt .NET . Jest to przekazywane z -fparametrem ormat, HHmmaby przekonwertować go na czas wojskowy (stolica HHokreśla czas 24-godzinny). Wynik jest niejawny.

Silnik analizujący jest dość solidny, więc dodatkowe dane wejściowe, takie jak 12amlub 12:00amsą dozwolone. Pobaw się z danymi wejściowymi w TIO i zobacz, co jeszcze działa.

( Zapisano 3 bajty dzięki @admalledd ... zapisałem kolejny bajt dzięki @briantist )

Python 2, 44 bajty

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

Format wejściowy:, 01:23amopcjonalny mi spacje po minutach
Format wyjściowy:123

Pyth, 21 20 bajtów

Aczd++*12}\pH%sG12PH

Pobiera dane wejściowe formularza 01 23ajako „01:23”. Początkowe 0 jest opcjonalne.
Dane wyjściowe mają postać 123, z pominięciem początkowego 0.

W pseudokodzie:

                         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

Wypróbuj online!

PHP, 35 32 bajtów

format wejściowy: bez rozróżniania wielkości liter, wymaga dwukropka i mformatu wyjściowego hhmm. wykorzystuje wbudowane:

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

pobiera dane wejściowe z argumentu pierwszego wiersza poleceń.

PHP, 45 bajtów, brak wbudowanych

format wejściowy (h)h:mm a(m)małe litery, format wyjściowy (h)hmm.

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

JavaScript (ES6), 40 bajtów

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

Dane wejściowe powinny być sformatowane w następujący sposób: 12:32 am

GNU Coreutils ( 18 16 bajtów)

Ze skryptu powłoki:

Nie akceptuje białych znaków na wejściu

W tym momencie równie dobrze może użyć 1 $ i zignorować dodatkowe argumenty.

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

Oryginalny

Aby zezwolić na białe znaki na wejściu,

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

C #, 46 bajtów

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

Ciągi znaków są pobierane jako dane wejściowe 12:00 AM

Wykonanie tej samej czynności, ale podciąganie danych wyjściowych z domyślnego wywołania ToString(Zakładając kulturę en-GB), jest o 3 bajty dłuższe na 49 bajtów:

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

date, 0 + 8 = 8 bajtów

Na temat korzystania z odpowiedniego narzędzia do pracy…

Pobiera dane wejściowe jako argument wiersza poleceń. Uruchom z +%H%M -d(kara 8 bajtów). Nie ma tutaj żadnego rzeczywistego programu; całą pracę wykonują argumenty wiersza poleceń. (To całkiem niezły dowód na to, że za argumenty wiersza poleceń grozi kara!)

Przykład:

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

Java 7, 138 106 105 104 bajtów

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

Wypróbuj online!

Dane wejściowe są rozdzielane dwukropkiem i mają spację między czasem a godziną przedpołudniową. Dane wyjściowe nie są rozdzielane dwukropkami.

-1 bajt dzięki Kevin Cruijssen

Japt , 14 bajtów

Ð"1/"+U s sG21

Wypróbuj online!

Działa to tylko w Chrome. Oto wersja, która działa we wszystkich przeglądarkach:

Ð"1/"³+U s sG21

Jeszcze raz dziękuję ETHproductions za pomoc!

Perl, 45 28 37 bajtów

28 37 bajtów

(c / o @Dada)

(Kod 36 bajtów, 1 bajt dla -pprzełącznika kompilatora )

Akceptuje 0145pmformaty typów z am / pm lub a / p. Wymagane zera wiodące na wejściach.

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

Moja oryginalna odpowiedź

(również delikatnie zmieniony)

(Kod 39 bajtów, 1 bajt dla -pprzełącznika kompilatora ).

Akceptuje tylko formę jak 0145p lub 0145a i żadnych innych, i wymaga perl -ptrybu do działania.

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 bajtów przed uruchomieniem, 321 bajtów używanych po uruchomieniu

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

Aby wprowadzić to na prawdziwym Commodore 64, musisz użyć skrótów BASIC, takich jak LE [shift] F dla LEFT$, M [shift] I dla MID$itp ... lub możesz spróbować CBM PRG STUDIO.

TI$Zmienna w Commodore Basic przedstawia czas w formacie 24-godzinnym jako GGMMSS po wydrukowaniu. Usunięcie spacji po numerze linii nie oszczędza pamięci, ponieważ Commodore BASIC i tak dodaje ją automatycznie po wyświetleniu listy programu po jej wprowadzeniu.

Podczas konwertowania liczby na ciąg za pomocą STR$Commodore BASIC doda spację (więc jeśli PRINT Azobaczysz spację przed wyświetleniem liczby), usunąłem spację otwierającą konwersję numeru na ciąg za pomocą RIGHT$polecenia. Możesz zapisać kilka bajtów, zmieniając wiersz zero na:

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

więc przed uruchomieniem programu musisz zadeklarować czas na konwersję:

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

W dowolnym momencie możesz zobaczyć aktualny czas za pomocą:

? TI$

Java, 171 bajtów

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

Format wejściowy to HH:MM a/pi format wyjściowy to HHMM. Nadużywanie faktu, że główna funkcja ma tablicę ciągów, aby podzielić dane wejściowe na 3 sekcje: godzinę, minutę i wskaźnik A / P.

Przykładowe dane wejściowe i wyjściowe:

Input: 01:02 a
Output: 0102

Input: 01:02 p
Output: 13:02

Input: 12:22 p
Output: 0022

Wersja bez golfa:

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 bajty

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

Posługiwać się:

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

Można to skrócić o kilka bajtów, jeśli nie zostanie użyty dwukropek jako separator.

C (brzęk) , 94 bajty

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

Wypróbuj online!

Jestem tutaj, aby się uczyć, więc wszelkie wskazówki dotyczące optymalizacji kodu są mile widziane.

@ Johan du Toit Dzięki za zaoszczędzenie kilku bajtów!

C, 87 72 bajtów

Zaoszczędź 15 bajtów dzięki @Johan du Toit

Wywołanie f()ze zmiennym ciągiem jako argumentem, wejściem jest wyjście.

Format to HH:MMa/p, gdzie a/pjest mała alub mała litera p. Nie ma spacji między czasem a specyfikatorem południka.

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

Wypróbuj na ideone .

tcl, 45 47

Teraz za pomocą wbudowanego:

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

Testowany na http://rextester.com/TSRXI8802, gdzie jest skrypt, który uruchamia go od 01:00 do 1259

SmileBASIC, 67 bajtów

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

Wkład: HH:MMa/p

Wydajność: HH MM

R, 68 bajtów

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

Odczytuje dane wejściowe ze standardowego wejścia i zakłada się, że jest w jednym z następujących formatów:

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

a dane wyjściowe mają format: [1] "00:00"

W większości przypadków strptime()dane wyjściowe mają format: "2017-01-06 12:00:00 CET"gdzie data jest datą lokalną. W związku z tym musimy użyć substr()tylko do zwrócenia czasu, jednak jeśli wejście jest północą (np. 12:00am) Wyjście jest tylko tym, "2017-01-06 CET"co jest przyczyną ifrzeczy na końcu (musi być jakieś bardziej sprytne obejście).

C, 159 152 bajtów

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

Format wejściowy: 07:30am

Pyke, 15 bajtów

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

Wypróbuj tutaj!

Mathematica, 33 bajty

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

Funkcja anonimowa. Pobiera ciąg jako dane wejściowe i zwraca ciąg jako dane wyjściowe. Działa z większością formatów, w tym hh:mm AM/PM.

JavaScript, 67 bajtów

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

Dane wejściowe są jak w przykładzie

Haskell, 61 znaków

Krótka wersja:

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

Format wejściowy: HHMM(a/p)gdzie (a/p)jest albo „a”, albo „p” bez nawiasów.

Format wyjściowy: (hs, MM)- krotka zawierająca godziny jako liczbę całkowitą i MM wciąż jako ciąg.

Przykład:

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

Dłuższa wersja (z bardziej przydatnymi nazwami i jednym podstawieniem 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 bajtów)

OK, CL nie ma być „zwięzły”, ale jestem zaskoczony, że nie jest to najbardziej gadatliwy w tym przypadku.

Oto wersja 122-bajtowa, która wymaga wprowadzenia stałej pozycji. 0145pmlub 145psą do zaakceptowania (z wiodącą spacją na pierwszej pozycji znaku).

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

Ładniejszy, ale większy

Korzystanie tylko z Common-Lisppakietu. Akceptuje (tylko) dane wejściowe w postaci liczb całkowitych (z lub bez wiodących 0), literałów :, dwucyfrowych minut i opcjonalnego końcowego amlub pm(tylko małymi literami). Zezwala na odstępy między godzinami i wokół AM / PM, ale nie bezpośrednio po :.

(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 definicja funkcji:

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

Usunięto zaciemnienie:

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

Siatkówka , 61 60 bajtów

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

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

Dane wejściowe są podawane bez dwukropka oddzielającego, obowiązkowe prowadzenie 0i używanie tylko alub pzamiast amlub pmnp. 0134aJest 01:34. Dane wyjściowe w prostym czasie wojskowym przy użyciu 0000 jako północy. (Mógłbym zaoszczędzić trochę bajtów, jeśli pozwolę na konwersję, na przykład 12:30 rano 2430, ale wątpię, czy to dopuszczalne).

Wypróbuj online!

Wyjaśnienie

Pierwsze dwa przypadki dotyczą godzin „12”, ponieważ rano / wieczorem zmienia się na 12:

^12(.*)a
00$1

Jeśli czas jest między północą (12 rano) a 1 rano, zmień go na 00 zamiast 12 i usuń a.

^(12.*)p
$1

Jeśli czas jest między południem (12 po południu) a 13 po południu, usuń p, aby uzyskać 24 godziny.

Na każdą inną godzinę:

a
 

Jeśli jest godzina, po prostu usuń, aaby uzyskać 24 godziny.

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

Jeśli jest godzina po południu, usuń p. Konwertuj składnik godziny na unary, dodaj 12 i przekonwertuj z powrotem na dziesiętne. Pozostaw minuty bez zmian.

Partia, 40 bajtów

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

Pobiera dane wejściowe jako trzy argumenty. Zakłada się drugi argument zerem, gdzie jest to konieczne, trzeci argument jest albo aczy p. Działa, traktując trzeci argument jako nazwę zmiennej pośredniej, dodając go do liczby godzin; liczba minut pozostaje niezmieniona, więc jest po prostu wyprowadzana bezpośrednio. Jeśli mieszanie różnych formatów jest w porządku, ostatnią spację można usunąć, aby zapisać bajt.

(Raczej irytujące, to pytanie nie pojawiło się na stronie pytań, gdy je pierwotnie załadowałem, i natknąłem się na nie, ponieważ szukałem innego pytania.)