Palabras retorcidas!

Dada una cadena y un entero positivo. Debes torcer la cuerda, de un lado a otro.

Ejemplo de entrada / salida

Entrada

Programming Puzzles & Code Golf
4

Salida

Prog
mmar
ing 
zzuP
les 
oC &
de G
 flo

Entrada

La entrada puede tomarse a través de STDIN o argumento de función. La entrada consistirá en una cadena y un entero positivo, n . El entero determinará la longitud de cada línea torcida.

La cuerda está retorcida de un lado a otro. Una entrada de HELLO, WORLD!y 5 se vería así:

Salida

El resultado será el texto retorcido. Puede que no haya ningún espacio en blanco al final. Si la longitud de la cadena de entrada no es divisible por la longitud de la línea, agregue un espacio hasta que se complete la línea:

Un ejemplo de esto:

Entrada

Hello, World!
5

Salida (tenga en cuenta el espacio en blanco al final)

Hello
roW ,
ld!  

Pyth, 19 15

VPc+z*dQQ_W~!ZN

Rellena previamente la cadena y luego invierte la línea a medida que la imprime El relleno es igual al tamaño del cuadro, pero la última línea después de cortar la entrada se descarta.

Pruébalo aquí

CJam, 19 bytes

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

Ejemplo de entrada:

5 "Hello, World!"

Explicaciones

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

Muñeco de nieve 1.0.1 , 91 bytes

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

O todo en una línea (para estética, o más específicamente, antiestética), a un costo de 2 bytes:

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

Esto es demasiado corto para Snowman. (Sin embargo, es probable que sea lo más corto que pueda ser; trabajé en jugar al golf durante bastante tiempo).

Esto tiene una advertencia: saldrá con un error (pero aún producirá la salida correcta) el 50% del tiempo, cuando la última línea no está invierte. (Esto se debe a que uso agpara agrupar los elementos de la matriz en grupos de dos para poder invertir todos los demás, pero no compruebo si el último elemento tiene ambos elementos esperados, por lo que intentará acceder a un elemento inexistente si hay un número impar de líneas)

Sin golf / explicación:

{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

Pitón 2, 60

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

Toma ncaracteres a la vez desde el de s, imprimiéndolos con una dirección dque alterna entre 1y -1. Para el espaciado en la última línea, sse rellena con nespacios al final antes de cortarlo, lo que solo lo afecta cuando tiene menos den quedan caracteres.

Una solución recursiva ahorraría un carácter (59) excepto que deja una nueva línea final, que no está permitida.

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

Haskell , 83 75 bytes

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

Simple chunksOfImplementación con tomar y soltar, aplicando un número par o impar de reversiones a la salida a medida que avanzamos.

¡Gracias a @BMO por cinco bytes y a @ ØrjanJohansen por tres bytes!

Pruébalo en línea!

Atascado , 42 41 40 38 Bytes

Esto es demasiado largo, ¡probablemente intente jugar más al golf!

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

La entrada debería ser como "string"|n.

Explicación:

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 bytes

(#)=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

Eso es bastante largo, Dios. Aquí está en acción:

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

Python 2, 109 bytes

Tuve que agregar relleno con espacios para que la última línea sea correcta.

Pruébalo aquí

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 bytes

Versión antigua:

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

Nueva versión:

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

O, 60 bytes

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

Mi primer programa O, ¡y uno largo!

Demo en vivo.

Perl, 87 bytes

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

Versión anterior (imprime una nueva línea final):

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

La cadena se pasa como un argumento de función sin nueva línea final. Llama así:

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

Paperas, 86 bytes

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)),!

Aunque podría ser 2 bytes más corto si elimina el primer ',!' caracteres en la declaración R (leída de STDIN); que agrega un retorno de carro entre la entrada y la salida. Si eso no estuviera allí, la salida es técnicamente correcta, pero la primera línea aparecerá adjunta a la cadena de entrada. [[El terminal estándar de paperas que uso no tiene eco local. ]]   Tal como está, aquí está la prueba:

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 

También tenga en cuenta que en realidad hay una pulsación de tecla de retorno / entrada de carro entre el '123' y el '6' al final de la entrada. [[El eco local de nuevo. ]]

Si alguien está interesado, puedo describir lo que sucede con el código; pero me doy cuenta de que no hay muchos entusiastas de las paperas ... :-)

PowerShell, 102 bytes

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

Se invoca de la siguiente manera (si se guarda en el archivo CodeGolf55051.ps1)

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

Intentos previos

(más largo o inválido)

PowerShell, 110 bytes

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

PowerShell, 111 bytes

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

