21

यहाँ 0 के माध्यम से अंक 0 के लिए 7 फ़ॉन्ट द्वारा एक पिक्सेल 5 है:

.███.
█...█
█...█
█...█
█...█
█...█
.███.

..█..
███..
..█..
..█..
..█..
..█..
█████

.███.
█...█
....█
...█.
..█..
.█...
█████

.███.
█...█
....█
..██.
....█
█...█
.███.

█..█.
█..█.
█..█.
█████
...█.
...█.
...█.

█████
█....
█....
.███.
....█
█...█
.███.

.███.
█...█
█....
████.
█...█
█...█
.███.

█████
....█
....█
...█.
...█.
..█..
..█..

.███.
█...█
█...█
.███.
█...█
█...█
.███.

.███.
█...█
█...█
.████
....█
█...█
.███.

(यह फ़ॉन्ट और संभवत: यह पृष्ठ बेहतर दिखेगा अगर आप अपने ब्राउज़र कंसोल में या यूआरएल बार लगाया जाता है में इस JavaScipt कोड चलेंगे javascript:: $('#question pre,.answer pre').css('line-height',1)।)

पाठ के दो समान आकार के आयताकार ब्लॉक लिखें, एक खाली स्थानों का प्रतिनिधित्व करने के लिए (. ऊपर के फ़ॉन्ट में ) का प्रतिनिधित्व करने के लिए, और एक भरे हुए रिक्त स्थान का प्रतिनिधित्व करने के लिए ( █)।

जब इन दोनों टेक्स्ट ब्लॉक को ऊपर के अंकों में से एक के रूप में एक ही 5 × 7 पैटर्न में व्यवस्थित किया जाता है, तो परिणामस्वरूप बड़े टेक्स्ट ब्लॉक को एक प्रोग्राम होना चाहिए जो उस अंक को स्टडआउट करने के लिए प्रिंट करता है। यह सभी 10 अंकों के लिए काम करना चाहिए।

उदाहरण के लिए, यदि आपका .टेक्स्ट ब्लॉक था

---
'''

और आपका █टेक्स्ट ब्लॉक था

ABC
123

फिर कार्यक्रम

---ABCABCABC---
'''123123123'''
ABC---------ABC
123'''''''''123
ABC---------ABC
123'''''''''123
ABC---------ABC
123'''''''''123
ABC---------ABC
123'''''''''123
ABC---------ABC
123'''''''''123
---ABCABCABC---
'''123123123'''

आउटपुट चाहिए 0। इसी तरह, कार्यक्रम

------ABC------
''''''123''''''
ABCABCABC------
123123123''''''
------ABC------
''''''123''''''
------ABC------
''''''123''''''
------ABC------
''''''123''''''
------ABC------
''''''123''''''
ABCABCABCABCABC
123123123123123

आउटपुट चाहिए 1 , और इस तरह के कार्यक्रम के लिए 9।

अंक के आकार के कार्यक्रम बनाने के लिए आप इस स्टैक स्निपेट का उपयोग कर सकते हैं:

<style>textarea{font-family:monospace;}</style><script>function go(){var t=parseInt(document.getElementById("digit").value[0]);if(isNaN(t))return void alert("Invalid digit.");for(var e=document.getElementById("empty").value.split("\n"),n=document.getElementById("filled").value.split("\n"),l=[],o=0;o<7*e.length;o++){l[o]="";for(var d=0;5>d;d++)l[o]+=font[t][Math.floor(o/e.length)][d]?n[o%n.length]:e[o%e.length]}document.getElementById("output").value=l.join("\n")}font=[[[0,1,1,1,0],[1,0,0,0,1],[1,0,0,0,1],[1,0,0,0,1],[1,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]],[[0,0,1,0,0],[1,1,1,0,0],[0,0,1,0,0],[0,0,1,0,0],[0,0,1,0,0],[0,0,1,0,0],[1,1,1,1,1]],[[0,1,1,1,0],[1,0,0,0,1],[0,0,0,0,1],[0,0,0,1,0],[0,0,1,0,0],[0,1,0,0,0],[1,1,1,1,1]],[[0,1,1,1,0],[1,0,0,0,1],[0,0,0,0,1],[0,0,1,1,0],[0,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]],[[1,0,0,1,0],[1,0,0,1,0],[1,0,0,1,0],[1,1,1,1,1],[0,0,0,1,0],[0,0,0,1,0],[0,0,0,1,0]],[[1,1,1,1,1],[1,0,0,0,0],[1,0,0,0,0],[0,1,1,1,0],[0,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]],[[0,1,1,1,0],[1,0,0,0,1],[1,0,0,0,0],[1,1,1,1,0],[1,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]],[[1,1,1,1,1],[0,0,0,0,1],[0,0,0,0,1],[0,0,0,1,0],[0,0,0,1,0],[0,0,1,0,0],[0,0,1,0,0]],[[0,1,1,1,0],[1,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0],[1,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]],[[0,1,1,1,0],[1,0,0,0,1],[1,0,0,0,1],[0,1,1,1,1],[0,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]]]</script><textarea id='empty' rows='8' cols='32' placeholder='empty space text block...'></textarea><textarea id='filled' rows='8' cols='32' placeholder='filled space text block...'></textarea><br>Digit <input id='digit' type='text' value='0'> <button type='button' onclick='go()'>Generate</button><br><br><textarea id='output' rows='16' cols='64' placeholder='output...' style='background-color: #eee;' readonly></textarea>

