Imprimir una matriz de bloques en diagonal

27

Aquí hay un código simple, tamaño de mordida (¿tamaño de byte?): Dada una lista no vacía de enteros positivos menores que 10, imprima una matriz de bloques en diagonal , donde la lista especifica el tamaño de los bloques, en orden. Los bloques deben constar de enteros positivos menores que 10. Entonces, si se le da como entrada

[5 1 1 2 3 1]

Su salida podría ser, por ejemplo,

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 algo así. Los elementos en la matriz deben estar separados por espacios (simples) y las filas separadas por líneas nuevas (simples). No debe haber espacios iniciales o finales en ninguna línea. Puede o no imprimir una nueva línea final.

Puede escribir una función o programa, tomando datos a través de STDIN (o la alternativa más cercana), argumento de línea de comando o argumento de función, en cualquier cadena conveniente o formato de lista (siempre que no esté preprocesado). Sin embargo, el resultado debe imprimirse en STDOUT (o la alternativa más cercana), en lugar de ser devuelto por una función, por ejemplo.

No debe utilizar ninguna función incorporada diseñada para crear matrices de bloques en diagonal.

Este es el código de golf, por lo que gana el envío más corto (en bytes).

Tablas de clasificación

Espero que los lenguajes basados ​​en matrices (como J y APL) tengan la ventaja aquí, pero no quiero que eso desaliente a las personas a intentar hacer lo mejor que puedan en su idioma de elección. Así que aquí hay un Fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma. Entonces, ¿por qué no tratar de obtener un lugar en este último?

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Mostrar fragmento de código

code-golf  array-manipulation 
— Martin Ender
fuente

Respuestas:

20

J, 7 bytes

Gracias por FUZxxl por la mejora de 2 bytes.

Los idiomas basados ​​en matrices deben contarse aquí en una competencia diferente, ya que tienen una gran ventaja. :)

   =/~@#<\

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

Otro enfoque de 7 bytes:

#]=@##\

