एक ASCII फाइबोनैचि घड़ी बनाएँ

Question

किसी ने फाइबोनैचि संख्याओं का उपयोग करके वास्तव में फैंसी घड़ी का निर्माण किया , जो वास्तव में अच्छा दिखता है लेकिन काफी अनुपयोगी है। ठीक वैसा, जैसा हम चाहते हैं! चलिए इसे फिर से बनाते हैं।

घड़ी पहले पांच फाइबोनैचि संख्याओं के अनुरूप 5 खंडों से बनी है, 1 से शुरू होती है (यानी 1, 1, 2, 3, 5):

ccbeeeee
ccaeeeee
dddeeeee
dddeeeee
dddeeeee

घड़ी 5 मिनट की वेतन वृद्धि में 12 घंटे का समय प्रदर्शित करने में सक्षम है। यहाँ है कि कैसे काम करता है। समय 7:20 पर विचार करें। घंटे 7 को दिए गए फाइबोनैचि संख्या के रूप में विघटित किया जा सकता है

7 = 2 + 5

पाँच मिनट की 4 इकाइयाँ भी हैं। 4 के रूप में विघटित किया जा सकता है

4 = 2 + 1 + 1

अब घंटों को लाल रंग में दिखाया गया है, मिनट को हरे रंग में दिखाया गया है, और यदि कोई संख्या दोनों घंटों और मिनटों के लिए उपयोग की जाती है, तो इसे नीले रंग में दिखाया गया है। यदि किसी नंबर का उपयोग नहीं किया जाता है, तो वह सफेद रहता है। तो ऊपर दिखाया जाएगा:

BBGRRRRR
BBGRRRRR
WWWRRRRR
WWWRRRRR
WWWRRRRR

लेकिन रुकिए, और भी है। उपरोक्त डिकम्पोज़िशन केवल संभावनाएँ नहीं हैं। एक भी लिख सकता है 7 = 3 + 2 + 1 + 1और 4 = 3 + 1, जो एक देगा

GGRWWWWW          GGBWWWWW
GGBWWWWW          GGRWWWWW
BBBWWWWW    or    BBBWWWWW
BBBWWWWW          BBBWWWWW
BBBWWWWW          BBBWWWWW

जिसके आधार पर 1चुना जाता है। बेशक अन्य संयोजन भी हैं। घड़ी यादृच्छिक पर सभी मान्य डिकम्पोजिशन से चुनती है।

जैसा कि मैंने कहा ... यह एक प्रयोज्य पुरस्कार नहीं जीत सकता है, लेकिन यह देखने में अच्छा है।

चुनौती

आपका काम ऐसी घड़ी को लागू करना है। आपके कार्यक्रम (या फ़ंक्शन) को STDOUT या निकटतम विकल्प के रूप में वर्णित वर्तमान समय के ASCII प्रतिनिधित्व (पिछले 5 मिनट के अंतिम दौर तक) प्रिंट करना चाहिए। आप इनपुट के रूप में किसी भी सामान्य प्रारूप में समय पढ़ने के लिए चुन सकते हैं या इसे मानक पुस्तकालय कार्यों के साथ प्राप्त कर सकते हैं। आपको यह नहीं समझना चाहिए कि वर्तमान / दिया गया समय 5 मिनट से विभाज्य है।

आपका समाधान को वर्तमान समय के सभी संभावित अभ्यावेदन से यादृच्छिक रूप से चुनना होगा । यह प्रत्येक प्रतिनिधित्व गैर-शून्य संभावना के साथ मुद्रित किया जाना चाहिए।

आधी रात और दोपहर को 0:00(जैसा विरोध किया गया 12:00) माना जाना चाहिए ।

आप वैकल्पिक रूप से एकल अनुगामी न्यूलाइन वर्ण प्रिंट कर सकते हैं।

आप के स्थान पर कोई भी चार अलग-अलग मुद्रण योग्य ASCII वर्ण (वर्ण कोड 0x20 से 0xFE) का उपयोग कर सकते हैं RGBW। कृपया अपने जवाब में अपनी पसंद बताएं और इसका लगातार उपयोग करें।

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

Comments

(ए) क्या हम मान सकते हैं कि इनपुट १२ = ० नियम का पालन करता है? (ख) क्या आउटपुट को उस अभिविन्यास में होना चाहिए, या हम इसे घुमा सकते हैं?

— सैपरकैवल

@sirpercival a) हां, मुझे लगता है कि "किसी भी सामान्य प्रारूप" के रूप में गिना जाता है। ख) इसे चुनौती में दिया गया अभिविन्यास होना चाहिए।

— मार्टिन एंडर

इस चुनौती ने दुर्भाग्यपूर्ण क्रिया "फाइबलॉकिंग" को जन्म दिया।

— एलेक्स ए

आधी रात / दोपहर 12 के बजाय 0 होने की प्रेरणा क्या है? अनुक्रम में पहले पाँच संख्याएँ ठीक 12 तक जुड़ती हैं।

— ब्रायन जे

@BrianJ मैं इसे लगातार बनाने के लिए एक का चयन करना चाहता था और शून्य को चुनना था। यह वास्तव में बहुत ज्यादा वैसे भी समाधान को प्रभावित नहीं करना चाहिए। मुझे लगा कि यह पसंद आसान हो जाएगी क्योंकि मिनटों में 0..11 सीमा है।

— मार्टिन एंडर

Answer 1

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

l~5/]:A{;L[TT][XXYZ5]{4mr_2bW%Mf*@.+\Ps=M*aM*@+W%z\}fMA=!}gN*

STDIN के माध्यम से दो अंतरिक्ष-पृथक पूर्णांक लेता है, और क्रमशः के 3.14बजाय का उपयोग करता WRGBहै। इसे ऑनलाइन आज़माएं ।