स्निपेट का विस्तार करें

विवरण

10 बड़े पाठ ब्लॉक कार्यक्रमों में से किसी को भी इनपुट की आवश्यकता नहीं होनी चाहिए। केवल एकल अंक प्लस एक वैकल्पिक अनुगामी न्यूलाइन आउटपुट। स्टडआउट या एक समान विकल्प के लिए आउटपुट।
कोई भी प्रोग्राम अपने स्वयं के सोर्स कोड को पढ़ या एक्सेस नहीं कर सकता है। इसे एक सख्त क्वीन चैलेंज की तरह ट्रीट करें ।
पाठ खंड समान नहीं हो सकता है और इसमें गैर-डायनेमो आयाम होना चाहिए।
टेक्स्ट ब्लॉक में लाइन टर्मिनेटर को छोड़कर कोई भी वर्ण हो सकता है ।
10 कार्यक्रमों को एक ही भाषा में लिखे गए पूर्ण कार्यक्रम होने चाहिए, वे REPL स्निपेट नहीं हैं । आप वैकल्पिक रूप से उन सभी या उनमें से किसी के लिए एक अनुगामी न्यूलाइन जोड़ सकते हैं।

स्कोरिंग

आपका स्कोर आपके टेक्स्ट ब्लॉक में से एक का क्षेत्रफल (चौड़ाई गुना ऊंचाई) है। (वे एक ही आकार के हैं इसलिए दोनों ब्लॉकों को गिनने का कोई मतलब नहीं है।) 6 के स्कोर के लिए उदाहरण का क्षेत्र 3 से 2 है।

सबसे कम स्कोर जीतता है। संबंधों के मामले में, सबसे ज्यादा वोट देने वाला उत्तर जीत जाता है।

code-golf source-layout

— केल्विन के शौक
स्रोत

अपने कोड पर, आप इसे बहुत सुधार सकते हैं। var t=parseInt(document.getElementById("digit").value[0]);if(isNaN(t))return void alert("Invalid digit.");के रूप में लिखा जा सकता है var t=document.getElementById("digit").value[0]/1;if(t!=t)return void alert("Invalid digit.");, जो समान है लेकिन कम है। कुछ और चीजें हैं जो आप इसमें सुधार कर सकते हैं, लेकिन यह बहुत अच्छी लगती है!

— इस्माइल मिगुएल

4

@IsmaelMiguel TBH मैंने इसे एक लाइन पर लाने के लिए JS मिनिफ़ायर के माध्यम से रखा। यह कभी गोल्फ होने के लिए नहीं था।

— केल्विन के

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

— इस्माइल मिगुएल

6

@IsmaelMiguel मैंने ungolfed उपयोगिता कोड पोस्ट किया , जो यकीनन जितना संभव हो उतना पठनीय होना चाहिए ताकि बग्स को स्पॉट करना आसान हो। लेकिन वास्तव में, जब तक यह काम करता है, स्टैक स्निपेट के कोड आकार का शाब्दिक रूप से चुनौती के परिणाम पर शून्य असर होता है।

— केल्विन के शौक

3

text blocks may not be identicalवास्तव में? मैं किसी को इस नियम को तोड़ते हुए देखना चाहता हूं, दो समान कोडब्लॉक देकर, जो जादुई रूप से अलग-अलग अंक लौटाता है, जब हर नंबर बिल्कुल एक ही कोड है ^ ^

— Falco

13

सीजाम, 20 18 14 13 12 * 1 = 12

इसे ऑनलाइन आज़माएं: 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9

खाली ब्लॉक

];BG*K+ :BD%

ठोस ब्लॉक

];B9+33%:B4/

व्याख्या

