단어를 왜곡!


34

단어를 왜곡!

문자열과 양의 정수가 주어집니다. 줄을 앞뒤로 꼬 아야합니다.

입력 / 출력 예

입력

Programming Puzzles & Code Golf
4

산출

Prog
mmar
ing 
zzuP
les 
oC &
de G
 flo

입력

입력은 STDIN 또는 함수 인수를 통해 가져올 수 있습니다. 입력은 문자열과 양의 정수 n으로 구성 됩니다. 정수는 각 꼬인 선의 길이를 결정합니다.

끈이 앞뒤로 꼬여 있습니다. HELLO, WORLD!및 5 의 입력 은 다음과 같습니다.

안녕하세요, 세계!

산출

출력은 꼬인 텍스트가됩니다. 뒤에 공백이 없을 수 있습니다. 입력 문자열 길이를 줄 길이로 나눌 수없는 경우 줄이 채워질 때까지 공백을 추가하십시오.

이것의 예 :

입력

Hello, World!
5

출력 (맨 끝의 공백 참고)

Hello
roW ,
ld!  


뒤에 공백이 없을 수 있습니다. 동사를 골라 내 셨나요?
Adám

줄 목록을 반환해도됩니까?
Adám

답변:


10

피스, 19 15

VPc+z*dQQ_W~!ZN

문자열을 미리 채운 다음 인쇄 할 때 서로 줄을 반대로 바꿉니다. 패딩은 상자의 크기와 동일하지만 입력을 자른 후 마지막 줄은 삭제됩니다.

여기 사용해보십시오


6

CJam, 19 바이트

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

입력 예 :

5 "Hello, World!"

설명

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

5

눈사람 1.0.1 , 91 바이트

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

또는 2 바이트의 비용으로 한 줄에 (미학, 더 구체적으로는 미학을 위해) :

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

눈사람에게는 이것이 너무 짧습니다. (아마도 가장 짧은 길이 일 것입니다. 저는 꽤 오랫동안 골프를 쳤습니다.)

여기에는 한 가지주의 사항이 있습니다. 마지막 줄이 반전 되지 않은 경우 시간의 50 %가 오류와 함께 종료됩니다 (그러나 여전히 올바른 출력을 생성 함) . (왜냐하면 ag배열 요소를 두 그룹으로 그룹화하여 다른 요소를 모두 뒤집을 수 있기 때문에 마지막 요소에 예상 요소가 모두 있는지 여부를 확인하지 않으므로 존재하지 않는 요소에 액세스하려고 시도합니다. 홀수 줄이 있습니다.)

언 골프 / 설명 :

{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

5

파이썬 2, 60

s,n=input()
d=1
while s:print(s+n*' ')[:n][::d];s=s[n:];d=-d

소요 n의에서에서 한 번에 문자를 s방향으로 그들을 인쇄, d그 대체 사이 1-1. 마지막 줄에 간격 들어 s채워집니다 n이이보다 더 적은이있는 경우에만 영향을 미치는, 다진 전에 끝에 공백이 n나머지 문자.

재귀 솔루션은 후행 줄 바꿈을 남겨두고 허용되지 않는 것을 제외하고 char (59)을 저장합니다.

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

4

하스켈 , 83 75 바이트

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

chunksOf테이크 앤 드롭을 사용한 간단한 구현으로 짝수 또는 홀수의 반전을 출력에 적용합니다.

5 바이트의 @BMO와 3 바이트의 @ ØrjanJohansen 덕분에!

온라인으로 사용해보십시오!


2
cycle5 바이트 절약을 사용하여 온라인으로 사용해보십시오!
ბიმო

더 저장 세 제거하여 바이트 g스와핑 nl: 온라인으로보십시오!
Ørjan Johansen 1

3

붙어 있음 , 42 41 40 38 바이트

이것은 너무 길다, 아마 더 많은 골프를하려고 할 것이다!

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

입력은와 같아야합니다 "string"|n.

설명:

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

2

하스켈, 108 바이트

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

오래 걸리 네요. 여기 실제로 작동합니다.

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

let표현식 바인딩은 어떻게 작동합니까?
xnor

let세미콜론으로 구분 된 2-in-one 문입니다. 일반적으로 줄 바꿈과 들여 쓰기를 사용하지만 Haskell은을 쓸 수도 있습니다 let a=b; c=d in expr.
Lynn

putStrLn을 프로그램에서 꺼내어 이것이 허용되는지 몰랐습니다!
Leif Willerts

1
@LeifWillerts, 최근 여기의 과제는 함수 인수 / 결과 또는 stdin / stdout을 통해 I / O를 수행하는 경향이 있습니다. 여기서 내 솔루션은 (%) :: String -> String -> String대신 함수 입니다 IO ().
Lynn

2

파이썬 2, 109 바이트

마지막 줄이 정확하도록 공백으로 패딩을 추가해야했습니다.

여기 사용해보십시오

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)

