Dans un monde multidimensionnel steam-punk, notre patron souhaite apposer des étiquettes d'index imprimées sur chaque tiroir du classeur multidimensionnel de notre conglomérat.

Le patron veut composer la totalité de la feuille d'étiquettes sous une forme unique, en utilisant une police achetée uniquement à cette fin, nous devons donc commander les tris (pièces de symboles métalliques). Étant donné que les tris sont très chers, notre commande doit être pour le nombre exact de chaque chiffre-symbole.

Pour un ensemble donné (par tous les moyens) de longueurs de dimensions ≥ 0, renvoyez (par tous les moyens) notre commande, qui est le tableau de fréquence des chiffres requis pour composer toutes les coordonnées cartésiennes. Il doit être organisé par ordre d'apparition du clavier (c.-à-d. 0 après 9) et peut ne pas inclure d'ordres de 0 sortes, donc si aucune sorte ne doit être ordonnée du tout (car une dimension a une longueur de 0); n'imprime rien.

• Bonus de -3 tri si votre code peut gérer (c'est-à-dire ne rien imprimer) 0 dimensions aussi.
• Les caractères finaux de nouvelle ligne sont acceptables.
• L'interdiction des échappatoires standard s'applique.
• Comme mentionné, les sortes sont chères, c'est donc du codecolf .

Une bonne âme peut modifier ce défi pour inclure une notation automatisée, alors incluez un en-tête comme:
# LanguageName, 123 sorts

Cas de test

Étant donné 11, imprimez:

1 4
2 1
3 1
4 1
5 1
6 1
7 1
8 1
9 1
0 1

parce que les étiquettes sont nécessaires 1, 2, 3, 4, 5, 6, 7, 8, 9, 10et 11.

Étant donné 2 3, imprimez:

1 5
2 5
3 2

parce que les étiquettes sont nécessaires 1 1, 1 2, 1 3, 2 1, 2 2et 2 3.

Étant donné 2 0, imprimez une ligne vide:

ou rien.

Étant donné 1 2 3, imprimez:

1 11
2  5
3  2

parce que les étiquettes sont nécessaires 1 1 1, 1 1 2, 1 1 3, 1 2 1, 1 2 2et1 2 3

Étant donné 5 5 5 5, imprimez:

1 500
2 500
3 500
4 500
5 500

Et non, je ne vais pas lister les 625 étiquettes.

Dyalog APL, 10 7

Le code est long de 10 octets et donne droit au bonus.

Merci à user46915 pour 3 octets!

,∘≢⌸∊⍕¨∊⍳⎕

Notez que ⎕(entrée) ne fonctionne pas sur TryAPL; vous pouvez essayer le formulaire de fonction ici .

            ⎕      Get input
           ⍳       Index vector
       ∊⍕¨∊        Flatten, stringify, flatten again
      ⌸            From the key, display the
{⍺,  }             elements concatenated with the
   ≢⍵              number of times they occur

Je ne comprends pas complètement l' ⌸opérateur, mais {⍺}⌸répertorie les valeurs uniques prises et {⍵}⌸répertorie leur place dans l'argument.

Cela a le bon ordre car c'est l'ordre dans lequel les chiffres apparaissent dans le tableau multidimensionnel d'étiquettes.

Mathematica, 48 octets - 3 = 45

Grid@Tally@Flatten@IntegerDigits@Tuples@Range@#&

Mathematica, 111 85 octets

Grid[Thread@{Range@10~Mod~10,DigitCount@Tuples@Range@#~Total~2}~DeleteCases~{_,‌​0}]&

La plupart du travail ici est effectué par DigitCount.

R, 110 octets

Enregistré 4 grâce à Alex A. (merci!)

U=unlist
X=table(U(strsplit(as.character(U(expand.grid(Map(seq_len,scan())))),"")))
z=Map(cat,names(X),X,"\n")

Rubis, 92 octets

f,*r=$*.map{|n|[*1..n.to_i]}
a=f.product(*r)*''
puts a.chars.uniq.map{|c|[c,a.count(c)]*" "}

Prend les longueurs comme arguments de ligne de commande:

$ ruby foo.rb 1 2 3
1 11
2 5
3 2

CJam, 31 octets

Laq~{,m*}/e_:)s{_'0=A*+}$e`{(S\N}%

Essayez-le en ligne

Le code fait 34 octets et prend 3 octets de bonus pour travailler avec une liste d'entrée vide. L'entrée est une liste au format CJam, par exemple:

[1 2 3]

Explication:

La    Push list containing empty list to seed Cartesian products.
q~    Get and interpret input.
{     Loop over values in input list.
  ,     Built range from 0 to value-1.
  m*    Form Cartesian product with the list we already have.
}/    End loop over values in input list.
e_    Resulting list has extra nesting. Flatten it.
:)    Increment all values in list, since it is 0-based, and we need 1-based.
s     Convert it to string, so we can operate on digits.
{     Block to calculate source key, needed to get 0 to the end.
  _     Copy the digit.
  '0=   Compare with '0.
  A*    Multiply comparison result by 10...
  +     ... and add it to digit.
}$    End of sort key block.
e`    RLE.
{     Start of loop over RLE entries, for generating output in specified format.
  (     Pop off the first value, which is the count.
  S     Push a space...
  \     ... and swap it with the count.
  N     Push a newline.
}%    End of loop over RLE entries.

Pyth, 15 octets

rjko%N_Ts*FSMQ8

Haskell, 125 octets

import Data.List
l=mapM_(putStrLn.(\(h:r)->h:' ':show(length r+1))).group.sort.concatMap show.concat.sequence.map(\n->[1..n])