Drucken Sie eine Blockdiagonalmatrix

27

Hier ist ein einfacher Code in Bite-Größe (Byte-Größe?): Bei einer nicht leeren Liste positiver Ganzzahlen von weniger als 10 wird eine blockdiagonale Matrix gedruckt , wobei die Liste die Größe der Blöcke in der angegebenen Reihenfolge angibt. Die Blöcke müssen aus positiven ganzen Zahlen kleiner als 10 bestehen. Wenn Sie also als Eingabe angegeben werden

[5 1 1 2 3 1]

Ihre Ausgabe könnte zum Beispiel sein,

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

oder

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

oder etwas ähnliches. Die Elemente in der Matrix müssen durch (einzelne) Leerzeichen und die Zeilen durch (einzelne) Zeilenumbrüche getrennt sein. Es dürfen keine führenden oder nachfolgenden Leerzeichen in den Zeilen stehen. Möglicherweise drucken Sie eine nachgestellte Zeile oder nicht.

Sie können eine Funktion oder ein Programm schreiben, indem Sie eine Eingabe über STDIN (oder die nächstgelegene Alternative), ein Befehlszeilenargument oder ein Funktionsargument in einem beliebigen geeigneten Zeichenfolge- oder Listenformat vornehmen (sofern es nicht vorverarbeitet ist). Das Ergebnis muss jedoch an STDOUT (oder die nächstgelegene Alternative) ausgegeben werden, anstatt beispielsweise von einer Funktion zurückgegeben zu werden.

Sie dürfen keine eingebauten Funktionen zum Erstellen von Blockdiagonalmatrizen verwenden.

Dies ist Codegolf, daher gewinnt die kürzeste Übermittlung (in Bytes).

Bestenlisten

Ich erwarte, dass die Array-basierten Sprachen (wie J und APL) hier die Nase vorn haben, aber ich möchte nicht, dass die Leute davon abgehalten werden, so gut wie möglich in der Sprache ihrer Wahl zu arbeiten. Hier ist also ein Stack-Snippet, um sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache zu generieren. Warum also nicht versuchen, einen Platz auf letzterem zu ergattern?

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

Code-Snippet anzeigen

code-golf  array-manipulation 
— Martin Ender
quelle

Antworten:

20

J, 7 Bytes

Danke für FUZxxl für die 2-Byte-Verbesserung.

Array-basierte Sprachen sollten hier in einem anderen Wettbewerb gezählt werden, da sie einen großen Vorteil haben. :)

   =/~@#<\

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

Ein weiterer 7-Byte-Ansatz:

#]=@##\

