N के साथ n प्रदर्शित करना

18

मैं क्या चाहता हूँ:

बहुत सरलता से, मैं एक पाठ आधारित प्रदर्शन चाहता हूं, जो इनपुट मांगता है n, फिर प्रदर्शन पर उस मूल्य को दिखाता है! लेकिन एक पकड़ है। प्रत्येक 'सही' 'पिक्सेल' (भरे हुए) को उस संख्या द्वारा दर्शाया जाना है n।

उदाहरण :

आपको एक इनपुट दिया जाता है n। आप मान सकते हैं nकि एक एकल अंक होगा

Input: 0
Output:
000
0 0
0 0
0 0
000

Input: 1
Output:
  1
  1 
  1
  1
  1

Input: 2
Output:
222
  2
222
2
222

Input: 3
Output:
333
  3
333
  3
333

Input: 4
Output:
4 4
4 4
444
  4
  4

Input: 5
Output:
555
5  
555
  5
555

Input: 6
Output:
666
6    
666
6 6
666

Input: 7
Output:
777
  7
  7
  7
  7

Input: 8
Output:
888
8 8
888
8 8
888

Input: 9
Output:
999
9 9
999
  9
999

चुनौती:

ऊपर से इसे जितना संभव हो उतना कम बाइट्स में करें।

मैं केवल उन उत्तरों को स्वीकार करूंगा जो सभी आवश्यकताओं को पूरा करते हैं।

जब तक अंक ठीक से प्रदर्शित नहीं हो जाता , तब तक व्हॉट्सएप घूमना वैकल्पिक है।

इसके अलावा, <75 बाइट्स मेरे लिए एक वोट है, सबसे कम स्वीकार है, लेकिन मैं हमेशा स्वीकार किए गए उत्तर को बदल सकता हूं, इसलिए जवाब देने के लिए निराश न हों।

code-golf  ascii-art  kolmogorov-complexity 
— VortexYT
स्रोत
— एमिग्ना
निश्चित रूप से, यह एक डुप्लिकेट है। यह निश्चित रूप से बहुत निकट है, इस
— शैगी
— कॉमरेड स्पार्कलपनी
2
मुझे नहीं लगता कि इसका कोई ठप्पा है। जबकि प्रश्न बहुत समान हैं, मुझे लगता है कि वर्णों का कम सेट (0-9) कुछ अलग उत्तरों के लिए बनेगा।
— डिजिटल ट्रामा

जवाबों:

8

SOGL V0.12 , 30 बाइट्स

■'τč▲Β►║⁰ΡāQšJ┘tXdnοO¹‘'¹n.w3n

यह कोशिश करो! संकुचित स्ट्रिंग ■'τč▲Β►║⁰ΡāQšJ┘tXdnοO¹‘है

  ŗ  ŗ  ŗ  ŗ  ŗŗŗŗ  ŗŗŗŗŗ  ŗŗŗŗŗŗ  ŗŗŗŗ  ŗŗŗŗŗ ŗŗ ŗŗŗŗ  ŗ  ŗŗŗŗŗ  ŗŗŗ  ŗŗŗŗŗŗŗŗ  ŗŗŗŗ ŗŗŗŗŗŗŗ  ŗ  ŗ  ŗ  ŗŗŗŗŗ ŗŗŗŗŗ ŗŗŗŗŗŗŗŗ ŗŗŗŗ  ŗŗŗŗŗŗŗŗ ŗŗ ŗŗ ŗŗŗŗ

जो है (1 से शुरू होकर, 0 से समाप्त) संख्या, रेखा से रेखा, संख्या से संख्या। बाकी

...‘             push the compressed string, replacing the ŗs with pop - the input
    '¹n          split into chunks of 15
       .w        push the (1-indexed, wrapping) input-th item of that array
             3n  split into chunks of 3
                 implicitly output the array, line by line
