क्यूपस एक प्राचीन उपकरण है जिसका उपयोग इंकोला द्वारा प्रीकोलम्बियन युग में एक नाल पर गांठों के आधार दस स्थिति प्रणाली में संख्याओं को रिकॉर्ड करने के लिए किया जाता है, जो निम्नानुसार काम करता है:

समुद्री मील का प्रत्येक समूह एक अंक है, और तीन मुख्य प्रकार के समुद्री मील हैं: साधारण ओवरहैंड समुद्री मील; "लॉन्ग नॉट्स", जिसमें एक या अधिक अतिरिक्त मोड़ के साथ एक ओवरहैंड गाँठ शामिल है; और आंकड़ा-आठ समुद्री मील।

दस की शक्तियों को स्ट्रिंग के साथ स्थिति द्वारा दिखाया गया है, और इस स्थिति को क्रमिक किस्में के बीच संरेखित किया गया है।

10 और उच्चतर शक्तियों के लिए पदों में अंकों को सरल समुद्री मील के समूहों द्वारा दर्शाया जाता है (उदाहरण के लिए, "दसियों" स्थिति में एक पंक्ति में 40 चार सरल समुद्री मील हैं)।

"लोगों" की स्थिति में अंक लंबे समुद्री मील (जैसे, 4 चार मोड़ों के साथ एक गाँठ) का प्रतिनिधित्व करते हैं। जिस तरह से गांठें बंधी हैं, अंक 1 को इस तरह से नहीं दिखाया जा सकता है और इसे इस स्थिति में एक आंकड़ा आठ-गाँठ द्वारा दर्शाया जाता है।

शून्य का प्रतिनिधित्व उपयुक्त स्थिति में गाँठ की अनुपस्थिति से होता है।

विवरण

इस चुनौती के लिए, क्विपु के प्रत्येक स्ट्रैंड एक एकल संख्या का प्रतिनिधित्व करते हैं (हालांकि, जैसा कि विकिपीडिया लेख बताता है, आप एक स्ट्रैंड पर कई संख्याओं का प्रतिनिधित्व कर सकते हैं , इस चुनौती में, हम नहीं करेंगे)।

समुद्री मील

प्रत्येक गाँठ का प्रतिनिधित्व एक एकल ASCII चरित्र द्वारा किया जाएगा।

. एक साधारण गाँठ का प्रतिनिधित्व करता है
: एक लंबी गाँठ के एक मोड़ का प्रतिनिधित्व करता है
8 एक आंकड़ा-आठ गाँठ का प्रतिनिधित्व करता है
| एक गाँठ के अभाव के साथ-साथ अंकों के बीच एक सीमांकक का प्रतिनिधित्व करता है।

Quipus का निर्माण

इन नियमों का पालन करते हुए क्विपु का निर्माण किया जाता है।

स्थिति के अवरोही क्रम में स्ट्रैंड्स ऊपर से नीचे तक चलते हैं (जैसा कि, यूनिट अंक एक स्ट्रैंड के निचले सिरे पर होगा)। एक किनारा के साथ अंक चरित्र ( |) द्वारा अलग किए जाते हैं ।
10 अंकों की शक्ति का प्रतिनिधित्व करता है, उसकी स्थिति स्ट्रैंड के साथ-साथ निर्धारित की जाती है, उसी प्रकार 10 अंकों की शक्ति की गणना हमारी संख्या प्रणाली के साथ एक संख्या में उसके सूचकांक का उपयोग करके की जाएगी। यही कारण है, 24एक साथ 2दहाई के स्थान में है और एक 4इकाइयों जगह में दो समुद्री मील, एक सीमांकक (द्वारा प्रतिनिधित्व किया जाएगा |), तो चार समुद्री मील।
उसी स्थिति में अंक स्ट्रैंड के नीचे की ओर संरेखित होते हैं। यदि किसी स्थिति में एक अंक में एक ही स्थिति में अन्य संख्याओं के अन्य अंकों की तुलना में कम समुद्री मील होंगे, तो उन समुद्री मील की अनुपस्थिति को ( |) द्वारा दर्शाया जाता है ।
लगातार साधारण समुद्री मील ( .) उनकी स्थिति में एक मूल्य का प्रतिनिधित्व करते हैं।
हर अंक को कम से कम 1 वर्ण द्वारा दर्शाया जाता है। जब एक क्विपु में सभी संख्याओं के लिए अंकों का मान 0 होता है, तो यह एक गाँठ ( |) की अनुपस्थिति का प्रतिनिधित्व करता है ।
इकाइयों का स्थान विशेष रूप से व्यवहार किया जाता है। इकाइयों में से एक को एक आंकड़ा-आठ गाँठ ( 8) द्वारा दर्शाया गया है । इकाइयों में दो या दो से अधिक का मान लगातार लंबी समुद्री मील ( :) द्वारा दर्शाया जाता है ।
जब एक क्विपु में सभी नंबरों के लिए यूनिट अंक 0 होता है, तो एक गाँठ की अनुपस्थिति मुद्रित नहीं होती है लेकिन, दसियों अंक के लिए अनुगामी सीमांकक को संरक्षित किया जाता है।
इकाइयों के अंकों के बाद कोई परिसीमन नहीं होता है।

नियम

इनपुट में गैर-नकारात्मक पूर्णांकों की गैर-रिक्त सूची शामिल होगी, जो किसी भी डिफ़ॉल्ट इनपुट विधियों के माध्यम से प्राप्त हो सकती है । आप देखेंगे कि ये पूर्णांकों से सभी कम कर रहे हैं या करने के लिए बराबर मान सकते हैं 2147483647या 2^31-1। हालांकि परीक्षण के मामले अंतरिक्ष-सीमांकित हैं, आपका इनपुट प्रारूप किसी भी तरह से इनपुट को अलग कर सकता है जो आपकी भाषा के लिए सुविधाजनक है, चाहे वह अल्पविराम से अलग हो, न्यूलाइन-अलग हो, एक सरणी में, और इसी तरह।
आउटपुट में एक एकल क्विपु शामिल है जो ऊपर वर्णित नियमों के अनुसार निर्मित है। आउटपुट किसी भी डिफ़ॉल्ट आउटपुट विधियों के माध्यम से दिया जा सकता है ।
आपका कोड एक प्रोग्राम या एक फ़ंक्शन होना चाहिए, हालांकि इसे नामांकित फ़ंक्शन होने की आवश्यकता नहीं है।
समय बचाने के लिए समुद्री मील टाई करने के लिए कुछ समय लेता है, आपके कोड जितना संभव हो उतना कम।

हमेशा की तरह, अगर समस्या स्पष्ट नहीं है, तो कृपया मुझे बताएं। गुड लक और गुड गोल्फिंग!

उदाहरण

इनपुट:

5 3 1 0

आउटपुट:

:|||
:|||
::||
::||
::8|

इनपुट:

50 30 10 0

आउटपुट:

.|||
.|||
..||
..||
...|
||||

इनपुट:

आउटपुट:

.
.
.
|
.
.
.
|

इनपुट:

204 1

आउटपुट:

.|
.|
||
||
||
:|
:|
:|
:8

इनपुट:

201 0 100 222

आउटपुट:

.||.
.|..
||||
|||.
|||.
||||
|||:
8||:

इनपुट:

1073741823 2147483647

आउटपुट:

|.
..
||
|.
||
.|
.|
.|
..
..
..
..
||
|.
|.
|.
|.
..
..
..
||
.|
.|
.|
..
..
..
..
||
|.
|.
|.
|.
..
..
..
..
||
|.
|.
..
||
.|
.|
..
..
..
..
..
..
||
|.
|.
..
..
||
|:
|:
|:
|:
::
::
::

इनपुट:

आउटपुट:

लंबे समय तक परीक्षण के मामले

