बाइनरी टाइम क्या है?


14

बाइनरी टाइम क्या है?

हर कोई जानता है कि सामान्य समय क्या है। यह आपकी स्क्रीन के शीर्ष-दाएं (या जहां भी आपने रखा है) में है। लेकिन एक सवाल जो शायद ही कभी लोग खुद से पूछते हैं, यह है: बाइनरी टाइम क्या है?

बाइनरी टाइम

बाइनरी टाइम (ट्रू बाइनरी टाइम) पहले नंबर के सबसे महत्वपूर्ण बिट (MSB) को पढ़कर काम करता है। यदि वह संख्या है 0, तो व्यक्त समय दोपहर से पहले है। यदि वह संख्या है 1, तो व्यक्त किया गया समय दोपहर के बाद है। अगले बिट दिन के आधे भाग को विभाजित करता है पहला 6 घंटे के इस समय में दो और बराबर हिस्सों में व्यक्त किया गया है। निम्नलिखित बिट 3 घंटे, अगले 90 मिनट, और इसी तरह से विभाजित होता है। टाइम्स की तरह 12:00:00, जहां ऐसा लगता है कि यह न तो होना चाहिए, न हो 1

मैं केवल समय की इस अजीब प्रणाली को समझ सकता हूं, इसलिए मुझे मेरे लिए इसे बदलने के लिए एक कार्यक्रम की आवश्यकता है। लेकिन जैसा कि बाइनरी नंबर बेस -2 हैं, और 2 एक छोटी संख्या है, आपका प्रोग्राम यथासंभव छोटा होना चाहिए।

आवश्यकताएँ

  • आपके कार्यक्रम को इनपुट के रूप में एक समय (24-घंटे-समय के रूप में) लेना चाहिए और संबंधित बाइनरी समय संख्या को आउटपुट करना चाहिए।
  • आउटपुट संख्या में 16-बिट परिशुद्धता होनी चाहिए (संख्या 16 अंकों की लंबी होनी चाहिए)।
  • आप एक बिल्टिन का उपयोग नहीं कर सकते जो आपके लिए उस सभी रूपांतरण को करता है।
  • यदि आपको इसे गोल करने की आवश्यकता है, तो आपको फर्श करना चाहिए।

नियम

  • मानक खामियों को मना किया जाता है।
  • आपके कार्यक्रम को कुछ भी नहीं लिखना चाहिए STDERR

परीक्षण के मामलों

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

स्कोरिंग

जीतने के लिए, जैसा कि मैंने पहले उल्लेख किया है, आपके पास कम से कम बाइट्स होने चाहिए।

प्रस्तुतियाँ

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई दे रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

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

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक स्कोर अंतिम संख्या है:

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

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

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

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।


3
क्या मैं इनपुट कर सकता हूं [hour, minute, second]? हमें इनपुट प्रारूप को प्रतिबंधित करना पसंद नहीं है।
लीक नून

2
कैसे करता है 09:57:30बनाने के 0110110000000000?
लीक नून

2
16 बिट्स केवल 65536 मूल्यों का प्रतिनिधित्व कर सकते हैं। एक दिन में 86400 सेकंड होते हैं। हमें किसी भी चीज़ का प्रतिनिधित्व कैसे करना चाहिए जो बाइनरी प्रतिनिधित्व से बिल्कुल मेल नहीं खाता है?
पुरकाकूदरी

क्या हम 16 नंबरों की सूची के रूप में परिणाम वापस कर सकते हैं?
प्रवेश

@ Adám हां, आप कर सकते हैं।
जॉर्ज गिब्सन

जवाबों:


1

MATL , 15 बाइट्स

YOtk-KWW*k16&YB

एक धारावाहिक दिनांक / समय संख्या के लिए एक स्ट्रिंग का प्रतिनिधित्व करने के लिए एक बिलिन का उपयोग करता है, जिसे चुनौती द्वारा अनुमति दी जाती है।

इसे ऑनलाइन आज़माएं!

व्याख्या

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

सीजेएम, 20 बाइट्स

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

परीक्षण सूट।

