ब्लॉक-विकर्ण मैट्रिक्स प्रिंट करें

27

यहां एक सरल, काटने के आकार (बाइट-आकार?) कोड गोल्फ है: 10 से कम सकारात्मक पूर्णांक की एक गैर-खाली सूची दी गई है, ब्लॉक-विकर्ण मैट्रिक्स प्रिंट करें , जहां सूची क्रम में ब्लॉकों के आकार को निर्दिष्ट करती है। यदि आप इनपुट के रूप में दिए गए हैं, तो ब्लॉक में 10 से कम सकारात्मक पूर्णांक शामिल होने चाहिए

[5 1 1 2 3 1]

उदाहरण के लिए, आपका आउटपुट हो सकता है,

1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1

या

1 2 3 4 5 0 0 0 0 0 0 0 0
6 7 8 9 1 0 0 0 0 0 0 0 0
2 3 4 5 6 0 0 0 0 0 0 0 0
7 8 9 1 2 0 0 0 0 0 0 0 0
3 4 5 6 7 0 0 0 0 0 0 0 0
0 0 0 0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 9 0 0 0 0 0 0
0 0 0 0 0 0 0 1 2 0 0 0 0
0 0 0 0 0 0 0 3 4 0 0 0 0
0 0 0 0 0 0 0 0 0 5 6 7 0
0 0 0 0 0 0 0 0 0 8 9 1 0
0 0 0 0 0 0 0 0 0 2 3 4 0
0 0 0 0 0 0 0 0 0 0 0 0 5

या कुछ इस तरह का। मैट्रिक्स में तत्वों को (एकल) रिक्त स्थान से अलग किया जाना चाहिए, और पंक्तियों को (एकल) नईलाइन्स द्वारा अलग किया जाना चाहिए। किसी भी लाइन पर अग्रणी या अनुगामी स्थान नहीं होना चाहिए। आप एक अनुगामी न्यूलाइन प्रिंट कर सकते हैं या नहीं।

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

आपको ब्लॉक-विकर्ण मैट्रिसेस बनाने के लिए डिज़ाइन किए गए किसी भी अंतर्निहित फ़ंक्शन का उपयोग नहीं करना चाहिए।

यह कोड गोल्फ है, इसलिए सबसे छोटा सबमिशन (बाइट्स में) जीतता है।

लीडरबोर्ड

मैं सरणी-आधारित भाषाओं (जैसे J और APL) से उम्मीद करता हूं कि यहां बढ़त होगी, लेकिन मैं नहीं चाहता कि लोगों को अपनी पसंद की भाषा में जितना संभव हो उतना अच्छा करने की कोशिश करें। तो यहां एक नियमित लीडरबोर्ड और भाषा द्वारा विजेताओं का अवलोकन दोनों उत्पन्न करने के लिए एक स्टैक स्निपेट है। तो क्यों न बाद के मौके पर कोशिश की जाए?

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

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

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

code-golf  array-manipulation 
— मार्टिन एंडर
स्रोत

जवाबों:

20

जे, 7 बाइट्स

2-बाइट सुधार के लिए FUZxxl के लिए धन्यवाद ।

