Qual è il tempo binario?


14

Qual è il tempo binario?

Tutti sanno che ore sono. È lassù in alto a destra (o ovunque lo metti) del tuo schermo. Ma una domanda che le persone raramente sembrano porsi è questa: qual è il tempo binario ?

Tempo binario

Il tempo binario (True Binary Time) funziona leggendo prima il bit più significativo (MSB) del numero. Se quel numero è 0, il tempo espresso è prima di mezzogiorno. Se quel numero è 1, il tempo espresso è dopo mezzogiorno. Il bit successivo divide la metà della giornata il primo bit espresso in altre due metà uguali, questa volta di 6 ore. Il bit seguente si divide in 3 ore, i successivi 90 minuti e così via. Tempi come 12:00:00, dove sembra che non dovrebbe essere nessuno dei due, diventano 1.

Posso solo capire questo strano sistema di tempistica, quindi ho bisogno di un programma per convertirlo in quello per me. Ma poiché i numeri binari sono Base-2 e 2 è un numero piccolo, il programma deve essere il più breve possibile.

Requisiti

  • Il tuo programma dovrebbe impiegare un tempo (come 24 ore) come input e output il corrispondente numero di tempo binario.
  • Il numero di uscita deve avere una precisione di 16 bit (il numero deve essere lungo 16 cifre).
  • Non puoi utilizzare un built-in che esegue tutta quella conversione per te.
  • Dovresti pavimentare se deve essere arrotondato.

Regole

  • Sono vietate le scappatoie standard .
  • Il tuo programma non dovrebbe scrivere nulla su STDERR.

Casi 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

punteggio

Per vincere, come ho detto prima, devi avere il minimo byte.

Inseriti

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad esempio perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

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

Classifica

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.


3
Posso inserire come [hour, minute, second]? Non ci piace limitare il formato di input.
Leaky Nun,

2
Come funziona 09:57:30fare 0110110000000000?
Leaky Nun,

2
16 bit possono rappresentare solo 65536 valori. Ci sono 86400 secondi in un giorno. Come dovremmo rappresentare qualcosa che non corrisponde esattamente a una rappresentazione binaria?
PurkkaKoodari,

Possiamo restituire il risultato come un elenco di 16 numeri?
Adám,

@Adám Sì, puoi.
George Gibson,

Risposte:


1

MATL , 15 byte

YOtk-KWW*k16&YB

Utilizza un builtin per convertire una stringa che rappresenta l'ora in un numero di data / ora seriale, che è consentito dalla sfida.

Provalo online!

Spiegazione

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 byte

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

Suite di test.

Spiegazione

Si avvale del fatto che 65536 (2 16 ) su 86400 (il numero di secondi in un giorno) si semplifica a 512 su 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 byte

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

Suite di test.

Converte l'input in numero di secondi trascorsi, moltiplicandolo per un fattore di 2^16 / 24*60*60, quindi piano e convertito in binario a 16 bit.

Ho salvato 4 byte semplificando 65536/86400in 512/675(stupido).

Input Output

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

Puoi giustificare " e poi piano "?
Peter Taylor,

@PeterTaylor Cosa devo fare invece?
Leaky Nun,

4
Attendere fino a quando le specifiche non sono state chiarite prima di inviare una risposta.
Peter Taylor,

@PeterTaylor Il modo giusto di arrotondamento è evidente da 10:33:06.
Adám,

@Adám, non proprio, perché dà lo stesso output con floor e round-to-più vicino.
Peter Taylor,

3

TSQL (sqlserver 2012), 103 byte

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

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

Provalo 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 byte

Includeva anche una versione diversa senza la variabile @x, tuttavia era più lunga di qualche byte. Inclusa la versione non golfata per gli interessati:

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 @

Non sembra golfato. Non riesci a rimuovere molto spazio bianco?
Adám,

@ Adám è molto sciocco, ho usato metodi diversi rispetto allo standard per rendere lo script più breve e ho persino provato un metodo diverso. Ho appena inserito uno spazio bianco accidentale quando ho copiato la mia risposta in codegolf (solo uno in più). Volevo mettere un break line lì, ma ho deciso di inserirlo dopo WHILE. Rimuovere lo spazio e chiedermi se mi hai veramente votato per quel singolo spazio extra
t-clausen.dk