मैंने Sp3000 के समाधान के लिए एक समान रणनीति का उपयोग किया , जैसे कि प्रत्येक ब्लॉक एक चर पर एक गुणन, एक जोड़, और (संभवतः) एक modulo ऑपरेशन करता है और मूल्य वापस बचाता है। एक इष्टतम समाधान खोजने के लिए, मैंने अच्छे पुराने जानवर बल का उपयोग किया। मैंने एक कार्यक्रम लिखा जो सभी संभावित प्रारंभिक मानों (सीजेएम चर के प्रारंभिक मूल्यों) के स्थान की खोज करता है और कई लाखों संभावित जोड़े ऐसे परिवर्तन कार्य करते हैं जैसे कि प्रत्येक अंक के लिए आउटपुट अद्वितीय है। फिर, मैंने परिणामों को ऐसे फ़िल्टर किया कि अंकों का अंतिम परिणाम एक खाली ब्लॉक में समाप्त हो रहा है, जिसमें 8 हैं, दूसरे परिणाम के माध्यम से सही परिणाम पर वापस मैप किया जा सकता है, जोड़ सकते हैं, और modulo सूत्र।

खोज के CPU समय के कुछ दिनों के बाद, अब तक का सबसे अच्छा परिणाम 12 के आकार के नीचे है! यह समाधान मान के साथ शुरू होता है 11, खाली ब्लॉक परिवर्तन फ़ंक्शन है x * 16 + 20, खाली ब्लॉक परिणाम फ़ंक्शन है x % 13, ठोस ब्लॉक परिवर्तन फ़ंक्शन है (x + 9) % 33, और ठोस ब्लॉक परिणाम फ़ंक्शन है x / 4।

— Runer112
स्रोत

23

> <> (मछली) , ५ * १० = ५०

खाली ब्लॉक

   \   !9 
4n;    n/ 
1n;\      
       \  
0n;n7\\\

ठोस ब्लॉक

   \; n8/ 
     /!/!v
     \  ;6
3n;\ ! /nn
2n;n5<  8;

इस कोड में कोई तर्क या अंकगणित नहीं है केवल 'दर्पण' ( /और \) और दो 'तीर' ( <और v) के साथ> <> 2 डी अनुदेश सूचक (आईपी) के स्थैतिक पुनर्निर्देशन का उपयोग करता है । एकमात्र अन्य प्रवाह-नियंत्रक 'ट्रैम्पोलिन' ( !) है जो अगले चरित्र के माध्यम से कूदता है।

IP शीर्ष बाएँ पूर्व कोने से शुरू होता है। कुछ पुनर्निर्देशन के बाद यह एक नंबर यह ढेर पर धक्का दे दिया और साथ बाहर छपा है तक पहुँच जाता है nऔर साथ कार्यक्रम समाप्त ;।

कार्यक्रम का प्रवाह

एक ब्लॉक 'प्रोग्राम की वर्तमान स्थिति को' इस तथ्य से पहचानता है कि आईपी किस बिंदु पर आया और राज्य के आधार पर यह तय करता है कि पॉइंटर को बाहर निकालने के लिए उसे किस दिशा में जाना चाहिए (कौन सा ब्लॉक आगे निष्पादित किया जाना चाहिए) और जिसमें सटीक स्थिति सूचक को छोड़ दिया जाना चाहिए (जो कि नया राज्य होगा)। बेशक ब्लॉक कोई तर्क नहीं करते हैं यह सब व्यवहार रीडायरेक्टर्स से आता है।

— randomra
स्रोत

मैं इस तरह के जवाब की उम्मीद कर रहा था। शुद्ध जादू।

— ईगलवी_अटनाम 10

11

सीजाम, २३ २२ १ ९ * १ = १ ९

खाली ब्लॉक:

];G)B%:G"73860594"=

ठोस ब्लॉक:

];GW*B+3*D%:G    7-

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

मैं गणितीय संयोगों और असफलता के साथ भाग्यशाली होने की कोशिश कर रहा हूं, इसलिए यहां मार्टिन के समाधान से अद्वितीयता मानचित्रण के लिए थोड़ा अलग दृष्टिकोण है।

16 से शुरू करें। खाली ब्लॉक 1 जोड़ते हैं और modulo 11. लेते हैं। ठोस ब्लॉक -1 से गुणा करते हैं, 11 जोड़ते हैं, 3 से गुणा करते हैं फिर modulo लेते हैं। 13. यह जादुई रूप से मानचित्र 03456789(जो एक खाली ब्लॉक पर समाप्त होता है) 41753026, जिसे हम अनुक्रमण का उपयोग करते हैं। सही पाने के लिए। 12बड़े करीने से नक्शे 89, जिन्हें हम 7 घटाकर माप सकते हैं।

— Sp3000
स्रोत

7

CJam, 28 27 x 1 = 27

यहाँ एक शुरुआत है।