सरणी आधारित भाषाओं को यहां एक अलग प्रतियोगिता में गिना जाना चाहिए क्योंकि उनके पास एक बड़ा फायदा है। :)

   =/~@#<\

   (=/~@#<\) 3 1 1 2
1 1 1 0 0 0 0
1 1 1 0 0 0 0
1 1 1 0 0 0 0
0 0 0 1 0 0 0
0 0 0 0 1 0 0
0 0 0 0 0 1 1
0 0 0 0 0 1 1

एक और 7-बाइट दृष्टिकोण:

#]=@##\

पुराने संस्करण के लिए स्पष्टीकरण ([:=/~]#<\):

पहला चरण nहर सूची तत्व के लिए समान चीजों (जैसे संख्याओं) का टुकड़ा उत्पन्न कर रहा है n। ये अन्य तत्वों से अलग होना चाहिए '। जैसे प्राकृतिक संख्याओं का उपयोग करना 3 1 1 2बन जाता है 0 0 0 1 2 3 3।

बाइट्स को बचाने के लिए हम सूची के बॉक्सिंग उपसर्गों का उपयोग करते हैं:

   ]#<\ 3 1 1 2
┌─┬─┬─┬───┬─────┬───────┬───────┐
│3│3│3│3 1│3 1 1│3 1 1 2│3 1 1 2│
└─┴─┴─┴───┴─────┴───────┴───────┘

=/~क्रिया के साथ हम इन बॉक्सिंग उपसर्गों के डेसकार्टेस उत्पादों की एक तालिका बनाते हैं और प्रत्येक सेल होगा 1यदि दोनों प्रविष्टियां समान 0हैं।

— randomra
स्रोत
2
मुझे नहीं लगता कि कोष्ठक [:=/~]#<\ आपके स्कोर की ओर गिनती के आसपास है । इसके अलावा, =/~@#<\ दो अतिरिक्त बाइट्स के लिए मुंडा।
— FUZxxl
"हालांकि, परिणाम को STDOUT (या निकटतम वैकल्पिक) पर मुद्रित किया जाना चाहिए, जैसा कि एक फ़ंक्शन से वापस करने का विरोध किया गया है, कहते हैं ।" आपको शायद या तो स्पष्ट इनपुट की आवश्यकता है (इसलिए यह केवल एक फ़ंक्शन नहीं है) या स्पष्ट आउटपुट।
— मारिनस
@marinus J एक चर के लिए बाध्य न होने पर अभिव्यक्ति के परिणाम को प्रिंट करता है।
— FUZxxl
@FUZxxl: हाँ, लेकिन (=/~@#<\)सिर्फ एक फ़ंक्शन है। आपको वास्तव में अभिव्यक्ति प्राप्त करने के लिए इसे किसी चीज़ पर लागू करना होगा, इसलिए आपको स्पष्ट इनपुट ( ".1!:1[1) की आवश्यकता होगी , या यदि आप एक फ़ंक्शन सबमिट करना चाहते हैं, तो उस फ़ंक्शन को वास्तव में मूल्य प्रिंट करना चाहिए और इसे वापस नहीं करना चाहिए (जैसे echo@या कुछ और )।
— मारिनस
=/~&I.­­­­­­­
— ngn
11

एपीएल, १०

∘.=⍨∆/⍋∆←⎕

उदाहरण:

      ∘.=⍨∆/⍋∆←⎕
⎕:
      5 1 1 2 3 1 
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1

स्पष्टीकरण:

  • ∆←⎕: इनपुट पढ़ें, स्टोर करें ∆।
  • ⍋∆: क्रमबद्धता ज्ञात करें जो छांटता है ∆(यह इनपुट में प्रत्येक मान के लिए एक अद्वितीय मूल्य देता है)
  • ∆/: उन अद्वितीय मूल्यों में से प्रत्येक के लिए, इसे Nबार-बार दोहराएं , जहां Nइनपुट में संबंधित मूल्य है
  • ∘.=⍨: उस सूची के प्रत्येक मान की अन्य मूल्यों से तुलना करते हुए एक मैट्रिक्स बनाएं।
— मारीनस
स्रोत
इस पर परीक्षण करने के लिए http://tryapl.org, आप dfn का उपयोग करना चाह सकते हैं {∘.=⍨⍵/⍋⍵}, क्योंकि साइट सभी उपयोगों ⎕( ⎕IOजैसे और सामान को छोड़कर) को फ़िल्टर करती है ।
— फ़ूजएक्सएक्सएल
1
@FUZxxl: यह कहता है "हालांकि, परिणाम को STDOUT (या निकटतम वैकल्पिक) में मुद्रित किया जाना चाहिए, जैसा कि किसी फ़ंक्शन से वापस करने के लिए विरोध किया जाता है, कहते हैं ।", इसलिए {∘.=⍨⍵/⍋⍵}मान्य नहीं है। आप की जरूरत है {⎕←∘.=⍨⍵/⍋⍵}, जो न केवल दो पात्रों की लागत पर अभी भी TryAPL पर काम नहीं करेगा। (और सामान्य तौर पर, TryAPL उपयोगी होने के लिए बहुत सीमित है।)
— marinus
अगर इसे परिणाम का प्रिंट आउट लेना है, तो क्या आपको ⎕←डीएफएन के बिना भी, वैसे भी ज़रूरत नहीं होगी ?
— फ़ूजएक्सएक्स
@FUxxxxl: नहीं, अभिव्यक्ति का आउटपुट स्वचालित रूप से मुद्रित होता है यदि इसके साथ कुछ और नहीं किया जाता है।
— मेरिनस
ओह समझा। मैं इस धारणा के तहत था कि यह केवल तब होता है जब आप इंटरप्रेटर का उपयोग अंतःक्रियात्मक रूप से करते हैं।
— फूजएक्सएक्सएल
8

आर, ६ ९ ६३

function(x)write(+outer(i<-rep(1:length(x),x),i,"=="),1,sum(x))

परीक्षण का मामला:

(function(x)write(+outer(i<-rep(1:length(x),x),i,"=="),1,sum(x)))(c(5,1,1,3,1))
1 1 1 1 1 0 0 0 0 0 0 
1 1 1 1 1 0 0 0 0 0 0 
1 1 1 1 1 0 0 0 0 0 0 
1 1 1 1 1 0 0 0 0 0 0 
1 1 1 1 1 0 0 0 0 0 0 
0 0 0 0 0 1 0 0 0 0 0 
0 0 0 0 0 0 1 0 0 0 0 
0 0 0 0 0 0 0 1 1 1 0 
0 0 0 0 0 0 0 1 1 1 0 
0 0 0 0 0 0 0 1 1 1 0 
0 0 0 0 0 0 0 0 0 0 1

बाहरी कार्य यहां अधिकांश काम करता है, फिर इसका सिर्फ उत्पादन ठीक लगने का मामला है - इसके लिए उसकी मदद के लिए @Vlo को धन्यवाद

— मनमुटाव
स्रोत
बहुत अच्छा समाधान
— मिकी
महान समाधान। -/+तार्किक का उपयोग करने के बारे में कभी नहीं सोचा । कुछ बाइट्स function(x)write(+outer(i<-rep(1:length(x),x),i,"=="),1,sum(x))63 बचाएं
— Vlo
6

पायथन 3, 103 97 82 78 78 बाइट्स

def P(L,n=0):k,*L=L;exec("print(*[0]*n+[1]*k+[0]*sum(L));"*k);L and P(L,n+k)

printथोड़ी सी पुनरावृत्ति के साथ, अंतरिक्ष को अलग करने वाली प्रकृति का लाभ लेने के लिए स्पैट का उपयोग करना ।

— Sp3000
स्रोत
6

रूबी, 86 90 83 बाइट्स

मेरा पहला गोल्फ कभी!

->l{n=l.reduce :+;s=0;l.map{|x|x.times{puts ([0]*s+[1]*x+[0]*(n-x-s))*" "};s+=x}}

पूर्णांक के साथ एक सरणी प्राप्त करता है, अपेक्षित परिणाम प्रिंट करता है:

$ (->l{n=l.reduce :+;s=0;l.map{|x|x.times{puts ([0]*s+[1]*x+[0]*(n-x-s))*" "};s+=x}}).call([5, 1, 1, 2, 3, 1])
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1

संपादित करें:

कुछ चीजों को छोटा करने में मेरी मदद करने के लिए मार्टिन ब्यूटनर का धन्यवाद!

— rorlork
स्रोत
1
आप कुछ और अक्षर बचा ->(l)सकते हैं : हो सकता है ->l। mapसे छोटा है each। .join(" ")को छोटा किया जा सकता है *" "।
— मार्टिन एंडर
6

मतलाब, 60 54 बाइट्स

यह मतलाब का विशेष क्षेत्र होगा यदि हम बिलिन कार्यों का उपयोग कर सकते हैं ...

धन्यवाद @ त्रुटि को ठीक करने के लिए धन्यवाद।

c=0;a=input('');for A=a;v=c+1:c+A;d(v,v)=1;c=c+A;end;d
— flawr
स्रोत
वाह, यह अब तक था कि मैंने देखा कि यह जेएस स्निपेट वास्तव में एक लीडरबोर्ड का उत्पादन करता है !!! मैंने इसे कभी नोटिस कैसे किया ??? यह इंगित करने के लिए धन्यवाद =)
— दोष
मुझे सही पता है? वास्तव में यह अच्छा है!
— एलेक्स ए।
1
मैं लगभग एक ही उत्तर पोस्ट करने वाला था :-)
— लुइस मेंडो
ठीक वही या कुछ अलग सा? =) (चर नामों से अलग।)
— 23
मेरे लिए इसे पोस्ट करने के लिए समान है :-)
— लुइस मेंडो
6

