Qual é o tempo binário?

Todo mundo sabe que horas são. Está lá em cima, no canto superior direito (ou onde quer que você o coloque) da tela. Mas uma pergunta que as pessoas raramente parecem se perguntar é: Qual é o tempo binário ?

Tempo binário

O tempo binário (tempo binário verdadeiro) funciona lendo primeiro o bit mais significativo (MSB) do número. Se esse número for 0, o horário expresso é antes do meio dia. Se esse número for 1, o tempo expresso será após o meio dia. O próximo bit divide a metade do dia em que o primeiro bit é expresso em mais duas metades iguais, desta vez de 6 horas. O bit a seguir se divide em 3 horas, nos próximos 90 minutos e assim por diante. Tempos como 12:00:00, onde parece que não deveria ser nenhum, se tornam 1.

Só consigo entender esse estranho sistema de tempo, então preciso de um programa para converter isso para mim. Mas como os números binários são Base-2 e 2 é um número pequeno, seu programa deve ser o mais curto possível.

Exigências

• Seu programa deve levar um tempo (como 24 horas) como entrada e saída do número de tempo binário correspondente.
• O número de saída deve ter precisão de 16 bits (o número deve ter 16 dígitos).
• Você não pode usar um built-in que faça toda essa conversão para você.
• Você deve andar se precisar ser arredondado.

Regras

• As brechas padrão são proibidas.
• Seu programa não deve escrever nada para STDERR.

Casos de teste

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

Pontuação

Para ganhar, como mencionei anteriormente, você deve ter o mínimo de bytes.

Submissões

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet do placar de líderes:

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

Entre os melhores

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

/* 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 bytes

YOtk-KWW*k16&YB

Usa um builtin para converter uma sequência que representa a hora em um número de data / hora de série, o que é permitido pelo desafio.

Experimente online!

Explicação

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 bytes

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

Suíte de teste.

Explicação

Utiliza o fato de que 65536 (2 ¹⁶ ) acima de 86400 (o número de segundos em um dia) simplifica para 512 acima de 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.

Pitão, 31 27 bytes

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

Suíte de teste.

Converte a entrada em um número de segundos passados, multiplique por um fator de 2^16 / 24*60*60e, em seguida, aplique e converta em binário de 16 bits.

Salvo 4 bytes, simplificando 65536/86400em 512/675(me estúpido).

Entrada / saída

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 bytes

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

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

Experimente online

Ungolfed

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 bytes

Também incluiu uma versão diferente sem a variável @x, porém foi mais alguns bytes. Incluindo a versão ungolfed para os interessados:

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 bytes

Editar 4 bytes, salvar thx @Neil

Ainda não está claro sobre o arredondamento. Este trunca e tudo bem.

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

Teste

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 bytes

As regras já foram esclarecidas.

Solicita tempo como lista de 3 elementos.

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

Editar: Atualizado ( ⌈→ ⌊) para corresponder a um novo resultado para 10:33:06.

Experimente online!

⎕ solicitação de entrada

60⊥ avaliar na base-60

675÷⍨ dividir por 675

512× multiplicar por 512

⌊ chão

(… )⊤ Converter para (mnemônico: a base invertida é anti-base) o seguinte sistema numérico:

 16/2 replicar 2 dezesseis vezes (ou seja, binário de 16 bits)   

Q, 32 bytes

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

Teste

   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

• Para reduzir a desordem da exibição, assumo uma ligeira modificação na expressão original, que dá nome tao lambda

• O sufixo b indica binário

Explicação

NOTA.- leia da esquerda para a direita, avalia da direita para a esquerda

Lê como: 48 são eliminados da representação binária do piso de 512 divideb por 675 e multiplicados por 60 scalarFromVector sobre o número inteiro convertido das divisões na sequência original ":"

Avaliação:

":"\:x divide a string x (argumento implícito do lambda) no caractere ":" (Q usa "" para indicar char)

"I"$x converter string (s) x para int (s) -> horas, minutos, segundos

60/:x usa a base 60 para calcular um único valor a partir de uma sequência de entradas -> total de segundos

(512%675)*x calcula a proporção 512%675(% é dividida) e multiplica segundos. 512% 675 é a forma simplificada da fração (totalSecondsPerDay% 64K)

_ x indica piso da bóia x

0b\:x calcula a representação binária de x (64 bits)

48_ x soltar os primeiros 48 bits, então temos nossa representação de 16 bits

Exemplo (x = "01:30:00"). NOTA.- "/" indica o comentário no final da linha

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

Ruby, 75 bytes

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

Eu sinto que deve haver um método mais curto de converter o tempo em segundos, mas isso é tudo que eu conseguia pensar.

Python, 45 bytes

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

Eu mesmo inventei o 512/675fator e vi os outros fazerem o mesmo.

C, 91 bytes

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 bytes

Usa a codificação IBM-850.

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

Execute assim:

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

Tweaks

• Salve um byte usando a codificação IBM-850.
• Salva 3 bytes usando $argn