— dzaima
स्रोत
मैं के बारे में है कि कैसे आप में ऐसा करने में कामयाब प्रभावित कर रहा हूँ 35 में बाइट्स एक जाने! हालाँकि मैंने पहले कभी एसओजीएल का उपयोग नहीं किया है, मैंने एक ऑनलाइन परीक्षक का उपयोग किया है और यह काम करता है!
— भंवर
संख्या आकार डेटा वास्तव में केवल 17 बाइट्स है (6 बाइट्स खो गई लंबाई डेटा हैं और यह `` और -) है, और बाकी आसान है। मैं उत्सुक हूं, आपने किस ऑनलाइन परीक्षक का उपयोग किया है? मैंने न तो बनाया है और न ही किसी को देखा है।
— dzaima
ओह, ऊपर SOGL पर क्लिक करें! आपको 1MB या कुछ और जैसे कुछ डाउनलोड करना होगा। मैंने उसे तुरन्त हटा दिया। : /
— भंवर
तुमने ये कैसे किया?
— भंवर
ओह वाह! तुम्हें बधाई! आपको इसमें बहुत सी फाइलें लगती हैं। हो सकता है कि इसे थोड़ा अलग किया जाए
— VortexYT
13

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

f=
n=>`019
2 3
459
6 7
889`.replace(/\d/g,c=>[2,18,142,96,130,131,698,4,146][c]>>n&1?` `:n)
<input type=number min=0 max=9 oninput=o.textContent=f(this.value)><pre id=o>
स्निपेट का विस्तार करें

संख्याएँ सांकेतिक शब्दों में बताती हैं कि वर्गों में किसी दिए गए अंक के लिए रिक्त स्थान होते हैं। नीचे बाएँ कोने का मूल्य 146 होता है क्योंकि 1, 4 और 7 इसका उपयोग नहीं करते हैं और 146 = 2¹ + 2⁴ + 2⁷।

— नील
स्रोत
11

05AB1E , 40 39 38 बाइट्स

•Y¤ŸèK'¦ú’ò™^N•4B5ô¹èvð¹«5714yè8+b¦Sè,

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

व्याख्या

•Y¤ŸèK'¦ú’ò™^N•            # the compressed string "318975565561233953387608032537"

4B                         # convert to base-4
  5ô                       # split into strings of size 5
    ¹è                     # get the string at index <input>
      v                    # for each digit y in string
          5714yè           # get the digit in 5714 at index y
                8+         # add 8
                  b        # convert to binary
                   ¦       # remove the leading 1
       𹫠         Sè     # with each digit in the binary number, 
                           # index into the string " <input>"   
                      ,    # print with newline
— Emigna
स्रोत
11

जाप , 43 बाइट्स

"Ýûÿ©ÿßY÷ß"®c s4äëAU ¬£2839¤ë4X÷d0S1U

कुछ unprintables शामिल हैं। इसे ऑनलाइन आज़माएं!

टैली: संपीड़ित डेटा के 13 बाइट्स, इसे विघटित करने के लिए 9 बाइट्स, और आउटपुट बनाने के लिए 21 बाइट्स।

व्याख्या

अघोषित कोड:

"Ýûÿ©ÿßY÷ß"®   c s4à ¤  ëAU ¬ £  2839¤  ë4Xà ·  d0S1U
"Ýûÿ©ÿßY÷ß"mZ{Zc s4} s2 ëAU q mX{2839s2 ë4X} qR d0S1U