मतलाब, 53 बाइट्स

हालाँकि यह अन्य मैटलैब के टुकड़े की तुलना में केवल एक चार छोटा है, मुझे लगा कि एक नया उत्तर देने के लिए कोड पर्याप्त रूप से अलग है:

d=[];a=input('');for A=a;v=1:A;d(end+v,end+v)=1;end;d

मुख्य चाल निश्चित रूप से सीमा सूचकांक से बाहर है, लेकिन endइसे अधिक कॉम्पैक्ट बनाने के लिए एक चर के रूप में उपयोग के साथ जोड़ा जाता है।

— डेनिस जहरुद्दीन
स्रोत
1
लानत है - मैंने end+1:end+vएक 'काउंटर' चर से छुटकारा पाने के लिए गोल्फ में आधे घंटे की कोशिश की , और मैंने इस समाधान के बारे में नहीं सोचा।
— Sanchises
दरअसल, जैसा कि @Geobits ने एक अनाम द्वारा संपादित संपादन का उल्लेख किया है blkdiag, आवश्यकताओं का उल्लंघन करेगा। बस संदर्भ के लिए मैं इसे यहाँ वैसे भी blkdiag(A,ones(i))
— डालूँगा
4

सीजेम, 21

q~{T):Ta*~}%_f{f=S*N}

