अपने कोड का एक नकारात्मक प्रिंट करें

Question

निम्नलिखित लंबाई की तरह N के लिए , मुद्रण योग्य ASCII वर्णों के एक वर्ग पर विचार करें (कोड अंक 0x20 से 0x7E) निम्नलिखित (यहाँ, N = 6 ):

=\    
 g \  
7     
m+y "g
  L ~ 
e> PHq

हमें प्रत्येक पंक्ति और प्रत्येक कॉलम में कम से कम 1 स्थान और 1 गैर-स्थान वर्ण होना चाहिए। (उपरोक्त उदाहरण इसको संतुष्ट करता है।)

हम इस तरह के एक वर्ग के नकारात्मक को परिभाषित करते हैं , एक ही आकार के एक वर्ग के लिए, जहां प्रत्येक स्थान को एक गैर-स्थान से बदल दिया जाता है और इसके विपरीत। उदाहरण के लिए, निम्नलिखित उपरोक्त उदाहरण का एक वैध नकारात्मक होगा:

  1234
a b cd  
 ZYXWV
   !  
{} [ ] 
  ?   

गैर-अंतरिक्ष वर्णों की पसंद अप्रासंगिक है (जब तक वे मुद्रण योग्य ASCII रेंज से हैं)।

चुनौती

आप एक प्रोग्राम लिख सकते हैं, जिसमें वर्टिकल सोर्स कोड साइड साइड N> 1 के साथ होता है , जो खुद को STDOUT में निगेटिव प्रिंट करता है। ट्रेलिंग स्पेस को प्रिंट करना होगा। आप एक एकल अनुगामी न्यूलाइन प्रिंट कर सकते हैं या नहीं।

सामान्य नियम नियम भी लागू होते हैं, इसलिए आपको अपने स्वयं के स्रोत कोड को प्रत्यक्ष या अप्रत्यक्ष रूप से नहीं पढ़ना चाहिए। इसी तरह, आपको एक आरईपीएल वातावरण नहीं मानना ​​चाहिए, जो प्रत्येक दर्ज की गई अभिव्यक्ति के मूल्य को स्वचालित रूप से प्रिंट करता है।

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

Comments

क्या किसी फ़ंक्शन का रिटर्न मान स्वीकार किया जाता है या उसे STDOUT में मुद्रित किया जाना चाहिए?

— पॉल गुयोट

@PaulGuyot इस चुनौती के लिए, कृपया पूर्ण कार्यक्रमों और STDOUT (जैसा कि यह शिथिल रूप से बोलना, एक क्वीन संस्करण) से चिपके रहें।

— मार्टिन एंडर

आपको स्पष्ट करना चाहिए कि बोर्ड का आकार N> 0 होना चाहिए । मैं देखता हूं कि आपका उदाहरण N> 1 निर्दिष्ट करता है (और क्या आपका मतलब N> = 1 है ?), लेकिन यह नियमों में उचित नहीं है।

— imallett

@imallett द्वारा निहित "हमें कम से कम 1 स्थान और 1 गैर-अंतरिक्ष वर्ण शामिल करने के लिए प्रत्येक पंक्ति और प्रत्येक स्तंभ की आवश्यकता है"। रुको। यह नहीं है। अच्छी बात। हालांकि यह N == 0 || N> 1 का अर्थ है।

— जॉन ड्वोरक

@jpcooper हाँ, यह एक वर्ग है, लेकिन यह संतुष्ट नहीं करता है "हमें प्रत्येक पंक्ति और प्रत्येक स्तंभ में कम से कम 1 स्थान और 1 गैर-स्थान वर्ण शामिल करने की आवश्यकता है।" क्योंकि पहले m कॉलम में स्थान नहीं हैं, और अंतिम n कॉलम में गैर-स्थान नहीं हैं।

— मार्टिन एंडर

Answer 1

CJam, 4 x 4 (8 गैर-स्थान)

 L _
{ _ 
 _ }
_ p 

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

उत्पादन

{ _ 
 _ }
{ _ 
 _ }

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

• Lएक खाली सरणी को _धक्का देता है और इसकी एक प्रति को धक्का देता है।

