Imprimer une matrice en diagonale de bloc

27

Voici un code de golf simple, de la taille d'une bouchée (octet?): Étant donné une liste non vide d'entiers positifs inférieurs à 10, imprimez une matrice diagonale de bloc , où la liste spécifie la taille des blocs, dans l'ordre. Les blocs doivent être constitués d'entiers positifs inférieurs à 10. Donc, si vous êtes donné en entrée

[5 1 1 2 3 1]

Votre sortie pourrait être, par exemple,

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 quelque chose comme ça. Les éléments de la matrice doivent être séparés par des espaces (simples) et les lignes séparées par des retours à la ligne (simples). Il ne doit y avoir aucun espace de début ou de fin sur aucune ligne. Vous pouvez ou non imprimer une nouvelle ligne de fin.

Vous pouvez écrire une fonction ou un programme, en prenant des entrées via STDIN (ou l'alternative la plus proche), un argument de ligne de commande ou un argument de fonction, dans n'importe quel format de chaîne ou de liste (tant qu'il n'est pas prétraité). Cependant, le résultat doit être imprimé sur STDOUT (ou l'alternative la plus proche), par opposition au retour d'une fonction, par exemple.

Vous ne devez pas utiliser de fonctions intégrées conçues pour créer des matrices à blocs diagonales.

Il s'agit du code golf, donc la soumission la plus courte (en octets) l'emporte.

Classements

Je m'attends à ce que les langages basés sur les tableaux (comme J et APL) aient l'avantage ici, mais je ne veux pas que cela décourage les gens d'essayer de faire aussi bien qu'ils le peuvent dans la langue de leur choix. Voici donc un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue. Alors pourquoi ne pas essayer de prendre une place sur ce dernier?

Pour vous assurer que votre réponse apparaît, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

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

Afficher l'extrait de code

code-golf  array-manipulation 
— Martin Ender
source

Réponses:

20

J, 7 octets

Merci pour FUZxxl pour l'amélioration de 2 octets.

Les langages basés sur des tableaux doivent être comptés ici dans une compétition différente car ils ont un énorme avantage. :)

   =/~@#<\

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

Une autre approche à 7 octets:

#]=@##\

Explication pour l'ancienne version ([:=/~]#<\):

La première étape consiste à générer ndes éléments similaires (par exemple, des nombres) pour chaque élément de la liste n. Ceux-ci devraient être différents des autres éléments ». Par exemple, l'utilisation des nombres naturels 3 1 1 2devient 0 0 0 1 2 3 3.

Pour économiser sur les octets, nous utilisons les préfixes encadrés de la liste:

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

Avec le =/~verbe, nous créons un tableau des produits Descartes de ces préfixes encadrés et chaque cellule sera 1si les deux entrées sont égales 0sinon.

— randomra
source
2
Je ne pense pas que les parenthèses autour [:=/~]#<\ comptent pour votre score. En outre, =/~@#<\ pour deux octets supplémentaires rasés.
— FUZxxl
"Cependant, le résultat doit être imprimé sur STDOUT (ou l'alternative la plus proche), par opposition au retour d'une fonction, par exemple ." Vous avez probablement besoin d'une entrée explicite (donc ce n'est pas seulement une fonction) ou d'une sortie explicite.
— marinus
@marinus J imprime le résultat d'une expression sur stdout si elle n'est pas liée à une variable.
— FUZxxl
@FUZxxl: oui, mais ce (=/~@#<\)n'est qu'une fonction. Vous devez l'appliquer à quelque chose pour obtenir une expression, vous aurez donc besoin d'une entrée explicite ( ".1!:1[1), ou si vous voulez soumettre une fonction, cette fonction devrait en fait afficher la valeur et pas seulement la renvoyer (comme echo@ou quelque chose ).
— marinus
=/~&I.­­­­­­­
— ngn
11

APL, 10

∘.=⍨∆/⍋∆←⎕

Exemple:

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

Explication:

  • ∆←⎕: lire l'entrée, stocker ∆.
  • ⍋∆: trouver une permutation qui trie ∆(cela donne une valeur unique pour chaque valeur dans l'entrée)
  • ∆/: pour chacune de ces valeurs uniques, répétez-la Nfois, où Nest la valeur correspondante dans l'entrée
  • ∘.=⍨: créer une matrice comparant chaque valeur de cette liste aux autres valeurs.
— marinus
source
Pour tester cela http://tryapl.org, vous voudrez peut-être utiliser le dfn {∘.=⍨⍵/⍋⍵}, car le site filtre toutes les utilisations de ⎕(sauf pour ⎕IOet des trucs comme ça).
— FUZxxl
1
@FUZxxl: il dit "Cependant, le résultat doit être imprimé sur STDOUT (ou l'alternative la plus proche), par opposition au retour d'une fonction, disons .", Donc il {∘.=⍨⍵/⍋⍵}n'est pas valide. Vous en auriez besoin {⎕←∘.=⍨⍵/⍋⍵}, qui non seulement coûte deux caractères mais ne fonctionnerait toujours pas sur TryAPL. (Et en général, TryAPL est trop limité pour être utile.)
— marinus
S'il doit imprimer le résultat, n'en auriez-vous pas besoin de ⎕←toute façon, même sans le dfn?
— FUZxxl
@FUZxxl: non, la sortie d'une expression est imprimée automatiquement si rien d'autre n'est fait avec.
— marinus
Ah, je vois. J'avais l'impression que cela ne se produit que lorsque vous utilisez l'interpréteur de manière interactive.
— FUZxxl
8

R, 69 63

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

Cas de test:

(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 fonction extérieure fait la majeure partie du travail ici, alors il s'agit juste de faire en sorte que la sortie soit correcte - Merci à @Vlo pour son aide à cet égard

— Mettre en boule
source
Très belle solution
— MickyT
Excellente solution. Je n'ai jamais pensé à utiliser -/+pour contraindre logique. Économisez quelques octets function(x)write(+outer(i<-rep(1:length(x),x),i,"=="),1,sum(x))63
— Vlo
6

Python 3, 103 97 82 78 76 octets

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

Utiliser splat pour profiter de la nature de séparation d'espace print, avec un peu de récursivité.

— Sp3000
source
6

Rubis, 86 90 83 octets

Mon tout premier golf!

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

Reçoit un tableau avec les entiers, imprime le résultat attendu:

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

Modifier:

Merci à Martin Büttner de m'avoir aidé à raccourcir certaines choses!

— rorlork
source
1
Vous pouvez enregistrer quelques caractères supplémentaires: ->(l)peut l'être ->l. mapest plus court que each. .join(" ")peut être raccourci *" ".
— Martin Ender
6

Matlab, 60 54 octets

Ce serait le domaine spécial de Matlab SI nous pouvions utiliser des fonctions intégrées ...

Merci @sanchises d'avoir corrigé l'erreur que j'ai manquée.

c=0;a=input('');for A=a;v=c+1:c+A;d(v,v)=1;c=c+A;end;d
— flawr
source
Wooow, c'est jusqu'à maintenant que j'ai remarqué que cet extrait js produit en fait un classement !!! Comment n'ai-je jamais remarqué ça ??? Merci de l'avoir signalé =)
— flawr
N'est-ce pas? C'est vraiment cool!
— Alex A.
1
J'étais sur le point de poster presque la même réponse :-)
— Luis Mendo
Exactement le même ou quelque chose de légèrement différent? =) (Bien à part les noms de variables.)
— flawr
Trop similaire pour moi de le poster :-)
— Luis Mendo
6

Matlab, 53 octets

Bien qu'il ne soit que d'un caractère plus court que l'autre fragment Matlab, j'ai pensé que le code était suffisamment différent pour justifier une nouvelle réponse:

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

L'astuce principale est bien sûr l'indexation hors limites, mais elle est combinée avec l'utilisation en endtant que variable pour la rendre plus compacte.

— Dennis Jaheruddin
source
1
Merde - J'ai passé une demi-heure à essayer de end+1:end+vjouer au golf pour me débarrasser d'une variable «compteur», et je n'ai pas pensé à cette solution.
— Sanchises
En effet, comme @Geobits l'a mentionné, la tentative de modification par un anonyme en blkdiagviolerait les exigences. Juste pour référence, j'en mettrai le cœur ici de toute façon:blkdiag(A,ones(i))
— Dennis Jaheruddin
4

CJam, 21 ans

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

Essayez-le sur http://cjam.aditsu.net/

Explication:

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

Suit l'index le plus à gauche du bloc au fur set à mesure qu'il effectue les xentrées 1, où xest la taille actuelle du bloc. Cette ligne est ensuite imprimée xfois. Python 3 est nécessaire pour le faire print(*r).

— xnor
source
Il est un caractère à court juste faire exprimer rcomme [0]*s+[1]*x+[0]*(sum(l)-s-x), mais je suis toujours à la recherche d' une façon meilleure.
— xnor
4

Haskell, 118 116 octets

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

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

Sortie:

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

Comment ça marche:

[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
source
Vous pouvez enregistrer deux octets en faisant (h,e:t)<-map(`splitAt`i)[0..length i-1], car nn'est pas utilisé en dehors de la letliaison.
— Zgarb
@Zgarb: belle trouvaille. Merci!
— nimi
3

Pyth, 23 21 octets

Dépôt GitHub pour Pyth

Ju+G*]GHQYFNJjdmsqdNJ

L'entrée est une liste d'entiers, comme [3, 1, 1, 2]. Essayez-le en ligne: Pyth Compiler / Executor

Utilise une idée assez similaire au code J de randomra. La première partie du code Ju+G*]GHQYgénère des nparties de choses similaires. Pour l'exemple d'entrée, [3, 1, 1, 2]le résultat ressemble à ceci:

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