Erklärung zur alten Version ([:=/~]#<\):

Der erste Schritt besteht darin, nfür jedes Listenelement ähnliche Dinge (z. B. Zahlen) zu generieren n. Diese sollten sich von den anderen Elementen unterscheiden. ZB unter Verwendung der natürlichen Zahlen 3 1 1 2wird 0 0 0 1 2 3 3.

Um Bytes zu sparen, verwenden wir die eingerahmten Präfixe der Liste:

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

Mit dem =/~Verb erstellen wir eine Tabelle mit Descartes-Produkten dieser eingerahmten Präfixe, und jede Zelle wird angezeigt, 1wenn die beiden Einträge 0ansonsten gleich sind.

— randomra
quelle
2
Ich denke nicht, dass die Klammern [:=/~]#<\ in Ihrer Punktzahl zählen. Auch =/~@#<\ für zwei zusätzliche Bytes rasiert.
— FUZxxl
"Das Ergebnis muss jedoch an STDOUT (oder die nächstgelegene Alternative) ausgegeben werden, anstatt beispielsweise von einer Funktion zurückgegeben zu werden ." Sie benötigen wahrscheinlich entweder eine explizite Eingabe (es handelt sich also nicht nur um eine Funktion) oder eine explizite Ausgabe.
— Marinus
@marinus J gibt das Ergebnis eines Ausdrucks an stdout aus, wenn er nicht an eine Variable gebunden ist.
— FUZxxl,
@FUZxxl: ja, ist aber (=/~@#<\)nur eine funktion. Sie müssten es tatsächlich auf etwas anwenden, um einen Ausdruck zu erhalten. Daher benötigen Sie eine explizite Eingabe ( ".1!:1[1). Wenn Sie eine Funktion übergeben möchten, sollte diese Funktion den Wert tatsächlich drucken und nicht nur zurückgeben (like echo@oder so) ).
— Marinus
=/~&I.­­­­­­­
— 24.
11

APL, 10

∘.=⍨∆/⍋∆←⎕

Beispiel:

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

Erläuterung:

  • ∆←⎕: Eingabe lesen, speichern in ∆.
  • ⍋∆: Finde eine sortierende Permutation ∆(dies gibt einen eindeutigen Wert für jeden Wert in der Eingabe)
  • ∆/: Wiederholen Sie diesen Vorgang für jeden dieser eindeutigen Werte, Nwobei Nsich der entsprechende Wert in der Eingabe befindet
  • ∘.=⍨: Erstelle eine Matrix, die jeden Wert in dieser Liste mit den anderen Werten vergleicht.
— Marinus
quelle
Um dies zu testen http://tryapl.org, möchten Sie möglicherweise die DFN verwenden {∘.=⍨⍵/⍋⍵}, da die Site alle Verwendungen von filtert ⎕(mit Ausnahme von ⎕IOund solchen Dingen ).
— FUZxxl
1
@FUZxxl: Es heißt "Das Ergebnis muss jedoch an STDOUT (oder die nächstgelegene Alternative) ausgegeben werden, im Gegensatz zur Rückgabe von beispielsweise einer Funktion ." Und {∘.=⍨⍵/⍋⍵}ist daher nicht gültig. Sie müssten {⎕←∘.=⍨⍵/⍋⍵}, was nicht nur zwei Zeichen kostet, sondern auf TryAPL auch nicht funktionieren würde. (Und im Allgemeinen ist TryAPL zu begrenzt, um nützlich zu sein.)
— Marinus
Wenn es das Ergebnis ausdrucken muss, brauchst du ⎕←sowieso kein , auch ohne die dfn?
— FUZxxl
@FUZxxl: nein, die Ausgabe eines Ausdrucks wird automatisch gedruckt, wenn nichts anderes damit gemacht wird.
— Marinus
Ah ich sehe. Ich hatte den Eindruck, dass dies nur geschieht, wenn Sie den Interpreter interaktiv verwenden.
— FUZxxl
8

R 69 63

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

Testfall:

(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

Die äußere Funktion erledigt hier den größten Teil der Arbeit. Es geht nur darum, dass die Ausgabe richtig aussieht. Vielen Dank an @Vlo für seine Hilfe

— Miff
quelle
Sehr schöne Lösung
— MickyT
Großartige Lösung. Nie daran gedacht -/+, logisch zu zwingen. Speichern Sie ein paar Bytes function(x)write(+outer(i<-rep(1:length(x),x),i,"=="),1,sum(x))63
— Vlo
6

Python 3, 103 97 82 78 76 Bytes

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

Verwenden Sie splat, um die räumliche Trennung von printmit ein wenig Rekursion zu nutzen.

— Sp3000
quelle
6

Ruby, 86 90 83 Bytes

Mein erstes Golf überhaupt!

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

Erhält ein Array mit den ganzen Zahlen und gibt das erwartete Ergebnis aus:

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

Bearbeiten:

Vielen Dank an Martin Büttner, der mir geholfen hat, einige Dinge zu verkürzen!

— rorlork
quelle
1
Sie können weitere Zeichen speichern: ->(l)können sein ->l. mapist kürzer als each. .join(" ")kann auf gekürzt werden *" ".
— Martin Ender
6

Matlab, 60 54 Bytes

Dies wäre Matlabs Spezialgebiet IF wir eingebauten Funktionen nutzen könnten ...

Vielen Dank an @sanchises für die Behebung des Fehlers, den ich verpasst habe.

c=0;a=input('');for A=a;v=c+1:c+A;d(v,v)=1;c=c+A;end;d
— Fehler
quelle
Wooow, bis jetzt ist mir aufgefallen, dass dieses js-Snippet tatsächlich eine Bestenliste erstellt !!! Wie habe ich das nie bemerkt ??? Vielen Dank für den Hinweis =)
— flawr
Ich weiß es schon gut? Es ist wirklich abgefahren!
— Alex A.
1
Ich wollte fast die gleiche Antwort posten :-)
— Luis Mendo
Genau das Gleiche oder etwas anderes? =) (Nun abgesehen von Variablennamen.)
— Fehler
Zu ähnlich für mich, um es zu posten :-)
— Luis Mendo
6

Matlab, 53 Bytes

Obwohl es nur ein Zeichen kürzer als das andere Matlab-Fragment ist, stellte ich fest, dass der Code unterschiedlich genug ist, um eine neue Antwort zu rechtfertigen:

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

Der Haupttrick ist natürlich das Indizieren außerhalb der Grenzen, aber dies wird mit der Verwendung endals Variable kombiniert , um es kompakter zu machen.

— Dennis Jaheruddin
quelle
1
Verdammt - ich habe eine halbe Stunde lang versucht, Golf end+1:end+vzu spielen, um eine "Counter" -Variable loszuwerden, und ich habe nicht an diese Lösung gedacht.
— Sanchises
Wie @Geobits bereits erwähnte, würde die versuchte Bearbeitung durch einen anonymen Benutzer blkdiagdie Anforderungen verletzen. Nur zum Nachschlagen, ich werde den Kern trotzdem hier platzieren:blkdiag(A,ones(i))
— Dennis Jaheruddin
4

