सुंदर पैटर्न दराज (लिटिल क्यूब्स शामिल)


18

सुंदर पैटर्न दराज

शुभ प्रभात पीपीसीजी!

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

सबसे पहले, निम्नलिखित आकार की जाँच करें:

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

जहां सभी काली संख्याएं आकृति में बिंदुओं का सूचकांक हैं और सभी गहरे-नीले अंक अंकों के बीच की कड़ी के सूचकांक हैं।

अब, 0x00000 से 0xFFFFF के लिए एक हेक्साडेसिमल नंबर दिया गया है, आपको केवल वर्ण स्थान और "■" का उपयोग करके कंसोल में एक आकृति बनाने की आवश्यकता है (चरित्र "ओ" का उपयोग करना भी ठीक है)।

यहाँ कुछ उदाहरण हैं जहां हेक्साडेसिमल संख्या इनपुट है और आकार आउटपुट है:

0xE0C25 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■               ■ 
■               ■ 
■               ■ 
■ ■ ■ ■ ■       ■ 
        ■       ■ 
        ■       ■ 
        ■       ■ 
        ■ ■ ■ ■ ■
0xC1043 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
              ■   
            ■     
          ■       
        ■         
      ■           
    ■             
  ■               
■ ■ ■ ■ ■ ■ ■ ■ ■ 
0xE4F27 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■       ■       ■ 
■       ■       ■ 
■       ■       ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■       ■       ■ 
■       ■       ■ 
■       ■       ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
0xF1957 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■           ■ ■ 
■   ■       ■   ■ 
■     ■   ■     ■ 
■       ■       ■ 
■     ■   ■     ■ 
■   ■       ■   ■ 
■ ■           ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
0xD0C67 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
  ■             ■ 
    ■           ■ 
      ■         ■ 
■ ■ ■ ■ ■       ■ 
      ■ ■       ■ 
    ■   ■       ■ 
  ■     ■       ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
0x95E30 :
■ ■ ■ ■ ■       ■ 
  ■     ■     ■ ■ 
    ■   ■   ■   ■ 
      ■ ■ ■     ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
        ■ ■       
        ■   ■     
        ■     ■   
        ■       ■ 
0x95622 :
■ ■ ■ ■ ■       ■ 
  ■     ■     ■   
    ■   ■   ■     
      ■ ■ ■       
■ ■ ■ ■ ■ ■ ■ ■ ■ 
        ■         
        ■         
        ■         
■ ■ ■ ■ ■         
0xC5463 : 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
        ■     ■   
        ■   ■     
        ■ ■       
■ ■ ■ ■ ■         
      ■ ■         
    ■   ■         
  ■     ■         
■ ■ ■ ■ ■ ■ ■ ■ ■ 
0xE5975 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■       ■     ■ ■ 
■       ■   ■   ■ 
■       ■ ■     ■ 
■       ■       ■ 
■     ■ ■ ■     ■ 
■   ■   ■   ■   ■ 
■ ■     ■     ■ ■ 
■       ■ ■ ■ ■ ■ 
0xB5E75 :
■ ■ ■ ■ ■       ■ 
■ ■     ■     ■ ■ 
■   ■   ■   ■   ■ 
■     ■ ■ ■     ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
      ■ ■ ■     ■ 
    ■   ■   ■   ■ 
  ■     ■     ■ ■ 
■       ■ ■ ■ ■ ■ 
0xF4C75 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■     ■       ■ 
■   ■   ■       ■ 
■     ■ ■       ■ 
■ ■ ■ ■ ■       ■ 
      ■ ■ ■     ■ 
    ■   ■   ■   ■ 
  ■     ■     ■ ■ 
■       ■ ■ ■ ■ ■
0xF5D75 :
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■     ■     ■ ■ 
■   ■   ■   ■   ■ 
■     ■ ■ ■     ■ 
■ ■ ■ ■ ■       ■ 
■     ■ ■ ■     ■ 
■   ■   ■   ■   ■ 
■ ■     ■     ■ ■ 
■       ■ ■ ■ ■ ■ 

