Stampa una matrice diagonale a blocchi

27

Ecco un semplice golf da codice di dimensioni ridotte (byte-size?): Dato un elenco non vuoto di numeri interi positivi inferiori a 10, stampa una matrice diagonale a blocchi , in cui l'elenco specifica la dimensione dei blocchi, in ordine. I blocchi devono essere costituiti da numeri interi positivi inferiori a 10. Quindi, se ti viene dato come input

[5 1 1 2 3 1]

Il tuo output potrebbe essere, ad esempio,

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

o

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

o qualcosa di simile. Gli elementi nella matrice devono essere separati da (singoli) spazi e le righe separate da (singoli) newline. Non ci devono essere spazi iniziali o finali su nessuna riga. È possibile o meno stampare una nuova riga finale.

È possibile scrivere una funzione o un programma, prendendo input tramite STDIN (o l'alternativa più vicina), argomento della riga di comando o argomento della funzione, in qualsiasi formato stringa o elenco conveniente (purché non sia preelaborato). Tuttavia, il risultato deve essere stampato su STDOUT (o l'alternativa più vicina), al contrario di restituito da una funzione, diciamo.

Non è necessario utilizzare alcuna funzione integrata progettata per creare matrici diagonali a blocchi.

Questo è il golf del codice, quindi vince l'invio più breve (in byte).

Classifiche

Mi aspetto che i linguaggi basati su array (come J e APL) abbiano il vantaggio qui, ma non voglio che ciò scoraggi le persone dal provare a fare il meglio che possono nella loro lingua preferita. Quindi ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua. Quindi perché non provare a prendere un posto su quest'ultimo?

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Mostra snippet di codice

code-golf  array-manipulation 
— Martin Ender
fonte

Risposte:

20

J, 7 byte

Grazie per FUZxxl per il miglioramento a 2 byte.

Le lingue basate su array devono essere conteggiate qui in una competizione diversa in quanto hanno un enorme vantaggio. :)

   =/~@#<\

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

Un altro approccio a 7 byte:

#]=@##\