CJam, 21

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

Versuchen Sie es unter http://cjam.aditsu.net/

Erläuterung:

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

Verfolgt den am weitesten links stehenden Index des Blocks sund macht die xEinträge danach 1, wobei xdie aktuelle Blockgröße ist. Diese Zeile wird dann xmal ausgedruckt . Dazu wird Python 3 benötigt print(*r).

— xnor
quelle
Es ist ein Zeichen kürzer einfach tun , ausdrücken rwie [0]*s+[1]*x+[0]*(sum(l)-s-x), aber ich bin immer noch nach einem besseren Weg suchen.
— Xnor
4

Haskell, 118 116 Bytes

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

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

Ausgabe:

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

Wie es funktioniert:

[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
quelle
Sie können auf diese Weise zwei Bytes einsparen (h,e:t)<-map(`splitAt`i)[0..length i-1], da ndies außerhalb der letBindung nicht verwendet wird .
— Zgarb
@Zgarb: schöner Fund. Vielen Dank!
— Nimi
3

Pyth, 23 21 Bytes

GitHub-Repository für Pyth

Ju+G*]GHQYFNJjdmsqdNJ

Eingabe ist eine Liste von ganzen Zahlen, wie [3, 1, 1, 2]. Probieren Sie es online aus: Pyth Compiler / Executor

Verwendet eine ganz ähnliche Idee wie der J-Code von randomra. Der erste Teil des Codes Ju+G*]GHQYgeneriert nTeile ähnlicher Dinge. Für die Beispieleingabe [3, 1, 1, 2]sieht das Ergebnis folgendermaßen aus:

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

Zuerst drei identische Elemente, dann wieder ein Element und am Ende zwei identische Elemente. 

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

Der zweite Teil des Codes vergleicht die Elemente des kartesischen Produkts und druckt es aus. 

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

C ++, 294 Bytes

Verwendeter Compiler - 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";}}

Erklärung -: 

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

K, 30 Bytes

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

Grundsätzlich stahl Marinus Antwort

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

Ein Verbraucher, der eine Liste von ganzen Zahlen akzeptiert.

Lesbare Version mit Kesselschildcode:

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

Aufrufen mit:

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

Python 2, 163 114 Bytes

Knabber golfen dies ein Haufen.

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
quelle
3
wie wäre es print" ".join("01"[i==j]for j in r(l(h))for x in r(h[j]))?
— Gnibbler
Ein ha ! Ich dachte, ich könnte so etwas tun.
— KSFT
Dies scheint nur eine Zeile von jedem Block zu drucken.
— Xnor
@xnor Du hast recht; Ich habe es repariert.
— 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
quelle
Beendet dies nicht mit einem Fehler?
— Xnor
@ xnor ja das tut es!
— Feersum
1
@feersum Ist das erlaubt? Ich sehe keinen Meta-Post zu diesem Thema. Was denkst du, Martin? Wenn es erlaubt ist, kann Sp3000 6 Zeichen sparen, indem der andKurzschluss beseitigt wird .
— Xnor
@xnor Beendet der Fehler das Programm oder nur den Funktionsaufruf? Wenn dies das Programm beendet, dann nein, ich glaube nicht, dass es erlaubt ist. Ich habe meine Meinung dazu hier auf Meta ausgedrückt . Ich denke auch, wenn feersum der Meinung wäre, dass dies völlig legitim ist, hätte er dies in seiner Antwort angegeben, anstatt zu hoffen, dass es niemand bemerkt.
— Martin Ender
@ MartinBüttner Beende das Programm, wenn ich verstehe, was du fragst. Wenn Sie dies tun würden f([1,2,3]);print("Done"), würde der Fehler das Programm beenden, nachdem es die Blockmatrix gedruckt hat, und es würde nicht zum Drucken von "Fertig" kommen.
— Xnor
2

JavaScript (ES6), 103 107

103 Bytes als anonyme Funktion, nicht mitgerechnet F=(aber zum Testen wird dies benötigt)

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

Test In der Firefox / FireBug-Konsole

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

Ausgabe

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

Pyth, 31 30

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

Ein ziemlich naives Programm, nimmt die Eingabe auf stdin. Damit kann man wohl mehr golfen;)

Vielen Dank an @Jakube für den Hinweis auf eine verschwendete Saibling

Probieren Sie es hier aus

— FryAmTheEggman
quelle
1

Perl, 69

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

Verwendet die Standardeingabe:

$ 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
quelle
Seltsamerweise druckt dies für mich keine Zeilenumbrüche auf ideone . Außerdem solltest du laut diesem Beitrag den benutzerdefinierten Shebang als 4 Bytes codieren, nicht als zwei. Sie können dies beheben, indem Sie nicht den Shebag verwenden, sondern die Flags des Interpreters verwenden und den Code mit -eanstelle einer Datei aufrufen (siehe Beispiele in diesem Meta-Post). auch, ich glaube , Sie haben das nicht brauchen nFlagge - nach dem perldoc, asetzt nimplizit.
— Martin Ender
Das Programm verwendet das eol aus der Standardeingabe erneut. Ihr Ideon-Setup funktioniert, wenn Sie es hinzufügen. Die Anzahl der Zeichen zähle ich in all meinen Antworten so, und ich habe auch andere gesehen, die das so gemacht haben. Ich habe den Beitrag gesehen, den Sie zuvor verlinkt haben, aber ich verstehe nicht, was es bedeutet, "den Unterschied zu zählen perl -nl file.pl". Ursprüngliche Perlgolfregeln würden den Bindestrich zählen, aber nicht das Leerzeichen, also in diesem Fall 3 Zeichen.
— Nutki
@ MartinBüttner, ist es strittig ohnehin als randomra Ansatz viel kürzere Lösung gibt: -lna //,print join$",map$'==$_|0,@,for@,=map{(++$i)x$_}@F. BTW meine Version von Perl setzt nicht -nmit -a, es muss eine Neuerung sein.
— Nutki
1

R, 117 144 137 133 129 123 Bytes

Im Moment ziemlich ausführlich. Sollte in der Lage sein, ein paar mehr zu rasieren. Erhielt eine Anzahl von Bytes, die es korrekt formatierten, ersparte jedoch das Auswechseln der Matrix für ein Array.

Vielen Dank an Alex für den Tipp, wie man sep durch s ersetzt und den Funktionsnamen entfernt.

Löschte das Array vollständig und verwendete eine Reihe von Wiederholungen, um jede Zeile zu erstellen.

Obwohl von Miff geschlagen, ließ seine Lösung mich erkennen, dass ich das s = '' insgesamt fallen lassen konnte.

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

Und der 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
>
— MickyT
quelle
Sie können 2 Bytes speichern, indem Sie die Funktionsparameter teilweise abgleichen. In cat(), Änderung sep=zu , s=da keine andere anerkannte Parameter für diese Funktion beginnen mit „s“.
— Alex A.
@ Alex Danke, habe das nicht gemerkt. Immer noch in Lernphase
— MickyT 10.02.15
Sie können weitere 2 speichern, indem Sie entfernen f=. Dies gibt Ihnen ein Funktionsobjekt. Wenn Sie das tun, müssen Sie nur festlegen, dass es mit etwas wie zugewiesen werden soll, f=bevor Sie es ausführen. Ich wusste nicht, dass das bei solchen Wettbewerben legitim ist, bis ich Martin Büttner bei Ruby sah.
— 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!)

Übernimmt die Eingabe von stdin ( C:\>script.bat 5 1 1 2 3 1) und die Ausgabe von echo. Leider konnte ich das letzte Echo nicht auf derselben Leitung erhalten, da ich sonst wahrscheinlich die gesamte Leitung innerhalb der Leitung anrufen könnte cmd/von/c, um zu vermeiden, dass die verzögerte Erweiterung auf lange Sicht aktiviert werden muss.

Nett und ordentlich - nichts als Grunzarbeit:

@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
quelle
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

Erzeugt eine Ausgabe, indem E / A-Aktionen durch mapM_und kombiniert werden foldr. Die Funktion dsollte eine Liste von Ints erhalten.

— Jmac
quelle
1

K (ngn / k) , 10 Bytes

{x=\:x:&x}

Probieren Sie es online!

-19 danke an ngn ... halte meine Einsendung unter haha

K (ngn / k) , 29 Bytes

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

Probieren Sie es online!

edit: Pausen für 1-Element-Eingabefall, braucht Arbeit

edit1: jetzt behoben +4 Bytes. Boo

— kritzeln
quelle
1
{x=\:x:&x}­­­
— 24.
@ngn oh kommt ...
— kritzeln
diese herausforderung wurde im apl-raum diskutiert , ich kannte die lösung von dort :) k und j haben hier einen vorteil, weil ihr "wo" ( &in k oder I.in j) mit int-vektoren arbeitet, während ⍸apls nur mit booleschen arten arbeitet .
— 25.
1

APL (Dyalog Extended) , 5 Bytes

∘.=⍨⍸

Probieren Sie es online!

APL gewinnt gegen J und K mit der erweiterten Domain für zurück ⍸ .

Wie es funktioniert

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

STATA, 155 Bytes

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
— Markierungen
quelle
Kann ich das irgendwo online testen?
— Martin Ender
@ MartinBüttner: Soweit ich weiß, gibt es für Stata keine Online-Compiler, da diese proprietär sind. Gleiches gilt für Sprachen wie SAS.
— Alex A.
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.