वहाँ बिल्कुल 4 अलग पंक्ति संभावनाएं हैं: ( #एक अंक का प्रतिनिधित्व करता है)

#  
  #
# #
###

इस प्रकार, प्रत्येक संख्या को पांच आधार -4 अंकों के सेट के रूप में संग्रहीत किया जा सकता है। चूंकि प्रत्येक संख्या को 10 बिट्स में संग्रहीत किया जा सकता है, कुल 100 बिट्स है, जो 13 बाइट्स से मेल खाती है। मैं संपीड़न प्रक्रिया को छोड़ दूंगा और इसके बजाय विघटन को समझाऊंगा।

mZ{Zc s4} 

mZ{     }  // Replace each character Z in the compressed string with the following:
   Zc      //   Take the char-code of Z.
      s4   //   Convert to a base-4 string.

विघटन के बाद, 13-बाइट संकुचित स्ट्रिंग इस तरह दिखता है:

3131332333332111200122213333313321011121213133133133

ध्यान दें कि यह विफल हो जाएगा यदि 4 अंकों में से कोई भी रन के साथ शुरू होता है 0, क्योंकि अग्रणी शून्य s4को चलाने के दौरान छोड़ दिया जाएगा । हम इसका 0प्रतिनिधित्व करते हुए इसे ठीक कर सकते हैं #  , जो केवल तीन बार दिखाई देता है, और उनमें से कोई भी 4 अंकों के रन की शुरुआत में नहीं आता है।

s2         // Slice off the first two chars of the result.

ठीक है, इसलिए 4 के क्रम में अच्छी तरह से संपीड़ित करने के लिए हमारे 50-अंकीय स्ट्रिंग प्राप्त करने के लिए, हमें दो अतिरिक्त अंक जोड़ना होगा। उन्हें स्ट्रिंग की शुरुआत में जोड़ने का मतलब है कि हम उन्हें एक-बटर के साथ काट सकते हैं ¤।

ëAU        // Take every 10th (A) char in this string, starting at index <input> (U).

ताज्जुब की बात है कि, Japt में X की लंबाई के स्लाइस में एक स्ट्रिंग को विभाजित करने के लिए बिल्ट-इन का अभाव है। इसमें हर Xth char प्राप्त करने के लिए बिल्ट-इन है, इसलिए हम पहले सभी शीर्ष पंक्तियों को एन्कोडिंग करके सभी डेटा को स्टोर कर सकते हैं, फिर दूसरी पंक्तियों आदि के सभी।

तो अब हमारे पास 5-अंकीय स्ट्रिंग एन्कोडिंग है जो अंक हम बनाना चाहते हैं, उदाहरण के 32223लिए 0।

q mX{2839s2 ë4X} qR
q                    // Split the resulting string into chars.
  mX{          }     // Replace each char X with the result of this function:
     2839s2          //   Convert the magic number 2839 to a binary string.
            ë4X      //   Take every 4th char of this string, starting at index X.
                 qR  // Join the result with newlines.

जादू की संख्या को समझाने के लिए, चार अलग-अलग पंक्तियों का संदर्भ लें। यदि आप के #साथ 1और  साथ प्रतिस्थापित करते हैं 0, तो आप प्राप्त करते हैं

100
001
101
111

इसे ट्रांसपोज़ करना और फिर सिंगल स्ट्रिंग में शामिल होना हमें देता है 101100010111। दशमलव और ध्वनि में परिवर्तित करें, आपके पास 2839 हैं। प्रक्रिया को उलट कर अंकों को मैप करता है0123 को ऊपर दिखाए गए चार बाइनरी पंक्तियों में है।

लगभग हो गया! अब बस इतना करना बाकी है कि रिक्त स्थान और अंकों में जोड़ दिया जाए:

d0S1U      // In the resulting string, replace 0 with " " (S) and 1 with <input> (U).

और प्रेस्टो, निहित उत्पादन बाकी की देखभाल करता है। मुझे खेद है कि यह स्पष्टीकरण इतना लंबा है, लेकिन मुझे इसे कम समझने योग्य बनाने के लिए इसे (यदि यह समझ में आता है, तो बिना इसे समझने के लिए कोई वास्तविक तरीका नहीं दिखता ...)

— ETHproductions
स्रोत
9

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

एक स्ट्रिंग के रूप में इनपुट लेता है।

n=>'02468'.replace(/./g,c=>(n+n+n+`   ${n} `+n).substr([126,341,36,68,327.5,66,98,340,102,70][n]*4>>c&6,3)+`
`)

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

पैटर्न एन्कोडिंग

चार अलग पैटर्न "XXX", "X..", "..X"और "X.X"के रूप में संकुचित किया जा सकता है "XXX...X.X"और इस तरह से निकाला:

XXX...X.X
^^^        --> XXX  (id = 0 / pointer = 0)
  ^^^      --> X..  (id = 1 / pointer = 2)
    ^^^    --> ..X  (id = 2 / pointer = 4)
      ^^^  --> X.X  (id = 3 / pointer = 6)

वास्तविक स्थानों के nलिए इनपुट अंक को प्रतिस्थापित "X"करके, यह अभिव्यक्ति देता है:

n+n+n+`   ${n} `+n

अंक एन्कोडिंग

ऊपर परिभाषित पैटर्न पहचानकर्ताओं का उपयोग करते हुए, प्रत्येक अंक को 5 * 2 = 10-बिट मात्रा द्वारा दर्शाया जा सकता है।

उदाहरण के लिए:

XXX  -->  0 *   1 =   0
X.X  -->  3 *   4 =  12
XXX  -->  0 *  16 =   0
..X  -->  2 *  64 = 128
XXX  -->  0 * 256 =   0
                    ---
                    140

पूरी सूची है:

[252, 682, 72, 136, 655, 132, 196, 680, 204, 140]

हालांकि, इन मूल्यों को 2 से विभाजित करने से दो बाइट्स को बचाने की अनुमति मिलती है। इसलिए इसके बजाय हम स्टोर करते हैं:

[126, 341, 36, 68, 327.5, 66, 98, 340, 102, 70]

डेमो

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

— Arnauld
स्रोत
6

बैश + जीएनयू के बर्तन, 114

  • 2 बाइट्स ने @SophiaLechner को धन्यवाद दिया

यहाँ संपीड़न के लिए संभवतः कुछ और अवसर हैं, लेकिन यहाँ एक शुरुआत है:

dc<<<4o16iEAC00CDF33AC373DEF00EEFB3p|fold -5|sed "$[$1+1]!d
s/0/  x\n/g
s/1/x\n/g
s/2/x x\n/g
s/3/xxx\n/g
y/x/$1/"

व्याख्या

हर अंक की प्रत्येक पंक्ति इन चार पैटर्न में से एक है:

  x
x
x x
xxx

इन 0-3 को लेबल करके, प्रत्येक अंक को 5 आधार -4 अंकों द्वारा दर्शाया जा सकता है। उदाहरण 0 होगा 32223, और अंकों की पूरी सूची को आधार -4 में इनकोड किया गया है 32223000003031330303223003130331323300003232332303। इस के रूप में हेक्स में एन्कोड किया गया EAC00CDF33AC373DEF00EEFB3।

  • dcहेक्स EAC00CDF33AC373DEF00EEFB3को बेस -4 में परिवर्तित करता है ।
  • fold प्रत्येक लाइन पर 5 आधार -4 अंक डालता है
  • sed:
    • लाइन नंबर n + 1 (sed 1-indexes lines) के अलावा सभी इनपुट लाइनों को हटाता है
    • आधार -4 अंकों को पैटर्न में अनुवाद करता है (इन x प्रत्येक पंक्ति के अंत के लिए एक नई रेखा के साथ, दिए गए अंकों की प्रत्येक पंक्ति के तों) में
    • अंको xको अंकीय n में बदलना।

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

— डिजिटल आघात
स्रोत
1
अच्छा विचार! एक जोड़े को बचाने की जगह बाइट्स s/1/x \n/gके साथ s/1/x\n/g, के बाद से उन रिक्त स्थान नेत्रहीन उत्पादन को प्रभावित नहीं करेगा।
— सोफिया लेचनर
5

MATL , 45 43 बाइट्स

'V~4;LR`I-D2q (z%eI)P-nc'F TFZa15eiZ)5eGV*c

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