@Adám e se stai guardando il secondo metodo, non è golfato (tranne il conteggio dei personaggi), dal momento che non è la mia vera risposta. Solo un diverso metodo più calcolatore per risolverlo
t-clausen.dk

3
No, non ho votato. Probabilmente è stato qualcuno che ha un principio a declassare tutte le risposte che vengono pubblicate prima che il PO chiarisca le domande in sospeso sulle regole. Tutti tranne la risposta più recente ha esattamente un voto negativo. (Probabilmente era Peter Taylor, perché era stato qui per l'ultima volta poco prima di quel post, e si è lamentato per questo.) Puoi vederlo quando hai abbastanza rappresentante. Eccone un po '!
Adám,

2

JavaScript (ES6), 72 76 byte

Modifica 4 byte salva thx @Neil

Ancora poco chiaro sull'arrotondamento. Questo tronca e va bene.

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

Test

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>


Sto cercando di capire perché questo è stato
sottoposto a downgrade

t=>([h,m,s]=t.split`:`,(+h+m/60+s/3600)*8192/3|65536).toString(2).slice(1)ti fa risparmiare 2 byte, ma reduceva oltre un byte:t=>(t.split`:`.reduce((n,m)=>+m+n*60)*512/675|65536).toString(2).slice(1)
Neil

Il downvote senza un commento non è bello, votato
t-clausen.dk

@Neil grazie mille! E con .map 1 byte in più salvato
edc65

Eh, mi chiedevo da dove avresti preso lo 0 per la mappa ...
Neil

1

APL (Dyalog) , 24 21 byte

Le regole sono state ora chiarite.

Richiede il tempo come elenco di 3 elementi.

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

Modifica: aggiornato ( ) per abbinare il nuovo risultato alle 10:33:06.

Provalo online!

 richiesta di input

60⊥ valutare in base-60

675÷⍨ dividere per 675

512× moltiplicare per 512

 pavimento

()⊤ Converti in (mnemonico: la base rovesciata è anti-base) il seguente sistema numerico:

16/2 replicare 2 sedici volte (ovvero binario a 16 bit)   


0

Q, 32 byte

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

Test

   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
  • Per ridurre il disordine del display, presumo una leggera modifica dell'espressione originale, che dà il nome tal lambda

  • il suffisso b indica binario

Spiegazione

NOTA.- leggi da sinistra a destra, valuta da destra a sinistra

Legge come: 48 drop dalla rappresentazione binaria di floor di 512 divideb per 675 e moltiplicata per 60 scalarFromVector su cast intero da split a ":" stringa originale

Valutazione:

":"\:x divide la stringa x (arg implicita della lambda) nel carattere ":" (Q usa "" per indicare il carattere)

"I"$x cast string (s) x a int (s) -> ore, minuti, secondi

60/:x usa la base 60 per calcolare un singolo valore da una sequenza di ints -> secondi totali

(512%675)*x calcola il rapporto 512%675(% è la divisione) e moltiplica i secondi. 512% 675 è la forma semplificata della frazione (totalSecondsPerDay% 64K)

_ x indica il piano del galleggiante x

0b\:x calcola la rappresentazione binaria di x (64 bit)

48_ x rilasciare i primi 48 bit, quindi abbiamo la nostra rappresentazione a 16 bit

Esempio (x = "01:30:00"). NOTA.- "/" indica un commento alla fine della riga

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


0

Rubino, 75 byte

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

Sento che ci deve essere un metodo più breve per convertire il tempo in secondi, ma questo è tutto ciò che mi viene in mente.


0

Python, 45 byte

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

Sono venuto con il 512/675fattore me stesso, poi ho visto gli altri fare lo stesso.


0

C, 91 byte

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 byte

Utilizza la codifica IBM-850.

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

Esegui in questo modo:

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

Ritocchi

  • Salvato un byte utilizzando la codifica IBM-850.
  • Salvato 3 byte usando $argn
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.