व्याख्या

इस तथ्य का उपयोग करता है कि 66436 (2 16 ) 86400 (एक दिन में सेकंड की संख्या) 675 से अधिक 512 तक सरल हो जाती है।

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

पायथ, 31 27 बाइट्स

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

परीक्षण सूट।

इनपुट को उत्तीर्ण सेकंड की संख्या में परिवर्तित करता है, के कारक से गुणा करता है 2^16 / 24*60*60और फिर फर्श और 16-बिट बाइनरी में परिवर्तित करता है।

4 बाइट्स को सरल 65536/86400करके 512/675(मुझे बेवकूफ बनाकर ) बचाया ।

इनपुट आउटपुट

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

क्या आप " और फिर मंजिल " को सही ठहरा सकते हैं ?
पीटर टेलर

@PeterTaylor इसके बजाय मुझे क्या करना चाहिए?
लीक नून

4
जवाब पोस्ट करने से पहले कल्पना को भंग कर दिए जाने तक प्रतीक्षा करें।
पीटर टेलर

@PeterTaylor द्वारा गोलाई का सही तरीका स्पष्ट है 10:33:06
आदम

@ Adám, वास्तव में नहीं है, क्योंकि यह मंजिल और गोल-से-निकटतम के साथ एक ही आउटपुट देता है।
पीटर टेलर

3

TSQL (sqlserver 2012), 103 बाइट्स

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

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

इसे ऑनलाइन आज़माएं

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 बाइट्स

चर @x के बिना भी एक अलग संस्करण शामिल है, हालांकि यह कुछ बाइट्स लंबा था। उन लोगों के लिए ungolfed संस्करण शामिल हैं:

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 @

यह गोल्फ नहीं दिखता है। क्या आप बहुत सारे व्हाट्सएप नहीं हटा सकते?
अदम

@ बहुत अच्छा लगता है, मैंने स्क्रिप्ट को छोटा बनाने के लिए मानक से अलग तरीकों का इस्तेमाल किया और एक अलग तरीके की कोशिश की। मेरे पास बस एक आकस्मिक व्हाट्सएप था, जब मेरे जवाब को कोडगुल्फ़ (केवल एक अतिरिक्त) में नकल करना था। मैं वहां एक लाइनब्रेक लगाना चाहता था, लेकिन उसने इसके बजाय WHILE के बाद इसे लगाने का फैसला किया। अंतरिक्ष को हटाना और यह सोचकर कि क्या आपने वास्तव में मुझे उस एकल अतिरिक्त स्थान के लिए
डाउनवोट कर दिया है

@ Adám और यदि आप दूसरी विधि देख रहे हैं, तो यह गोल्फ (वर्ण गणना को छोड़कर) नहीं है, क्योंकि यह कोई वास्तविक उत्तर नहीं है। इसे हल करने की बस एक और अधिक गणना विधि
t-clausen.dk

3
नहीं, मैंने नीचे नहीं किया। यह संभवत: ऐसा कोई व्यक्ति था जिसके पास ओपी के उत्कृष्ट नियम प्रश्नों को स्पष्ट करने से पहले पोस्ट किए गए सभी उत्तरों को कम करने का सिद्धांत है। सभी लेकिन बहुत नवीनतम उत्तर में एक ही गिरावट है। (यह शायद पीटर टेलर था, क्योंकि वह उस पोस्ट से ठीक पहले यहां था, और वह इस बारे में शिकायत कर रहा है।) आप इसे देख सकते हैं जब आप पर्याप्त प्रतिनिधि प्राप्त करते हैं। यहाँ, कुछ है!
आदम

2

जावास्क्रिप्ट (ईएस 6), 72 76 बाइट्स

4 बाइट संपादित करें thx @Neil को बचाएं

गोलाई के बारे में अभी भी स्पष्ट नहीं है। यह एक छोटा है और यह ठीक है।

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

परीक्षा

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>


यह पता लगाने की कोशिश कर रहा हूं कि यह क्यों
घट

