Quel est le temps binaire?


14

Quel est le temps binaire?

Tout le monde sait quelle est l'heure normale. Il est là-haut en haut à droite (ou partout où vous le mettez) de votre écran. Mais une question que les gens semblent rarement se poser est la suivante: quel est le temps binaire ?

Temps binaire

Le temps binaire (True Binary Time) fonctionne en lisant d'abord le bit le plus significatif (MSB) du nombre. Si ce nombre est 0, le temps exprimé est avant midi. Si ce nombre est 1, le temps exprimé est après midi. Le bit suivant divise la moitié de la journée, le premier bit exprimé en deux moitiés plus égales, cette fois de 6 heures. Le bit suivant se divise en 3 heures, les 90 minutes suivantes, etc. Des temps comme 12:00:00, où il semble que ce ne devrait être ni l'un ni l'autre, deviennent 1.

Je ne peux que comprendre cet étrange système de synchronisation, j'ai donc besoin d'un programme pour le convertir pour moi. Mais comme les nombres binaires sont Base-2 et 2 est un petit nombre, votre programme doit être aussi court que possible.

Exigences

  • Votre programme doit prendre un certain temps (au format 24 heures) comme entrée et sortie du numéro d'heure binaire correspondant.
  • Le numéro de sortie doit avoir une précision de 16 bits (le nombre doit être composé de 16 chiffres).
  • Vous ne pouvez pas utiliser une fonction intégrée qui effectue toute cette conversion pour vous.
  • Vous devriez plancher s'il doit être arrondi.

Règles

Cas de test

00:00:00==> 0000000000000000
12:00:00==> 1000000000000000
01:30:00==> 0001000000000000
10:33:06==> 0111000010001101
09:57:30==> 0110101000111000
06:00:00==> 0100000000000000
18:00:00==>1100000000000000

Notation

Pour gagner, comme je l'ai mentionné plus tôt, vous devez avoir le moins d'octets.

Soumissions

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre, en utilisant le modèle de démarque suivant:

# Language Name, N bytes

Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

# Perl, 43 + 2 (-p flag) = 45 bytes

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Classement

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.


3
Puis-je entrer en tant que [hour, minute, second]? Nous n'aimons pas restreindre le format d'entrée.
Leaky Nun

2
Comment ça 09:57:30fait 0110110000000000?
Leaky Nun

2
16 bits ne peuvent représenter que 65536 valeurs. Il y a 86400 secondes par jour. Comment représenter tout ce qui ne correspond pas exactement à une représentation binaire?
PurkkaKoodari

Pouvons-nous renvoyer le résultat sous la forme d'une liste de 16 chiffres?
Adám

@ Adám Oui, vous le pouvez.
George Gibson

Réponses:


1

MATL , 15 octets

YOtk-KWW*k16&YB

Utilise une fonction intégrée pour convertir une chaîne représentant l'heure en un numéro de date / heure série, ce qui est autorisé par le défi.

Essayez-le en ligne!

Explication

YO       % Input time string. Convert to serial date/time. Time is fractional part
tk-      % Duplicate, round down, subtract. This keeps fractional part only
KWW      % 34, 2 raised to, 2 raised to (`16W` would require an extra space)
*        % Multiply
k        % Round down
16&YB    % Convert to binary string with 16 digits. Display

5

CJam, 20 octets

l':/60b9m<675/2bG0e[

Suite de tests.

Explication

Utilise le fait que 65536 (2 16 ) sur 86400 (le nombre de secondes dans une journée) se simplifie à 512 sur 675.

l     e# Read input.
':/   e# Split around ':', so we get ["hh" "mm" "ss"].
60b   e# Interpret as base-60 digits, which computes hh*60^2 + mm*60 + ss,
      e# i.e. it computes the total number of seconds. Note that this implicitly
      e# converts all three strings to integers.
9m<   e# Bitwise left-shift by 9 positions, which is the same as multiplying by
      e# 2^9 = 512.
