90 डिग्री पर घंटे का उत्पादन

26

आज अपने बच्चों के साथ खेलते हुए मैंने देखा कि पार्क में एक स्पष्ट रूप से साधारण खिलौना एक चुनौती को छिपा देता है।

घड़ी

पहिया में एक त्रिकोण होता है जो एक संख्या की ओर इशारा करता है, लेकिन इसमें तीन वृत्त भी होते हैं जो पहले एक से हर 90 डिग्री की संख्या को इंगित करते हैं। इसलिए:

चुनौती (वास्तव में सरल)

किसी भी स्वीकार्य रूप में 1 और 12 (त्रिकोण द्वारा इंगित किया गया) के बीच पूर्णांक को देखते हुए, आउटपुट किसी भी स्वीकार्य रूप में भी होता है और हलकों द्वारा बताई गई तीन संख्याओं को क्रमबद्ध करता है (प्रत्येक 90 डिग्री वाले)।

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

In       Out
1        4, 7, 10
2        5, 8, 11
3        6, 9, 12
4        7, 10, 1
5        8, 11, 2
6        9, 12, 3
7        10, 1, 4
8        11, 2, 5
9        12, 3, 6
10       1, 4, 7
11       2, 5, 8
12       3, 6, 9

यह कोड-गोल्फ है , इसलिए हर भाषा की जीत के लिए सबसे छोटा कोड हो सकता है!

code-golf  integer  clock 
— चार्ली
स्रोत
क्या हम इनपुट को 0-अनुक्रमित के रूप में ले सकते हैं? की तरह 0 -> 4, 7, 10?
— श्री एक्सकोडर
8
@ Mr.Xcoder क्षमा करें, इस बार मैं नहीं कहने जा रहा हूं।
— चार्ली
3
क्या यह चौथी चुनौती अब आपके बच्चों को शामिल करने वाली किसी गतिविधि पर आधारित है? : पी
— 21
3
@FlipTack शायद हमें एक प्रेरित-से-बच्चों के टैग की आवश्यकता है;)
— स्टेडीबॉक्स
6
@FlipTack मैंने गिनती खो दी है। :-) लेकिन यह देखते हुए कि मैंने अपना अधिकांश खाली समय अपने बच्चों के साथ बिताया है, लगता है कि मेरी प्रेरणा कहाँ से आती है ...
— चार्ली

जवाबों:

9

जेली , 8 बाइट्स

12Rṙ’m3Ḋ

एक मोनडिक लिंक एक नंबर ले रहा है और संख्याओं की सूची लौटा रहा है।

इसे ऑनलाइन आज़माएं! या सभी मामलों को देखें।

कैसे?

12Rṙ’m3Ḋ - Link: number, n   e.g. 5
12       - literal twelve         12
  R      - range                  [1,2,3,4,5,6,7,8,9,10,11,12]
    ’    - decrement n            4
   ṙ     - rotate left            [5,6,7,8,9,10,11,12,1,2,3,4]
      3  - literal three          3
     m   - modulo slice           [5,8,11,2]
       Ḋ - dequeue                [8,11,2]
— जोनाथन एलन
स्रोत
वैकल्पिक समाधान: 12Rṙm-3Ḋ(रिवर्स ऑर्डर में आउटपुट)
— user202729
6

MATL , 9 बाइट्स

I:I*+12X\

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

व्याख्या

4एक्सैम्पल के रूप में इनपुट पर विचार करें ।

I:     % Push [1 2 3]
       % STACK: [1 2 3]
I      % Push 3
       % STACK: [1 2 3], 3
*      % Multiply, element-wise
       % STACK: [3 6 9]
+      % Add implicit input, element-wise
       % STACK: [7 10 13]
12     % Push 12
X\     % 1-based modulus. Implicit display
       % STACK: [7 10 1]
— लुइस मेंडो
स्रोत
5

एपीएल + विन, 13bytes

(⎕⌽⍳12)[3×⍳3]

स्पष्टीकरण:

⎕ Prompt for screen input of indicated time t

⍳12 Create a vector of integers from 1 to 12

⌽ Rotate the vector by t elements front to back

[3×⍳3] Select 3rd, 6th and 9th elements.
— ग्राहम
स्रोत
काफी साफ-सुथरा। मुझे वह अनुक्रमणित रोटेशन एप्रोच पसंद है
— उरईल
4

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

Xnor के जवाब के समान ।

n=>[2,5,8].map(k=>(n+k)%12+1)

डेमो

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
मैंने n=>[3,6,9].map(v=>(v+n)%12)तब महसूस किया था कि यह 0 नहीं, 12 है ...
— ericw31415
@ ericw31415 वास्तव में, मेरा पहला दृष्टिकोण था n=>[3,6,9].map(v=>(v+n)%12||12)(लेकिन यह 31 बाइट्स था)।
— अरनौलड
4

ऑक्टेव , 25 बाइट्स

@(x)[a=1:12 a](3+x:3:9+x)

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

बहुत ही सरल अनाम फ़ंक्शन।