यह कैसे काम करता है, इसके बारे में कुछ स्पष्टीकरण यहां दिए गए हैं:

0xFFFFF(16) = 1111 1111 1111 1111 1111(2)

आपके पास 20 बिट्स हैं, प्रत्येक बिट कहता है कि लिंक मौजूद है या नहीं।

सबसे महत्वपूर्ण बिट (MSB) का सूचकांक 0 (चित्र संदर्भ) या कम महत्वपूर्ण बिट (LSB) 19 है (चित्र संदर्भ फिर से)।

यहां बताया गया है कि यह उदाहरण के लिए दिए गए पहले आकार के लिए कैसे काम करता है:

0xE0C25(16) = 1110 0000 1100 0010 0101(2)

मतलब आपके पास निम्न मौजूदा लिंक होंगे: 0,1,2,8,9,14,17,19।

यदि आप उन नंबरों के साथ संदर्भ चित्र पर लाइनों को उजागर करते हैं, तो यह आपको यह आकार देगा:

■ ■ ■ ■ ■ ■ ■ ■ ■ 
■               ■ 
■               ■ 
■               ■ 
■ ■ ■ ■ ■       ■ 
        ■       ■ 
        ■       ■ 
        ■       ■ 
        ■ ■ ■ ■ ■

यदि आपको अधिक सहायता की आवश्यकता है, तो यहां एक सरल और अनगढ़ भेदी कार्यान्वयन है:

patterns = [
  0xE0C25, 0xC1043, 0xE4F27, 0xF1957, 
  0xD0C67, 0x95E30, 0x95622, 0xC5463, 
  0xE5975, 0xB5E75, 0xF4C75, 0xF5D75
]

def printIfTrue(condition, text = "■ "):
  if condition:
    print(text, end="")
  else:
    print(" "*len(text), end="")

def orOnList(cube, indexes):
  return (sum([cube[i] for i in indexes]) > 0)

def printPattern(pattern):
  cube = [True if n == "1" else False for n in str(bin(pattern))[2::]]
  for y in range(9):
    if y == 0: printIfTrue(orOnList(cube, [0, 2, 3]))
    if y == 4: printIfTrue(orOnList(cube, [2, 4, 9, 11, 12]))
    if y == 8: printIfTrue(orOnList(cube, [11, 13, 18]))
    if y in [0, 4, 8]:
      printIfTrue(cube[int((y / 4) + (y * 2))], "■ ■ ■ ")
      if y == 0: printIfTrue(orOnList(cube, [0, 1, 4, 5, 6]))
      if y == 4: printIfTrue(orOnList(cube, [3, 5, 7, 9, 10, 13, 14, 15]))
      if y == 8: printIfTrue(orOnList(cube, [12, 14, 16, 18, 19]))
      printIfTrue(cube[int((y / 4) + (y * 2)) + 1], "■ ■ ■ ")
    elif y in [1, 5]:
      for i in range(7):
        if i in [2, 5]:
          print(" ", end=" ")
        printIfTrue(cube[y * 2 + (1 - (y % 5)) + i])
    elif y in [2, 6]:
      for i in range(5):
        if i in [1, 2, 3, 4]:
          print(" ", end=" ")
        if i in [1, 3]:
          if i == 1 and y == 2:
            printIfTrue(orOnList(cube, [3, 4]))
          elif i == 3 and y == 2:
            printIfTrue(orOnList(cube, [6, 7]))
          if i == 1 and y == 6:
            printIfTrue(orOnList(cube, [12, 13]))
          elif i == 3 and y == 6:
            printIfTrue(orOnList(cube, [15, 16]))
        else:
          printIfTrue(cube[(y * 2 - (1 if y == 6 else 2)) + i + int(i / 4 * 2)])
    elif y in [3, 7]:
      for i in range(7):
        if i in [2, 5]:
          print("  ", end="")
        ri, swap = (y * 2 - 2) + (1 - (y % 5)) + i, [[3, 6, 12, 15], [4, 7, 13, 16]]
        if ri in swap[0]: ri = swap[1][swap[0].index(ri)]
        elif ri in swap[1]: ri = swap[0][swap[1].index(ri)]
        printIfTrue(cube[ri])
    if y == 0: printIfTrue(orOnList(cube, [1, 7, 8]))
    if y == 4: printIfTrue(orOnList(cube, [6, 8, 10, 16, 17]))
    if y == 8: printIfTrue(orOnList(cube, [15, 17, 19]))
    print()

