Questa domanda è ispirata alla domanda di Kevin Cruijssen .

Ora che il tappeto è steso, vogliamo arrotolarlo. Il tuo compito è scrivere un programma che prende una stringa e restituisce una spirale fatta da questa stringa (che rappresenta un tappeto arrotolato visto di lato).

La procedura per un passaggio del tappeto è la seguente. C'è un esempio per illustrare cosa intendo. Si noti che l'esempio inizia con un tappeto parzialmente arrotolato per una migliore comprensione:

ac
rpet

• separare la "testa" dalla "coda" del tappeto: la testa è ciò che è stato rotolato finora, la coda è ciò che resta da rotolare.

Head: ac   Tail:
      rp          et

• Ruota la testa di 90 °, in senso orario.

Rotated head: ra   Tail (unchanged):
              pc                       et

• se la larghezza della nuova testa (qui 2) è inferiore o uguale alla lunghezza della coda (qui 2)
  • quindi, mettilo sopra la coda
  • altrimenti, il tappeto (com'era all'inizio del gradino) è stato arrotolato

New carpet: ra
            pc
            et

Ripeti la procedura tutte le volte che è necessario.

Due esempi che mostrano tutti i passaggi del rotolamento del tappeto:

carpet

 c
 arpet

  ac
  rpet

    ra
    pc
    et

0123456789

 0
 123456789

  10
  23456789

    21
    30
    456789

      432
      501
      6789

Alcune precisazioni:

• Non è necessario mostrare tutti i passaggi intermedi, solo il tappeto arrotolato (ad es. Se si trova un modo non iterativo per calcolare il risultato, è perfetto). Inoltre, non è necessario stampare spazi bianchi iniziali, negli esempi sopra, li mostro solo per allineare le cose.
• L'input è una stringa, un elenco / matrice di caratteri
• L'output viene stampato su stdout o su un file.
• L'input è buono: la lunghezza è di almeno 1 carattere e al massimo una costante sufficientemente piccola da non causare problemi, ma non è possibile utilizzare quella costante nel programma; il contenuto della stringa è costituito solo da simpatici caratteri ([a-zA-Z0-9]), codificabili secondo le proprie preferenze.
• Questo è code-golf , quindi vince la risposta più breve in byte. Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Le scappatoie predefinite sono vietate.
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, aggiungi una spiegazione per la tua risposta se ritieni che sia necessaria.

Carbone , 15 byte

ＦＳ«Ｆ¬℅§ＫＶ⁰⟲⁶→Ｐι

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

ＦＳ«

Passa sopra il tappeto.

Ｆ¬℅§ＫＶ⁰

Controlla se c'è qualcosa sopra il cursore.

⟲⁶

In caso contrario, arrotolare il tappeto.

→Ｐι

Sposta a destra e visualizza il carattere corrente.

Esempio: per l'input 0123456789, si verificano le seguenti azioni:

0

0 è stampato.

01

Il cursore si sposta a destra e 1viene stampato.

0
1

Poiché non c'è nulla al di sopra di 1, la tela viene ruotata.

0
12

Il cursore si sposta a destra e 2viene stampato.

10
2

Poiché non c'è nulla al di sopra di 2, la tela viene ruotata.

10
23

Il cursore si sposta a destra e 3viene stampato.

10
234

Il cursore si sposta a destra e 4viene stampato.

21
30
4

Poiché non c'è nulla al di sopra di 4, la tela viene ruotata.

21
30
45

Il cursore si sposta a destra e 5viene stampato.

21
30
456

Il cursore si sposta a destra e 6viene stampato.

432
501
6

Poiché non c'è nulla al di sopra di 6, la tela viene ruotata.

432
501
67

Il cursore si sposta a destra e 7viene stampato.

432
501
678

Il cursore si sposta a destra e 8viene stampato.

432
501
6789

Il cursore si sposta a destra e 9viene stampato.

Pyth, 37 byte

.U+j;bZ.WgleHJlhH,+_MChZ<eZJ>eZJ,]hQt

Provalo online qui o verifica tutti i casi di test contemporaneamente qui .

