27

Dưới đây là một golf mã đơn giản, có kích thước cắn (cỡ byte?): Đưa ra một danh sách các số nguyên dương không nhỏ hơn 10, in một ma trận khối chéo , trong đó danh sách chỉ định kích thước của các khối, theo thứ tự. Các khối phải bao gồm các số nguyên dương nhỏ hơn 10. Vì vậy, nếu bạn được cung cấp làm đầu vào

[5 1 1 2 3 1]

Đầu ra của bạn có thể là, ví dụ,

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

hoặc là

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

hoặc điều tương tự. Các phần tử trong ma trận phải được phân tách bằng dấu cách (đơn) và các hàng được phân tách bằng dòng mới (đơn). Không được có dấu cách hàng đầu hoặc dấu trên bất kỳ dòng nào. Bạn có thể hoặc không thể in một dòng mới.

Bạn có thể viết một hàm hoặc chương trình, lấy đầu vào qua STDIN (hoặc thay thế gần nhất), đối số dòng lệnh hoặc đối số hàm, trong bất kỳ định dạng chuỗi hoặc danh sách thuận tiện (miễn là nó không được xử lý trước). Tuy nhiên, kết quả phải được in thành STDOUT (hoặc thay thế gần nhất), trái ngược với trả về từ một hàm, nói.

Bạn không được sử dụng bất kỳ hàm dựng sẵn nào được thiết kế để tạo ma trận khối chéo.

Đây là mã golf, vì vậy bài nộp ngắn nhất (tính bằng byte) sẽ thắng.

Bảng xếp hạng

Tôi hy vọng các ngôn ngữ dựa trên mảng (như J và APL) sẽ có lợi thế ở đây, nhưng tôi không muốn điều đó ngăn cản mọi người cố gắng làm tốt nhất có thể bằng ngôn ngữ họ chọn. Vì vậy, đây là một Snippet Stack để tạo cả bảng xếp hạng thông thường và tổng quan về người chiến thắng theo ngôn ngữ. Vì vậy, tại sao không thử và lấy một vị trí trên sau này?

Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu câu trả lời của bạn bằng một tiêu đề, sử dụng mẫu Markdown sau:

# Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

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

Hiển thị đoạn mã

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>

Expand snippet

code-golf array-manipulation

— Martin Ender
nguồn

20

J, 7 byte

Cảm ơn FUZxxl vì đã cải thiện 2 byte.

