Mots tordus!

Étant donné une chaîne et un entier positif. Vous devez tordre la corde, d'avant en arrière.

Exemple d'entrée / sortie

Contribution

Programming Puzzles & Code Golf
4

Sortie

Prog
mmar
ing 
zzuP
les 
oC &
de G
 flo

Contribution

L'entrée peut être prise via STDIN ou un argument de fonction. L'entrée consistera en une chaîne et un entier positif, n . Le nombre entier déterminera la longueur de chaque ligne torsadée.

La chaîne est tordue d'avant en arrière. Une entrée de HELLO, WORLD!et 5 ressemblerait à ceci:

Sortie

La sortie sera le texte tordu. Ce ne peut pas être un espace de fuite. Si la longueur de la chaîne en entrée n'est pas divisible, insérez un espace jusqu'à ce que la ligne soit remplie:

Un exemple de ceci:

Contribution

Hello, World!
5

Sortie (notez les espaces à la fin)

Hello
roW ,
ld!  

Pyth, 19 15

VPc+z*dQQ_W~!ZN

Pré-remplit la chaîne, puis inverse l’autre ligne lorsqu’elle l’imprime. Le remplissage est égal à la taille de la boîte, mais la dernière ligne après avoir découpé l'entrée est supprimée.

Essayez-le ici

CJam, 19 octets

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

Exemple d'entrée:

5 "Hello, World!"

Des explications

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

Bonhomme de neige 1.0.1 , 91 octets

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

Ou tous sur une seule ligne (pour l'esthétique, ou plus précisément l'anti-esthétique), au prix de 2 octets:

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

C'est trop court pour Snowman. (C'est probablement le plus court possible; cependant, j'ai travaillé assez longtemps au golf.)

Cela comporte une mise en garde: il sortira avec une erreur (mais produira toujours la sortie correcte) 50% du temps, lorsque la dernière ligne n'est pas inversée. (C’est parce que j’ai l'habitude agde regrouper les éléments du tableau en groupes de deux pour pouvoir inverser les uns sur les autres, mais je ne vérifie pas si le dernier élément contient les deux éléments attendus. Il tentera donc d'accéder à un élément inexistant si il y a un nombre impair de lignes.)

Ungolfed / explication:

{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

Prend des ncaractères à la fois dès le début s, en les imprimant avec une direction dalternant entre 1et -1. Pour l'espacement sur la dernière ligne, il sest complété d' nespaces à la fin avant d'être haché, ce qui ne l'affecte que s'il reste moins de ncaractères.

Une solution récursive sauverait un caractère (59) sauf qu’il laisse une nouvelle ligne, ce qui n’est pas autorisé.

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

Haskell , 83 à 75 octets

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

Une chunksOfmise en œuvre simple avec take and drop, appliquant un nombre pair ou impair de retours à la sortie au fur et à mesure.

Merci à @BMO pour cinq octets et à @ Øjanjohansen pour trois octets!

Essayez-le en ligne!

Coincé , 42 41 40 38 octets

C'est un peu trop long, probablement essayer de jouer plus!

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

L'entrée devrait être comme "string"|n.

Explication:

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 octets

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

C'est un peu long, jeez. Ici c'est en action:

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

Python 2, 109 octets

Il a fallu ajouter un rembourrage avec des espaces pour que la dernière ligne soit correcte.

Essayez-le ici

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 octets

Ancienne version:

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

Nouvelle version:

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

O, 60 octets

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

Mon tout premier programme O, et un long en plus!

Démo en direct.

Perl, 87 octets

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

Ancienne version (affiche un retour à la ligne):

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

La chaîne est transmise en tant qu'argument de fonction sans nouvelle ligne. Appelle comme ça:

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

Oreillons, 86 octets

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

Bien que cela puisse être 2 octets plus court si vous supprimez le premier ",!" caractères dans l'instruction R (extrait de STDIN); qui ajoute un retour chariot entre l’entrée et la sortie. Si ce n'était pas là, la sortie est techniquement correcte, mais la première ligne apparaîtrait ajoutée à la chaîne d'entrée. [[Le terminal standard Mumps que j'utilise n'a pas d'écho local. ]]   En l'état, voici le 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 