2

루아, 91 88 88 84 83 82 바이트

구 버전:

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

새로운 버전:

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

2

O, 60 바이트

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

나의 첫 O 프로그램, 그리고 그것에서 긴 하나!

라이브 데모.


2

펄, 87 바이트

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

이전 버전 (후행 줄 바꿈 인쇄) :

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

문자열은 줄 바꿈없이 함수 인수로 전달됩니다. 이런 식으로 전화하십시오 :

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

2

볼거리, 86 바이트

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

첫 번째 ',!'를 제거하면 2 바이트 더 짧을 수 있습니다. R 문의 문자 (STDIN에서 읽음); 입력과 출력 사이에 캐리지 리턴을 추가합니다. 그것이 없으면 출력은 기술적으로 정확하지만 첫 번째 줄은 입력 문자열에 추가 된 것으로 나타납니다. [[사용하는 표준 Mumps 터미널에는 로컬 에코가 없습니다. ]]   테스트 결과는 다음과 같습니다.

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 

또한 실제로 입력 끝에 '123'과 '6'사이에 캐리지 리턴 / Enter 키 누름이 있습니다. [[다시 지역 반향 일. ]]

누군가 관심이 있다면 코드에서 무슨 일이 일어나고 있는지 설명 할 수 있습니다. 그러나 나는 많은 유행성 이하선염 애호가가 없다는 것을 알고 있습니다 ... :-)


2

PowerShell, 102 바이트

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

다음과 같이 호출됩니다 (file에 저장된 경우 CodeGolf55051.ps1)

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

이전 시도

(더 이상 또는 유효하지 않음)

PowerShell, 110 바이트

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

PowerShell, 111 바이트

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

설명

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 바이트

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 바이트

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

설명

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

