Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die eine Zeichenfolge sund eine Ganzzahl nals Parameter akzeptiert. Ihr Programm sollte die Zeichenfolge bei der Transformation wie folgt drucken (oder zurückgeben):

Beginnen Sie oben links und bewegen Sie sich nach unten und rechts. Schreiben Sie sals Welle der Höhe n. Kombinieren Sie dann jede Zeile von oben nach unten als Zeichenfolge (ohne Leerzeichen).

Beispiel

Mit der Zeichenfolge "WATERMELON" und einer Höhe von 3:

Die Welle sollte so aussehen:

W   R   O
 A E M L N
  T   E

Kombinieren Sie dann die Zeilen von oben nach unten:

WRO
AEMLN
TE

Ihr Programm sollte also den String "WROAEMLNTE" zurückgeben

Ebenso sollte "WASSERMELONE" mit Höhe 4 die folgende Welle erzeugen:

W     E
 A   M L
  T R   O
   E     N

Ihr Programm sollte dann den String "WEAMLTROEN" zurückgeben

Regeln

Eingang

Die Eingabe kann in jedem vernünftigen Format erfolgen. Die Zeichenfolge kann auf jeden Fall beliebig sein. Sie können das annehmen0 < n <= s.length

Ausgabe

Die Ausgabe sollte nur aus der transformierten Zeichenfolge (unabhängig davon, ob sie an STDOUT zurückgegeben oder gedruckt wird) und allen nachfolgenden Zeilenumbrüchen bestehen.

Wertung

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes! Standardlücken sind nicht erlaubt.

Testfälle

Input                        Output

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

Schale , 6 Bytes

δÖK…¢ḣ

Probieren Sie es online!

Funktioniert auch für n = 1.

Erläuterung

δÖ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.

So funktioniert die übergeordnete Funktion δunter der Haube. Angenommen, Sie haben eine Funktion höherer Ordnung, die eine unäre Funktion und eine Liste übernimmt und eine neue Liste zurückgibt. Nimmt zum Beispiel Öeine Funktion und sortiert eine Liste unter Verwendung dieser als Schlüssel. Nimmt δÖdann eine Binärfunktion und zwei Listen, komprimiert die Listen, Ösortiert die Paare mit der Binärfunktion als Schlüssel und projiziert die Paare schließlich auf die zweite Koordinate. Wir verwenden Kals Schlüsselfunktion, die einfach das erste Argument zurückgibt und das zweite ignoriert.

MATL , 16 Bytes

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

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Betrachten Sie Eingänge 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]

Probieren Sie es online!

J , 54, 29, 27, 26 Bytes

-1 Byte dank hoosierEE

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

Probieren Sie es online!

R , 68 Bytes

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

Probieren Sie es online!

• -10 Bytes dank @ Giuseppe
• -17 Bytes, weil ich albern war
• -9 Bytes und n=1Groß- / Kleinschreibung behoben dank @ J.Doe
• -3 Bytes dank @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))

Probieren Sie es online!

_{-1 Byte, danke an Jonathan Frech}

05AB1E (Legacy) , 11 8 Bytes

Σ²Lû¨¾è¼

Inspiriert von der MATL -Antwort von @LuisMendo .
-3 Bytes danke an @Adnan, weil ich ein Idiot bin ..>.>

Probieren Sie es online aus .

Erläuterung:

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

HINWEIS: Das counter_variablewird verwendet, da es in der Python Legacy-Version von 05AB1E Σkeinen integrierten Index hatte N, den es in der neuen Elixir-Neuschreibversion von 05AB1E hat. Warum verwende ich immer noch die Legacy-Version? Da beim Neuschreiben von Elixir die Zeichenfolge implizit in eine Liste von Zeichen umgewandelt wird und eine zusätzliche Zeichenfolge erforderlich ist, }Jum sie wieder in eine auszugebende Zeichenfolge umzuwandeln (und es enthält derzeit auch einen Fehler, èbei dem das Indizieren in die verlängerte Liste überhaupt nicht funktioniert) ..: S)

Japt , 16 Bytes

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

Testen Sie es online!

Erläuterung

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

Gelee , 8 Bytes

6 Byte schlägt für Höhe 1 fehl; Zwei Bytes für die Adressierung ... kann eine 7 gefunden werden?

