Imprimir uma matriz de diagonais de bloco

27

Aqui está um código simples de tamanho de mordida (tamanho de byte?): Dada uma lista não vazia de números inteiros positivos menores que 10, imprima um matriz diagonal de blocos, em que a lista especifica o tamanho dos blocos, em ordem. Os blocos devem consistir em números inteiros positivos menores que 10. Portanto, se você receber como entrada

[5 1 1 2 3 1]

Sua saída pode ser, por exemplo,

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

ou

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

ou algo assim. Os elementos na matriz devem ser separados por espaços (únicos) e as linhas separadas por novas linhas (únicas). Não deve haver espaços iniciais ou finais em nenhuma linha. Você pode ou não imprimir uma nova linha à direita.

Você pode escrever uma função ou programa, recebendo entrada via STDIN (ou alternativa mais próxima), argumento de linha de comando ou argumento de função, em qualquer formato conveniente de string ou lista (desde que não seja pré-processado). No entanto, o resultado deve ser impresso em STDOUT (ou alternativa mais próxima), em vez de retornar de uma função, digamos.

Você não deve usar nenhuma função interna projetada para criar matrizes diagonais de bloco.

Isso é código de golfe, então a submissão mais curta (em bytes) vence.

Classificação

Espero que as linguagens baseadas em array (como J e APL) tenham vantagem aqui, mas não quero que isso desencoraje as pessoas a tentarem fazer o melhor que puderem no idioma de sua escolha. Então, aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma. Então, por que não tentar conseguir uma vaga nesse último?

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Mostrar snippet de código

code-golf  array-manipulation 
— Martin Ender
fonte

Respostas:

20

J, 7 bytes

Obrigado por FUZxxl pela melhoria de 2 bytes.

Os idiomas baseados em matriz devem ser contados aqui em uma competição diferente, pois eles têm uma enorme vantagem. :)

   =/~@#<\

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

Outra abordagem de 7 bytes:

#]=@##\