हम पहले एक सरणी बनाते हैं [1:12 1:12]- इसलिए पूर्ण संख्या सेट की दो प्रतियां। फिर हम उन मूल्यों को चुनने के लिए अनुक्रमित करते हैं x+3, x+6, x+9, जहां xनंबर इनपुट है।

ऑक्टेव 1-अनुक्रमित है, इसलिए हम केवल इनपुट के आधार पर सरणी तत्वों का चयन कर सकते हैं (हालांकि ईमानदार होने के लिए 0-अनुक्रमित यहां बाइट्स की समान संख्या का उपयोग करेगा)।

यह एक ऐसी विधि का उपयोग करने के लिए लगता है जो अन्य उत्तरों के लिए अद्वितीय है, जिसमें सरणी की दो प्रतियां होने से, हमें मॉडुलो का उपयोग करके सूचकांकों को लपेटना नहीं पड़ता है।

— टॉम बढ़ई
स्रोत
बहुत अच्छा है, लेकिन "उबाऊ" आधुनिक दृष्टिकोण कम है! इसे ऑनलाइन आज़माएं!
— ग्यूसेप
@Giuseppe योग्य, मुझे यकीन है कि मैंने प्रयोग करने की कोशिश की है modऔर इसे छोटा नहीं बना सकता। बहुत बढ़िया! एक उत्तर के रूप में पोस्ट करने के लिए स्वतंत्र महसूस करें।
— टॉम कारपेंटर
3

बेफुंज -93, 20 19 18 बाइट्स

852<_@#:.+1%+66+&p

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

व्याख्या

852                   Push 8, 5 and 2 onto the stack - the offsets we're going to add.
   <                  Reverse direction, and start the main loop.
852                   Push 2, 5, and 8 onto the stack, but we don't actually want these.
                 p    So we use a "put" operation to drop the top three values.
                &     Read the hour from stdin.
               +      Add it to the topmost offset.
         +1%+66       Mod 12 and add 1 to get it in the range 1 to 12.
        .             Then output the result to stdout.
    _@#:              Exit if the next offset is zero (i.e. nothing more on the stack).
   <                  Otherwise start the main loop again.

यह संदर्भ दुभाषिया के लिए विशिष्ट व्यवहार पर निर्भर करता है: एंड-ऑफ-द-फाइल पर, &ऑपरेटर उस अंतिम मान को लौटाता है जिसे पढ़ा गया था। इसलिए हम लूप के प्रत्येक पुनरावृत्ति पर स्टड से घंटे को फिर से पढ़ सकते हैं।

— जेम्स होल्डरनेस
स्रोत
साफ। मुझे नहीं पता &था कि
— Jo King
3
@JoKing तकनीकी रूप से दुभाषिया में एक बग है, एक अन्य संबंधित साइड-इफ़ेक्ट है जिसे &एक तरह के एक-रैंडम नंबर जनरेटर के रूप में भी इस्तेमाल किया जा सकता है । यह कम विश्वसनीय है, हालांकि, चूंकि यह उस कंपाइलर पर निर्भर करता है जिसे इसे बनाने के लिए इस्तेमाल किया गया था। यह इस समय TIO पर काम कर रहा है, लेकिन एक समय था जब डेनिस gcc के एक अलग संस्करण में बदल गया और हमने कुछ समय के लिए उस कार्यक्षमता को खो दिया।
— जेम्स होल्डरनेस
2

जाप, 11 बाइट्स

3ÆU±3 uC ªC

कोशिश करो

व्याख्या

पूर्णांक का निहित इनपुट U। 3 तत्व सरणी ( 3Æ) और, प्रत्येक तत्व के लिए, U3 से वृद्धि ( U±3), 12 से modulo ( uC) और, क्योंकि 12%12=0, परिणाम 12 या ( ªC) लौटें ।

— झबरा
स्रोत
2

ब्रेन-फ्लैक , 84 बाइट्स

(()()()){({}<(()(){})(((()()()){}){}<>){(({})){({}[()])<>}{}}<>(([{}]{})<>)>[()])}<>

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

कम से कम मैंने Doorknob के चेहरे के समाधान को हराया ...

स्पष्टीकरण:

LOOP 3 TIMES: (()()()){({}<

  n += 2:
   (()(){})
  push 12:
   (((()()()){}){}<>)
  n mod 12 + 1; pushing to both stacks:
   {(({})){({}[()])<>}{}}<>(([{}]{})<>)

END LOOP: >[()])}<>
— MegaTom
स्रोत
1

पुष्य , 12 बाइट्स