675/  e# Divide by 675, flooring the result.
2b    e# Convert to binary.
G0e[  e# Left-pad with zeros to 16 digits.

3

Pyth, 31 27 octets

.[\016.Bs*512cisMcQ\:60 675

Suite de tests.

Convertit l'entrée en nombre de secondes écoulées, multiplie par un facteur de 2^16 / 24*60*60, puis plancher et convertit en binaire 16 bits.

Enregistré 4 octets en simplifiant 65536/86400en 512/675(stupide moi).

Entrée sortie

00:00:00    0000000000000000
11:00:00    0111010101010101
12:00:00    1000000000000000
01:30:00    0001000000000000
10:33:06    0111000010001101
09:57:30    0110101000111000
06:00:00    0100000000000000
18:00:00    1100000000000000
23:59:59    1111111111111111

Pouvez-vous justifier « et ensuite plancher »?
Peter Taylor

@PeterTaylor Que dois-je faire à la place?
Leaky Nun

4
Attendez que la spécification ait été levée avant de poster une réponse.
Peter Taylor

@PeterTaylor La bonne façon d'arrondir est évidente par 10:33:06.
Adám

@ Adám, pas vraiment, car cela donne la même sortie avec plancher et arrondi au plus proche.
Peter Taylor

3

TSQL (sqlserver 2012), 103 octets

DECLARE @d datetime = '10:33:06'

DECLARE @ char(16)='',@x INT=cast(@d as real)*131072WHILE
len(@)<16SELECT @x/=2,@=concat(@x%2,@)PRINT @

Essayez-le en ligne

Non golfé

DECLARE @d datetime = '10:33:06'

DECLARE @ char(16)='',
        @x INT=cast(@d as real)*131072
WHILE len(@)<16
SELECT @x/=2,@=concat(@x%2,@)
PRINT @

TSQL (sqlserver 2012), 119 106 octets

Inclut également une version différente sans la variable @x, mais elle était plus longue de quelques octets. Y compris la version non golfée pour les personnes intéressées:

DECLARE @d datetime = '23:59:59'

DECLARE @ varchar(16) =''
WHILE LEN(@)<16
SET @+=LEFT(CAST(@d as decimal(9,9))*2*POWER(2,LEN(@))%2,1)
PRINT @

Ça n'a pas l'air golfé. Vous ne pouvez pas supprimer beaucoup d'espaces?
Adám

@ Adám c'est très gogo, j'ai utilisé des méthodes différentes de la norme pour raccourcir le script et j'ai même essayé une méthode différente. Je viens d'avoir un espace blanc accidentel lors de la copie de ma réponse dans codegolf (un seul supplémentaire). Je voulais y mettre un saut de ligne, mais j'ai décidé de le mettre après WHILE à la place. Supprimer l'espace et me demander si vous m'avez vraiment rétrogradé pour cet espace supplémentaire unique
t-clausen.dk

@ Adám et si vous regardez la deuxième méthode, elle n'est pas jouée au golf (sauf le nombre de caractères), car ce n'est pas ma vraie réponse. Juste une autre méthode plus calculatrice pour le résoudre
t-clausen.dk

3
Non, je n'ai pas downvote. C'est probablement quelqu'un qui a un principe de rétrograder toutes les réponses qui sont affichées avant que le PO clarifie les questions de règles en suspens. Tout sauf la toute dernière réponse a exactement un downvote. (C'était probablement Peter Taylor, car il était ici pour la dernière fois juste avant ce poste, et il s'en plaignait.) Vous pouvez le voir lorsque vous aurez suffisamment de représentants. Ici, en avoir!
Adám

2

JavaScript (ES6), 72 76 octets

Éditer 4 octets de sauvegarde thx @Neil

Pas encore clair sur l'arrondissement. Celui-ci tronque et c'est ok.

t=>(t.split`:`.map(v=>t=+v+60*~~t),t*512/675|65536).toString(2).slice(1)

Tester

f=t=>(t.split`:`.map(v=>t=+v+60*~~t),t*512/675|65536).toString(2).slice(1)

function test() {
  var v=I.value
  R.textContent=f(v)
}

test()


;`00:00:00 ==> 0000000000000000
12:00:00 ==> 1000000000000000
01:30:00 ==> 0001000000000000
10:33:06 ==> 0111000010001101
09:57:30 ==> 0110101000111000
06:00:00 ==> 0100000000000000
18:00:00 ==> 1100000000000000`
.split('\n').forEach(t=>{
  [i,k]=t.split(' ==> ')
  r=f(i)
  ok=r==k
  O.textContent += (ok ? 'OK ':'KO ')+ i + ' -> ' + r + (ok? '\n' : ' Expected '+k+'\n')
})
<input id=I value='12:34:56' oninput=test()>
<span id=R></span>
<pre id=O></pre>


j'essaie de comprendre pourquoi cela a été rejeté
t-clausen.dk

t=>([h,m,s]=t.split`:`,(+h+m/60+s/3600)*8192/3|65536).toString(2).slice(1)vous économise 2 octets, mais reduceva un octet plus loin:t=>(t.split`:`.reduce((n,m)=>+m+n*60)*512/675|65536).toString(2).slice(1)
Neil

Downvote sans commentaire n'est pas cool, a voté
t-clausen.dk

@Neil merci beaucoup! Et avec .map 1 octet de plus enregistré
edc65

Huh, je me demandais d'où vous alliez obtenir le 0 pour la carte ...
Neil

1

APL (Dyalog) , 24 21 octets

Les règles ont maintenant été clarifiées.

Demande l'heure en tant que liste à 3 éléments.

(16/2)⊤⌊512×675÷⍨60⊥⎕

Modifier: mis à jour () pour correspondre au nouveau résultat pour 10:33:06.

Essayez-le en ligne!

 demande de saisie

60⊥ évaluer en base 60

675÷⍨ diviser par 675

512× multiplier par 512

 sol

()⊤  Convertir (mnémonique: la base à l'envers est anti-base) le système numérique suivant:

16/2 répliquer 2 seize fois (c'est-à-dire binaire 16 bits)   


0

Q, 32 octets

48_0b\:_(512%675)*60/:"I"$":"\:

Tester

   t "00:00:00"
0000000000000000b
   t "12:00:00"
1000000000000000b
   t "01:30:00"
0001000000000000b
   t "10:33:06"
0111000010001101b
   t "09:57:30"
0110101000111000b
   t "06:00:00"
0100000000000000b
   t "18:00:00"
1100000000000000b
  • Afin de réduire l'encombrement de l'affichage, je suppose une légère modification de l'expression originale, qui donne un nom tau lambda

  • le suffixe b indique le binaire

Explication

REMARQUE: lire de gauche à droite, évaluer de droite à gauche

Lit comme: 48 baisse de la représentation binaire du plancher de 512 diviserb par 675 et multiplié par 60 scalarFromVector sur un entier transtypé à partir de divisions à ":" chaîne d'origine

Évaluation:

":"\:x divise la chaîne x (argument implicite du lambda) au caractère ":" (Q utilise "" pour désigner le caractère)

"I"$x cast chaîne (s) x en int (s) -> heures, minutes, secondes

60/:x utilise la base 60 pour calculer une valeur unique à partir d'une séquence d'entiers -> secondes au total

(512%675)*x calcule le ratio 512%675 (% est divisé) et multiplie les secondes. 512% 675 est la forme simplifiée de la fraction (totalSecondsPerDay% 64K)

_ x indique le plancher du flotteur x

0b\:x calcule la représentation binaire de x (64 bits)

48_ x déposer les 48 premiers bits, nous avons donc notre représentation 16 bits

Exemple (x = "01:30:00"). NOTE.- "/" indique un commentaire à la fin de la ligne

":"\:"01:30:00" /-> ("01";"30";"00") "I"$ /-> 1 30 0 60/: /-> 5400 (512%675)* /-> 4096.0 _ /-> 4096 0b\: /-> 0000000000000000000000000000000000000000000000000001000000000000b 48_ /-> 0001000000000000b


0

Rubis, 75 octets

h,m,s=t.split(':').map &:to_i;((h*3600+m*60+s<<9)/675).to_s(2).rjust 16,'0'

J'ai l'impression qu'il doit y avoir une méthode plus courte pour convertir le temps en secondes, mais c'est tout ce à quoi je pouvais penser.


0

Python, 45 octets

lambda h,m,s:bin((s+m*60+h*3600)*512/675)[2:]

Je suis venu avec le 512/675facteur moi-même, puis j'ai vu que d'autres faisaient de même.


0

C, 91 octets

f(h,m,s,n,i){i=0;n=(s+m*60+h*3600)*512/675;while(i<16)printf((n&32768)?"1":"0"),n<<=1,i++;}

0

PHP, 47 46 43 octets

Utilise le codage IBM-850.

printf(~┌Ø,strtotime($argn.UTC,0)*512/675);

Courez comme ceci:

echo "18:00:00" | php -nR 'printf(~┌Ø,strtotime($argn.UTC,0)*512/675);';echo

Tweaks

  • Enregistrement d'un octet à l'aide du codage IBM-850.
  • Enregistré 3 octets en utilisant $argn
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.