Spiegazione per la vecchia versione ([:=/~]#<\):

Il primo passo è generare nelementi simili (ad es. Numeri) per ogni elemento della lista n. Questi dovrebbero essere diversi dagli altri elementi '. Ad esempio, l'utilizzo dei numeri naturali 3 1 1 2diventa 0 0 0 1 2 3 3.

Per risparmiare sui byte utilizziamo i prefissi inscatolati dell'elenco:

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

Con il =/~verbo creiamo una tabella di prodotti Descartes di questi prefissi inscatolati e ogni cella sarà 1se le due voci sono uguali in caso 0contrario.

— randomra
fonte
2
Non credo che le parentesi [:=/~]#<\ contino per il tuo punteggio. Inoltre, =/~@#<\ per due byte extra rasati.
— FUZxxl,
"Tuttavia, il risultato deve essere stampato su STDOUT (o alternativa più vicina), al contrario di restituito da una funzione, diciamo ." Probabilmente hai bisogno di input esplicito (quindi non è solo una funzione) o output esplicito.
— Marin
@marinus J stampa il risultato di un'espressione su stdout se non è associato a una variabile.
— FUZxxl,
@FUZxxl: sì, ma (=/~@#<\)è solo una funzione. Dovresti effettivamente applicarlo a qualcosa per ottenere un'espressione, quindi avresti bisogno di input esplicito ( ".1!:1[1), o se vuoi inviare una funzione, quella funzione dovrebbe effettivamente stampare il valore e non solo restituirlo (come echo@o qualcosa del genere ).
— Marin
=/~&I.­­­­­­­
— ngn
11

APL, 10

∘.=⍨∆/⍋∆←⎕

Esempio:

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

Spiegazione:

  • ∆←⎕: lettura input, memorizzazione in ∆.
  • ⍋∆: trova permutazione che ordina ∆(questo fornisce un valore univoco per ciascun valore nell'input)
  • ∆/: per ciascuno di quei valori univoci, ripeti i Ntempi, dove si Ntrova il valore corrispondente nell'input
  • ∘.=⍨: crea una matrice confrontando ciascun valore in quell'elenco con gli altri valori.
— marinus
fonte
Per testarlo http://tryapl.org, potresti voler usare dfn {∘.=⍨⍵/⍋⍵}, poiché il sito filtra tutti gli usi di ⎕(eccetto ⎕IOe cose del genere).
— FUZxxl,
1
@FUZxxl: dice "Tuttavia, il risultato deve essere stampato su STDOUT (o l'alternativa più vicina), invece di essere restituito da una funzione, diciamo ", quindi {∘.=⍨⍵/⍋⍵}non è valido. {⎕←∘.=⍨⍵/⍋⍵}Ne avresti bisogno , che non solo costa due personaggi ma non funzionerebbe ancora su TryAPL. (E in generale, TryAPL è troppo limitato per essere utile.)
— marinus
Se deve stampare il risultato, non ti servirebbe ⎕←comunque, anche senza il dfn?
— FUZxxl,
@FUZxxl: no, l'output di un'espressione viene stampato automaticamente se non viene fatto altro.
— Marin
Ah, capisco. Ho avuto l'impressione che ciò avvenga solo quando si utilizza l'interprete in modo interattivo.
— FUZxxl,
8

R, 69 63

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

Caso di prova:

(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

La funzione esterna fa la maggior parte del lavoro qui, quindi è solo un caso per ottenere l'output giusto - Grazie a @Vlo per il suo aiuto in questo

— battibecco
fonte
Ottima soluzione
— MickyT
Ottima soluzione Non ho mai pensato di usare -/+per forzare logico. Salva qualche 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)

Usare splat per sfruttare la natura di separazione dello spazio di print, con un po 'di ricorsione.

— SP3000
fonte
6

Rubino, 86 90 83 byte

Il mio primo golf in assoluto!

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

Riceve un array con gli interi, stampa il risultato atteso:

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

Modificare:

Grazie a Martin Büttner per avermi aiutato ad abbreviare alcune cose!

— rorlork
fonte
1
Puoi salvare altri personaggi: ->(l)può essere ->l. mapè più corto di each. .join(" ")può essere abbreviato in *" ".
— Martin Ender,
6

Matlab, 60 54 byte

Questo sarebbe il campo speciale di Matlab SE potremmo usare le funzioni integrate ...

Grazie @sanchise per aver corretto l'errore che ho perso.

c=0;a=input('');for A=a;v=c+1:c+A;d(v,v)=1;c=c+A;end;d
— flawr
fonte
Wow, è stato fino ad ora che ho notato che questo frammento di js in realtà produce una classifica !!! Come non l'ho mai notato ??? Grazie per
— averlo
Infatti, NO? È davvero fico!
— Alex A.
1
Stavo per pubblicare quasi la stessa risposta :-)
— Luis Mendo,
Lo stesso identico o qualcosa di leggermente diverso? =) (A parte i nomi delle variabili.)
— flawr
Troppo simile per me postarlo :-)
— Luis Mendo,
6

Matlab, 53 byte

Sebbene sia solo un carattere più corto dell'altro frammento di Matlab, ho pensato che il codice fosse sufficientemente diverso da giustificare una nuova risposta:

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

Il trucco principale è ovviamente l'indicizzazione fuori dai limiti, ma questo è combinato con l'uso endcome variabile per renderlo più compatto.

— Dennis Jaheruddin
fonte
1
Accidenti - ho passato mezz'ora a cercare di giocare a golf end+1:end+vper sbarazzarmi di una variabile "counter" e non ho pensato a questa soluzione.
— Sanchises,
Infatti, come menzionato da @Geobits, il tentativo di modifica da parte di un anonimo blkdiagviolerebbe i requisiti. Solo per riferimento, lo metterò comunque qui:blkdiag(A,ones(i))
— Dennis Jaheruddin,
4

CJam, 21

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

Provalo su http://cjam.aditsu.net/

Spiegazione:

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

Tiene traccia dell'indice più a sinistra del blocco se crea le xvoci successive 1, dov'è xla dimensione del blocco corrente. Questa riga viene quindi stampata xvolte. Python 3 è necessario per fare print(*r).

