문자열이 주어지면 각 대각선을 따라 텍스트가 위아래로 움직이는 삼각형 형태로 인쇄하십시오. 예를 들어, 입력은 다음 "Hello World"을 출력해야합니다.

                    d
                  l  
                r   d
              o   l  
            W   r   d
              o   l  
        o   W   r   d
      l       o   l  
    l   o   W   r   d
  e   l       o   l  
H   l   o   W   r   d
  e   l       o   l  
    l   o   W   r   d
      l       o   l  
        o   W   r   d
              o   l  
            W   r   d
              o   l  
                r   d
                  l  
                    d

올바른 형식을 유지하려면 행의 각 문자 사이의 간격이 1 이상이어야합니다.

숯 , 10 7 바이트

↗ＥＬθ✂θιＵＥ¹

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

    ↗       Print up and to the right
     ＥＬθ✂θι All suffixes of the input, as a list down and to the right
    ＵＥ¹     Insert blank columns

처음으로 ＵＥ명령 을 사용해야했습니다 .

05AB1E , 10 8 7 바이트

2 바이트를 절약 한 Emigna 에게 감사드립니다 !

ðâƶ.cðζ

05AB1E 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

파이썬 2 , 75 바이트

s=input()
k=l=len(s)
while k>1-l:k-=1;m=abs(k);print' '*m+' '.join(s[m::2])

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

Ruud는 3 바이트를 절약했습니다.

C, 86 78 73 70 자

for(int i=1,j=1-n;i=putchar(j*j<i*i&i-j?s[i-1]?:13:32)^13?i+1:++j<n;);

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

설명

순진한 구현 : 두 사이클, 위에서 아래로 채우고 왼쪽에서 오른쪽으로 (99 바이트) 채 웁니다.

for(int j=1;j<n*2;j++){for(int i=0;i<n;i++)printf("%c ",(i+j)%2&&i+1>=abs(j-n)?s[i]:' ');puts("");}

여기에서 puts ()는 \ n을 출력에 출력합니다. 변수 선언을 결합하고 j ++을 무언가 (94 바이트)와 결합합시다.

for(int i,j=0;++j<n*2;){for(i=0;i<n;i++)printf("%c ",(i+j)%2&&i>=abs(j-n)?s[i]:' ');puts("");}

좋은. 변수 j의 범위는 0 ... 2n입니다. -n ... n 안에있게하면 수학이 더 간단 해집니다. &&의 오른쪽에있는 부울 표현식의 값은 항상 0 또는 1입니다. 이는 &&를 &로 대체 할 수 있음을 의미합니다. 91 바이트 :

for(int i,j=-n;++j<n;){for(i=0;i<n;i++)printf("%c ",~(i+j)%2&i>=abs(j)?s[i]:' ');puts("");}

그리고 우리는 여분의 공간을 인쇄한다는 것을 깨달았습니다. 예, 하나의 심볼 만 인쇄하기 위해 printf ()가 필요하지 않습니다. 86 바이트 :

for(int i,j=-n;++j<n;){for(i=0;i<n;i++)putchar(~(i+j)%2&i>=abs(j)?s[i]:' ');puts("");}

더 좋습니다. 조건 i * i> = j * j는 i> = abs (j)와 동일하지만 더 짧습니다. 루프 증분 식에 puts ()를 옮깁니다. 그리고 무엇을 추측합니까? 실제로, 우리는 i + j 주위에 중괄호가 필요하지 않습니다. 78 바이트 :

for(int i,j=-n;++j<n;puts(""))for(i=0;i<n;i++)putchar(i*i>=j*j&~i+j?s[i]:' '); 

putchar ()가 인쇄 한 문자를 반환한다는 것을 알고 있습니까? XOR을 사용하여 등가의 숫자를 테스트 해 봅시다. 공백을 ASCII 코드 인 32로 바꿉니다. 줄 끝 문자 코드는 13이라는 것을 기억하십시오. 마지막으로, GCC / Clang이 https://en.wikipedia.org/wiki/Elvis_operator를 지원한다는 것을 알고 있습니까? 73 바이트 :

for(int i,j=-n;++j<n;)for(i=0;putchar(i*i>=j*j&~i+j?s[i]?:13:32)^13;i++);

마지막으로, 무엇을 추측합니까? 두 개의 for 루프가 필요하지 않습니다. 못생긴 ~ i + j를 ij로 바꿀 수 있습니다. 70 바이트 :

for(int i=1,j=1-n;i=putchar(j*j<i*i&i-j?s[i-1]?:13:32)^13?i+1:++j<n;);

향후 작업 : 루프 방향을 변경 하시겠습니까? 올바르게 수행하면 일부 바이트가 절약 될 수 있습니다.

SOGL V0.12 , 13 10 9 바이트

ēI*@∑}¹╚H

이것은 방금 추가 한 기능을 사용 하지만 얼마 전에 문서화 되었습니다.