• खंड

  { _ 
   _ }
  

  स्टैक पर उस ब्लॉक को धकेलता है।

• _कोड ब्लॉक की एक प्रति को धक्का देता है और pइसे प्रिंट करता है, उसके बाद एक लाइनफीड।

• अंत में, दुभाषिया स्टैक पर शेष सभी वस्तुओं को प्रिंट करता है: दो खाली सरणियाँ जो आउटपुट को प्रभावित नहीं करती हैं, और मूल कोड ब्लॉक।

वैकल्पिक संस्करण

 L ~
{ _ 
 p }
_ ~ 

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

उत्पादन

{ _ 
 p }
{ _ 
 p }

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

• Lएक खाली सरणी को धकेलता है और उसे ~डुबो देता है। स्टैक फिर से खाली है।

• खंड

  { _ 
   p }
  

  स्टैक पर उस ब्लॉक को धकेलता है।

• _ब्लॉक की एक प्रति को धक्का ~देता है और प्रतिलिपि निष्पादित करता है।

  _ब्लॉक की प्रति के अंदर मूल ब्लॉक है, जो की एक प्रति धक्का होगा pप्रिंट होगा, एक linefeed द्वारा पीछा किया।

• अंत में, दुभाषिया स्टैक पर शेष आइटम को प्रिंट करता है: मूल कोड ब्लॉक।

Answer 2

पर्ल, 7 × 7 (42 गैर-स्थान)

for$i( 
1..56 )
{$_= $i
%8? $i%
7? $":7
: $/;1;
 print}

आउटपुट:

      7
     7 
    7  
   7   
  7    
 7     
7      

Comments

यह कोड के सबसे अच्छे टुकड़ों में से एक है जिसे मैंने लंबे समय में देखा है।

— कासरन

सीधा और सरल, लेकिन काफी उबाऊ। अभी भी +1।

— नोवा

यह एक और अधिक शांत होगा अगर यह एक 7बना बनाया प्रदर्शित करता है 7। :)

— AL

@ केवल 8 और पात्रों (7 रिक्त स्थान और एक नई पंक्ति) की आवश्यकता है।

— Qix 7

Answer 3

CJam, 4X4 ( 12 10 गैर-स्थान)

 6, 
SS +
* 4/
 N* 

आउटपुट:

0  1
  2 
 3  
4  5

---

12 गैर-रिक्त स्थान वाला पिछला संस्करण:

 4a4
* 4S
** 4
/N* 

और आउटपुट है

4   
 4  
  4 
   4

जैसा कि मार्टिन ने बताया, इस संस्करण में है

• 4 रिक्त स्थान,
• 4 * ,
• 4 4 ,
• 4 अन्य वर्ण, और
• 4 4 आउटपुट के रूप में

;)

इसे यहाँ ऑनलाइन आज़माएँ

Comments

इसमें 4 अपवोट भी हैं, लेकिन मैं इसे आपके लिए खराब करने वाला हूं। माफ़ करना! :-D

— स्क्विश ossifrage

शायद हम इसे ४४ पर ला सकते हैं? +1 :)

— डोरकनब

4 ^ 4 तक चलने की गति रखें

— ऑप्टिमाइज़र

4 ^ 4 == 0 नहीं है? ;)

— ज़ेनहॉय

हां, मुझे यह तथ्य पसंद नहीं है कि बिटवाइजर एक्सओआर ने उन प्रतीकों को चुरा लिया है जिनका इस्तेमाल एक्सपोर्टरों के लिए किया जाना चाहिए था। ईमानदारी से कोड की पठनीयता को बढ़ाता है।

— SuperJedi224

Answer 4

मारबेलस - 16x16

....@0..@1....  
@3..0A08..@2  ..
/\--....>1  ..Hp
..@2..\\  =0@3..
ss..//  --\\\\..
@0/\  @1/\Hp..!!
:s  #the-cake-is
  2020#a-pie/lie

इसे यहाँ टेस्ट करें! रिक्त स्थान, बेलनाकार बोर्ड, और पुस्तकालयों को शामिल किया जाना चाहिए।

उत्पादन

              07
            06  
          05    
        04      
      03        
    02          
  01            
