Parole contorte!

Data una stringa e un numero intero positivo. Devi torcere la corda, avanti e indietro.

Esempio di input / output

Ingresso

Programming Puzzles & Code Golf
4

Produzione

Prog
mmar
ing 
zzuP
les 
oC &
de G
 flo

Ingresso

L'ingresso può essere accettato tramite STDIN o argomento della funzione. L'input sarà costituito da una stringa e un numero intero positivo, n . L'intero determinerà la lunghezza di ciascuna linea contorta.

La corda è attorcigliata avanti e indietro. Un input di HELLO, WORLD!e 5 sarebbe simile a:

Produzione

L'output sarà il testo contorto. Non può contenere spazi vuoti finali. Se la lunghezza della stringa di input non è divisibile per la lunghezza della linea, aggiungi uno spazio fino a riempire la linea:

Un esempio di questo:

Ingresso

Hello, World!
5

Output (notare lo spazio bianco alla fine)

Hello
roW ,
ld!  

Pyth, 19 15

VPc+z*dQQ_W~!ZN

Pre-pad la stringa, quindi si inverte a vicenda mentre la stampa. L'imbottitura è uguale alla dimensione della scatola, ma l'ultima riga dopo aver tagliato l'input viene scartata.

Provalo qui

CJam, 19 byte