व्याख्या

'V~4;LR`I-D2q (z%eI)P-nc' % Compressed string using printable ASCII except '
F TFZa                    % Decompress (change of base) into alphabet [1 0]
15e                       % Reshape into 15-row matrix. Each column contains the
                          % art for one digit, packed in column-major order
iZ)                       % Take input number and pick the corresponding column.
                          % Indexing is 1-based and modular, so 0 is at the end
5e                        % Reshape into a 5-row matrix. This already looks like
                          % the number, with active pixels as 1 and inactive as 0
GV                        % Push input number again. Convert to string, of one char
*                         % Multiply, element-wise. The previous char is
                          % interpreted as its ASCII code. This changes 1 into the 
                          % ASCII code of the input digit, and leaves 0 as is
c                         % Convert to char. Implicitly display. Char 0 is shown as
                          % a space
— लुइस मेंडो
स्रोत
3

रेटिना, 166 164 163 बाइट्स

तीसरी पंक्ति में नीचे से दो स्थान

0
0addda
d
0 0
1
1b1b1b1b1b1
2
2ab2a2b222
3
3ab3ab3a
4
44 44 4ab4b4
5
55ab555b5a
6
66ab6a 6a
7
7ab7b7b7b7
8
88a 8a8 8a
9
99a 9ab9a
(\d)a
$1$1$1$1
^.