01              

व्याख्या

यहां दो बोर्ड हैं: मुख्य बोर्ड (नीचे दिखाया गया है), और ssबोर्ड, जो कोई इनपुट नहीं लेता है और दो रिक्त स्थान (0x20) को STDOUT में आउटपुट करता है।

एक रिक्त सेल एक के बराबर है .., और #एक टिप्पणी के बाद कुछ भी है।

हर टिक, ssSTDOUT को दो रिक्त स्थान देता है।

हरे रंग का मार्ग एक सरल लूप है जो हर 7 वें टिक के अंत में एक नई पंक्ति (0x0A) को आउटपुट करता है।

नीले रंग का रास्ता आउटपुट को Hpउपस्थित करेगा (आउटपुट में संगमरमर को दो हेक्स अंकों के रूप में प्रिंट करता है) जो हर 6 वें टिक के अंत में आउटपुट में मौजूद है।

हमारे द्वारा 01एक बार छपने के बाद, लूप समाप्त हो जाता है, और लाल पथ नीचे चला जाता है, जो इस संगमरमर की नकल करता है।

एक डुप्लिकेट मुद्रित होता है (दूसरा 01), और दूसरे को काले रास्ते से नीचे भेजा जाता है, जो !!सेल में बोर्ड को समाप्त करता है । Hpइस अंतिम प्रिंट में उपयोग किए जाने के स्थान के कारण , एक ही टिक के दो स्थानों से पहले01 दिखाई देता है , इसके बजाय हर दूसरे कॉल का व्यवहार ।Hp

Comments

स्रोत के चित्रमय प्रतिनिधित्व के लिए Upvoting।

— रेकिंग

Answer 5

अजगर - 11x11

import re
[print(
    re.sub(
"0",   " ",
bin(x)[
2:].zfill(
11)))for x
in[19,15,
1920,116,
15,1,5,3,
3,3, 67]]

उत्पादन

      1  11
       1111
1111       
    111 1  
       1111
          1
        1 1
         11
         11
         11
    1    11

यह एक बहुत ही गन्दा और उबाऊ समाधान है, लेकिन मैंने सोचा था कि मैं इसे दिखाऊंगा ...

1. यह पायथन में किया जा सकता है
2. यदि आप अपने कोड से कम अपने कोड के बारे में जानकारी संपीड़ित कर सकते हैं, तो आप कुछ इस तरह से खींच सकते हैं :)

यह समाधान इस तथ्य का लाभ उठाता है कि, यदि आप पायथन में कोष्ठक की एक जोड़ी के भीतर हैं, तो आप अपने कोड को कई पंक्तियों में विभाजित कर सकते हैं और मनमाने ढंग से रिक्त स्थान जोड़ सकते हैं IndentationError। ऐसा कुछ करने का एक और तरीका है बैकस्लैश के साथ लाइन को समाप्त करना।

Answer 6

पायथन - 7x7 (37 गैर-स्थान)

print( 
'%+7s' 
'\n'%1 
*6+'%' 
'-7s'% 
111111 
      )

उत्पादन

      1
      1
      1
      1
      1
      1
111111 

अजगर के पुराने का उपयोग करता है %: काम करने के लिए स्ट्रिंग स्वरूपण ऑपरेटर +7और -7आखिरी स्थान के लिए समापन कोष्ठक मैच के लिए दाएँ / बाएँ औचित्य की देखभाल, और ले printविशेष रूप से। प्रारूप स्ट्रिंग तैयार करने में, हमारे पास भी है

• लाइनों के पार स्ट्रिंग शाब्दिक का स्वत: संयोजन, और
• गुणन द्वारा स्ट्रिंग पुनरावृत्ति (हमें एक की कीमत के लिए कई प्रतिस्थापन फ़ील्ड प्रदान करता है)

Answer 7

जावास्क्रिप्ट (9x9)

 i=9;q=""
; for(;++
i< 91;){;
var q=q+(
!(i% 10.0
)?1:" ");
;i%9|| (q
+="\n") }
alert(q) 

उत्पादन

1        
 1       
  1      
   1     
    1    
     1   
      1  
       1 
        1