.U+j;bZ.WgleHJlhH,+_MChZ<eZJ>eZJ,]hQtQ   Implicit: Q=eval(input())
                                         Trailing Q inferred
                                 ]hQ     First character of Q, wrapped in an array
                                    tQ   All but the first character of Q
                                ,        2-element array of the two previous results
                                           This yields array with rolled carpet (as array of strings) followed by the tail
       .W                                While condition function is truthy, execute inner function, with initial value of the above:
         gleHJlhH                          Condition function, input H
             JlhH                            Number of layers in the current rolled carpet, store in J
          leH                                Lenth of the tail
         g   J                               Is the above greater than or equal to J?
                 ,+_MChZ<eZJ>eZJ           Inner function, input Z
                   _MChZ                     Rotate the current rolled carpet (transpose, then reverse each row)
                  +     <eZJ                 Append the first J characters of the tail as a new row
                 ,                           Pair the above with...
                            >eZJ             ... all but the first J characters of the tail - this is the new tail
.U+j;bZ                                  Join the carpet roll on newlines and append the tail, implicit print

Buccia , 24 byte

►S=ÖLmFȯ:T↔ø§z:oΘḣĠ+CṘ2N

Provalo online!

Spiegazione

Implicit input, say s="carpets"

CṘ2N  Break s into chunks:
   N   Natural numbers: [1,2,3,4,..
 Ṙ2    Repeat each twice: [1,1,2,2,3,3,4,4,..
C      Break s into chunks of these lengths: ["c","a","rp","et","s"]
       The last chunk is shorter if we run out of characters.

§z:oΘḣĠ+  Attempt to merge suffix of chunks:
      Ġ    Cumulative reduce chunk list from right
       +   by concatenation: ["carpets","arpets","rpets","ets","s"]
   oΘḣ     Prefixes of chunk list (empty and nonempty): [[],["c"],..,["c","a","rp","et","s"]]
§z         Zip these by
  :        appending: [["carpets"],["c","arpets"],..,["c","a","rp","et","s"]]
           These are all versions of the chunk list where some suffix has been merged.

mFȯ:T↔ø  Roll each list:
m         Map
 F        reduce from left
      ø   starting from empty character matrix
  ȯ:T↔    by this function:
    T↔     Reverse and transpose (rotating by 90 degrees)
  ȯ:       then append next chunk as new row.
         Result: [["carpets"],["c","arpets"],..,["epr","tca","s"]]

►S=ÖL  Select the matrix rolled by the correct amount:
►       Find element that maximizes
 S=     being equal to
   ÖL   sort by length.
        This selects a matrix whose rows have non-decreasing lengths.
        Ties are broken by choosing the rightmost one.
       Result: ["ra","pc","ets"]

Implicitly print each row separated by newlines.

J , 69 byte

-3 byte grazie a FrownyFrog

[:(}:@[,{:@[,])&>/[:((|:@|.@[,#@[$]);#@[}.])&>/^:(<:&#&>/)^:_,.@{.;}.

Provalo online!

spiegazione

[: (}:@[ , {:@[ , ])&>/ [: ((|:@|.@[ , #@[ {. ]) ; #@[ }. ])&>/^:(<:&#&>/)^:_ }. ;~ 1 1 $ {.

L'algoritmo è semplice nonostante sia un po 'prolisso per J.

Strategia generale: riduci l'input in una tabella quadrata, con un pezzo (possibilmente vuoto) rimanente.

Riducendo, utilizzeremo un elenco di caselle di 2 elementi. Il nostro "risultato finora" sarà il primo riquadro e "gli articoli rimanenti da elaborare" saranno il secondo riquadro. La prima casella verrà inizializzata in testa all'input (ma convertita in una tabella):

1 1 $ {.

e "gli elementi rimanenti da elaborare" saranno la coda dell'input:

}. ;~

Ora abbiamo:

┌─┬─────┐
│c│arpet│
└─┴─────┘

dove la 'c' è in realtà una tabella 1x1.

Lo riduciamo usando un ciclo J Do ... While:

^:(...)^:_

Dove la parte tra parentesi è la condizione "continua":

<:&#&>/

che dice "continua mentre la lunghezza della casella destra è maggiore o uguale alla lunghezza della casella sinistra (ovvero, la lunghezza laterale della matrice quadrata)

Che cosa significa "continua"? Questo è definito nel verbo a sinistra del primo ^:, che ci dice come prendere il risultato corrente e produrre l'iterazione successiva. Quel verbo è:

((|:@|.@[ , #@[ {. ]) ; #@[ }. ])&>/

Analizziamolo:

((|:@|.@[ , #@[ {. ]) ; #@[ }. ])&>/
(  verb in parens               )&>/ NB. put the verb in parens
                                     NB. between the two items
                                     NB. of our list, and unbox
                                     NB. them into left / right
                                     NB. args ([ / ]) for the verb
 (|:@|.@[ , #@[ {. ]) ; #@[ }. ]     NB. breaking down verb in 
                                     NB. parens...
                      ; ....         NB. new "remaining items":
                            }. ]     NB. remove from remaining
                        #@[          NB. the size of a side of
                                     NB. the result matrix
                ....  ;              NB. new "result":
  |:@|.@[                            NB. rotate existing result
          ,                          NB. and put it on top of
            #@[ {. ]                 NB. the items we removed
                                     NB. from remaining items

Cioè, questo è solo un algoritmo descritto nell'OP tradotto letteralmente in J.

Finalmente ci occupiamo degli (eventualmente 0) elementi rimanenti, la coda del nostro rotolo di moquette:

(}:@[ , {:@[ , ])&>/

Questo dice "prendi tutto tranne l'ultimo olmo del risultato":

}:@[ 

e aggiungerlo agli ,ultimi elementi del risultato {:@[con gli elementi rimanenti aggiunti all'ultimo elemento, ]

R , 146 132 byte

function(s){m=F[F]
while({m=rbind(t(m)[,F:0],s[1:F])
s=s[-1:-F]
length(s)>sum(F<-dim(m))})0
write(m[F:1,],1,F[1],,"")
cat(s,sep="")}

Provalo online!

Implementa la procedura di moquette. Accetta input come un elenco di caratteri e stampa su stdout.

Salvato 14 byte trovando un modo per usare un do-whileciclo e inizializzando usando F.

function(s){
m=F[F]					# logical(0); create an empty array (this gets automatically promoted to character(0) later
while(					# do-while loop
      {m=rbind(t(m)[,F:0],s[1:F])	# rotate m counterclockwise and add the first F characters of s to the bottom
       s=s[-1:-F]			# remove those characters
       length(s)>sum(F<-dim(m))})0	# while the number of characters remaining is greater than the sum of m's dimensions
write(m[F:1,],1,F[1],,"")		# write the rolled portion write writes down the columns, we reverse each column
cat(s,sep="")				# and write the remaining characters
}

Gelatina , 30 byte

_{Sembra troppo lungo ...}

ḢW,ðZU;Ls@¥©ḢWɗ,®Ẏ¤ð/ẈṢƑ$¿ḢY;Ɗ

Provalo online!

Come?

ḢW,ðZU;Ls@¥©ḢWɗ,®Ẏ¤ð/ẈṢƑ$¿ḢY;Ɗ - Main Link: list of characters
Ḣ                              - pop and yield head
 W                             - wrap in a list
  ,                            - pair with (the remaining list after Ḣ)
                         ¿     - while...
                        $      - ...condition: last two links as a monad:
                     Ẉ         -   length of each
                       Ƒ       -   is invariant under:
                      Ṣ        -     sort
                    /          - ...do: reduce by:
   ð               ð           -   the enclosed dyadic chain -- i.e. f(head, tail):
    Z                          -     transpose
     U                         -     reverse each (giving a rotated head)
              ɗ                -     last three links as a dyad:
          ¥                    -       last two links as a dyad:
       L                       -         length (i.e. number of rows in current roll)
         @                     -         with swapped arguments:
        s                      -           split (the tail) into chunks of that length
           ©                   -       (copy to register for later)
            Ḣ                  -       pop and yield head (Note register "copy" is altered too)
             W                 -       wrap in a list
      ;                        -     concatenate (the rotated head with the first chunk of the tail)
                  ¤            -     nilad followed by link(s) as a nilad:
                ®              -       recall from register (other chunks of tail, or an empty list)
                 Ẏ             -       tighten (the chunks to a flat list)
               ,               -     pair (the concatenate result with the tightened chunks)
                             Ɗ - last three links as a monad:
                          Ḣ    -   pop and yield head
                           Y   -   join with newline characters
                            ;  -   concatenate (the remaining tail)
                               - when running as a full program implicitly prints

05AB1E , 41 byte

g©L¦€DD2šηO®>‹Ï©IŽ8OS®g4α._.ΛðÜI®O®g->.$«

Troppo a lungo, ma volevo usare la tela .. Che probabilmente era una cattiva scelta ora che l'ho finita e si è rivelata così lunga ..

Provalo online . (Nessuna suite di test, perché sembra esserci uno strano problema con il .Λbuiltin ..)

Spiegazione:

Vorrei iniziare dando una spiegazione generale della tela e di ciò che volevo realizzare con il mio codice. Informazioni più dettagliate sono disponibili in questo mio suggerimento 05AB1E pertinente , ma per questa sfida ho voluto fare quanto segue:

Il built-in Canvas accetta tre parametri:

• $a$[2,2,3,3,4,4,5,5,...]
• $b$
• $c$$[2,0,6,4]$$[→,↑,←,↓]$$n$carpet$[0,6,4,2]$0123456789ABCDEFGHI$[6,4,2,0]$

Per quanto riguarda il codice:

g                # Get the length of the (implicit) input-string
 ©               # Store it in the register (without popping)
  L              # Create a list in the range [1,length]
   ¦             # Remove the first item to make the range [2,length]
    €D           # Duplicate each to get the list [2,2,3,3,4,4,5,5,...]
      D2š        # Create a copy and prepend a 2: [2,2,2,3,3,4,4,5,5,...]
         η       # Get the prefixes: [[2],[2,2],[2,2,2],[2,2,2,3],...]
          O      # Sum each prefix: [2,4,6,9,12,16,20,...]
           ®     # Push the length from the register again
            >‹   # Check for each summed prefix if it's <= length
              Ï  # And only leave the truthy values
               © # And store this in the register (without popping)
                 # (This is our `a` for the Canvas builtin)
I                # Push the input-string
                 # (This is our `b` for the Canvas builtin)
Ž8O              # Push compressed integer 2064
   S             # Converted to a list of digits: [2,0,6,4]
    ®g           # Push the list from the register, and get its length
      4α         # Get the absolute difference with 4
        ._       # And rotate the [2,0,6,4] that many times towards the left
                 # (This is our `c` for the Canvas builtin)
.Λ               # Now use the Canvas builtin, without printing it yet
  ðÜ             # Remove any trailing spaces (since the Canvas implicitly makes a rectangle)
     ®O          # Push the sum of the list from the register
       ®g-       # Subtract the length of the list from the register
          >      # And add 1
    I      .$    # Remove that many leading characters from the input-string
             «   # And append it at the end of the roll created by the Canvas
                 # (after which the result is output implicitly)

Vedere questo 05AB1E punta del mio (sezione Come comprimere grandi numeri interi? ) Per capire il motivo per cui Ž8Oè 2064.

Python 3 , 112 byte

r=lambda t,h=[[]]:len(h)>len(t)and h[:-1]+[h[-1]+list(t)]or r(t[len(h):],list(zip(*h[::-1]))+[list(t)[:len(h)]])

In questo caso, l'output è il valore della funzione.

Provalo online!

Se si preferisce, qui un'altra soluzione (più lunga, 129 byte ) che stampa direttamente l'input ottenuto:

r=lambda t,h=['']:len(h)>len(t)and set(map(print,h[:-1]+[h[-1]+t]))or r(t[len(h):],list(map(''.join,zip(*h[::-1])))+[t[:len(h)]])

Provalo online!

MATLAB / Octave , 154 byte

Non il più corto, ma giocare a golf in MATLAB / Octave è sempre divertente :)

function h=r(t,h);n=fliplr(h');s=size(n,2);q=numel(t);if s<=q h=r(t(max(s,1)+1:end),[n; t(1:max(s,1))]);elseif q>0 h(:,end+q)=' ';h(end,end-q+1:end)=t;end

Provalo online!