सबसे छोटे परफेक्ट स्क्वायर को प्रिंट आउट करें

Question

स्क्वायर को स्क्वेर करना केवल अन्य वर्गों का उपयोग करके एक वर्ग को टाइल करने की एक प्रक्रिया है। इस टाइलिंग केवल विभिन्न आकार के वर्गों का उपयोग करता है, तो यह माना जाता है सही । सबसे छोटा संभव परफेक्ट स्क्वेयर स्क्वायर 21x अलग-अलग वर्गों का उपयोग करके 112x112 वर्ग टाइल वाला है।

मैंने इस वर्ग के एससीआई कला संस्करण को नीचे बनाया है:

################################################################################################################
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ############################
#                                                ##                                 ############################
#                                                ##                                 ##      ##                 #
#                                                ##                                 ##      ##                 #
#                                                ##                                 ##      ##                 #
#                                                ##                                 ##      ##                 #
#                                                ##                                 ##      ##                 #
#                                                ##                                 ##      ##                 #
#                                                #############################################                 #
#                                                #############################################                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ###############################
#                                                ##             ##               ###############################
#                                                ##             ##               ##    ##                      #
#                                                ##             ##               ##    ##                      #
##################################################################               ##    ##                      #
##################################################################               ##    ##                      #
#                           ##                       ##       ###########################                      #
#                           ##                       ##       ###########################                      #
#                           ##                       ##       ##     ##                ##                      #
#                           ##                       ##       ##     ##                ##                      #
#                           ##                       ##       ##     ##                ##                      #
#                           ##                       ##       ##     ##                ##                      #
#                           ##                       ##       ##     ##                ##                      #
#                           ##                       ##################                ##                      #
#                           ##                       ##################                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ###########################################
#                           ##                       ##              ###########################################
#                           ##                       ##              ##                                        #
#                           ##                       ##              ##                                        #
#                           ##                       ##              ##                                        #
#                           ###########################################                                        #
#                           ###########################################                                        #
#                           ##  ##                                   ##                                        #
#                           ##  ##                                   ##                                        #
##################################                                   ##                                        #
##################################                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
################################################################################################################

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

Comments

@ ऑप्टिमाइज़र प्रश्न और विकिपीडिया के अनुसार, सभी छोटे वर्गों को पूरी तरह से अलग आकार देना होगा।

— लेवल रिवर सेंट

नाथन, क्या मेरे नियमों के अनुसार प्रस्तुत किया गया है? मैंने सभी लाइनों के लिए एक समान मोटाई का उपयोग किया।

— डेविड जूल

@DavidCarraher मेरे पास वर्ग के प्रत्येक पक्ष को रेखांकित किया गया है (इसलिए आंतरिक पक्षों में कई पाउंड संकेत हैं)। इसके अलावा, आप उपयोग करने की आवश्यकता #के बजायX

— नाथन मेरिल

नाथन, विमान में, किनारे सीमा नहीं हैं। वे एक आयामी रेखा खंड हैं। जहां दो टाइलें खत्म हो जाती हैं, हमें एक लाइन देखनी चाहिए, दो नहीं। अन्यथा, हम इस विचार को बता रहे हैं कि टाइल्स के बीच एक अंतर है।

— डेविड

@DavidCarraher जबकि यह सच है, मुझे लगता है कि यह इस तरह से एएससीआई में इसका प्रतिनिधित्व करने के लिए अधिक समझ में आता है।

— नाथन मेरिल

Answer 1

सीजेएम, 88 84 83 बाइट्स

'p:Ci_C*a*"2#   *%!"{i_S*a*{3af.|W%z}4*1$0=C#C*f{\+}..e<{_C&{oNo}|}%}/

इसका परीक्षण यहां करें।

व्याख्या