Các ngôn ngữ dựa trên mảng nên được tính ở đây trong một cuộc cạnh tranh khác vì chúng có lợi thế rất lớn. :)

   =/~@#<\

   (=/~@#<\) 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

Một cách tiếp cận 7 byte khác:

#]=@##\

Giải thích cho phiên bản cũ ([:=/~]#<\):

Bước đầu tiên là tạo ra nnhững thứ tương tự (ví dụ số) cho mọi thành phần danh sách n. Chúng nên khác với các yếu tố khác '. Ví dụ, sử dụng các số tự nhiên 3 1 1 2trở thành 0 0 0 1 2 3 3.

Để tiết kiệm byte, chúng tôi sử dụng các tiền tố đóng hộp của danh sách:

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

Với =/~động từ, chúng ta tạo một bảng các sản phẩm Descartes của các tiền tố được đóng hộp này và mỗi ô sẽ là 1nếu hai mục nhập khác nhau 0.

— ngẫu nhiên
nguồn

2

Tôi không nghĩ các dấu ngoặc đơn xung quanh [:=/~]#<\ tính vào điểm số của bạn. Ngoài ra, =/~@#<\ cho hai byte thêm cạo đi.

— FUZxxl

"Tuy nhiên, kết quả phải được in thành STDOUT (hoặc thay thế gần nhất), trái ngược với trả về từ một hàm, nói ." Bạn có thể cần đầu vào rõ ràng (vì vậy nó không chỉ là một chức năng) hoặc đầu ra rõ ràng.

— bến tàu

@marinus J in kết quả của một biểu thức thành thiết bị xuất chuẩn nếu nó không bị ràng buộc với một biến.

— FUZxxl

@FUZxxl: có, nhưng (=/~@#<\)chỉ là một chức năng. Bạn thực sự phải áp dụng nó cho một cái gì đó để có được một biểu thức, vì vậy bạn cần nhập liệu rõ ràng ( ".1!:1[1) hoặc nếu bạn muốn gửi một hàm, hàm đó thực sự nên in giá trị và không chỉ trả về nó (như echo@hoặc một cái gì đó ).

— bến tàu

=/~&I.

— ngn

11

APL, 10

∘.=⍨∆/⍋∆←⎕

Thí dụ:

      ∘.=⍨∆/⍋∆←⎕
⎕:
      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

Giải trình:

∆←⎕: đọc đầu vào, lưu trữ trong ∆.
⍋∆: tìm hoán vị sắp xếp ∆(điều này mang lại một giá trị duy nhất cho mỗi giá trị trong đầu vào)
∆/: đối với mỗi giá trị duy nhất đó, lặp lại Nlần đó , Ngiá trị tương ứng trong đầu vào là bao nhiêu
∘.=⍨: tạo một ma trận so sánh từng giá trị trong danh sách đó với các giá trị khác.

— bến cảng
nguồn

Để kiểm tra điều này http://tryapl.org, bạn có thể muốn sử dụng dfn {∘.=⍨⍵/⍋⍵}, vì trang web lọc tất cả các cách sử dụng ⎕(ngoại trừ ⎕IOvà những thứ tương tự).

— FUZxxl

1

@FUZxxl: thông báo "Tuy nhiên, kết quả phải được in thành STDOUT (hoặc thay thế gần nhất), trái ngược với trả về từ một hàm, giả sử .", Vì vậy {∘.=⍨⍵/⍋⍵}không hợp lệ. Bạn cần {⎕←∘.=⍨⍵/⍋⍵}, không chỉ tốn hai ký tự mà vẫn không hoạt động trên TryAPL. (Và nói chung, TryAPL là quá giới hạn có ích.)

— marinus

Nếu nó phải in ra kết quả, ⎕←dù sao bạn cũng không cần đến dfn?

— FUZxxl

@FUZxxl: không, đầu ra của một biểu thức được in tự động nếu không có gì khác được thực hiện với nó.

— bến tàu

Ah tôi thấy. Tôi có ấn tượng rằng điều này chỉ xảy ra khi bạn đang sử dụng trình thông dịch tương tác.

— FUZxxl

8

R, 69 63

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

Trường hợp thử nghiệm:

(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

Hàm bên ngoài thực hiện hầu hết các công việc ở đây, sau đó chỉ là trường hợp để đầu ra trông ổn - Cảm ơn @Vlo vì sự giúp đỡ của anh ấy với điều đó

— Miff
nguồn

Giải pháp rất hay

— MickyT

Giải pháp tuyệt vời. Không bao giờ nghĩ về việc sử dụng -/+để ép buộc logic. Lưu một vài byte function(x)write(+outer(i<-rep(1:length(x),x),i,"=="),1,sum(x))63

— Vlo

6

Python 3, 103 97 82 78 76 byte

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

Sử dụng splat để tận dụng tính chất phân tách không gian của print, với một chút đệ quy.

— Sp3000
nguồn

6

Ruby, 86 90 83 byte

Golf đầu tiên của tôi bao giờ hết!

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

Nhận một mảng với các số nguyên, in kết quả mong đợi:

$ (->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

Chỉnh sửa:

Cảm ơn Martin Büttner đã giúp tôi rút ngắn một số điều!

— rorlork
nguồn

1

Bạn có thể lưu thêm một số ký tự: ->(l)có thể ->l. mapngắn hơn each. .join(" ")có thể rút ngắn thành *" ".

— Martin Ender

6

Matlab, 60 54 byte

Đây sẽ là trường đặc biệt của Matlab NẾU chúng ta có thể sử dụng các hàm dựng sẵn ...

Cảm ơn @sanchises đã sửa lỗi tôi bỏ qua.

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

— lỗ hổng
nguồn

Wooow, đến bây giờ tôi mới nhận thấy đoạn trích js này thực sự tạo ra một bảng xếp hạng !!! Làm thế nào tôi không bao giờ nhận thấy điều này ??? Cảm ơn bạn đã chỉ ra điều này =)

— flawr 10/2/2015

Tôi biết, phải không? Nó thực sự rất ngầu!

— Alex A.

1

Tôi chuẩn bị đăng gần như cùng một câu trả lời :-)

— Luis Mendo 10/2/2015

Chính xác giống nhau hoặc một cái gì đó hơi khác nhau? =) (Ngoài tên biến.)

— flawr

Quá giống tôi để đăng nó :-)

— Luis Mendo

6

Matlab, 53 byte

Mặc dù nó chỉ ngắn hơn một char so với đoạn Matlab khác, tôi nghĩ rằng mã này đủ khác nhau để đảm bảo một câu trả lời mới:

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

Thủ thuật chính tất nhiên là nằm ngoài giới hạn chỉ mục, nhưng điều này được kết hợp với việc sử dụng endnhư một biến để làm cho nó nhỏ gọn hơn.

— Dennis Jaheruddin
nguồn

1

Chết tiệt - Tôi đã dành nửa giờ để chơi golf end+1:end+vđể thoát khỏi biến số 'truy cập' và tôi đã không nghĩ đến giải pháp này.

— Sanchise 12/2/2015

Thật vậy, như @Geobits đã đề cập đến việc chỉnh sửa đã cố gắng bởi một người ẩn danh thành blkdiagvi phạm các yêu cầu. Chỉ để tham khảo tôi sẽ đặt cốt lõi của nó ở đây bằng mọi cách:blkdiag(A,ones(i))

— Dennis Jaheruddin

4

CJam, 21

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

Dùng thử tại http://cjam.aditsu.net/

Giải trình:

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
nguồn

4

Trăn 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)