b
  
.{3}
$+¶

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

@ ओएक्सएक्स के समाधान का एक उन्नत संस्करण

— गणित के दीवाने
स्रोत
2

बैच फ़ाइल, 8 + 184 बाइट्स

यहाँ मेरा अनिवार्य बैच समाधान है। दुर्भाग्य से इसे पूरा करने का मानक तरीका बैच में 300 से अधिक बाइट्स है, इसलिए हम बहुत सस्ती रणनीति का सहारा लेते हैं।

@type %1

वर्तमान निर्देशिका में, मेरे पास 10 फाइलें हैं, जिनका नाम 0 से 9 तक है। इनमें से प्रत्येक में पिक्सल के संबंधित 5x3 ग्रिड हैं। उदाहरण के लिए:

यहाँ छवि विवरण दर्ज करें

इनके लिए बाइट मायने रखती है:

19 0
19 1
17 2
19 3
19 4
17 5
17 6
19 7
19 8
19 9
Total - 184

फिर भी जावा को हराया।

— BDM
स्रोत
1

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

->n{20.times{|i|print i%4>2?$/:[" ",n]["_Q_@@_]UWUU_GD_WU]_U]AA__U_WU_"[n*3+i%4].ord>>i/4&1]}}

परीक्षण कार्यक्रम में अपराजित

f=->n{
  20.times{|i|                           #4 characters * 5 rows = 20
    print i%4>2?$/:                      #If i%4=3 print a newline else
    [" ",n][                             #either a space if the expression below is 0 or the digit n if 1.
      "_Q_@@_]UWUU_GD_WU]_U]AA__U_WU_"[  #bitmap data for digits, one character for each column
        n*3+i%4].ord>>i/4&1              #Select the correct character for the column, convert to ascii code,
    ]                                    #rightshift to find the correct bit for the row, 
  }                                      #use & to isolate the bit: 0 or 1
}

f[gets.to_i]
— स्तर नदी सेंट
स्रोत
1

PHP, 115 बाइट्स

for(;$i<5;)echo strtr(sprintf("%03b\n","1754"[[425,0,465,273,26,285,413,1,409,281][$argn]/4**$i++%4]),[" ",$argn]);

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

विस्तारित

for(;$i<5;)
  echo strtr(
    sprintf("%03b\n",  # make a binary
      "1754"[[425,0,465,273,26,285,413,1,409,281][$argn]/4**$i++%4])
    ,[" ",$argn]); # replace 0 with space and 1 with the input

एन्कोडिंग ऑनलाइन यह कोशिश करो!

— जार्ग हुल्सरमन
स्रोत
1

रेटिना , 125 बाइट्स

.
A$&¶B$&¶C$&¶D$&¶E$&
([ACE][235689]|A0|E0|C4|A7)(?<=(.))
$2$2$2
(B[0489]|D[068]|A4|C0)(?<=(.))
$2 $2
D2
2
B5
5
B6
6
[A-E]

इसे ऑनलाइन आज़माएं! (अलग-अलग इनपुट अंकों का परीक्षण करने के लिए हेडर में टेस्ट सूट हटाएं।) अंतिम पंक्ति में दो स्थान हैं।

— नील
स्रोत
1

पॉवरशेल, 126 120 113 109 101

