Torcendo palavras!

Dada uma string e um número inteiro positivo. Você deve torcer a corda, para frente e para trás.

Exemplo de entrada / saída

Entrada

Programming Puzzles & Code Golf
4

Saída

Prog
mmar
ing 
zzuP
les 
oC &
de G
 flo

Entrada

A entrada pode ser recebida através de STDIN, ou argumento de função. A entrada consistirá em uma sequência e um número inteiro positivo, n . O número inteiro determinará o comprimento de cada linha torcida.

A corda é torcida para frente e para trás. Uma entrada de HELLO, WORLD!e 5 seria semelhante a:

Saída

A saída será o texto distorcido. Pode não haver espaço em branco à direita. Se o comprimento da sequência de entrada não for divisível, seja o comprimento da linha, adicione um espaço até que a linha seja preenchida:

Um exemplo disso:

Entrada

Hello, World!
5

Saída (observe o espaço em branco no final)

Hello
roW ,
ld!  

Pitão, 19 15

VPc+z*dQQ_W~!ZN

Prepara previamente a corda e depois inverte a outra linha conforme a imprime. O preenchimento é igual ao tamanho da caixa, mas a última linha após cortar a entrada é descartada.

Experimente aqui

CJam, 19 bytes

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

Exemplo de entrada:

5 "Hello, World!"

Explicações

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

Boneco de neve 1.0.1 , 91 bytes

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

Ou tudo em uma linha (para estética, ou mais especificamente, antiestética), ao custo de 2 bytes:

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

Isso é muito curto, para Snowman. (É provavelmente o menor tempo possível; trabalhei no golfe por um longo tempo.)

Isso tem uma ressalva: ele sairá com um erro (mas ainda produzirá a saída correta) 50% do tempo, quando a última linha não for revertida. (Isso ocorre porque eu uso agpara agrupar os elementos da matriz em grupos de dois para que eu possa reverter todos os outros, mas não verifico se o último elemento tem os dois elementos esperados, portanto, ele tentará acessar um elemento inexistente se existe um número ímpar de linhas.)

Ungolfed / explicação:

{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

Pega ncaracteres de cada vez a partir de s, imprime-os com uma direção dque alterna entre 1e -1. Para espaçamento na última linha, sé preenchido com nespaços no final antes de ser cortado, o que só afeta quando há menos de ncaracteres restantes.

Uma solução recursiva salvaria um caractere (59), exceto que ele deixa uma nova linha à direita, o que não é permitido.

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

chunksOfImplementação simples com take and drop, aplicando um número par ou ímpar de reversões à saída à medida que avançamos.

Obrigado ao @BMO por cinco bytes e ao ØrjanJohansen por três bytes!

Experimente online!

Preso , 42 41 40 38 Bytes

Isso é um pouquinho longo demais, provavelmente tentará jogar mais!

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

A entrada deve ser como "string"|n.

Explicação:

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

Isso é meio tempo, caramba. Aqui está em ação:

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

Python 2, 109 bytes

Teve que adicionar preenchimento com espaços para a última linha estar correta.

Experimente aqui

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

Versão antiga:

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

Nova versão:

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

Meu primeiro programa de O, e muito longo!

Demonstração ao vivo.

Perl, 87 bytes

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

Versão antiga (imprime uma nova linha à direita):

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

String é passada como um argumento de função sem nova linha à direita. Ligue assim:

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

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

Embora possa ser 2 bytes mais curto se você remover o primeiro ',!' caracteres na instrução R (leia de STDIN); isso adiciona um retorno de carro entre a entrada e a saída. Se isso não existisse, a saída seria tecnicamente correta, mas a primeira linha apareceria anexada à sequência de entrada. [[O terminal Mumps padrão que eu uso não tem eco local. ]]   Como está, aqui está o teste:

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 

Observe também que, na verdade, há um retorno de carro / tecla Enter entre o '123' e o '6' no final da entrada. [[O eco local novamente. ]]

Se alguém estiver interessado, posso descrever o que está acontecendo com o código; mas percebo que não há muitos entusiastas de caxumba por aí ... :-)

PowerShell, 102 bytes

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