टिप्पणियाँ

मैंने किसी भी आकार n के विकर्ण के साथ एक वर्ग के लिए (मेरी क्षमता के सर्वश्रेष्ठ) कोड को बनाया और गढ़ा:

q="";for(i=***n***;++i<***n^2+n+1***;i%***n***||(q+="\n"))q+=i%***n+1***?"0":1

साइड की लंबाई के आधार पर स्थिरांक के साथ *** asdf *** नंबर की जगह, उदाहरण के लिए n = 6 के लिए:

q="";for(i=6;++i<43;i%6||(q+="\n"))q+=i%7?" ":1

लेकिन, उस कोड की लंबाई 46 होने के बावजूद, मैं कोड के विकर्ण में एक स्थान के साथ लाइन अप करने के लिए निरंतर स्थान प्राप्त नहीं कर सका, जब तक कि यह 9x9 जितना बड़ा नहीं था, एक व्यर्थ लाइन (5 वें एक) के साथ

संपादित करें: अलर्ट जोड़ने के लिए परिवर्तित ()। इससे पहले:

 i=9;q=""
; while((
++ i)<91)
{q= q+""+
""+( "")+
(!((i %10
))?1:" ")
;i%9||( q
+="\n")} 

Comments

आह, हाँ, उफ़, मैं देख रहा हूँ कि तुम क्या मतलब है। मैं इसे अभी ठीक कर रहा हूँ, क्षमा करें।

— कुइलिन ली

आपको वहां पर कुछ यूनिटलाइज्ड ग्लोबल वैरिएबल मिल गए हैं: P

— Tomáš Zato

Answer 8

सीजेएम, 5x5, 12 गैर-रिक्त स्थान

विजेता नहीं, लेकिन मैं एक छोटा और विरल सबमिशन जोड़ना चाहता था , क्योंकि ज्यादातर जवाब सिर्फ एक विकर्ण को प्रिंट करते हैं।

 1 ]
D * S
 * 5
/ N *
 1 ; 

प्रिंट

1 1 1
 1 1 
1 1 1
 1 1 
1 1 1

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

कोड के अंतिम दो अक्षर, कुछ भी नहीं करते हैं, इसलिए इसमें वास्तव में केवल 10 बाइट्स हैं असली कोड। एक छोटे से ग्रिड के लिए, मैं इसे एक और दो बाइट्स से 8 तक कम कर सकता था, लेकिन यह 3x3 पर फिट नहीं होता है, और यह कोड ग्रिड आकारों के लिए भी काम नहीं करता है।

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

1]           "Push [1].";
  D*         "Repeat 13 times.";
    S*       "Riffle with spaces.";
      5/     "Split into runs of five elements.";
        N*   "Join those with line breaks.";
          1; "Push and pop a 1. No-op.";

Comments

विस्फोटित सीजेम और पायथ के उत्तर साइट पर अब तक मेरी पसंदीदा चीज़ है। एक उत्थान है, रेडिट-स्टाइल।

— सोहम चौधरी 18

Answer 9

बेफुज , 9x9

मुझे नहीं पता कि मैंने ऐसा क्यों किया। यह ले लिया जिस तरह से बहुत लंबा है। मुझे अब भारी सिरदर्द है।

8>v_20gv 
v9<^v#<4 
1@,/<>^6 
v1,*$:<p 
->,!-^87 
:^*25<^g 
_88g,^^4 
9vp\v#6< 
        @

आउटपुट:

        @
        @
        @
        @
        @
        @
        @
        @
$$$$$$$$ 

कुछ स्पष्टीकरण

कोड ग्रिड से पात्रों को "मक्खी पर" (और अंतिम स्थान, जो है ) gको पढ़ने के लिए और अंतिम आउटपुट लाइन लिखने के लिए लूप को संशोधित करने के लिए उपयोग करता है।@@ / 2p

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

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

मैंने स्टैक पर कुछ रचनात्मक काम भी किया:

• जब (आंतरिक) वर्ण लेखन लूप समाप्त हो जाता है (इस पंक्ति के लिए किए गए सभी स्थान), स्टैक है n,0। मुझे तो घटाना है n। स्पष्ट समाधान होगा $1-, लेकिन मैं इसका उपयोग करके इसे छोटा करने में कामयाब रहा !-।
• जब बाहरी (बाहरी) लाइन लेखन लूप समाप्त हो जाता है (सभी सामान्य लाइनें मुद्रित होती हैं), तो स्टैक में ए 0। मैंने तब कोड परिवर्तक ( 20g46p7g46\p) का उपयोग किया था 0, जिसका उपयोग करने के बजाय, 2 वर्णों को बर्बाद करने के लिए $0।

Comments

Befunge को हमेशा मुझसे +1 मिलता है। के साथ अच्छा लगा !-; मैं कुछ करूँगा। मजेदार तथ्य: फंज -98 में, zएक एनओपी है।

— कासरन

@ कासरन हाँ। zविकि पर सूचीबद्ध नहीं किया गया था और मैं प्रयोग किया जाता है इस कोडिंग के लिए, जिसका अर्थ यह किसी भी गैर-आदेश आईपी दिशा फ़्लिप। बहुत ज्यादा एक जगह की वजह से 70% कोड को रिफ्लेक्टर करना पड़ा जो कि NOP होना चाहिए।

— पुरकाकूदरी

ठीक है, ऐसा करने का लाभ यह है कि आपका कोड Befunge-95 (जो मुझे नहीं लगता कि एक गैर-स्थान NOP है) के साथ-साथ 98 में चलेगा; चूंकि यह 95 का उपयोग करने के लिए बहुत कठिन है, मैंने हमेशा उन उत्तरों को अतिरिक्त प्रभावशाली पाया है।

— कासरन

Answer 10

पायथन 3, 8x8

50 गैर-अंतरिक्ष वर्ण और 14 स्थान हैं। अंतिम पंक्ति में एक बेकार चरित्र है, लेकिन बाकी सब कुछ आवश्यक है।

(*_,q,n 
)=p=''' 
       p
'''[2:] 
print(p 
*2+q*7, 
n+p*4+p 
[0:-1]) 

आउटपुट:

       p
       p
ppppppp 
       p
       p
       p
       p
       p

Comments

बस के साथ खेलने की कोशिश की (a,*b,c)="12345"... तारांकित असाइनमेंट दिलचस्प है :)

— Sp3000

@ sp3000 तरह के हैस्केल-एस्क। मैं हेकेल की तुलना में अजगर के तरीके का उपयोग करता हूं, मुझे यह कैसे पता नहीं था

— अंडरग्राउंडोरेल

Answer 11

रूबी, 8x8

 (0...8)
. map(){
|x |$><<
32. chr*
x+[x ]*'
'<<32 .\
chr*(7 -
x)+?\n} 

आउटपुट:

0       
 1      
  2     
   3    
    4   
     5  
      6 
       7

Answer 12

सीजेएम, 5 एक्स 5

SSSS 
1N]4 
*B11 
    S

और आउटपुट है

    1
    1
    1
    1
1111 

मैं 4X4 समाधान के करीब था। <sigh>मेरा दूसरा जवाब देखिए

इसे यहाँ ऑनलाइन आज़माएँ

Answer 13

सी ++, 12x12

संपादित करें: इसलिए, मैं इस चुनौती से थोड़ा रोमांचित हो गया और इसे 17x17 से 12x12 तक नीचे लाने में कामयाब रहा। मुझे यह महसूस करने में थोड़ा समय लगा कि मैं /**/एक टोकन सीमांकक के रूप में उपयोग कर सकता हूं । यह कोड इस तथ्य का लाभ उठाता है कि क्लैंग में एक लाइन स्प्लिस अभी भी उसके बाद एक स्थान के साथ काम करता है, हालांकि यह चेतावनी देता है और कोड के एक्सकोड के रंगीकरण को बर्बाद कर देता है।

