Cetak Matriks Blok-Diagonal

27

Berikut ini adalah kode golf sederhana, berukuran gigitan (ukuran byte?): Diberi daftar bilangan bulat positif kurang dari 10, cetak matriks blok-diagonal , di mana daftar menentukan ukuran blok, secara berurutan. Blok harus terdiri dari bilangan bulat positif kurang dari 10. Jadi jika Anda diberikan sebagai input

[5 1 1 2 3 1]

Output Anda bisa, misalnya,

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

atau

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

atau semacam itu. Elemen-elemen dalam matriks harus dipisahkan oleh spasi (tunggal), dan baris dipisahkan oleh baris baru (tunggal). Tidak boleh ada spasi awal atau akhir pada garis apa pun. Anda mungkin atau mungkin tidak mencetak baris baru.

Anda dapat menulis fungsi atau program, mengambil input melalui STDIN (atau alternatif terdekat), argumen baris perintah atau argumen fungsi, dalam string atau format daftar yang mudah digunakan (asalkan tidak diproses sebelumnya). Namun, hasilnya harus dicetak ke STDOUT (atau alternatif terdekat), bukan kembali dari fungsi, katakanlah.

Anda tidak boleh menggunakan fungsi bawaan yang dirancang untuk membuat matriks blok-diagonal.

Ini adalah kode golf, jadi pengiriman terpendek (dalam byte) menang.

Papan peringkat

Saya berharap bahasa berbasis array (seperti J dan APL) memiliki keunggulan di sini, tetapi saya tidak ingin hal itu membuat orang tidak mau mencoba melakukan sebaik yang mereka bisa dalam bahasa pilihan mereka. Jadi di sini adalah Cuplikan Stack untuk menghasilkan leaderboard reguler dan tinjauan pemenang berdasarkan bahasa. Jadi mengapa tidak mencoba dan mendapatkan tempat di yang terakhir?

Untuk memastikan bahwa jawaban Anda muncul, silakan mulai jawaban Anda dengan tajuk utama, menggunakan templat Penurunan harga berikut:

# Language Name, N bytes

di mana Nukuran kiriman Anda. Jika Anda meningkatkan skor Anda, Anda dapat menyimpan skor lama di headline, dengan mencoretnya. Contohnya:

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

Tampilkan cuplikan kode

code-golf  array-manipulation 
— Martin Ender
sumber

Jawaban:

20

J, 7 byte

Terima kasih untuk FUZxxl untuk peningkatan 2-byte.

Bahasa berbasis array harus dihitung di sini dalam kompetisi yang berbeda karena mereka memiliki keuntungan besar. :)

   =/~@#<\

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

Pendekatan 7 byte lainnya:

#]=@##\