Explicación de la versión anterior ([:=/~]#<\):

El primer paso es generar nelementos similares (por ejemplo, números) para cada elemento de la lista n. Estos deberían ser diferentes de los otros elementos '. Por ejemplo, usar los números naturales se 3 1 1 2convierte 0 0 0 1 2 3 3.

Para guardar en bytes, usamos los prefijos en caja de la lista:

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

Con el =/~verbo creamos una tabla de productos Descartes de estos prefijos encuadrados y cada celda será 1si las dos entradas son iguales de lo 0contrario.

— randomra
fuente
2
No creo que los paréntesis [:=/~]#<\ cuenten para tu puntaje. Además, =/~@#<\ para dos bytes adicionales recortados.
— FUZxxl
"Sin embargo, el resultado debe imprimirse en STDOUT (o la alternativa más cercana), en lugar de ser devuelto por una función, por ejemplo ". Probablemente necesite una entrada explícita (por lo que no es solo una función) o una salida explícita.
— marinus
@marinus J imprime el resultado de una expresión en stdout si no está vinculado a una variable.
— FUZxxl
@FUZxxl: sí, pero (=/~@#<\)es solo una función. Tendría que aplicarlo realmente a algo para obtener una expresión, por lo que necesitaría una entrada explícita ( ".1!:1[1), o si desea enviar una función, esa función debería imprimir el valor y no solo devolverlo (me gusta echo@o algo así) )
— marinus
=/~&I.­­­­­­­
— ngn
11

APL, 10

∘.=⍨∆/⍋∆←⎕

Ejemplo:

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

Explicación:

  • ∆←⎕: leer entrada, almacenar en ∆.
  • ⍋∆: encuentra la permutación que ordena ∆(esto le da un valor único para cada valor en la entrada)
  • ∆/: para cada uno de esos valores únicos, repítelo Nveces, donde Nestá el valor correspondiente en la entrada
  • ∘.=⍨: crea una matriz que compara cada valor de esa lista con los otros valores.
— marinus
fuente
Para probar esto http://tryapl.org, es posible que desee utilizar el dfn {∘.=⍨⍵/⍋⍵}, ya que el sitio filtra todos los usos de ⎕(excepto para ⎕IOy cosas por el estilo).
— FUZxxl
1
@FUZxxl: dice "Sin embargo, el resultado debe imprimirse en STDOUT (o la alternativa más cercana), en lugar de ser devuelto por una función, digamos ", por {∘.=⍨⍵/⍋⍵}lo que no es válido. Necesitaría {⎕←∘.=⍨⍵/⍋⍵}, que no solo cuesta dos caracteres, sino que aún no funcionaría en TryAPL. (Y en general, TryAPL es demasiado limitado para ser útil.)
— marinus
Si tiene que imprimir el resultado, ¿no necesitaría uno de ⎕←todos modos, incluso sin el dfn?
— FUZxxl
@FUZxxl: no, la salida de una expresión se imprime automáticamente si no se hace nada más con ella.
— marinus
Ah, ya veo. Tenía la impresión de que esto solo sucede cuando está utilizando el intérprete de forma interactiva.
— FUZxxl
8

R, 69 63

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

Caso de prueba:

(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 función externa hace la mayor parte del trabajo aquí, entonces es solo un caso para que la salida se vea bien - Gracias a @Vlo por su ayuda con eso

— Ofender
fuente
Muy buena solución
— MickyT
Gran solución Nunca pensé en usar -/+para forzar la lógica. Ahorre algunos 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)

Usando splat para aprovechar la naturaleza de separación de espacios de print, con un poco de recursividad.

— Sp3000
fuente
6

Ruby, 86 90 83 bytes

¡Mi primer golf!

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

Recibe una matriz con los enteros, imprime el resultado esperado:

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

Editar:

¡Gracias a Martin Büttner por ayudarme a acortar algunas cosas!

— rorlork
fuente
1
Puedes guardar algunos personajes más: ->(l)puede ser ->l. mapes más corto que each. .join(" ")se puede acortar a *" ".
— Martin Ender
6

Matlab, 60 54 bytes

Este sería el campo especial de Matlab SI pudiéramos usar funciones integradas ...

Gracias @sanchises por corregir el error que me perdí.

c=0;a=input('');for A=a;v=c+1:c+A;d(v,v)=1;c=c+A;end;d
— falla
fuente
¡Guau, fue hasta ahora que me di cuenta de que este fragmento js en realidad produce una tabla de clasificación! ¿Cómo nunca me di cuenta de esto? Gracias por señalar esto =)
— error
¿Yo se, verdad? ¡Es bastante genial!
— Alex A.
1
Estaba a punto de publicar casi la misma respuesta :-)
— Luis Mendo
¿Exactamente igual o algo ligeramente diferente? =) (Bueno, aparte de los nombres de variables.)
— error
Demasiado similar para mí para publicarlo :-)
— Luis Mendo
6

Matlab, 53 bytes

Aunque es solo un carácter más corto que el otro fragmento de Matlab, pensé que el código es lo suficientemente diferente como para garantizar una nueva respuesta:

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

El truco principal es, por supuesto, la indexación fuera de límites, pero esto se combina con el uso endcomo una variable para hacerlo más compacto.

— Dennis Jaheruddin
fuente
1
Maldición: pasé media hora tratando de jugar golf end+1:end+vpara deshacerme de una variable 'contador', y no pensé en esta solución.
— Sanchises
De hecho, como @Geobits mencionó que el intento de edición por un anónimo blkdiagviolaría los requisitos. Solo como referencia, pondré el núcleo aquí de todos modos:blkdiag(A,ones(i))
— Dennis Jaheruddin
4

CJam, 21

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

Pruébalo en http://cjam.aditsu.net/

Explicación:

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

Pitó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)

Rastrea el índice más a la izquierda del bloque como sy realiza las xentradas después de que sea 1, donde xestá el tamaño actual del bloque. Esta fila se imprime xveces. Python 3 es necesario para hacer print(*r).

