32

सबसे छोटा प्रोग्राम लिखिए जो एकल पूर्णांक को इनपुट के रूप में लेता है और एक सुपन अपैक को प्रिंट करता है

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

इनपुट:

आउटपुट:

|\======================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
||  (__)  (__)  (__)  (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)  (__)  ||
|<======================================>|
||  (__)  (__)  (__)  (__)   ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||   ||    ||   (__)   ||    ||   (__)  ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/======================================\|

इनपुट:

6302715408

आउटपुट:

|\==============================================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
||   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  (__)   ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||  (__)   ||    ||    ||   (__)   ||   (__)   ||    ||   (__)  ||
|<==============================================================>|
||  (__)  (__)   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  ||
||   ||   (__)   ||   (__)  (__)   ||    ||   (__)   ||   (__)  ||
||   ||   (__)   ||    ||    ||    ||    ||   (__)   ||   (__)  ||
||   ||    ||    ||    ||    ||    ||    ||   (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||   ||    ||   (__)   ||    ||    ||   (__)   ||   (__)   ||   ||
||  (__)   ||   (__)   ||    ||   (__)  (__)   ||   (__)   ||   ||
||  (__)   ||   (__)  (__)  (__)  (__)  (__)   ||   (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)   ||   (__)  (__)  ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/==============================================================\|

code-golf ascii-art

— gnibbler
स्रोत

क्या कमांड-लाइन पर नंबर दिया जा सकता है?

— जॉय

इनपुट लंबाई पर कोई प्रतिबंध?

— जोए

अगर कोई और कैसे गोल्फ के बारे में कुछ विचारों की जरूरत है, तो golf.shinh.org/p.rb?Soroban+Fixed के समान ।

— नबं

1

तो शीर्ष पंक्ति और नीचे पंक्ति हमेशा पूरी तरह से भरी होती हैं? उन्होंने ऐसे निरर्थक अबेकस का आविष्कार क्यों किया? :)

— तिमवी

@ टिमी, एक ही एबेकस का उपयोग हेक्सिडेसिमल के लिए किया जा सकता है। जब दशमलव के लिए उपयोग किया जाता है तो अतिरिक्त पंक्तियों का उपयोग बहुतायत और विभाजनों का प्रदर्शन करते समय किया जाता है

— gnibbler

14

J, 126 124 121 119 116 115 113 113 105 116 115 112 वर्ण

'|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1[(s=:[,.~,.)9!:7'\=/<=>/=\|='

कीबोर्ड से इनपुट लेता है। उदाहरण:

   '|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1[(s=:[,.~,.)9!:7'\=/<=>/=\|='
6302715408
|\==============================================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
||   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  (__)   ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||  (__)   ||    ||    ||   (__)   ||   (__)   ||    ||   (__)  ||
|<==============================================================>|
||  (__)  (__)   ||   (__)  (__)  (__)   ||   (__)   ||   (__)  ||
||   ||   (__)   ||   (__)  (__)   ||    ||   (__)   ||   (__)  ||
||   ||   (__)   ||    ||    ||    ||    ||   (__)   ||   (__)  ||
||   ||    ||    ||    ||    ||    ||    ||   (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||   ||    ||   (__)   ||    ||    ||   (__)   ||   (__)   ||   ||
||  (__)   ||   (__)   ||    ||   (__)  (__)   ||   (__)   ||   ||
||  (__)   ||   (__)  (__)  (__)  (__)  (__)   ||   (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)   ||   (__)  (__)  ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/==============================================================\|

यहाँ मुख्य चाल जे के मुक्केबाजी का दुरुपयोग है जो इसके पात्रों का उपयोग करता है। यह ऐसा करने के लिए एक वैश्विक पैरामीटर - 9!:7- का उपयोग करता है । आगे गोल्फिंग के लिए जगह हो सकती है, लेकिन ईमानदार होने के लिए मुझे कुछ काम करने की खुशी थी जो इस सवाल पर मेरे आखिरी प्रयास की भरपाई करनी चाहिए ।

एक ट्वीट में लिखा गया है कि 'गज़ ने इसे' बना दिया है।

संपादित करें: बचत के 3 वर्ण जेसी मिलिकन के उत्तर 2 6$' || (__)'से उधार लेने के कारण हैं ।

आगे संपादित करें: मेरे द्वारा देखे गए 11 वर्णों को अतिरिक्त रिक्त स्थान नहीं मिला, जो कि मेरे पास नहीं थे।

स्पष्टीकरण:

कोड तीन मुख्य वर्गों में है:

1) सेटअप