Notez également qu'il y a en fait un retour chariot / Entrée enfoncé entre le '123' et le '6' à la fin de l'entrée. [[L'écho local à nouveau. ]]

Si quelqu'un est intéressé, je peux décrire ce qui se passe dans le code. mais je me rends compte qu'il n'y a pas une tonne d'amateurs d'oreillons là-bas ... :-)

PowerShell, 102 octets

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

Invoqué comme suit (si enregistré dans un fichier CodeGolf55051.ps1)

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

Tentatives précédentes

(plus long ou invalide)

PowerShell, 110 octets

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

PowerShell, 111 octets

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

Explication

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 octets

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 octets

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

Explication

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

( {...}dans les commentaires ci-dessus, c’est en fait {0}|{1}|{2}; j’ai mis {...}pour une meilleure lisibilité.

Powershell, 120 octets (invalide)

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

Clojure, 83 octets, 87 octets , 79 octets

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

plusieurs corrections après les commentaires ci-dessous, merci Ørjan .

Essayez-le en ligne!

Clojure semble souvent tristement absent des réponses au code de golf. Il ne peut certainement pas rivaliser en longueur d’octets avec les langues de golf, mais je pense que l’absence totale est quelque peu injustifiée.

Explication:

• in-data, deux arguments un nombre et une chaîne
• démarrer en exécutant clojure intégré fonction partition sur chaîne de ssegmentation dans une séquence de listes de caractères où les listes ont une longueur n. Le dernier morceau sera complété avec des espaces à la longueur en nutilisant la "collection de pads" renvoyée (repeat " ")qui renvoie une séquence infinie d'espaces paresseux
• on appelle alors map avec trois arguments:
  • une fonction anonyme (la #(..))
  • une séquence infinie de fonctions alternées #(or %)qui fonctionnent comme la fonction d' identité et l' inverse (c'est-à-dire [#(or %) reverse #(or %) reverse ...]) renvoyé par cycle .
  • la séquence paresseuse de listes retournées par partition.
• enfin la fonction anonyme #(apply ...) :
  • appelle soit identityou reversealternativement sur un morceau. Cela se fait via l' (% %2)expression qui appelle la fonction envoyée en tant que premier argument à la fonction anonyme [ie identityou reverse] en utilisant le second argument [ie le morceau] à la fonction anonyme en tant qu'argument de l'appel.
  • appels (apply str ...)à convertir la liste de caractères en une chaîne
• la fonction externe renvoie une séquence paresseuse de chaînes

Une astuce que nous utilisons ici est que beaucoup de fonctions de type clojure, telles que mapprendre un nombre arbitraire de collections comme arguments, c'est-à-dire (map f coll1 coll2 coll3 ...)lorsque la fonction f doit simplement accepter autant d'arguments qu'il y a de collections. Dans ce cas, nous envoyons deux collections, une collection de références de fonctions en alternance et la chaîne tronquée.

APL (Dyalog Unicode) , 19 octets

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

Essayez-le en ligne!

Tirez le ⊢∘⌽\tour de la brillante réponse de ngn au défi de la boustrophédonisation .

Après avoir réalisé que ma soumission était interrompue pour les lignes comportant de nouvelles lignes principales, j'ai ajouté deux octets supplémentaires. Ci-dessous, la soumission la plus ancienne.

APL (Dyalog Unicode) , 17 octets

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

Essayez-le en ligne!

Python 3, 110 108 107 103 octets

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

(en regardant d'autres réponses), avec rjust:95 93 92 90 octets

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 octets

Prend deux arguments en ligne de commande, comme indiqué avec $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 octets

Cela semble trop long.

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 octets

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 octets

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

Essayez-le ici

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 octets

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

• {}est une fonction qui devrait être appelée comme {}[x;y].
  • x sera la chaîne.
  • y sera la longueur des lignes résultantes.

Tester:

{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

edit : Utilise des fonctions plus courtes inspirées de l'autre réponse q de @tmartin

Python 2, 82 75 octets

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

Je ne pouvais pas commenter sur @willem mais j'ai rendu son code plus petit.

Essayez ici Essayez ici

Perl, 72 octets

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

70 octets, plus 2 octets pour -p0.

Démo:

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

Notez que l'entrée lue à partir de STDIN ne peut pas se terminer par une nouvelle ligne (cela coûterait 2 octets supplémentaires).

Explication:

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 octets

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}

Appel avec t(input_string, twist_length), qui retourne la chaîne de sortie.

Perl 5 , 51 octets

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

Essayez-le en ligne!

Ruby, 80

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

Démo en ligne: http://ideone.com/w6o8PI

Coffeescript, 151 octets

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

Trop = (

Bash, 83 74

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

Cela alterne entre cat et revpour les sous-chaînes du premier argument avec une longueur du second argument.

Les variables spéciales utilisées incluent

• ${#1} (la longueur de la chaîne $1 )
• ((i/$2%2))(Une expression arithmétique divisant incrémenteur $ien $2puis prenant son modulo pour déterminer impair / pair, ce qui dicte d’utiliser ou nonrev )
• ${1:i:$2}(sous-chaîne de $1départ en position $iavec une longueur de $2).

JavaScript ES6, 113 octets

Juste mon propre crack à ma propre question. Cela va ajouter des espaces, donc c'est divisible par n, de cette façon, c'est tout simplement diviser et inverser.

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