#include<c\ 
stdio>/***/ 
int/**/mai\ 
n(){for(in\ 
t/**/i=0;i\ 
<12;++i)pr\ 
intf(i^8?"\ 
           \
|\n":"~~~~\ 
~~~~~~~\x2\ 
0\n");}/**/ 

आउटपुट:

           |
           |
           |
           |
           |
           |
           |
           |
~~~~~~~~~~~ 
           |
           |
           |

Answer 14

बेगुंजे -98 , 8x8 (56 गैर-रिक्त स्थान [11 नोड्स))

नोट: अच्छे खेल-व्यक्ति-जहाज के हित में, यह अपने स्वयं के स्रोत के माध्यम से पढ़ता है ', जिससे यह कुछ लोगों को धोखा देता है। बहस यहाँ पढ़ें ।

कार्यक्रम

 07'?>:8v
v y+da:%<
<v ':vj!-
,+# '<zzv
v1#a vj!<
>z,\1 -\v
z>+,$v z<
1_@#:<v -
zzzzzv<z 

उत्पादन

(       
 ,      
  &     
   %    
    $   
     #  
      " 
       !

व्याख्या

बिना गोल्फ वाला संस्करण

07'?>:8%:ad+y-!jv>'n,$v
  !jv   a,\1-\v > 's,  
    >         >       v
    v-1_@#:           <

(गैर-स्थान और स्थान को पठनीयता के लिए 'n और s' से बदल दिया जाता है।)

यह समाधान इस तथ्य पर आधारित है कि एक सूचकांक [0, चौड़ाई ^ 2) का उपयोग करके मॉड की चौड़ाई बता सकती है कि आप पंक्ति के अंत में हैं या विकर्ण पर। चूंकि सभी रिक्त स्थान विकर्ण के साथ रखे जाते हैं, इसलिए यह बताना आसान है कि गैर-स्थान को कब प्रिंट करना है!

स्यूडोकोड में

const int WIDTH = 8
push 0    //Because of the way the 'y' instruction works when picking
int row=7 //8-1 rows
int i=63  //Starting at the end allows for the cheaper i != 0
do
{
    pick variable row from the stack bottom + 1//ad+y
    if(i%WIDTH == row)
    {
        print non-space
    }
    else
    {
        print space
        if(i%WIDTH == 0)
        {
            print new-line
            --row
        }
    }
  --i
}
while(i != 0);

विचार-विमर्श

मुझे इस पर बहुत गर्व है, हालांकि मैं चाहता हूं कि मैं हर गैर-स्थान को भी गैर-शून्य बना सकता था। मुझे गर्व है कि मैंने मानक Befunge get-increment-put trope का उपयोग नहीं किया! यह गैर-स्थान के लिए विभिन्न प्रतीकों को प्रिंट करता है क्योंकि मेरे पास इसके लिए जगह थी और उबाऊ नहीं होना चाहता था।

BefungeSharp के साथ विंडोज पर इसे आज़माएं !

Answer 15

CJam, 4 x 4 (8 गैर-स्थान)

 N a
` S 
 * N
X $ 

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

उत्पादन

[ " 
 " ]
[ " 
 " ]

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

• Nएक सिंगलटन स्ट्रिंग के रूप में एक लाइनफीड को धक्का देता है। aउस स्ट्रिंग को एक सरणी में लपेटता है।

• ` परिणाम का निरीक्षण करता है, अर्थात, यह सरणी का एक स्ट्रिंग प्रतिनिधित्व करता है।

  यह परिणाम है:

  ["
  "]
  

• S*रिक्तियों के उपयोग से इसके तत्वों को अलग करते हुए, परिणामी स्ट्रिंग (वर्णों की सरणी) को जोड़ता है। दूसरे शब्दों में, यह स्ट्रिंग के आसन्न पात्रों के सभी जोड़े के बीच एक अंतरिक्ष चरित्र डालता है।

  यह परिणाम है:

  [ " 
   " ]
  

• N एक और लाइनफीड को धक्का देता है।

• X$ अनुक्रमणिका 1 पर स्टैक आइटम की प्रतिलिपि बनाता है (ऊपर से गिनती), यानी, बहु-पंक्ति स्ट्रिंग।

• अंत में, दुभाषिया स्टैक पर सभी वस्तुओं को प्रिंट करता है: मूल मल्टी-लाइन स्ट्रिंग, लाइनफीड और मल्टी-लाइन स्ट्रिंग की प्रतिलिपि।

Answer 16

SOGL V0.12 , 2x2 (2 गैर-स्थान)

2 
 ╚

यह कोशिश करो!

उत्पादन

 /
/ 

व्याख्या

एसओजीएल में अंतिम को छोड़कर सभी लाइनें लाइनों की जगह ले रही हैं - यह जारी कोड में हर जगह बदल देता है लाइन के अंतिम चरित्र को इसके पहले सब कुछ के साथ। तो पहली पंक्ति यहाँ है replace space with 2 in the next line।
फिर अगली पंक्ति - 2╚निष्पादित हो जाती है: 22 धक्का देती है, और ╚आकार 2 का विकर्ण बनाता है।

Answer 17

सीबीएम बेसिक v2.0 (8 × 8)

मेरे पिछले उत्तर पर सुधार , पूरी तरह से अलग दृष्टिकोण का उपयोग करते हुए:

1s=56/8 
2?sP7); 
3?"?":: 
4s=s-+1 
5ifsgO2 
6?-8^6; 
7?sP1): 
       8

आउटपुट:

       ?
       ?
       ?
       ?
       ?
       ?
       ?
-262144 

Answer 18

रूबी, 8x8 7x7

 print(
 (?f+"\
 "*6+?\
 )*6).!
 $><<"\
 f"<<!1
;      

आउटपुट:

f      
f      
f      
f      
f      
f      
 ffalse

पिछला संस्करण, 20 स्थानों के साथ 8x8:

  puts((
  "ff"+#
  ?\s*6+
  ?\n)*7
  );$><<
  ?\s*2+
  ?f;p:p
.!

आउटपुट:

ff     
ff     
ff     
ff     
ff     
ff
ff     
  ffalse

Answer 19

पुष्य , 4x4 वर्ग

भाषा को चुनौती देने के रूप में गैर-प्रतिस्पर्धा:

कोड:

 H32
2 C4
:" } 
\o/

आउटपुट:

d   
 d  
  d 
   d

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

क्योंकि व्हाट्सएप पुष्य में अप्रासंगिक है, इसलिए इसके आउटपुट के नकारात्मक से मेल खाने के लिए कोड को आसानी से व्यवस्थित किया जाता है। वास्तविक कार्यक्रम इस तरह दिखता है:

H      \ Push char 100, 'd'
32 2C  \ Push char 32, a space, and make 2 extra copies
       \ We now have the string 'd   '
4:     \ 4 times do:
  "    \   Print the string
   }   \   Cyclically shift it right, once

बैकस्लैश एक टिप्पणी शुरू करते हैं, इसलिए अनुगामी \o/सिर्फ नकारात्मक को पूरा करने के लिए होती है, और शांत दिखती है।

---

वैकल्पिक रूप से, समान स्कोर के लिए, हमारे पास निम्नलिखित समाधान हो सकते हैं:

Code    Output

 35;    #
3 2j     #
2C 4      #
:"}        #

K 36     #
33 2      #
Ct4        #
 :}"    #

Answer 20

हास्केल, 10 × 10

main=let{ 
0&c='\32' 
!c;n&c=c! 
'\32'>>(n 
-1)&c;a!b 
=putStrLn 
$(b<$[1.. 
10])++[a] 
}in(9&'*' 
         )

एक सहायक फ़ंक्शन को परिभाषित करता है a ! bजो फ़ॉर्म की एक रेखा को प्रिंट करता है bbbbbbbbba, और एक पुनरावर्ती फ़ंक्शन n & cजो nप्रपत्र की ccccccccc␣एक पंक्ति के बाद प्रपत्र की पंक्तियों को प्रिंट करता है ␣␣␣␣␣␣␣␣␣c।

एक चरित्र को दोहराने के लिए एक सीमा पर <$( fmap constफिर से) का उपयोग करता है । ध्यान दें कि <$यह जीएचसी 7.10 के बाद से केवल आयात के बिना उपलब्ध है, जो इस चुनौती को पूरा करता है। मुझे पूरी तरह से यकीन नहीं है कि अगर यह इस सबमिशन को गैरकानूनी बनाता है।

यहां लेआउट या एल्गोरिदम की पसंद के साथ वास्तव में कुछ भी रोमांचक नहीं है; मेरे पास बहुत से बाइट्स नहीं थे और यह सौभाग्यशाली है putStrLnकि जिस तरह से उन्होंने किया था उसके आसपास होने के लिए लाइन ब्रेक मिल सकता है ।

Comments

नई भाषाओं / संस्करणों को अब गैर-प्रतिस्पर्धी होने की आवश्यकता नहीं है।

— मार्टिन एंडर

Answer 21

05AB1E , 3x3 (6 गैर-स्पेस बाइट्स )

 3Ð
Λ q
°° 

आउटपुट:

3  
 3 
  3

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

स्पष्टीकरण:

3Ð       # Push three 3s to the stack
  Λ      # Canvas with parameters num; filler; pattern
         #  num: The amount of characters to display (3)
         #  filler: The character to display ('3')
         #  pattern: The available options are single-digit integers in the range [0,7]
         #           indicating the direction to print in.
         #           (Option 3 is a top-left to bottom-right diagonal line)
    q    # Exit the program
°°       # no-ops to complete the pattern

Answer 22

पर्ल, 6x6 (26 गैर-स्थान)

मैं एक पूरी तरह से इन के माध्यम से देख रहा था और यकीन है कि वहाँ एक पर्ल समाधान किसी भी तरह 7x7 से छोटा होगा ... एक बहुत ही मजेदार चुनौती! इस समाधान की आवश्यकता है -E।

say+( 
$"x5, 
"5$/" 
)x5,5 
x5,$" 
     ;

उपयोग:

perl -E 'say+( 
$"x5, 
"5\n" 
)x5,5 
x5,$" 
     ;'

