นี่คือรหัสกอล์ฟแบบง่ายๆขนาดกัด (ขนาดไบต์): เนื่องจากรายการจำนวนเต็มบวกที่ไม่ว่างน้อยกว่า 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) จะมีความได้เปรียบที่นี่ แต่ฉันไม่ต้องการที่จะกีดกันผู้คนจากการพยายามทำเช่นเดียวกับที่พวกเขาสามารถทำได้ในภาษาที่พวกเขาเลือก ดังนั้นนี่คือ Stack Snippet เพื่อสร้างทั้งกระดานผู้นำปกติและภาพรวมของผู้ชนะตามภาษา ดังนั้นทำไมไม่ลองและคว้าจุดหลัง?

เพื่อให้แน่ใจว่าคำตอบของคุณปรากฏขึ้นโปรดเริ่มคำตอบด้วยหัวข้อโดยใช้เทมเพลต Markdown ต่อไปนี้:

# Language Name, N bytes

ที่Nมีขนาดของส่งของคุณ หากคุณปรับปรุงคะแนนของคุณคุณสามารถเก็บคะแนนเก่าไว้ในพาดหัวโดยการตีพวกเขาผ่าน ตัวอย่างเช่น

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

function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){$.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(e){answers.push.apply(answers,e.items);if(e.has_more)getAnswers();else process()}})}function shouldHaveHeading(e){var t=false;var n=e.body_markdown.split("\n");try{t|=/^#/.test(e.body_markdown);t|=["-","="].indexOf(n[1][0])>-1;t&=LANGUAGE_REG.test(e.body_markdown)}catch(r){}return t}function shouldHaveScore(e){var t=false;try{t|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(n){}return t}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading);answers.sort(function(e,t){var n=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0],r=+(t.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0];return n-r});var e={};var t=0,c=0,p=-1;answers.forEach(function(n){var r=n.body_markdown.split("\n")[0];var i=$("#answer-template").html();var s=r.match(NUMBER_REG)[0];var o=(r.match(SIZE_REG)||[0])[0];var u=r.match(LANGUAGE_REG)[1];var a=getAuthorName(n);t++;c=p==o?c:t;i=i.replace("{{PLACE}}",c+".").replace("{{NAME}}",a).replace("{{LANGUAGE}}",u).replace("{{SIZE}}",o).replace("{{LINK}}",n.share_link);i=$(i);p=o;$("#answers").append(i);e[u]=e[u]||{lang:u,user:a,size:o,link:n.share_link}});var n=[];for(var r in e)if(e.hasOwnProperty(r))n.push(e[r]);n.sort(function(e,t){if(e.lang>t.lang)return 1;if(e.lang<t.lang)return-1;return 0});for(var i=0;i<n.length;++i){var s=$("#language-template").html();var r=n[i];s=s.replace("{{LANGUAGE}}",r.lang).replace("{{NAME}}",r.user).replace("{{SIZE}}",r.size).replace("{{LINK}}",r.link);s=$(s);$("#languages").append(s)}}var QUESTION_ID=45550;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/;var NUMBER_REG=/\d+/;var LANGUAGE_REG=/^#*\s*([^,]+)/

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js></script><link rel=stylesheet type=text/css href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id=answer-list><h2>Leaderboard</h2><table class=answer-list><thead><tr><td></td><td>Author<td>Language<td>Size<tbody id=answers></table></div><div id=language-list><h2>Winners by Language</h2><table class=language-list><thead><tr><td>Language<td>User<td>Score<tbody id=languages></table></div><table style=display:none><tbody id=answer-template><tr><td>{{PLACE}}</td><td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table><table style=display:none><tbody id=language-template><tr><td>{{LANGUAGE}}<td>{{NAME}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table>

J, 7 ไบต์

ขอบคุณสำหรับFUZxxlสำหรับการปรับปรุง 2 ไบต์

ภาษาที่ใช้อาร์เรย์ควรนับที่นี่ในการแข่งขันที่แตกต่างกันเนื่องจากมีข้อได้เปรียบอย่างมาก :)

   =/~@#<\

   (=/~@#<\) 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 20 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│
└─┴─┴─┴───┴─────┴───────┴───────┘

ด้วย=/~คำกริยาที่เราสร้างตารางของผลิตภัณฑ์ Descartes คำนำหน้ากล่องเหล่านี้และแต่ละเซลล์จะเป็น1ถ้าทั้งสองรายการมีค่าเท่ากัน0เป็นอย่างอื่น

APL, 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

คำอธิบาย:

• ∆←⎕: ∆อ่านเข้าจัดเก็บใน
• ⍋∆: ค้นหาการเรียงสับเปลี่ยนที่∆( เรียงตามนี้จะให้ค่าที่ไม่ซ้ำกันสำหรับแต่ละค่าในอินพุต)
• ∆/: สำหรับค่าที่ไม่ซ้ำแต่ละค่าให้ทำซ้ำNครั้งโดยที่Nค่าที่สอดคล้องกันในอินพุต
• ∘.=⍨: ทำให้เมทริกซ์ทำการเปรียบเทียบแต่ละค่าในรายการนั้นกับค่าอื่น ๆ

R, 69 63

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 สำหรับความช่วยเหลือของเขา

Python 3, 103 97 82 78 76 ไบต์

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ด้วยบิตของการเรียกซ้ำ

Ruby, 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

แก้ไข:

ขอบคุณ Martin Büttnerที่ช่วยฉันย่อบางสิ่ง!

Matlab, 60 54 ไบต์

นี่จะเป็นเขตพิเศษของ Matlab ถ้าเราสามารถใช้ฟังก์ชั่น builtin ...

ขอบคุณ @sanchises สำหรับการแก้ไขข้อผิดพลาดที่ฉันพลาด

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

Matlab, 53 ไบต์

แม้ว่าจะมีเพียงตัวอักษรตัวเดียวที่สั้นกว่าส่วน Matlab อื่น ๆ แต่ฉันคิดว่ารหัสนั้นแตกต่างกันมากพอที่จะรับประกันคำตอบใหม่:

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

เคล็ดลับหลักของหลักสูตรคือการทำดัชนีนอกขอบเขต แต่รวมกับการใช้endเป็นตัวแปรเพื่อให้กะทัดรัดยิ่งขึ้น

CJam, 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

Python 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)เป็นสิ่งจำเป็นที่ต้องทำ

Haskell, 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

Pyth, 23 21 ไบต์

ที่เก็บ GitHub สำหรับ Pyth

Ju+G*]GHQYFNJjdmsqdNJ

[3, 1, 1, 2]ป้อนข้อมูลคือรายการของจำนวนเต็มเช่น ลองใช้งานออนไลน์: Pyth Compiler / Executor

ใช้แนวคิดที่ค่อนข้างคล้ายกันกับรหัส J ของ randomra ส่วนแรกของรหัส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)

