끈 계단

면책 조항 : 이것은 내가 제안한 첫 번째 과제입니다. 모든 의견을 환영합니다. 이것이 중복이라면 지적하십시오.

다음 은 샌드 박스 게시물에 대한 링크입니다.

골

이 과제의 목표는 문자열과 정수가 주어지면 문자열을 해당 정수 크기의 블록으로 인쇄하는 것입니다. 단어의 크기가 블록 크기보다 많은 경우 내림차순 "계단"패턴으로 인쇄하십시오.

규칙

• 위에서 언급 한 "계단 패턴"은 동일한 단어의 모든 블록에 대해 해당 블록이 해당 블록의 끝에서 정확히 시작해야한다는 것을 의미합니다. 질문이 있으면 테스트 사례를 확인하거나 요청하십시오.
• 단어가 여러 블록으로 분리 된 경우 다음 단어는 적절한 수의 공백으로 인쇄되어야합니다. 즉, 이전 단어의 최하단 블록에서 정확히 하나의 공백으로 분리해야합니다. 테스트 사례를 확인하거나 확인하십시오.
• 입력 문자열이 인쇄 가능한 ASCII 문자로만 구성되어 있다고 가정 할 수 있습니다. 또한 행에 여러 개의 공백이 없습니다.
• 정수가 항상 [1, + ∞) 범위에 있다고 가정 할 수도 있습니다.
• 후행 공백이나 개행이 허용됩니다.
• 적절한 I / O 방법 을 사용할 수 있습니다 .
• 표준 허점이 적용됩니다.
• 이것은 code-golf 이므로 가장 짧은 코드 (바이트 단위)가 이깁니다. 일주일 정도 지나면 전체적으로 가장 짧은 답변을받습니다.

테스트 사례

(String, Integer) => (Output)

"This is a large string", 3 => Thi is a lar  str
                                 s        ge   ing

"This is an even larger string!", 2 => Th  is an ev  la   st
                                        is        en  rg   ri
                                                       er   ng
                                                             !
"Ooooh dear, what a big string you have!", 3 
=> Ooo  dea  wha a big str   you hav
     oh   r,   t         ing       e!

"Staphylococcus saprophyticus", 4 => Stap        sapr
                                        hylo        ophy
                                           cocc        ticu
                                              us          s

"I hope you find this challenge interesting", 2
=> I ho  yo fi  th  ch    in
      pe  u  nd  is  al    te
                      le    re
                       ng    st
                        e     in
                               g

"Well, this test case looks kinda pointless now doesn't it?", 15
=> Well, this test case looks kinda pointless now doesn't it?

"This one looks a lot more interesting!", 1 => T o l a l m i
                                               h n o   o o n
                                               i e o   t r t
                                               s   k     e e
                                                   s       r
                                                           e
                                                           s
                                                           t
                                                           i
                                                           n
                                                           g
                                                           !
"Keep in mind, people: 'Punctuation! Does! Matter!'", 2
=> Ke  in mi  pe   'P      Do  Ma
    ep     nd  op   un      es  tt
            ,   le   ct      !   er
                 :    ua          !'
                       ti
                        on
                         !

숯 , 22 바이트

Ｆ⪪θ «↑⸿⸿ＦＬι«Ｍ¬﹪κＩη↙§ικ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

  θ                      First input
 ⪪                      Split on spaces
Ｆ   «                   Loop over each word
     ↑⸿⸿                Move the cursor to the top row and two columns right*
          ι             Current word
         Ｌ              Length
        Ｆ  «            Loop over implicit range
               κ        Current index
                 η      Second input
                Ｉ       Cast to integer
              ﹪         Modulo
             ¬          Logical not
            Ｍ     ↙     Move that many characters down and left
                    ι   Current word
                     κ  Current index
                   §    Index into word and implicitly print