for pattern in patterns:
  printPattern(pattern)

बेशक, यह सही नहीं है और यह बहुत लंबा है कि इसे क्या करना चाहिए, और यही सटीक कारण है कि आप यहां क्यों हैं!

इस कार्यक्रम को हास्यास्पद रूप से छोटा बनाना :)

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


क्या हम लाइनों पर एकल अनुगामी स्थान प्रिंट कर सकते हैं? आपके उदाहरणों में वे हैं।
orlp


4
क्या ग्राफिकल आउटपुट की अनुमति है?
12M2121

1
क्या आपको हेक्साडेसिमल इनपुट की आवश्यकता है या दशमलव ठीक है?
टाइटस

1
हो सकता है कि सभी कोड गोल्फ सिर्फ मुझे मिल रहा हो, लेकिन यह कोड पढ़ने में दर्दनाक है ...
लिन

जवाबों:


8

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

let f =

n=>`0${x=',16,-54,21,-26,21,21,-26,21,166'}${x},16`.split`,`.map((d,i)=>(k-=d,n)>>i&1&&[..."ooooo"].map(c=>g[p-=(k&3||9)^8]=c,p=k>>2),g=[...(' '.repeat(9)+`
`).repeat(9)],k=356)&&g.join``

console.log(f(0xE0C25))
console.log(f(0xC1043))
console.log(f(0xE4F27))
console.log(f(0xF1957))

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

n =>                                                 // given 'n':
  `0${x = ',16,-54,21,-26,21,21,-26,21,166'}${x},16` // build the list of delta values
  .split`,`.map((d, i) =>                            // split the list and iterate
    (k -= d, n) >> i & 1 &&                          // update 'k', test the i-th bit of 'n'
    [..."ooooo"].map(c =>                            // if the bit is set, iterate 5 times:
      g[                                             // 
        p -= (k & 3 || 9) ^ 8                        // compute the direction and update 'p'
      ] = c,                                         // write a 'o' at this position
      p = k >> 2                                     // initial value of 'p'
    ),                                               //
    g = [...(' '.repeat(9) + `\n`).repeat(9)],       // initialization of the 'g' array
    k = 356                                          // initial value of 'k'
  )                                                  //
  && g.join``                                        // yield the final string

हम g10 वर्णों की 9 पंक्तियों के ग्रिड पर काम करते हैं । ग्रिड शुरू में रिक्त स्थान से भरा है, हर 10 वें पंक्ति में एक लाइनफ़ीड के साथ।

प्रत्येक खंड को एक प्रारंभिक स्थिति और एक दिशा द्वारा परिभाषित किया गया है।

निर्देशों का पालन के रूप में इनकोड किया गया है:

ID | Dir.| Offset
---|-----|-------
 0 |  W  |  -1        Offset encoding formula:
 1 | NE  |  -9        -((ID || 9) ^ 8)
 2 |  N  |  -10
 3 | NW  |  -11

प्रत्येक खंड को पूर्णांक के रूप में एन्कोड किया गया है:

  • दिशा बिट्स # 0 और # 1 में संग्रहीत है
  • प्रारंभिक स्थिति बिट्स # 2 से # 8 में संग्रहीत की जाती है

उदाहरण के लिए, सेगमेंट # 3 स्थिति 55 पर शुरू होता है और 3 डी दिशा का उपयोग करता है। इसलिए, यह इनकोडिंग है (55 << 2) | 3 == 223

नीचे पूर्णांकों की परिणामी सूची है, खंड # 19 से खंड # 0:

356,340,394,373,399,378,357,383,362,196,180,234,213,239,218,197,223,202,36,20

एक बार डेल्टा-एनकोडेड, 356 से शुरू होकर, यह बन जाता है:

0,16,-54,21,-26,21,21,-26,21,166,16,-54,21,-26,21,21,-26,21,166,16

जो अंत में इनकोडिंग है:

`0${x=',16,-54,21,-26,21,21,-26,21,166'}${x},16`

उफ़ ... बीच में रिक्त स्थान भूल गए। उसको ठीक करना।
अरनुलद

5

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

def f(n):
 for r in range(9):print(*(" o"[any(n&1<<ord(c)-97for c in"trq|t|t|t|tspon|s|s|s|sml|r|q||p|o|n||m|l|r||qp||o||nm||l|r|p||q|o|m||n|l|rpkih|k|k|k|qomkjgfe|j|j|j|nljdc|i|h||g|f|e||d|c|i||hg||f||ed||c|i|g||h|f|d||e|c|igb|b|b|b|hfdba|a|a|a|eca".split("|")[r*9+c])]for c in range(9)))

स्मार्ट कुछ भी नहीं, बस हार्डकोडिंग।


नहीं "trq|t...a|eca".split("|")बन सका "tqr t...a eca".split()?
लोवजो २ Lo ’

@ बेलोवजो नोप, .split()नष्ट कर देता है ||
orlp

3

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

->n{s=[' '*17]*9*$/
20.times{|i|j=i%9
n>>19-i&1>0&&5.times{|k|s[i/9*72+(j>1?~-j/3*8+k*18:j*16)+k*(2--j%3*2)]=?O}}
s}

यह मेरे द्वारा देखे गए कुछ पैटर्न पर निर्भर करता है। सबसे पहले, पैटर्न हर 9 लाइनों को दोहराता है। दूसरे, यदि क्षैतिज रेखाओं के आरंभ बिंदुओं को उचित रूप से चुना जाता है, तो x दिशाएं दाएं, बाएं, सीधे के माध्यम से निरंतर चक्र करती हैं।

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

f=->n{
   s=[' '*17]*9*$/                    #Setup a string of 9 newline separated lines of 17 spaces.
   20.times{|i|                       #For each of the 20 bits..
     j=i%9                            #The pattern repeats every 9 bits.
     n>>19-i&1>0&&                    #If the relevant bit is set,
     5.times{|k|                      #draw each of the 5 points on the relevant line.
       s[i/9*72+                      #There are 9 lines starting on each row. Row y=0 starts at 0 in the string, row y=1 at 72, etc.
       (j>1?~-j/3*8+k*18:j*16)+       #~-j=j-1. For j=2..8, the starting x coordinates are (0,0,1,1,1,2,2)*8. For j=0 and 1 starting x coordinates are 0 and 16. 
       k*(2--j%3*2)                   #From the starting points, draw the lines right,left,straight. Down movement if applicable is given by conditional k*18 above.
       ]=?O                           #Having described the correct index to modify, overwrite it with a O character.
     }
   }
s}                                    #Return the string.


[0xE0C25, 0xC1043, 0xE4F27, 0xF1957, 
  0xD0C67, 0x95E30, 0x95622, 0xC5463, 
  0xE5975, 0xB5E75, 0xF4C75, 0xF5D75].map{|m|puts f[m],'---------'}

मेरा मानना ​​है कि 20-वर्ण स्ट्रिंग और कुछ डिकोडिंग का उपयोग करके 20 लाइनों के मापदंडों को परिभाषित करने के लिए 112 बाइट समाधान है। मैं बाद में यह कोशिश करूंगा अगर मेरे पास समय हो।


अच्छी व्याख्या!
Sygmei

2

PHP, 142 150 149 बाइट्स

for($r="";$c=ord(",(NMKJIGFHDjigfecbd`"[$i]);)if(hexdec($argv[1])>>$i++&1)for($p=96^$c&~$k=3;$k++<8;$p+=7+($c&3?:-6))$r[$p]=o;echo chunk_split($r,9);