Theo dõi chỉ số ngoài cùng bên trái của khối như svà thực hiện các xmục sau nó 1, xkích thước khối hiện tại. Hàng này sau đó được in xlần. Python 3 là cần thiết để làm print(*r).

— xnor
nguồn

Đó là một char ngắn hơn để chỉ thể hiện rnhư [0]*s+[1]*x+[0]*(sum(l)-s-x), nhưng tôi vẫn đang tìm kiếm một cách tốt hơn.

— xnor

4

Haskell, 118 116 byte

(#)=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

Sử dụng: f [2,1,1,3]

Đầu ra:

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

Làm thế nào nó hoạt động:

[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
nguồn

Bạn có thể lưu hai byte bằng cách thực hiện (h,e:t)<-map(`splitAt`i)[0..length i-1], vì nkhông được sử dụng bên ngoài letliên kết.

— Zgarb

@Zgarb: tìm thấy tốt đẹp. Cảm ơn!

— nimi

3

Pyth, 23 21 byte

Kho GitHub cho Pyth

Ju+G*]GHQYFNJjdmsqdNJ

Đầu vào là một danh sách các số nguyên, như [3, 1, 1, 2]. Dùng thử trực tuyến: Trình biên dịch / thực thi Pyth

Sử dụng một ý tưởng khá giống như mã J của Randomra. Phần đầu tiên của mã Ju+G*]GHQYtạo ra ncác phần của những thứ tương tự. Đối với ví dụ đầu vào [3, 1, 1, 2], kết quả trông như thế này:

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

Đầu tiên ba phần tử giống nhau, hơn một phần tử, sau đó một phần tử một lần nữa và ở cuối hai phần tử giống hệt nhau.

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

Phần thứ hai của mã là so sánh các yếu tố của sản phẩm Cartesian và in nó.

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
nguồn

3

C ++, 294 byte

Trình biên dịch được sử dụng - 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";}}

Giải trình -:

#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";
    }
}

— Anmol Singh Jaggi
nguồn

3

K, 30 byte

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

Về cơ bản đã đánh cắp câu trả lời của bến

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
nguồn

2

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

Một người tiêu dùng chấp nhận một danh sách các số nguyên.

Phiên bản có thể đọc được, với mã soạn sẵn:

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

Gọi bằng cách sử dụng:

List list = Arrays.asList(5, 1, 1, 2, 3, 1);
c.accept(list);

— Ypnypn
nguồn

2

Python 2, 163 114 byte

gnibbler chơi golf này một bó.

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
nguồn

3

làm thế nào về print" ".join("01"[i==j]for j in r(l(h))for x in r(h[j]))?

— gnibbler

A ha ! Tôi nghĩ rằng tôi có thể làm một cái gì đó như thế.

— KSFT

Điều này dường như chỉ in một hàng của mỗi khối.

— xnor

@xnor Bạn nói đúng; Tôi sửa nó rồi.

— KSFT

2

Trăn 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)

— feerum
nguồn

Điều này không chấm dứt với một lỗi?

