Convertisseur de temps de 12 heures à 24 heures


27

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


Quels formats devons-nous prendre en charge? Juste un?
redstarcoder

@redstarcoder Oui. Tout format conforme aux exigences ci-dessus est correct, mais comme indiqué ci-dessus dans les cas d'exemple, vous n'êtes pas obligé de prendre en charge tous les formats. Un seul format d'entrée et un seul format de sortie sont très bien.
Carcigenicate

nos formats sont-ils autorisés à exiger des zéros non significatifs? Par exemple, 01:54pmcela fonctionnerait, mais 1:54pmpas?
FlipTack

Oui. Vous pouvez choisir le format d'entrée requis.
Carcigenicate

Sommes-nous autorisés à inclure des secondes dans nos entrées et sorties?
12Me21

Réponses:


8

V , 21 17 octets

Merci @DJMcMayhem pour 4 octets!

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

Essayez-le en ligne! Cela prend le format HH:MMxxest 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

L'entrée sera toujours en [1-12]droit? Dans ce cas, je pense que vous pourriez faire ó^12/0au lieu decw^R=^R"%12
DJMcMayhem

1
En outre, vous pouvez utiliser la "commande globale" pour appliquer une commande aux lignes correspondant à une expression régulière, ce qui est plus court que la rupture d'une macro. çp/12^Aqui équivaut à :g/p/norm 12<C-a>in vim
DJMcMayhem

J'ai accepté cela parce que c'était la réponse ayant obtenu le score le plus bas qui indiquait clairement qu'il n'utilisait pas de système intégré (même si je n'ai pas interdit de les utiliser). Si quelqu'un a un problème avec ce choix, je peux changer ma réponse pour être juste. Je pense que cette réponse est la plus méritante.
Carcigenicate


10

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

7

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 )


Devrait être en mesure d'éliminer l'espace entre $args[0]et -f, ainsi que de retirer les guillemets simples autour du format str: date $args[0]-f HHmm. Au moins, cela fonctionne sur mon PowerShell ...
admalledd

@admalledd Pour pleurer à voix haute, j'oublie toujours ces citations. Sérieusement, je pense que chaque fois que j'ai utilisé Get-Dateavec -f, quelqu'un m'a rappelé que vous n'avez pas besoin des citations. Et bon appel à la suppression de l'espace également, car l'analyseur traite le ]comme la fin d'un jeton. Merci!
AdmBorkBork

5

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


5

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!


4

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

4
Pourquoi le downvote?
Titus

Je ne fais que spéculer, mais c'est peut-être parce que vous avez utilisé PHP et que le downvoter n'aime pas PHP? : p
bash0r

3

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


3

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

3

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

3

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

3

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


Bout aussi court que possible pour Java, 20% du code étant des qualificatifs de package.
Urne de poulpe magique

Les règles stipulent ceci " Pour l'entrée et la sortie: - les 0 en premier lieu sont facultatifs. Les 0 aux 3 derniers endroits sont obligatoires. ", Ce qui signifie que vous pouvez passer HHmmà Hmm.
Kevin Cruijssen

@KevinCruijssen belle prise!
Poke

2

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!


2

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

Bienvenue sur PPCG. Belle première réponse. Vous pouvez utiliser des commutateurs, mais ils comptent dans votre bytecount (comme expliqué ici ). Dans votre cas, ce serait +1 octet (car seul -pest nécessaire) si vous modifiez les guillemets simples pour les guillemets doubles.
Dada

Merci. Impossible de trouver cette FAQ, vous vous demandez si l'équipe Stack Exchange pourrait l'épingler sur la page de réponse ou quelque chose?
BRPocock

OK, je suis Perling depuis la série 4 et cela me fait mal à la tête, vous devriez vous en attribuer le mérite et vous poster avec celui-ci. ☺
BRPocock

Je pense que cela devrait couvrir maintenant?
BRPocock

J'ai fait une erreur, cette solution ne fonctionnera pas lorsque les minutes sont comprises entre 0 et 9. Ce code fonctionne alors: s/(..)(.)$//;$_=$_%12+12*(p eq$2).$1(37 octets). Et en passant, votre première solution peut être un peu étudiée: s/(..)(..)([ap])/$1%12+12*($3eq"p").$2/e(40 octets)
Dada

2

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$

Jouer au golf à code sur des machines 8 bits est vraiment intéressant car il montre tout ce qui est fait pour un programmeur moderne sans même avoir à y penser.
Shaun Bebbers

2

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

Je n'avais pas vu enumutilisé pour tenir le main. Nice :)
Robert Benson

Vous pouvez omettre un espace dans la signature de la méthode principale: public static void main (String [] a) {...
staticmethod

2

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


Le délimiteur du côlon est facultatif.
Carcigenicate

Oui, mais ça n'a pas l'air bien.
idrougge

Étant donné que c'est un défi de golf de code, si vous avez la possibilité d'un programme plus long avec une jolie sortie, ou un programme plus court avec une sortie plus laide, choisissez ce dernier. Personne ne te jugera.
Carcigenicate

2

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!


Vous n'avez pas à tester si b == 'm' et vous pouvez le raccourcir beaucoup plus en utilisant les instructions inline if:printf("%02d:%02d", (a=='p' ? 12 : 0) + (h %12), m);
Johan du Toit

1
@JohanduToit Ce que j'entre est 6: 00pc? :)
Abel Tom

1
Cela causera un préjudice irréparable au continuum espace-temps.
Johan du Toit


2

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 .


vous pouvez enregistrer quelques octets en utilisant ce qui suit: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

Suggérer à la (p[5]!=97)*12;place de(p[5]^97?12:0);
plafondcat


2

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


1

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


Je voulais vraiment trouver un moyen plus court avec lubridate, mais le nom du paquet est trop long (entre autres problèmes).
BLT

1

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



1

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.


1

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


Ne fonctionne pas pour 12:00 amou12:00 pm
Herman L

1

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

1

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

1

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.


1

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

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.