[(s=:[,.~,.)9!:7'\=/<=>/=\|='

यह स्वयं दो भागों में है।
9!:7'\=/<=>/=\|='उन वर्णों को फिर से परिभाषित करता है जिनका उपयोग J बक्से को प्रदर्शित करने के लिए करेगा। जे की मुक्केबाजी आम तौर पर इस तरह दिखती है:

   2 2$<"0[1 2 3 4
┌─┬─┐
│1│2│
├─┼─┤
│3│4│
└─┴─┘

लेकिन फिर से परिभाषित करने के बाद यह इस तरह दिखता है:

   2 2$<"0[1 2 3 4
\===/
|1|2|
<===>
|3|4|
/===\

(s=:[,.~,.)एक क्रिया को परिभाषित करता हूं जो मैं बाद में एक दो बार उपयोग करने जा रहा हूं। यह घोषित करने के लिए सबसे अच्छी जगह है। यह बाईं ओर एक चरित्र और दाईं ओर वर्णों की एक सरणी लेता है और चरित्र के बीच की सरणी को सैंडविच करता है। उदाहरण के लिए:

   3 5$'abcdefghijklmno'
abcde
fghij
klmno

   '-' s 3 5$'abcdefghijklmno'
-abcde-
-fghij-
-klmno-

अंतिम [केवल अगले भाग से सेटअप को अलग करने के लिए कार्य करता है।

2) इनपुट और प्रतिनिधित्व

,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1

".,.1!:1[1 कीबोर्ड से इनपुट लेता है और इसे अलग-अलग अंकों में अलग करता है:

   ".,.1!:1[1
314159
3 1 4 1 5 9

((i.5)</5|]) एक शून्य बनाता है और अबेकस के निचले हिस्से का प्रतिनिधित्व करता है:

   ((i.5)</5|]) 3 1 4 1 5 9
1 1 1 1 0 1
1 0 1 0 0 1
1 0 1 0 0 1
0 0 1 0 0 1
0 0 0 0 0 0

|:@(1,.<&5) शून्य के शीर्ष भाग का एक शून्य और एक प्रतिनिधित्व बनाता है:

   |:@(1,.<&5) 3 1 4 1 5 9
1 1 1 1 1 1
1 1 1 1 0 0

इन दो भागों को एक साथ उपयोग करके बॉक्सिंग किया जाता है ;:

   (|:@(1,.<&5);((i.5)</5|])) 3 1 4 1 5 9
\=======================/
|1 1 1 1 1 1|1 1 1 1 0 1|
|1 1 1 1 0 0|1 0 1 0 0 1|
|           |1 0 1 0 0 1|
|           |0 0 1 0 0 1|
|           |0 0 0 0 0 0|
/=======================\

तब पेटियों को एब्सस के आधार बनाने के लिए एक के ऊपर एक रखा जाता है, जिससे:

   ,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
\===========/
|1 1 1 1 1 1|
|1 1 1 1 0 0|
<===========>
|1 1 1 1 0 1|
|1 0 1 0 0 1|
|1 0 1 0 0 1|
|0 0 1 0 0 1|
|0 0 0 0 0 0|
/===========\

3) आउटपुट

'|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>

&.>इसका मतलब है कि बारी-बारी से दोनों बॉक्सों पर काम किया जाएगा।
(,-.)यह एक हुक है जो इनपुट को नकार देगा और फिर इसे मूल के अंत में जोड़ देगा:

   2 5$1 0 1 0 1
1 0 1 0 1
1 0 1 0 1

   (,-.) 2 5$1 0 1 0 1
1 0 1 0 1
1 0 1 0 1
0 1 0 1 0
0 1 0 1 0

यह वास्तव में प्रतिनिधित्व का हिस्सा है, लेकिन गोल्फिंग उद्देश्यों के लिए इसे इस खंड में रखना बेहतर है। पिछले इनपुट पर लागू:

   (,-.)&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
\===========/
|1 1 1 1 1 1|
|1 1 1 1 0 0|
|0 0 0 0 0 0|
|0 0 0 0 1 1|
<===========>
|1 1 1 1 0 1|
|1 0 1 0 0 1|
|1 0 1 0 0 1|
|0 0 1 0 0 1|
|0 0 0 0 0 0|
|0 0 0 0 1 0|
|0 1 0 1 1 0|
|0 1 0 1 1 0|
|1 1 0 1 1 0|
|1 1 1 1 1 1|
/===========\

