Il tuo compito è quello di assemblare gli interi da 1a N(dato come input) in un rettangolo di larghezza We altezza H(dato anche come input). I singoli numeri possono essere ruotati di qualsiasi multiplo di 90 gradi, ma devono apparire come blocchi contigui nel rettangolo. Cioè, non è possibile suddividere uno dei numeri in più cifre e posizionare le cifre nel rettangolo singolarmente, né è possibile piegare tre cifre di un numero attorno a un angolo. Puoi considerare ogni numero come un mattone dal quale stai costruendo un muro.

Ecco un esempio Di 'che il tuo contributo è (N, W, H) = (12, 5, 3). Una possibile soluzione è:

18627
21901
53114

Per chiarezza, ecco due copie di questa griglia, una con i numeri a una cifra nascosti e una con i numeri a due cifre nascosti:

1####    #8627
2##01    #19##
##11#    53##4

Va bene se il rettangolo non può essere smontato di nuovo in un modo unico. Ad esempio, nell'esempio sopra, 12potrebbe anche essere stato posizionato in questo modo:

#####    18627
21#01    ##9##
##11#    53##4

Regole

Si può presumere che Nsia positivo e che W*Hcorrisponda al numero di cifre negli interi da 1a Ncompreso, e che esista una piastrellatura del rettangolo nei numeri dati. Al momento non ho una prova se questo sia sempre possibile, ma sarei interessato a uno se lo fai.

L'output può essere una stringa separata da un'alimentazione di riga singola o un elenco di stringhe (una per ogni riga) o un elenco di liste di numeri interi a una cifra (una per ogni cella).

I risultati del tuo invio devono essere deterministici e dovresti essere in grado di gestire tutti i casi di test in meno di un minuto su una macchina desktop ragionevole.

È possibile scrivere un programma o una funzione e utilizzare uno qualsiasi dei nostri metodi standard per ricevere input e fornire output.

È possibile utilizzare qualsiasi linguaggio di programmazione , ma si noti che queste scappatoie sono vietate per impostazione predefinita.

Questo è code-golf , quindi la risposta valida più breve - misurata in byte - vince.

Casi test

Tranne il primo, nessuno di questi è unico. Ogni caso di test è N W Hseguito da un possibile output. Assicurati che la tua risposta funzioni quando il rettangolo è troppo stretto per scrivere i numeri più grandi in orizzontale.

1 1 1
1

6 6 1
536142

6 2 3
16
25
34

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

11 13 1
1234567891011

27 9 5
213112117
192422581
144136119
082512671
205263272

183 21 21
183116214112099785736
182516114011998775635
181116013911897765534
180415913811796755433
179115813711695745332
178315713611594735231
177115613511493725130
176215513411392715029
175115413311291704928
174115313211190694827
173115213111089684726
172015113010988674625
171915012910887664524
170814912810786654423
169714812710685644322
168614712610584634221
167514612510483624120
166414512410382614019
165314412310281603918
164214312210180593817
163114212110079583716

200 41 12
81711132917193661114105533118936111184136
50592924448815915414562967609909953662491
89529721161671582389717813151113658811817
41418184511110119010183423720433017331118
35171183614003547461181197275184300111711
41874381132041861871718311415915921116264
11914245014112711011594492626831219331845
17125112629222085166344707736090956375181
94507611291431121128817413566319161275711
11011540021119913511011169939551729880780
92725141607727665632702567369893534277304
78118311405621148296417218591118562161856

Pyth, 35 byte

juum+WghHl+dQd~tQN<+.TGmkeHeH)_BvzY

Crediti a mbomb007. Ho usato il suo algoritmo. Inizialmente volevo solo aiutare Steven H., ma poi volevo davvero vedere una versione breve.

Scatta Nsulla prima riga e W,Hsulla seconda riga: provalo online: dimostrazione

Trovato un brutto bug nell'implementazione di Pyth di .[(colpa mia, da quando l'ho implementata). Devo aggiustarlo domani. Ciò ha comportato +3 byte.

Spiegazione:

juum+WghHl+dQd~tQN<+.TGmkeHeH)_BvzY
                                  Y   start with the empty list []
                                      I'll perform all operations on this list. 
                                      Sometimes it is called G, sometimes N. 
                                vz    read the second line and evaluate it: [W, H]
                              _B      bifurcate it with reverse: [[W, H], [H, W]]
 u                                    for each pair H in ^:
                    .TG                  transpose G
                   +   mkeH              append H[1] empty strings
                  <        eH            use only the first H[1] strings
                                         lets call this result N
  u                          )           modify N, until it doesn't change anymore:
   m                        N               map each d in N to:
     WghHl+dQ                                  if H[0] >= len(d+Q):
    +        d  Q                                 d + Q
              ~t                                  and decrement Q by 1
             d                                 else:
                                                  d
j                                     at the end print every row on a separate line

Python 2, 210 200 byte

Modifica: funziona ora!

Riempie dall'alto verso il basso, da sinistra a destra, iniziando con i numeri più grandi. Quindi, trasponi e fallo di nuovo. Quindi trasporre e stampare. Ho dovuto riempire gli spazi perché la trasposizione funzionasse, poiché le linee non sono ancora alla loro lunghezza.

