Défi

Écrivez un programme ou une fonction qui accepte une chaîne set un entier ncomme paramètres. Votre programme doit imprimer (ou renvoyer) la chaîne une fois transformée comme suit:

En commençant en haut à gauche et en descendant vers la droite, écrivez scomme une vague de hauteur n. Ensuite, de haut en bas, combinez chaque ligne sous forme de chaîne (sans espaces).

Exemple

Compte tenu de la chaîne "WATERMELON" et d'une hauteur de 3:

La vague devrait ressembler à ceci:

W   R   O
 A E M L N
  T   E

Ensuite, combinez les rangées de haut en bas:

WRO
AEMLN
TE

Donc, votre programme devrait retourner la chaîne "WROAEMLNTE"

De même, "WATERMELON" de hauteur 4 devrait produire la vague suivante:

W     E
 A   M L
  T R   O
   E     N

Votre programme devrait alors renvoyer la chaîne "WEAMLTROEN"

Règles

Contribution

L'entrée peut être prise dans n'importe quel format raisonnable. La chaîne peut être dans tous les cas que vous préférez. Vous pouvez supposer que0 < n <= s.length

Sortie

La sortie ne doit être constituée que de la chaîne transformée (qu'elle soit retournée ou imprimée sur STDOUT), plus tous les retours à la ligne de fin.

Notation

C'est le golf de code , donc la réponse la plus courte en octets gagne! Les échappatoires standard ne sont pas autorisées.

Cas de test

Input                        Output

programmingpuzzles, 5 ->     piermnlsomgzgapzru
codegolf, 3           ->     cgoeofdl
elephant, 4           ->     enlatehp
1234567, 3            ->     1524637
qwertyuiop, 1         ->     qwertyuiop

Husk , 6 octets

δÖK…¢ḣ

Essayez-le en ligne!

Fonctionne n = 1aussi.

Explication

δÖK…¢ḣ  Implicit inputs, say n=4 and s="WATERMELON"
     ḣ  Range: [1,2,3,4]
    ¢   Cycle: [1,2,3,4,1,2,3,4,1,2,3,4..
   …    Rangify: [1,2,3,4,3,2,1,2,3,4,3,2..
δÖK     Sort s by this list: "WEAMLTROEN"
        Print implicitly.

La fonction d'ordre supérieur fonctionne δcomme ceci sous le capot. Supposons que vous ayez une fonction d'ordre supérieur qui prend une fonction unaire et une liste et renvoie une nouvelle liste. Par exemple, Öprend une fonction et trie une liste en l'utilisant comme clé. Prend ensuite δÖune fonction binaire et deux listes, zippe les listes ensemble, s'applique Öà trier les paires en utilisant la fonction binaire comme clé, et enfin projette les paires à la deuxième coordonnée. Nous utilisons Kcomme fonction clé, qui renvoie simplement son premier argument et ignore le second.

MATL , 16 octets

Zv3L)t?yn:)2$S}i

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Tenez compte des entrées 5, 'programmingpuzzles'.

Zv     % Input, implicit: number n. Symmetric range
       % STACK: [1 2 3 4 5 4 3 2 1]
3L     % Push [1 -1+1j]. When used as an index, this means 1:end-1
       % STACK: [1 2 3 4 5 4 3 2 1], [1 -1+1j]
)      % Index. Removes last element
       % STACK: [1 2 3 4 5 4 3 2]
t      % Duplicate
       % STACK: [1 2 3 4 5 4 3 2], [1 2 3 4 5 4 3 2]
?      %   If non-empty and non-zero
       %   STACK: [1 2 3 4 5 4 3 2]
  y    %   Implict input: string s. Duplicate from below
       %   STACK: 'programmingpuzzles', [1 2 3 4 5 4 3 2], 'programmingpuzzles'
  n    %   Number of elements
       %   STACK: 'programmingpuzzles', [1 2 3 4 5 4 3 2], 18
  :    %   Range
       %   STACK: 'programmingpuzzles', [1 2 3 4 5 4 3 2], [1 2 3 ··· 17 18]
  )    %   Index modularly
       %   STACK: 'programmingpuzzles', [1 2 3 4 5 4 3 2 1 2 3 4 5 4 3 2 1 2]
  2$S  %   Two-input sort: stably sorts first input as given by the second
       %   STACK: 'piermnlsomgzgapzru'
}      % Else. This branch is entered when n=1. The stack contains an empty array
       %   STACK: []
  i    %   Take input
       %   STACK: [], [], 'programmingpuzzles'
       % End, implicit
       % Display stack, implicit. Empty arrays are not displayed

