Étonnamment, cette tâche simple ne semble pas déjà exister, alors ...

Votre tâche consiste à écrire un programme qui prend en entrée une heure de 12 heures, et la convertit en "heure militaire", ou au format 24 heures.

L'entrée se fera sous la forme:

HH:MM am/pm

Bien que de légères variations soient autorisées:

• L'espace séparant l'am / pm du reste du temps est optionnel.

• La dernière partie peut être "am" / "pm" ou "a" / "p".

• Toute capitalisation est très bien.

La sortie sera l'heure entrée, transformée en format 24 heures. Il peut s'agir d'un nombre ou d'une chaîne.

Pour l'entrée et la sortie:

• Les 0 en premier lieu sont facultatifs. Les 0 aux 3 dernières places sont obligatoires.

• le délimiteur séparant les heures et les minutes peut être un ":", "" (un espace) ou rien.

Autres notes:

• Minuit peut être exprimé en 0000 ou 2400.

• Minuit sera considéré comme "am", tandis que midi sera considéré comme "pm".

Votre programme peut être une fonction, ou un programme complet, et doit soit retourner le résultat, soit le sortir vers la sortie standard. La fin des espaces blancs est correcte.

Exemples (vous n'êtes pas obligé de prendre en charge tous les formats):

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

C'est le golf de code, donc le plus petit nombre d'octets gagne. Étant donné que c'est tellement trivial à résoudre en utilisant un intégré, il serait bien de voir du code qui résout manuellement cela (mais l'utilisation des intégrés est très bien).

Juste pour clarifier, vous n'êtes pas obligé de prendre en charge tous les formats possibles. La prise en charge d'une seule entrée et d'un seul format de sortie (de votre choix) convient parfaitement. Je voudrais cependant limiter le format comme indiqué ci-dessus (qui est déjà assez gratuit). {1134,'pm'}, par exemple, serait inacceptable.

V , 21 17 octets

Merci @DJMcMayhem pour 4 octets!

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

Essayez-le en ligne! Cela prend le format HH:MMxoù xest soit aou p, et le renvoie au formatHH:MM

Hexdump:

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

Explication:

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

15XO

Essayez-le en ligne!

Explication

Fonction intégrée: conversion de chaîne de date avec détection automatique du format d'entrée et du format de sortie 15, ce qui correspond à 'HH:MM'. Cela équivaut à la réponse Octave de @ StewieGriffin .

Octave, 21 17 octets

Enregistré 4 octets grâce à Luis Mendo. Je pourrais spécifier le format numéro 15 au lieu de 'HHMM'.

@(c)datestr(c,15)

Explication:

Ceci est une fonction anonyme prenant une chaîne cen entrée sur le format: '11:34 AM'. datestrreconnaît automatiquement le format comme l'un des formats de date standard et le sort au format spécifié numéro 15, qui est HH:MM.

Étant donné que le format de sortie spécifié n'a pas AMou PMOctave le convertit automatiquement en ce que vous appelez l'heure militaire.

Essayez-le en ligne.

Une version n'utilisant pas en datestrutilisant 35 octets

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

Explication:

Prend une chaîne d'entrée csur le 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

Ou, une approche différente pour 37 octets:

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

PowerShell , 23 20 19 octets

date "$args"-f HHmm

Essayez-le en ligne!

(Si vous êtes sous Windows, vous pouvez omettre le get-, pour descendre à 19 octets. Sur TIO, il nécessite apparemment le Get-Datenom complet .)

Prend l'entrée sous forme de chaîne $args[0], l'utilise comme entrée de l' Get-Dateapplet de commande, qui l'analyse en un datetimeobjet .NET . Cela est passé avec le -fparamètre ormat de HHmmpour le convertir en heure militaire (la capitale HHspécifie l'heure de 24 heures). La sortie est implicite.

Le moteur d'analyse est assez robuste, donc des entrées supplémentaires comme 12amou 12:00amsont également autorisées. Jouez avec l'entrée sur TIO et voyez ce qui fonctionne.

( Enregistré 3 octets grâce à @admalledd ... enregistré un autre octet grâce à @briantist )

Python 2, 44 octets

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

Format d'entrée:, en 01:23amoption met espaces après les minutes
Format de sortie:123

Pyth, 21 20 octets

Aczd++*12}\pH%sG12PH

Prend l'entrée du formulaire 01 23acomme "01:23 am". Le 0 initial est facultatif.
La sortie est de la forme 123, avec le 0 initial omis.

En 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

Essayez-le en ligne!

PHP, 35 32 octets