यहां मूल विचार है: एक "खाली" 112x112 वर्ग के साथ शुरू करें। अब पढ़ने के क्रम में वर्गों के माध्यम से जाएं (बाएं से दाएं, ऊपर से नीचे)। प्रत्येक वर्ग को पहले उपलब्ध स्थिति में जोड़ें। बाद में, सभी पूर्ण लाइनों को प्रिंट करें - यह सुनिश्चित करता है कि हमें केवल यह पता लगाने के लिए पहली (शेष) लाइन की जांच करने की आवश्यकता है कि अगला वर्ग कहां जाता है।

खाली ग्रिड की शुरुआत pएस से होती है, क्योंकि मुझे अंतरिक्ष से बड़े वर्ण कोड वाले चरित्र की आवश्यकता होती है #, और क्योंकि मैं 112शुरुआती ग्रिड के आकार के लिए अपने स्वयं के चरित्र कोड का पुन: उपयोग कर सकता हूं । मैंने डेनिस के कुछ ASCII कला ट्रिक का उपयोग किया छोटे से वर्ग को ग्रिड में भरने के लिए का उपयोग किया।

'p:C        e# Store the character 'p' in C.
i           e# Convert to its character code 112.
_C*a*       e# Generate a 112x112 array of p's.
"2#   *%!"  e# The 21 characters in this string correspond to the side lengths of
            e# the squares in the solution in reading order.
{           e# For each character in that string...
  i         e#   Convert to its character code (the current square's side length N).
  _S*a*     e#   Generate an NxN array of spaces.
  {         e#   Run this block 4 times. Each iteration turns the leading column into #'s
            e#   and then rotates the square by 90 degrees.
    3af.|   e#     For the first character in each row, take the bitwise OR with 3. 
            e#     This turns spaces into #'s and leaves #'s unchanged.
    W%z     e#     Reverse and transpose, which rotates by 90 degrees.
  }4*
  1$0=      e#   Copy the remaining grid and fetch the top row.
  C#        e#   Find the index of the first 'p'.
  C*        e#   Get a string of that many p's.
  f{\+}     e#   Prepend this string to each row of the small square, which gives the
            e#   square the correct horizontal position.
  ..e<      e#   Take the pairwise minimum of the square and the remaining grid. The p's
            e#   prepended to the square will leave the grid unchanged, but the spaces
            e#   and #'s in the square will overwrite the p's in the grid.
  {         e#   Map this block onto each row of the grid.
    _C&     e#     Copy the row and check if any p's are left.
    {oNo}|  e#     If NOT, the row is complete and we print it together with a newline.
            e#     This also removes the row from the grid, such that the top row for
            e#     the next iteration will have space for the next square left.
  }%
}/

Answer 2

गणितज्ञ 360 426

कोड पहले वर्गों के सही वर्ग को चित्रित करके काम करता है, छवि को रेखापुंज और बायनेरीज़ करता है, और फिर 0 को "#" और 1 से "" में परिवर्तित करता है।

आउटपुट एक तालिका में साधारण ASCII वर्णों के रूप में दिया जाता है।