여기 사용해보십시오!
해당 링크 ,에는 스택의 입력이 필요하고 루프에서 매번 실행될 때마다 {추가되므로 추가 ,됩니다.

implicitly start loop over POP
ē            increase the variable E, on first push which will be 0
 I           increase by 1
  *          multiply the current character that many times
   @∑        join with spaces
     }     end loop
      ¹    wrap everything on stack in an array
       ╚   center vertically
        H  rotate counter-clockwise

하스켈 , 73 바이트

f s|l<-length s-1=[zipWith min s$(' '<$[1..abs x])++cycle"~ "|x<-[-l..l]]

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

가이아 , 16 바이트

$:ċ⟪×$§×⟫†€|$¦tụ

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

설명

$                 Split into list of chars
 :ċ               Push [1 .. len(input)]
   ⟪×$§×⟫†        Apply this block to corresponding elements of the two lists:
    ×              Repetition
     $             Split into chars
      §×           Join with spaces
          €|      Centre align the rows
            $¦    Split each line into chars
              t   Transpose
               ụ  Join each row with spaces, then join the rows together with newlines

파이썬 2 , 86 83 바이트

officialaimm 덕분에 -3

lambda s,j=' '.join:map(j,zip(*(j(c*-~i).center(len(s)*2)for i,c in enumerate(s))))

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

젤리 , 15 바이트

;€⁶ṁ"JUz⁶ZUŒBZG

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

옥타브, 59 63 58 57 바이트