Ho avuto problemi a ottenere un execlavoro annidato (da fare exec'exec"..."*w\n;...'*2. Se qualcuno riesce a capirlo, fammelo sapere.

n,w,h=input()
s=[""]*h
for x in 1,2:
    exec"for i in range(h):l=len(s[i]+`n`)<=w;s[i]+=`n`*l;n-=l\n"*w;s=[r.replace(" ","")for r in map(lambda x:`x`[2::5],zip(*[r.ljust(w)for r in s]))];w,h=h,w
print s

Provalo online : utilizza una funzione modificata in modo da poter eseguire più casi di test più facilmente (e non è possibile utilizzarliexec). Rimuovi il commento dall'altra versione e modifica lo stdin per vederlo funzionare.

Meno golf:

def f(n,w,h):
    s=[""]*h
    for x in 1,2:
        for j in[0]*w:
            for i in range(h):
                l=len(s[i]+`n`)<=w
                s[i]+=`n`*l
                n-=l
        s=[r.ljust(w)for r in s]
        s=map(lambda x:`x`[2::5],zip(*s))
        s=[r.replace(' ','')for r in s]
        w,h=h,w
    print"\n".join(s)

JavaScript, 284 259 245 241 240 223 209 205 byte

// Golfed
let f = (N,W,H)=>eval('a=Array(H).fill("");while(N)g:{s=""+N--;d=s[L="length"];for(i in a)if(a[i][L]+d<=W){a[i]+=s;break g}for(p=0;d;++p){l=a[p][L];for(k=p+d;k>p;)l=a[--k][L]-l?W:l;while(l<W&&d)a[p+--d]+=s[d]}}a');

// Ungolfed
(N,W,H) => {
    a = Array(H).fill(""); // Create `H` empty rows.

    while (N) g : {
        s = "" + N--; // Convert the number to a string.
        d = s[L="length"]; // Count the digits in the number.

        // Loop through the rows trying to fit the number in horizontally.
        for (i in a) {
            if (a[i][L] + d <= W) { // If it fits.
                a[i] += s; // Append the number to the row.
                break g; // This is what a goto statement looks like in JavaScript.
            }
        }

        // Loop through the rows trying to fit the number in vertically.
        for (p = 0; d; ++p) {
            l = a[p][L]; // Get the length of the row.

            // Find `d` adjacent rows of the same length.
            for (k = p + d; k > p; ) {
                // If `a[--k][L] == l`, continue.
                // Else set `l` to `W` so the next loop doesn't run.
                l = a[--k][L] - l ? W : l;
            }

            // Put the characters in position.
            while (l < W && d)
                a[p+--d] += s[d];
        }
    }

    return a;
}

let test_data = [[1,1,1],
                 [6,6,1],
                 [6,2,3],
                 [10,1,11],
                 [10,11,1],
                 [11,13,1],
                 [27,9,5],
                 [183,21,21],
                 [184,2,222],
                 [200,41,12],
                 [1003,83,35]];

for (let test of test_data)
    console.log(f(test[0],test[1],test[2]));

Pyth, 79 50 48 byte

Non competitivo fino a quando non risolvo i bug (ad esempio, [6,6,1] restituisce lo stesso di [6,1,6]). È la prima volta che provo ad usare Pyth, quindi probabilmente mi mancano molte funzionalità.

Grazie a Jakube, ho salvato 29 byte e fatto funzionare il mio codice!

Salvati altri due byte rendendosi conto che le repr()chiamate non erano necessarie.

Fondamentalmente è solo una traduzione della risposta Python 2 di mbomb007.

AEJmkHFb2VHVGIgGl+@JNQ XNJ~tQ)))=.[.TJkGA,HG)jJ

Accetta input sotto forma di
n
w,h.

Stax , 27 byte

é!L↑?∞S░♠╔)¥¼/ÿµ◄÷│♦╫Δò6√√╣

Esegui ed esegui il debug

Richiede input su una riga nel for {N} {H} {W}.

Questo programma inizia con una griglia di spazi della dimensione specificata. Per ogni numero da N... 1, tenta di eseguire una singola sostituzione di stringa da una stringa di spazi della dimensione appropriata al numero formattato. Se non è possibile eseguire alcuna sostituzione, riprova con una griglia trasposta.

z)A+*   create "grid" of spaces and newlines of specified size
,Rr     create range [n ... 1]
F       for each number execute the indented section; it will fit the value into the grid
  $%z(  make a string out of spaces the same length as the number; e.g. 245 => "   "
  Y     store the space string in register Y; this will be used as a search substring
  [#    count the number of occurrences of y in the grid; the grid is still on the stack
  X     store the count in register X; this will be used as a condition
  G     jump to routine at closing curly brace
  y_$|e replace the first instance of y (the spaces) with the current number
  xG    push x; then jump to routine at closing curly brace
        end program
}       called routine jump target
C       pop top of stack; if it's truthy terminate routine
|jM|J   split on newlines; transpose; join with newlines

Esegui questo