[:,.(_6[\' || (__)'){~ शून्य और लोगों को अब एक मनका या अनुपस्थिति का प्रतिनिधित्व करने के लिए एक स्ट्रिंग का चयन करने के लिए उपयोग किया जाता है:

   ([:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
\====================================/
| (__)  (__)  (__)  (__)  (__)  (__) |
| (__)  (__)  (__)  (__)   ||    ||  |
|  ||    ||    ||    ||    ||    ||  |
|  ||    ||    ||    ||   (__)  (__) |
<====================================>
| (__)  (__)  (__)  (__)   ||   (__) |
| (__)   ||   (__)   ||    ||   (__) |
| (__)   ||   (__)   ||    ||   (__) |
|  ||    ||   (__)   ||    ||   (__) |
|  ||    ||    ||    ||    ||    ||  |
|  ||    ||    ||    ||   (__)   ||  |
|  ||   (__)   ||   (__)  (__)   ||  |
|  ||   (__)   ||   (__)  (__)   ||  |
| (__)  (__)   ||   (__)  (__)   ||  |
| (__)  (__)  (__)  (__)  (__)  (__) |
/====================================\

लेकिन अब, जैसा कि हावर्ड ने मुझे बताया, मोतियों के दोनों तरफ एक जगह कम है। इसलिए हम sरिक्त स्थान के दो स्तंभों के बीच प्रत्येक बॉक्स की सामग्री को सैंडविच करने के लिए पूर्वनिर्धारित क्रिया का उपयोग करते हैं:

   (' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
\======================================/
|  (__)  (__)  (__)  (__)  (__)  (__)  |
|  (__)  (__)  (__)  (__)   ||    ||   |
|   ||    ||    ||    ||    ||    ||   |
|   ||    ||    ||    ||   (__)  (__)  |
<======================================>
|  (__)  (__)  (__)  (__)   ||   (__)  |
|  (__)   ||   (__)   ||    ||   (__)  |
|  (__)   ||   (__)   ||    ||   (__)  |
|   ||    ||   (__)   ||    ||   (__)  |
|   ||    ||    ||    ||    ||    ||   |
|   ||    ||    ||    ||   (__)   ||   |
|   ||   (__)   ||   (__)  (__)   ||   |
|   ||   (__)   ||   (__)  (__)   ||   |
|  (__)  (__)   ||   (__)  (__)   ||   |
|  (__)  (__)  (__)  (__)  (__)  (__)  |
/======================================\

ऐसा करने के बाद, जो कुछ बचा है उसे एक स्ट्रिंग में परिवर्तित करना है ":ताकि हम इसे दो कॉलमों के बीच सैंडविच कर सकें |:

   '|'s":(' 's[:,.(_6[\'  ||   (__)'){~(,-.))&.>,.(|:@(1,.<&5);((i.5)</5|]))".,.1!:1[1
314159
|\======================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
||  (__)  (__)  (__)  (__)   ||    ||   ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)  (__)  ||
|<======================================>|
||  (__)  (__)  (__)  (__)   ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||  (__)   ||   (__)   ||    ||   (__)  ||
||   ||    ||   (__)   ||    ||   (__)  ||
||   ||    ||    ||    ||    ||    ||   ||
||   ||    ||    ||    ||   (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||   ||   (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)   ||   (__)  (__)   ||   ||
||  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/======================================\|

— गैरेथ
स्रोत

मुझे लगा कि आपके आउटपुट के साथ कुछ "गलत" है, लेकिन मुझे पहचानने में कुछ समय लगा: आप प्रदर्शन के तीसरे और तीसरे (तीसरे और अंतिम-एएससीआई कॉलम) पर एक खाली कॉलम छोड़ते हैं।

— हावर्ड

@ हावर्ड वाह, अच्छी जगह है। मैंने उस पर ध्यान नहीं दिया। मैं इसे ठीक करने पर एक नज़र डालूंगा।

— गारेथ

@ 11 अक्षरों की लागत पर निर्धारित है। शर्म आ रही है, मुझे लगा कि मेरे पास 100 से नीचे जाने का मौका हो सकता है :-(

— गैरेथ

अच्छा काम। लगता है @ हॉवर्ड को पकड़ने के लिए बहुत काम करना है

— gnibbler

बाउंटी के पास 3 दिन शेष हैं। मैंने इसे माध्य समय के लिए स्वीकार किया है।

— gnibbler

14

रूबी 1.9, 154 वर्ण

puts'|\%s/|'%$r=?=*(2+6*gets.size),(0..14).map{|a|a==4?"|<#$r>|":"|| #{$_.gsub(/./){(5*a+n=$&.hex)/10!=1&&(a-n%5)/5!=1?' (__) ':'  ||  '}} ||"},"|/#$r\\|"

मान लेता है कि इनपुट किसी नई पंक्ति से समाप्त नहीं हुआ है ।

मजेदार तथ्य: जिस तरह से मैं इनपुट अंकों को संख्याओं में बदल रहा हूं ( $&.hexयह एक बाइट से छोटा है $&.to_i), यह अबेकस वास्तव में हेक्स अंकों के साथ काम करता है e:

$ echo -n "0123456789abcdef" | ruby suanpan.rb
|\==================================================================================================/|
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)   ||    ||    ||    ||    ||    ||   ||
||  (__)  (__)  (__)  (__)  (__)   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   (__)  ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   (__)  (__)  (__)  (__)  (__)  (__)  ||
||   ||    ||    ||    ||    ||   (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|<==================================================================================================>|
||   ||   (__)  (__)  (__)  (__)   ||   (__)  (__)  (__)  (__)   ||   (__)  (__)  (__)  (__)   ||   ||
||   ||    ||   (__)  (__)  (__)   ||    ||   (__)  (__)  (__)   ||    ||   (__)  (__)  (__)   ||   ||
||   ||    ||    ||   (__)  (__)   ||    ||    ||   (__)  (__)   ||    ||    ||   (__)  (__)   ||   ||
||   ||    ||    ||    ||   (__)   ||    ||    ||    ||   (__)   ||    ||    ||    ||   (__)   ||   ||
||   ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||    ||   ||
||  (__)   ||    ||    ||    ||   (__)   ||    ||    ||    ||   (__)   ||    ||    ||    ||   (__)  ||
||  (__)  (__)   ||    ||    ||   (__)  (__)   ||    ||    ||   (__)  (__)   ||    ||    ||   (__)  ||
||  (__)  (__)  (__)   ||    ||   (__)  (__)  (__)   ||    ||   (__)  (__)  (__)   ||    ||   (__)  ||
||  (__)  (__)  (__)  (__)   ||   (__)  (__)  (__)  (__)   ||   (__)  (__)  (__)  (__)   ||   (__)  ||
||  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  (__)  ||
|/==================================================================================================\|

इसके लिए 0xf, ऊपरी आधे हिस्से में एक तीसरा मनका जादुई रूप से दिखाई देता है।

स्क्रिप्ट मंगलाचरण के दौरान अतिरिक्त झंडे की अनुमति देते समय, इसे 152 बाइट्स के लिए छोटा किया जा सकता है (149 बाइट्स कोड + 3 बाइट्स अतिरिक्त चालान झंडे:

puts'|\%s/|'%$r=?=*(2+6*~/$/),(0..14).map{|a|a==4?"|<#$r>|":"|| #{$_.gsub(/./){(5*a+n=$&.hex)/10!=1&&(a-n%5)/5!=1?' (__) ':'  ||  '}} ||"},"|/#$r\\|"

साथ चलाना ruby -n suanpan.rb।

— Ventero
स्रोत

12

पर्ल (151 वर्ण)

( ~~168~~ ~~163~~ ~~158~~ ~~157~~ ~~156~~ ~~154~~ )

$i=<>;$c.=$_-4?"
||  $i||":"
|<$m>|",$m='==',$c=~s!\d!$m.='='x6;($_-$&%5)/5%2|(5*$_+$&)/10%7==1?' ||   ':'(__)  '!eg for 0..14;print"|\\$m/|$c
|/$m\\|"

व्याख्या

# Read the number from STDIN.
$i = <>;

# for statement starts here...

    # Append to $c a line containing either the horizontal dividing bar (in row #4)
    # or the current abacus row with the digits in place of the pegs.
    # This relies on the fact that $m will have been computed after at least one iteration.
    $c .= $_-4 ? "\n||  $i||" : "\n|<$m>|",

    # Notice that $m is redundantly recomputed from scratch in each iteration.
    $m = '==',

    # Substitute the correct pegs for the digit characters.
    $c =~ s!\d!
        $m .= '=' x 6;

        # Weird expression for the abacus function.
        # I have to use “% 7” because otherwise the division is floating-point...
        # Notice that $_ is the row and $& is the digit.
        ($_ - $& % 5)/5 % 2 | (5*$_ + $&)/10 % 7 == 1
        ? ' ||   '
        : '(__)  '
    !eg
for 0..14;

# Could shorten further by using “say” if you don’t mind excluding the “-E” from the count...
print "|\\$m/|$c\n|/$m\\|"

संपादित करता

(१५४ → १५१) तीन \nनई वास्तविक वर्णों में बदल गए । विश्वास नहीं कर सकता कि मैंने पहले ऐसा नहीं सोचा था!

— Timwi
स्रोत

1

यह सिर्फ ... बहुत बढ़िया!

— german_guy

8

विंडोज पॉवरशेल, 191

$y='='*(2+6*($i=[char[]]"$input").Count)
filter f($v){"|| $((' (__)','  || ')[($i|%{iex $_%$v})])  ||"}"|\$y/|"
f 1
f 10-ge5
f 1+1
f 10-lt5
"|<$y>|"
1..5|%{f 5-lt$_}
1..5|%{f 5-ge$_}
"|/$y\|"

इतिहास:

2011-03-11 23:54 (340) प्रारंभिक प्रयास।
2011-03-12 00:21 (323) पूरे कोड में स्ट्रिंग इंटरपोलेशन का उपयोग करना।
2011-03-12 00:21 (321) झुका हुआ$l ।
2011-03-12 01:07 (299) अधिक दोहराव वाले भागों के साथ-साथ एक प्रारूप स्ट्रिंग के लिए एक फ़ंक्शन का उपयोग किया।
2011-03-12 01:19 (284) ने तर्कों को समारोह में थोड़ा बदल दिया। कमांड पार्सिंग मोड के लिए हुर्रे।
2011-03-12 01:22 (266) आवर्ती अभिव्यक्तियों के लिए अधिक चर।
2011-03-12 01:28 (246) अब प्रत्येक पंक्ति फ़ंक्शन द्वारा उत्पन्न होती है।
2011-03-12 01:34 (236) के बाद से मैं केवल स्ट्रिंग प्रक्षेप में वर्णों का उपयोग करता हूं मैं %अंकों से संख्याओं को सुरक्षित रूप से अनदेखा कर सकता हूं ।
2011-03-12 01:34 (234) समारोह में सरणी सूचकांक पीढ़ी को थोड़ा अनुकूलित किया।
2011-03-12 01:42 (215) मुझे अब $rऔर ज़रूरत नहीं है $b। और $aअप्रचलित भी है। जैसा है $l।
2011-03-12 01:46 (207)$OFS मुझे केवल एक बार ज़रूरत पड़ने पर सेट करने की आवश्यकता नहीं है ।
2011-03-12 01:49 (202) झुका हुआ $f।
2011-03-12 01:57 (200) अब प्रारूप स्ट्रिंग के लिए कोई ज़रूरत नहीं है। स्ट्रिंग प्रक्षेप बस ठीक काम करता है।
2011-03-12 02:00 (198) व्यक्तिगत पंक्तियों (पाइपलाइन और एरे इंडेक्स को फिर से ऑर्डर करना ) पैदा करने के लिए थोड़ा अनुकूलित।
2011-03-12 02:09 (192)-join क्योंकि हमें वास्तव में अच्छे प्रभाव के लिए अतिरिक्त स्थान का उपयोग करने की कोई आवश्यकता नहीं है।

— एक छोटा सा सिक्का
स्रोत

5

हास्केल, 243 वर्ण

z x|x=" (__) ";z _="  ||  "
h[a,b]d f w='|':a:replicate(2+6*length d)'='++b:"|\n"++q z++q(z.not)
 where q b=w>>=(\v->"|| "++(d>>=b.(>v).f)++" ||\n")
s d=h"\\/"d(5-)[-9,0]++h"><"d(`mod`5)[0..4]++h"/\\"d id[]
main=interact$s.map(read.(:[])).init

विशेष रूप से चतुर नहीं है। मुझे यकीन है कि इसे किसी तरह छोटा किया जा सकता है ...

संपादित करें: (246 -> 243) बातचीत का उपयोग करने के लिए @ फ़ूजज़नल का सुझाव लिया

— MtnViewMark
स्रोत

कैसे का उपयोग करने के बारे मेंinteract

— FUZxxl

पहली पंक्ति को छोटा किया जा सकता है z x|x=" (__) "|0<1=" || "।

— FUZxxl

आपकी वैकल्पिक पहली पंक्ति केवल छोटी है क्योंकि आपने दो रिक्त स्थान छोड़ दिए हैं जो आवश्यक हैं!

— माउंटनवार्कर

ऊप्स! तुम बिल्कुल सही हो।

— FUZxxl

4

डेल्फी, 348

यह संस्करण सिर्फ एक बार लिखने के लिए एक स्ट्रिंग बनाता है; अंकों को एक अलग फ़ंक्शन द्वारा नियंत्रित किया जाता है जो एक digit modulo m >= valueनिर्माण के माध्यम से काम करता है (यदि मान <0) नकारात्मक हो।

var d,s,o,p:string;c:Char;i:Int8;function g(m,v:Int8):string;begin p:='|| ';for c in d do p:=p+Copy('  ||   (__) ',1+6*Ord(((Ord(c)+2)mod m>=Abs(v))=(v>0)),6);g:=p+' ||'^J;end;begin ReadLn(d);s:=StringOfChar('=',2+6*Length(d));for i:=1to 5do o:=g(5,6-i)+o+g(5,-i);Write('|\'+s+'/|'^J+g(1,-1)+g(10,-5)+g(1,1)+g(10,5)+'|<'+s+'>|'^J+o+'|/'+s+'\|')end.

~~डेल्फी, 565~~

पहला प्रयास :

var _:array[0..6]of string=('  ||  ',' (  ) ','======','|\==/|','||  ||','|/==\|','|<==>|');m:array[0..186]of Byte;o:array[0..16]of string;i,j,c,f,l:Word;begin for i:=0to 9do begin f:=i*17;m[f+1]:=1;m[f+2]:=Ord(i<5);m[f+3]:=0;m[f+4]:=Ord(i>4);for j:=6to 10do m[f+j]:=Ord(i mod 5>j-6);for j:=11to 15do m[f+j]:=Ord(i mod 5<=j-11);m[f]:=2;m[5+f]:=2;m[16+f]:=2;end;f:=170;m[f]:=3;for i:=1to 15do m[f+i]:=4;m[f+5]:=6;m[f+16]:=5;repeat for i:=0to 16do Insert(_[m[f+i]],o[i],l);Read(PChar(@c)^);c:=c-48;f:=c*17;l:=Length(o[0])-2;until c>9;for i:=0to 16do WriteLn(o[i])end.

यह 3 सरणियों का उपयोग करता है; 7 स्ट्रिंग्स के लिए एक जिसे डिस्कनेक्ट किया जा सकता है, एक आउटपुट लाइनों के लिए और एक 7 स्ट्रिंग्स को 11 कॉलम (10 अंक और 1 प्रारंभिक कॉलम) में मैप करने के लिए।

— PatrickvL
स्रोत

3

GolfScript, 139 अक्षर

0+17'|':Q*:R'\<||'4Q**'/'+@{48-.5<)[1]*2,2*$+4<\5%[1]*2,5*$+10<+`{{1$=}%+2>'=='1/*5/('='+\+}+'     (|_|_ )'2//}/;;;;'/>||'4Q**'\\'+R]zip n*

अभी तक बहुत गोल्फ नहीं हुआ है, लेकिन यह एक ट्वीट में फिट बैठता है (केवल ASCII के साथ)। इसे यहाँ आज़माएँ ।

— हावर्ड
स्रोत

2

जे, 225

दिए गए दो परीक्षणों को पास करता है, कम से कम कई सौ अंकों तक काम करना चाहिए।

c=:2 6$'   ||   (__)'
f=:(2{.[),('='#~2+6*#@]),2}.[
d=:'||',"1'  ||',~"1,"2&(c{~|:)
g=:('|\/|'&f,d&(1,.-.,.0,.])&(4&<),'|<>|'&f,d&(5($!.0"1)0,~"(1)1#~"0|~&5),|.&d&(5($!.0"1)1#~"0(5-5|])),'|/\|'&f)
4(1!:2)~LF,"1 g"."0}:(1!:1)3

पहले बंद: हाँ, हाँ, ग्रेडिंग। दूसरा: यह सिर्फ शर्मनाक ढंग से लंबा है। ओह अच्छा। मैंने अभी तक यह तय नहीं किया है कि इसे आगे बढ़ाना है या गर्भस्थ स्थिति में रोना है। (अथवा दोनों!)

यहाँ एक छोटे कार्यक्रम के बदले में व्याख्या की गई है:

सी खाली सेल की 2x6 तालिका है, प्रतिपादन के लिए मनका सेल।
f बाएं तर्क के रूप में चार बाहर के पात्रों के साथ एक '=' पंक्ति प्रस्तुत करता है।
d बीड कोशिकाओं में 0/1 मेट्रिसेस का अनुवाद करके एक एबेकस पंक्ति का प्रतिपादन करता है जिसके साथ गद्देदार ||
g अंक लेता है और वर्टिकली वर्टिकल रो पंक्तियों को 'फॉर्मेटिंग' रो के लिए f और अबैकस रो के लिए उपयोग करता है।
अंतिम पंक्ति को इनपुट मिलता है, वर्णों में विभाजित होता है और उन्हें संख्याओं में परिवर्तित करता है, जी और फिर प्रिंट्स को खिलाता है।

— जेसी मिलिकन
स्रोत

2

सी, 277 274 वर्ण

तुम्हें पता है, यह मुझे लगता है कि हमारे पास पर्याप्त समाधान नहीं हैं जो वास्तव में सी प्रीप्रोसेसर का लाभ उठाते हैं। आंशिक रूप से ऐसा इसलिए है क्योंकि वे #defineवास्तव में बहुत कम जगह लेते हैं। लेकिन फिर भी, वहाँ बहुत अधिक क्षमता है। मुझे इस कमी को दूर करने की आवश्यकता है।

#define L(x,z)for(printf("|"x),p=b;*p||puts(#z)<0;++p)printf(
#define F(x,y,z)L(#x,==z|)"======",y);
#define T(y)L("|  ",||)*p-47 y?"(__)  ":" ||   ");
i;char*p,b[99];main(j){gets(b);F(\\,0,/)T()T(<6)T(<1)T(>5)F(<,*p>52?*p-=5:0,>)
for(;++i<6;)T(>i)for(;++j<7;)T(<j)F(/,0,\\)}

वह बेहतर है।

— रोटी का डिब्बा
स्रोत

2

गणितज्ञ २ 281१

w@n_:= Module[{t=Table,f,g},
 f@d_:=ReplacePart["O"~t~{7},{2-Quotient[d,5]-> "|",3+Mod[d,5]-> "|"}];
 g@k_:=IntegerDigits@n~PadLeft~10;
 Grid[Insert[Insert[(f/@g@n)T,"=="~t~{10},{{1},{3},{8}}]T,""~t~{10},{{1},{11}}]T]]

उदाहरण

w[6302715408]

अबेकस

— DavidC
स्रोत

10k पर बधाई! :-D

— दरवाज़े

@Doorknob। धन्यवाद! आपको भी बधाई!

— डेविड मार्क

1

C, 548

#define p(a) printf(a);
#define F(x,m) for(x=0;x<m;x++)
#define I(x) {p("||")F(j,l)if(b[l*(i+x)+j]){p("  (__)")}else{p("   || ")}p("  ||\n")}
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main(int a,char* c[]){int i,j,l,m,*b;l=strlen(c[1]);b=(int*)malloc(l*56);m=6*l;F(i,14*l)b[i]=0;
F(j,l){b[j]=1;if(c[1][j]<53){b[l+j]=1;}else{b[3*l+j]=1;c[1][j]-=5;}F(i,5){if(i<c[1][j]-'0'){
b[(i+5)*l+j]=1;}else{b[(i+9)*l+j]=1;}}}p("|\\=")F(i,m)p("=")p("=/|\n")F(i,4)I(0)p("|<=")F(i,m)
p("=")p("=>|\n")F(i,9)I(5)p("|/=")F(i,m)p("=")p("=\\|\n")}

पहला संस्करण, अभी तक थोड़ा सा गोल्फिंग।

— schnaader
स्रोत

1

स्काला (489 वर्ण)

def a(i:String){val b=" (__) ";val n="  ||  ";1 to 17 map{l=>;{print(l match{case 1=>"|\\=";case 6=>"|<=";case 17=>"|/=";case _=>"|| "});print(l match{case 1|6|17=>"======"*i.size;case 2|16=>b*i.size;case 4|11=>n*i.size;case 3=>i flatMap{d=>{if(d.asDigit<5)b else n}};case 5=>i flatMap{d=>{if(d.asDigit>4)b else n}};case _=>i flatMap{d=>{if(l<11)if(d.asDigit%5<l-6)n else b else if(d.asDigit%5>l-12)n else b}}});;print(l match{case 1=>"=/|";case 6=>"=>|";case 17=>"=\\|";case _=>" ||"})}}}

वास्तव में बहुत भद्दा प्रयास।

— गैरेथ
स्रोत

1

स्किलिंग , 77 वर्ण

इनाम ट्वीट्स को संदर्भित करता है , और ट्विटर पात्रों (बाइट्स नहीं) को गिनता है । :)

꿓뤽꿓뤽①長復標독렽꿐②껷렊밃겠上❶가侔是丟돃렽꿐②꿧렊不돇렠글⓶①各❷❷걐剩減갰減갰分❸⓷걀大加增增감右與꺅뭟꺒갠⓵긇롼긂갠嗎⓶終丟돇렊終終돂묽꿐②뇇렊

मैंने वास्तव में इस साल पहले लिखा था (जब यह चुनौती पोस्ट की गई थी), लेकिन मैंने इसे कभी पोस्ट नहीं किया क्योंकि मैंने इस चुनौती के बाद स्लीपिंग का आविष्कार किया था। यदि आपको लगता है कि यह इसे अयोग्य बनाता है, तो मैं समझता हूं।

व्याख्या

꿓뤽꿓뤽①長復 | let x = "======" times the length of the input string
標 | mark
독렽꿐②껷렊 | "|\\==" + x + "/|\n"
밃겠上 | for row in [-4 .. 10]
    ❶가侔是 | if row == 0
        丟돃렽꿐②꿧렊 | "|<==" + x + ">|\n"
    不 | else
        돇렠글 | "||  "
        ⓶①各 | foreach char c in input
            | ((r-(c%5)-3)/3 & ((r + (c>4?3:2)) >> 1)) ? "(__) " : " ||   "
            ❷❷걐剩減갰減갰分❸⓷걀大加增增감右與꺅뭟꺒갠⓵긇롼긂갠嗎⓶
        終丟
        돇렊 | "||\n"
    終
終
돂묽꿐②뇇렊 | "|/==" + x + "\\|\n"

— Timwi
स्रोत

आपके दिलचस्प जवाब के लिए धन्यवाद। मैं मानता हूं कि नियम से चिपके रहना सबसे अच्छा है कि केवल उन भाषाओं को प्रकाशित किया जाए जो पूछे जाने वाले प्रश्न के योग्य हैं। मुझे विश्वास नहीं है कि आपने जानबूझकर इस चुनौती को जीतने के लिए अपनी भाषा तैयार की होगी, लेकिन साथ ही मुझे नहीं लगता कि यह अन्य उत्तरदाताओं के लिए उचित है, और हम पुराने पर नई आविष्कृत भाषाओं के लिए फ्लगगेट नहीं खोलना चाहते हैं सवाल क्योंकि हम जानते हैं कि क्या होगा ...

— gnibbler

@gnibbler: यकीन है, मैं उस के साथ ठीक हूँ। मुझे लगता है कि यह नियम एक महत्वपूर्ण है।

— तिमवी

1

अजगर, 309 301 288 वर्ण

कॉम्पैक्ट संस्करण:

q=p,b="  ||  "," (__) "
t="|| %s ||\n"
a=lambda h:t%"".join(q[i]for i in h)
n=[int(d)for d in str(input())]
c=len(n)
e="="*(c*6+2)
h="|\\"+e+"/|"
print h+"\n"+t%(b*c)+a(d<5 for d in n)+t%(p*c)+a(d>4 for d in n)+"|<"+e+">|\n"+"".join(a((d%5>i%5)^(i>4)for d in n)for i in range(10))+h[::-1]

स्पष्ट संस्करण:

bead = " (__) "
pole = "  ||  "
template = "|| %s ||\n"
output = ""
def addline(hasbeads):
    global output
    output += template % "".join([bead if item else pole for item in hasbeads])

digits = [int(d) for d in str(input())]
count = len(digits)
equalsigns = "=" * (count * 6 + 2)
output = ""
header = "|\\" + equalsigns + "/|"
output += header + "\n"
output += template % (bead * count)
addline([d < 5 for d in digits])
output += template % (pole * count)
addline([d > 4 for d in digits])
output += "|<" + equalsigns + ">|\n"
for i in range(5):
    addline([d % 5 > i for d in digits])
for i in range(5):
    addline([d % 5 <= i for d in digits])
output += header[::-1]
print output

ध्यान दें कि कॉम्पैक्ट करने के लिए, चर को एक एकल अक्षर में बदल दिया गया था, और सूची समझ को जनरेटर में बदल दिया गया था जिसे अतिरिक्त कोष्ठक की आवश्यकता नहीं है।

— Nayuki
स्रोत

एक Suanpan अबैकस ड्रा

J, 126 124 121 119 116 115 113 113 105 116 115 112 वर्ण

रूबी 1.9, 154 वर्ण

पर्ल (151 वर्ण)

व्याख्या

संपादित करता

विंडोज पॉवरशेल, 191

हास्केल, 243 वर्ण

डेल्फी, 348

GolfScript, 139 अक्षर

जे, 225

सी, 277 274 वर्ण

गणितज्ञ २ 281१

C, 548

स्काला (489 वर्ण)

स्किलिंग , 77 वर्ण

व्याख्या

अजगर, 309 301 288 वर्ण