Em um mundo multidimensional steam-punk, nosso chefe deseja afixar etiquetas de índice impressas em cada gaveta no arquivo de arquivos multidimensionais do nosso conglomerado.

O chefe deseja digitar toda a folha de etiquetas em um único formulário, usando uma fonte comprada apenas para esse fim, por isso temos que pedir os tipos (peças de símbolos de metal). Como as classificações são muito caras, nosso pedido deve corresponder à contagem exata de cada símbolo de dígito.

Para um determinado conjunto de comprimentos de dimensões ≥ 0, retorne (por qualquer meio) nossa ordem, que é a tabela de frequências de dígitos necessária para definir todas as coordenadas cartesianas. Ele deve ser organizado pela ordem de aparência do teclado (ou seja, 0 após 9) e não pode incluir pedidos de 0 classificações, portanto, se nenhuma classificação for solicitada (porque uma dimensão tem comprimento 0); imprima nada.

• O bônus de -3 é ordenado se o seu código também pode manipular (ou seja, imprimir nada) 0 dimensões.
• Caracteres finais de nova linha são aceitáveis.
• A proibição de brechas padrão se aplica.
• Como mencionado, os tipos são caros, portanto, este é um codecolf .

Uma alma gentil pode editar esse desafio para incluir pontuação automatizada, portanto inclua um cabeçalho como:
# LanguageName, 123 sorts

Casos de teste

Dado 11, imprima:

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

porque os rótulos necessários são 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, e 11.

Dado 2 3, imprima:

1 5
2 5
3 2

porque os rótulos necessários são 1 1, 1 2, 1 3, 2 1, 2 2, e 2 3.

Dado 2 0, imprima uma linha vazia:

ou nada.

Dado 1 2 3, imprima:

1 11
2  5
3  2

porque os rótulos necessários são 1 1 1, 1 1 2, 1 1 3, 1 2 1, 1 2 2, e1 2 3

Dado 5 5 5 5, imprima:

1 500
2 500
3 500
4 500
5 500

E não, eu não vou listar todos os 625 rótulos.

Dyalog APL, 10 7

O código tem 10 bytes e se qualifica para o bônus.

Obrigado user46915 por 3 bytes!

,∘≢⌸∊⍕¨∊⍳⎕

Observe que ⎕(entrada) não funciona no TryAPL; você pode tentar o formulário da função aqui .

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

Eu não entendo completamente o ⌸operador, mas {⍺}⌸lista os valores únicos assumidos e {⍵}⌸lista seus lugares no argumento.

Essa ordem está correta, porque é a ordem na qual os dígitos aparecem na matriz multidimensional de etiquetas.

Mathematica, 48 bytes - 3 = 45

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

Mathematica, 111 85 bytes

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

A maior parte do trabalho aqui é feita por DigitCount.

R, 110 bytes

Guardado 4 graças a Alex A. (obrigado!)

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

Ruby, 92 bytes

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

Toma os comprimentos como argumentos da linha de comando:

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

CJam, 31 bytes

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

Experimente online

O código tem 34 bytes e recebe um bônus de 3 bytes para trabalhar com a lista de entradas vazia. A entrada é uma lista no formato CJam, por exemplo:

[1 2 3]

Explicação:

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.

Pitão, 15 bytes

rjko%N_Ts*FSMQ8

Haskell, 125 bytes

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