$n="$args"
-split'ϽϭϿ·ͱ Ο·ͽͼϿ·Ņ ϻ·ͭͭϿ'|%{-join($_[0..2]|%{"$n·"[!($_-band1-shl$n)]})}

यूनिकोड मजेदार है। वर्ण भी संख्या की तुलना में छोटे हैं। उपरोक्त कोड में दो बार U + 0000 शामिल हैं, इस प्रकार सीधे कॉपी नहीं की जा सकती (फ़ाइल में ठीक काम करता है, हालांकि)। निम्नलिखित कोड की प्रतिलिपि बनाई जा सकती है:

$n="$args"
-split"ϽϭϿ ͱ`0Ο ͽͼϿ Ņ`0ϻ ͭͭϿ"|%{-join($_[0..2]|%{"$n "[!($_-band1-shl$n)]})}

हम तीन बाइट्स खो देते हैं क्योंकि हमें शुरुआत में UTF-8 हस्ताक्षर की आवश्यकता होती है। अन्यथा स्ट्रिंग काम नहीं करेगी।

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

रेटिना , 190 बाइट्स

0
000¶aaa000
a
0 0¶
1
aaaaa
a
b1¶
2
ab2¶a2¶a
a
222¶
3
ab3¶ab3¶a
a
333¶
4
4 4¶4 4¶444¶b4¶b4
5
a5b¶ab5¶a
a
555¶
6
a6¶a6 6¶a
a
666¶
7
777aaaa
a
¶b7
8
a8 8¶a8 8¶a
a
888¶
9
a9 9¶ab9¶a
a
999¶
b

अंतिम पंक्ति में दो स्थान हैं लेकिन एसई इसे रेंडर नहीं करना चाहता: / फिक्स्ड!

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

— Okx
स्रोत
मेरे पास aतीन अंकों और एक नई रेखा के साथ बार-बार प्रतिस्थापन को संयोजित करने का एक तरीका है । (शायद लुकाहेड्स का उपयोग कर रहे हैं?)
— गणित नशेड़ी
@ मैथजंकी हाँ: /
— ओकेक्स
1

जावा 8, 278 214 210 204 बाइट्स

n->("A"+n+"\nB"+n+"\nC"+n+"\nD"+n+"\nE"+n).replaceAll("([ACE][235689]|A0|E0|C4|A7)(?<=(.))","$2$2$2").replaceAll("(B[0489]|D[068]|A4|C0)(?<=(.))","$2 $2").replaceAll("D2|B5|B6",n).replaceAll("[A-E]","  ")

पोर्ट ऑफ @ नील का रेटिना उत्तर । इनपुट के रूप में लेता है String।

इसे यहाँ आज़माएँ।

— केविन क्रूज़सेन
स्रोत
1

पॉवरशेल , 159 135 128 118 बाइट्स

param($n);0..4|%{("$n$n$n","$n $n","  $n","$n  ")['01110333330203002020110220302003010022220101001020'[$_+($n*5)]-48]}

वर्तमान उत्तर: निकाले गए चर नामकरण को हटा दिया गया

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

मुझे यह देखना होगा कि क्या मुझे अन्य उत्तरों से कुछ तरकीबें मिल सकती हैं: पी

EDIT मेगा स्ट्रिंग को कॉल करने के साथ होशियार हो रही है

EDIT2$a 7 बाइट्स को बचाने के लिए इंडेक्स में संख्याओं की एक स्ट्रिंग का उपयोग करने के लिए स्विच किया गया । हालाँकि मुझे अपना पिछला डायनामिक वैरिएबल नेम कॉल नीचे के कोड में पसंद आया (135 बाइट्स)

param($n);$a="$n$n$n";$b="$n $n";$c="  $n";$d="$n  ";$r="abbbadddddacadaacacabbaccadacaadabaaccccababaabaca";0..4|%{gv $r[$_+($n*5)]-v}
— sinusoid
स्रोत
0

चारकोल , 61 38 बाइट्स