t=>([h,m,s]=t.split`:`,(+h+m/60+s/3600)*8192/3|65536).toString(2).slice(1)आपको 2 बाइट्स बचाता है, लेकिन reduceआगे एक बाइट जाता है:t=>(t.split`:`.reduce((n,m)=>+m+n*60)*512/675|65536).toString(2).slice(1)
नील

एक टिप्पणी के बिना डाउनवोट शांत नहीं है,
upvote

@ नील आपको बहुत बहुत धन्यवाद! और
.map

हुह, मैं सोच रहा था कि आप नक्शे के लिए 0 कहां से
नील

1

एपीएल (डायलॉग) , 24 21 बाइट्स

नियमों को अब स्पष्ट किया गया है।

3-तत्व सूची के रूप में समय के लिए संकेत।

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

संपादित करें: अपडेट किया गया ( ) 10:33:06 के लिए नए परिणाम का मिलान करने के लिए।

इसे ऑनलाइन आज़माएं!

 इनपुट के लिए संकेत

60⊥ आधार -60 में मूल्यांकन

675÷⍨ 675 से विभाजित करें

512× 512 से गुणा करें

 मंज़िल

()⊤ (संख्या: उल्टा आधार एंटी-बेस है) निम्नलिखित संख्या प्रणाली में परिवर्तित करें:

16/2 2 सोलह बार दोहराएं (यानी 16-बिट बाइनरी)   


0

क्यू, 32 बाइट्स

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

परीक्षा

   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
  • प्रदर्शन अव्यवस्था को कम करने के लिए, मैं मूल अभिव्यक्ति के लिए थोड़ा संशोधन करता हूं, जो tलैम्ब्डा को नाम देता है

  • b प्रत्यय बाइनरी इंगित करता है

व्याख्या

NOTE.- बाएँ से दाएँ पढ़ा जाता है, दाएँ से बाएँ का मूल्यांकन करता है

के रूप में पढ़ता है: 675 द्वारा 512 डिवाइड के फर्श के द्विआधारी प्रतिनिधित्व से 48 बूंद और 60 से स्केलरफ्रॉमविक्टर द्वारा गुणा करके पूर्णांक कलाकारों में विभाजित किया जाता है ":" मूल स्ट्रिंग

मूल्यांकन:

":"\:x स्प्लिट्स स्ट्रिंग x (लैम्बडा का निहित अर्थ) ":" वर्ण (क्यू उपयोग करता है "" चार को निरूपित करने के लिए)

"I"$x कास्ट स्ट्रिंग (s) x से इंट (s) -> घंटे, मिनट, सेकंड

60/:x चींटियों के अनुक्रम से एकल मूल्य की गणना करने के लिए बेस 60 का उपयोग करता है -> कुल सेकंड

(512%675)*x गणना अनुपात 512%675(% विभाजित है) और सेकंडों को गुणा करता है। 512% 675 अंश का सरलीकृत रूप है (TotalSecondsPerDay% 64K)

_ x फ्लोट x के फर्श को इंगित करता है

0b\:x x (64 बिट्स) के द्विआधारी प्रतिनिधित्व की गणना करता है

48_ x पहले 48 बिट्स गिराएं, इसलिए हमारे पास 16 बिट्स प्रतिनिधित्व हैं

उदाहरण (x = "01:30:00")। नोट.- "/" लाइन के अंत में टिप्पणी को इंगित करता है

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


0

रूबी, 75 बाइट्स

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

मुझे ऐसा लगता है कि समय को सेकंडों में परिवर्तित करने का एक छोटा तरीका होना चाहिए, लेकिन यह मैं सोच सकता हूं।


0

पायथन, 45 बाइट्स

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

512/675स्वयं कारक के साथ आया , फिर दूसरों को भी ऐसा ही करते देखा।


0

सी, 91 बाइट्स

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 बाइट्स

IBM-850 एन्कोडिंग का उपयोग करता है।

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

इस तरह से चलाएं:

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

बदलाव

  • IBM-850 एन्कोडिंग का उपयोग करके एक बाइट को बचाया।
  • उपयोग करके 3 बाइट्स सहेजे गए $argn
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.