Explicação para a versão antiga ([:=/~]#<\):

O primeiro passo é gerar ncoisas semelhantes (por exemplo, números) para cada elemento da lista n. Estes devem ser diferentes dos outros elementos '. Por exemplo, usando os números naturais 3 1 1 2torna-se 0 0 0 1 2 3 3.

Para economizar em bytes, usamos os prefixos em caixa da lista:

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

Com o =/~verbo, criamos uma tabela de produtos Descartes desses prefixos em caixas e cada célula será 1se as duas entradas forem iguais 0.

— randomra
fonte
2
Eu não acho que os parênteses ao redor [:=/~]#<\ contam para a sua pontuação. Além disso, =/~@#<\ por dois bytes extras cortados.
— FUZxxl
"No entanto, o resultado deve ser impresso em STDOUT (ou alternativa mais próxima), em vez de retornar de uma função, digamos ." Você provavelmente precisa de entrada explícita (portanto, não é apenas uma função) ou saída explícita.
— marinus
@marinus J imprime o resultado de uma expressão em stdout se não estiver vinculada a uma variável.
— FUZxxl
@ FuZxxl: sim, mas (=/~@#<\)é apenas uma função. Você precisaria aplicá-lo a algo para obter uma expressão, portanto, seria necessário input explícito ( ".1!:1[1) ou, se você quiser enviar uma função, essa função deve realmente imprimir o valor e não apenas devolvê-lo (como echo@algo assim) )
— marinus
=/~&I.­­­­­­­
— ngn 24/10
11

APL, 10

∘.=⍨∆/⍋∆←⎕

Exemplo:

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

Explicação:

  • ∆←⎕: ler entrada, armazenar em ∆.
  • ⍋∆: encontre a permutação que classifica ∆(isso fornece um valor único para cada valor na entrada)
  • ∆/: para cada um desses valores exclusivos, repita-o Nvezes, onde Né o valor correspondente na entrada
  • ∘.=⍨: faça uma matriz comparando cada valor nessa lista com os outros valores.
— marinus
fonte
Para testar isso http://tryapl.org, convém usar o dfn {∘.=⍨⍵/⍋⍵}, pois o site filtra todos os usos de ⎕(exceto ⎕IOcoisas assim).
— FUZxxl
1
@FUZxxl: diz "No entanto, o resultado deve ser impresso em STDOUT (ou alternativa mais próxima), em vez de retornar de uma função, digamos .", Portanto, {∘.=⍨⍵/⍋⍵}não é válido. Você precisaria {⎕←∘.=⍨⍵/⍋⍵}, que não apenas custa dois caracteres, mas ainda não funcionaria no TryAPL. (E, em geral, TryAPL é muito limitada para ser útil.)
— marinus
Se tiver que imprimir o resultado, você não precisaria de ⎕←qualquer maneira, mesmo sem o dfn?
— FUZxxl
@FUZxxl: não, a saída de uma expressão é impressa automaticamente se nada mais for feito com ela.
— marinus
Ah entendo. Fiquei com a impressão de que isso só acontece quando você está usando o intérprete interativamente.
— FUZxxl
8

R, 69 63

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

Caso de teste:

(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

A função externa faz a maior parte do trabalho aqui, então é apenas um caso de obter a saída correta - Obrigado a @Vlo por sua ajuda com isso

— Miff
fonte
Solução muito boa
— MickyT
Ótima solução. Nunca pensei em usar -/+para coagir a lógica. Salve alguns bytes function(x)write(+outer(i<-rep(1:length(x),x),i,"=="),1,sum(x))63
— Vlo 12/02
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 aproveitar a natureza de separação de espaço de print, com um pouco de recursão.

— Sp3000
fonte
6

Ruby, 86 90 83 bytes

Meu primeiro golfe de todos os tempos!

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

Recebe uma matriz com os números inteiros, imprime o 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:

Obrigado a Martin Büttner por me ajudar a diminuir algumas coisas!

— rorlork
fonte
1
Você pode salvar mais alguns caracteres: ->(l)pode ser ->l. mapé mais curto que each. .join(" ")pode ser reduzido para *" ".
— Martin Ender
6

Matlab, 60 54 bytes

Isso seria campo especial de Matlab SE nós poderíamos usar builtin funções ...

Obrigado @sanchises por corrigir o erro que eu perdi.

c=0;a=input('');for A=a;v=c+1:c+A;d(v,v)=1;c=c+A;end;d
— flawr
fonte
Uau, foi até agora que eu notei que esse snippet js realmente produz uma tabela de classificação !!! Como eu nunca percebi isso ??? Graças para apontar isto =)
— flawr
Eu sei direito? É muito legal!
— Alex A.
1
Eu estava prestes a postar quase a mesma resposta :-)
— Luis Mendo
Exatamente o mesmo ou algo ligeiramente diferente? =) (Pois além de nomes de variáveis).
— flawr
Muito semelhante para eu postá-lo :-)
— Luis Mendo
6

Matlab, 53 bytes

Embora seja apenas um caractere mais curto que o outro fragmento do Matlab, imaginei que o código fosse suficientemente diferente para garantir uma nova resposta:

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

O truque principal é, obviamente, a indexação fora dos limites, mas isso é combinado com o uso endcomo uma variável para torná-la mais compacta.

— Dennis Jaheruddin
fonte
1
Porra - passei meia hora tentando jogar golfe end+1:end+vpara me livrar de uma variável 'counter', e não pensei nessa solução.
— Sanchises
De fato, como a @Geobits mencionou, a tentativa de edição por um anônimo em blkdiagviolaria os requisitos. Apenas para referência, colocarei aqui o cerne da questão de qualquer maneira:blkdiag(A,ones(i))
— Dennis Jaheruddin 13/02/15
4

CJam, 21

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

Experimente em http://cjam.aditsu.net/

