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

• Les failles standard sont interdites.
• Votre programme ne doit rien écrire STDERR.

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

où 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.

/* Configuration */

var QUESTION_ID = 81057; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 53406; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

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

CJam, 20 octets

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

Suite de tests.

Explication

Utilise le fait que 65536 (2 ¹⁶ ) 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.

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

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 @

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>

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)   

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

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.

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.

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

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