Ｅ§⪪”{⊞¶↙⬤\→*'K«-aRＱ¹νÀ⁰”⁵Ｎ⭆421⎇＆ＩιＩλθ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। नोट: अनुगामी स्थान। स्पष्टीकरण:

Ｅ§⪪”{⊞¶↙⬤\→*'K«-aRＱ¹νÀ⁰”⁵Ｎ

5 के समूहों में (संपीड़ित) स्ट्रिंग को विभाजित करें, इनपुट द्वारा दिए गए इंडेक्स पर एक लें, और समूह में पात्रों पर मैप करें (जो हमेशा 1, 4, 5 या 7 हैं)।

⭆421⎇＆ＩιＩλθ

अंकों के रूप में इनपुट वर्ण और स्थान का उपयोग करके चरित्र को आधार 10 से 3 अंकों के आधार 2 में परिवर्तित करें। 5 परिणामों को फिर अलग-अलग लाइनों पर छापा जाता है।

एक सामान्य बंदरगाह थोड़ा उबाऊ है, इसलिए यहां एक अधिक मुहावरेदार 61-बाइट का जवाब है:

ＧＨ✳✳§⟦⟦↑L↓¬⟧⟦↓↓⟧⟦T↓→⟧⟦T→¬⟧⟦↑↑¬↑⟧⟦←↓T⟧⟦T↑L⟧⟦→↓↓⟧⟦+L↓⟧⟦+↓T⟧⟧Ｎ³θ

इसे ऑनलाइन आज़माएं! कोई वर्बोज़ संस्करण नहीं है क्योंकि डिवर्बोसिफ़र दिशाओं की सूची या साधारण बहुभुज के अंदर भी मल्टीडायरेक्शनल को नहीं समझता है। स्पष्टीकरण:

     ⟦...⟧      Array of paths, see below
          Ｎ     Input as an integer
    §           Index into the array
  ✳✳            Treat the element as direction data
           ³    Length of each segment (including 1 character overlap)
            θ   Draw using the input character
ＧＨ              Draw a path

प्रत्येक पथ निर्देशों की सूची ( ←↑→↓) का उपयोग करके निर्दिष्ट किया गया है । बाइट्स बचाने चार उपयोगी शॉर्टकट: Lका प्रतिनिधित्व करता है ↑→, ¬का प्रतिनिधित्व करता है ↓←, Tका प्रतिनिधित्व करता है →↓←, जबकि +का प्रतिनिधित्व करता →↓←↑है, हालांकि कम से कम एक तीर सूची के लिए रहना चाहिए एक दिशा सूची के रूप में मान्यता प्राप्त होना (ताकि उदाहरण के लिए TTके लिए इस्तेमाल नहीं किया जा सकता है 3)।

— नील
स्रोत
0

पायथन 3 , 119 बाइट्स

lambda n:(3*f"%s%s{n}\n%s %s\n")[:30]%(*[n if i//(2**n)%2else" "for i in[1021,1005,881,927,893,892,325,1019,877,877]],)

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

प्रत्येक 'पिक्सेल' को एक पूर्णांक के रूप में दर्शाया जाता है जहाँ दो की प्रत्येक शक्ति इंगित करती है कि पिक्सेल ठोस है या नहीं। यह इस तथ्य का लाभ उठाता है कि तीन दाहिने हाथ के कोने हमेशा अंक होते हैं।

— मैथ्यू जेन्सेन
स्रोत
-1

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

n=>`019
2 3
459
6 7
889`.replace(/\d/g,c=>[2,18,142,96,130,131,698,4,146][c]>>n&1?' ':n)
— mhmhhmgg
स्रोत
2
ये है ठीक वैसा ही जवाब है जैसा कि27 अप्रैल के @Neil के जावास्क्रिप्ट उत्तर में है। यदि आपके पास कुछ ऐसा है जो वह सुधार सकता है, तो आपको एक नया पोस्ट करने के बजाय उसके उत्तर पर टिप्पणी करनी चाहिए जो कि एक ही है (EDIT: और हाँ, मुझे एहसास है आपके पास अभी तक टिप्पणी करने के लिए पर्याप्त प्रतिष्ठा नहीं है ..)
— केविन क्रूज़सेन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.