जहाँ तक जरूरत हो, आकृति को प्रिंट करता है; यानी अगर निचला हिस्सा खाली है, तो उसे काट दिया जाएगा।
साथ चलाना php -nr '<code>' <input>। उपसर्ग इनपुट मत करो

इसे ऑनलाइन टेस्ट करें

बिना कटिंग के 11 बाइट्स जोड़ें: ,$r[80]=" "बाद में डालें $r=""

एन्कोडिंग समझाया

प्रत्येक रेखा को एक प्रारंभिक बिंदु और चार दिशाओं में से एक के साथ वर्णित किया जा सकता है।
9x9 ग्रिड पर आरेखण, प्रारंभिक स्थिति से 0,0लेकर 8,4; या, से, संयुक्त 0करने के लिए 8*9+4=76। सौभाग्य से, सभी शुरुआती बिंदु [0,4,8,36,40,44,72,76]4 से विभाज्य हैं; इसलिए दिशा कोड [0..3]को बिट्स 0 और 1 -> में स्थानांतरित नहीं किया जा सकता है।

कर्सर आंदोलन की एक आसान गणना के लिए, 0पूर्व (बिना किसी ऊर्ध्वाधर आंदोलन के साथ केवल दिशा) और [1,2,3]दक्षिण-पश्चिम, दक्षिण, दक्षिण-पूर्व के लिए लिया जाता है, जहां ऑफसेट 9(ऊर्ध्वाधर आंदोलन के लिए) प्लस [-1,0,1]-> [8,9,10]-> है delta=code?code+7:1

पहली और अंतिम लाइनों की दिशा पूर्व में होने के कारण, इसका परिणाम 0 से 76 तक के कोड में होता है [0+0,4+0,0+2,0+3,4+1,4+2,4+3,8+1,8+2,...,44+1,44+2,72+0,76+0]; और बिट वाइज xor 96 प्रत्येक मूल्य पर प्रिंट करने योग्य और अप्रमाणिक ascii कोड में परिणाम [96,100,98,99,101,102,103,105,106,68, 72,70,71,73,74,75,77,78,40,44]-> `dbcefgijDHFGIJKMN(,। कोड बिट 0 के लिए एलएसबी का उपयोग करता है, जबकि लाइन 0 एमएसबी से मेल खाती है, इसलिए स्ट्रिंग को उल्टा करना पड़ता है। Finito।

टूट - फूट

for($r="";                  // init result string, loop through line codes
    $c=ord(",(NMKJIGFHDjigfecbd`"[$i]);)
    if(hexdec($argv[1])>>$i++&1)// if bit $i is set, draw line 19-$i:
        for($p=96^$c&~$k=3          // init $k to 3, init cursor to value&~3
            ;$k++<8;                // loop 5 times
            $p+=7+($c&3?:-6)            // 2. map [0,1,2,3] to [1,8,9,10], move cursor
        )
            $r[$p]=o;                   // 1. plot
echo chunk_split($r,9);     // insert a linebreak every 9 characters, print

कुछ गोल्फ ने समझाया

  • चूंकि ^96निचले दो बिट्स पर कोई प्रभाव नहीं है, इसलिए दिशा को निकालने पर इसे अनदेखा किया जा सकता है; इसलिए किसी वैरिएबल में वैल्यू स्टोर करने की आवश्यकता नहीं है, जो कर्सर इनिट पर 5 बाइट्स बचाता है।
  • एक बाइट बचाने के ~3बजाय का उपयोग करना 124और अगले गोल्फिंग की अनुमति देता है:
  • असाइनमेंट के $k=3अंदर लूपिंग काउंटर को शुरू करने $pसे दो बाइट्स बचते हैं
    और यह पूर्व स्थिति को चोट नहीं पहुंचाता है (क्योंकि ऊपरी मूल्य में अभी भी एक अंक है)।
  • परिणाम के लिए एक स्ट्रिंग का उपयोग करना सबसे कम आरंभीकरण और प्लॉटिंग संभव है: जब किसी वर्ण को स्ट्रिंग के अंत से परे सेट किया जाता है, तो PHP अंतर्निहित रूप से लापता वर्णों को अंतरिक्ष में सेट करता है। और chunk_splitलाइनब्रेक डालने का सबसे छोटा तरीका है।
    मैं यह भी नहीं जानना चाहता कि और कितना कुछ लेना है।
  • 7+($c&3?:-6)एक बाइट से छोटा है $c&3?$c%4+7:1
  • hexdec()इनपुट प्रतिबंध को संतुष्ट करने के लिए (8 बाइट्स) जोड़ा गया ।

