प्याज प्रोग्रामिंग

Question

केवल मुद्रण योग्य ASCII (हेक्स कोड 20 से 7E) का उपयोग करते हुए , टिप्पणियों के बिना एक वर्ग एन × एन कोर कार्यक्रम लिखें जो 4 और परतों से घिरा हुआ है , एक (एन + 8) × (एन + 8) वर्ग कार्यक्रम (एन> 0) बना रहा है। । N = 3 के लिए लेआउट (वास्तविक कोड द्वारा प्रतिस्थापित किया जाना) इस तरह दिखता है:

44444444444
43333333334
43222222234
43211111234
4321CCC1234
4321CCC1234
4321CCC1234
43211111234
43222222234
43333333334
44444444444

• C कोर 3 × 3 कार्यक्रम का प्रतिनिधित्व करता है।
• 1 `पहली परत का प्रतिनिधित्व करता है, 2 दूसरी परत का प्रतिनिधित्व करता है, आदि।

कार्यक्रम हमेशा अंतरिक्ष अलग किए गए पूर्णांक जैसे स्ट्रिंग 0 -1 31 -1 2 2 2या समान के माध्यम से लेता है (यह सिर्फ सादे संख्या, कोई उद्धरण या ब्रैकेट या कुछ भी नहीं होना चाहिए)। आउटपुट इस बात पर निर्भर करता है कि लेआउट के किन हिस्सों को चलाया गया था।

कार्यक्रम को चलाने के लिए पांच तरीके हैं (नईलाइन रन में शामिल हैं)। प्रत्येक सूची में कुछ अलग करता है:

1. बस कोर भागो:

   CCC
   CCC
   CCC
   

   यह इनपुट सूची तत्वों के निरपेक्ष मानों की अधिकतम गणना करता है, और COREकई बार एक नई लाइन पर प्रिंट करता है। यदि अधिकतम 0 कुछ भी नहीं है तो आउटपुट (एक नई रेखा ठीक है) है।

   • के लिए आउटपुट 0 -1 31 -1 2 2 2होगा

     CORE
     CORE
     ...
     

     31 बार।

2. परत 1 के साथ कोर चलाएँ:

   11111
   1CCC1
   1CCC1
   1CCC1
   11111
   

   यह मानक मानों के औसत ( अंकगणितीय माध्य ) को मानक फ़्लोटिंग पॉइंट परिशुद्धता के लिए आउटपुट करता है ।

   • के लिए आउटपुट 0 -1 31 -1 2 2 235/7 = 5( 5.0ठीक है) होगा।

3. परतों 1 और 2 के साथ कोर चलाएँ:

   2222222
   2111112
   21CCC12
   21CCC12
   21CCC12
   2111112
   2222222
   

   यह उलट इनपुट सूची के एक अंतरिक्ष अलग सूची आउटपुट करता है।

   • के लिए आउटपुट 0 -1 31 -1 2 2 2होगा 2 2 2 -1 31 -1 0।

4. परतों 1, 2, और 3 के साथ कोर चलाएँ (पैटर्न स्पष्ट होना चाहिए)।
   यह छांटे गए इनपुट सूची की एक अलग अंतरिक्ष सूची को आउटपुट करता है।

   • के लिए आउटपुट 0 -1 31 -1 2 2 2होगा -1 -1 0 2 2 2 31।

5. परतों 1, 2, 3, और 4 के साथ कोर चलाएँ।
   यह डुप्लिकेट हटाए गए आदेशों के साथ इनपुट सूची की एक अंतरिक्ष से अलग सूची को आउटपुट करता है, ऑर्डर करने से कोई फर्क नहीं पड़ता।

   • के लिए आउटपुट 0 -1 31 -1 2 2 2हो सकता है -1 0 2 31।

सभी आउटपुट स्टडआउट या एक समान विकल्प के लिए है।

केवल इन 5 लेआउट संयोजनों में व्यवहार निर्दिष्ट है।

टिप्पणियाँ

• कोर या परतों या उसके संयोजन में टिप्पणियों की अनुमति नहीं है। कोड जो एक न-ऑप है या कुछ भी रचनात्मक नहीं है वह एक टिप्पणी के रूप में नहीं गिना जाता है।
• याद रखें कि कोर में कोई (धनात्मक) N × N आयाम हो सकते हैं, लेकिन परतें केवल एक वर्ण मोटी होती हैं।
• आप मान सकते हैं कि इनपुट में कोई अग्रणी या अनुगामी स्थान नहीं है और संख्याओं के बीच एक स्थान है। इसमें हमेशा कम से कम एक नंबर होगा। (आउटपुट सूचियों को इस तरह भी स्वरूपित किया जाना चाहिए।)
• आप मान सकते हैं कि आउटपुट के लिए आवश्यक सूची और गणना में वे मान नहीं होंगे जो आपके पूर्णांकों (जब तक कि उनकी अधिकतम 2 ^{16 की} तरह कुछ उचित हो) को ओवरफ़्लो (या अंडरफ़्लो) कर सकते हैं ।

स्कोरिंग

इस कार्यक्रम को सामान्य रूप से लिखना आसान होगा। छोटे कोर के साथ इसे लिखना कठिन है।

सबसे छोटे कोर आकार (सबसे छोटा एन) के साथ कार्यक्रम जीतता है। संबंधों के मामले में विजेता पूर्ण प्रोग्राम है ((N + 8) × (N + 8) वर्ग के साथ कुछ अलग-अलग वर्ण (नई गिनती नहीं)।

कृपया अपने उत्तर के शीर्ष पर अपना एन मान दर्ज करें।

Comments

मैंने सोचा था कि यह उन नए प्रकारों में से एक और भी होगा

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

क्या मैं एक ऐसी भाषा का उपयोग कर सकता हूं जो एक नई पंक्ति के बाद सब कुछ अनदेखा करती है?

— isaacg

@isaacg हाँ (जब तक newline को टिप्पणी चरित्र नहीं माना जाता है, जो अजीब होगा)।

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

@ ऑप्टिमाइज़र मुझे मत लुभाएं ... " प्रत्येक उत्तर कोड प्याज में एक नई परत जोड़ता है, इसलिए यह सूची के साथ कुछ नया करता है ... "

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

@Optimizer No. (मुझे पता है कि ये i / o नियम थोड़े कठोर हैं, लेकिन यह सभी भाषाओं के अनुरूप है।)

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

Answer 1

CJam, N = 5, 27 (26) अद्वितीय वर्ण

अगर मैं रिक्त स्थान नहीं गिनता तो यह 26 अक्षर है। कार्यक्रम को वास्तव में एक में परिवर्तित किया जा सकता है जो रिक्त स्थान का उपयोग नहीं करता है, बस सभी रिक्त स्थानों को बिना-ऑप्स के भरने के द्वारा (जैसे _;जो शीर्ष स्टैक तत्व को डुप्लिकेट करता है और फिर डिस्क को या फिर से और फिर से सरणी को छाँटकर), लेकिन यह सिर्फ वास्तविक कोड से ध्यान भंग होगा।

l~]_|S*      
{l~]$S*      
 {l~]W%S*    
  {l~]_,\    
   {l~]{z    
    }%$W=    
    "CORE    
    "*       
         }   
   ;:+d\/ }  
  ;        } 
 ;          }
;            

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

कोर है

l~]{z
}%$W=
"CORE
"*

(प्लस एक खाली लाइन।)

मुझे पूरा यकीन है कि N = 4सीजेएम में नहीं किया जा सकता (और मुझे यकीन है कि डेनिस मुझे अन्यथा मना लेंगे: डी)। उपरोक्त में 17 वर्ण हैं, और इसे 16 तक नीचे ले जाना संभव हो सकता है (जैसे कि CJam के पास चोक करने के लिए बग नहीं है :z, जिसकी आवश्यकता है {z}%, या ARGV का उपयोग करके), मुझे नहीं लगता कि आप इसे फिट कर सकते हैं लेआउट में बिना लाइन ब्रेक शुरू किए CORE।

सभी कार्यान्वयन दिए गए कार्यों के लिए बहुत ही सरल समाधान हैं। वे सभी l~]जिसके साथ STDIN पढ़ता है, उसका मूल्यांकन करता है, और इसे एक सरणी में रखता है।

पिछली परत हमेशा अंदर घिरी रहती है {...}, जो इसे एक ऐसा ब्लॉक बनाती है जो स्वचालित रूप से निष्पादित नहीं होती है। और इसे निष्पादित करने के बजाय, मैं इसे स्टैक से हटा देता हूं ;, इसलिए कोई भी परत पिछली परत में कोड पर निर्भर नहीं करती है। लेयर 1 में, कोड पहली पंक्ति में फिट नहीं था, इसलिए मैंने कोर ब्लॉक को छोड़ने के बाद इसे जारी रखा।

अब वास्तविक कार्यक्रमों के लिए:

• कोर:

  {z}%$W="CORE
  "*
  

  absसूची पर मैप करें , इसे सॉर्ट करें, आखिरी तत्व लें, CORE(और एक लाइन ब्रेक) जो कई बार दोहराएं ।

• परत 1:

  _,\:+d\/
  

  सूची को डुप्लिकेट करें, लंबाई लें, स्टैक तत्वों को स्वैप करें, योग प्राप्त करें, कास्ट करें double, स्टैक तत्वों को स्वैप करें, विभाजित करें। मुझे लगता है कि यह कम हो सकता है, लेकिन ऐसा करने के लिए कोई प्रोत्साहन नहीं है।

• परत 2:

  W%S*
  

  सरणी को उल्टा करें, रिक्त स्थान के साथ राइफल करें।

• परत 3:

  $S*
  

  सरणी को सॉर्ट करें, रिक्त स्थान के साथ राइफल।

• परत 4:

  डुप्लिकेट, सेट यूनियन लें, रिक्त स्थान के साथ राइफल लें।

कुछ अन्य अनुकूलन भी संभव है, पुन: उपयोग की तरह ;और *Sपरत 2 की है, लेकिन फिर से, लेकिन यह स्कोर को प्रभावित नहीं करता है।

Answer 2

पायथन 2 - एन = 17, 53 वर्ण

ओह, मैं पायथन के साथ स्रोत-लेआउट चुनौतियों से प्यार करता हूं ...

i=4                     ;
ii=3                    ;
iii=2                   ;
iiii=1                  ;
iiiii=0;R=raw_input     ;
iiiii;w=R().split()     ;
iiiii;n=map(int,w)      ;
iiiii;S=set(n);M=max    ;
iiiii;s=sorted(n)       ;
iiiii;J="\n".join       ;
iiiii;j=" ".join        ;
iiiii;k=M(map(abs,n))   ;
iiiii;A=J(["CORE"]*k)   ;
iiiii;B=sum(n)/len(n)   ;
iiiii;C=j(w[::-1])      ;
iiiii;D=j(map(str,s))   ;
iiiii;E=j(map(str,S))   ;
iiiii;P=A,B,C,D,E       ;
iiiii;print P[i]        ;
iiiii;" /__----__\  "   ;
iiiii;"|/ (')(') \| "   ;
iiii;"  \   __   /  "   ;
iii;"   ,'--__--'.   "  ;
ii;"   /    :|    \   " ;
i;"   (_)   :|   (_)   ";

हालांकि अभी भी कुछ अप्रयुक्त व्हाट्सएप हैं।

मैं अभी भी अद्वितीय वर्ण गणना में सुधार कर सकता था, लेकिन मैं बेहतर पठनीयता के साथ रहूंगा - अगर कोई भी है।

संपादित करें: ओह, यह फिर से स्टेन है !

Comments

आप शायद i=*चाल के बजाय प्रिंट को अलियासिंग करके कुछ पंक्तियों को बचा सकते हैं

— M.Herzkamp

@ M.Herzkamp: printपाइथन 2 के साथ एलियासिंग संभव नहीं है। लेकिन निश्चित रूप से, इसमें सुधार की गुंजाइश है - शायद पाइथन 3 का उपयोग करना।

— फाल्को

मैं पायथन को नहीं जानता, लेकिन कोर कोड आउटपुट में यह अनुपलब्ध पूर्ण मान नहीं है -c*max(n)

— Nutki

@ कुटकी: आप सही कह रहे हैं! मैंने ध्यान से नहीं पढ़ा। लेकिन मैं इसे ठीक करने में सक्षम था।

— फ़ाल्को

Answer 3

पायथन 3: एन = 11, 40 अलग-अलग वर्ण

if 1:              
 if 1:             
  if 1:            
   if 1:           
    p=print;R=0    
    a=input()      
    b=a.split()    
    m=map;a=abs    
    E=max;l=len    
    n=m(int,b);    
    C=['CORE']     
   "R=E(m(a,n))"   
   OO=C*R;s=sum    
   "x='\n'.join"   
   "p(x(O))    "   
  "p(s(n)/l(b)) "  
 "p(*b[::-1])    " 
"p(*sorted(n))    "
p(*set(n))         

मेरे म्यूज होने के लिए @ फालको को धन्यवाद। यह काम करता है, क्योंकि पायथन प्रत्येक बयान के लिए एक नया दायरा नहीं बनाता है, इसलिए चर बाहरी printबयानों में बने रहते हैं । एक कष्टप्रद बात यह थी कि एक mapवस्तु (हमारे मामले में n) का उपयोग केवल एक बार किया जा सकता है। इसलिए R=E(...)लाइन को स्ट्रिंग करना आवश्यक था, लेकिन तब Rपरिभाषित नहीं किया गया था। इसलिए मैं भाग्यशाली था कि पहली पंक्ति में चार स्थान बचे थे!

*b[::-1]सूची के बजाय कई तत्व प्रदान करके आउटपुट को हल किया जा सकता है । विकल्प ' '.join(...)बहुत लंबा होता।

Comments

सुंदर! अजगर में चर रेखा की शुरुआत से निपटने के लिए एक वैकल्पिक दृष्टिकोण को देखकर अच्छा लगा। बस कुछ कम अगर बयान और वे सभी रिक्त स्थान ठीक हैं। :)

— फाल्को

@ फालो: नकारात्मक पक्ष यह है: स्टेन के लिए कोई जगह नहीं है :(

— M.erzkamp

Answer 4

सी (जीसीसी) , एन = 15, 47 अद्वितीय अक्षर

मान लेता है sizeof(int) == 4और sizeof(int*) >= sizeof(int)।

;                     ;
 ;                   ; 
  ;                 ;  
   ;           float   
    s;c(a,b)int*a,*    
    b;{b=*b-*a;}i,n    
    ,*f;*q,*R,C,E ;    
    main(a){for(;0<    
    scanf("%i",&a);    
    i=i<abs(a)?a:i,    
    s+=f[n-!0]=a)f=    
    realloc(f,++n*4    
    );qsort(f,n*C,4    
    ,c);for(i=q?R?n    
    :!0:i;i--;a=f[i    
    ])!E|n-i<2|a!=f    
    [i]&&printf(q?R    
    ?R:q:"CORE\n",!    
    q+R?f[i]:s/n);}    
   ;*q="%f";       ;   
  ;*R="%.0f ";      ;  
 ;C=!0;              ; 
;E=!0;                ;

4 परतें

3 परतें

2 परतें

1 परत

कोर

Answer 5

रूनिक एनचेंमेंट्स , एन = ९ एन =,, ३। अक्षर

/ o/\  \     \S\
" //RiU\      \}
@            q "
"        }+1\r @
}   ^U \    {q "
     \{\?)}\+  }
  o\/'|A:{:/R' S
 //r/Ril2=?\?R :
   ,A~/"OC"/=? {
   @| \"RE"\3= =
 D$\' /rqka/l2S?
    i \*@   il\/
   'R1i     Ui ~
 R$/Rak      U \
 ?!D  Rlril1-{=
R   R: }S:{=?\~

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

इससे पहले कि मैं गलत था , मैं भूल गया था कि मैं पहले से ही एक स्पष्ट oएसटी कमांड था, "पहले एक सूची" समस्या का सामना करने के कारण। हालाँकि, यह उन इनपुटों के आकार को सीमित करता है जो अंतिम प्रोग्राम ले सकते हैं (8 मान), सॉर्ट कमांड की आंतरिक लागतों के कारण। एक मामूली घुमाव 1 अद्वितीय चरित्र की लागत पर 13 या दो अद्वितीय वर्णों के लिए 19 तक बढ़ा सकता है (सभी अतिरिक्त वर्ण परत 1 पर हैं और एक ही समय में जोड़े गए हैं, लेकिन IP के स्टैक की बढ़ी हुई क्षमता नहीं है लेयर 3 तक आवश्यक, C, L1 और L2 के रूप में, मेमोरी में पूरे इनपुट को पकड़े बिना अपनी गणना कर सकते हैं)।

कोर: यह ऑनलाइन की कोशिश करो!

परत 1: इसे ऑनलाइन आज़माएं!

परत 2: इसे ऑनलाइन आज़माएं!

परत 3: इसे ऑनलाइन आज़माएं!

परत 4: इसे ऑनलाइन आज़माएं!

आगे की संपीड़न अत्यधिक संभावना नहीं है, छोटे स्थान के कारण प्रवाह नियंत्रण वर्णों की संख्या में वृद्धि की आवश्यकता होती है। मुझे एक व्यवस्था मिली जिसने कोर प्रोग्राम में 9 खाली स्थान दिए, लेकिन यह पर्याप्त नहीं है, जैसा कि हमें (सही ढंग से व्यवस्थित) 15 की आवश्यकता है।

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

तल पर 1 और 2 अवरोधक (ताकि भविष्य की परतों के लिए शीर्ष रेखा खाली रहे) और फिर दाहिने हाथ के किनारे (एक लूप व्यवस्थित व्यवस्थित) के साथ अपना संचालन करते हैं। लेयर 1 थोड़ा बहुत लंबा है और शीर्ष किनारे के साथ-साथ 3 अक्षर भी लेता है, लेकिन \शीर्ष दाएं में विकर्ण परावर्तक ( आईपी) अगले लूप पुनरावृत्ति के साथ आईपी को अहसास कराता है।

लेयर 3 नीचे के किनारे पर रीडायरेक्ट करने से पहले पहले इनपुट वैल्यू को हथियाने के लिए शीर्ष किनारे के साथ इंटरसेप्ट करता है (लेयर 4 अपने निचले लाइन पर इस कॉलम में एक एनओपी छोड़ता है) और निचले किनारे पर लूप का उपयोग करके पूरा इनपुट पढ़ता है, डाउन पर रीडायरेक्ट करता है। कमांड ( D) निचले बाएँ में। वहाँ से आईपी एक आउटपुट ( $) लूप में समाप्त होने से पहले कुछ समय बाउंस करता है ताकि मूल्यों को अलग-अलग किया जा सके।

परत 4 परत 3 (इसलिए रिक्त स्थान) की सभी कार्यक्षमता का उपयोग करता है, लेकिन परत 3 के प्रसंस्करण के अंत में अपनी कार्यक्षमता का प्रदर्शन करने के लिए अपने स्वयं के नए शीर्ष किनारे (ऊपरी बाएं) पर इंटरसेप्ट करता है। शीर्ष बाएं कोने में एक स्ट्रिंग सम्मिलित "@"होती है जिसका उपयोग नीचे के साथ प्रोसेसिंग लूप में प्रवेश करने से पहले सरणी के अंत को दर्शाने के लिए किया जाता है। यदि कोई डुप्लिकेट मान पाया जाता है, तो यह पॉपअप किया जाता है ( ~, निचले दाएं कोने) अन्यथा शाखा को लिया जाता है जो नए दाहिने हाथ के किनारे का उपभोग करता है। यह साइड ब्रांच यह देखने के लिए चेक करती है कि एरे का अंत हो गया है या नहीं, और यदि ऐसा है, तो लेयर से समान स्पेस-अलग-अलग आउटपुट लूप पर जाएं और वापस जाएं। अन्यथा मुख्य पर वापस लौटने के लिए लेयर 3 पर रिक्त स्थान का उपयोग करें पाश।