Chamado da seguinte forma (se salvo no arquivo CodeGolf55051.ps1)

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

Tentativas anteriores

(mais longo ou 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]}

Explicação

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

Explicação

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

( {...}nos comentários acima é realmente {0}|{1}|{2}; eu coloquei {...}para melhorar a legibilidade.

Powershell, 120 bytes (invá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))))

várias correções após os comentários abaixo, obrigado Ørjan .

Experimente online!

Clojure parece muitas vezes tristemente ausente das respostas do código de golfe. Certamente não pode competir em comprimento de bytes com idiomas de golfe, mas acho que a ausência total é um tanto injustificada.

Explicação:

• em dados, dois argumentos, um número e uma sequência
• comece executando a partição de função interna do clojure na string, dividindos -a em uma sequência de listas de caracteres em que as listas têm comprimento n. O último pedaço será preenchido com espaços no comprimento nusando a "coleção de blocos" retornada da (repeat " ")qual retorna uma sequência infinita de espaços lenta
• então chamamos map com três argumentos:
  • uma função anônima (a #(..))
  • uma sequência lenta e infinita de funções preguiçosas #(or %)que funciona como a função de identidade e a inversa (ou seja [#(or %) reverse #(or %) reverse ...]), retornada pelo ciclo .
  • a sequência lenta de listas retornada por partição.
• finalmente a função anônima #(apply ...) :
  • chama identityou reversealternadamente em um pedaço. Isso é feito através da (% %2)expressão que chama a função enviada como o primeiro argumento para a função anônima [ie identityou reverse] usando o segundo argumento [ie o pedaço] para a função anônima como argumento para a chamada.
  • chamadas (apply str ...)para converter a lista de caracteres em uma sequência
• a função externa retorna uma sequência lenta de seqüências de caracteres

Um truque que usamos aqui é que muitas funções de clojure mapusam um número arbitrário de coleções como args, ou seja, (map f coll1 coll2 coll3 ...)onde a função f só precisa aceitar tantos argumentos quanto coleções. Nesse caso, enviamos duas coleções, uma coleção de referências de função alternadas e a string fragmentada.

APL (Dyalog Unicode) , 19 bytes

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

Experimente online!

Tomou o ⊢∘⌽\truque da brilhante resposta da ngn ao desafio dos boferedados .

Depois de perceber que meu envio quebra para linhas com novas linhas principais, adicionei mais dois bytes. Abaixo está o envio mais antigo.

APL (Dyalog Unicode) , 17 bytes

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

Experimente online!

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

(olhando para outras respostas), com 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

Leva dois argumentos de linha de comando, como mostrado em $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

Isso parece muito longo.

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)

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

Experimente aqui

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;}

• {}é uma função que deve ser chamada como {}[x;y].
  • x será a string.
  • y será o comprimento das linhas resultantes.

Teste:

{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 : Utilizou funções mais curtas, inspiradas na outra resposta 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

Não pude comentar no @willem, mas reduzi o código dele.

Experimente aqui Experimente aqui

Perl, 72 bytes

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

70 bytes, mais 2 bytes para -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!  $

Observe que a entrada lida no STDIN não pode terminar com uma nova linha (isso custaria 2 bytes extras).

Explicação:

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}

Call with t(input_string, twist_length), que retorna a string de saída.

Perl 5 , 51 bytes

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

Experimente online!

Ruby, 80

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

Demonstração on-line: 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

Demais = (

Bash, 83 74

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

Isso alterna entre cate revpara substrings do primeiro argumento com um comprimento do segundo argumento.

Variáveis ​​especiais usadas incluem

• ${#1}(o comprimento da corda $1)
• ((i/$2%2))(uma expressão aritmética dividindo incrementor $ipor $2e, em seguida, tendo o seu módulo para determinar estranho vs mesmo, que ditada ou não ao uso rev)
• ${1:i:$2}(substring de $1iniciar na posição $icom um comprimento de $2).

JavaScript ES6, 113 bytes

Apenas meu próprio crack na minha própria pergunta. Ele adicionará espaços para que seja divisível n, dessa forma é simplesmente dividir e reverter.

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