Trois premiers éléments identiques, puis un élément, puis encore un élément et à la fin deux éléments identiques. 

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 deuxième partie du code compare les éléments du produit cartésien et l'imprime. 

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

C ++, 294 octets

Compilateur utilisé - 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";}}

Explication -: 

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

K, 30 octets

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

J'ai volé la réponse 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
source
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 consommateur qui accepte une liste d'entiers.

Version lisible, avec code passe-partout:

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

Appelez en utilisant:

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

Python 2, 163 114 octets

gnibbler y a joué un tas.

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
source
3
que diriez-vous print" ".join("01"[i==j]for j in r(l(h))for x in r(h[j]))?
— gnibbler
Un ha ! Je pensais pouvoir faire quelque chose comme ça.
— KSFT
Cela ne semble imprimer qu'une seule ligne de chaque bloc.
— xnor
@xnor Vous avez raison; Je l'ai corrigé.
— 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
source
Cela ne se termine-t-il pas par une erreur?
— xnor
@xnor oui c'est le cas!
— feersum
1
@feersum Est-ce autorisé? Je ne vois aucun meta post sur la question. Qu'en penses-tu, Martin? Si cela est autorisé, le Sp3000 peut économiser 6 caractères en se débarrassant du andcourt-circuit.
— xnor
@xnor L'erreur met-elle fin au programme ou uniquement à l'appel de fonction? Si cela met fin au programme, alors non, je ne pense pas que ce soit autorisé. J'ai exprimé mon opinion à ce sujet ici sur meta . Je pense également que si feersum était d'avis que cela est tout à fait légitime, il l'aurait dit dans sa réponse au lieu d'espérer que personne ne le remarque.
— Martin Ender
@ MartinBüttner Terminez le programme, si je comprends ce que vous demandez. Si vous deviez le faire f([1,2,3]);print("Done"), l'erreur mettrait fin au programme après avoir imprimé la matrice de bloc, et il ne serait pas possible d'imprimer "Terminé".
— xnor
2