format d'entrée: insensible à la casse, nécessite deux-points et le mformat de sortie hhmm. utilise des fonctions intégrées:

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

prend l'entrée du premier argument de ligne de commande.

PHP, 45 octets, aucun intégré

format d'entrée en (h)h:mm a(m)minuscules, format de sortie (h)hmm.

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

JavaScript (ES6), 40 octets

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

L'entrée doit être formatée comme: 12:32 am

GNU Coreutils ( 18 16 octets)

À partir d'un script shell:

N'accepte pas les espaces dans l'entrée

À ce stade, peut également utiliser $ 1 et ignorer les arguments supplémentaires.

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

Pour autoriser les espaces dans l'entrée,

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

C #, 46 octets

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

Les chaînes sont prises en entrée comme 12:00 AM

Faire la même chose mais sous-chaîne sur la sortie de l'appel par défaut à ToString(en supposant une culture de en-GB) est 3 octets de plus pour 49 octets:

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

date, 0 + 8 = 8 octets

Au sujet de l'utilisation du bon outil pour le travail…

Prend l'entrée comme argument de ligne de commande. Courez avec +%H%M -d(pénalité de 8 octets). Il n'y a pas de programme réel ici; l'ensemble du travail est effectué par les arguments de la ligne de commande. (Ceci est une assez bonne démonstration de la raison pour laquelle il existe une pénalité pour les arguments de ligne de commande!)

Exemple:

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

Java 7, 138 106 105 105 104 octets

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

Essayez-le en ligne!

L'entrée est délimitée par deux points et a un espace entre l'heure et le matin / l'après-midi. La sortie n'est pas délimitée par deux points.

-1 octet grâce à Kevin Cruijssen

Japt , 14 octets

Ð"1/"+U s sG21

Essayez-le en ligne!

Cela ne fonctionne que sur Chrome. Voici une version qui fonctionne dans tous les navigateurs:

Ð"1/"³+U s sG21

Merci encore à ETHproductions pour l'aide!

Perl, 45 28 37 octets

28 37 octets

(a / s @Dada)

(Code de 36 octets, 1 octet pour le -pcommutateur du compilateur )

Accepte 0145pmles formats de type, avec am / pm ou a / p. Zéros de tête sur les entrées nécessaires.

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

Tester:

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

Ma réponse originale

(également légèrement révisé)

(Code de 39 octets, 1 octet pour le -pcommutateur du compilateur .)

Accepte uniquement le formulaire comme 0145p ou 0145a, et aucun autre, et nécessite le perl -pmode pour fonctionner.

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

tester:

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

Commodore 64 BASIC, 301 octets avant l'exécution, 321 octets utilisés une fois l'exécution

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

Pour entrer cela sur un vrai Commodore 64, vous devrez utiliser les abréviations de mots clés BASIC, telles que LE [shift] F pour LEFT$, M [shift] I pour MID$etc ... ou vous pouvez essayer CBM PRG STUDIO.

La TI$variable dans Commodore BASIC présente l'heure au format 24 heures au format HHMMSS lors de l'impression. La suppression de l'espace après le numéro de ligne n'économise pas de mémoire car le Commodore BASIC ajoute automatiquement de l'espace de toute façon lorsque vous listez le programme après l'avoir entré.