— xnor

@xnor đúng vậy!

— frageum

1

@feersum Được phép chưa? Tôi không thấy bất kỳ bài viết meta về vấn đề này. Bạn nghĩ gì, Martin? Nếu được phép, Sp3000 có thể lưu 6 ký tự bằng cách loại bỏ andngắn mạch.

— xnor 11/2/2015

@xnor Lỗi có chấm dứt chương trình hay chỉ gọi hàm? Nếu điều này chấm dứt chương trình, thì tôi không nghĩ nó được cho phép. Tôi đã bày tỏ ý kiến của tôi về điều này ở đây trên meta . Tôi cũng nghĩ rằng nếu feerum có ý kiến rằng điều này là hoàn toàn hợp pháp, anh ta sẽ nói điều đó trong câu trả lời của mình thay vì hy vọng rằng không ai thông báo.

— Martin Ender

@ MartinBüttner Kết thúc chương trình, nếu tôi hiểu bạn đang hỏi gì. Nếu bạn phải làm như vậy f([1,2,3]);print("Done"), lỗi sẽ kết thúc chương trình sau khi nó in ma trận khối và nó sẽ không được in "Xong".

— xnor

2

JavaScript (ES6), 103 107

103 byte là một hàm ẩn danh, không tính F=(nhưng bạn cần điều này để kiểm tra nó)

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

Kiểm tra trong bảng điều khiển Firefox / FireBug

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

Đầu ra

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
nguồn

2

Octave, 49 41 byte

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

— alephalpha
nguồn

1

Bình thường, 31 30

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

Một chương trình khá ngây thơ, lấy đầu vào trên stdin. Điều này có thể được đánh gôn nhiều hơn;)

Cảm ơn @Jakube đã chỉ ra một char lãng phí

Hãy thử nó ở đây

— FryAmTheEggman
nguồn

1

Perl, 69

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

Sử dụng đầu vào tiêu chuẩn:

$ 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

— hạt dẻ
nguồn

kỳ lạ thay, điều này không in dòng mới cho tôi trên ideone . Ngoài ra, theo bài đăng này, bạn nên mã shebang tùy chỉnh là 4 byte, không phải hai. bạn có thể khắc phục điều đó bằng cách không sử dụng shebag mà thay vào đó là sử dụng các cờ trên trình thông dịch và gọi mã -ethay vì từ một tệp (xem ví dụ trong bài đăng meta đó). Ngoài ra, tôi nghĩ rằng bạn không cần ncờ - theo perldoc, ađặt nngầm.

— Martin Ender

Chương trình sử dụng lại eol từ đầu vào tiêu chuẩn. Thiết lập ideone của bạn hoạt động khi bạn thêm nó. Về số lượng nhân vật, tôi đếm theo cách này trong tất cả các câu trả lời của mình và tôi cũng đã thấy những người khác cũng làm theo cách này. Tôi đã thấy bài đăng bạn liên kết trước đây, nhưng tôi không hiểu ý nghĩa của nó bằng cách "đếm sự khác biệt perl -nl file.pl". Các quy tắc perlgolf ban đầu sẽ đếm dấu gạch nối nhưng không có khoảng trắng nên 3 ký tự trong trường hợp này.

— nutki

@ MartinBüttner, dù sao thì đó cũng là tất cả vì cách tiếp cận của Randomra đưa ra giải pháp ngắn hơn nhiều : -lna //,print join$",map$'==$_|0,@,for@,=map{(++$i)x$_}@F. BTW phiên bản của tôi về Perl không thiết lập -nvới -a, nó phải là một bổ sung gần đây.

— nutki

1

R, 117 144 137 133 129 123 byte

Hợp lý dài dòng tại thời điểm này. Nên có thể cạo thêm vài cái ra. Đạt được một số byte định dạng chính xác, nhưng đã lưu một số hoán đổi ma trận cho một mảng.

Cảm ơn Alex về mẹo trên sep thay thế bằng s và xóa tên hàm.

Bỏ hoàn toàn mảng và sử dụng một loạt các đại diện để xây dựng mỗi dòng.

Mặc dù bị Miff đánh đập mạnh mẽ, nhưng giải pháp của anh ta khiến tôi nhận ra mình có thể bỏ s = '' hoàn toàn.

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}}

Và bài kiểm tra