यहाँ RGBWकुछ अतिरिक्त बाइट्स के लिए "साने" संस्करण है:

l~5/]:A{;L[TT][XXYZ5]{4mr_2bW%Mf*@.+\"WRGB"=M*aM*@+W%z\}fMA=!}gN*

व्याख्या

एल्गोरिथ्म मेरे पाइथन उत्तर के समान है - घड़ियों को उत्पन्न करने से अस्वीकृति का नमूना जब तक हम एक को सही नहीं कर लेते।

l~5/]:A            Read input and make array [<hours> <minutes>/5]
{...}g             Do...

  ;                  Pop the only element on the stack
  L                  Push empty array, which will become our clock
  [TT]               Push [0 0] for [h m], to keep track of our sample
  [XXYZ5]{...}fI     For I in [1 1 2 3 5]...
    4mr                Push random number from [0 1 2 3]
    _2bW%              Copy and get reversed base 2 rep for one of [0] [1] [0 1] [1 1]
    If*                Multiply bit(s) by I
    @.+                Add element-wise to [h m] array
    \Ps=               Index the random number into stringified pi for one of "3.14"
    I*aI*              Make into I by I square
    @+W%z\             Add above clock and rotate clockwise

  A=!              ... while the resulting clock is incorrect
N*                 Riffle clock with newlines

Answer 2

पायथन 2, 194 182 बाइट्स

from random import*
h=m=H,M=input()
while[h,m]!=[H,M/5]:
 h=m=0;s=[]
 for n in 1,1,2,3,5:c=randint(0,3);h+=c%2*n;m+=c/2*n;s=zip(*(["WRGB"[c]*n]*n+s)[::-1])
for L in s:print"".join(L)

एल्गोरिथ्म सिर्फ अस्वीकृति नमूनाकरण है, इसलिए यह घड़ियों को उत्पन्न करता रहता है जब तक कि यह एक सही नहीं हो जाता है। घड़ी को कुछ भी नहीं के साथ शुरू करके बनाया गया है, फिर 5 बार "ऊपर एक वर्ग जोड़ें और दक्षिणावर्त घुमाएं"।

STDIN के माध्यम से दो अल्पविराम से अलग पूर्णांक बनाता है।

>>> ================================ RESTART ================================
>>> 
7,17
BBBWWWWW
BBRWWWWW
RRRWWWWW
RRRWWWWW
RRRWWWWW
>>> ================================ RESTART ================================
>>> 
7,17
GGBRRRRR
GGRRRRRR
WWWRRRRR
WWWRRRRR
WWWRRRRR

Answer 3

पायथन 2, 421 बाइट्स

उह, मुझे यकीन है कि यह अधिक गोल्फ हो सकता है।

from itertools import*
from random import*
f,r=[1,1,2,3,5],range
c={_:[x for x in chain(*[combinations(f,i)for i in r(6)])if sum(x)==_]for _ in r(13)}
k=[[2,1,4],[2,0,4]]+[[3,4]]*3
def b(h,m):
 o=['W']*5;m/=5;h,m=choice(c[h]),choice(c[m])
 l=dict(zip(zip('WWR',[m,h,m]),'GRB'))
 for x in h,m:
    d={1:[0,1],2:[2],3:[3],5:[4]}
    for _ in x:j=d[_].pop();o[j]=l[o[j],x]
 print'\n'.join([''.join(o[i]*f[i]for i in _)for _ in k])

परीक्षण का मामला:

>>> b(7,20)
WWBRRRRR
WWRRRRRR
GGGRRRRR
GGGRRRRR
GGGRRRRR
>>> b(7,20)
RRBWWWWW
RRRWWWWW
BBBWWWWW
BBBWWWWW
BBBWWWWW

Comments

@ ओप्टिमाइज़र अब हमें बस IDL को Google प्रीटेटिफाइंग सिस्टम में लाना है, ताकि मैं XD को हाइलाइट करने वाला IDL सिंटैक्स प्राप्त कर

— सकूं

Answer 4

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

यह गोल्फ हो सकता है, लेकिन कुछ और समय की कोशिश करेंगे।

z=[]
13.times{z<<[]}
(0..5).to_a.permutation{|p|l=p.take_while{|n|n<5};z[l.map{|n|[1,1,2,3,5][n]}.reduce(0,:+)]<<l}
t=Time.now
h,m=z[t.hour%12].sample,z[t.min/5].sample
5.times{|y|puts (0..7).map{|x|a=(x>2?4:y>1?3:x<2?2:y<1?1:0);q=m.include?(a);h.include?(a)?q ? ?B:?R: q ??G:?W}*""}

स्पष्टीकरण:

z=[]
13.times{z<<[]}                 # Initialize the array where we will have all the combinations
(0..5).to_a.permutation{|p|     # Get all the permutations of the 5 positions plus a 5, which will be used as a separator
    l=p.take_while{|n|n<5};     # Get the permutation until the separator. This way we get all the possible sum combinations of the other five numbers
    z[l.map{|n|[1,1,2,3,5][n]}.reduce(0,:+)]<<l}     # Add the permutation to the list with id=the permutation's sum

t=Time.now # Get current time
h,m=z[t.hour%12].sample,z[t.min/5].sample     # For the hour and the minute, get a random permutation that has the expected sum
5.times{|y|                 # For each row
    $><<(0..7).map{|x|      # For each column
        a=(x>2?4:y>1?3:x<2?2:y<1?1:0);     # Get the panel we are in
        q=m.include?(a);h.include?(a)?q ? ?B:?R: q ??G:?W     # Get the color this panel is painted
    }*""}                   # Join the string and print it

Comments

आप के (0..5).to_aसाथ प्रतिस्थापित कर सकते हैं[*0..5]

— Addison