In einer mehrdimensionalen Steampunk-Welt möchte unser Chef gedruckte Indexetiketten an jeder Schublade im mehrdimensionalen Aktenschrank unseres Konglomerats anbringen.

Der Chef möchte den gesamten Beschriftungsbogen als eine einzige Form mit einer nur für diesen Zweck gekauften Schrift setzen, also müssen wir die Sortierungen ( Metallsymbolstücke) bestellen . Da Sorten sehr teuer sind, muss in unserer Bestellung die genaue Anzahl der einzelnen Ziffern angegeben werden.

Geben Sie für einen gegebenen Satz von Längen mit Dimensionen ≥ 0 (mit allen Mitteln) unsere Reihenfolge zurück, die die Häufigkeitstabelle der Ziffern ist, die zum Setzen aller kartesischen Koordinaten erforderlich ist. Es muss nach der Reihenfolge des Aussehens der Tastatur geordnet sein (dh 0 nach 9) und darf keine Sortierungen von 0 enthalten. Wenn also überhaupt keine Sortierungen bestellt werden sollen (weil eine Dimension die Länge 0 hat), muss die Reihenfolge der Sortierungen 0 sein. drucke nichts.

• Bonus von -3 Sortierungen, wenn Ihr Code auch 0 Dimensionen verarbeiten kann (dh nichts drucken kann).
• Letzte Zeilenumbrüche sind akzeptabel.
• Es gilt das Verbot von Standardlücken.
• Wie gesagt , Sorten sind teuer, das ist also Codecolf .

Eine freundliche Seele kann diese Herausforderung so bearbeiten, dass sie automatisiertes Scoring enthält. Fügen Sie daher einen Header wie den folgenden hinzu:
# LanguageName, 123 sorts

Testfälle

Gegeben 11, drucken:

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

weil die benötigten Etiketten 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, und 11.

Gegeben 2 3, drucken:

1 5
2 5
3 2

weil die benötigten Etiketten 1 1, 1 2, 1 3, 2 1, 2 2, und 2 3.

Gib 2 0eine leere Zeile aus:

oder nichts.

Gegeben 1 2 3, drucken:

1 11
2  5
3  2

weil die benötigten Etiketten 1 1 1, 1 1 2, 1 1 3, 1 2 1, 1 2 2, und1 2 3

Gegeben 5 5 5 5, drucken:

1 500
2 500
3 500
4 500
5 500

Und nein, ich werde nicht alle 625 Labels auflisten.

Dyalog APL, 10 7

Der Code ist 10 Bytes lang und qualifiziert sich für den Bonus.

Danke an user46915 für 3 Bytes!

,∘≢⌸∊⍕¨∊⍳⎕

Beachten Sie, dass ⎕(Eingabe) bei TryAPL nicht funktioniert. Sie können die Funktion Form versuchen hier .

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

Ich verstehe den ⌸Operator nicht ganz, liste aber {⍺}⌸die eindeutigen Werte auf und {⍵}⌸liste deren Stellen im Argument auf.

Dies hat die richtige Reihenfolge, da es die Reihenfolge ist, in der Ziffern in dem mehrdimensionalen Array von Beschriftungen angezeigt werden.

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}]&

Die meiste Arbeit wird hier von erledigt DigitCount.

R, 110 Bytes

4 Dank an Alex A. gespart (danke!)

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)]*" "}

Nimmt die Längen als Kommandozeilenargumente:

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

CJam, 31 Bytes

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

Probieren Sie es online aus

Der Code ist 34 Byte groß und benötigt einen 3-Byte-Bonus für die Arbeit mit leeren Eingabelisten. Die Eingabe ist eine Liste im CJam-Format, zB:

[1 2 3]

Erläuterung:

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