q~1$S*+/W<{(N@Wf%}h

Esempio di input:

5 "Hello, World!"

spiegazioni

q~         e# Input n and the string.
1$S*+      e# Append n spaces to the string.
/W<        e# Split by each n characters, and remove the last chunk.
{          e# While the array of chunks isn't empty:
    (N     e# Extract the first chunk and push a newline.
    @Wf%   e# Reverse every chunk left in the array.
}h

Snowman 1.0.1 , 91 byte

{vg10vg|sB*#.'aGal'NdE'aaAaL|al!*+#5nS" "'aR'!#aCwR|.aC2aG:0aa|sP"
"sP'NdE|1aA.aNsP"
"sP;aE

O tutto su una linea (per l'estetica, o più specificamente, antiestetica), al costo di 2 byte:

{vg10vg|sB*#.'aGal'NdE'aaAaL|al!*+#5nS" "'aR'!#aCwR|.aC2aG:0aa|sP10wRsP'NdE|1aA.aNsP10wRsP;aE

È troppo breve per Snowman. (È probabilmente il più breve che può ottenere, però; ho lavorato sul golf per un tempo piuttosto lungo.)

Questo ha un avvertimento: uscirà con un errore (ma produrrà comunque l'output corretto) il 50% delle volte, quando l'ultima riga non viene invertita. (Questo perché uso agi gruppi di elementi in gruppi di due in modo da poterli invertire reciprocamente, ma non controllo se l'ultimo elemento ha entrambi gli elementi previsti, quindi proverò ad accedere a un elemento inesistente se c'è un numero dispari di righe.)

Ungolfed / spiegazione:

{vg10vg|sB*#      // get input, convert second string to number and store
.'aG              // split string into groups of n chars
al'NdE'aaAaL      // take out the last element of the array
|al!*+#5nS" "'aR  // subtract its length from 5, repeat that many spaces
'!#aCwR|.aC       // concat spaces to last el. and that back to the array
2aG               // split in groups of 2, so we can reverse every other string
// for each sub-group in the array of groups...
:
    0aa|sP10wRsP         // print the first element as is
    'NdE|1aA.aNsP10wRsP  // print the second element, reversed
;aE

Python 2, 60

s,n=input()
d=1
while s:print(s+n*' ')[:n][::d];s=s[n:];d=-d

Prende i npersonaggi alla volta dal di s, stampandoli con una direzione dche si alterna tra 1e -1. Per la spaziatura sull'ultima riga, sè imbottito conn spazi alla fine prima di essere tagliato, il che influisce solo quando ha meno ncaratteri rimanenti.

Una soluzione ricorsiva salverebbe un carattere (59) tranne per il fatto che lascia una nuova riga finale, il che non è consentito.

f=lambda s,n,d=1:s and(s+n*' ')[:n][::d]+"\n"+f(s[n:],n,-d) 

Haskell , 83 75 byte

(id!)
(f![])_=[]
(f!l)n=f(take n$l++cycle" ")++'\n':((f.reverse)!drop n l)n

Semplice chunksOfImplementazione con take and drop, applicando un numero pari o dispari di inversioni all'output mentre procediamo.

Grazie a @BMO per cinque byte e @ ØrjanJohansen per tre byte!

Provalo online!

Bloccato , 42 41 40 38 byte

È un po 'troppo lungo, probabilmente proverò a giocare di più!

tg;_lu_@%u;-_0G<*' *+0GKE"];2%;Y_Y?p":

L'input dovrebbe essere simile "string"|n.

Spiegazione:

tg                 # Take input, place each item on stack, save the int to variable stack                                        
;_l                # Swap the top two items, duplicate the string and obtain length
u_@%               # Rotate to the left, duplicate, rotate right and take mod
u;-                # Rotate left, swap the top two and subtract from each other
_0G<*              # duplicate this value, check if less than stored int and multiply
' *+               # Push space onto stack n times, append to starting string
0GKE               # Split this string into segments, and enumerate
"];2%;Y_Y?p":      # For each segment, determine if should be reversed, and print

Haskell, 108 byte

(#)=splitAt
s!n=let(a,t)=n#s;(b,u)=n#t in a:reverse b:(u!n)
s%n=unlines$takeWhile(any(>' '))$(s++cycle" ")!n

È un po 'lungo, cavolo. Eccolo in azione:

*Main> putStrLn $ "Programming Puzzles & Code Golf" % 4
Prog
mmar
ing
zzuP
les
oC &
de G
 flo

Python 2, 109 byte

Ho dovuto aggiungere un'imbottitura con spazi affinché l'ultima riga fosse corretta.

Provalo qui

I,c=input()
I+=(c-len(I)%c)*" "
L=[]
i=0
while I:s=I[:c];L+=[[s,s[::-1]][i%2]];i+=1;I=I[c:]
print"\n".join(L)

Lua, 91 88 88 84 83 82 byte

Vecchia versione:

a=arg for i=1,#a[1],a[2]do s=a[1]:sub(i,i+a[2]-1)print(d and s:reverse()or s)d=not d end

Nuova versione:

arg[1]:gsub((".?"):rep(arg[2]),function(s)print(d and s:reverse()or s)d=not d end)

O, 60 byte

z""/rlJ(Q/{n:x;Q({+}dxe{`}{}?p}drQJQ%-{' }dJQ/e{r}{}?Q({o}dp

Il mio primissimo programma O, e molto lungo!

Dimostrazione dal vivo.

Perl, 87 byte

sub f{$_=@_[0].$"x(@_[1]-1);$a.=(($i++&1?reverse$1:$1).$/)while/(.{@_[1]})/g;chop$a;$a}

Vecchia versione (stampa una nuova riga finale):

sub f{$_=@_[0].$"x(@_[1]-1);print(($i++&1?reverse$1:$1).$/)while/(.{@_[1]})/g}

La stringa viene passata come argomento di funzione senza nuova riga finale. Chiama in questo modo:

$_=<>;chomp;print f($_,5);

Parotite, 86 byte

R I,S,! S P=$L(I),$P(I," ",P)=P F Q=1:S:P S F=$E(I,Q,Q+S-1),P='P W $S('P:F,1:$RE(F)),!

Anche se potrebbe essere più corto di 2 byte se si rimuove il primo ",!" caratteri nell'istruzione R (leggi da STDIN); che aggiunge un ritorno a capo tra l'input e l'output. In caso contrario, l'output è tecnicamente corretto, ma la prima riga sembrerebbe aggiunta alla stringa di input. [[Il terminale Mumps standard che utilizzo non ha eco locale. ]]   Così com'è, ecco il test:

R I,S,! S P=$L(I),$P(I," ",P)=P F Q=1:S:P S F=$E(I,Q,Q+S-1),P='P W $S('P:F,1:$RE(F)),!
ABCDEFGHIJKLMNOPQRSTUVWXYZ1236
ABCDEF
LKJIHG
MNOPQR
XWVUTS
YZ123 

Inoltre, in realtà c'è un ritorno a capo / Invio premuto tra '123' e '6' alla fine dell'ingresso. [[Di nuovo l'eco locale. ]]

Se qualcuno è interessato posso descrivere cosa sta succedendo con il codice; ma mi rendo conto che non ci sono un sacco di appassionati di parotite là fuori ... :-)

PowerShell, 102 byte

param($s,$i)$l=$s.Length;$s+' '*($i%$l)-split"(.{$i})"|?{$_}|%{$r=-not$r;@($_,($_[$l..0]-join''))[$r]}

Richiamato come segue (se salvato su file CodeGolf55051.ps1)

.\CodeGolf55051.ps1 -s '1234567890' -i 4

Tentativi precedenti

(più lungo o non valido)

PowerShell, 110 byte

param($s,$i)$l=$s.Length;$s+' '*(($i-$l%$i)%$i)-split"(.{$i})"|?{$_}|%{$r=-not$r;@($_,($_[$l..0]-join''))[$r]}

PowerShell, 111 byte

param($s,$i)$s+' '*(($i-$s.Length%$i)%$i)-split"(.{$i})"|?{$_}|%{$r=-not$r;@($_,($_[$_.length..0]-join''))[$r]}

Spiegazione

param($s,$i)                         #Take input text (s) and column width (i)
$s                                   #take the user entered string
+ ' ' * (($i - $s.Length % $i) % $i) #add the least number of spaces required to make its length divisible by i
-split"(.{$i})"                      #break it into chunks of i characters in length
| ?{$_}                              #skip any blank lines created in the process
| %{                                 #for each line
    $r = -not $r;                    #    toggle a boolean value
    @(                               #    define an array
        $_                           #    index 0 = the string going forwards
        ,($_[$_.length..0] -join '') #    index 1 = the string reversed (by taking each character from the last to the first, then joining them)
    )[$r]                            #    if our boolean value is false take the forward string (index 0), if true take the backwards one (index 1)
}                                    #next

PowerShell, 180 byte

param($s,$i)$x="`${0}|{1}|`${2}";$w=$x;1..$i|%{$w=$w-f$_,$x,($i+$_)};$w=$w-replace'\||\${.*}';$r=$w-replace'\$\d+','(.)?';$s+' '*($i-$s.Length%$i)-replace$r,$w-split"(.{$i})"|?{$_}

PowerShell, 196 byte

param($s,$i)$x="{0}|{1}|{2}";$w=$x;1..$i|%{$w=$w-f$_,$x,($i+$_)};$w=$w-replace'(\d+)','$$$1'-replace'\||{.*}';$r=$w-replace'\$\d+','(.)?';$s+' '*($i-$s.Length%$i)-replace$r,$w-split"(.{$i})"|?{$_}

Spiegazione

param ($s, $i)                      #Take input text (s) and column width (i)

$x = "{0}|{1}|{2}"                  #Define string format which takes 3 entries and pipe delimits them

$w = $x                             #initialise our replacement regex with this format
1..$i | %{                          #for 1 to the specified column width
    $w = $w -f $_, $x, ($i + $_)    #update the regex 1|{...}|5, 1|2|{...}|6|5, etc
}                                   #resulting in w = 1|2|3|4|{...}|8|7|6|5
$w = $w -replace '(\d+)', '$$$1'    #now prefix the numbers with a dollar (so they're regex replacement variables)
        -replace '\||{.*}'          #and remove the delimiters and superfluous `{...}` left from our middle insertion routine

$r = $w -replace '\$\d+', '(.)?'    #then create the match pattern by replacing the variables with optional single character captures

$s                                  #now take the user entered string
    + ' ' * ($i - $s.Length % $i)   #add the least number of spaces required to make its length divisible by i
    -replace $r, $w                 #perform a replacement using the regex match and replace patterns created above
    -split "(.{$i})"                #then split the string into blocks of length i
    | ?{$_}                         #removing any blank lines created in the process

( {...}nei commenti sopra è in realtà {0}|{1}|{2}; ho messo {...}per una migliore leggibilità.

Powershell, 120 byte (non valido)

param($s,$i)$s + ' ' * ($i-$s.Length%$i) -replace '(.{4})?(.)(.)(.)(.)',"`$1`n`$5`$4`$3`$2`n" -split "`n" | ?{$_ -ne ""}

Clojure, 83 byte, 87 byte , 79 byte

(fn[n s](map #(apply str(% %2))(cycle[#(or %)reverse])(partition n n(repeat\ )s))))

diverse correzioni dopo i commenti qui sotto, grazie Ørjan .

Provalo online!

Clojure sembra spesso tristemente assente dalle risposte di golf del codice. Certamente non può competere nella lunghezza dei byte con le lingue del golf, ma penso che l'assenza totale sia in qualche modo ingiustificata.

Spiegazione:

• in-data, due argomenti un numero e una stringa
• iniziare eseguendo la partizione di funzione integrata clojure su stringa che las in una sequenza di elenchi di caratteri in cui gli elenchi hanno lunghezza n. L'ultimo pezzo verrà riempito di spazi per la lunghezza nusando la "collezione pad" restituita da(repeat " ") cui restituisce una sequenza infinita di spazi pigri
• chiamiamo quindi mappa con tre argomenti:
  • una funzione anonima (il #(..) )
  • una sequenza pigra alternata infinita di funzioni #(or %)che funziona come la funzione identità e viceversa (es[#(or %) reverse #(or %) reverse ...] ) restituita dal ciclo .
  • la sequenza pigra di liste tratteggiate restituite dalla partizione.
• infine la funzione anonima #(apply ...) :
  • chiama identityo reversealternativamente su un pezzo. Questo viene fatto tramite l' (% %2)espressione che chiama la funzione inviata come primo argomento alla funzione anonima [cioè identityo reverse] usando il secondo argomento [cioè il blocco] alla funzione anonima come argomento della chiamata.
  • chiama (apply str ...)per convertire l'elenco di caratteri in una stringa
• la funzione esterna restituisce una sequenza pigra di stringhe

un trucco che usiamo qui è che molte funzioni di clojure come mapprendere un numero arbitrario di raccolte come args, cioè (map f coll1 coll2 coll3 ...)dove la funzione f deve solo accettare tanti argomenti quanti sono le raccolte. In questo caso inviamo due raccolte, una raccolta di riferimenti a funzioni alternate e la stringa divisa.

APL (Dyalog Unicode) , 19 byte

{↑⊢∘⌽\↓↑⍵⊆⍨⌈⍺÷⍨⍳≢⍵}

Provalo online!

Ho preso il ⊢∘⌽\trucco dalla brillante risposta di Ngn alla sfida boustrophedonise .

Dopo aver realizzato che la mia presentazione si interrompe per le linee con le nuove linee principali, ho aggiunto altri due byte. Di seguito è la presentazione più vecchia.

APL (Dyalog Unicode) , 17 byte

{↑⊢∘⌽\⍵⊆⍨⌈⍺÷⍨⍳≢⍵}

Provalo online!

Python 3, 110 108 107 103 byte

def a(s,n):l=len(s)//n+1;s+=' '*(len(s)-l);print('\n'.join([s[x*n:n*x+n][::(-1)**x]for x in range(l)]))

(guardando altre risposte), con rjust :95 93 92 90 byte

def a(s,n):print('\n'.join([s[x*n:n*x+n][::(-1)**x].rjust(n)for x in range(len(s)//n+1)]))

PHP, 135 byte

Accetta due argomenti della riga di comando come mostrato con $argv.

<? foreach($a=str_split($s=$argv[1],$n=$argv[2])as$k=>&$v)$v=$k%2?$v:strrev($v);echo implode("\n",$a).str_repeat(' ',$n-strlen($s)%$n);

CoffeeScript, 131 byte

Questo sembra troppo lungo.

f=(s,n,r=l=s.length,i=0,z='')->(t=s[i...i+=n].split '';t=t.reverse()if r=!r;z+=t.join('')+(i<l&&'\n'||' '.repeat n-l%n))while i<l;z

Julia, 104 byte

f(s,n)=(L=length(s);L+=L÷n;j=0;for i=1:n:L-n+1 x=rpad(s,L)[i:i+n-1];println(j%2<1?x:reverse(x));j+=1end)

Ungolfed:

function f(s::String, n::Int)
    L = length(s) + length(s) ÷ n
    j = 0
    for i = 1:n:L-n+1
        x = rpad(s, L)[i:i+n-1]
        println(j % 2 == 0 ? x : reverse(x))
        j += 1
    end
end

Python 3, 101 byte

t,x=eval(input())
print("\n".join([t[c:c+x].ljust(x)[::1-2*(int(c/x)%2)] for c in range(0,len(t),x)]))

Provalo qui

q, 46

{-1@neg[y]$@[a;(&)(til(#)a:y cut x)mod 2;|:];}

.

q){-1@neg[y]$@[a;(&)(til(#)a:y cut x)mod 2;|:];}["Programming Puzzles & Code Golf";4]
Prog
mmar
ing
zzuP
les
oC &
de G
 flo

Q, 64 56 byte

{c::neg y;-1(til(#)l){$[x mod 2;c$(|:)y;y]}'l:y cut x;}

• {}è una funzione che dovrebbe essere chiamata come {}[x;y].
  • x sarà la stringa.
  • y sarà la lunghezza delle linee risultanti.

Test:

{c::neg y;-1(til(#)l){$[x mod 2;c$(|:)y;y]}'l:y cut x;}["Programming Puzzles & Code Golf";4]
Prog
mmar
ing
zzuP
les
oC &
de G
 flo

modifica : utilizzate funzioni più brevi ispirate all'altra risposta q di @tmartin

Python 2, 82 75 byte

s,n=input()
k=0
while k<=len(s):print s[k:k+n].ljust(n)[::1-2*(k/n%2)];k+=n

Non ho potuto commentare @willem ma ho ridotto il suo codice.

Prova qui Prova qui

Perl, 72 byte

perl -p0e's/\n(.*)/$"x($1-$-[0]%$1)/e;s/.{$1}/($i++%2?reverse$&:$&)."\n"/ge;chop'

70 byte, più 2 byte per -p0 .

demo:

$ echo -en 'Hello, World!\n5' | perl -p0e's/\n(.*)/$"x($1-$-[0]%$1)/e;s/.{$1}/($i++%2?reverse$&:$&)."\n"/ge;chop'
Hello
roW ,
ld!  $

Si noti che l'input letto da STDIN non può terminare con una nuova riga (costerebbe 2 byte extra).

Spiegazione:

perl -p0e'  # Read from STDIN, splitting on null bytes,
            # and print $_ automatically at the end

    s/
        \n(.*)  # Replace everything after first newline,
                # capturing wrap length in $1...
     /
        $"x($1-$-[0]%$1)  # ...with spaces until the total length of $_ is
                          # a multiple of $1 (i.e. right-pad with spaces)
     /e;

    s/
        .{$1}  # Replace series of $1 contiguous chars...
     /
        ($i++%2?reverse$&:$&)."\n"  # ...alternately with themselves or in
                                    # reverse, with a trailing newline
     /ge;

    chop'  # Remove final newline

JavaScript ES6, 123 byte

var t=(s,n)=>{for(var d=1,i=0,o='',l=s.length;i<l;i++){o+=d?s[i]:s[i-i%n+n-1-i%n]||' ';if(i%n==n-1){d=!d;o+='\n'}}return o}

Chiama con t(input_string, twist_length), che restituisce la stringa di output.

Perl 5 , 51 byte

$_.=$"x(($-=<>)-1);say--$|?$_:~~reverse for/.{$-}/g

Provalo online!

Ruby, 80 anni

->s,l{s+=' '*(l-s.size%l)
(s.size/l).times{|i|puts [x=s[i*l,l],x.reverse][i%2]}}

Demo online: http://ideone.com/w6o8PI

Coffeescript, 151 byte

f=(s,n)->r="";d=n;i=0;_="\n";u=" ";l=s.length;(d--and(r+=s[i]or u;++i)or(r+=_;r+=s[c]or u for c in[i+n-1..i];i+=d=n;r+=_ if i<l))while i<(l/n+1>>0)*n;r

Troppo = ((

Bash, 83 74

for((i=0;i<${#1};i+=$2));do b=cat;((i/$2%2))&&b=rev;echo ${1:i:$2}|$b;done

Questo si alterna tra caterev per sottostringhe del primo argomento con una lunghezza del secondo argomento.

Le variabili speciali utilizzate includono

• ${#1}(la lunghezza della stringa $1)
• ((i/$2%2))(un'espressione aritmetica che divide l'incremento $iper $2e quindi prendendo il suo modulo per determinare pari o dispari, che ha dettato se usare o meno rev)
• ${1:i:$2}(sottostringa di $1partenza in posizione $icon una lunghezza di $2).

JavaScript ES6, 113 byte

Solo il mio crack alla mia domanda. Aggiungerà spazi in modo che sia divisibile per n, in questo modo è semplicemente suddivisione e inversione.

(s,n)=>(s+' '.repeat(n-s.length%n)).match(eval(`/.{1,${n}}/g`)).map((l,i)=>i%2?[...l].reverse().join``:l).join`
`