इसे http://cjam.aditsu.net/ पर आज़माएं

स्पष्टीकरण:

q~          read and evaluate the input array
{…}%        transform each number using the block
    T):T    increment T (initially 0)
    a*      wrap T in an array and repeat it <number> times
    ~       dump the repeated numbers so they end up in a flat array
_           duplicate the array
f{…}        for each array item and the array
    f=      compare the current item with each item, resulting in an array of 1 and 0
    S*      join with spaces
    N       add a newline
— aditsu
स्रोत
4

पायथन 3, 79

def f(l,s=0):
 for x in l:r=[0]*sum(l);r[s:s+x]=[1]*x;s+=x;exec("print(*r);"*x)

ब्लॉक के सबसे बाएं इंडेक्स को ट्रैक sकरता है और xप्रविष्टियों को इसके बाद बनाता है 1, जहां xवर्तमान ब्लॉक आकार है। इस पंक्ति को तब मुद्रित किया जाता xहै। अजगर 3 करने की जरूरत है print(*r)।

— XNOR
स्रोत
यह सिर्फ एक के rरूप में व्यक्त करने के लिए छोटा है [0]*s+[1]*x+[0]*(sum(l)-s-x), लेकिन मैं अभी भी एक बेहतर तरीके की तलाश कर रहा हूं।
— xnor
4

हास्केल, 118 116 बाइट्स

(#)=replicate
f i=putStr$[e#(unwords$sum h#"0"++e#"1"++sum t#"0")|(h,e:t)<-map(`splitAt`i)[0..length i-1]]>>=unlines

उपयोग: f [2,1,1,3]

आउटपुट:

1 1 0 0 0 0 0
1 1 0 0 0 0 0
0 0 1 0 0 0 0
0 0 0 1 0 0 0
0 0 0 0 1 1 1
0 0 0 0 1 1 1
0 0 0 0 1 1 1

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

[0..length i-1]           for each index n of the input list i
(h,e:t)<-map(`splitAt`i)  split i at n and
                            let e be the element at index n
                            let h be the list of elements to the left of e
                            let t be the list of elements to the right of e
                          foreach triple h, e, t make a list of
sum h # "0" ++              sh copies of "0" (sh = the sum of the elements of h) followed by
e # "1" ++                  e copies of "1" followed by
sum t # "0"                 st copies of "0" (st = the sum of the elements of t)
unwords                   join those list elements with spaces inbetween
e #                       make e copies
>>=unlines                join those lists with newlines inbetween
putStr                    print
— nimi
स्रोत
आप दो बाइट्स को कर के बचा सकते हैं (h,e:t)<-map(`splitAt`i)[0..length i-1], क्योंकि बाध्यकारी के nबाहर उपयोग नहीं किया जाता है let।
— जर्ग्बेल
@Zbb: अच्छा लगता है। धन्यवाद!
— निमि
3

पायथ, 23 21 बाइट्स

पाइथ के लिए गिटहब रिपॉजिटरी

Ju+G*]GHQYFNJjdmsqdNJ

इनपुट पूर्णांकों की एक सूची है, जैसे [3, 1, 1, 2]। इसे ऑनलाइन आज़माएं: पायथ कंपाइलर / एक्ज़ीक्यूटर

रैंडम्रा के जे कोड के समान एक समान विचार का उपयोग करता है। कोड का पहला भाग समान चीजों के हिस्से Ju+G*]GHQYउत्पन्न करता है n। उदाहरण इनपुट के [3, 1, 1, 2]लिए परिणाम इस तरह दिखता है:

[
 [], 
 [], 
 [], 
 [[], [], []], 
 [[], [], [], [[], [], []]], 
 [[], [], [], [[], [], []], [[], [], [], [[], [], []]]], 
 [[], [], [], [[], [], []], [[], [], [], [[], [], []]]]
]

पहले तीन समान तत्व, एक तत्व से, फिर एक तत्व फिर से और अंत में दो समान तत्व। 

Ju+G*]GHQY
 u      QY  reduce the input Q, start with empty list G=[]
            for each H in input, replace the value of G by:
  +G*]GH       G+[G]*H
J           store the result in J

कोड का दूसरा भाग कार्टेशियन उत्पाद के तत्वों की तुलना कर रहा है और इसे प्रिंट कर रहा है। 

FNJjdmsqdNJ
FNJ          for N in J:
     m    J     map each element d of J to
       qdN          the boolean value of d == N
      s             and convert it to an integer (0 = False, 1 = True)
   jd           print the resulting list seperated by d (=space)
— Jakube
स्रोत
3

सी ++, 294 बाइट्स

संकलक का इस्तेमाल किया - जीसीसी 4.9.2

#include<bits/stdc++.h>
using namespace std;
#define F(a,b) for(a=0;a<b;a++)
#define V vector<int>
int n,i,j,s,o;
main(){V v;while(cin>>n)v.push_back(n),s+=n;vector<V> m(s,V(s,0));F(i,v.size()){F(j,v[i])F(n,v[i])m[j+o][n+o]=1;o+=v[i];}F(j,s){F(n,s)cout<<m[j][n]<<((n==s-1)?"":" ");cout<<"\n";}}

स्पष्टीकरण -: 

#include<bits/stdc++.h>
using namespace std;
#define F(a,b) for(a=0;a<b;a++)
#define V vector<int>
int n, i, j, s, o;
/*
 n = Used to take inputs, and as an iterator after that
 i, j = Iterators
 s = sum of all the inputs
 o = offset ( used to find the location of the starting cell of the next matrix of 1's )
*/

main()
{
    V v;
    while ( cin >> n )  // Take input
    {
        v.push_back( n ), s += n;
    }

    vector<V> m( s, V( s, 0 ) ); // m is a matrix of size (s*s) with all elements initialized to 0
    F( i, v.size() )
    {
        F( j, v[i] )F( n, v[i] )m[j + o][n + o] = 1; // Assign 1 to the required cells
        o += v[i]; // Add the value of the current element to the offset
    }

    F( j, s )  // Output the matrix
    {
        F( n, s )cout << m[j][n] << ( ( n == s - 1 ) ? "" : " " ); // Prevent any trailing whitespace
        cout << "\n";
    }
}
— अनमोल सिंह जग्गी
स्रोत
3

के, 30 बाइट्स