— xnor
fuente
Es un carácter más corto para expresar rcomo [0]*s+[1]*x+[0]*(sum(l)-s-x), pero todavía estoy buscando una mejor manera.
— xnor
4

Haskell, 118116 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

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

Salida:

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

Cómo funciona:

[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
fuente
Puede guardar dos bytes al hacerlo (h,e:t)<-map(`splitAt`i)[0..length i-1], ya nque no se usa fuera del letenlace.
— Zgarb
@ Zgarb: buen hallazgo. ¡Gracias!
— nimi
3

Pyth, 23 21 bytes

Repositorio de GitHub para Pyth

Ju+G*]GHQYFNJjdmsqdNJ

La entrada es una lista de enteros, como [3, 1, 1, 2]. Pruébelo en línea: Pyth Compiler / Executor

Utiliza una idea bastante similar al código J de randomra. La primera parte del código Ju+G*]GHQYgeneran partes de cosas similares. Para el ejemplo de entrada[3, 1, 1, 2] el resultado se ve así:

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

Primero tres elementos idénticos, que un elemento, luego un elemento nuevamente y al final dos elementos idénticos. 

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 segunda parte del código es comparar los elementos del producto cartesiano e imprimirlo. 

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

C ++, 294 bytes

Compilador utilizado - 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";}}

Explicación -: 

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

K, 30 bytes

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

Básicamente robó la respuesta de 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
fuente
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 consumidor que acepta una lista de enteros.

Versión legible, con código repetitivo:

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

Invocar usando:

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

Pitón 2, 163 114 bytes

gnibbler golfed esto un montón.

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
fuente
3
¿qué tal print" ".join("01"[i==j]for j in r(l(h))for x in r(h[j]))?
— gnibbler
A ha ! Pensé que podría hacer algo así.
— KSFT
Esto parece imprimir solo una fila de cada bloque.
— xnor
@xnor Tienes razón; Lo arreglé.
— KSFT
2

Pitó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)
— Feersum
fuente
¿No termina esto con un error?
— xnor
@xnor sí lo hace!
— feersum
1
@feersum ¿Eso está permitido? No veo ninguna meta publicación sobre el tema. ¿Qué te parece, Martin? Si está permitido, Sp3000 puede ahorrar 6 caracteres al deshacerse del andcortocircuito.
— xnor
@xnor ¿El error finaliza el programa o solo la llamada a la función? Si esto termina el programa, entonces no, no creo que esté permitido. He expresado mi opinión sobre esto aquí en meta . También creo que si feersum opinara que esto es completamente legítimo, lo habría dicho en su respuesta en lugar de esperar que nadie se dé cuenta.
— Martin Ender
@ MartinBüttner Termine el programa, si entiendo lo que está preguntando. Si lo hiciera f([1,2,3]);print("Done"), el error finalizaría el programa después de que imprima la matriz de bloques, y no llegaría a imprimir "Listo".
— xnor
2

JavaScript (ES6), 103 103107

103 bytes como una función anónima, sin contar F=(pero necesita esto para probarlo)

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

Prueba en la consola Firefox / FireBug

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

Salida

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

Pyth, 31 30

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

Un programa bastante ingenuo, toma la entrada en stdin. Esto probablemente se puede jugar más al golf;)

Gracias @Jakube por señalar un char perdido

Pruébalo aquí

— FryAmTheEggman
fuente
1

Perl, 69

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

Utiliza entrada estándar:

$ 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
fuente
curiosamente, esto no imprime nuevas líneas para mí en ideone . Además, de acuerdo con esta publicación , debe codificar el shebang personalizado como 4 bytes, no dos. puedes arreglar eso no usando el shebag sino usando las banderas en el intérprete y llamando al código en -elugar de desde un archivo (ver ejemplos en esa meta publicación). Además, creo que no necesita la nbandera, según el perldoc, se aestablece nimplícitamente.
— Martin Ender
El programa reutiliza el eol de la entrada estándar. Su configuración de ideone funciona cuando la agrega. En cuanto al recuento de personajes, lo cuento de esta manera en todas mis respuestas, y también he visto a otros hacerlo de esta manera. He visto la publicación que vinculaste antes, pero no entiendo lo que significa "contar la diferencia para perl -nl file.pl". Las reglas originales de perlgolf contarían el guión pero no el espacio, por lo que 3 caracteres en este caso.
— nutki
@ MartinBüttner, todo es discutible de todos modos como el acercamiento de randomra da solución mucho más corto: -lna //,print join$",map$'==$_|0,@,for@,=map{(++$i)x$_}@F. Por cierto mi versión de Perl no establece -ncon -a, debe ser una adición reciente.
— nutki
1

R, 117 144 137 133 129 123 bytes

Razonablemente detallado en este momento. Debería poder afeitarse un poco más. Obtuve una cantidad de bytes formateándolo correctamente, pero guardé algunos intercambiando la matriz por una matriz.

Gracias a Alex por la sugerencia de reemplazar sep con sy eliminar el nombre de la función.

Soltó la matriz por completo y usó una serie de repeticiones para construir cada línea.

Aunque golpeado por Miff, su solución me hizo darme cuenta de que podía soltar el s = '' por completo.

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

Y la prueba

> (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
fuente
Puede guardar 2 bytes utilizando la coincidencia parcial de los parámetros de la función. En cat(), cambie sep=a s=dado que ningún otro parámetro reconocido para esa función comienza con "s".
— Alex A.
@Alex Gracias, no me di cuenta de eso. Todavía en una curva de aprendizaje
— MickyT
Puede guardar otros 2 quitando f=. Esto te da un objeto de función. Si hace eso, solo tiene que estipular que se asigne usando algo como f=antes de ejecutarlo. No me di cuenta de que era legítimo en concursos como este hasta que vi a Martin Büttner hacerlo con Ruby.
— Alex A.
1

Lote: 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!)

Toma la entrada de stdin ( C:\>script.bat 5 1 1 2 3 1) y la salida de echo. Desafortunadamente no pude obtener ese último eco en la misma línea, de lo contrario, probablemente podría llamar a toda la línea dentrocmd/von/c para evitar tener que permitir la expansión retardada en el largo camino.

Agradable y ordenado, nada más que un trabajo duro:

@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!
    )
)
— carne sin carne
fuente
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 resultados combinando acciones IO a través de mapM_y foldr. La función ddebe recibir una lista de entradas.

— Jmac
fuente
1

K (ngn / k) , 10 bytes

{x=\:x:&x}

Pruébalo en línea!

-19 gracias a ngn ... manteniendo mi presentación debajo jaja

K (ngn / k) , 29 bytes

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

Pruébalo en línea!

editar: saltos para el caso de entrada de 1 elemento, necesita trabajo

edit1: ahora corregido. +4 bytes. abucheo

— garabatear
fuente
1
{x=\:x:&x}­­­
— ngn
@ngn oh vamos ...
— garabatea el
este desafío se había discutido en la sala de apl , sabía que la solución a partir de ahí :) k y j tienen una ventaja aquí porque sus "where" -s ( &en k o I.en j) funcionan con vectores int, mientras que apl's ⍸solo funciona con booleanos .
— ngn
1

APL (Dyalog Extended) , 5 bytes

∘.=⍨⍸

Pruébalo en línea!

APL vuelve a ganar contra J y K con el dominio extendido para ⍸.

Cómo funciona

∘.=⍨⍸
    ⍸  ⍝ 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
fuente
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
— comentarios
fuente
¿Puedo probar esto en línea en alguna parte?
— Martin Ender
@ MartinBüttner: Hasta donde yo sé, no hay compiladores en línea para Stata ya que es propietario. Lo mismo ocurre con idiomas como SAS.
— Alex A.
0

Jalea , 7 bytes

ĖŒṙ⁼þ`G

Pruébalo en línea!

El mismo enfoque que la respuesta de 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.
— Cadena no relacionada
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.