2

जावास्क्रिप्ट, 184 183 178 168 167 बाइट्स

f=
n=>[...`<>K[LM]NO\\^k{lm}no|~`].map((e,i)=>n>>i&1&&[0,2,4,6,8].map(i=>a[(e&102)*4+(e&17||15)*i]=`o`,e=~e.charCodeAt()),a=[...(` `.repeat(31)+`
`).repeat(9)])&&a.join``
<input oninput=o.textContent=f(+this.value)><pre id=o>

मूल रूप से 206 बाइट्स था, लेकिन @ अरनुल्ड के जवाब ने मुझे एक आयामी सरणी समाधान की जांच करने के लिए प्रेरित किया। संपादित करें: @ edc65 के लिए 1 बाइट का धन्यवाद सहेजा गया। सहेजे गए 5 15 बाइट्स @Arnauld के लिए धन्यवाद। पात्रों की पसंद को ट्विट करके एक और बाइट को बचाया।


[0,1,2,3,4]कम है
edc65

मुझे लगता है कि आप का उपयोग करके 4 बाइट्स बचा सकते हैं [67,65,52,36,51,50,34,49,48,35,33,20,4,19,18,2,17,16,3,1]और[0,2,4,6,8].map(i=>a[(e&102)*4+(e&17||15)*i]='o')
Arnauld

1
या आप उपयोग कर सकते हैं [..."ecVFUTDSREC6&54$32%#"]और [0,2,4,6,8].map(i=>a[(e&102)*4+(e&17||15)*i]='o',e=e.charCodeAt()-34)10 से अधिक बाइट को बचाने के लिए।
Arnauld

