En un mundo multidimensional steam-punk, nuestro jefe quiere colocar etiquetas de índice impresas en cada cajón del archivador multidimensional de nuestro conglomerado.

El jefe quiere componer la hoja de etiquetas completa como una sola forma, usando una fuente comprada solo para este propósito, por lo que tenemos que ordenar las clases (piezas de símbolos de metal). Dado que los tipos son muy caros, nuestro pedido debe ser para el recuento exacto de cada símbolo de dígito.

Para un conjunto dado (por cualquier medio) de longitudes de dimensiones ≥ 0, devuelva (por cualquier medio) nuestro orden, que es la tabla de frecuencia de dígitos requerida para componer todas las coordenadas cartesianas. Debe organizarse por orden de aparición del teclado (es decir, 0 después de 9), y no puede incluir órdenes de 0 tipos, por lo que si no se debe ordenar ningún tipo (porque una dimensión tiene una longitud 0); No imprima nada.

• El bono de -3 ordena si su código puede manejar (es decir, no imprimir nada) 0 dimensiones también.
• Los caracteres finales de nueva línea son aceptables.
• Se aplica la prohibición de lagunas estándar.
• Como se mencionó, los tipos son caros, por lo tanto, esto es codecolf .

Un alma amable puede editar este desafío para incluir una puntuación automática, así que incluye un encabezado como:
# LanguageName, 123 sorts

Casos de prueba

Dado 11, imprimir:

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

debido a que las etiquetas son necesarios 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, y 11.

Dado 2 3, imprimir:

1 5
2 5
3 2

debido a que las etiquetas son necesarios 1 1, 1 2, 1 3, 2 1, 2 2, y 2 3.

Dado 2 0, imprima una línea vacía:

o nada.

Dado 1 2 3, imprimir:

1 11
2  5
3  2

debido a que las etiquetas son necesarios 1 1 1, 1 1 2, 1 1 3, 1 2 1, 1 2 2, y1 2 3

Dado 5 5 5 5, imprimir:

1 500
2 500
3 500
4 500
5 500

Y no, no voy a enumerar todas las 625 etiquetas.

Dyalog APL, 10 7

El código tiene 10 bytes de longitud y califica para la bonificación.

¡Gracias a user46915 por 3 bytes!

,∘≢⌸∊⍕¨∊⍳⎕

Tenga en cuenta que ⎕(input) no funciona en TryAPL; Puedes probar el formulario de función aquí .

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

No entiendo completamente el ⌸operador, pero {⍺}⌸enumera los valores únicos asumidos y {⍵}⌸enumera sus lugares en el argumento.

Tiene el orden correcto porque es el orden en que aparecen los dígitos en la 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}]&

La mayor parte del trabajo aquí es realizado por DigitCount.

R, 110 bytes

Guardado 4 gracias a Alex A. (¡gracias!)

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 las longitudes como argumentos de línea 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}%

Pruébalo en línea

El código es de 34 bytes y requiere una bonificación de 3 bytes para trabajar con una lista de entrada vacía. La entrada es una lista en formato CJam, por ejemplo:

[1 2 3]

Explicación:

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