Reto

Escriba un programa o función que tome una cadena sy un entero ncomo parámetros. Su programa debe imprimir (o devolver) la cadena cuando se transforma de la siguiente manera:

Comenzando en la parte superior izquierda y moviéndose hacia abajo y hacia la derecha, escriba scomo una ola de altura n. Luego, de arriba a abajo, combine cada fila como una cadena (sin espacios).

Ejemplo

Dada la cadena "WATERMELON" y una altura de 3:

La ola debería verse así:

W   R   O
 A E M L N
  T   E

Luego, combine las filas de arriba a abajo:

WRO
AEMLN
TE

Por lo tanto, su programa debería devolver la cadena "WROAEMLNTE"

Del mismo modo, "WATERMELON" con altura 4 debería producir la siguiente ola:

W     E
 A   M L
  T R   O
   E     N

Su programa debería devolver la cadena "WEAMLTROEN"

Reglas

Entrada

La entrada puede tomarse en cualquier formato razonable. La cadena puede ser en cualquier caso que prefiera. Puedes suponer que0 < n <= s.length

Salida

La salida debe consistir solo en la cadena transformada (ya sea devuelta o impresa en STDOUT), más cualquier nueva línea final.

Tanteo

Este es el código de golf , por lo que la respuesta más corta en bytes gana Las lagunas estándar no están permitidas.

Casos de prueba

Input                        Output

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

Casco , 6 bytes

δÖK…¢ḣ

Pruébalo en línea!

Funciona para n = 1también.

Explicación

δÖ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 función de orden superior funciona δasí debajo del capó. Suponga que tiene una función de orden superior que toma una función unaria y una lista, y devuelve una nueva lista. Por ejemplo, Ötoma una función y ordena una lista usándola como clave. Luego δÖtoma una función binaria y dos listas, comprime las listas juntas, aplica Öpara ordenar los pares usando la función binaria como clave, y finalmente proyecta los pares a la segunda coordenada. Usamos Kcomo la función clave, que simplemente devuelve su primer argumento e ignora el segundo.

MATL , 16 bytes

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

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

Considere insumos 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 bytes

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

Pruébalo en línea!

J , 54, 29, 27 26 bytes

-1 byte gracias a hoosierEE

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

Pruébalo en línea!

R , 68 bytes

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

Pruébalo en línea!

• -10 bytes gracias a @Giuseppe
• -17 bytes porque era tonto
• -9 bytes y n=1caso arreglado gracias a @ J.Doe
• -3 bytes gracias a @JayCe

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

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

Pruébalo en línea!

_{-1 byte, gracias a Jonathan Frech}

05AB1E (heredado) , 11 8 bytes

Σ²Lû¨¾è¼

Inspirado por @LuisMendo MAT respuesta 's .
-3 bytes gracias a @Adnan porque soy un idiota ..>.>

Pruébalo en línea .

Explicación:

Σ           # 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

NOTA: Se counter_variableutiliza, porque en la versión de Python Legacy de 05AB1E, Σno tenía un índice incorporado N, que sí tiene en la nueva versión de reescritura de Elixir de 05AB1E. Entonces, ¿por qué sigo usando la versión heredada? Porque en la reescritura de Elixir, transforma implícitamente la cadena en una lista de caracteres, lo que requiere un adicional }Jpara transformarla nuevamente en una cadena para generar (y también contiene un error en este momento donde èno funciona para indexar en la lista alargada ..: S)

Japt , 16 bytes

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

¡Pruébalo en línea!

Explicación

 ¬ üÏ   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.

Jalea , 8 bytes

6 bytes fallan para la altura 1; dos bytes utilizados para abordarlo ... ¿tal vez se pueda encontrar un 7?

ŒḄṖȯ1ṁỤị

Un enlace diádico que acepta un número entero positivo y una lista de caracteres que produce una lista de caracteres.

Pruébalo en línea!

¿Cómo?

ŒḄṖȯ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 bytes