आउटपुट:

     5
     5
     5
     5
     5
55555 

Answer 23

सीबीएम बेसिक v2.0 (9 × 9)

0dA8,7,6 
1dA5,4, 3
2dA2,1 ,0
3rEs: rem
4?sP s)::
5:? "*";:
6p =8---s
7 ?sPp):?
 8ifsgO3:

आउटपुट:

        *
       * 
      *  
     *   
    *    
   *     
  *      
 *       
*        

Answer 24

सी (जीसीसी) , 7x7 8x8

संपादित करें: पिछले संस्करण में गलत व्यवहार था।

 main(i)
{ for(;i
<9 ;pri\
ntf ("%\
*d%" "*\
c",i, 1,
9-i,10 )
,i++);} 

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

Comments

" हमें प्रत्येक पंक्ति और प्रत्येक स्तंभ में कम से कम 1 स्थान और 1 गैर-स्थान वर्ण सम्‍मिलित करने की आवश्‍यकता है । " आपका पहला कॉलम गैर-स्‍थान वर्ण गुम है।

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

@ केविनक्रूजसेन किसी तरह मैं कॉलम की कसौटी पर चूक गया, इसलिए वे सभी गलत हैं। रीमेक होगा जब मेरे पास असली कंप्यूटर होगा।

— गैस्ट्रोपनर

Answer 25

जेली , 4 x 4 (12 गैर-स्थान)

 4=þ
¢ +⁴
¢+ ⁴
¢ỌY

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

आउटपुट:

!   
 !  
  ! 
   !

यह बहुत मजेदार था।

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

 4=þ    Link 1 (nilad): Generate an identity matrix of size 4
¢ +⁴    Link 2 (nilad): Add 16 to above
¢+ ⁴    Link 3 (nilad): Add 16 again
¢ỌY     Main link (nilad): Convert the above to ASCII chars, and join by newline

आसान हिस्सा: जेली व्हाट्सएप को नजरअंदाज करती है (जब तक कि केवल एक-बाइट का उपयोग किया जाता है)।

कठिन हिस्सा: जेली में प्रत्येक पंक्ति एक अलग लिंक (या फ़ंक्शन) है, इसलिए कई लाइनों में एक निरंतर बयान को फैलाने के लिए यह बहुत कम नहीं है। एक स्ट्रिंग शाब्दिक का उपयोग करना एक अच्छा उम्मीदवार है, लेकिन नकारात्मक को उत्पन्न करने का कोई विचार नहीं है।