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ù N
est 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
function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){$.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(e){answers.push.apply(answers,e.items);if(e.has_more)getAnswers();else process()}})}function shouldHaveHeading(e){var t=false;var n=e.body_markdown.split("\n");try{t|=/^#/.test(e.body_markdown);t|=["-","="].indexOf(n[1][0])>-1;t&=LANGUAGE_REG.test(e.body_markdown)}catch(r){}return t}function shouldHaveScore(e){var t=false;try{t|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(n){}return t}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading);answers.sort(function(e,t){var n=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0],r=+(t.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0];return n-r});var e={};var t=0,c=0,p=-1;answers.forEach(function(n){var r=n.body_markdown.split("\n")[0];var i=$("#answer-template").html();var s=r.match(NUMBER_REG)[0];var o=(r.match(SIZE_REG)||[0])[0];var u=r.match(LANGUAGE_REG)[1];var a=getAuthorName(n);t++;c=p==o?c:t;i=i.replace("{{PLACE}}",c+".").replace("{{NAME}}",a).replace("{{LANGUAGE}}",u).replace("{{SIZE}}",o).replace("{{LINK}}",n.share_link);i=$(i);p=o;$("#answers").append(i);e[u]=e[u]||{lang:u,user:a,size:o,link:n.share_link}});var n=[];for(var r in e)if(e.hasOwnProperty(r))n.push(e[r]);n.sort(function(e,t){if(e.lang>t.lang)return 1;if(e.lang<t.lang)return-1;return 0});for(var i=0;i<n.length;++i){var s=$("#language-template").html();var r=n[i];s=s.replace("{{LANGUAGE}}",r.lang).replace("{{NAME}}",r.user).replace("{{SIZE}}",r.size).replace("{{LINK}}",r.link);s=$(s);$("#languages").append(s)}}var QUESTION_ID=45550;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:<(?:s>[^&]*<\/s>|[^&]+>)[^\d&]*)*$)/;var NUMBER_REG=/\d+/;var LANGUAGE_REG=/^#*\s*([^,]+)/
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
<script src=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js></script><link rel=stylesheet type=text/css href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id=answer-list><h2>Leaderboard</h2><table class=answer-list><thead><tr><td></td><td>Author<td>Language<td>Size<tbody id=answers></table></div><div id=language-list><h2>Winners by Language</h2><table class=language-list><thead><tr><td>Language<td>User<td>Score<tbody id=languages></table></div><table style=display:none><tbody id=answer-template><tr><td>{{PLACE}}</td><td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table><table style=display:none><tbody id=language-template><tr><td>{{LANGUAGE}}<td>{{NAME}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table>
[:=/~]#<\
comptent pour votre score. En outre,=/~@#<\
pour deux octets supplémentaires rasés.(=/~@#<\)
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 (commeecho@
ou quelque chose ).=/~&I.
APL, 10
Exemple:
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-laN
fois, oùN
est la valeur correspondante dans l'entrée∘.=⍨
: créer une matrice comparant chaque valeur de cette liste aux autres valeurs.la source
http://tryapl.org
, vous voudrez peut-être utiliser le dfn{∘.=⍨⍵/⍋⍵}
, car le site filtre toutes les utilisations de⎕
(sauf pour⎕IO
et des trucs comme ça).{∘.=⍨⍵/⍋⍵}
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.)⎕←
toute façon, même sans le dfn?R,
6963Cas de test:
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
la source
-/+
pour contraindre logique. Économisez quelques octetsfunction(x)write(+outer(i<-rep(1:length(x),x),i,"=="),1,sum(x))
63Python 3,
10397827876 octetsUtiliser splat pour profiter de la nature de séparation d'espace
print
, avec un peu de récursivité.la source
Rubis,
869083 octetsMon tout premier golf!
Reçoit un tableau avec les entiers, imprime le résultat attendu:
Modifier:
Merci à Martin Büttner de m'avoir aidé à raccourcir certaines choses!
la source
->(l)
peut l'être->l
.map
est plus court queeach
..join(" ")
peut être raccourci*" "
.Matlab,
6054 octetsCe 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.
la source
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:
L'astuce principale est bien sûr l'indexation hors limites, mais elle est combinée avec l'utilisation en
end
tant que variable pour la rendre plus compacte.la source
end+1:end+v
jouer au golf pour me débarrasser d'une variable «compteur», et je n'ai pas pensé à cette solution.blkdiag
violerait les exigences. Juste pour référence, j'en mettrai le cœur ici de toute façon:blkdiag(A,ones(i))
CJam, 21 ans
Essayez-le sur http://cjam.aditsu.net/
Explication:
la source
Python 3, 79
Suit l'index le plus à gauche du bloc au fur
s
et à mesure qu'il effectue lesx
entrées1
, oùx
est la taille actuelle du bloc. Cette ligne est ensuite impriméex
fois. Python 3 est nécessaire pour le faireprint(*r)
.la source
r
comme[0]*s+[1]*x+[0]*(sum(l)-s-x)
, mais je suis toujours à la recherche d' une façon meilleure.Haskell,
118116 octetsUsage:
f [2,1,1,3]
Sortie:
Comment ça marche:
la source
(h,e:t)<-map(`splitAt`i)[0..length i-1]
, carn
n'est pas utilisé en dehors de lalet
liaison.Pyth,
2321 octetsDépôt GitHub pour Pyth
L'entrée est une liste d'entiers, comme
[3, 1, 1, 2]
. Essayez-le en ligne: Pyth Compiler / ExecutorUtilise une idée assez similaire au code J de randomra. La première partie du code
Ju+G*]GHQY
génère desn
parties 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.
La deuxième partie du code compare les éléments du produit cartésien et l'imprime.
la source
C ++, 294 octets
Compilateur utilisé - GCC 4.9.2
Explication -:
la source
K, 30 octets
J'ai volé la réponse de Marinus
la source
Java, 163
Un consommateur qui accepte une liste d'entiers.
Version lisible, avec code passe-partout:
Appelez en utilisant:
la source
Python 2,
163114 octetsgnibbler y a joué un tas.
la source
print" ".join("01"[i==j]for j in r(l(h))for x in r(h[j]))
?Python 3, 74
la source
and
court-circuit.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é".JavaScript (ES6), 103
107103 octets en tant que fonction anonyme, sans compter
F=
(mais vous en avez besoin pour le tester)Tester dans la console Firefox / FireBug
Sortie
la source
Octave,
4941 octetsla source
Pyth,
3130Un 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
la source
Perl, 69
Utilise une entrée standard:
la source
-e
au lieu d'un fichier (voir les exemples dans cette méta-publication). aussi, je pense que vous n'avez pas besoin dun
drapeau - selon le perldoc,a
définitn
implicitement.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.-lna //,print join$",map$'==$_|0,@,for@,=map{(++$i)x$_}@F
. BTW ma version de Perl n'est pas définie-n
avec-a
, ce doit être un ajout récent.R,
117144137133129 129123 octetsRaisonnablement 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 = ''.
Et le test
la source
cat()
, passezsep=
às=
car aucun autre paramètre reconnu pour cette fonction ne commence par "s".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 commef=
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.Lot - 226 octets
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érieurcmd/von/c
pour éviter d'avoir à activer l'extension retardée sur le long terme.Agréable et soigné - rien que du travail de grognement:
la source
Haskell, 124
Produit une sortie en combinant les actions d'E / S via
mapM_
etfoldr
. La fonctiond
doit recevoir une liste d'entiers.la source
K (ngn / k) , 10 octets
Essayez-le en ligne!
-19 merci à ngn ... garder ma soumission en dessous haha
K (ngn / k) , 29 octets
Essayez-le en ligne!
edit: pauses pour le cas d'entrée à 1 élément, besoin de travail
edit1: maintenant corrigé. +4 octets. huer
la source
{x=\:x:&x}
&
en k ouI.
en j) fonctionnent avec des vecteurs int, tandis que apl ne⍸
fonctionne qu'avec des booléens .APL (Dyalog Extended) , 5 octets
Essayez-le en ligne!
APL regagne contre J et K avec le domaine étendu pour
⍸
.Comment ça marche
la source
STATA, 155 octets
la source
Gelée , 7 octets
Essayez-le en ligne!
Même approche que la réponse J.
la source