@Arnauld आपको लगता है कि आपकी बचत 1 से कम हो गई है, और मैं भी ~इसके बजाय का उपयोग करके एक अतिरिक्त बाइट को रोकने में कामयाब -34रहा (दुख की बात है कि मैं `\ _ के बेईमानी से गिरता हूं, यही वजह है कि मैं 2 बाइट नहीं बचाता)।
नील

मुझे आश्चर्य है कि अगर आप ASCII वर्ण # 220 के साथ इस '\' को बदल सकते हैं।
अरनौलद

1

बैच, 491 बाइट्स

@set n=%1
@for %%i in ("720896 524288 524288 524288 843776 262144 262144 262144 268288" "131072 65536 0 32768 16384 8192 0 4096 2048" "131072 0 98304 0 16384 0 12288 0 2048" "131072 32768 0 65536 16384 4096 0 8192 2048" "165248 1024 1024 1024 89312 512 512 512 10764" "256 128 0 64 32 16 0 8 4" "256 0 192 0 32 0 24 0 4" "256 64 0 128 32 8 0 16 4" "322 2 2 2 171 1 1 1 17")do @set s=&(for %%j in (%%~i)do @set/am=%1^&%%j&call:c)&call echo(%%s%%
:c
@if %m%==0 (set s=%s%  )else set s=%s%o 

नोट: अंतिम पंक्ति एक स्थान के साथ समाप्त होती है। ifएक forलूप के अंदर एक चर के साथ एक सशर्त डालना बैच से परे है, ताकि इसकी अपनी सबरूटीन की आवश्यकता हो। चूंकि यह कुछ भी दिखाई नहीं देता है इसलिए मैं बाहर निकलने के लिए इसमें गिर जाता हूं। ~बाहरी पाश संख्या पर पाश के लिए भीतरी पाश देने में तार unquotes। संख्या केवल उन सभी स्थानों के लिए बिटमास्क हैं, जहां पर oड्रा किया जाना चाहिए।


1

सी, 267 262 260 256 वर्ण

गिनती 1 वर्ण के रूप में बच जाती है

void f(int i){char*k="\0\x1\x2\x3\x4\x4\x5\x6\x7\x8\0\x9\x12\x1b\x24\0\xa\x14\x1e\x28\x4\xc\x14\x1c\x2d\x4\xd\x16\x1f\x28\x4\xe\x18\x22\x2c\x8\x10\x18\x20\x28\x8\x11\x1a\x23\x2c\x24\x25\x26\x27\x28\x28\x29\x2a\x2b\x2c\x24\x2d\x36\x3f\x48\x24\x2e\x38\x42\x4c\x28\x30\x38\x40\x48\x28\x31\x3a\x43\x4c\x28\x31\x3a\x43\x4c\x28\x32\x3c\x46\x50\x2c\x35\x3e\x47\x50\x48\x49\x4a\x4b\x4c\x4c\x4d\x4e\x4f\x50";for(int n=0,s,l;n<81;!(++n%9)&&putchar(10))for(s=l=0;s<20;!(++l%5||++s^20)&&putchar(32))if(i<<s&1<<19&&k[l]==n&&putchar(111))break;}

k एक लुकअप है, जिसमें 'o' डालने के लिए किस बॉक्स का जिक्र है।

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


1

Befunge, 468 बाइट्स

~:85+`!#v_86*-:9`7*-48*%\82**+
3%2:/2\<$v0%2:/2\*g02*!g03%2:/2\*!+4g07%2:/2\*g02*!-8g06%2:/2\*g02*!-4g0
g!*20g*^00>50g*\2/:2%00g8-!*40g*\2/:2%30g8-!*20g*\2/:2%60g66+-!*\2/:2%70
`\5:p00:<g^*!-8g00%2:\-10:\p07-g00:p06+g00:p05`3:p04`\5:p03:<0\p02`3:p01
#o 8`#@_^4>*50g*\2/2%00g!*40g*0\>:#<1#\+_$!1+4g,48*,\1+:8`!#^_55+,$\1+:
g03%2:/2<-^!g00%2:/2\*g01*!g03%2:/2\*g01*!g07%2:/2\*!-4g06%2:/2\*g01*!-4
70g4-!*\^>!*50g*\2/:2%00g4-!*40g*\2/:2%30g8-!*10g*\2/:2%60g8-!*10g*\2/:2%

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

पहली पंक्ति स्टड से एक स्ट्रिंग को पढ़ती है, इसे हेक्साडेसिमल संख्या के रूप में मूल्यांकन करती है। कोड के बाकी अनिवार्य रूप से ग्रिड के x / y निर्देशांक पर सिर्फ एक डबल लूप है, एक विशाल बूलियन गणना के साथ यह निर्धारित करता है कि क्या oप्रत्येक स्थान के लिए आउटपुट होना चाहिए।

मूल रूप से 20 ग्रिड बिंदुओं में से प्रत्येक के लिए एक अलग स्थिति है, उदाहरण के लिए (पहले चार):

(y==0) * (x<5) * bit0
(y==0) * (x>3) * bit1
(x==0) * (y<5) * bit2
(x==y) * (y<5) * bit3

और फिर एक बार हमने उनमें से सभी 20 की गणना की, हम या बहुत से एक साथ, और अगर यह परिणाम सच है, तो हम आउटपुट ए o , अन्यथा हम एक स्थान का उत्पादन करते हैं।

Befunge के पास बिट मैनिपुलेशन ऑपरेशंस के तरीके में कुछ भी नहीं है, इसलिए बिट्स को इनपुट से निकालने के लिए, हम बार-बार खाली कर रहे हैं n%2और फिर n/=2जैसे ही हम 20 कंडीशन कैलकुलेशन के माध्यम से अपना रास्ता बनाते हैं।

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