C ++, 294 ไบต์

ใช้คอมไพเลอร์ - GCC 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";
    }
}

K, 30 ไบต์

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

โดยพื้นฐานแล้วขโมยคำตอบของ marinus

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

Java, 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;}}

Consumer ที่รับรายการจำนวนเต็ม

รุ่นที่อ่านได้พร้อมด้วยรหัสสำเร็จรูป:

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);

Python 2, 163 114 ไบต์

gnibbler golfed พวงนี้

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]))

Python 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)

JavaScript (ES6) 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,' '))

การทดสอบใน Firefox / คอนโซล FireBug

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

คู่, 49 41 ไบต์

@(a)(c=repelems(b=1:length(a),[b;a]))'==c

Pyth, 31 30

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

โปรแกรมที่ไร้เดียงสาสวยรับอินพุตบน stdin สิ่งนี้อาจจะสามารถเล่นกอล์ฟได้มากขึ้น;)

ขอบคุณ @Jakube ที่ชี้ให้เห็นว่าถ่านที่สูญเปล่า

ลองที่นี่

Perl, 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

R, 117 144 137 133 129 123 ไบต์

พูดอย่างมีเหตุผลในขณะนี้ ควรจะสามารถโกนหนวดออกมาได้อีกไม่กี่ รับจำนวนไบต์การจัดรูปแบบที่ถูกต้อง แต่บันทึกการแลกเปลี่ยนเมทริกซ์สำหรับอาร์เรย์

ขอบคุณ Alex สำหรับคำแนะนำในการแทนที่ sep ด้วย s และลบชื่อฟังก์ชัน

วางอาร์เรย์ลงอย่างสมบูรณ์และใช้ชุดตัวแทนเพื่อสร้างแต่ละบรรทัด

แม้ว่า Miff จะถูกทุบตีอย่างสมบูรณ์ แต่วิธีการแก้ปัญหาของเขาทำให้ฉันรู้ว่าฉันสามารถดรอป 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
> 

รุ่นที่ - 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!)

รับอินพุตจาก stdin ( C:\>script.bat 5 1 1 2 3 1) และเอาต์พุตของ echo น่าเสียดายที่ฉันไม่สามารถรับเสียงสะท้อนสุดท้ายในบรรทัดเดียวกันไม่เช่นนั้นฉันอาจโทรไปที่ทั้งบรรทัดภายใน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!
    )
)

Haskell, 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

ผลิตออกโดยการรวมการกระทำ IO ผ่านและmapM_ foldrฟังก์ชั่นdควรได้รับรายชื่อของ ints

K (ngn / k) , 10 ไบต์

{x=\:x:&x}

ลองออนไลน์!

-19 ขอบคุณที่ ngn ... ทำให้การส่งของฉันต่ำกว่าฮ่าฮ่า

K (ngn / k) , 29 ไบต์

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

ลองออนไลน์!

แก้ไข: ตัวแบ่งสำหรับกรณีอินพุต 1 องค์ประกอบต้องการงาน

edit1: แก้ไขแล้ว +4 ไบต์ หุยฮา

APL (ขยาย Dyalog) 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

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

เยลลี่ขนาด 7 ไบต์

ĖŒṙ⁼þ`G

ลองออนไลน์!

วิธีการเช่นเดียวกับคำตอบ J

      G    Grid format
   ⁼þ      a table of whether or not pairs of elements are equal, from
 Œṙ        the run-length decoded
Ė          enumeration of the input,
     `     compared with itself.