आगे की पढाई

code-golf number

— Sherlock9
स्रोत

माया नंबरों पर एक संबंधित चुनौती

— घातक

3

पायथ, 64 बाइट्स

=QjRTQjCmj\|+:R"[8:]"\.PdedCmm+*\|-h.MZdk*?tk\:\8kdC.[L0h.MZlMQQ

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

यह काम किस प्रकार करता है

=QjRTQ   Converts each number in input to decimal (as a list)
         123 becomes [1,2,3]

----

jCmj\|+:R"[8:]"\.PdedCmm+*\|-h.MZdk*?tk\:\8kdC.[L0h.MZlMQQ

                                              .[L0       Q  0-leftpad each #
                                                  h.MZlMQ   (max length) times

                                             C              transpose

                      mm                    d    for each digit:
                        +                        [convert to] sum of
                         *\|                     "|" repeated
                            -                    the difference of
                             h.MZd               maximum digit in same row
                                  k              and itself.. that many times
                                   *?tk\:\8      and (digit > 1 then ":" or "8") repeated
                                           k     itself many times


the list:
[11,23,52]
->[[1,1],[2,3],[5,2]]
->[[1,2,5],[1,3,2]]
->[["||||8","|||::",":::::"],["||8",":::","|::"]]

                     C      transpose

->[["||||8","||8"],["|||::",":::"],[":::::","|::"]]

  m                          for each number
      +                      [convert to] sum of
                 Pd          every element but the last
       :R"[8:]"\.            with "8" and ":" replaced by "."
                   ed        and the last element
   j\|                       joined with "|"

  C                          transpose
 j                           join (with newlines)

— लीक नन
स्रोत

यह एक समस्या को छोड़कर एक उत्कृष्ट उत्तर है। अंतिम गाँठ हमेशा एक आंकड़ा-आठ गाँठ नहीं होती है 8। वास्तव में, यह केवल एक 8गाँठ है जब अंतिम अंक 1 होता है (नियम 6 देखें)। आप सभी अंतिम समुद्री मील परिवर्तित कर रहे हैं और यह कल्पना से मेल नहीं खाता है। इसके अलावा, आपका यह ऑनलाइन प्रयास करें! लिंक का अलग कोड है जो यहाँ पोस्ट किया गया है, जाहिरा तौर पर

— शर्लक

22

अपठनीय , 3183 3001 बाइट्स

यह क्रिसमस समारोह के बीच, चालू और बंद काम करने के लिए एक मजेदार चुनौती थी। प्रविष्टि के लिए धन्यवाद! यह दिलचस्प था क्योंकि विनिर्देश अपवादों और विशेष मामलों से भरा है, जिनके लिए बहुत सारी स्थितियों की आवश्यकता होती है। इस समय, जबकि मुझे इस समय दशमलव से और उससे अधिक रूपांतरण करने की आवश्यकता नहीं थी, मुझे प्रत्येक स्थान में अंकों की सबसे बड़ी संख्या और प्रत्येक स्थान के अंकों के सबसे बड़े मूल्य को निर्धारित करने के लिए "अधिकतम" फ़ंक्शन की आवश्यकता थी ।

इसका पहला संस्करण 4844 बाइट्स था, बस आपको यह अंदाजा लगाने के लिए कि मैंने इसे कितना गॉल्फ़ किया है।

कार्यक्रम इनपुट को पूर्णांक की अल्पविराम से अलग सूची के रूप में उम्मीद करता है । कोई रिक्त स्थान या newlines। उन का उपयोग अपरिभाषित व्यवहार का उत्पादन होगा।

' "" "" "" ""' "" ' ""' "" ' ""' "" " '" "" "" "" ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" "" "" ' ""' "" ' ""' "" ' ""' "" ' "" "'" " ' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" '"" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' ""' "" "" "" ' " "" "" "" "" "" ' ""' "" ' ""' "" ' ""' "" "" "" ' ""' "" " '" "'" " '" "' "" ' ""' "" ' ""' "" ' "" "'" "" "" ' "" "" ""' "" " '" "" "" "" "" "" """ "" "" ' "" "" "" "" "" "" "" "" "'" " '" "'" "" "" "" "" "" "" "" ' "" "" "" "" ""' "" "" "" ' ""' "" ' ""' "" " '" "" "" "" "" "" "" "' "" "" "" "" ' ""' "" " '" "" "" "" ""' "" ' ""' "" ' ""' "" ' "" "'""" "" "" "" "" "" "" ' "" "" ""' "" ' "" "'" " '" "" "" "" ""' "" " '" " ' "" "" "'" "" "" " '" "'" " '" ""' "" "" "" "" "" "" "" " '" "'" " '" "" ' "" "" "" ""' "" ' ""' "" " '" "" "" "" "" "" "" "" ""' "" ' ""' """ ' "" "" "" "" "" ""' "" " '" "" "" "" "" "" "" "" "" "'" "" "" "" "" ' "" "" "" "" "" "" ""' "" "" "" "" ' ""' "" " '" "" ""' "" "" "" " ' "" "" "" "" ""' "" "" "" "" " '" "" "" "" "" "" "" "" "" "'" """ "" "" "" " '" ""' "" ' "" "" "" "" ""' "" "" "" "" "" ' ""' "" ' "" ' "" "" "" "" "" "" ""' "" "" " '" "" "" "" "" "" "" "'" "" "" "" "" " '" "'" "" "" "" "" "" "" "" "" ' "" "" "" "" "'" "" "" "" "" """" "" " '" "" "" "" "" "'" "" "" "" "" "" "" " '" "" "" "" "" "'" "" ' "" "" "" "" "" "'" "" "" "" "" "" "" " '" "'" "" ' ""' "" ' ""' "" ' "" ' ""' "" ' ""' "" "" "" "" "" "" "" "" "" "" " '" "'" "" ' ""' """ "" "" ' ""' "" "" "" "" "" "" "" "" "" "" "" ' ""' "" ' ""' "" ' " " '" "'" " '" ""' "" "" "" "" ' ""' "" ' ""' "" " '" "" "" "" "" "" ""' "" ' "" "" "'" "" "" "" ' ""' "" "" "" ' "" "" "'" "" "" "" "" "" "" '" "'" "" ' "" "" "" "" "" "" "" "'" " '" "" "" "" "" "" "" "" "" "" " '" "" "" "" "" "" ""' "" ' ""' "" ' ""' "" ' ""' "" ' "" "'" "" "" "" " ' "" "" "" "" "'" " '" "'" " '" "'" " '" "'" "" ' "" "" "" "" "'" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" " '" "" "" "" ""' "" "" "" " '" "'" " '" "'" "" ' "" "" "" ""' "" ' ""' "" ' "" "'" ' "" "" "" "" "' "" ' "" "" "" "" "" "" ""' "" ' "" "" "" "" "" "" ""' "" ' "" "" """ ' "" "" "" "" "'" "" ' "" "" "" "" ""' "" "" "" " '" "'" "" "" "" " "" "" "" "" "" "" "" " '" "" "" "" "" "'" "" "" "" "" "" "" " '" "' "" "" "" "" "" "" "" "" " '" "" "" "" "" "" "" "'" " '" "'" "" """ "" "" "" "" ' ""' "" "" "" ' "" "" "" "" "" "'" " '" "" "" "" "" " "" "" "" ' "" "'" "" "" "" "" "" "" "" "" "" ' "" "" "" "" "" "" "" " ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'" "" "" "" "" ' ""' "" "" "" "" ""' "" "" "" "" " '" "'" " '" "'" " '" "'" "" ' ""' "" ' " "" "" "" "" ' ""' "" ' ""' "" ' "" "'" "" "" "" "" "" "" "" "" " '" "" "" "" "" ' ""' "" ' ""' "" ' "" "'" "" "" "" "" "" "" "" "" "" "" "' ""' "" "" " '" "" "" "" "" "" ""' "" ' ""' "" " '" "" "" "" "" "" "" " " '" "'" " '" ""' "" "" "" "" "" "" " '" "'" "" "" "" "" "" "" "" "" " ' "" "" "" "" "'" "" ' "" "" "" "" "" "" "" "" "" "" "'" " '" "'"" '" "'" "" "" "" "" ' ""' "" " '" "" "" "" "" "" "" "'" "" "" "" "" " '" ""' "" "" "" "" "" " '" "" "" "" "" "" ""' "" ' "" "" "" "" "" "' "" "" "" "" "" "" "" ' ""' "" "" "" ' "" "" "'" "" "" "" "" "" ""' ""' "" ' "" "'" " '" "" "" "" ""' "" ' "" "'" "" "" "" "" "" "" "" " '" "" "" "'" "" "" "" ' ""' "" "" "" "" "" "" "" "" "" "" "" "" " '" " '" ""' "" "" "" "" "" "" ' ""' "" ' "" "'" "" "" "" "" "" "" "" ' "" '" "'" "" ' "" "" "" "" "" "" "" "" "" "" "'" " '" "'" "" ' ""' "" " "" "" "" ' ""' "" " '" "" "" "" "" "" "" ""' "" " '" "'" "" "" "" "" "" "" " '" "'" "" ' "" "" "" "" "'" " '" "" "" "" "" "'" "" "" "" """" "" " '" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""' "" ' ""' "" " ' "" "" ""' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ' ""' "" " ' ""' "" "" "" "" " '" ""' "" "" "" "" " '" "'" " '" "'" "" ' "" "'""" "" "" "" "" "" "" "" " '" "'" " '" ""' " '" "" "" "" "" "" "" ""' " "" ' "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " '" "" "" "" "" "'" "" "" "" "" ' "" "" "" "" "'" " '" "'" "" ' "'"" ' ""' "" ' ""' "" ' ""' "" ' ""' "" ' "" "'" "" "" "" "" ' "" "" "" "' "" "" "" "" "" "" "" "" " '" "'" " '" "'" "" ' "" "" "'" "" "" "" "" " "" "" " '" "'" "" ' "" "" "" "" "" "" "" "" "'" " '" ""' "" "" "" '"" "" "" "" "" ' "" "" "" "" "" "" "" "" "" "" "" "" "'" ""

व्याख्या

मैं आपको दिखाने जा रहा हूं कि प्रोग्राम आपको कैसे दिखाता है कि यह विशिष्ट इनपुट को कैसे संसाधित करता है 202,100,1।

शुरुआत में, हम कुछ मानों का निर्माण करते हैं जिनकी हमें बाद में आवश्यकता होगी - ज्यादातर ASCII वर्ण जो हम आउटपुट करेंगे।

जैसा कि आप देख सकते हैं, '8'और '.'पहले से ही उपलब्ध हैं। '|'हालाँकि, यह वास्तव में 124 है, 14. नहीं। हम 124 पाने के लिए इस पर स्लॉट # 1 में दो बार अस्थायी मान जोड़ने के लिए थोड़ी देर के लूप का उपयोग करते हैं (जो कि 14 + 55 × 2 है, क्योंकि लूप 56−1 = 55 के लिए चलता है पुनरावृत्तियों)। यह कुछ बाइट्स बचाता है क्योंकि बड़े पूर्णांक शाब्दिक जैसे 124 वास्तव में लंबे होते हैं। निम्नलिखित चित्र में, मैं उस प्रोग्राम का उपयोग करने वाले प्रत्येक चर का स्थान दिखाता हूं।

अगला, हम सभी वर्णों को इनपुट करना चाहते हैं और सेल # 12 पर शुरू होने वाले टेप पर संग्रहीत करते हैं ( पी इसके लिए रनिंग पॉइंटर है)। साथ ही हम यह जानना चाहते हैं कि सबसे लंबी संख्या (कितने अंक) है। इसे प्राप्त करने के लिए, हम सेल # starting1 पर शुरू होने वाले लेयर में एक कुल रनिंग करते हैं (हम रनिंग पॉइंटर के रूप में q का उपयोग करते हैं )। पहले इनपुट नंबर ( 202) के बाद, टेप अब इस तरह दिखता है:

आपने देखा होगा कि संख्याएँ 4 से बंद हैं। खैर, जब हम पहली बार उन्हें इनपुट करते हैं, तो वे उनके ASCII मान हैं, इसलिए वे 48 से "बंद" हैं और अल्पविराम 44 है। प्रत्येक चरित्र के लिए, हम 46 से कॉपी करते हैं '.'में आर और फिर थोड़ी देर के पाश (जो 45 घटा देती है) के साथ यह घटाना और फिर हम 1. जोड़ने हम जानते हैं कि ताकि अल्पविराम (हमारे विभाजक) 0 है, इसलिए हम एक सशर्त उपयोग कर सकते हैं यह पहचान करने के लिए है।

इसके अलावा, आपने देखा होगा कि हम सेल # 11 को 0. पर छोड़ देते हैं। हमें पहले नंबर की सीमा को पहचानने की आवश्यकता है।

अगला चरित्र अल्पविराम होगा, इसलिए हम # 15 में 0 स्टोर करते हैं, लेकिन निश्चित रूप से इस बार हम q को अग्रिम नहीं करते हैं । इसके बजाय, हम q को 0 पर सेट करते हैं और 1s को "ओवरराइटिंग" शुरू करते हैं जो हमने पहले ही रखा है।

शेष सभी पात्रों को संसाधित करने के बाद, हमें यह मिलता है:

जैसा कि आप देख सकते हैं, q द्वारा लिखे गए 1s अब इंगित करते हैं ( एकात्मक में) सबसे लंबी संख्या की लंबाई।

अब हम कुछ समय के लिए q को स्थानांतरित करने के लिए थोड़ी देर के लूप का उपयोग करते हैं , और फिर वहां एक और पॉइंटर लगाते हैं जिसे मैं r2 कहूंगा । R2 का उद्देश्य बाद में स्पष्ट हो जाएगा।

इस बिंदु पर, मुझे उस शब्दावली को स्पष्ट करना चाहिए जो मैं इस पूरे उपयोग में लाऊंगा।

तक नंबर , मैं इनपुट संख्या कि अल्पविराम के द्वारा अलग कर रहे हैं में से एक मतलब है। हमारे उदाहरण में, वे 202, 100 और 1 हैं।
द्वारा अंकों , मैं नंबर की एक विशिष्ट एक में एक एकल अंक मतलब है। पहले नंबर पर 3 अंक होते हैं।
द्वारा जगह , मैं इकाई के स्थान, दहाई के स्थान, सैकड़ों जगह, आदि तो इसका मतलब यह है कि अगर मैं कहते हैं कि "वर्तमान जगह में अंक", और वर्तमान जगह लोगों को जगह है, उन अंकों 2, 0 कि में हैं, और 1 आदेश।

अब वापस हमारे नियमित प्रोग्रामिंग पर जाएँ। कार्यक्रम का पूरा बाकी एक बड़ा लूप है जो q को आगे बढ़ाता है जब तक कि यह सेल # 0 तक नहीं पहुंच जाता। रास्ते में मौजूद प्रत्येक कोशिका एक स्थान का प्रतिनिधित्व करती है, जिसके सबसे दाईं ओर जगह होती है, और q सबसे महत्वपूर्ण स्थान पर शुरू होगा। हमारे उदाहरण में, वह सैकड़ों जगह है।

हम (यानी, * q ) पर सेल q अंक बढ़ाकर आगे बढ़ते हैं ।

अब हम "स्टेज 2" में सैकड़ों स्थान पर हैं। इस चरण में, हम यह पता लगाएंगे कि सैकड़ों अंकों में सबसे बड़ा अंक क्या है। हम इसके लिए एक ही यूनिरी काउंटिंग ट्रिक का उपयोग करते हैं, इस समय को छोड़कर पॉइंटर को r कहा जाता है और पॉइंटर r2 इसकी शुरुआती स्थिति को चिन्हित करता है जिसके लिए हमें हर बार अगले नंबर पर जाने के लिए इसे रीसेट करने की आवश्यकता होती है।

पहले नंबर से शुरू करते हैं। हम पी से 11 (सभी संख्याओं की हार्ड-कोडित शुरुआती स्थिति) की स्थापना करते हैं । फिर हम संख्या के अंत का पता लगाने के लिए थोड़ी देर के लूप का उपयोग करते हैं और वहां स्थिति को चिह्नित करने के लिए P2 सेट करते हैं। उसी समय, हमने q2 को 0 पर भी सेट किया :

इस तथ्य से विचलित न हों कि q2 vars में इंगित हो रहा है। हमारे पास वहाँ एक रिक्त कक्ष की गद्दी नहीं है क्योंकि हम सेल का पता लगा सकते हैं क्योंकि यह संख्या शून्य है।

इसके बाद, हम p और q2 को एक साथ घटाकर वर्तमान संख्या से गुजरते हैं जब तक कि * p शून्य नहीं होता। प्रत्येक स्थान पर, * q2 का मान बताता है कि हमें क्या करने की आवश्यकता है। 1 का अर्थ है "कुछ मत करो", इसलिए हम चलते रहते हैं। अंततः हम सेल # 2 में 2 का सामना करते हैं। हर बार * q2 1 के बराबर नहीं होता, q2 हमेशा q के बराबर होता है ।

जैसा कि मैंने पहले ही कहा था, स्टेज 2 "इस जगह का सबसे बड़ा अंक है"। इसलिए हम r2 को r पर सेट करते हैं, जबकि थोड़ी देर के लूप का उपयोग * पी से घटाएं और r को बाईं ओर ले जाएं और 1s के साथ टेप भरें, और फिर r का उपयोग करें जबकि r को दाईं ओर वापस ले जाएं और मूल्य को बहाल करने के लिए फिर से * p फिर से बढ़ाएं। याद रखें कि हर बार लूप उस मूल्य से एक कम पुनरावृत्ति के लिए चलता है, जिस पर हम उसका उपयोग करते हैं; इस वजह से, लिखे गए 1s की संख्या अंकों के मूल्य से 3 अधिक (4 के बजाय) होगी, और * p में वापस संग्रहीत अंतिम मान 2 और होगा। इस प्रकार, इसने प्रभावी रूप से 2 से * p घटाया है ।

उसके बाद, हम सेट पी के मूल्य के p2 और फिर हम सभी इसे पुन: करें। दूसरी बार, q2 को 0 पर सेट करें, दाईं ओर p स्थानांतरित करके संख्या का अंत ज्ञात करें , और फिर p और q2 को एक साथ घटाकर इस संख्या के अंकों के माध्यम से जाएं। एक बार फिर हम सेल # −3 में 2 का सामना करेंगे और लिखेंगे कि * r के कई 1s बचे हैं ।

तीसरे नंबर के मामले में, हम कुछ भी नहीं कर रहे हैं क्योंकि इसमें सैकड़ों जगह नहीं है (इसलिए q2 कभी भी q तक नहीं पहुंचता है ), लेकिन यह ठीक है क्योंकि यह अधिकतम अंकों के मूल्य की गणना को प्रभावित नहीं करता है।

हमने सेल * (r - 4) भी सेट किया है , जिसे मैंने यहां एक अनलिस्टेड एरो के साथ 1 के रूप में चिह्नित किया है (भले ही यह पहले से ही 1 है)। मैं आपको यह बताने नहीं जा रहा हूं कि अभी तक क्यों, लेकिन शायद आपने पहले ही अनुमान लगा लिया है?

* Q की अगली वृद्धि हमें स्टेज 3 तक ले जाती है, जो "वर्तमान स्थान के सभी अंकों से अधिकतम अंक घटाना" है। पहले की तरह, हम पी को 11 और q2 से 0 पर रीसेट करते हैं और फिर सभी संख्याओं से गुजरते हैं जैसे हमने पिछले चरण में किया था; इस समय को छोड़कर, * क्ष = 3 के बजाय 2. हर बार जब Q2 को पूरा करती है क्ष और पी एक सैकड़ों जगह में है, हम का उपयोग कुछ समय घटती को पाश * पी के रूप में वहाँ ब्लॉक के बाएँ में 1s हैं कई बार के रूप * r2 (5 हमारे उदाहरण में) r का उपयोग करकेएक रनिंग पॉइंटर के रूप में। हम वास्तव में इसे एक बार से अधिक घटाते हैं ताकि सबसे बड़ा अंक ,2 पर समाप्त हो जाए, इस कारण से कि बाद में स्पष्ट हो जाएगा:

हमने सभी नंबरों को संसाधित करने के बाद, अब हम चरण 3 के अंत में हैं। यहां हम दो विलक्षण चीजें करते हैं।

सबसे पहले, हम r -block (प्लस 1) के आकार को भी * q से घटाते हैं , लेकिन r2 पॉइंटर का उपयोग करते हुए , जो इसे बाईं ओर छोड़ देता है। * q इस तरह नकारात्मक हो जाता है। हमारे मामले में, r -block के पांच 1s हैं, इसलिए * q −3 हो जाता है।
दूसरा, हम एक चर सेट बाहर से संकेत मिलता है कि हम अब उत्पादन चरण में प्रवेश कर रहे हैं एक गैर शून्य मान के लिए। (तकनीकी रूप से, यह तथ्य कि * q ऋणात्मक है, पहले से ही आउटपुट अवस्था को इंगित करता है, लेकिन यह जाँच करना बहुत मुश्किल है, इसलिए अतिरिक्त चर है।)

अब आप समझते हैं कि हम संख्याओं से गुजर रहे हैं, प्रत्येक स्थान के भीतर वर्तमान स्थान ( * q के गैर -1 मान द्वारा दर्शाया गया है ) को खोजें, और * q के मूल्य के आधार पर कुछ करें । हम देखते हैं कि * q पहले 2 (= अधिकतम अंक मूल्य की गणना) में वृद्धि की जाती है, फिर 3 (इस स्थान में प्रत्येक अंक से अधिकतम अंक मूल्य घटाएं) और फिर हम इसे नकारात्मक बनाने के लिए इसे घटाते हैं। वहां से, यह 1 तक पहुंचने तक जारी रहेगा, इस प्रकार मूल्य को बहाल करने का मतलब है कि "कुछ भी नहीं"। उस बिंदु पर, हम अगले स्थान पर जाते हैं।

अब, जब * q ऋणात्मक है, हम आउटपुट कर रहे हैं। * q बिल्कुल सही मूल्य पर है ताकि हम 1 तक पहुँचने से पहले वर्णों की सही संख्या का उत्पादन कर सकें; यदि सबसे बड़ा अंक 2 है, तो हमें 3 पंक्तियों को आउटपुट करने की आवश्यकता है। आइए देखें कि प्रत्येक मूल्य पर क्या होता है * क्ष :

* q = −2:
- पहले नंबर के लिए, * p ,2 है, जो इंगित करता है कि हमें a '.'(dot) या a ':'(colon) आउटपुट करने की आवश्यकता है । हम तय करते हैं कि क्यू को देखकर : यदि यह we're1 है, तो हम एक ही स्थान पर हैं, इसलिए आउटपुट ':'(जिसे हम '8'+2 के रूप में गणना करते हैं ), अन्यथा ए '.'।
- दूसरे नंबर के लिए, * p −3 है। कुछ भी जो −2 नहीं है, इसका मतलब है कि हम '|'(पाइप) आउटपुट करते हैं और फिर मूल्य बढ़ाते हैं। इस तरह यह सही जगह पर −2 तक पहुंच जाएगा और फिर हम उस अंक के बाकी हिस्सों के लिए '.'s / ':'s आउटपुट करते हैं।
- प्रत्येक मामले में, हम नंबर को प्रोसेस करने से पहले एक वैरिएबल पीडी को भी 0 पर सेट करते हैं, और एक गैर-शून्य मान के लिए पीडी (= "प्रिंटेड") सेट करके यह दर्शाते हैं कि हमने एक कैरेक्टर प्रिंट किया है।
- तीसरे नंबर के लिए, कोई प्रोसेसिंग नहीं होती है क्योंकि तीसरे नंबर में सैकड़ों जगह नहीं होती है। इस मामले में, पीडी अभी भी नंबर संसाधित करने के बाद 0 रहेगी, जिसका अर्थ है कि हम अभी भी उत्पादन एक करने की जरूरत है '|'(लेकिन केवल तभी बाहर है गैर शून्य, क्योंकि अन्यथा हम चरण 2 या 3 में अब भी कर रहे हैं)।
- सभी नंबरों को प्रसंस्करण के बाद, यदि बाहर गैर शून्य, उत्पादन एक नई पंक्ति है। ध्यान दें कि हमें आउट वेरिएबल की जरूरत है ताकि हम स्टेज 2 या 3 में न्यूलाइन को आउटपुट न करें।
* q = * 1: पहले की तरह ही, सिवाय इसके कि * p both2 है जो दोनों पहले दो संख्याओं के लिए है, इसलिए दोनों आउटपुट a'.'(और तीसरा आउटपुट'|'पहले जैसा है)।
* q = 0: जब * q 0 होता है, इसका मतलब है "कुछ भी नहीं अगर हम एक ही स्थान पर हैं, अन्यथा'|'एसकी एक पंक्ति का उत्पादन करें,भले ही * p "। इस तरह हमें अंकों के बीच पैडिंग मिलती है।

अब हम आगे बढ़ने के लिए q को बढ़ाते हैं , अगले स्थान पर दसवें स्थान पर जाते हैं, और वहां * qrement * बढ़ाते हैं । स्टेज 2 की शुरुआत में, टेप इस तरह दिखता है:

फिर हम पहले की तरह ही स्टेज 2 का प्रदर्शन करते हैं। यह याद रखें कि इस स्थान के प्रत्येक अंक से प्रभावी रूप से 2 घटाएं और अधिकतम अंक का संकेत देने वाले * r2 के बचे हुए संख्या को भी छोड़ देता है । हम पिछले एकाकी संख्या को अकेले छोड़ देते हैं और बस टेप को बाईं ओर बढ़ाते रहते हैं; यह केवल "साफ" करने के लिए अनावश्यक अतिरिक्त कोड खर्च होंगे। जब हम कर रहे हैं और हम वृद्धि * * , स्टेज 3 की शुरुआत में अब टेप है:

दरअसल, यह एक झूठ है। पहले याद रखें कि मैंने कहां कहा कि हमने * (r - 4) को 1 पर सेट किया है और मैंने आपको क्यों नहीं बताया? अब मैं आपको बताता हूँ कि क्यों। यह इस तरह के मामलों के लिए है, जहां सबसे बड़ा अंक वास्तव में 0 है, जिसका अर्थ है कि इस जगह के सभी अंक 0. सेटिंग * (आर - 4) हैं , जो ऊपर दिए गए गैर-लिंक किए गए तीर द्वारा इंगित किया गया है, 1 को 1 से एकतरफा संख्या को बढ़ाता है, लेकिन केवल इस विशेष मामले में। इस तरह हम दिखावा करते हैं जैसे कि सबसे बड़ा अंक 1 था, जिसका मतलब है कि हम एक अतिरिक्त पंक्ति का उत्पादन करेंगे।

चरण 3 के बाद (वर्तमान स्थान में सभी अंकों से अधिकतम अंक घटाएं), अतिरिक्त चरण जो * q नकारात्मक बनाता है, सहित टेप इस तरह दिखता है। पिछली बार * p ब्लॉक में * 2 द्वारा सबसे बड़े अंक का प्रतिनिधित्व किया गया था , लेकिन इस बार वे सभी because3 हैं क्योंकि वे सभी वास्तव में शून्य हैं लेकिन हम दिखावा कर रहे हैं जैसे कि अधिकतम अंक 1 था।

अब देखते हैं कि क्या होता है * q 1 की ओर बढ़ता है:

जब * q = * 1, * p मान सभी which3 हैं, जिसका अर्थ है कि हम '|'उन्हें आउटपुट करते हैं और बढ़ाते हैं।
जब * q = 0, हम आउटपुट करते हैं '|'क्योंकि यही हम हमेशा करते हैं जब * q = 0, * p की परवाह किए बिना ।

इस प्रकार, हमें पाइप की दो पंक्तियाँ मिलती हैं।

अंत में, हम * q को एक स्थान पर ले जाते हैं। यह एक दिलचस्प हो जाता है क्योंकि हमें ':'वास्तविक उत्पादन कुछ भी नहीं है '8'अगर 1 अंक है, लेकिन अगर यह 1. है तो आइए देखें कि कार्यक्रम कैसे आगे बढ़ता है। सबसे पहले, हम स्टेज 2 को शुरू करने के लिए * q बढ़ाते हैं :

स्टेज 2 ("अधिकतम अंक मान की गणना करें") के बाद, हम इसके साथ बचे हैं:

चरण 3 के बाद ("वर्तमान स्थान के सभी अंकों से अधिकतम अंकों का मूल्य घटाएं") टेप इस तरह दिखता है:

अब बारी में * q के प्रत्येक पुनरावृत्ति के माध्यम से चलते हैं:

* q = −2:
- सबसे पहले नंबर: पर -2 पहले से ही है, तो उत्पादन एक ':'(बजाय एक '.'क्योंकि क्ष = -1)।
- दूसरी संख्या: ,4 पर, इसलिए एक '|'और वेतन वृद्धि।
- तीसरा नंबर: ,3 पर, इसलिए आउटपुट ए '|'। हालांकि, इस बार, वेतन वृद्धि के बजाय, एक विशेष मामला ट्रिगर होता है। केवल तब जब हम अंतिम स्थान ( q = −1) का उत्पादन कर रहे हैं , और हम उस ( * q = q2) के लिए दूसरी-अंतिम पंक्ति में हैं , और अंक वास्तव में 1 ( * p = −3) है , फिर इसे instead2 तक बढ़ाने के बजाय, हमने इसे re1 पर सेट किया। दूसरे शब्दों में, हम ,1 का उपयोग एक विशेष मान के रूप में करते हैं ताकि यह पता चले कि अगले पुनरावृत्ति में, हमें '8'इसके बजाय आउटपुट की आवश्यकता होगी ':'।
* q = −1:
- पहली संख्या: पहले से ही −2 पर, इसलिए आउटपुट ए ':'।
- दूसरी संख्या: ,3 पर, इसलिए आउटपुट a '|'। विशेष स्थिति ट्रिगर नहीं करती है क्योंकि * q अब trigger2 नहीं है। इसलिए वेतन वृद्धि।
- तीसरा नंबर: .1 पर, इसलिए आउटपुट '8'।
* q = 0: आमतौर पर, हम'|'यहाँ sकी पैडिंग पंक्ति को आउटपुट करेंगे, लेकिन विशेष स्थिति में जहाँ हम एक ही स्थान पर हैं ( q = −1), हम इसे छोड़ देते हैं।

इसके बाद, क्यू 0 में वृद्धि होती है और लूप समाप्त होने पर बड़ा होता है।

अब आप जानते हैं कि इनपुट कैसे 202,100,1काम करता है। हालाँकि, एक और विशेष मामला है जिसे हमने अभी भी कवर नहीं किया है। आपको याद हो सकता है कि जब हम अंतिम स्थान का प्रसंस्करण कर रहे थे, जब * p set3 था तो हमने इसे −1 के लिए to1 पर सेट किया 1(बजाय इसे (2 में वृद्धि के) ताकि अगली पुनरावृत्ति '8'इसके बजाय आउटपुट करेगी । यह केवल इसलिए काम करता है क्योंकि हमारे पास एक पुनरावृत्ति है जिसमें * p we3 है और हम एक निर्णय लेते हैं कि क्या इसे बढ़ाना है या इसे −1 पर सेट करना है। हम नहीं है इस तरह के एक यात्रा है, तो सभी इकाई के स्थान में अंकों की 0 या 1. हैं इस तरह के एक मामले में सभी * p 1s हैं के लिए मूल्यों से शुरू -2 में; इसे no1 पर सेट करने का निर्णय लेने का कोई अवसर नहीं हैबल्कि इसे बढ़ाने के लिए ment3 से । इस वजह से, स्टेज 3 के अंदर एक और विशेष आवरण स्थिति है ("वर्तमान स्थान में प्रत्येक अंक से अधिकतम अंक घटाएं")। मैंने दावा किया कि प्रत्येक अंक से अधिकतम अंकों के मूल्य को घटाकर (जिस बिंदु पर अधिकतम अंक )1 पर है), हम इसे एक बार फिर से घटाते हैं, लेकिन वास्तव में इस पर एक शर्त है जो निम्नानुसार है:

यदि हम जो अंक देख रहे हैं, वह इस जगह ( * p = )1) के अधिकतम अंक के बराबर है , और यह स्थान लोगों का स्थान ( q = −1) है, और अधिकतम अंक 1 ( * (r +) है 5) = 0, (बहुत बाईं ओर गैरी ब्लॉक केवल 5 सेल लंबा है), तभी हम उत्पादन की एकमात्र पुनरावृत्ति को इंगित करने के लिए ie1 पर * p छोड़ते हैं '8'। अन्य सभी मामलों में हम इसे एक बार फिर घटाते हैं।

किया हुआ। नया साल मुबारक हो!

1 संपादित करें (3183 → 3001): कुछ नया साल मुबारक! मैं चर p2 और r2 से पूरी तरह से छुटकारा पाने में कामयाब रहा ! p अब संख्याओं की शुरुआत और अंत खोजने के लिए आगे और पीछे दौड़ता रहता है, लेकिन यह कोड में छोटा लगता है। मैंने q2 से भी छुटकारा पाने की कोशिश की , लेकिन मैं कोड को इस तरह छोटा नहीं बना सका।

मुझे कुछ और जगहें भी मिलीं, जहाँ मैं कुछ समय के लिए लूप के अंतिम मूल्य का फिर से उपयोग करने जैसे विशिष्ट अपठनीय गोल्फिंग गुर लगा सकता था। इसके बदले आपको एक उदाहरण देना है
```
while *(++p) { 1 }         // just increment p until *p is 0; the 1 is a noop
if (pd) { x } else { y }   // where pd is a variable
```
मैं इसे इस तरह से लिखकर ( '""""पहले, फिर दूसरे) और '"""(लगातार 1) बचा सकता हूं
```
if (while *(++p) { pd }) { x } else { y }
```
बेशक, यह केवल तभी काम करता है जब मुझे पता है कि जबकि लूप कम से कम एक पुनरावृत्ति के लिए चलेगा, लेकिन अगर यह होता है, तो इसका रिटर्न वैल्यू पीडी है इसलिए मैं इसे इफ़ेक्ट के रूप में उपयोग कर सकता हूं।

— Timwi
स्रोत

"अपठनीय" निश्चित रूप से एक उपयुक्त नाम है ...

— एलेक्स ए।

9

-1 पर्याप्त व्याख्या नहीं

— द हैट

7

जावास्क्रिप्ट (ES6) 750 744 690 604 498 346 245 234 बाइट्स

मैं PPCG के लिए नया हूं और मैंने सोचा कि मैं यह कोशिश कर सकता हूं यह सोचकर कि यह सरल था। लड़का मैं गलत था !! मैं थोड़ी देर के लिए इस पर काम कर रहा हूं और मेरे पास बहुत कुछ करने के लिए गोल्फ है ...
सुझावों को प्रोत्साहित किया जाता है! - हालांकि यह समझ में आना एक आसान काम नहीं होगा।

आउटपुट रस्सियों जब इनपुट संख्या की एक सरणी है (जैसे:) [204, 1]।

a=>(o=m=s="",l=a.map(n=>(s+="|",l=(n+"").length)>m?m=l:l),h=[],a=a.map((n,i)=>[..."0".repeat(m-l[i])+n].map((d,j)=>d<h[j]?d:h[j]=d)),h.map((n,i)=>{i?o+=s+`
`:0;for(j=n;j--;o+=`
`)a.map(d=>o+="|.:8"[d[i]-j<1?0:i<m-1?1:d[i]-1?2:3])}),o)

व्याख्या

a=>(

  o=m=s="",                      // m = max number of digits in a number, s = separator string         
  l=a.map(n=>(                   // l = lengths of each number
      s+="|",                    // set the separator string
      l=(n+"").length                 // convert each number to a string
    )>m?m=l:l                    // get max length
  ),
  h=[],
  a=a.map((n,i)=>
    [..."0".repeat(m-l[i])+n]    // add leading 0s to make all same length
    .map((d,j)=>d<h[j]?d:h[j]=d) // set each digit of h to max
  ),

  h.map((n,i)=>{
    i?o+=s+`
`:0;
    for(j=n;j--;o+=`
`)
      a.map(d=>
        o+=
          "|.:8"[
            d[i]-j<1?0
            :i<m-1?1
            :d[i]-1?2:
            3
          ]
      )
  }),
  o
)

उदाहरण

इनपुट: संख्या की संख्या: [4,8,15,16,23,42]
आउटपुट:

|||||.
|||||.
||||..
||....
||||||
|:||||
|:||||
|:|:||
|:::||
::::||
:::::|
::::::
::::::

— Aᴄʜᴇʀᴏɴғᴀɪʟ
स्रोत

+1 प्रभावशाली गोल्फ। क्या आप इनपुट और आउटपुट के साथ एक उदाहरण शामिल करेंगे?

— डेविड डिक

@ डेविड धन्यवाद! और उदाहरण शामिल है। इसे कंसोल से कॉल करें और यह एक स्ट्रिंग लौटाता है। :)

— Aᴄʜᴇʀᴏɴғᴀɪʟ

7

पायथन 3, 624 598 595 574 561 535 532 527 525 426 345 328 324 294 288 286 283 280 267 265 255 251 245 238 235 234 230 228 बाइट्स

z=input().split();v=max(map(len,z));d=''.join(i.zfill(v)for i in z);x=['']*len(z)
for k,c in enumerate(d):j=k%v;m=int(max(d[j::v]));c=int(c);x[k//v]+="|"*(m-c+0**m+(j>0))+":8."[(c<2)|-(j<v-1)]*c
for r in zip(*x):print(*r,sep='')

खैर, चूंकि इस सवाल का जवाब चाहिए था, मैंने यहां एक प्रदान किया है, जहां इनपुट को संख्याओं के एक अलग-अलग स्ट्रिंग होना चाहिए, जैसे "204 1"। लड़का, क्या यह एक लंबा है। किसी भी गोल्फिंग सुझाव (या बेहतर जवाब) का स्वागत है।

संपादित करें: टैब और रिक्त स्थान को मिलाकर बाइट्स सहेजे गए।

संपादित करें: मैंने एक नंबर के अंकों को प्राप्त करने के तरीके को बदलकर बहुत सारे बाइट्स को बचाया (संख्या के शून्य-गद्देदार स्ट्रिंग से एक सूची बनाएं, फिर कोड के शरीर में, सैकड़ों अंक, दस अंक आदि प्राप्त करने के लिए संक्रमण करें। ।)

संपादित करें: और मैंने उस अंतिम :8लूप को मुख्य क्विपु लूप में शामिल करके कुछ और बचाया । ~~अब अगर केवल मैं समझ सकता हूं कि b=d[j*v+i]==m(d[i::v])काम क्यों नहीं होगा।~~ यह पता लगा और समाधान बहुत सारे बाइट्स लेता है। (इसके अलावा बाइट काउंट गिरा क्योंकि किसी तरह टैब चार स्थानों में बदल गए। यह शायद इस साइट पर कोड स्वरूपण था)

संपादित करें: मैंने पुनर्गठित किया कि क्विपस कैसे बना। अब यह एक बार में एक स्ट्रैंड बनाता है, फिर प्रिंटिंग के लिए स्थानांतरित करता है।

संपादित करें: मेरे उत्तर को कुछ और बाइट्स को बचाने के लिए पायथन 3 कार्यक्रम में वापस लाया।

संपादित करें: मुझे अपने कोड में एक बग मिला जिसने इसे बनाया ताकि यह संख्याओं के बीच में जीरो को सही ढंग से प्रिंट नहीं कर रहा था (देखें परीक्षण मामले 204 1)। इसे ठीक करने में, मैं इसे गोल्फ में कामयाब रहा :)

संपादित करें: मैंने 10 बाइट बचाने के लिए मुद्रण को बदल दिया। और मैं सभी पुराने बाइट काउंट को वापस रख देता हूं, सिर्फ इसलिए।

संपादित करें: चार बाइट्स के लिए vउपयोग करने के काम में जुटे map। कारपेटपाइथन को श्रेय , क्योंकि मुझे यहां उनके उत्तर से विचार मिला ।

संपादित करें: मध्य को "एक लूप के लिए लूप के लिए" में बदल दिया, छह बाइट्स के लिए लूप के लिए सिर्फ एक में।

संपादित करें: अब उपयोग कर रहा है enumerate। अब उपयोग नहीं l=len(z)। टर्नरी if-elseको सूची सूची में बदल दिया । विवरण के लिए नीचे देखें।

संपादित करें: Sp3000 ने printप्रत्येक को एक बाइट को बचाने वाली टर्नरी स्थिति को संपादित करने और संपादित करने का सुझाव दिया ।

Ungolfed:

s = input()
z = s.split()
v = max(map(len, z))                # the amount of digits of the largest number
d = ''.join(i.zfill(v) for i in z)  # pad zeroes until every number is the same length
                                     # then join the numbers into one string
x = ['']*len(z)                     # a list of strings for the output, one for each number

for k,c in enumerate(d):          # for every digit in every number
    i,j = divmod(k, v)            # i is the index of the number we're on
                                   # j is the index of the digit of the number we're on
    m = int(max(d[j::v]))         # the largest of all the digits in the j-th place
    c = int(c)                    # the digit in j-th place of the i-th number
    x[i] += "|"*(m-c+0**m+(j>0))  # pad | to size m-c, until the knots are correctly spaced
                                  # add a | if m<1, all j-th place digits are 0
                                  # add a | if j>0, if it's not at the start, as delimiters
    x[i] += ":8."[(c<2)|-(j<v-1)] * c
    # this is essentially the following code
    # if j<v-1:
    #     x[i] += "."*c      # . knots if not in the units place
    # else:
    #     if c == 1:
    #         x[i] += "8"*c  # 8 knots for ones in the units place
    #     else:
    #         x[i] += ":"*c  # : knots for something else is in the units place

for r in zip(*x):       # transpose so all the rows (the quipu strings) now hang down
    print(*r, sep='')    # join the strings together at each knot
                         # and print each on a separate line

— Sherlock9
स्रोत

क्या यहां पायथन 3 के लिए कुछ खास है? यदि नहीं, तो इसे पायथन 2 में परिवर्तित करना काफी कुछ बाइट्स बचा सकता है

— साइओस

@ कुछ भी नहीं पायथन 3 विशिष्ट। मैंने अभी पायथन 3 में शुरुआत की है क्योंकि मेरे पास इसका संस्करण है। मैं ideone या कुछ और पर पायथन 2 संस्करण का परीक्षण करूँगा।

— शर्लक

@ मैलेटसेन ऐसे इनपुट्स के साथ काम नहीं करता है 0, जो इसके साथ शुरू करते हैं , जैसे कि 0 12 4।

— शर्लक

आप पायथन 2 में इंडेंटेशन के लिए टैब और स्पेस को वैकल्पिक करके कुछ बाइट्स बचा सकते हैं। मेरा मानना है कि अजगर के इंडेंटेशन पार्सर के अनुसार 1 टैब वर्ण == 8 स्थान

— Cycece

for r in zip(*x):print(''.join(r))->print(''.join(r)for r in zip(*x))

— लीक नून

4

सी, 238 235 बाइट्स

कोड को जितना संभव हो उतना कम करने के लिए C प्रीप्रोसेसर पर भरोसा करना। एक साइड इफेक्ट के रूप में, यह भी बहुत ज्यादा अपठनीय बनाता है।

#define l strlen(a[i])
#define d l<k||a[i][l-k]-48
#define m(e) for(i=1;a[i];e<=r?i++:r++);
#define p(e) {m(!putchar(e?'|':k>1?46:d<2?56:58))puts("");}
k,r;main(int i,char**a){m(l)for(k=r,r=1;k;r=k>1){m(d)for(;r;r--)p(d<r)if(--k)p(1)}}

उबंटू 14.04 पर, आप कोड को एक सीधा के साथ संकलित कर सकते हैं gcc quipu.c(कृपया चेतावनियों को अनदेखा करें)। निष्पादन योग्य चलाने का एक उदाहरण:

$ ./a.out 1 2 3 2 1
||:||
|:::|
8:::8

सभी ओपी के परीक्षण मामलों के खिलाफ परीक्षण किया गया।

स्रोत कोड:

// Standard library; leaving out the includes still gives executable code despite the warnings.
#include <stdio.h>
#include <string.h>

// 4 preprocessor macros.
// Note: some of these actually make use of the fact that parentheses have been left out

// l: length of argument i
#define l     strlen(a[i])

// d: shorthand for a digit
#define d     l<k || a[i][l-k]-'0'

// m: loop across all arguments; calculates r as the maximum of expression e
#define m(e)  for (i=1; a[i]; e<=r ? i++ : r++);

// p: prints one line of output
// note: intentionally does not use the r++ code branch of m;
//       putchar always returns a non-zero number here, so !putchar is zero,
//       which is always <=r (because r is never negative)
// note: the semicolon after m(...) is redundant;
//       the definition of m already contains a semicolon
// note: puts("") outputs a newline
#define p(e)  { m(!putchar(e ? '|' : k > 1 ? '.' : d < 2 ? '8' : ':')); puts(""); }

// k: knot position; 1 for units, 2 for tens, 3 for hundreds...
int k;

// r: input and output value for m
// note: the first time we call m, we need r to be zero;
//       by defining it outside main, it is automatically initialized as such
int r;

// function main
// note: parameter i (normally named argc by convention) is not needed
//       (the last element of argv is known; it is followed by a NULL pointer)
//       but we cannot leave it out (otherwise we cannot access argv)
//       so it serves as a local variable (to loop through arguments; see m)
// note: parameter a (normally named argv by convention)
//       is the array of arguments (starting from index 1)
int main(int i, char **a)
{
    // Determine the longest argument; store its length in r.
    // This is the number of knot positions to consider.
    m(l)

    // Iterate k through the knot positions from top to bottom.
    // Note: k > 0 has been abbreviated to k.
    // Note: for each iteration, we also initialize r with either 0 or 1.
    //       0 = suppress printing when all knots are zero
    //       1 = always print, even when all knots are zero
    for (k = r, r = 1; k > 0; r = k > 1)
    {
        // Determine the highest digit at this knot position.
        // Note: due to the absence of parentheses, d mixes up with <=r into:
        // (l < k) || (a[i][l-k]-'0' <= r)
        m(d)

        // Count the digits down.
        for (; r; r--)
        {
            // Print a single line of output.
            // When d (the digit in the current strand) is less than the counter,
            // then print a '|', otherwise print a knot.
            p(d < r)
        }

        // Decrement k (go to next knot position).
        // If this was not the last iteration...
        if (--k > 0)
        {
            // Print separator line.
            p(1)
        }
    }

    // Return exit code zero; redundant.
    return 0;
}

— रूड हेलडरमैन
स्रोत

बधाई हो! सबसे छोटे उत्तर के रूप में बाउंटी पीरियड के भीतर पोस्ट करने पर, आपको मेरा +50 रिपीट का इनाम मिला है। अच्छा जवाब! :)

— एलेक्स ए।

4

गणितज्ञ 436 453 357 352 347 बाइट्स

t=Transpose;y=ConstantArray;a=Table;
g@j_:=(s=t[PadLeft[#,Max[Length/@i]]&/@(i=IntegerDigits@#)]&;p_~u~o_:=(m=Max@p;c=If[o==-2,":","."];w=If[o==-2,"8","."];p//.{0->a["|",Max@{1,m}],1->Join[a["|",{m-1}],{w}],n_/;MemberQ[2~Range~9,n]:>Join[y["|",m-n ],c~y~n]});t[Join@@@t@Join[u[#,0]&/@Most@#,u[#,-2]&/@{#[[-1]]}]]&[Riffle[(s@j),{a[0,Length@j]}]]//Grid)

उपरोक्त

प्रत्येक पूर्णांक को अंकों की सूची में, उपयोग करके तोड़ता है IntegerDigits; बाईं ओर शून्य के साथ प्रत्येक संख्या पैड (बराबर रिक्ति सुनिश्चित करने के लिए); प्रत्येक इनपुट संख्या, अब अंकों में विघटित, एक सरणी की एक पंक्ति से मेल खाती है; प्रत्येक स्तंभ एक स्थान मान का प्रतिनिधित्व करता है। एरियर ट्रांसपोट किया जाता है।
पैडिंग के साथ समुद्री मील की सूची के साथ अंकों को बदलता है। इकाइयों के लिए थोड़ा अलग पैटर्न-मिलान दिनचर्या का उपयोग किया जाता है।

उदाहरण

g[Range[0, 50]]

— DavidC
स्रोत

Transpose@Join? यह सही होना चाहिए?

— कैलक्यूलेटरफ्रंटलाइन

हाँ। इसे पकड़ने के लिए धन्यवाद।

— डेविड

उससे ठीक पहले स्पेस।

— कैलक्यूलेटरफैलिन

1

आर - 446 444

मैं देख रहा हूं कि अभी तक कोई आर समाधान नहीं है, इसलिए यहां एक है। फ़ंक्शन पूर्णांक के साथ एक वेक्टर लेता है।

function(x){r=nchar(max(x));c=length(x);m=matrix(0,r,c);for(i in 1:c){t=as.numeric(strsplit(as.character(x[i]),"")[[1]]);m[(r+1-length(t)):r,i]=t};Q=c();for(i in 1:r){d=m[i,];z=ifelse(max(d)>0,max(d),1);q=matrix("|",z,c);for(j in 1:c){v=m[i,j];if(i==r){if(v==1)q[z,j]=8;if(v>1)q[(z-v+1):z,j]=rep(":",v)};if(i<r){if(v>0)q[(z-v+1):z,j]=rep(".",v)}};if(i!=1&sum(d)>0)q=rbind(rep("|",c),q);Q=rbind(Q,q)};for(i in 1:nrow(Q))cat(Q[i,],sep="",fill=T)}

Ungolfed

# Some test data
test <- c(201, 0, 100, 222, 53)

# Define function
quipu <- function (x) {

    # Create matrix with a row for each digit and a column for each number
    r=nchar(max(x));c=length(x);m <- matrix(0,r,c)
    for(i in 1:c) {
        t=as.numeric(strsplit(as.character(x[i]),"")[[1]])
        m[(r+1-length(t)):r,i]=t
    }

    # Loop through each row (digit) starting at the top of the quipu
    Q=c() # Empty matrix to store quipu 
    for(i in 1:r){

        d=m[i,]
        z=ifelse(max(d)>0,max(d),1)
        q=matrix("|",z,c)

        # Loop through each column (number in the vector) starting at the leftmost quipu
        for(j in 1:c){

            # The digit
            v=m[i,j]

            # If it is the last segment of the quipu
            if(i==r){
                if(v==1){q[z,j]=8} # If unit digit =1
                if(v>1){q[(z-v+1):z,j]=rep(":",v)} # If unit digit >1               
            }

            # If it is not the last segment of the quipu
            if(i<r){
                if(v>0){q[(z-v+1):z,j]=rep(".",v)} # If non-unit digit >0   
            }
        }

        # Add segment to Q
        if(i!=1 & sum(d)>0){q=rbind(rep("|",c),q)}
        Q=rbind(Q,q)    
    }

    # Print quipu
    for(i in 1:nrow(Q)) {cat(Q[i,], sep="", fill=T)}
}

# Test
quipu(test)

— स्लो लोरिस नामक दक्षिण एशिया के हृष्टपुष्ट बंदर
स्रोत

क्या आपको if(v>0)अपने if(i<r)खंड में आवश्यकता है ? क्या R z+1:zकब जैसी सीमा को स्वीकार करता है v==0? यदि ऐसा q[z+1:z,j]बिल्कुल प्रभावित नहीं होता, तो मुझे लगता है। इसके अलावा, क्या R के पास कोई elseकीवर्ड और किसी प्रकार का else ifकीवर्ड है? यदि हां, तो आप इनमें से कुछ शर्तों को पूरा करने में सक्षम होंगे।

— शर्लक

if(v>0)जरूरत है क्योंकि अगर v=0, सूचकांक सीमा से बाहर हो जाएगा (यानी, पंक्ति nrow + 1 पाने की कोशिश करता है)। आर के पास है else, और मैंने वास्तव में आपके सुझाव की कोशिश की और elseजहां संभव हुआ, उसका उपयोग किया , लेकिन यह बाइट्स की समान संख्या निकला।

— धीमी लोरिस

काउंटिंग क्विपु: बेस 10 इन द न्यू वर्ल्ड

विवरण

नियम

उदाहरण

आगे की पढाई

पायथ, 64 बाइट्स

यह काम किस प्रकार करता है

अपठनीय , 3183 3001 बाइट्स

व्याख्या

जावास्क्रिप्ट (ES6) 750 744 690 604 498 346 245 234 बाइट्स

व्याख्या

उदाहरण

पायथन 3, 624 598 595 574 561 535 532 527 525 426 345 328 324 294 288 286 283 280 267 265 255 251 245 238 235 234 230 228 बाइट्स

सी, 238 235 बाइट्स

गणितज्ञ 436 453 357 352 347 बाइट्स

आर - 446 444

Ungolfed