Penjelasan untuk versi lama ([:=/~]#<\):

Langkah pertama adalah menghasilkan nbagian dari hal-hal serupa (mis. Angka) untuk setiap elemen daftar n. Ini harus berbeda dari elemen lain '. Misalnya menggunakan bilangan asli 3 1 1 2menjadi 0 0 0 1 2 3 3.

Untuk menghemat byte, kami menggunakan awalan kotak dari daftar:

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

Dengan =/~kata kerja kami membuat tabel produk Descartes dari awalan kotak ini dan setiap sel akan menjadi 1jika dua entri sama dengan yang 0sebaliknya.

— randomra
sumber
2
Saya tidak berpikir tanda kurung sekitar [:=/~]#<\ dihitung terhadap skor Anda. Juga, =/~@#<\ untuk dua byte tambahan dicukur habis.
— FUZxxl
"Namun, hasilnya harus dicetak ke STDOUT (atau alternatif terdekat), bukan kembali dari fungsi, katakanlah ." Anda mungkin memerlukan input eksplisit (jadi itu bukan hanya fungsi) atau output eksplisit.
— marinus
@marinus J mencetak hasil ekspresi ke stdout jika tidak terikat ke variabel.
— FUZxxl
@ FuZxxl: ya, tetapi (=/~@#<\)hanya sebuah fungsi. Anda harus benar-benar menerapkannya pada sesuatu untuk mendapatkan ekspresi, jadi Anda perlu input eksplisit ( ".1!:1[1), atau jika Anda ingin mengirimkan fungsi, fungsi itu seharusnya benar-benar mencetak nilai dan tidak hanya mengembalikannya (seperti echo@atau sesuatu ).
— marinus
=/~&I.­­­­­­­
— ngn
11

APL, 10

∘.=⍨∆/⍋∆←⎕

Contoh:

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

Penjelasan:

  • ∆←⎕: baca input, simpan di ∆.
  • ⍋∆: temukan permutasi yang macam-macam ∆(ini memberikan nilai unik untuk setiap nilai dalam input)
  • ∆/: untuk masing-masing nilai unik tersebut, ulangi Nkali, di mana Nnilai yang sesuai dalam input
  • ∘.=⍨: buat matriks yang membandingkan setiap nilai dalam daftar itu dengan nilai-nilai lainnya.
— marinus
sumber
Untuk mengujinya http://tryapl.org, Anda mungkin ingin menggunakan dfn {∘.=⍨⍵/⍋⍵}, karena situs memfilter semua penggunaan ⎕(kecuali untuk ⎕IOdan hal-hal seperti itu).
— FUZxxl
1
@FUZxxl: dikatakan "Namun, hasilnya harus dicetak ke STDOUT (atau alternatif terdekat), sebagai lawan dikembalikan dari fungsi, katakanlah .", Jadi {∘.=⍨⍵/⍋⍵}tidak valid. Anda perlu {⎕←∘.=⍨⍵/⍋⍵}, yang tidak hanya membutuhkan dua karakter tetapi masih tidak berfungsi pada TryAPL. (Dan secara umum, TryAPL terlalu terbatas untuk berguna.)
— marinus
Jika harus mencetak hasilnya, tidakkah Anda akan memerlukannya ⎕←, bahkan tanpa dfn?
— FUZxxl
@ FuZxxl: tidak, output dari ekspresi dicetak secara otomatis jika tidak ada lagi yang dilakukan dengannya.
— marinus
Ah, begitu. Saya mendapat kesan bahwa ini hanya terjadi ketika Anda menggunakan interpreter secara interaktif.
— FUZxxl
8

R, 69 63

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

Kasus cobaan:

(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

Fungsi luar melakukan sebagian besar pekerjaan di sini, maka itu hanya kasus mendapatkan output yang terlihat benar - Terima kasih kepada @Vlo atas bantuannya dengan itu

— Pertengkaran sengit
sumber
Solusi yang sangat bagus
— MickyT
Solusi bagus Tidak pernah berpikir untuk menggunakan -/+logika logis. Simpan beberapa 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)

Menggunakan percikan untuk mengambil keuntungan dari sifat pemisah ruang print, dengan sedikit rekursi.

— Sp3000
sumber
6

Ruby, 86 90 83 byte

Golf pertamaku!

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

Menerima array dengan bilangan bulat, mencetak hasil yang diharapkan:

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

Edit:

Terima kasih kepada Martin Büttner karena membantu saya mempersingkat beberapa hal!

— rorlork
sumber
1
Anda dapat menyimpan lebih banyak karakter: ->(l)bisa ->l. maplebih pendek dari each. .join(" ")dapat disingkat menjadi *" ".
— Martin Ender
6

Matlab, 60 54 byte

Ini akan menjadi bidang khusus Matlab JIKA kita bisa menggunakan fungsi builtin ...

Terima kasih @sanchises untuk memperbaiki kesalahan yang saya lewatkan.

c=0;a=input('');for A=a;v=c+1:c+A;d(v,v)=1;c=c+A;end;d
— cacat
sumber
Wooow, sampai sekarang saya perhatikan bahwa snipet js ini benar-benar menghasilkan papan peringkat !!! Bagaimana saya tidak pernah memperhatikan ini ??? Terima kasih telah menunjukkan ini =)
— flawr
Saya tau? Sangat keren!
— Alex A.
1
Saya akan memposting jawaban yang hampir sama :-)
— Luis Mendo
Sama persis atau sesuatu yang sedikit berbeda? =) (Terlepas dari nama variabel.)
— flawr
Terlalu mirip bagi saya untuk mempostingnya :-)
— Luis Mendo
6

Matlab, 53 byte

Meskipun hanya satu char yang lebih pendek dari fragmen Matlab lainnya, saya pikir kodenya cukup berbeda untuk menjamin jawaban baru:

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

Trik utama tentu saja di luar batas pengindeksan, tetapi ini dikombinasikan dengan menggunakan endsebagai variabel untuk membuatnya lebih kompak.

— Dennis Jaheruddin
sumber
1
Sial - Saya menghabiskan setengah jam mencoba golf end+1:end+vuntuk menghilangkan variabel 'counter', dan saya tidak memikirkan solusi ini.
— Sanchises
Memang, seperti @Geobits menyebutkan upaya edit oleh anonim ke blkdiagakan melanggar persyaratan. Sekedar referensi, saya akan meletakkan intinya di sini:blkdiag(A,ones(i))
— Dennis Jaheruddin
4

CJam, 21

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

Cobalah di http://cjam.aditsu.net/

Penjelasan:

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
sumber
4

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)