JavaScript (ES6), 103 107

103 octets en tant que fonction anonyme, sans compter F=(mais vous en avez besoin pour le tester)

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

Tester dans la console Firefox / FireBug

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

Sortie

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

Pyth, 31 30

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

Un programme assez naïf, prend l'entrée sur stdin. Cela peut probablement être joué plus;)

Merci @Jakube d'avoir signalé un omble gâché

Essayez-le ici

— FryAmTheEggman
source
1

Perl, 69

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

Utilise une entrée 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
source
étrangement, cela n'imprime pas de nouvelles lignes pour moi sur ideone . également, selon cet article, vous devez coder le shebang personnalisé en 4 octets, pas deux. vous pouvez résoudre ce problème en n'utilisant pas le shebag mais en utilisant à la place les drapeaux de l'interpréteur et en appelant le code avec -eau lieu d'un fichier (voir les exemples dans cette méta-publication). aussi, je pense que vous n'avez pas besoin du ndrapeau - selon le perldoc, adéfinit nimplicitement.
— Martin Ender
Le programme réutilise l'eol de l'entrée standard. Votre configuration ideone fonctionne lorsque vous l'ajoutez. Quant au nombre de personnages, je le compte de cette façon dans toutes mes réponses, et j'en ai vu d'autres le faire aussi. J'ai déjà vu le post que vous avez lié, mais je ne comprends pas ce que cela signifie par "compter la différence pour perl -nl file.pl". Les règles perlgolf originales compteraient le trait d'union mais pas l'espace donc 3 caractères dans ce cas.
— nutki
@ MartinBüttner, il est tout discutable de toute façon que l'approche de randomra donne une solution beaucoup plus courte: -lna //,print join$",map$'==$_|0,@,for@,=map{(++$i)x$_}@F. BTW ma version de Perl n'est pas définie -navec -a, ce doit être un ajout récent.
— nutki
1