Lors de la conversion d'un nombre en chaîne avec STR$, le Commodore BASIC ajoutera de l'espace (donc si vous PRINT Averrez un espace avant que le nombre ne s'affiche), j'ai supprimé l'espace d'ouverture sur le nombre en conversion de chaîne avec la RIGHT$commande. Vous pouvez économiser quelques octets en modifiant la ligne zéro pour:

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

vous devrez donc déclarer votre temps de conversion avant d'exécuter le programme, comme suit:

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

À tout moment par la suite, vous pouvez voir l'heure actuelle avec:

? TI$

Java, 171 octets

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

Le format d'entrée est HH:MM a/pet le format de sortie est HHMM. Abuser du fait que la fonction principale dispose d'un tableau de chaînes pour diviser l'entrée en 3 sections: heure, minute et indicateur a / p.

Exemple d'entrée et de sortie:

Input: 01:02 a
Output: 0102

Input: 01:02 p
Output: 13:02

Input: 12:22 p
Output: 0022

Version non golfée:

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 octets

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

Utilisation:

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

Cela pourrait être raccourci de quelques octets si un deux-points comme délimiteur n'était pas utilisé.

C (clang) , 94 octets

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

Essayez-le en ligne!

Je suis ici pour apprendre, donc tous les conseils sur la façon d'optimiser le code sont les bienvenus.

@ Johan du Toit Merci d'avoir économisé quelques octets!

C, 87 72 octets

15 octets enregistrés grâce à @Johan du Toit

Appelez f()avec une chaîne mutable comme argument, l'entrée est la sortie.

Le format est HH:MMa/p, où a/pest en minuscule aou en minuscule p. Aucun espace entre l'heure et le spécificateur méridien n'est autorisé.

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

Essayez-le sur ideone .

tcl, 45 47

Maintenant, en utilisant un intégré:

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

Testable sur http://rextester.com/TSRXI8802 où il existe un script qui l'exécute de 01h00 à 1259h00

SmileBASIC, 67 octets

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

Contribution: HH:MMa/p

Sortie: HH MM

R, 68 octets

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

Lit l'entrée de stdin et il est supposé être dans l'un des formats suivants:

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

et la sortie est au format: [1] "00:00"

Dans la plupart des cas, la strptime()sortie est au format: "2017-01-06 12:00:00 CET"où la date est la date locale. En tant que tel, nous devons utiliser substr()pour renvoyer uniquement l'heure, cependant, si l'entrée est minuit (par exemple 12:00am), la sortie n'est que "2017-01-06 CET"ce qui est la raison de la ifchose à la fin (il doit y avoir une solution de contournement plus intelligente).

C, 159 152 octets

#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 d'entrée: 07:30am

Pyke, 15 octets

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

Essayez-le ici!

Mathematica, 33 octets

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

Fonction anonyme. Prend une chaîne en entrée et renvoie une chaîne en sortie. Fonctionne avec la plupart des formats, y compris hh:mm AM/PM.

JavaScript, 67 octets

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

L'entrée est comme dans l'exemple

Haskell, 61 caractères

Version courte:

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

Format d'entrée: HHMM(a/p)où (a/p)est soit 'a' soit 'p' sans parenthèses.

Format de sortie: (hs, MM)- un tuple contenant les heures sous forme d'entier et MM toujours sous forme de chaîne.

Exemple:

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

Version plus longue (avec des noms plus utiles et une substitution 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 commun ( 151 122 octets)

OK, CL n'est pas censé être "laconique" mais je suis juste surpris que ce ne soit pas le plus bavard pour celui-ci.

Voici la version 122 octets, qui nécessite une entrée à position fixe. 0145pmou 145psont acceptables (avec l'espace de tête dans la première position de caractère).

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

Plus agréable mais plus grand

Utiliser uniquement le Common-Lisppackage. Accepte (uniquement) la saisie sous forme d'heures entières (avec ou sans interligne 0), littérales :, minutes à deux chiffres et facultatif à la fin amou pm(en minuscules uniquement). Autorise les espaces autour de l'heure et autour de l'AM / PM, mais pas directement après le :.

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

Tester:

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 définition de la fonction:

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

Désobscurci:

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

Rétine , 61 60 octets

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

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

L'entrée est donnée sans séparer les deux-points, interligne obligatoire 0et en utilisant uniquement aou à la pplace de amou pm, par exemple 0134aest 01h34. Sorties en temps militaire simple en utilisant 0000 comme minuit. (Je pourrais économiser quelques octets si je suis autorisé à convertir, par exemple, 12h30 en 2430, mais je doute que cela soit acceptable).

Essayez-le en ligne!

Explication

Les deux premiers cas concernent les "12" heures, car am / pm est inversé pour 12:

^12(.*)a
00$1

Si l'heure est comprise entre minuit (12 h) et 1 h, remplacez-la par 00 au lieu de 12 et supprimez le a.

^(12.*)p
$1

Si l'heure est comprise entre midi (12 h) et 13 h, retirez le p pour obtenir simplement l'heure de 24 heures.

Pour toute autre heure:

a
 

Si l'heure est am, retirez simplement le apour obtenir l'heure de 24 heures.

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

Si l'heure est pm, retirez le p. Convertissez le composant horaire en unaire, ajoutez 12 et reconvertissez en décimal. Laissez les minutes inchangées.

Lot, 40 octets

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

Prend l'entrée comme trois arguments. Suppose que le deuxième argument a un zéro en tête si nécessaire, le troisième argument est soit aou p. Fonctionne en traitant le troisième argument comme un nom de variable indirecte, l'ajoutant donc au nombre d'heures; le nombre de minutes n'est pas affecté, il est donc simplement émis directement. Si le mélange de différents formats est OK, le dernier espace peut être supprimé pour enregistrer un octet.

(Plutôt ennuyeux, cette question n'apparaissait pas sur la page des questions lorsque je l'ai chargée à l'origine, et je ne suis tombée dessus que parce que je cherchais une autre question.)