— XNOR
fonte
È solo un carattere più breve per esprimere r come [0]*s+[1]*x+[0]*(sum(l)-s-x), ma sto ancora cercando un modo migliore.
— 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

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

Produzione:

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

Come funziona:

[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
— Nome del modello
fonte
È possibile salvare due byte facendo (h,e:t)<-map(`splitAt`i)[0..length i-1], poiché nnon viene utilizzato al di fuori letdell'associazione.
— Zgarb,
@Zgarb: bella scoperta. Grazie!
— nimi,
3

Pyth, 23 21 byte

Repository GitHub per Pyth

Ju+G*]GHQYFNJjdmsqdNJ

L'input è un elenco di numeri interi, come [3, 1, 1, 2] . Provalo online: Pyth Compiler / Executor

Usa un'idea abbastanza simile al codice J di randomra. La prima parte del codice Ju+G*]GHQYgenera nparti di cose simili. Per l'input di esempio[3, 1, 1, 2] il risultato è simile al seguente:

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

Primi tre elementi identici, rispetto a un elemento, quindi di nuovo un elemento e alla fine due elementi identici. 

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

La seconda parte del codice sta confrontando gli elementi del prodotto cartesiano e stampandolo. 

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

C ++, 294 byte

Compilatore utilizzato - 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";}}

Spiegazione -: 

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

K, 30 byte

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

Fondamentalmente ha rubato la risposta di 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
fonte
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;}}

Un consumatore che accetta un elenco di numeri interi.

Versione leggibile, con codice 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;
    }
};

Richiamare usando:

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

Python 2, 163 114 byte

gnibbler ha giocato a golf un sacco.

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
fonte
3
che ne dici print" ".join("01"[i==j]for j in r(l(h))for x in r(h[j]))?
— Gnibbler,
Un ettaro ! Pensavo di poter fare qualcosa del genere.
— KSFT,
Questo sembra stampare solo una riga di ogni blocco.
— xnor
@xnor Hai ragione; L'ho riparato.
— 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
fonte
Questo non termina con un errore?
— xnor
@xnor sì lo fa!
— feersum
1
@feersum È permesso? Non vedo alcun meta post sul problema. Che ne pensi, Martin? Se consentito, Sp3000 può salvare 6 caratteri eliminando il andcortocircuito.
— xnor
@xnor L'errore termina il programma o solo la chiamata di funzione? Se questo termina il programma, no, non penso che sia permesso. Ho espresso la mia opinione su questo qui su meta . Penso anche che se Feersum fosse del tutto legittimo, lo avrebbe dichiarato nella sua risposta invece di sperare che nessuno se ne accorgesse.
— Martin Ender,
@ MartinBüttner Terminare il programma, se capisco cosa mi stai chiedendo. Se lo dovessi fare f([1,2,3]);print("Done"), l'errore terminerebbe il programma dopo aver stampato la matrice a blocchi e non sarà possibile stampare "Fine".
— xnor
2

JavaScript (ES6), 103 107

103 byte come funzione anonima, senza contare F=(ma è necessario per verificarlo)

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

Test nella console di Firefox / FireBug

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

Produzione

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
fonte
2

Ottava, 49 41 byte

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

Pyth, 31 30

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

Un programma abbastanza ingenuo, prende l'input su stdin. Questo probabilmente può essere giocato a golf di più;)

Grazie @Jakube per aver segnalato un carattere sprecato

Provalo qui

— FryAmTheEggman
fonte
1

Perl, 69

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

Utilizza input standard:

$ 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
fonte
stranamente, questo non stampa nuove righe per me su ideone . inoltre, secondo questo post dovresti codificare lo shebang personalizzato come 4 byte, non due. puoi risolverlo non usando lo shebag ma invece usando i flag sull'interprete e chiamando il codice -einvece che da un file (vedi esempi in quel meta post). inoltre, penso che non ti serva la nbandiera - secondo il perldoc, aimposta nimplicitamente.
— Martin Ender,
Il programma riutilizza l'eol dall'input standard. La tua configurazione di ideone funziona quando la aggiungi. Per quanto riguarda il conteggio dei personaggi, lo conto in questo modo in tutte le mie risposte e ho visto anche altri farlo in questo modo. Ho visto il post che hai collegato prima, ma non capisco cosa significhi "conta la differenza perl -nl file.pl". Le regole originali perlgolf contano il trattino ma non lo spazio, quindi in questo caso 3 caratteri.
— Nutki,
@ MartinBüttner, è tutto discutibile comunque come l'approccio di randomra dà soluzione molto più breve: -lna //,print join$",map$'==$_|0,@,for@,=map{(++$i)x$_}@F. A proposito la mia versione di Perl non è impostata -ncon -a, deve essere un'aggiunta recente.
— Nutki,
1