Explicación

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 bytes

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 bytes

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})"|?{$_}

Explicación

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

( {...}en los comentarios anteriores es en realidad {0}|{1}|{2}; pongo {...}para mejorar la legibilidad.

Powershell, 120 bytes (no válido)

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

Clojure, 83 bytes, 87 bytes , 79 bytes

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

varias correcciones después de los comentarios a continuación, gracias Ørjan .

Pruébalo en línea!

Clojure parece a menudo tristemente ausente de las respuestas de golf de código. Ciertamente no puede competir en longitud de bytes con los idiomas de golf, pero creo que la ausencia total es algo injustificada.

Explicación:

• en datos, dos argumentos, un número y una cadena
• comience ejecutando la partición de función incorporada clojure en una cadena que se divides en una secuencia de listas de caracteres donde las listas tienen longitud n. El último fragmento se rellenará con espacios a la longitud nutilizando la "colección de almohadillas" devuelta por(repeat " ") cual se devuelve una secuencia infinita de espacios perezosos.
• luego llamamos mapa con tres argumentos:
  • una función anónima (la #(..) )
  • una secuencia infinita de funciones perezosas alternantes #(or %)que funciona como la función de identidad e inversa (es decir, [#(or %) reverse #(or %) reverse ...]como se devuelve por ciclo) .
  • la secuencia perezosa fragmentada de listas devueltas por partición.
• finalmente la función anónima #(apply ...) :
  • llama ya sea identityo reversealternativamente en un trozo. Esto se realiza mediante la (% %2)expresión que llama a la función enviada como primer argumento a la función anónima [es decir, identityoreverse ] usando el segundo argumento [es decir, el fragmento] a la función anónima como argumento a la llamada.
  • llamadas (apply str ...)para convertir la lista de caracteres en una cadena
• la función externa devuelve una secuencia perezosa de cadenas

Un truco que usamos aquí es que muchas funciones de clojure, como maptomar un número arbitrario de colecciones como argumentos, es decir, (map f coll1 coll2 coll3 ...)donde la función f solo necesita aceptar tantos argumentos como colecciones. En este caso, enviamos dos colecciones, una colección de referencias de funciones alternas y la cadena fragmentada.

APL (Dyalog Unicode) , 19 bytes

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

Pruébalo en línea!

Tomó el ⊢∘⌽\truco de la brillante respuesta de ngn al desafío de la boustrofedonía .

Después de darme cuenta de que mi envío se rompe para las líneas con nuevas líneas principales, he agregado dos bytes más. A continuación se muestra la presentación anterior.

APL (Dyalog Unicode) , 17 bytes

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

Pruébalo en línea!

Python 3, 110 108 107 103 bytes

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

(mirando otras respuestas), con rjust :95 93 92 90 bytes

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 bytes

Toma dos argumentos de línea de comandos como se muestra 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 bytes

Esto parece demasiado largo.

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 bytes

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)

Sin golf:

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 bytes

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

Pruébalo aquí

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 bytes

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

• {}es una función que debería llamarse como {}[x;y].
  • x Será la cadena.
  • y será la longitud de las líneas resultantes.

Prueba:

{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

editar : Utiliza funciones más cortas inspiradas en la otra respuesta q de @tmartin

Python 2, 82 75 bytes

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

No pude comentar sobre @willem pero reduje su código.

Prueba aquí Prueba aquí

Perl, 72 bytes

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

70 bytes, más 2 bytes para -p0.

Manifestación:

$ 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!  $

Tenga en cuenta que la entrada leída de STDIN no puede terminar con una nueva línea (que costaría 2 bytes adicionales).

Explicación:

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 bytes

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}

Llamar con t(input_string, twist_length), que devuelve la cadena de salida.

Perl 5 , 51 bytes

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

Pruébalo en línea!

Rubí, 80

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

Demostración en línea: http://ideone.com/w6o8PI

Coffeescript, 151 bytes

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

Demasiado = (

Bash, 83 74

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

Esto alterna entre catyrev para las subcadenas del primer argumento con una longitud del segundo argumento.

Las variables especiales utilizadas incluyen

• ${#1}(la longitud de la cuerda $1)
• ((i/$2%2))(una expresión aritmética que divide el incrementador $ientre $2y luego toma su módulo para determinar pares e impares, que dictaminó si usarlos o no rev)
• ${1:i:$2}(subcadena de $1inicio en la posición $icon una longitud de $2).

JavaScript ES6, 113 bytes

Solo mi propio crack ante mi propia pregunta. Agregará espacios para que sea divisible por n, de esa manera simplemente se divide y se invierte.

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