ŒḄṖȯ1ṁỤị

Eine dyadische Verknüpfung, die eine positive Ganzzahl und eine Liste von Zeichen akzeptiert, die eine Liste von Zeichen ergibt.

Probieren Sie es online!

Wie?

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

Kürzere Formel vorgeschlagen von @MattH (-3 Bytes)

Übernimmt die Eingabe als (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

Probieren Sie es online!

JavaScript (ES7), 78 Byte

4 Bytes gespart dank @ETHproductions

Übernimmt die Eingabe als (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

Probieren Sie es online!

K ( Kona ), 23 Bytes

Eine Übersetzung der J-Antwort von 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

Aktualisiert, um n = 1 zu behandeln

Ausgabe:

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

Probieren Sie es online!

Nimmt Eingaben als Curry-Funktion.

Erläuterung:

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

Die Reihenfolge, nach der sortiert wird, sieht folgendermaßen aus (für 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'::[

Probieren Sie es online!

Explizites dyadisches Verb. Führen Sie es wie 'codegolf' f 3.

Wie es funktioniert

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

Normalerweise benötigt die explizite Funktion zusätzliche 5 Bytes in Form von n :'...'. Wenn jedoch eine Fehlerbehandlung hinzugefügt wird, sinkt die Differenz aufgrund der Parens und des Speicherplatzes in auf 2 Byte (tacit)<space>::.

APL (Dyalog Classic) , 23 Byte

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

Probieren Sie es online!

Powershell, 99 bis 95 Bytes

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

Testskript:

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

Ausgabe:

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

Erläuterung

Das Drehbuch:

• erstellt ein Array von Zeilen,
• füllt Zeilen mit entsprechenden Werten,
• und gibt die verbundenen Zeilen zurück.

Der Ausdruck ((1..$n+$n..1)*$s.Length|gu erzeugt eine Sequenz wie 1,2,3,3,2,1,1,2,3,3,2,1... und entfernt benachbarte Duplikate. guist ein Alias ​​für Get-Unique .

• Für $n=3die deduplizierte Sequenz gilt:1,2,3,2,1,2,3,2,1...
• Für $n=1die deduplizierte Sequenz gilt:1

Der Ausdruck $i++*($n-gt1) gibt einen Index in der deduplizierten Sequenz zurück. =$i++wenn $n>1sonst=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*''}

Probieren Sie es online!

Nimmt Eingaben als Array von Zeichen und gibt einen String zurück

Wie es funktioniert:

• Erstellen Sie hZeichenfolgen
• Entscheiden Sie anhand des Indexes für jedes Zeichen in der Eingabezeichenfolge, in welche Zeichenfolge es eingefügt werden soll (der Index der zu ändernden Zeichenfolge steigt bis hund fällt bis 0und usw.).
• Geben Sie alle zusammengefügten Saiten zurück

C 142 134 Bytes

8 Bytes gespart dank 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]);}

Erläuterung:

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

Probieren Sie es online!

Holzkohle , 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

Probieren Sie es online!

Nimmt Sdann Ngetrennte Zeilen auf.

Erläuterung:

	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

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

Probieren Sie es online!

JavaScript (Node.js) , 83 Byte

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)

Probieren Sie es online!

Pyth , 22 21 Bytes

|seMhD,V*lz+PUQP_UQzz

Übernimmt die Eingabe wie nfolgt sin separaten Zeilen. Versuchen Sie es online hier oder überprüfen alle Testfälle auf einmal hier .

|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

Bearbeiten: Speichert ein Byte, indem das leere Häkchen an das Ende der Verarbeitung verschoben wird. Vorherige Version: seMhD,V*lz|+PUQP_UQ]0z

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

Probieren Sie es online!

Erläuterung:

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
]

Ich habe zwei Lösungen für das Problem. Die erste Lösung, die ich zuerst gemacht habe, dann habe ich mir eine andere Möglichkeit ausgedacht, um Bytes zu sparen, aber das ist nicht so, dass ich es trotzdem aufgenommen habe.

Lösung 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 dank @JoKing
• 28 Bytes dank @Shaggy

Probieren Sie es online!

Lösung 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);

Probieren Sie es online!

Ruby , 84 Bytes

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

Probieren Sie es online!