( {...}위의 의견에서 실제로 {0}|{1}|{2}; 나는 {...}가독성을 향상시키기 위해 두었습니다 .

Powershell, 120 바이트 (잘못된)

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

1
다른 PowerShell slinger를 만나서 반갑습니다! 쉬운 시작은 모든 공간 근처에서 댕을 제거 param($s,$i)$s+' '*($i-$s.Length%$i)-replace'(.{4})?(.)(.)(.)(.)',"`$1`n`$5`$4`$3`$2`n"-split"`n"|?{$_-ne""}하여 108까지 내려갈 수 있습니다.
AdmBorkBork

감사합니다 @TimmyD; 내 스크립트에서 몇 가지 근본적인 오류를 발견했습니다 (요구 사항을 충족하지 못함 / 4로만 작동하도록 하드 코딩되었습니다 ... 지금 수정)
JohnLBevan

테스트하는 동안 흐름을 앞뒤로 올바른 방향으로 시작하려면 최종 [$r]색인 을 바꿔야했습니다 [-not$r]. 그렇지 않으면 첫 번째 줄은 제공된 예제와 반대 (즉, 오른쪽에서 왼쪽으로)를 읽습니다. 그렇지 않으면 정말 매끄러운 실행입니다!
AdmBorkBork

1
또한 입력 번호 n가 양수로 주어 졌으므로 문자열의 길이가 음수가 아닌 (정의 적으로) 보장됩니다. 즉, 이는 4자를 저장 (($i-$l%$i)%i)하는 것과 같습니다 ($i-$l%$i).
AdmBorkBork

1
어쨌든, 나는 어떻게 든 그것을 오타했습니다 (-$l)%$i. 어디에서 왔는지 모릅니다. 그러나 그것이 동등하지는 않지만 흥미 롭습니다. PowerShell (다른 언어 중에서)이 모듈러스 함수를 구현하는 방법에 대한 기묘한 것입니다. 분명히 더 긴 버전을 사용해야합니다. 참조 증명->((y-x%y)%y) ==> ((y%y)-(x%y%y))%y ==> ((0)-(x%y))%y ==> (-x%y)%y ==> (-x)%y
AdmBorkBork

2

클로저, 83 바이트, 87 바이트 , 79 바이트

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

아래의 의견 후 몇 가지 수정, Ørjan 감사합니다 .

온라인으로 사용해보십시오!

Clojure는 종종 코드 골프 답변에 슬프게도없는 것처럼 보입니다. 확실히 골프 언어와 바이트 길이로 경쟁 할 수는 없지만 총 부재는 다소 부당한 것이라고 생각합니다.

설명:

  • 데이터 내에서 두 개의 인수는 숫자와 문자열
  • 문자열 에 clojure 내장 함수 파티션 을 실행하여 시작 s하여 목록 길이가있는 일련의 문자 목록으로 시작하십시오 n. 마지막 청크 길이 공란한다 n은 "컬렉션 패드"를 사용하는 리턴(repeat " ") 공간 무한 지연 시퀀스를 반환
  • 우리는 전화 세 가지 인수로 map 합니다
    • 익명 함수 ( #(..) )
    • 함수의 무한한 교류 지연 시퀀스 #(or %)등의 기능 식별 함수와 역방향 (즉, [#(or %) reverse #(or %) reverse ...])에 의해 반환사이클에 .
    • 파티션에 의해 리턴 된 청크리스트 된 일련의 지연된리스트
  • 마지막으로 익명 함수 #(apply ...) :
    • 청크에서 identity또는 reverse교대로 호출합니다 . 이것은 통해 이루어집니다 (% %2)익명 함수에 첫 번째 인수로 전송 함수를 호출 표현 [즉, identity또는reverse 상기 호출 인수와 익명 함수 번째 인자 [즉 청크]을 사용.
    • (apply str ...)문자 목록을 문자열로 변환하기위한 호출
  • 외부 함수는 지연된 문자열 시퀀스를 리턴합니다.

여기서 사용하는 한 가지 트릭 map은 임의의 수의 콜렉션을 args로 취하는 것과 같이 많은 클로저 함수가 있다는 것입니다. 즉 (map f coll1 coll2 coll3 ...)함수 f는 콜렉션이있는만큼 많은 인수를 받아 들여야합니다. 이 경우 대체 함수 참조 모음과 청크 분할 문자열의 두 컬렉션을 보냅니다.


1
이것은 좋지만에 끝에 공백이없는 것 같습니다 ld! .
Ørjan Johansen

당신이 가장 정확합니다. 문제를 해결해야하는 패드 모음을 추가하고 8 바이트 비용이 발생했습니다 ...
Matias Bjarland

골프 규칙에 대한 질문이 있습니다. 가져 오기 또는 유사한 문이 필요한 내장 함수를 사용하는 경우 (clojure 필요, Java 가져 오기 등) 해당 내장의 가져 오기가 골프 솔루션 바이트 수? 나는 그렇다고 가정하지만 회색 영역처럼 약간의 느낌이 듭니다.
Matias Bjarland

예, 수입이 계산됩니다.
Ørjan Johansen

아, 그러나 당신이 깨고있는 또 다른 규칙이 있습니다 : 사전 정의 된 변수로 입력을 할 수 없으므로 솔루션을 전체 프로그램 또는 함수로 만들어야합니다. (사용 중 fn또는 것은 defn괜찮습니다.) 함수가 바로 결과를 반환하는 대신 그것을 인쇄에 허용되는 플립 측면에서.
Ørjan Johansen

2

APL (Dyalog Unicode) , 19 바이트

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

온라인으로 사용해보십시오!

⊢∘⌽\에서 트릭을 boustrophedonise 도전에 NGN의 화려한 대답 .

줄 바꿈이있는 줄에 대한 제출이 중단된다는 것을 알고 난 후에 2 바이트를 더 추가했습니다. 아래는 이전 제출물입니다.

APL (Dyalog Unicode) , 17 바이트

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

온라인으로 사용해보십시오!


2

파이썬 3, 110 108 107 103 바이트

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

(다른 답변보기) rjust:95 93 92 90 바이트

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

출력의 마지막 줄이 잘못되었습니다. 여기서 실행하십시오. 그것은 훌륭한 첫 번째 게시물이며 일단 수정하면 몇 가지 바이트를 골라내는 방법을 제안 할 것입니다. 첫 번째 방법은 답변에서 모든 공간 / 탭을 제거 할 수 있다는 것입니다.
mbomb007

하하, 당신이 옳아 요. 이것을 고치는 것은 많은 비용이 들지만 나는 그것에 달려 있습니다. 감사합니다
bobrobbob


또한, 당신은 꽤 오래 전에 내 대답을 이겼습니다 : codegolf.stackexchange.com/a/55082/34718
mbomb007

팁을 읽고. 다시 감사
bobrobbob

1

PHP, 135 바이트

로 표시된 두 개의 명령 줄 인수를 사용 $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);

1

CoffeeScript, 131 바이트

너무 긴 것 같습니다.

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

1

줄리아, 104 바이트

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)

언 골프 드 :

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


1

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

마지막 줄이 짧고 꼬이지 않으면 올바르지 않습니다. 응답에 버그 수정을 게시하고 싶었지만 대신 업데이트 할 수 있으면 더 좋을 것입니다. {-1@[l;(&)(til(#)l:y cut x)mod 2;'[neg[y]$;|:]];}(49 바이트). 영감을 주셔서 감사합니다! :)
hjk

1

Q, 64 56 바이트

{c::neg y;-1(til(#)l){$[x mod 2;c$(|:)y;y]}'l:y cut x;}
  • {}로 호출되어야하는 함수입니다 {}[x;y].
    • x 문자열이됩니다.
    • y 결과 라인의 길이가됩니다.

테스트:

{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

편집 : @tmartin 의 다른 q 답변 에서 영감을 얻은 짧은 기능 사용


1

파이썬 2, 82 75 바이트

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

@willem에 대해서는 언급 할 수 없었지만 그의 코드는 작게 만들었습니다.

여기를보십시오 여기를 보십시오


안녕하세요 AlexN, 좋습니다. 'Try here'예제의 마지막 줄이 올바르지 않다고 생각합니다. 그것은 정당화되어야한다. 또한 86자를 계산합니까? 업데이트에 대한 내 항목 을 참조하십시오 .
Willem

안녕 willem, 당신 말이 맞아, 나는 코드를 수정하고 당신에 오류가 있음을 발견 : ideone.com/GOmMrE 오른쪽에 있어야합니다.
Alexander Nigl

1

펄, 72 바이트

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

70 바이트 +에 2 바이트 -p0.

데모:

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

STDIN에서 읽은 입력은 개행으로 끝날 수 없습니다 (2 바이트 추가 비용).

설명:

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

1

자바 스크립트 ES6, 123 바이트

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}

with를 호출 t(input_string, twist_length)하면 출력 문자열이 반환됩니다.


1
죄송합니다. 너무 빨리 게시했습니다. 고정되어 있습니다.
DankMemes



0

커피 스크립트, 151 바이트

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

너무 많이 = (


0

배쉬, 83 74

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

간의 대체물 catrev번째 인자 길이의 첫번째 인수의 문자열에 대한.

사용되는 특수 변수는 다음과 같습니다.

  • ${#1}(문자열의 길이 $1)
  • ((i/$2%2))(산술 표현식 증 분기 분할 $i$2하고 있는지의 여부를 지시하는 용도에도 대 홀수 결정하기 위해 모듈로 복용 rev)
  • ${1:i:$2}( 의 길이 로 $1시작하는 부분 문자열 ).$i$2

흠, 나는 bash지금 막 본 다른 답변 과는 독립적으로 이것을했습니다 . 우리는 사실상 같은 논리를 가지고 있습니다. ... 실제로, viktorahlström의 대답 은 또 다른 9 개의 문자를 제거하도록하겠습니다.
Adam Katz

0

자바 스크립트 ES6, 113 바이트

내 자신의 질문에 내 자신의 균열. 공백을 추가하여로 나눌 수 있으므로 n간단하게 나누고 뒤집을 수 있습니다.

(s,n)=>(s+' '.repeat(n-s.length%n)).match(eval(`/.{1,${n}}/g`)).map((l,i)=>i%2?[...l].reverse().join``:l).join`
`
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.