{"i"$,/x#',:',/'g=\:\:x#'g:<x}

मूल रूप से मारिनस का जवाब चुरा लिया

k){"i"$,/x#',:',/' g=\:\:x#'g:<x}5 1 1 2 3 1
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1
— tmartin
स्रोत
2

जावा, 163

a->{int n=a.stream().mapToInt(x->x).sum(),t=0,j,k;for(int i:a){for(j=0;j++<i;System.out.println("\b"))for(k=0;k<n;)System.out.print(k>=t&k++<t+i?"1 ":"0 ");t+=i;}}

एक उपभोक्ता जो पूर्णांकों की सूची को स्वीकार करता है।

बॉयलरप्लेट कोड के साथ पठनीय संस्करण:

java.util.function.Consumer<java.util.List<Integer>> c = a -> {
    int n = a.stream().mapToInt(x -> x).sum(), t = 0, j, k;
    for (int i : a) {
        for (j = 0; j++ < i; System.out.println("\b")) {
            for (k = 0; k < n;) {
                System.out.print(k >= t & k++ < t + i ? "1 " : "0 ");
            }
        }
        t += i;
    }
};

उपयोग करें:

List list = Arrays.asList(5, 1, 1, 2, 3, 1);
c.accept(list);
— Ypnypn
स्रोत
2

पायथन 2, 163 114 बाइट्स

gnibbler ने इसे एक गुच्छा बना दिया।

h=input()
r=range
l=len(h)
for i in r(l):
 for k in r(h[i]):print" ".join("01"[i==j]for j in r(l)for x in r(h[j]))
— KSFT
स्रोत
3
कैसे के बारे में print" ".join("01"[i==j]for j in r(l(h))for x in r(h[j]))?
— 20-22 पर gnibbler
ए हा ! मुझे लगा कि मैं ऐसा कुछ कर सकता हूं।
— KSFT
ऐसा लगता है कि प्रत्येक ब्लॉक की केवल एक पंक्ति ही प्रिंट होती है।
— xnor
@xnor आप सही कह रहे हैं; मैंने ठीक कर दिया।
— KSFT
2

पायथन 3, 74

def f(a,p=0):n=a.pop(0);exec("print(*'0'*p+'1'*n+'0'*sum(a));"*n);f(a,p+n)
— feersum
स्रोत
क्या यह एक त्रुटि के साथ समाप्त नहीं होता है?
— xnor
@xnor हाँ यह करता है!
— feersum
1
@ Faersum क्या इसकी अनुमति है? मुझे इस मुद्दे पर कोई मेटा पोस्ट नहीं दिख रहा है। आपको क्या लगता है, मार्टिन? यदि इसकी अनुमति है, तो Sp3000 andशॉर्ट-सर्किट से छुटकारा पाकर 6 वर्णों को बचा सकता है ।
— xnor
@xnor क्या प्रोग्राम या केवल फ़ंक्शन कॉल को समाप्त करने में त्रुटि होती है? यदि यह कार्यक्रम समाप्त करता है, तो नहीं, मुझे नहीं लगता कि इसकी अनुमति है। मैंने मेटा पर इस पर अपनी राय व्यक्त की है । मुझे यह भी लगता है कि अगर फ़ेरसुम की राय थी कि यह पूरी तरह से वैध है, तो उन्होंने अपने जवाब में यह उम्मीद करने के बजाय कहा कि कोई भी नोटिस नहीं करेगा।
— मार्टिन एंडर
@ मार्टिनबटनर कार्यक्रम समाप्त करें, अगर मैं समझता हूं कि आप क्या पूछ रहे हैं। यदि आप ऐसा करते हैं f([1,2,3]);print("Done"), तो ब्लॉक मैट्रिक्स को प्रिंट करने के बाद त्रुटि समाप्त हो जाएगी, और इसे "डन" प्रिंटिंग नहीं मिलेगी।
— xnor
2

जावास्क्रिप्ट (ईएस 6), 103 107

एक अनाम फ़ंक्शन के रूप में 103 बाइट्स, गिनती नहीं F=(लेकिन आपको इसे जांचने के लिए इसकी आवश्यकता है)

F=l=>alert(l.map((n,y)=>(l.map((n,x)=>Array(n).fill(x==y|0))+'\n').repeat(n))
.join('').replace(/,/g,' '))

फ़ायरफ़ॉक्स / फायरबग कंसोल में टेस्ट करें

F([5,1,1,2,3,1])

उत्पादन

1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1
— edc65
स्रोत
1

अजगर, ३१ ३०

FbQVbjd++*]0Z*b]b*]0--sQbZ)~Zb

एक सुंदर अनुभवहीन कार्यक्रम, स्टड पर इनपुट लेता है। यह शायद अधिक गोल्फ हो सकता है;)

धन्यवाद @Jakube एक बर्बाद चार की ओर इशारा करने के लिए

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

— FryAmTheEggman
स्रोत
1

पर्ल, 69

#!perl -na
$j=s/./0 x$&/ger;print+($j|$i.1x$_)=~s/\B/ /gr x($i.=0 x$_,$_)for@F

मानक इनपुट का उपयोग करता है:

$ perl a.pl <<<"1 2 3"
1 0 0 0 0 0
0 1 1 0 0 0
0 1 1 0 0 0
0 0 0 1 1 1
0 0 0 1 1 1
0 0 0 1 1 1
— nutki
स्रोत
अजीब बात है, यह मेरे लिए ideone पर newlines नहीं छापता है । इसके अलावा, इस पोस्ट के अनुसार आपको कस्टम शेबंग को 4 बाइट्स के रूप में कोड करना चाहिए, दो नहीं। आप उस शीब का उपयोग न करके, बल्कि दुभाषिया पर झंडे का उपयोग करके और -eएक फ़ाइल के बजाय कोड के साथ कॉल करके ठीक कर सकते हैं (उस मेटा पोस्ट में उदाहरण देखें)। इसके अलावा, मुझे लगता है कि आपको nध्वज की आवश्यकता नहीं है - पेर्डोक के अनुसार, अंतर्निहित रूप से aसेट करता nहै।
— मार्टिन एंडर
कार्यक्रम मानक इनपुट से ईओएल का पुन: उपयोग करता है। जब आप इसे जोड़ते हैं तो आपका आइडोन सेटअप काम करता है। चरित्र की गिनती के लिए, मैं इसे अपने सभी उत्तरों में इस तरह से गिनता हूं, और मैंने दूसरों को भी इस तरह से करते देखा है। मैंने आपके द्वारा पहले पोस्ट को देखा है, लेकिन मुझे इसका अर्थ "अंतर को गिनना perl -nl file.pl" नहीं है। मूल पर्लगुल्फ नियम हाइफ़न की गणना करेंगे लेकिन इस मामले में 3 वर्ण नहीं।
— नटकी
@ मार्टिनबटनर, वैसे भी यह सब बहुत ही कम है क्योंकि रैंडम्रा का दृष्टिकोण बहुत कम समाधान देता है -lna //,print join$",map$'==$_|0,@,for@,=map{(++$i)x$_}@F:। BTW पर्ल का मेरा संस्करण इसके -nसाथ सेट नहीं होता है -a, यह हाल ही में जोड़ा जाना चाहिए।
— नटकी
1

आर, 117 144 137 133 133 129 123 बाइट्स

इस समय यथोचित क्रिया। बाहर कुछ और दाढ़ी बनाने में सक्षम होना चाहिए। यह सही ढंग से स्वरूपित बाइट्स के एक नंबर दिया है, लेकिन एक सरणी के लिए मैट्रिक्स बाहर कुछ गमागमन बचा लिया।

एलेक्स के साथ टिप के लिए एलेक्स के लिए धन्यवाद एस के साथ एसप और फ़ंक्शन नाम को हटा दिया।

सरणी को पूरी तरह से गिरा दिया और प्रत्येक पंक्ति के निर्माण के लिए प्रतिनिधि की एक श्रृंखला का उपयोग किया।

यद्यपि मिफ़ द्वारा ध्वनिपूर्वक पीटा गया, लेकिन उसके समाधान ने मुझे एहसास दिलाया कि मैं पूरी तरह से s = '' छोड़ सकता हूँ।

function(i){s=sum(i);i=cumsum(i);b=0;for(n in 1:s){d=i[i>=n][1];cat(c(rep(0,b),rep(1,d-b),rep(0,s-d)),fill=T);if(d==n)b=d}}

और परीक्षण

> (function(i){s=sum(i);i=cumsum(i);b=0;for(n in 1:s){d=i[i>=n][1];cat(c(rep(0,b),rep(1,d-b),rep(0,s-d)),fill=T,s=' ');if(d==n)b=d}})(c(5,1,1,3,1))
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 1
>
— MickyT
स्रोत
आप फ़ंक्शन मापदंडों के आंशिक मिलान का उपयोग करके 2 बाइट्स बचा सकते हैं। में cat(), परिवर्तन sep=करने के लिए s=के बाद से है कि समारोह के लिए कोई अन्य मान्यता प्राप्त मानकों "एस" के साथ शुरू करते हैं।
— एलेक्स ए।
@ एलेक्स थैंक्स, इसका एहसास नहीं हुआ। फिर भी एक सीखने की अवस्था पर
— मिकी
आप हटाकर एक और 2 बचा सकते हैं f=। यह आपको एक फंक्शन ऑब्जेक्ट देता है। यदि आप ऐसा करते हैं, तो आपको बस यह निर्धारित करना होगा कि इसे f=चलाने से पहले कुछ का उपयोग करके असाइन किया जाए। मुझे एहसास नहीं था कि इस तरह से प्रतियोगिताओं में वैध था जब तक कि मैंने मार्टिन ब्यूटनर को रूबी के साथ ऐसा करते नहीं देखा।
— एलेक्स ए।
1