*보다 정확하게는, "다음 줄의 시작 부분으로 두 번 이동하지만 캔버스가 회전 된 것처럼" 편집 :이 도전이 설정 되고이 대답이 받아 들여질 때까지 Charcoal은 실제로 문자열을 문자 쌍으로 나누는 방법을 얻었으며 코드를 16 바이트 줄였습니다.
Ｆ⪪θ «↑⸿⸿Ｆ⪪ιＩη«κ↙ 온라인으로 시도하십시오! 링크는 자세한 버전의 코드입니다. 설명:

  θ                 First input
 ⪪                  Split on spaces
Ｆ   «               Loop over each word
     ↑⸿⸿            Move the cursor to the top row and two columns right
          ι         Current wordＩη
            η       Second input
           Ｉ        Cast to integer
         ⪪          Split into substrings of that length
        Ｆ    «      Loop over each substring
              κ     Print the substring
               ↙    Move the cursor down and left

SOGL V0.12 , 28 27 26 바이트

ā,θ{0Eā;{ēb÷eb‰⁴bH*+I;Iž}┼

여기 사용해보십시오!

이것을 ‰만드는 동안 구현 했지만 그에 대한 설명서는 이전에 존재했습니다.

설명:

ā                            push an empty array - the main canvas
 ,                           push the first input
  θ{                         for each word (pushing the word each time)
    0E                         set the variable E to 0
      ā;                       below the current word place an empty array - current word canvas
        {               }      for each character of the word
         ēb÷                     push (E++ // B) - note that E is incremented after being used
            eb‰                  push E positive modulo B - like regular modulo but in the 0 output case it gives B
               ⁴                 duplicate the item below ToS
                bH               push B-1
                  *              multiply [(E++ // B) and B-1]
                   +             add [that multiplication to E‰B] - current letters X position
                    I            increase the X position to have one leading space row
                     ;           swap top 2 items - current X position and (E++ // B)
                      I          increase to create current letters Y position
                       ž         in those positions insert the current letter in the current words canvas
                         ┼     append to main canvas current word canvas horizontally

자바 ES6, 187 183 174 166 163 148 145 143 141 140 138 바이트

• 가독성을 위해 코드에 일부 바이트를 추가하고 바이트 수에서 제거했습니다.
• s = "", j = 0 대신 j = s = ""를 수행했습니다.
• for (i in s) 대신-for for 루프-1 바이트 제거
• 배열의 인덱서에서 이미 생성 된 값 사용-8 바이트 제거
• 실제 배열 길이 대신 eval에서 i = s.length (첫 번째 루프에서) 값으로 이미 사용하면 후행 공백이 허용됩니다.
• eval 대신 S의 맵 사용-3 바이트 감소
• 빈 배열을 초기화 할 때 대신 채우기를 사용하므로 맵 결과에 루프가 필요하지 않습니다.
• ||를 대체 할 수있었습니다 와 | -2 바이트 감소
• @Justin Mariner 덕분에-발생을 == ""로 < "!" 2 바이트를 줄입니다
• 하나의 "u <"! "를 줄이기 위해 a [I]에서 다른 명령문으로 조건을 이동했습니다.-2 바이트를 줄입니다.
• (I + = 2, j = 0) 대신-j =! (I + = 2)-1 바이트 감소
• 대신에 "의"

  F=(s,n)=>{R=[I=j=i=0]
  for(u of s)
  a=R[z=u<"!"?j=!(I+=2):(j%n&&I++,j++/n|0)]=R[z]||[...s].fill` `,a[I]=u
  return R.map(x=>x.join``).join`
  `}
  console.log(F("This is a large string", 3));
  console.log(F("This is an even larger string!", 2));
  console.log(F("Ooooh dear, what a big string you have!", 3));
  console.log(F("Staphylococcus saprophyticus", 4));
  console.log(F("I hope you find this challenge interesting", 2));
  console.log(F("Well, this test case looks kinda pointless now doesn't it?", 15));
  console.log(F("This one looks a lot more interesting!", 1))
  console.log(F("Keep in mind, people: 'Punctuation! Does! Matter!'", 2));

  코드 스 니펫 실행결과 숨기기

  스 니펫 확장

C #, 200 바이트

int x=-2,y=0;Regex.Split(i,@"\s+").ToList().ForEach(w =>{y=0;Regex.Matches(w,".{0,"+s+"}").Cast<Match>().ToList().ForEach(c=>{x+=(y==0?2:s-1);Console.SetCursorPosition(x,y);Console.Write(c);y++;});});

여기서 문자열은 i 로 지정되고 크기는 s 로 지정됩니다 .

예 :

string i = "Staphylococcus saprophyticus";
int s = 2;    
int x=-2,y=0;Regex.Split(i,@"\s+").ToList().ForEach(w =>{y=0;Regex.Matches(w,".{0,"+s+"}").Cast<Match>().ToList().ForEach(c=>{x+=(y==0?2:s-1);Console.SetCursorPosition(x,y);Console.Write(c);y++;});});

기본적으로 첫 번째 부분 인 Regex.Split 은 공백을 사용하여 문장을 단어로 나누고 Regex.Matches는 각 단어를 s 로 지정된 청크로 나눕니다 . 청크는 커서 위치 (x, y)에 기록되며 여기서 새 단어마다 Y가 0으로 설정되고 단어의 첫 번째 청크에 대해서는 x가 2 씩 증가하고 그에 따라 각 청크에 대해 (s-1)이 증가합니다.

x는 첫 사용이 0으로 설정되도록 -2에서 수명을 시작합니다.

C # 퀴즈에서 더 작게 만들 수있을 정도로 지식이 충분하지는 않지만 아마도 그럴 수 있다고 생각합니다.

파이썬 2 , 203 199 바이트

s,l=input()
S=s.split()
x=[]
for w in S:L=len(w);W=[i/l*~-l*' '+w[i:i+l]for i in range(0,L,l)];x+=[[c.ljust(L/l*~-l+L%l)for c in W+['']*len(s)]]
for l in zip(*x):
 L=' '.join(l)
 if L.strip():print L

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

펄 5, 59 바이트

55 바이트 코드 + 4 -ai.

$-=s/.{$^I}\K(?=.)/\x1b[1B\x1b[1D/g,print$_,"\x1b[1A"x$-,$"for@F

참고 : \x1bs는 리터럴 ESC문자이지만 쉽게 복사하여 붙여 넣기 위해 이스케이프 처리되었습니다.

이 스크립트는 ANSI 이스케이프 시퀀스를 사용하며 -i표준이 아닌 플래그를 통한 입력이 필요합니다 . 이들 중 하나라도 허용되지 않으면 알려 주시면 업데이트하겠습니다.

예제 실행

perl -ai3 string-stairs.pl <<< 'This is a large string' 2>/dev/null
Thi is a lar  str   
  s        ge   ing

perl -ai2 string-stairs.pl <<< 'This is an even larger string!' 2>/dev/null
Th  is an ev  la   st   
 is        en  rg   ri
                er   ng
                      !

perl -ai3 string-stairs.pl <<< 'Ooooh dear, what a big string you have!' 2>/dev/null
Ooo  dea  wha a big str   you hav  
  oh   r,   t         ing       e!

perl -ai4 string-stairs.pl <<< 'Staphylococcus saprophyticus' 2>/dev/null
Stap        sapr       
   hylo        ophy
      cocc        ticu
         us          s

perl -ai2 string-stairs.pl <<< 'I hope you find this challenge interesting' 2>/dev/null
I ho  yo fi  th  ch    in     
   pe  u  nd  is  al    te
                   le    re
                    ng    st
                     e     in
                            g

perl -ai15 string-stairs.pl <<< "Well, this test case looks kinda pointless now doesn't it?" 2>/dev/null
Well, this test case looks kinda pointless now doesn't it? 

perl -ai1 string-stairs.pl <<< 'This one looks a lot more interesting!' 2>/dev/null
T o l a l m i 
h n o   o o n
i e o   t r t
s   k     e e
    s       r
            e
            s
            t
            i
            n
            g
            !

perl -ai2 string-stairs.pl <<< "Keep in mind, people: 'Punctuation! Does! Matter!'" 2>/dev/null
Ke  in mi  pe   'P       Do   Ma    
 ep     nd  op   un       es   tt
         ,   le   ct       !    er
              :    ua            !'
                    ti
                     on
                      !