f@{n_,x_,y_}:=Rectangle[{x,y},{x+n,y+n}];t=Transpose;
Flatten[i=Rasterize[Graphics[{EdgeForm[{(*Thickness[.015],*)Black}],White,
f/@ Partition[{33,0,0,29,0,33,50,0,62,37,33,0,25,29,37,42,70,0,18,70,42,24,88,42,9,54,53,7,63,53,15,50,62,17,65,60,
11,82,66,19,93,66,35,50,77,27,85,85},3]
},ImageSize->70
],RasterSize->70]//Binarize//ImageData,1]/.{0:> "#",1:> " "};
GraphicsGrid@t@Most@Most@Rest@t[Most@Most[Rest[ArrayReshape[%,Dimensions[i]]]]]

---

मैं इस प्रतिपादन को प्राथमिकता देता हूं, हटाकर प्राप्त किया गया Thickness[.015]

Comments

लाइन की मोटाई भिन्न नहीं होती है, 50x50 वर्ग के पार 48 अंतरिक्ष वर्ण होते हैं और 48 अंतरिक्ष वर्ण नीचे होते हैं, जिनकी सीमा होती है #। यह दाईं ओर और नीचे के अन्य वर्गों के मुकाबले ऊपर है, जो एक समान तरीके से खींचे जाते हैं। जहाँ दो वर्ग जो #बाहर के दौर से मिलते हैं, आपको #अंदर की पंक्तियों के लिए एक डबल मिलता है , और वर्ग वास्तव में वर्गाकार होते हैं, उनके पास समान और क्षैतिज रूप से वर्णों की समान संख्या होती है, समस्या फ़ॉन्ट है। यह उत्तर कल्पना का अनुपालन नहीं करता है, अगर यह स्वीकार किया जाता है, तो प्रश्न गैर-उद्देश्य जीत के लिए बंद हो जाएगा।

— लेवल रिवर सेंट

रेखाओं की कल्पना एक आयामी के रूप में की जाती है, द्वि-आयामी के रूप में नहीं। वे मोटाई के रूप में सीमाओं के रूप में व्याख्या नहीं की जानी चाहिए। आखिरकार, हम एक वर्ग क्षेत्र को वर्ग उप-वर्गों में विभाजित कर रहे हैं। सीमाओं को किसी भी क्षेत्र में नहीं लेना चाहिए।

— डेविड

यह थोड़े बात है। लाइनें वर्गों के बीच जाती हैं , और ओपी ने आंतरिक सीमाओं के साथ वर्गों का प्रतिनिधित्व करने के लिए चुना। यह स्पष्ट हो सकता है कि अगर उसने प्रत्येक वर्ग के लिए एक अलग प्रतीक का उपयोग करने के लिए चुना (और संभवतः उन्हें भी भर सकता है।) किसी भी मामले में, जैसा कि आप हाल के ध्वज प्रश्नों, सामान्य समझ (और कोमोलगोरोव जटिलता के पूरे बिंदु से देख सकते हैं। टैग) ओपी द्वारा आपूर्ति की गई आस्की कला प्रतिनिधित्व को ईमानदारी से पुन: पेश करना है, न कि अपनी व्याख्या करना। जबकि दिलचस्प, यह एक वैध जवाब नहीं है। कई वर्गों में अभी भी उनकी ऊँचाई और चौड़ाई में विभिन्न वर्ण हैं।

— लेवल रिवर सेंट

वॉन कर्मन सड़कों की याद दिलाता है

— बीटा डेके

Answer 3

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

नीचे दिए गए ungolfed संस्करण पर आधारित गोल्फ संस्करण। हम इस तथ्य का लाभ उठाते हैं कि आम तौर पर समान के साथ 2 या 3 वर्ग होते हैंy शीर्ष बाएं कोने के लिए समन्वय के ।

पहले मैजिक स्ट्रिंग में square sidelength+70और के लिए ASCII कोड होते हैं y increment +40। जब एक वर्ग साइडलिफ्टिंग (Ascii कोड> 67) का सामना करते हुए हम मानते हैं कि अगला वर्ग एक ही y निर्देशांक पर है, और x निर्देशांक वर्तमान x निर्देशांक बढ़ाकर प्राप्त किया जा सकता है sidelength+2। जब एन इंक्रीमेंट (Ascii कोड <67) का सामना करते हैं, तो हम y के अनुसार समन्वय करते हैं और x को दूसरी मैजिक स्ट्रिंग में एन्कोड किए गए चित्र के लिए समन्वयित करते हैं।

a=Array.new(112){?#*112}
x=y=1
j=9
'vg_CLW0SUO3J\,a]M*KV/T3n-Hi,e'.each_byte{|i|i>67?(s=i-70;(y..y+s-1).map{|i|a[i][x,s]=" "*s};x+=s+2):(x=')Fo_h){[~'[j-=1].ord-40;y+=i-40)}
puts a

मूल संस्करण

इस (पूरी तरह से ungolfed) समाधान में 315 बाइट्स होते हैं, जो अनावश्यक खाली लाइनों और इंडेंट को छोड़कर। यह बस 112 के 112 तारों की एक सरणी बनाता है, #फिर रिक्त स्थान के साथ वर्गों के अंदरूनी हिस्सों को बदल देता है।

$a=Array.new(112){"#"*112}
def f(x,y,s)
  (y..y+s-1).map{|i|$a[i][x,s]=" "*s}
end

f(1,1,48)
f(51,1,33)
f(86,1,25)

f(86,28,6)
f(94,28,17)

f(51,36,13)
f(66,36,15)
f(83,36,9)

f(83,47,4)
f(89,47,22)

f(1,51,27)
f(30,51,23)
f(55,51,7)

f(64,53,5)
f(71,53,16)

f(55,60,14)

f(71,71,40)

f(30,76,2)
f(34,76,35)

f(1,80,31)

puts $a

Answer 4

सी, 198 बाइट्स

char*i="bSK8C?A;6HMI927B@Z4UQ",o[112][113],x,y,p,q,n;main(){for(;y<112;puts(o[y]),y++)for(x=-1;++x<112;)if(!o[y][x]){n=*i++-48;for(p=-1;++p<n;)for(q=-1;++q<n;)o[q+y][p+x]=p&&n-1-p&&q&&n-1-q?32:35;}}

(Ungolfed)

char *i="bSK8C?A;6HMI927B@Z4UQ", o[112][113], x, y, p, q, n;
main() {
  for ( ; y<112; puts(o[y]),y++) {
    for (x=-1; ++x<112; ) {
      if (!o[y][x]) {
        n = *i++ - 48;
        for (p=-1; ++p<n; ) {
          for(q=-1; ++q<n; ) {
            o[q+y][p+x] = (p && n-1-p && q && n-1-q) ? ' ' : '#';
          }
        }
      }
    }
  }
}

यह सब करता है 112 × 112 बाइट्स की एक सरणी के माध्यम से स्कैन किया जाता है (शून्य से आरंभिक)। जब भी यह एक शून्य बाइट का सामना करता है, यह सरणी से एक मूल्य प्राप्त करता है iऔर संबंधित आकार का एक बॉक्स जोड़ता है। प्रत्येक पंक्ति में अतिरिक्त बाइट एक स्ट्रिंग टर्मिनेटर के रूप में कार्य करता है, इसलिए हम उपयोग puts()करने के बजाय संपूर्ण लाइनों को आउटपुट करने के लिए उपयोग कर सकते हैंputchar() व्यक्तिगत रूप से आउटपुट वर्णों करने के ।

यह शायद थोड़ा अधिक गोल्फ हो सकता है, लेकिन मुझे नहीं लगता कि यह स्टीवेवर्रिल के जवाब को हरा देने की अधिक संभावना है ।

(आइडोन लिंक)

Comments

+1 यह एक उत्कृष्ट अवधारणा है, कम गोल्फ की भाषा में, खदान से बेहतर है। मुझे विश्वास है कि यह मेरे उत्तर को हरा सकता है। ध्यान दें कि आपको एक प्रिंट करने की आवश्यकता है #जब !(p%(n-1)&&q%(n-1))मैं forचार से दो छोरों की संख्या को कम करने पर ध्यान केंद्रित करूंगा , उपयोग x=i%113और y = i/113 etc।

— लेवल रिवर सेंट

Answer 5

आर, 293 291 287 282 बाइट्स

a=array('#',112:113)
a[,113]='
'
for(g in list(c(0,0,49,34,26),c(27,85,7,18),c(35,50,14,16,10),c(46,82,5,23),c(50,0,28,24,8,1),c(52,63,6,17),c(59,54,15),c(70,70,41),c(75,29,3,36),c(79,0,32))){y=g[1];x=g[2]
for(b in g[0:1-2]){a[(y+2):(y+b),(x+2):(x+b)]=' '
x=x+b+1}}
cat(t(a),sep='')

मैंने ऐसा करने के बाद, मुझे एहसास हुआ कि मैंने @steveverrill के रूप में लगभग समान प्रक्रिया की थी। '#' की एक सरणी और वर्ग अंदरूनी रिक्त करें। शायद इसमें से कुछ और निचोड़ सकते हैं। तीसरी पंक्ति के लिए गाड़ी वापसी महत्वपूर्ण है। कुछ के लिए एलेक्सा को धन्यवाद।

Comments

आप केवल sएक बार संदर्भ देते हैं , इसलिए आप पहले से अलग for(g in list(...))से निर्दिष्ट करने के बजाय ऐसा नहीं कर सकते हैं s? मुझे लगता है कि इससे आपको 2-3 बाइट्स बचेंगे।

— एलेक्स ए।

@AlexA। धन्यवाद, एक स्पष्ट है कि मैं पूरी तरह से याद किया

— मिकट

Answer 6

एमएस-डॉस बाइनरी, 137

यदि आप इसे sq.com नामक फाइल में लिखते हैं, तो निम्नलिखित कोड एमएस-डॉस में चलेगा, इसके लिए कोई और संकलन की आवश्यकता नहीं है (लेकिन चूंकि यह हेक्स में दिया गया है, इसलिए आपको पहले इसे "अनशेक" करने की आवश्यकता है):

fcba8f01b82370e83000bd1400bb4d018b1743438a27b02043e81e004d75
f1b97000ba8f3289d7b00daab00aaab82409aa83ea70cd214975ecc331c9
88e189ce89d788e1f3aa83c2704e75f4c3201d30e223218527190524063d
1f11521d0d811c0f321f09921c04b8141670101b4d12176619076f1905a6
141066120e4602288d100221022300021f

अधिकांश टर्मिनलों में आउटपुट अप्राप्य होगा, लेकिन आप इसे किसी फ़ाइल ( square.com > output.txt) में रीडायरेक्ट कर सकते हैं और इसे टेक्स्ट एडिटर में देख सकते हैं। यदि आप कुछ अधिक पठनीय चाहते हैं, तो निम्नलिखित कोड एक कार्यशील वर्ग का उत्पादन करेगा। अगर debug.exe ( debug.exe < square.asm) में खिलाया गया है :

a
cld
mov dx,18f
mov ax,7023
call 13a
mov bp,14
mov bx,14d
mov dx,[bx]
inc bx
inc bx
mov ah,[bx]
mov al,20
inc bx
call 13a
dec bp
jnz 110
mov cx,70
mov dx,328f
mov di,dx
mov al,d
stosb
mov al,a
stosb
mov ax,924
stosb
sub dx,70
int 21
dec cx
jnz 125
ret
xor cx,cx
mov cl,ah
mov si,cx
mov di,dx
mov cl,ah
rep stosb
add dx,70
dec si
jnz 140
ret
db 20,1d,30,e2,23,21
db 85,27,19,05,24,6
db 3d,1f,11,52,1d,d
db 81,1c,f,32,1f,9
db 92,1c,4,b8,14,16
db 70,10,1b,4d,12,17
db 66,19,7,6f,19,5
db a6,14,10,66,12,e
db 46,02,28,8d,10,2
db 21,02,23,00,02,1f

n square.com
rcx
89
w
q

Answer 7

मतलाब / ऑक्टेव, 258

हमेशा की तरह, मैट्रिसेस। मैंने पंक्ति और प्रत्येक वर्ग ans के स्तंभ सूचक को आकार के अनुसार हार्डकोड किया। मैं इनमें से एक बड़ा 'रिक्त' वर्ग भरने के लिए उपयोग कर सकता हूं #।

r=[2,2,2,29,29,37,37,37,48,48,52,52,52,54,54,61,72,77,77,81];
c=[2,52,87,87,95,52,67,84,84,90,2,31,56,65,72,56,72,31,35,2];
s=[47,32,24,5,16,12,14,8,3,21,26,22,6,4,15,13,39,1,34,30];
z=ones(112)*35;
for i=1:20;
    z(r(i)+(0:s(i)),c(i)+(0:s(i)))=32;
end;disp([z,''])

Answer 8

बैश, 252

हर कोडग्राफर को एक सामान्य उद्देश्य संपीड़न एल्गोरिदम को हरा देने में सक्षम होना चाहिए:

base64 -d<<<H4sIADyFv1UCA+3ZOw6EMAwFwH5PgeT735EOUSyfQAgOmVeCxUgusAkRbfOLqTARd0qAQCAQCAQCgcAvg80375dW/T+lQGAbsCCdgvsdXl0AAoHjgM8e7mUA92bKG+DtpAevDPflRsko7BXcKAQCD9+X3wOPCoFA4ABgnZ/OmcHTS+bw4PXzkV7Ak93KDdboVm6wxrOAQCAQCAQCgUAgENj++7BuZsq8xQ1vMQAA|gunzip

छोटे इनपुट (मूर्खतापूर्ण तरीके से संपीड़न के gzipबजाय मुझे इस्तेमाल किया गया gzip -9) का उपयोग करने के लिए टिंट स्पाइट के लिए धन्यवाद और यहां एक स्ट्रिंग।

Comments

यहाँ 2-स्ट्रिंग के साथ छोटा:base64 -d<<<H4sIAP9YuVUAA+3XQQrDIBAF0H1PUfD+d+yq0FA7GirGie/vdEZfkCy0lLl5lOfJlPaKoAUIBAKBQCAQCLwzOP3mfdFVv9IKBM4BTyQpGA0PE0AgcB8wzC3A6vS7egH4d5YH64WPtVGh/zvygj8agcCvQuufzA+2GoFA4AZgd9KCwS7Hzu3B7qQFO09rbXDEaa0NjtgLCAQCgUAgEAgEAoHz34dj8wLKvMUNbzEAAA==|gunzip

— टोबी स्पाइट

और एक छोटा इनपुट हमें 251 पर ले जाता है :base64 -d<<<H4sIADyFv1UCA+3ZOw6EMAwFwH5PgeT735EOUSyfQAgOmVeCxUgusAkRbfOLqTARd0qAQCAQCAQCgcAvg80375dW/T+lQGAbsCCdgvsdXl0AAoHjgM8e7mUA92bKG+DtpAevDPflRsko7BXcKAQCD9+X3wOPCoFA4ABgnZ/OmcHTS+bw4PXzkV7Ak93KDdboVm6wxrOAQCAQCAQCgUAgENj++7BuZsq8xQ1vMQAA|gunzip

— Toby Speight

क्या आप सुनिश्चित हैं कि काम करता है? मुझे ही मिलता है gunzip: command not found। मैं इसे एक सबशेल का उपयोग करके काम कर सकता हूं: (base64 -d|gunzip)<<<...लेकिन यह अभी भी 258 बाइट्स का उपयोग करता है।

— user2845840

अजीब, @ user284584 - अपने रास्ते के साथ कुछ अजीब है? मैंने परीक्षण किया कि मैंने क्या लिखा (एक संवादात्मक शेल में, अगर इससे कोई फर्क पड़ता है)

— टोबी स्पाईट

हे भगवान ... अपनी टिप्पणी की प्रतिलिपि बनाने और इसे शेल में वापस चिपकाने की कोशिश करें। Stackexchange "helpfully" में 6 अदृश्य अक्षर डाले, 3 प्रत्येक u + 200c & u + 200b। उन्हें हटाने के बाद, यह काम करता है।

— user2845840