Haskell , 64 octets

s#n=[c|m<-[0..n],(c,i)<-zip s.cycle$[0..n-1]++[n-2,n-3..1],i==m]

Essayez-le en ligne!

J , 54, 29, 27 26 octets

-1 octet grâce à hoosierEE

([\:#@[$[:}:|@i:@<:@]) ::[

Essayez-le en ligne!

R , 68 octets

function(s,n)intToUtf8(unlist(split(utf8ToInt(s),-(n:(2.9-n)-1)^2)))

Essayez-le en ligne!

• -10 octets grâce à @Giuseppe
• -17 octets parce que j'étais idiot
• -9 octets et n=1cas corrigés grâce à @ J.Doe
• -3 octets grâce à @JayCe

Python 2 , 119 108 98 92 91 97 93 91 90 octets

lambda s,n:''.join(c*(j%(2*n-2or 1)in(i,2*n-i-2))for i in range(n)for j,c in enumerate(s))

Essayez-le en ligne!

_{-1 octet, merci à Jonathan Frech}

05AB1E (hérité) , 11 8 octets

Σ²Lû¨¾è¼

Inspiré par la réponse MATL de @LuisMendo .
-3 octets grâce à @Adnan parce que je suis un idiot ..>.>

Essayez-le en ligne .

Explication:

Σ           # Sort the (implicit) input-string by:
 ²L         #  Create a list in the range [1, second input-integer]
            #   i.e. 5 → [1,2,3,4,5]
   û        #  Palindromize it
            #   i.e. [1,2,3,4,5] → [1,2,3,4,5,4,3,2,1]
    ¨       #  Remove the last item
            #   i.e. [1,2,3,4,5,4,3,2,1] → [1,2,3,4,5,4,3,2]
     ¾è     #  Index into it (with wraparound) using the counter_variable (default 0)
            #   i.e. counter_variable = 0 → 1
            #   i.e. counter_variable = 13 → 4
       ¼    #  And after every iteration, increase the counter_variable by 1

REMARQUE: Le counter_variableest utilisé, car dans la version Python Legacy de 05AB1E, le Σn'avait pas d'index intégré N, ce qu'il a dans la nouvelle version de réécriture Elixir de 05AB1E. Alors pourquoi est-ce que j'utilise toujours la version Legacy? Parce que dans la réécriture Elixir, il transforme implicitement la chaîne en une liste de caractères, nécessitant un supplément }Jpour la retransformer en chaîne pour la sortie (et il contient également un bogue en ce moment où ène fonctionne pas du tout pour indexer dans la liste allongée ..: S)

Japt , 16 octets

¬üÏu´VÑ aV°ÃÔc q

Testez-le en ligne!

Explication

 ¬ üÏ   u´ VÑ  aV° Ã Ô c q
Uq üXY{Yu--V*2 aV++} w c q    Ungolfed
                               Implicit: U = input string, V = size of wave
Uq                             Split U into chars.
   üXY{            }           Group the items in U by the following key function:
       Y                         Take the index of the item.
        u--V*2                   Find its value modulo (V-1) * 2.
               aV++              Take the absolute difference between this and (V-1).
                                 This maps e.g. indices [0,1,2,3,4,5,6,7,...] with V=3 to
                                                        [2,1,0,1,2,1,0,1,...]
                                 The items are then grouped by these values, leading to
                                 [[2,6,...],[1,3,5,7,...],[0,4,...]].
                     w         Reverse the result, giving [[0,4,...],[1,3,5,7,...],[2,6,...]].
                       c       Flatten.
                         q     Join back into a single string.

Gelée , 8 octets

6 octets échouent pour la hauteur 1; deux octets utilisés pour y remédier ... peut-être qu'un 7 peut être trouvé?

ŒḄṖȯ1ṁỤị

Un lien dyadique acceptant un entier positif et une liste de caractères qui donne une liste de caractères.

Essayez-le en ligne!

Comment?

ŒḄṖȯ1ṁỤị - Link: positive integer N; list of characters, T
ŒḄ       - bounce (implicit range of) N -> [1,2,3,...,N-1,N,N-1,...,3,2,1]
  Ṗ      - pop off the final entry         [1,2,3,...,N-1,N,N-1,...,3,2]
   ȯ1    - OR one                          if this is [] get 1 instead
     ṁ   - mould like T (trim or repeat to make this list the same length as T)
      Ụ  - grade-up (get indices ordered by value - e.g. [1,2,3,2,1,2] -> [1,5,2,4,6,3])
       ị - index into T

JavaScript (ES6), 75 octets

Formule plus courte suggérée par @MattH (-3 octets)

Prend l'entrée comme (string)(n).

s=>n=>--n?[...s].map((c,x)=>o[x=x/n&1?n-x%n:x%n]=[o[x]]+c,o=[])&&o.join``:s

Essayez-le en ligne!

JavaScript (ES7), 78 octets

4 octets enregistrés grâce à @ETHproductions

Prend l'entrée comme (string)(n).

s=>n=>--n?[...s].map((c,x)=>o[x=n*n-(x%(n*2)-n)**2]=[o[x]]+c,o=[])&&o.join``:s

Essayez-le en ligne!

K ( Kona ), 23 octets

Une traduction de la réponse J par Galen

{y@<(#y)#-1_(!x),|!x-1}

MBasic , 146 159 155 octets

1 INPUT S$,N:DIM C$(N):P=1:D=1:FOR I=1 TO LEN(S$):C$(P)=C$(P)+MID$(S$,I,1)
2 IF N>1 THEN P=P+D
3 IF P=N OR P=1 THEN D=-D
4 NEXT:FOR I=1 TO N:PRINT C$(I);:NEXT

Mis à jour pour gérer n = 1

Sortie:

? programmingpuzzles, 5
piermnlsomgzgapzru

? codegolf, 3
cgoeofdl

? elephant, 4
enlatehp

? 1234567, 3
1524637

? WATERMELON, 4
WEAMLTROEN

? qwertyuiop, 1
qwertyuiop

Perl 6 , 49 octets

->\n{*.comb.sort({-abs n-1-$++%(2*n-2||1)}).join}

Essayez-le en ligne!

Prend l'entrée comme une fonction curry.

Explication:

->\n{*.comb.sort({-abs n-1-$++%(2*n-2||1)}).join}
->\n{                                           }  # Take an number
     *.comb        # Turn the string into a list of chars
           .sort({                       })   # And sort them by
                           $++    # The index of the char
                              %(2*n-2||1)  # Moduloed by 2*(n-1) or 1 if n is 0
                       n-1-       # Subtract that from n-1
                   abs            # get the absolute value
                  -               # And negate to reverse the list
                                          .join  # and join the characters

La séquence de tri est la suivante (pour n=5):

(-4 -3 -2 -1 0 -1 -2 -3 -4 -3 -2 -1 0 -1 -2 -3 -4 -3 -2 -1)

J , 24 octets

4 :'x\:(#x)$}:|i:<:y'::[

Essayez-le en ligne!

Verbe dyadique explicite. Exécutez-le comme'codegolf' f 3 .

Comment ça marche

4 :'x\:(#x)$}:|i:<:y'::[    x: string, y: height
4 :                         Define a dyadic verb:
               i:<:y        Generate a range of -(y-1) .. y-1
            }:|             Take absolute value and remove last
       (#x)$             1) Repeat to match the string's length
    x\:                     Sort x by the decreasing order of above
                     ::[    If 1) causes `Length Error`, return the input string instead

Normalement, la fonction explicite prend 5 octets supplémentaires sous la forme de n :'...'. Mais si la gestion des erreurs est ajoutée, la différence descend à 2 octets en raison des parens et de l'espace (tacit)<space>::.

APL (Dyalog Classic) , 23 octets

{⍺[⍋(≢⍺)⍴(¯1↓⊢,1↓⌽)⍳⍵]}

Essayez-le en ligne!

Powershell, 99 95 octets

param($s,$n)$r=,''*$n
$s|% t*y|%{$r[((1..$n+$n..1)*$s.Length|gu)[$i++*($n-gt1)]-1]+=$_}
-join$r

Script de test:

$f = {

param($s,$n)$r=,''*$n
$s|% t*y|%{$r[((1..$n+$n..1)*$s.Length|gu)[$i++*($n-gt1)]-1]+=$_}
-join$r

}

@(
    ,("1234567", 3            ,     "1524637")
    ,("qwertyuiop", 1         ,     "qwertyuiop")
    ,("codegolf", 3           ,     "cgoeofdl")
    ,("elephant", 4           ,     "enlatehp")
    ,("programmingpuzzles", 5 ,     "piermnlsomgzgapzru")
) | % {
    $s,$n,$e = $_
    $r = &$f $s $n
    "$($r-eq$e): $r"
}

Sortie:

True: 1524637
True: qwertyuiop
True: cgoeofdl
True: enlatehp
True: piermnlsomgzgapzru

Explication

Le script:

• crée un tableau de lignes,
• remplit les lignes avec les valeurs appropriées,
• et renvoie les lignes jointes.

L'expression ((1..$n+$n..1)*$s.Length|gu génère une séquence similaire 1,2,3,3,2,1,1,2,3,3,2,1... et supprime les doublons adjacents. guest un alias pour Get-Unique .

• Pour $n=3la séquence dédupliquée, c'est:1,2,3,2,1,2,3,2,1...
• Pour $n=1la séquence dédupliquée, c'est:1

L'expression $i++*($n-gt1) renvoie un index dans la séquence dédupliquée. =$i++si $n>1, sinon=0

Rubis , 75 65 octets

->s,h{a=['']*h;x=-k=1;s.map{|c|a[x+=k=h-x<2?-1:x<1?1:k]+=c};a*''}

Essayez-le en ligne!

Prend l'entrée comme un tableau de caractères, renvoie une chaîne

Comment ça marche:

• Créer des hchaînes
• Pour chaque caractère de la chaîne d'entrée, choisissez la chaîne à insérer en fonction de son index (l'index de la chaîne à modifier monte het descend jusqu'à 0et ainsi de suite)
• Renvoie toutes les chaînes réunies

C, 142 134 octets

8 octets économisés grâce à Jonathan Frech

Code:

t;i;j;d;f(s,n)char*s;{for(t=strlen(s),i=0;i<n;i++)for(j=0;j+i<t;j=d+i+(n<2))d=j-i+2*~-n,putchar(s[i+j]),i>0&i<n-1&d<t&&putchar(s[d]);}

Explication:

// C variable and function declaration magic
t;i;j;d;f(s,n)char*s;{
    // Iterate through each "row" of the string
    for(t=strlen(s),i=0;i<n;i++)
        // Iterate through each element on the row
        // Original index iterator here was j+=2*(n-1), which is a full "zig-zag" forward
        // The (n<2) is for the edge case of n==1, which will break the existing logic.
        for(j=0; j+i<t; j=d+i+(n<2))
            // If j+i is the "zig", d is the "zag": Original index was d=j+i+2*(n-i-1)
            // Two's complement swag here courtesy of Jonathan Frech
            d=j-i+2*~-n,
            putchar(s[i+j]),
            // Short circuit logic to write the "zag" character for the middle rows
            i>0 & i<n-1 & d<t && putchar(s[d]);
}

Essayez-le en ligne!

Fusain , 21 octets

⭆ＮΦη¬⌊Ｅ²﹪⁺μ⎇νι±ι∨⊗⊖θ¹

$m$$i$$m \pm i = 0 \pmod {2n - 2}$

 Ｎ                      First input as a number
⭆                       Map over implicit range and join
   η                    Second input
  Φ                     Filter over characters
       ²                Literal 2
      Ｅ                 Map over implicit range
          μ             Character index
             ι ι        Outer index
              ±         Negate
            ν           Inner index
           ⎇            Ternary
         ⁺              Plus
                   θ    First input
                  ⊖     Decremented
                 ⊗      Doubled
                    ¹   Literal 1
                ∨       Logical Or
        ﹪               Modulo
     ⌊                  Minimum
    ¬                   Logical Not
                        Implicitly print

SNOBOL4 (CSNOBOL4) , 191 octets

	S =INPUT
	N =INPUT
	A =ARRAY(N)
	A<1> =EQ(N,1) S	:S(O)
I	I =I + -1 ^ D
	S LEN(1) . X REM . S	:F(O)
	A<I> =A<I> X
	D =EQ(I,N) 1
	D =EQ(I * D,1)	:(I)
O	Y =Y + 1
	O =O A<Y>	:S(O)
	OUTPUT =O
END

Essayez-le en ligne!

Prend Sensuite Nsur des lignes distinctes.

Explication:

	S =INPUT			;* read S
	N =INPUT			;* read N
	A =ARRAY(N)			;* create array of size N
	A<1> =EQ(N,1) S	:S(O)		;* if N = 1, set A<1> to S and jump to O
I	I =I + -1 ^ D			;* index into I by I + (-1)^D (D starts as '' == 0)
	S LEN(1) . X REM . S	:F(O)	;* extract the first character as X and set S to the
					;* remaining characters, jumping to O when S is empty
	A<I> =A<I> X			;* set A<I> to A<I> concatenated with X
	D =EQ(I,N) 1			;* if I == N, D=1
	D =EQ(I * D,1)	:(I)		;* if I == D == 1, D = 0. Goto I
O	Y =Y + 1			;* increment the counter
	O =O A<Y>	:S(O)		;* concatenate the array contents until last cell
	OUTPUT =O			;* and print
END

Nettoyer , 105 84 octets

import StdEnv,Data.List
$s n=[c\\l<-[1..n],c<-s&m<-cycle([1..n]++[n-1,n-2..2])|m==l]

Essayez-le en ligne!

JavaScript (Node.js) , 83 octets

c=>g=(s,d=c*2-2,r=d,n=o='')=>s&&([...s].map((c,i)=>i%d%r?n+=c:o+=c),o)+g(n,r-1,r-2)

Essayez-le en ligne!

Pyth , 22 21 octets

|seMhD,V*lz+PUQP_UQzz

Prend la saisie comme nsuit ssur des lignes distinctes. Essayez-le en ligne ici ou vérifiez tous les cas de test en même temps ici .

|seMhD,V*lz+PUQP_UQzz   Implicit: Q=eval(input()), z=remaining input

             UQ         Range [0-Q)
            P           All but last from the above
                         e.g. for Q=3, yields [0,1]
               P_UQ     All but last of reversed range
                         e.g. for Q=3, yields [2,1]
           +            Concatenate the previous two results
                          e.g. for Q=3, yields [0,1,2,1]
        *lz              Repeat len(z) times
      ,V           z    Vectorised pair the above with z, truncating longer to length of shorter
                          e.g. for Q=3, z=WATERMELON, yields:
                          [[0,'W'],[1,'A'],[2,'T'],[1,'E'],[0,'R'],[1,'M'],[2,'E'],[1,'L'],[0,'O'],[1,'N']]
    hD                  Sort the above by the first element
                          Note this is a stable sort, so relative ordering between equal keys is preserved
  eM                    Take the last element of each
 s                      Concatenate into string
                          Note that if n=1, the result of the above will be 0 (sum of empty array)
|                   z   If result of above is falsey, yield z instead

Modifier: sauvegarde un octet en déplaçant le chèque vide à la fin du traitement. La version précédente: seMhD,V*lz|+PUQP_UQ]0z

Rouge , 153 octets

func[s n][i: v: m: 1 b: collect[foreach c s[keep/only reduce[v i c]v: v + m
if all[n > 1(i: i + 1)%(n - 1)= 1][m: -1 * m]]]foreach k sort b[prin last k]]

Essayez-le en ligne!

Explication:

f: func [ s n ] [                      ; s is the string, n is the height
    i: 1                               ; index of the current character in the string
    v: 1                               ; value of the "ladder"
    m: 1                               ; step (1 or -1)
    b: collect [                       ; collect the values in a block b
        foreach c s [                  ; foreach character in the string 
            keep/only reduce [ v i c ] ; keep a block of the evaluated [value index char] 
            i: i + 1                   ; increase the index
            v: v + m                   ; calculate the value 
            if all [ n > 1             ; if height is greater than 1 and
                    i % (n - 1) = 1    ; we are at a pick/bottom of the ladder
                   ]
                [ m: -1 * m ]          ; reverse the step
        ]
    ]
    foreach k sort b [ prin last k ]   ; print the characters in the sorted block of blocks
]

J'ai deux solutions au problème. La première solution que j'ai faite d'abord, j'ai pensé à une autre façon de faire qui, selon moi, permettrait d'économiser des octets, mais elle ne l'a pas fait, je l'ai donc incluse de toute façon.

Solution 1

PHP , 152 144 116 octets

<?php
for($i=0;$i<$n=$argv[2];$i++)
    for($j=$i;$s=$argv[1][$j];$j+=$n<2|(($f=!$f|!$i)?$i<$n-1?$n+~$i:$i:$i)*2)
        echo $s;

• 8 octets grâce à @JoKing
• 28 octets grâce à @Shaggy

Essayez-le en ligne!

Solution 2

PHP , 162 octets

<?php
$s=$argv[0];
$n=$argv[1];
$l=strlen($s);
for($i=0;$i<$l;){
    for($j=0;$j<$n&&$i<$l;)
        $a[$j++].=$s[$i++];
    for($j=$n-2;$j>0&&$i<$l;)
        $a[$j--].=$s[$i++];
}
echo join($a);

Essayez-le en ligne!

Rubis , 84 octets

->s,n{r=['']*n;[*0...n,*(2-n)..-1].map{|x|r[x.abs]+=s.slice!(0)||''}while s[0];r*''}

Essayez-le en ligne!