258s{K+12%h_

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

258            \ Push 258                            
   s           \ Split into digits, yielding [2, 5, 8]
    {K+        \ Add input to each
       12%     \ Modulo each by 12
          h    \ Increment each
           _   \ Print (space separated)

12 बाइट्स

एक ही बाइट गिनती के लिए एक विकल्प:

12R{:{;$...#

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

12R            \ Push range(1, 12), inclusive
   {: ;        \ Input times do:
     {         \   Rotate left
       $       \ While there are items on stack:
        ...    \   Pop the top three
           #   \   Print top item
— FlipTack
स्रोत
1

के (ओके) , 11 बाइट्स

समाधान:

1+12!2 5 8+

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

उदाहरण:

1+12!2 5 8+1
4 7 10
1+12!2 5 8+2
5 8 11
1+12!2 5 8+3
6 9 12
1+12!2 5 8+4
7 10 1

स्पष्टीकरण:

यह पहला समाधान था जो दिमाग में आया। सबसे अच्छा या छोटा नहीं हो सकता है।

1+12!2 5 8+ / the solution
     2 5 8+ / add 2, 5 and 8 to the input
  12!       / apply modulo 12 to the results
1+          / add 1
— streetster
स्रोत
1

GolfScript, 46 बाइट्स

~13,1>:x?:y;0:i;x y 3+12%=x y 6+12%=x y 9+12%=

यह पहली बार है जब मैं कोड गोल्फ कर रहा हूं, इसलिए मेरे अनुभव की कमी के साथ मुझे शायद सबसे अच्छा समाधान नहीं मिला है, लेकिन मुझे कहीं और शुरू करने की आवश्यकता है, है ना?

इसे ऑनलाइन आज़माएँ या सभी मामलों को आज़माएँ

— QunSyBer
स्रोत
नमस्कार, साइट पर आपका स्वागत है! यह एक अच्छा पहला उत्तर की तरह लग रहा है :) दुर्भाग्य से, मुझे गोल्फस्क्रिप्ट के बारे में कुछ भी नहीं पता है, लेकिन आप यहाँ
— DJMcMayhem
1

चेहरा , 96 94 बाइट्स

(%d
@)\$*,c'$ooiim%*m1*6%+%%%11m!*mn*m~*3!m&!r!&!is!&$pn3!:L+nn1+nn1%nn%+nn1p~>$inw~>~o-!!1?!L

यह बस 12 से दो, mods को जोड़ता है, एक और जोड़ता है, और प्रिंट करता है। फिर ऐसा वह दो बार करता है।

टिप्पणी संस्करण:

(%d
@)

\$*,c'$ooii     ( store format string in $, ip in *, get stdin/out )
m%*m1*6%+%%%11  ( initialize constants, %=12, 1=1 )
m!*mn*m~*       ( malloc space for a counter, input var, and length )
3!m&!r!&!i      ( read into & )
s!&$pn          ( scan into n )
3!:L            ( start of main loop, executed thrice )
  +nn1+nn1      ( add 2 to n )
  %nn%+nn1      ( mod by 12 and add 1 more )
  p~>$in        ( sprintf n into > )
  w~>~o         ( output to stdout )
  -!!1          ( decrement counter )
?!L             ( conditional jump back to loop start )

इसे ऑनलाइन आज़माएं! (टीआईओ पर बग के कारण ट्रेलिंग न्यूलाइन आवश्यक है जो चेहरे के नए संस्करण में तय की गई है।)

— Doorknob
स्रोत
एक वैरिएबल बनाना जो मान 3 रखता है, m3*33आपको तीनों +nn1को एक +nn3 tio.run/… के
— क्रिति लिथोस
@Cowsquack ध्यान दें कि आपके लिंक में आउटपुट गलत है।
— दरवाज़े
1

फोर्थ (gforth) , 39 बाइट्स

इनपुट को स्टैक से लिया जाता है और आउटपुट को स्टैक पर रखा जाता है 

: a 2 + 12 mod 1+ ; : f a dup a dup a ;

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

व्याख्या

 : a 2 + 12 mod 1+ ; \ helper word to handle adding the hours
    2 +              \ Add 2 to the input
    12 mod           \ get the result modulo 12
    1+               \ add 1

 : f a dup a dup a ; \ word that calculates and outputs the result
    a dup            \ add 3 hours to the input and then duplicate the result
    a dup            \ add 3 hours to the duplicate then duplicate the result
    a                \ add 3 hours to the duplicate
— reffu
स्रोत
0

वोल्फ्राम भाषा (गणितज्ञ) 35 बाइट्स

Range@12~RotateLeft~#~Take~{3,9,3}&

उपरोक्त कथन, इनफिक्स नोटेशन में, अधिक स्पष्ट रूप से क्या व्यक्त किया जा सकता है

Function[Take[RotateLeft[Range[12],Slot[1]],List[3,9,3]]]

RotateLeftघूमता है Range[12], अनुक्रम 1,2, ... 12, इनपुट संख्या द्वारा छोड़ा गया। Slot[1]या #इनपुट नंबर रखता है, एन।

उदाहरण के लिए, n = 4 के साथ, 

Function[RotateLeft[Range[12],4]]]

सूची लौटाता है 

{5, 6, 7, 8, 9, 10, 11, 12, 1, 2, 3, 4}

Take...{3,9,3} उस सूची में हर तीसरे तत्व को स्थिति 9 से स्थिति 9, अर्थात् के माध्यम से लौटाता है

{7, 10, 1}
— DavidC
स्रोत
— user202729
0

विंडोज बैच, 137 125 111 68 बाइट्स

@set/ab=(%1+2)%%12+1,c=(%1+5)%%12+1,d=(%1+8)%%12+1
@echo %b% %c% %d%

का पोर्ट add value to input and mod 12 + 1

— stevefestl
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.