Explicação:

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)

Rastreia o índice mais à esquerda do bloco como se faz as xentradas depois dele 1, onde xestá o tamanho atual do bloco. Esta linha é impressa xvezes. Python 3 é necessário para fazer print(*r).

— xnor
fonte
É um caractere mais curto para apenas expressar rcomo [0]*s+[1]*x+[0]*(sum(l)-s-x), mas ainda estou procurando uma maneira melhor.
— 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

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

Saída:

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

Como 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
fonte
Você pode salvar dois bytes fazendo isso (h,e:t)<-map(`splitAt`i)[0..length i-1], pois nnão é usado fora da letligação.
— Zgarb
@ Zgarb: bom achado. Obrigado!
— nimi
3

Pitão, 23 21 bytes

Repositório do GitHub para Pyth

Ju+G*]GHQYFNJjdmsqdNJ

Entrada é uma lista de números inteiros, como [3, 1, 1, 2]. Experimente online: Pyth Compiler / Executor

Usa uma idéia bastante semelhante ao código J do randomra. A primeira parte do código Ju+G*]GHQYgera npartes de coisas semelhantes. Para a entrada de exemplo, [3, 1, 1, 2]o resultado é semelhante a este:

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

Primeiro três elementos idênticos, que um elemento, depois um elemento novamente e no final dois 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

A segunda parte do código está comparando os elementos do produto cartesiano e imprimindo-o. 

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 bytes

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

Explicação -: 

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

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

Roubou basicamente a resposta 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
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;}}

Um consumidor que aceita uma lista de números inteiros.

Versão legível, com código padrão:

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

Invoque usando:

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

Python 2, 163 114 bytes

gnibbler jogou um monte de golfe.

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
que tal print" ".join("01"[i==j]for j in r(l(h))for x in r(h[j]))?
— gnibbler
A ha ! Eu pensei que poderia fazer algo assim.
— KSFT
Isso parece imprimir apenas uma linha de cada bloco.
— Xnor
@xnor Você está certo; Eu consertei isso.
— 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
Isso não termina com um erro?
— Xnor
@xnor sim, sim!
— feersum
1
@feersum Isso é permitido? Não vejo nenhuma meta post sobre o assunto. O que você acha, Martin? Se for permitido, o Sp3000 pode economizar 6 caracteres, eliminando o andcurto-circuito.
— xnor
@xnor O erro encerra o programa ou apenas a chamada de função? Se isso encerrar o programa, não, não acho que seja permitido. Eu expressei minha opinião sobre isso aqui na meta . Eu também acho que se feersum fosse da opinião de que isso é completamente legítimo, ele teria declarado isso em sua resposta, em vez de esperar que ninguém percebesse.
— Martin Ender
@ MartinBüttner Encerre o programa, se eu entendo o que você está perguntando. Se você o fizesse f([1,2,3]);print("Done"), o erro terminaria o programa depois que ele imprimisse a matriz de blocos e não chegaria à impressão "Concluído".
— xnor
2

JavaScript (ES6), 103 103107

103 bytes como uma função anônima, sem contar F=(mas você precisa disso para testá-lo)

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

Teste no console Firefox / FireBug

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

Saída

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

Oitava, 49 41 bytes

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

Pyth, 31 30

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

Um programa bastante ingênuo, aceita a entrada do stdin. Provavelmente isso pode ser jogado mais;)

Obrigado @Jakube por apontar um caractere desperdiçado

Experimente aqui

— 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

Usa entrada padrão:

$ 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
estranhamente, isso não imprime novas linhas para mim no ideone . Além disso, de acordo com este post, você deve codificar o shebang personalizado como 4 bytes, não dois. você pode corrigir isso não usando o shebag, mas usando os sinalizadores no intérprete e chamando o código com, e -enão a partir de um arquivo (veja exemplos nessa meta post). Além disso, acho que você não precisa da nbandeira - de acordo com o perldoc, adefine nimplicitamente.
— Martin Ender
O programa reutiliza o eol da entrada padrão. Sua configuração de ideone funciona quando você a adiciona. Quanto à contagem de caracteres, conto desta maneira em todas as minhas respostas, e vi outros fazerem isso também. Eu já vi a postagem que você vinculou antes, mas não entendi o que significa "contar a diferença para perl -nl file.pl". As regras originais do perlgolf contariam o hífen, mas não o espaço, com três caracteres nesse caso.
— nutki
@ MartinBüttner, é tudo discutível de qualquer maneira como a abordagem de randomra dá solução muito mais curto: -lna //,print join$",map$'==$_|0,@,for@,=map{(++$i)x$_}@F. BTW minha versão do Perl não define -ncom -a, deve ser uma adição recente.
— nutki
1

R, 117 144 137 133 129 123 bytes

Razoavelmente detalhado no momento. Deve ser capaz de raspar mais alguns. Ganhou um número de bytes formatando-o corretamente, mas economizou alguns trocando a matriz por uma matriz.

Obrigado a Alex pela dica sobre a substituição de sep por se removendo o nome da função.

Abandonou completamente a matriz e usou uma série de representantes para construir cada linha.

Embora profundamente derrotado por Miff, sua solução me fez perceber que eu poderia largar o s = '' completamente.

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 o teste

> (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
Você pode salvar 2 bytes usando a correspondência parcial dos parâmetros de função. Em cat(), mude sep=para, s=pois nenhum outro parâmetro reconhecido para essa função começa com "s".
— 102815 Alex A.
@ Alex Obrigado, não percebi isso. Ainda em uma curva de aprendizado
— MickyT
Você pode salvar outros 2 removendo f=. Isso fornece um objeto de função. Se você fizer isso, basta estipular que ele seja atribuído usando algo como f=antes de executá-lo. Eu não sabia que isso era legítimo em concursos como esse até ver Martin Büttner fazendo isso com 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!)

Recebe a entrada de stdin ( C:\>script.bat 5 1 1 2 3 1) e a saída do eco. Infelizmente, não consegui obter o último eco na mesma linha; caso contrário, provavelmente poderia ligar para toda a linha cmd/von/cpara evitar a necessidade de permitir a expansão atrasada.

Agradável e arrumado - nada além de trabalho pesado:

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

Produz saída combinando ações de E / S por meio de mapM_e foldr. A função ddeve receber uma lista de entradas.

— Jmac
fonte
1

K (ngn / k) , 10 bytes

{x=\:x:&x}

Experimente online!

-19 graças a ngn ... mantendo minha submissão abaixo haha

K (ngn / k) , 29 bytes

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

Experimente online!

editar: interrupções para o caso de entrada de 1 elemento, precisa funcionar

edit1: agora corrigido. +4 bytes. vaia

— rabisco
fonte
1
{x=\:x:&x}­­­
— ngn 24/10
@ngn oh vamos lá ...
— rabisco
esse desafio havia sido discutido na sala de aplicativos , eu sabia a solução a partir daí :) k e j têm uma vantagem aqui porque seus "onde" -s ( &em k ou I.em j) trabalham com vetores int, enquanto o apl ⍸trabalha apenas com booleanos .
— ngn 25/10
1

APL (Dyalog Extended) , 5 bytes

∘.=⍨⍸

Experimente online!

O APL ganha de volta contra J e K com o domínio estendido de ⍸ .

Como 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
fonte
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
— marcações
fonte
Posso testar isso online em algum lugar?
— Martin Ender
@ MartinBüttner: Até onde eu sei, não existem compiladores on-line para o Stata, pois ele é proprietário. O mesmo vale para idiomas como SAS.
— Alex A.
0

Geléia , 7 bytes

ĖŒṙ⁼þ`G

Experimente online!

Mesma abordagem que a resposta 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 não relacionada
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.