R, 117 144 137 133 129 123 byte

Al momento ragionevolmente prolisso. Dovrebbe essere in grado di radersi un po 'di più. Ha ottenuto un numero di byte formattandolo correttamente, ma ha risparmiato alcuni sostituendo la matrice per un array.

Grazie ad Alex per il suggerimento sulla sostituzione di sep con s e la rimozione del nome della funzione.

Abbandonato completamente l'array e utilizzato una serie di ripetizioni per costruire ogni riga.

Sebbene battuta da Miff, la sua soluzione mi ha fatto capire che avrei potuto eliminare del tutto la s = ''.

function(i){s=sum(i);i=cumsum(i);b=0;for(n in 1:s){d=i[i>=n][1];cat(c(rep(0,b),rep(1,d-b),rep(0,s-d)),fill=T);if(d==n)b=d}}

E il 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
fonte
È possibile salvare 2 byte utilizzando la corrispondenza parziale dei parametri della funzione. In cat(), cambia sep=in s=poiché nessun altro parametro riconosciuto per quella funzione inizia con "s".
— Alex A.
@Alex Grazie, non me ne sono reso conto. Sempre su una curva di apprendimento
— MickyT
Puoi salvare altri 2 rimuovendoli f=. Questo ti dà un oggetto funzione. Se lo fai, devi solo stabilire che deve essere assegnato usando qualcosa di simile f=prima di eseguirlo. Non mi ero reso conto che era legittimo in concorsi come questo fino a quando non ho visto Martin Büttner farlo con Ruby.
— Alex A.
1

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

Prende l'input C:\>script.bat 5 1 1 2 3 1dall'output di stdin ( ) e dell'eco. Sfortunatamente non ho potuto ottenere quell'ultimo eco sulla stessa linea, altrimenti avrei potuto chiamare l'intera linea all'interno cmd/von/cper evitare di dover abilitare l'espansione ritardata a lungo.

Bello e pulito - nient'altro che lavoro grugnito:

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

Produce output combinando azioni IO tramite mapM_e foldr. Alla funzione ddovrebbe essere fornito un elenco di ints.

— Jmac
fonte
1

K (ngn / k) , 10 byte

{x=\:x:&x}

Provalo online!

-19 grazie a ngn ... mantenendo la mia presentazione sotto haha

K (ngn / k) , 29 byte

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

Provalo online!

modifica: interruzioni per il caso di input a 1 elemento, necessita di lavoro

edit1: ora risolto. +4 byte. fischio

— scarabocchio
fonte
1
{x=\:x:&x}­­­
— ngn
@ngn oh andiamo ...
— scarabocchio
questa sfida era stata discussa nella stanza apl , sapevo che la soluzione da lì :) k e j hanno un vantaggio qui perché i loro "dove" ( &in k o I.in j) lavorano con vettori int, mentre apl ⍸funziona solo con booleani .
— ngn
1

APL (Dyalog Extended) , 5 byte

∘.=⍨⍸

Provalo online!

APL vince contro J e K con il dominio esteso per ⍸.

Come funziona

∘.=⍨⍸
    ⍸  ⍝ 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
fonte
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
— bmarks
fonte
Posso provarlo online da qualche parte?
— Martin Ender,
@ MartinBüttner: per quanto ne so, non ci sono compilatori online per Stata poiché è proprietario. Lo stesso vale per lingue come SAS.
— Alex A.
0

Gelatina , 7 byte

ĖŒṙ⁼þ`G

Provalo online!

Stesso approccio della risposta 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.
— Stringa non correlata
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.