R, 117 144 137 133 129 129 123 octets

Raisonnablement bavard en ce moment. Doit pouvoir en raser un peu plus. A gagné un certain nombre d'octets en le formatant correctement, mais a permis d'économiser de la matrice pour un tableau.

Merci à Alex pour le conseil sur le remplacement de sep par s et la suppression du nom de la fonction.

Supprimé complètement le tableau et utilisé une série de répétitions pour créer chaque ligne.

Bien que violemment battu par Miff, sa solution m'a fait réaliser que je pouvais laisser tomber le 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}}

Et le 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
source
Vous pouvez enregistrer 2 octets en utilisant une correspondance partielle des paramètres de fonction. Dans cat(), passez sep=à s=car aucun autre paramètre reconnu pour cette fonction ne commence par "s".
— Alex A.
@Alex Merci, je ne m'en étais pas rendu compte. Toujours sur une courbe d'apprentissage
— MickyT
Vous pouvez enregistrer 2 autres en supprimant f=. Cela vous donne un objet fonction. Si vous faites cela, il vous suffit de stipuler qu'il doit être attribué en utilisant quelque chose comme f=avant de l'exécuter. Je n'avais pas réalisé que c'était légitime dans des concours comme celui-ci jusqu'à ce que je voie Martin Büttner le faire avec Ruby.
— Alex A.
1

Lot - 226 octets

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

Prend l'entrée de stdin ( C:\>script.bat 5 1 1 2 3 1) et la sortie d'écho. Malheureusement, je n'ai pas pu obtenir le dernier écho sur la même ligne, sinon je pourrais probablement appeler la ligne entière à l'intérieur cmd/von/cpour éviter d'avoir à activer l'extension retardée sur le long terme.

Agréable et soigné - rien que du travail de grognement:

@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!
    )
)
— dégrader
source
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

Produit une sortie en combinant les actions d'E / S via mapM_et foldr. La fonction ddoit recevoir une liste d'entiers.

— Jmac
source
1

K (ngn / k) , 10 octets

{x=\:x:&x}

Essayez-le en ligne!

-19 merci à ngn ... garder ma soumission en dessous haha

K (ngn / k) , 29 octets

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

Essayez-le en ligne!

edit: pauses pour le cas d'entrée à 1 élément, besoin de travail

edit1: maintenant corrigé. +4 octets. huer

— griffonner
source
1
{x=\:x:&x}­­­
— ngn
@ngn oh allez ...
— gribouillage
ce défi avait été discuté dans la salle apl , je connaissais la solution à partir de là :) k et j ont un avantage ici parce que leurs "où" -s ( &en k ou I.en j) fonctionnent avec des vecteurs int, tandis que apl ne ⍸fonctionne qu'avec des booléens .
— ngn
1

APL (Dyalog Extended) , 5 octets

∘.=⍨⍸

Essayez-le en ligne!

APL regagne contre J et K avec le domaine étendu pour ⍸.

Comment ça marche

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

STATA, 155 octets

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
source
Puis-je tester cela en ligne quelque part?
— Martin Ender
@ MartinBüttner: Pour autant que je sache, il n'y a pas de compilateurs en ligne pour Stata car il est propriétaire. Il en va de même pour des langues comme SAS.
— Alex A.
0

Gelée , 7 octets

ĖŒṙ⁼þ`G

Essayez-le en ligne!

Même approche que la réponse 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.
— Chaîne indépendante
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.