@(s,a=@strjust)a([kron(+a(hankel(s)),[1 0;0 0]) '']',99)'

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

자바, 292 바이트 (죄송합니다)

public class D{
public static void main(String[]r){
String s=r[0];int L=s.length(),n=L*2-1,x=L-1,d=-1,i,j;boolean a=false,o=L%2==1;
for(i=0;i<n;i++){
for(j=0;j<L;j++)System.out.print(j<x||a&&j%2==(o?0:1)||!a&&j%2==(o?1:0)?' ':s.charAt(j));
System.out.println();
x+=d;if(x<0){x=0;d=1;}a=!a;}}}

하스켈 , 81 바이트

f s|l<-length s=[[last$' ':[s!!i|i>=n,mod(n+i)2<1]|i<-[0..l-1]]|n<-abs<$>[-l..l]]

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

자바 (OpenJDK 8) 116 바이트

s->{for(int l=s.length(),i=-l;++i<l;)System.out.printf("%"+l+"s%n",s.substring(i<0?-i:i).replaceAll("(.).","$1 "));}

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

설명

s->{                                // Consumer<String> lambda
 for(int l=s.length(),i=-l;++i<l;)  // For each length between l and 1 and back to l, 
  System.out.printf("%"+l+"s%n",    // Print with align to right
    s.substring(i<0?-i:i)           // skip the first |i| characters
     .replaceAll("(.).","$1 ")      // replace every even-positioned character with a space.
   );
}

C ++, 135 바이트

좋아, 여기에 C ++로 촬영 한 내용이 있습니다.

auto f=[&](auto f,int y)->void{
  for(int i{};i<n;i++) putchar(y<0?f(f,y+1?i+1:n-1-i),'\n':i<y||i+y&1?' ':s[i]);
}; f(f,-1); f(f,-2);

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

하스켈 , 140 137 바이트

(m#n)s=(\(i,x)->' ':(last$"  ":[x:" "|rem i 2==m&&i>n]))=<<zip[0..]s
g s=((++)=<<reverse.tail)$id=<<[[(0#n)s,(1#n)s]|n<-[-1,1..length s]]

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

Challenger5에 3 바이트를 저장했습니다.

나는 그것이 최적이라고 생각하지 않습니다 ...

f라인 중 하나를 생성합니다 ( m= 0 또는 1은 라인 번호의 모듈로, 라인 번호 n입니다)

g "홀수"및 "짝수"라인을 삽입하고 결과에 자체 미러를 추가합니다.

Pyth , 25 바이트

j+_Km++*d;@Qdtj;%2>QdUQtK

여기에서 시도하십시오.

젤리 , 18 바이트

JrLm€2Ṭ;€0a⁸o⁶ṚŒḄG

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

매스 매 티카 105 바이트

(c=Characters@#;l=Length@c;StringRiffle@Table[If[Abs[j-l]<i&&EvenQ[j+i],c[[i]]," "],{j,1,2l+1},{i,1,l}])&

어쩌면 나는 다른 바이트를 깎을 수는 있지만 Mathematica에서 문자열을 처리하는 데 걸리는 문자 수 오버 헤드는 이와 같은 간단한 도전을 어렵게 만듭니다.

J, 54 바이트

[:|:|.@i.@#(>@],~' '#~[)"_1[:(,' '&,)/&.>>:@i.@#<@#"0]

온라인으로 사용해보십시오! (TIO의 출력에는 줄 바꿈과 세 개의 공백이 있지만 함수 호출이 아니기 때문에 J 인터프리터가 자동으로 수행하는 것일 수 있습니다).

나는 이것을 해결하기위한 일반적인 아이디어가 옳다고 생각하지만, 아마도 바이트 수에 추가하는 하위 최적화로 할 작은 일들이 있습니다.

이전 변형

55 바이트

<:@+:@#{.[:|:|.@i.@#(],~' '#~[)"_1>:@i.@#(,' '&,)/@#"0]

56 바이트

<:@+:@#{.[:|:|.@i.@#(],~' '#~[)"_1#{.[:(,' '&,)//.[:]\.]

설명

이것은 몇 가지 기능으로 나뉩니다. 또한 설명의 뒷부분을 철저히 다루지 않았으므로 특정 부분에 대한 더 나은 설명이 필요한지 알려 주시면 수정할 수 있습니다.

dup   =. >:@i.@# <@#"0 ]
space =. (,' '&,)/&.>
pad   =. |.@i.@# (>@],~' '#~[)"_1 ]
trans =. |:

• dup 문자열에서 각 문자를 색인 (더하기 1)만큼 여러 번 복제
• space 각 문자 사이에 공백을 삽입합니다
• pad 적절한 양의 공백으로 문자를 채 웁니다.
• trans 결과 행렬을 전치

샘플 통화 :

   trans pad space dup 'abc'
  c
 b 
a c
 b 
  c

덥

>:@i.@# <@#"0 ]
>:@i.@#         Indices of each character plus one
      #          Length of the string
   i.            Range [0,length)
>:               Add one
        <@#"0 ] Duplicate each character as many times as it index (plus one)
           "0   For each
          #   ]  Copy the character
>:@i.@#           as many times as it index
        <        Box the result

J는 길이가 고르지 않기 때문에 끝이 공백으로 채워지지 않도록 결과가 상자로 표시됩니다.

샘플 통화 :

   dup 'abc'
┌─┬──┬───┐
│a│bb│ccc│
└─┴──┴───┘

공간

(,' '&,)/&.>
         &.>  For each boxed element
(,' '&,)/      Insert spaces between each

샘플 통화 :

   space dup 'abc'
┌─┬───┬─────┐
│a│b b│c c c│
└─┴───┴─────┘

인주

|.@i.@# (>@],~' '#~[)"_1 ]
        (>@],~' '#~[)      Pad the right arg with spaces given by the left arg
|.@i.@#                    Indices in reverse order
   i. #                     Range [0,length)
|.                          Reverse

기본적으로 첫 번째 요소는 길이-1 공백으로 채우고 두 번째 요소는 길이-2로 채우십시오. 또한 복싱도 제거합니다.

샘플 통화 :

   pad space dup 'abc'
  a  
 b b 
c c c

바꾸어 놓다

이것은 |:매트릭스의 전치를 취하는 내장 함수일뿐 입니다.

JavaScript (ECMAScript 6), 161 바이트

(s,n=console.log)=>s.split("").map((q,i,a,p)=>n(p=" ".repeat(q=a.length-++i)+a.map((v,j)=>j>=q&&j%2==q%2?a[j]+' ':'').join(''))||p).reverse().map((v,i)=>i&&n(v))

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

Perl 5 , 86 + 2 (-F) = 88 바이트

@Dom의 제안과 몇 가지 내 조정을 사용하여 바이트 수를 줄였습니다.

for$k(0..$#F){$i=1;$a[$#F+$k]=$a[$#F-$k]=[map$i++<$k|($i+$k)%2?$":$_,@F]}say"@$_"for@a

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

q / kdb +, 55 바이트

해결책:

-1(+){{1_a,((2*y)#" ",z),a:x#" "}'[(|)c;1+c:(!)(#)x]x};

예:

q)-1(+){{1_a,((2*y)#" ",z),a:x#" "}'[(|)c;1+c:(!)(#)x]x}"Hello World";
          d
         l
        r d
       o l
      W r d
       o l
    o W r d
   l   o l
  l o W r d
 e l   o l
H l o W r d
 e l   o l
  l o W r d
   l   o l
    o W r d
       o l
      W r d
       o l
        r d
         l
          d

설명:

할 것. ungolfed 버전은 66 바이트입니다.

-1 flip{{1_a,((2*y)#" ",z),a:x#" "}'[reverse c;1+c:til count x]x};

보너스:

예제와 동일한 출력을 얻으려면 (74 바이트) :

q)-1(+){1_'raze{(a,((2*y)#" ",z),a:x#" ";(2*y+x)#" ")}'[(|)c;1+c:(!)(#)x]x}"Hello World";
                    d
                  l
                r   d
              o   l
            W   r   d
              o   l
        o   W   r   d
      l       o   l
    l   o   W   r   d
  e   l       o   l
H   l   o   W   r   d
  e   l       o   l
    l   o   W   r   d
      l       o   l
        o   W   r   d
              o   l
            W   r   d
              o   l
                r   d
                  l
                    d