बैच - 226 बाइट्स

@echo off&setLocal enableDelayedExpansion&set c=0&for %%a in (%*)do set/ac+=1&for /l %%b in (1,1,%%a)do (set l=&set d=0&for %%c in (%*)do (set/ad+=1&for /l %%d in (1,1,%%c)do if !d!==!c! (set l=!l!1)else set l=!l!0)
echo !l!)

स्टडिन ( C:\>script.bat 5 1 1 2 3 1) और इको के आउटपुट से इनपुट लेता है । दुर्भाग्य से मैं एक ही लाइन पर उस अंतिम प्रतिध्वनि को प्राप्त नहीं कर सका, अन्यथा cmd/von/cलंबे समय तक विलंबित विस्तार को सक्षम करने से बचने के लिए शायद मैं पूरी लाइन को कॉल कर सकता था ।

अच्छा और साफ-सुथरा काम और कुछ नहीं:

@echo off
setLocal enableDelayedExpansion
set c=0
for %%a in (%*) do (
    set /a c+=1
    for /l %%b in (1,1,%%a) do (
        set l=
        set d=0
        for %%c in (%*) do (
            set /a d+=1
            for /l %%d in (1,1,%%c) do if !d!==!c! (set l=!l!1) else set l=!l!0
        )
        echo !l!
    )
)
— unclemeat
स्रोत
1

हास्केल, 124

(%)=replicate
d l=fst$foldr(\x(m,n)->(m>>mapM_(\_->putStrLn$unwords$n%"0"++x%"1"++(sum l-n-x)%"0")[1..x],n+x))(return(),0)l

के माध्यम से mapM_और IO कार्यों के संयोजन के द्वारा उत्पादन करता है foldr। फ़ंक्शन dको सूची की सूची दी जानी चाहिए।

— Jmac
स्रोत
1

के (ngn / k) , 10 बाइट्स

{x=\:x:&x}

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

-19 धन्यवाद ngn करने के लिए ... मेरी प्रस्तुत नीचे haha ​​रखते हुए

के (ngn / k) , 29 बाइट्स

{,/d#',:'-':+\[d:x,0]>\:!+/x}

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

संपादित करें: 1-तत्व इनपुट मामले के लिए विराम, काम की जरूरत है

edit1: अब ठीक किया गया। +4 बाइट्स। बू

— घसीट
स्रोत
1
{x=\:x:&x}­­­
— ngn
@ngn ओह चलो ...
— घसीट
इस चुनौती पर apl रूम में चर्चा की गई थी , मुझे पता था कि वहाँ से समाधान :) k और j का यहाँ एक फायदा है क्योंकि उनके "जहाँ" -s ( &k या I.j में) इंट वैक्टर के साथ काम करते हैं, जबकि apl का ⍸कार्य केवल बूलियन्स के साथ होता है। ।
— ngn
1

APL (Dyalog Extended) , 5 बाइट्स

∘.=⍨⍸

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

APL J और K के खिलाफ विस्तारित डोमेन के साथ वापस जीतता है ⍸।

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

∘.=⍨⍸
    ⍸  ⍝ Where; convert to an array that,
       ⍝   for each element n at index i, has n copies of i
∘.=⍨   ⍝ Outer product by element-wise equality on self
— bubbler
स्रोत
0

STATA, 155 बाइट्स

di _r(a)
forv x=1/wordcount($a){
gl b=word($a,`x')
gl c=_N+1
set ob _N+$b
forv y=$c/_N{
g d`y'=_n>=$c
}
}
forv z=1/_N{
replace d`z'=0 if d`z'>1
}
l,noo noh
— bmarks
स्रोत
क्या मैं यह ऑनलाइन कहीं परीक्षण कर सकता हूं?
— मार्टिन एंडर
@ मार्टिनबटनर: जहां तक ​​मुझे पता है, मालिकाना के बाद से कोई ऑनलाइन कंपाइलर नहीं हैं। एसएएस जैसी भाषाओं के लिए समान है।
— एलेक्स ए।
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.