In un mondo multidimensionale punk a vapore, il nostro capo desidera apporre etichette di indice stampate su ciascun cassetto nell'armadietto multidimensionale del nostro conglomerato.

Il boss vuole comporre l'intero foglio di etichette in un unico modulo, usando un font acquistato solo per questo scopo, quindi dobbiamo ordinare i tipi (pezzi di simboli in metallo). Poiché le specie sono molto costose, il nostro ordine deve essere per il conteggio esatto di ciascun simbolo di cifra.

Per un dato set (con qualsiasi mezzo) di lunghezze di dimensioni ≥ 0, restituisci (con ogni mezzo) il nostro ordine, che è la tabella delle frequenze delle cifre richieste per comporre tutte le coordinate cartesiane. Deve essere organizzato in base all'ordine di aspetto della tastiera (ovvero 0 dopo 9) e potrebbe non includere ordini di 0 ordinamenti, quindi se non è necessario ordinare alcun ordinamento (poiché una dimensione ha lunghezza 0); non stampare nulla.

• Bonus di -3 specie se il tuo codice è in grado di gestire (cioè non stampare nulla) anche 0 dimensioni.
• I caratteri finali di newline sono accettabili.
• Si applica il divieto di scappatoie standard.
• Come accennato, le specie sono costose, questo è quindi codecolf .

Un'anima gentile può modificare questa sfida per includere il punteggio automatico, quindi includi un'intestazione come:
# LanguageName, 123 sorts

Casi test

Dato 11, stampa:

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

perché le etichette sono necessari 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, e 11.

Dato 2 3, stampa:

1 5
2 5
3 2

perché le etichette sono necessari 1 1, 1 2, 1 3, 2 1, 2 2, e 2 3.

Dato 2 0, stampa una riga vuota:

o niente.

Dato 1 2 3, stampa:

1 11
2  5
3  2

perché le etichette sono necessari 1 1 1, 1 1 2, 1 1 3, 1 2 1, 1 2 2, e1 2 3

Dato 5 5 5 5, stampa:

1 500
2 500
3 500
4 500
5 500

E no, non elencherò tutte le 625 etichette.

Dyalog APL, 10 7

Il codice è lungo 10 byte e si qualifica per il bonus.

Grazie a user46915 per 3 byte!

,∘≢⌸∊⍕¨∊⍳⎕

Si noti che ⎕(input) non funziona su TryAPL; puoi provare il modulo funzione qui .

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

Non capisco completamente l' ⌸operatore, ma {⍺}⌸elenca i valori univoci assunti ed {⍵}⌸elenca i loro posti nell'argomento.

Questo ha l'ordinamento corretto perché è l'ordine in cui le cifre compaiono nella matrice multidimensionale delle etichette.

Mathematica, 48 byte - 3 = 45

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

Mathematica, 111 85 byte

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

La maggior parte del lavoro qui è svolto da DigitCount.

R, 110 byte

Salvato 4 grazie ad Alex A. (grazie!)

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

Rubino, 92 byte

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

Accetta le lunghezze come argomenti della riga di comando:

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

CJam, 31 byte

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

Provalo online

Il codice è di 34 byte e richiede un bonus di 3 byte per lavorare con un elenco di input vuoto. L'input è un elenco in formato CJam, ad esempio:

[1 2 3]

Spiegazione:

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 byte

rjko%N_Ts*FSMQ8

Haskell, 125 byte

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