Melacak indeks paling kiri dari blok sebagai sdan membuat xentri setelah itu 1, di mana xukuran blok saat ini. Baris ini kemudian dicetak xkali. Python 3 perlu dilakukan print(*r).

— Tidak
sumber
Ini satu char pendek untuk hanya melakukan mengungkapkan rsebagai [0]*s+[1]*x+[0]*(sum(l)-s-x), tapi aku masih mencari cara yang lebih baik.
— 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

Pemakaian: f [2,1,1,3]

Keluaran:

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

Bagaimana itu bekerja:

[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
sumber
Anda dapat menyimpan dua byte dengan melakukan (h,e:t)<-map(`splitAt`i)[0..length i-1], karena ntidak digunakan di luar letpenjilidan.
— Zgarb
@ Zgarb: temukan bagus. Terima kasih!
— nimi
3

Pyth, 23 21 byte

Repositori GitHub untuk Pyth

Ju+G*]GHQYFNJjdmsqdNJ

Input adalah daftar bilangan bulat, seperti [3, 1, 1, 2]. Cobalah secara online: Pyth Compiler / Executor

Menggunakan ide yang sangat mirip dengan kode J randomra. Bagian pertama dari kode Ju+G*]GHQYmenghasilkan nbagian dari hal-hal serupa. Sebagai contoh input [3, 1, 1, 2]hasilnya terlihat seperti ini:

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

Pertama tiga elemen identik, dari satu elemen, lalu satu elemen lagi dan pada akhirnya dua elemen identik. 

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

Bagian kedua dari kode ini membandingkan elemen-elemen produk Cartesian dan mencetaknya. 

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
sumber
3

C ++, 294 byte

Kompiler yang digunakan - 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";}}

Penjelasan -: 

#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
sumber
3

K, 30 byte

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

Pada dasarnya mencuri jawaban 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
— tmartin
sumber
2

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

Seorang konsumen yang menerima daftar bilangan bulat.

Versi yang mudah dibaca, dengan kode boilerplate:

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

Meminta menggunakan:

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

Python 2, 163 114 byte

Gnibbler bermain golf ini banyak.

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
sumber
3
bagaimana print" ".join("01"[i==j]for j in r(l(h))for x in r(h[j]))?
— gnibbler
A ha ! Saya pikir saya bisa melakukan sesuatu seperti itu.
— KSFT
Ini sepertinya hanya mencetak satu baris dari setiap blok.
— xnor
@ xnor Anda benar; Aku telah memperbaikinya.
— KSFT
2

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)
— feersum
sumber
Bukankah ini diakhiri dengan kesalahan?
— xnor
@xnor ya itu!
— feersum
1
@feersum Apakah itu diizinkan? Saya tidak melihat meta pos tentang masalah ini. Bagaimana menurutmu, Martin? Jika diizinkan, Sp3000 dapat menyimpan 6 karakter dengan menghilangkan andkorsleting.
— xnor
@ xnor Apakah kesalahan menghentikan program atau hanya panggilan fungsi? Jika ini menghentikan program, maka tidak, saya tidak berpikir itu diizinkan. Saya sudah menyatakan pendapat saya tentang ini di sini di meta . Saya juga berpikir jika feersum berpendapat bahwa ini benar-benar sah, ia akan menyatakannya dalam jawabannya alih-alih berharap tidak ada yang memperhatikan.
— Martin Ender
@ MartinBüttner Hentikan program, jika saya mengerti apa yang Anda minta. Jika Anda melakukannya f([1,2,3]);print("Done"), kesalahan akan mengakhiri program setelah mencetak matriks blok, dan itu tidak akan mencetak "Selesai".
— xnor
2

JavaScript (ES6), 103 107

103 byte sebagai fungsi anonim, tidak termasuk F=(tetapi Anda perlu ini untuk mengujinya)

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

Uji di Firefox / konsol FireBug

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

Keluaran

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
sumber
1

Pyth, 31 30

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

Program yang cukup naif, mengambil input dari stdin. Ini mungkin bisa golf lebih banyak;)

Terima kasih @ Jakube untuk menunjukkan char yang sia-sia

Coba di sini

— FryAmTheEggman
sumber
1

Perl, 69

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

Menggunakan input standar:

$ 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
sumber
anehnya, ini tidak mencetak baris baru untuk saya di ideone . juga, menurut posting ini Anda harus mengkodekan custom shebang sebagai 4 byte, bukan dua. Anda dapat memperbaikinya dengan tidak menggunakan kantong sampah tetapi sebaliknya menggunakan bendera pada penerjemah dan memanggil kode dengan -ealih - alih dari file (lihat contoh di posting meta itu). juga, saya pikir Anda tidak perlu nbendera - menurut perldoc, adiset nsecara implisit.
— Martin Ender
Program menggunakan kembali eol dari input standar. Pengaturan ideone Anda berfungsi saat Anda menambahkannya. Sedangkan untuk jumlah karakter, saya menghitungnya dengan cara ini dalam semua jawaban saya, dan saya telah melihat orang lain melakukannya dengan cara ini juga. Saya telah melihat pos yang Anda tautkan sebelumnya, tetapi saya tidak mengerti apa artinya dengan "menghitung perbedaannya perl -nl file.pl". Aturan perlgolf asli akan menghitung tanda hubung tetapi bukan spasi jadi 3 karakter dalam hal ini.
— nutki
@ MartinBüttner, itu semua diperdebatkan pula sebagai pendekatan randomra ini memberikan solusi yang jauh lebih pendek: -lna //,print join$",map$'==$_|0,@,for@,=map{(++$i)x$_}@F. BTW versi saya dari Perl tidak diatur -ndengan -a, itu harus menjadi tambahan baru.
— nutki
1

R, 117 144 137 133 129 123 byte

Cukup masuk akal saat ini. Harus bisa mencukur lebih banyak. Memperoleh sejumlah byte memformatnya dengan benar, tetapi menyimpan beberapa swap matriks untuk array.

Terima kasih kepada Alex untuk tip penggantian sep dengan s dan menghapus nama fungsi.

Menjatuhkan array sepenuhnya dan menggunakan serangkaian repetisi untuk membangun setiap baris.

Meskipun dipukuli oleh Miff, solusinya membuat saya sadar bahwa saya bisa menghilangkan s = '' sekaligus.

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

Dan ujiannya

> (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
sumber
Anda dapat menyimpan 2 byte menggunakan pencocokan sebagian parameter fungsi. Di cat(), ubah sep=ke s=karena tidak ada parameter lain yang dikenali untuk fungsi itu dimulai dengan "s".
— Alex A.
@ Alex Terima kasih, tidak menyadarinya. Masih dalam kurva belajar
— MickyT
Anda dapat menyimpan 2 lainnya dengan menghapus f=. Ini memberi Anda objek fungsi. Jika Anda melakukannya, Anda hanya perlu menetapkan bahwa itu ditugaskan menggunakan sesuatu seperti f=sebelum menjalankannya. Saya tidak menyadari bahwa itu sah dalam kontes seperti ini sampai saya melihat Martin Büttner melakukannya dengan Ruby.
— Alex A.
1

Batch - 226 Bytes

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

Mengambil input dari stdin ( C:\>script.bat 5 1 1 2 3 1) dan gema output. Sayangnya saya tidak bisa mendapatkan gema terakhir di jalur yang sama, kalau tidak saya mungkin bisa memanggil seluruh baris di dalam cmd/von/cuntuk menghindari harus memungkinkan ekspansi yang tertunda jauh.

Bagus dan rapi - tidak ada tapi pekerjaan kasar:

@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!
    )
)
— hapus clemeat
sumber
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

Menghasilkan output dengan menggabungkan tindakan IO melalui mapM_dan foldr. Fungsi tersebut dharus diberi daftar int.

— Jmac
sumber
1

K (ngn / k) , 10 byte

{x=\:x:&x}

Cobalah online!

-19 Berkat ngn ... menjaga kiriman saya di bawah haha

K (ngn / k) , 29 byte

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

Cobalah online!

edit: istirahat untuk kasus input 1-elemen, perlu bekerja

sunting1: sekarang diperbaiki. +4 byte. boo

— tulisan cakar ayam
sumber
1
{x=\:x:&x}­­­
— ngn
@ngn oh ayolah ...
— coretan
tantangan ini telah dibahas di ruang apl , saya tahu solusinya dari sana :) k dan j memiliki keuntungan di sini karena "mana" -s ( &dalam k atau I.dalam j) bekerja dengan vektor int, sedangkan apl ⍸hanya bekerja dengan boolean .
— ngn
1

APL (Dyalog Extended) , 5 byte

∘.=⍨⍸

Cobalah online!

APL menang melawan J dan K dengan domain yang diperluas untuk ⍸.

Bagaimana itu bekerja

∘.=⍨⍸
    ⍸  ⍝ 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
sumber
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
— tanda
sumber
Bisakah saya menguji ini secara online di suatu tempat?
— Martin Ender
@ MartinBüttner: Sejauh yang saya tahu, tidak ada kompiler online untuk Stata karena ini adalah miliknya. Hal yang sama berlaku untuk bahasa seperti SAS.
— Alex A.
0

Jelly , 7 byte

ĖŒṙ⁼þ`G

Cobalah online!

Pendekatan yang sama dengan jawaban 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.
— String yang tidak terkait
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.