> (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
nguồn

Bạn có thể lưu 2 byte bằng cách sử dụng khớp một phần các tham số hàm. Trong cat(), thay đổi sep=thành s=vì không có tham số được nhận dạng nào khác cho chức năng đó bắt đầu bằng "s".

— Alex A.

@Alex Cảm ơn, đã không nhận ra điều đó. Vẫn đang trên đường học tập

— MickyT

Bạn có thể lưu thêm 2 bằng cách loại bỏ f=. Điều này cung cấp cho bạn một đối tượng chức năng. Nếu bạn làm điều đó, bạn chỉ cần quy định rằng nó được chỉ định sử dụng một cái gì đó như f=trước khi chạy nó. Tôi đã không nhận ra rằng đó là hợp pháp trong các cuộc thi như thế này cho đến khi tôi thấy Martin Büttner làm điều đó với Ruby.

— Alex A.

1

Mẻ - 226 byte

@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!)

Lấy đầu vào từ đầu ra stdin ( C:\>script.bat 5 1 1 2 3 1) và echo. Thật không may, tôi không thể có được tiếng vang cuối cùng trên cùng một dòng, nếu không tôi có thể gọi toàn bộ dòng bên trong cmd/von/cđể tránh phải mở rộng chậm trễ trong thời gian dài.

Đẹp và gọn gàng - không có gì ngoài công việc lẩm bẩm:

@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!
    )
)

— không mặc quần áo
nguồn

1

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

Tạo đầu ra bằng cách kết hợp các hành động IO thông qua mapM_và foldr. Hàm dnên được đưa ra một danh sách các số nguyên.

— Jmac
nguồn

1

K (ngn / k) , 10 byte

{x=\:x:&x}

Hãy thử trực tuyến!

-19 cảm ơn ngn ... giữ bài nộp của tôi dưới đây haha

K (ngn / k) , 29 byte

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

Hãy thử trực tuyến!

chỉnh sửa: ngắt cho trường hợp đầu vào 1 phần tử, cần làm việc

chỉnh sửa1: hiện đã được sửa. +4 byte. boo

— nguệch ngoạc
nguồn

1

{x=\:x:&x}

— ngn

@ngn oh thôi nào ...

— nguệch ngoạc

Thử thách này đã được thảo luận trong phòng apl , tôi biết giải pháp từ đó :) k và j có lợi thế ở đây vì "where" -s ( &in k hoặc I.in j) của chúng hoạt động với vectơ int, trong khi apl ⍸chỉ hoạt động với booleans .

— ngn

1

APL (Dyalog mở rộng) , 5 byte

∘.=⍨⍸

Hãy thử trực tuyến!

APL giành chiến thắng trước J và K với tên miền mở rộng cho ⍸.

Làm thế nào nó hoạt động

∘.=⍨⍸
    ⍸  ⍝ 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

— Bong bóng
nguồn

0

STATA, 155 byte

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

— đánh dấu
nguồn

Tôi có thể kiểm tra điều này trực tuyến ở đâu đó không?

— Martin Ender

@ MartinBüttner: Theo tôi biết, không có trình biên dịch trực tuyến nào cho Stata vì nó là độc quyền. Các ngôn ngữ như SAS cũng vậy.

— Alex A.

0

Thạch , 7 byte

ĖŒṙ⁼þ`G

Hãy thử trực tuyến!

Cách tiếp cận tương tự như câu trả lời 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.

— Chuỗi không liên quan
nguồn

In một ma trận khối chéo

Bảng xếp hạng

J, 7 byte

APL, 10

R, 69 63

Python 3, 103 97 82 78 76 byte

Ruby, 86 90 83 byte

Matlab, 60 54 byte

Matlab, 53 byte

CJam, 21

Trăn 3, 79

Haskell, 118 116 byte

Pyth, 23 21 byte

C ++, 294 byte

K, 30 byte

Java, 163

Python 2, 163 114 byte

Trăn 3, 74

JavaScript (ES6), 103 107

Octave, 49 41 byte

Bình thường, 31 30

Perl, 69

R, 117 144 137 133 129 123 byte

Mẻ - 226 byte

Haskell, 124

K (ngn / k) , 10 byte

K (ngn / k) , 29 byte

APL (Dyalog mở rộng) , 5 byte

Làm thế nào nó hoạt động

STATA, 155 byte

Thạch , 7 byte