İşte basit, ısırık büyüklüğünde (bayt büyüklüğünde?) Bir kod golf: 10'dan küçük olmayan pozitif tamsayıların boş bir listesi verildiğinde, listenin blokların boyutunu sırayla belirttiği bir blok çapraz matrisi yazdırın . Bloklar, 10'dan küçük pozitif tamsayılardan oluşmalıdır.

[5 1 1 2 3 1]

Çıktınız, örneğin,

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

veya

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

ya da böyle bir şey. Matristeki öğeler (tek) boşluklarla ve satırlar (tek) yeni çizgilerle ayrılmalıdır. Herhangi bir satırda ana veya sonda boşluk olmamalıdır. İzleyen bir newline yazdırabilir veya basmayabilirsiniz.

STDIN (ya da en yakın alternatif), komut satırı argümanı ya da işlev argümanı yoluyla herhangi bir uygun dize ya da liste formatında (önceden işlenmediği sürece) giriş alarak bir işlev ya da program yazabilirsiniz. Bununla birlikte, sonuç bir fonksiyondan döndürülmek yerine, STDOUT'a (veya en yakın alternatife) yazdırılmalıdır.

Blok-diyagonal matrisler oluşturmak için tasarlanmış herhangi bir yerleşik işlevi kullanmamalısınız.

Bu kod golf, yani en kısa gönderme (bayt cinsinden) kazanır.

Liderler

Dizi tabanlı dillerin (J ve APL gibi) burada üstünlük kazanmasını bekliyorum, ancak insanların kendi seçtikleri dilde olduğu gibi yapmayı denemelerini engellemelerini istemiyorum. Yani burada hem düzenli bir lider tablosu hem de kazananların dile göre genel bir bakış oluşturması için bir Stack Snippet var. Öyleyse neden ikincisinde bir nokta yakalamaya çalışmıyorsunuz?

Cevabınızın göründüğünden emin olmak için, lütfen aşağıdaki Markdown şablonunu kullanarak cevabınızı bir başlık ile başlatın:

# Language Name, N bytes

Gönderinizin Nbüyüklüğü nerede ? Puanınızı artırmak varsa, olabilir onları içinden vurarak, başlığa eski hesapları tutmak. Örneğin:

# 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 bayt

2 baytlık iyileştirme için FUZxxl için teşekkürler .