Fórmula más corta sugerida por @MattH (-3 bytes)

Toma entrada como (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

Pruébalo en línea!

JavaScript (ES7), 78 bytes

Guardado 4 bytes gracias a @ETHproductions

Toma entrada como (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

Pruébalo en línea!

K ( Kona ), 23 bytes

Una traducción de la respuesta J de Galen

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

MBASIC , 146 159 155 bytes

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

Actualizado para manejar n = 1

Salida:

? programmingpuzzles, 5
piermnlsomgzgapzru

? codegolf, 3
cgoeofdl

? elephant, 4
enlatehp

? 1234567, 3
1524637

? WATERMELON, 4
WEAMLTROEN

? qwertyuiop, 1
qwertyuiop

Perl 6 , 49 bytes

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

Pruébalo en línea!

Toma la entrada como una función curry.

Explicación:

->\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 secuencia por la que se ordena se ve así (para n=5):

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

J , 24 bytes

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

Pruébalo en línea!

Verbo diádico explícito. Ejecútalo como 'codegolf' f 3.

Cómo funciona

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

Normalmente, la función explícita toma 5 bytes adicionales en forma de n :'...'. Pero si se agrega el manejo de errores, la diferencia se reduce a 2 bytes debido a los parentes y al espacio en (tacit)<space>::.

APL (Dyalog Classic) , 23 bytes

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

Pruébalo en línea!

Powershell, 99 95 bytes

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

Script de prueba:

$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"
}

Salida:

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

Explicación

La secuencia de comandos:

• crea una matriz de filas,
• llena filas con valores apropiados,
• y devuelve las filas unidas.

La expresión ((1..$n+$n..1)*$s.Length|gu genera una secuencia como 1,2,3,3,2,1,1,2,3,3,2,1... y elimina duplicados adyacentes. gues un alias para Get-Unique .

• Para $n=3la secuencia deduplicada es:1,2,3,2,1,2,3,2,1...
• Para $n=1la secuencia deduplicada es:1

La expresión $i++*($n-gt1) devuelve un índice en la secuencia deduplicada. =$i++si de lo $n>1contrario=0

Ruby , 75 65 bytes

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

Pruébalo en línea!

Toma la entrada como una matriz de caracteres, devuelve una cadena

Cómo funciona:

• Crea hcadenas
• Para cada carácter en la cadena de entrada, decida en qué cadena colocarlo en función de su índice (el índice de la cadena que se va a modificar sube hasta hy luego baja hasta, 0etc.)
• Devuelve todas las cadenas unidas

C, 142134 bytes

8 bytes guardados gracias a Jonathan Frech

Código:

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

Explicación:

// 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]);
}

Pruébalo en línea!

Carbón , 21 bytes

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

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

	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

Pruébalo en línea!

Toma S entonces Nen líneas separadas.

Explicación:

	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

Limpio , 105 84 bytes

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

Pruébalo en línea!

JavaScript (Node.js) , 83 bytes

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)

Pruébalo en línea!

Pyth , 22 21 bytes

|seMhD,V*lz+PUQP_UQzz

Toma entrada como nseguido por sen líneas separadas. Pruébelo en línea aquí , o verifique todos los casos de prueba a la vez aquí .

|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

Editar: guardado un byte moviendo el cheque vacío al final del procesamiento. Versión previa: seMhD,V*lz|+PUQP_UQ]0z

Rojo , 153 bytes

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

Pruébalo en línea!

Explicación:

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
]

Tengo dos soluciones al problema. La primera solución que hice primero, luego pensé en otra forma de hacerlo que pensé que ahorraría bytes, pero no fue así, así que la incluí de todos modos.

Solución 1

PHP , 152 144 116 bytes

<?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 bytes gracias a @JoKing
• 28 bytes gracias a @Shaggy

Pruébalo en línea!

Solución 2

PHP , 162 bytes

<?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);

Pruébalo en línea!

Ruby , 84 bytes

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

Pruébalo en línea!