Dizi tabanlı diller burada büyük bir avantaja sahip oldukları için farklı bir yarışmada sayılmalıdır. :)

   =/~@#<\

   (=/~@#<\) 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 baytlık başka bir yaklaşım:

#]=@##\

Eski versiyonun açıklaması ([:=/~]#<\):

İlk adım, nher liste elemanı için benzer şeyler (örneğin sayılar) üretmektir n. Bunlar diğer unsurlardan farklı olmalı. Örneğin, doğal sayıları kullanarak 3 1 1 2olur 0 0 0 1 2 3 3.

Baytlardan tasarruf etmek için, listedeki kutulu önekleri kullanırız:

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

İle =/~fiil bu kutulu prefix'lerin Descartes ürünlerinin bir tablo oluşturun ve her bir hücre olacak 1iki girdi eşitse 0aksi.

APL, 10

∘.=⍨∆/⍋∆←⎕

Örnek:

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

Açıklama:

• ∆←⎕: girişi okuyun, saklayın ∆.
• ⍋∆: sıralayan permitasyonunu bul ∆(bu, girdideki her değer için benzersiz bir değer verir)
• ∆/: bu benzersiz değerlerin her biri için , girişindeki karşılık gelen değerin Nolduğu zamanları tekrarlayınN
• ∘.=⍨: Bu listedeki her değeri diğer değerlerle karşılaştırarak bir matris yapın.

R, 69 63

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

Test durumu:

(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

Dış işlev, burada işin çoğunu yapıyor, sonra çıktının doğru görünmesini sağlamak için bir durum - Bu konuda yaptığı yardım için @Vlo'ya teşekkürler

Python 3, 103 97 82 78 76 bayt

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

Uzayı ayıran doğanın avantajlarından yararlanmak için, printbir parça özyinelemeyle uyarının kullanılması.

Ruby, 86 90 83 bayt

Benim ilk golfüm!

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

Tamsayılarla bir dizi alır, beklenen sonucu yazdırır:

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

Düzenle:

Bazı şeyleri kısaltmama yardım ettiği için Martin Büttner'e teşekkürler!

Matlab, 60 54 bayt

Bu Matlab'ın özel alanını olacağını EĞER biz fonksiyonları yerleşik kullanabilirsiniz ...

Kaçırdığım hatayı düzeltmek için teşekkür @sanchises.

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

Matlab, 53 bayt

Diğer Matlab parçasından sadece bir karakter daha kısa olmasına rağmen, kodun yeni bir cevap alabilmek için yeterince farklı olduğunu düşündüm:

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

Asıl püf noktası elbette sınır indeksleme dışında, ama bu enddaha küçük hale getirmek için değişken olarak kullanmakla birleştiriliyor .

CJam, 21

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

Http://cjam.aditsu.net/ adresinde deneyin

Açıklama:

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)

Bloğun en solundaki dizini olduğu gibi izler ve girişleri geçerli blok büyüklüğünün olduğu yerde syapar . Bu satır daha sonra kez yazdırılır . Python 3 yapmak için gereklidir .x1xxprint(*r)

Haskell, 118 116 bayt

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

Kullanımı: f [2,1,1,3]

Çıktı:

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

Nasıl çalışır:

[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 bayt

Pyth için GitHub deposu

Ju+G*]GHQYFNJjdmsqdNJ

Giriş, gibi bir tamsayı listesidir [3, 1, 1, 2]. Çevrimiçi deneyin: Pyth Compiler / Executor

Randomra'nın J kodu olarak oldukça benzer bir fikir kullanır. Kodun ilk bölümü benzer şeylerin bölümlerini Ju+G*]GHQYoluşturur n. Örnek giriş [3, 1, 1, 2]için sonuç şöyle görünür:

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

Önce üç özdeş eleman, bir eleman, sonra bir eleman tekrar ve sonunda iki özdeş eleman.

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

Kodun ikinci kısmı, Kartezyen ürününün elemanlarının karşılaştırılması ve basılmasıdır.

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 bayt

Derleyici kullanılmış - 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";}}

Açıklama -:

#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 bayt

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

Temelde marinus'un cevabını çaldı

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

Bir tamsayı listesini kabul eden bir tüketici.

Kazan kodu ile okunabilen versiyon:

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

Kullanmaya davet et:

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

Python 2,163 114 bayt

Gnibbler bunu bir demet attı.

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

Adsız bir işlev olarak 103 bayt, sayılmıyor F=(ancak bunu sınamak için buna ihtiyacınız var)

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 konsolunda test edin

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

Çıktı

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

Octave, 49 41 bayt

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

Pyth, 31 30

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

Oldukça naif bir program, stdin girişini alıyor. Bu muhtemelen daha fazla golf olabilir;)

Harcanan bir karaktere işaret ettiğiniz için teşekkürler @Jakube

Burada dene

Perl, 69

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

Standart girdi kullanır:

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

Şu anda oldukça ayrıntılı. Birkaç tane daha tıraş edebilmelisin. Doğru şekilde biçimlendiren birkaç bayt kazanıldı, ancak bir dizinin matrisini değiştirerek bazılarını kurtardı.

Sep'in s ile değiştirilmesi ve işlev isminin kaldırılmasıyla ilgili ipucu için Alex'e teşekkür ederiz.

Diziyi tamamen düşürdüm ve her satırı oluşturmak için bir dizi tekrar kullandım.

Her ne kadar Miff tarafından iyice dövülmüş olsa da, çözümü s = '' yi tamamen düşürebileceğimin farkına varmamı sağladı.

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

Ve test

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

Toplu İş - 226 Bayt

@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) ve echo'nun çıktısından girdi alır . Maalesef, aynı son satırdaki son yankıyı alamadım, aksi halde cmd/von/c, uzun bir gecikmeyi geciktirmeyi mümkün kılmaktan kaçınmak için muhtemelen tüm çizgiyi arayabilirim .

Güzel ve temiz - kaba iş dışında hiçbir şey:

@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 eylemlerini mapM_ve ile birleştirerek çıktı üretir foldr. Fonksiyon dints listesi verilmelidir.

K (ngn / k) , 10 bayt

{x=\:x:&x}

Çevrimiçi deneyin!

-19 ngn sayesinde ... gönderilerimi haha ​​altında tutuyorum

K (ngn / k) , 29 bayt

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

Çevrimiçi deneyin!

düzenleme: 1 elemanlı giriş durumu için sonlar, işe ihtiyacı var

edit1: şimdi düzeltildi. +4 bayt. boo

APL (Dyalog Genişletilmiş) , 5 bayt

∘.=⍨⍸

Çevrimiçi deneyin!

APL, J ve K karşı genişletilmiş alan için geri kazanır ⍸.

Nasıl çalışır

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

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

Jöle , 7 bayt

ĖŒṙ⁼þ`G

Çevrimiçi deneyin!

J cevabıyla aynı yaklaşım.

      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.