문자열을 천천히 다른 것으로 바꾸십시오

31

도전

두 개의 문자열 / 문자열 배열이 주어지면 첫 번째 문자열을 천천히 축소하고 두 번째 문자열로 다시 확장하십시오.

문자열이 항상 같은 문자로 시작한다고 가정 할 수 있습니다.

예

Input:
"Test", "Testing"

Output:
Test
Tes
Te
T
Te
Tes
Test
Testi
Testin
Testing

먼저 첫 번째 단어를 출력하십시오.

Test

그런 다음 문자열이 한 문자 길이가 될 때까지 한 문자를 계속 제거하십시오.

Tes
Te
T

그런 다음 두 번째 단어의 한 글자를 추가 할 때까지 계속 추가하십시오.

Te
Tes
Test
Testi
Testin
Testing

(두 문자열이 한 문자 길이 인 경우, 그중 하나를 한 번만 출력하십시오.)

테스트 사례

"Hello!", "Hi."
Hello!
Hello
Hell
Hel
He
H
Hi
Hi.

"O", "O"

O

"z", "zz"

z
zz

".vimrc", ".minecraft"

.vimrc
.vimr
.vim
.vi
.v
.
.m
.mi
.min
.mine
.minec
.minecr
.minecra
.minecraf
.minecraft

"     ", "   "

SSSSS
SSSS
SSS
SS
S
SS
SSS

"0123456789", "02468"

0123456789
012345678
01234567
0123456
012345
01234
0123
012
01
0
02
024
0246
02468

(참고 : 공간 / 네 번째 테스트 사례에서 S를 공백으로 바꿉니다.)

규칙

  • 이것은 code-golf 이므로 바이트 단위의 최단 답변이 승리합니다! Tiebreaker는 가장 많이 올린 게시물입니다. 당첨자는 2016 년 10 월 10 일에 선정됩니다.

  • 표준 허점은 금지되어 있습니다.

code-golf  string 
— 아크로리스
소스
후행 줄 바꿈 2 개 (시퀀스 다음에 보이는 빈 줄 하나)가 허용됩니까?
— seshoumara

답변:

11

Pyth, 9 바이트

j+_._Et._

STDIN에서 따옴표로 묶인 문자열로 두 번째 문자열을 가져온 다음 첫 번째 문자열을 가져 와서 결과를 인쇄하는 프로그램.

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

작동 원리

j+_._Et._  Program. Inputs: Q, E
   ._E     Yield prefixes of E as a list
  _        Reverse the above
       ._  Yield prefixes of Q as a list (implicit input fill)
      t    All but the first element of above
 +         Merge the two lists
j          Join on newlines
           Implicitly print
— 바이킹 바이킹
소스
14

V , 14 바이트

òYp$xhòjòÄ$xhh

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

설명:

ò     ò     "Recursively:
 Yp         "  Yank the current line and paste it
   $        "  Move to the end of the current line
    x       "  Delete one character
     h      "  Move One character to the right.
            "  Because of the way loops work in V, this will throw an error if there
            "  Is only one character on the current line.

이제 버퍼는 다음과 같습니다.

0123456789
012345678
01234567
0123456
012345
01234
0123
012
01
0

다음 줄에 대해 같은 작업을 반대로 수행하면됩니다.

j           "Move down one line
 ò     ò    "Recursively (The second ò is implicit)
  Ä         "  Duplicate this line up
   $        "  Move to the end of the current line
    x       "  Delete one character
     hh     "  Move two characters to the right.
            "  Because of the way loops work in V, this will throw an error if there
            "  Is only two characters on the current line.

더 흥미로운 대체 솔루션 :

òÄ$xhòç^/:m0
ddGp@qd
— DJMcMayhem
소스
3
그것은 vim이 항상 직업을위한 올바른 도구 인 것처럼
— Downgoat
@ Downgoat 정확합니다. 당신 이
— V.:P
9

파이썬, 93 바이트

f=lambda a,b,r='',i=2:a and f(a[:-1],b,r+a+'\n')or(len(b)>=i and f(a,b,r+b[:i]+'\n',i+1)or r)

빈 문자열로 시작은 r, 추가 a및 줄 바꿈과에서 마지막 문자를 제거 a할 때까지 a다음 비어의 필요한 부분을 추가 b카운터를 유지하여와 줄 바꿈을, i에서 시작하는 2길이 될 때까지 b다음, 수익을 초과 r. 후행 줄 바꿈이 있습니다.

모든 테스트는 이데온에 있습니다

— 조나단 앨런
소스
2 가지 1) 나는 당신이 문자를 잘못 계산했다고 생각합니다. 실제로 93과 2입니다. 당신은 말할 필요가 없습니다 r="". 간단 r하게 작동합니다.
@JackBates에게 감사드립니다. 1. 수정 및 업데이트-아마 f=. 2. r=''현재가 없으면 효과 f('test','testing')가 없을 것이다. 예 f('test','testing',''),하지만 사양을 따라야합니다.
— Jonathan Allan
용서 해줘. 나는 예제가 아닌 코드를보고있었습니다.
7

망막, 50 41 26 바이트

15 (!) 바이트를 절약 한 Martin Ender에게 감사합니다.

M&!r`.+
Om`^.¶[^·]+|.+
A1`

줄 바꿈으로 구분 된 두 문자열로 입력을받습니다.

Test
Testing

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

설명

M&!r`.+

첫 번째 줄은 두 단어의 "단계"를 생성합니다.

Testing
Testin
Testi
Test
Tes
Te
T
Test
Tes
Te
T

M일치 모드 용이며 &겹치는 일치를 고려 !하여 일치 수 대신 인쇄합니다. 반대의 이유는 r왼쪽에서 오른쪽으로의 옵션입니다. 엔진이 문자열의 끝에서 일치하는 항목을 찾기 시작하고 시작 부분으로 계속합니다.

Om`^.¶[^·]+|.+

이것은 올바른 순서로 모든 것을 얻습니다 O. 다음 정규 표현식의 모든 일치 항목을 rts : 자체 줄의 문자와 그 이후의 모든 문자 (줄 바꿈 포함), 전체 절반을 하나의 청크로 또는 일치하는 문자 줄과 일치시킵니다. 각 개별 줄과 일치합니다. 그런 다음이 일치 항목은 코드 포인트별로 정렬되므로 T 다음에 줄 바꿈이 먼저오고 그 뒤에 줄이 오며 길이가 오름차순으로 나타납니다.

A1`

이제 첫 번째 문자 줄이 맨 위에 있으므로 Antigrep 모드를 사용 하여 기본 정규 표현식의 첫 번째 일치 항목을 삭제합니다 .+.

구 버전

M&!r`.+
O`\G..+¶
s`(.*)¶.¶(.*)
$2¶$1
¶.$

이 버전을 온라인으로 사용해보십시오!

설명

첫 번째 줄은 동일하므로 위의 설명을 참조하십시오.

O`\G..+¶

이것은 전반부의 행을 반전시킵니다 (두 번째 입력 단어). 실제로 O행을 rts하고 정규 표현식은 일치를 제한합니다. 두 개 이상의 문자 ( ..+)와 줄 바꿈 ( )이 뒤 따르는 마지막 행 ( )으로 시작해야합니다 \G. 위의 예 T에서 가운데 의 싱글 은 일치하지 않으므로 그 뒤에는 아무것도 없습니다.

Te
Tes
Test
Testi
Testin
Testing
T
Test
Tes
Te
T

이제 올바른 두 가지 구성 요소가 있지만 순서가 잘못되었습니다.

s`(.*)¶.¶(.*)
$2¶$1

¶.¶중간에있는 고독한 T와 일치하지만 두 부분을 분리 할 필요는 없습니다. 둘 (.*)은 s잉글 라인 모드 덕분에 개행을 포함하여 전후의 모든 것을 포착 합니다. 두 캡처는 사이에 줄 바꿈을 사용하여 올바른 순서로 대체됩니다.

입력 문자열이 한 문자 길이가 아니라면 입력이 변경되지 않는 한 완료됩니다. 중복을 제거하기 위해 ¶.$(문자열의 마지막 줄이 단일 문자 일 때) 아무것도 대체 하지 않습니다.

— NinjaBearMonkey
소스
4

파이썬 2, 88 82 바이트

x,y=input(),input()
for i in x:print x;x=x[:-1]
s=y[0]
for i in y[1:]:s+=i;print s

각각 따옴표로 묶인 두 개의 입력을받습니다.

바이트를 절약하고 버그를 지적한 @JonathanAllan에게 감사합니다.

— Atlasologist
소스
1
필요 없음 len(x)에 x=x[:len(x)-1]그냥 쓸 수 - 부정적인 오프셋 슬라이스가 작동하기 때문에 x=x[:-1]. 문제는 코드가 " ", " "테스트 사례를 잘 처리하지 못한다는 것입니다.
— Jonathan Allan
1
두 번째를 삭제하고 다음 input()과 같은 입력 형식을 사용할 수 있습니다."<str1>", "<str2>"
— LevitatingLion
당신은 두 번째 라인을 변경할 수 있습니다 for i in range(x):print x[-i:], 그리고에 네 번째 줄 for i in range(1,y):print y[:-i]. 그래도 작동하는지 확실하지 않습니다.
— clismique
4

펄, 34 28 바이트

포함 +2 을 위해-0n

STDIN에서 별도의 줄에 문자열을 사용하여 실행하십시오.

perl -M5.010 -0n slow.pl
Test
Testing
^D

slow.pl:

/(^..+|
\K.+?)(?{say$&})^/

정규식 역 추적으로 작업을 수행하십시오 ...

— 톤호 스펠
소스
3

Brachylog , 32 바이트

:1aLtT,Lhbr:Tc~@nw
:2fb
~c[A:B]h

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

설명

Brachylog 그러므로 우리가 사용하여 접두사를 얻을 것이다, 내장 된 접두사가없는 concatenate접두사 : (참조 2 술어) S되는 P경우 P에 연결된 Q에서 (그것이 무엇이든) 결과를 S.

  • 주요 술어 :

    :1aL                  L is all prefixes of both elements of the input (see predicate 1)
   LtT,               T is the second element of L
       Lhbr           Remove the first prefix of the first list of L and reverse it
           :Tc        Concatenate with T
              ~@n     Join with newlines
                 w    Write to STDOUT

  • 술어 1 :

    :2f                   Find all prefixes of the input string (see predicate 2)
   b                  Remove the first one (empty string)

  • 술부 2 :

    ~c[A:B]               Input is the result of concatenating A to B
       h              Output is A
— 치명적
소스
3

자바 스크립트, 103 81 바이트

f=(x,y,n=1)=>x?`
`+x+f(x.slice(0,-1),y):n++<y.length?`
`+y.slice(0,n)+f(x,y,n):''

예: f("Test", "Testing")

산출:

Test
Tes
Te
T
Te
Tes
Test
Testi
Testin
Testing

원래 답변

f=(x,y,n=1)=>x?(console.log(x),f(x.slice(0,-1),y)):n++<y.length?(console.log(y.slice(0,n)),f(x,y,n)):''
— 헤디
소스
3

자바, 188 179 바이트

interface E{static void main(String[]a){int i=a[0].length();while(i>1)System.out.println(a[0].substring(0,i--));while(i<=a[1].length())System.out.println(a[1].substring(0,i++));}}

최신 정보

  • s 변수 제거, 9 바이트 저장

언 골프 :

interface E {

    static void main(String[] a) {
        int i = a[0].length();
        while (i > 1) {
            System.out.println(a[0].substring(0, i--));
        }
        while (i <= a[1].length()) {
            System.out.println(a[1].substring(0, i++));
        }
    }
}

사용법 :

$ java E 'test' 'testing'
test
tes
te
t
te
tes
test
testi
testin
testing
— Master_ex
소스
3

하스켈, 54 53 47 바이트

t[]=[]
t x=x:t(init x)
(.reverse.t).(++).init.t

사용 예 : ((.reverse.t).(++).init.t) "Hello" "Hi!"->["Hello","Hell","Hel","He","H","Hi","Hi!"] .

무의미한 마술. 모든 초기 하위 문자열의 목록을 만드는 f x y = (init(t x))++reverse (t y)위치 와 같습니다 ( t예 : t "HI!"->) ["H","HI","HI!"].

— 니미
소스
흠 t=reverse.tail.inits?
— Bergi
@ Bergi : 물론이지만 inits필요합니다 import Data.List.
— nimi
3

GNU sed, 57 45 + 2 (rn 플래그) = 47 바이트

:;1{/../p};2G;2h;s/.(\n.*)?$//;/./t;g;s/.$//p

운영:

echo -e "Test\nTesting" | sed -rnf morphing_string.sed

입력은 개행으로 구분 된 두 문자열이어야합니다. 코드는 각 줄마다 sed로 실행됩니다.

루프 :는 문자열의 끝에서 한 문자를 반복적으로 삭제합니다. 첫 번째 문자를 제외하고 첫 번째 문자열과 관련된 출력이 직접 인쇄됩니다 1{/../p}. 두 번째 문자열의 출력은 2G;2h삭제하는 동안 보류 공간에 역순 ( )으로 저장되고 끝에 인쇄됩니다.

— 세수 마라
소스
3

C (gcc) , 102 97 95 93 바이트

n;f(char*a,char*b){for(n=strlen(a);n;puts(a))a[n--]=0;for(a=b+1;*a++;*a=n)n=*a,*a=0,puts(b);}

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

첫 번째 루프는 끝에서 시작하여 0 바이트로 문자열을 덮어 씁니다. puts() 을 인쇄하는 합니다. 두 번째 루프는 처음부터 덮어 쓸 수 없으며 이전 값을 저장해야 다시 되돌릴 수 있습니다. 0 바이트는 끝을 향해 걷고 있습니다.

2 바이트를 면도 할 때마다 @homersimpson과 @ceilingcat에게 감사드립니다!

— 슬리에 펜
소스
1
다음 n과 같은 전역 int로 선언하여 몇 바이트를 저장할 수 있습니다 n;f(char*a,char*b){n=strlen(a).... 그리고 아마도 n=*a=0for 루프의 본문에서 체인 할당으로 할 수 있습니다 .
— homersimpson
@homersimpson에게 감사합니다. 그러나 n = * a = 0은 n = * a, * a = 0과 같지 않습니다.
— G. Sliepen
2

파이썬 3, 104 바이트

Meh.

n='\n';lambda x,y:x+n+n.join(x[:-i]for i in range(1,len(x)-1))+n+n.join(y[:i]for i in range(1,len(y)+1))

21 바이트를 골프로 해준 @DJMcMayhem에게 감사합니다.

무시 했어!

— 베타 붕괴
소스
1
5 바이트를 n='\n'사용하고 대신 n 을 사용할 수 있습니다 '\n'. 인쇄 대신 람다를 사용하면 8을 더 줄일 수 있습니다.n='\n';lambda x,y:n.join(x+n+n.join(x[:-i]for i in range(1,len(x)-1))+n+n.join(y[:i]for i in range(1,len(y)+1)))
— DJMcMayhem
2

REPL / 자바 스크립트, 109 바이트

거짓 문자열을 사용하여 원래 문자열을 휘젓습니다.

숫자가 큰 하위 문자열을 남용하여 두 번째 숫자를 늘리면 마지막과 같은 단어를 인쇄하려고 할 때 중지합니다.

(a,b)=>{l=console.log;z='substring';for(c=a.length;d=a[z](0,c--);){l(d)}for(c=2;d!=(n=b[z](0,c++));){l(d=n)}}

데모:

> ((a,b)=>{l=console.log;z='substring';for(c=a.length;d=a[z](0,c--);){l(d)}for(c=2;d!=(n=b[z](0,c++));){l(d=n)}})("asdf","abcd")
[Log] asdf
[Log] asd
[Log] as
[Log] a
[Log] ab
[Log] abc
[Log] abcd
— 바르 탄
소스
1
a=>b=>...(a) (b)를 사용하여 함수를 호출하는 것이 1 바이트 더 짧습니다.
— Zwei
2

Brainfuck, 38 55 바이트

>++++++++++>,[>,]<[<]>>[[.>]<[-]<[<]>.>],.[[<]>.>[.>],]

편집 : 출력에 개행 포함

— 제프
소스
코드를 작동시킬 수 없습니다. 입력이 줄 바꾸기로 분리되어 있습니까? 어떤 통역사를 사용하고 있습니까?
— acrolith
2

라켓 193 바이트

(define(f l)
(let*((s(list-ref l 0))
(x(string-length s)))
(for((n x))
(println(substring s 0(- x n))))
(set! s(list-ref l 1))
(for((n(range 1(string-length s))))
(println(substring s 0(add1 n))))))

테스트 : 

(f(list "Test" "Testing"))

"Test"
"Tes"
"Te"
"T"
"Te"
"Tes"
"Test"
"Testi"
"Testin"
"Testing"


(f(list "Hello!" "Hi."))

"Hello!"
"Hello"
"Hell"
"Hel"
"He"
"H"
"Hi"
"Hi."
— rnso
소스
첫 번째 문자가 아닌 입력 문자열에서 마지막 문자를 삭제해야합니다.
— agilob
2

플로 로이드 , 69 바이트

a,b=L.J
c=1
NZ(a)!=1:z(a);a=a[:-1]
z(a)
NZ(a)!=Z(b):c+=1;a=b[:c];z(a)

시작입니다. STDIN에서 입력을받습니다.

테스트 케이스

Input: Test Testing
Output:
Test
Tes
Te
T
Te
Tes
Test
Testi
Testin
Testing

Input: O O
Output: O
— 이트시
소스
1

자바 스크립트 (ES6), 92 바이트

(s,t)=>s.replace(/./g,`
$\`$&`).split`
`.slice(2).reverse().join`
`+t.replace(/./g,`
$\`$&`)

이 replace문장은 삼각형의 문자열을 생성하는데, 이는 출력의 후반부에 정확히 필요한 것이지만, 전반은 반전되고 단일 문자 행은 제거되어야합니다. 참고 : 첫 번째 문자열이 단일 문자 인 경우 선행 개행을 출력합니다. 이것이 바람직하지 않은 경우 여분의 바이트의 경우이 버전은 항상 후행 줄 바꿈을 출력합니다.

(s,t)=>s.replace(/./g,`
$\`$&\n`).split(/^/m).slice(1).reverse().join``+t.replace(/./g,`
$\`$&\n`)
— 닐
소스
1

C, 142 바이트

#define _(x,y) while(y)printf("%.*s\n",d,x-c);
f(char*a,char*b){int c=1,d=strlen(a)+1;while(*++a==*++b)c++;_(a,--d>=c)d++;_(b,d++<strlen(b-c))}

제공하십시오 f(char* str1, char* str2).

— 케누 간
소스
1

TI 기본, 56 바이트

Prompt Str1,Str2
Str1
While 1<length(Ans
Disp Ans
sub(Ans,1,length(Ans)-1
End
For(I,1,length(Str2
Disp sub(Str2,1,I
End

사용법 예

Str1=?Test
Str2=?Testing
Test
Tes
Te
T
Te
Tes
Test
Testi
Testin
Testing

Str1=?O
Str2=?O
O

Str1=?z
Str2=?zz
z
zz
— 팀텍
소스
1

자바, 168136 바이트

(s,d)->{int i=s.length()+1;while(i-->1)System.out.println(s.substring(0,i));while(i++<d.length())System.out.println(d.substring(0,i));};

언 골프 테스트 프로그램

public static void main(String[] args) {

    BiConsumer<String, String> biconsumer = (s, d) -> {
        int i = s.length() + 1;
        while (i-- > 1) {
            System.out.println(s.substring(0, i));
        }
        while (i++ < d.length()) {
            System.out.println(d.substring(0, i));
        }
    };

    biconsumer.accept("Test", "Testing123");

}
— 숀 와일드
소스
1

(Lambdabot) Haskell-41 바이트

f=(.drop 2.inits).(++).reverse.tail.inits

더 읽기 쉽지만 2 바이트 더 깁니다.

a!b=(reverse.tail$inits a)++drop 2(inits b)


산출:

f "Hello" "Hi!"
["Hello","Hell","Hel","He","H","Hi","Hi!"]
— 블랙 캡
소스
1

J, 18 바이트

]\@],~[:}:[:|.]\@[

언 골프 드 :

]\@] ,~ [: }: [: |. ]\@[

이것은 7 열차입니다.

]\@] ,~ ([: }: ([: |. ]\@[))

가장 안쪽 기차는 [: |. ]\@[캡으로 구성되어 [:우리가 적용 할 수 있도록, 왼쪽 |.의 결과 (역) ]\@[입니다, ]\(접두사) 이상[ (왼쪽 인수).

testing, test입력 에 다음과 같은 모습이 있습니다 .

   'testing' ([: |. ]\@]) 'test'
test
tes
te
t

이것은 우리에게 거의 첫 번째 부분을 제공합니다. 그 외부의 5 트레인 은 위의 표현식에 ([: }: ([: |. ]\@[))적용됩니다 }:(마지막 요소 제거).

   'testing' ([: }: [: |. ]\@]) 'test'
test
tes
te

(중복 점이 중복 될 수 없기 때문입니다.)

바깥 부분은 마침내 :

]\@] ,~ ([: }: ([: |. ]\@[))

이것은 ]\@](왼쪽 인수의 접두사)와 ,~(왼쪽에 무엇이 있는지, 오른쪽에 무엇이 있는지 추가 ) 로 구성되어 원하는 결과를 얻습니다.

   'testing' (]\@] ,~ ([: }: ([: |. ]\@[))) 'test'
testing
testin
testi
test
tes
te
t
te
tes
test

테스트 사례

   k =: ]\@] ,~ ([: }: ([: |. ]\@[))
   'o' k 'o'
o
   k~ 'o'
o
   'test' k 'test'
test
tes
te
t
te
tes
test
   k~ 'test'
test
tes
te
t
te
tes
test
   '. . .' k '...'
. . .
. .
. .
.
.
..
...
   'z' k 'zz'
z
zz
— 코너 오브라이언
소스
(,~}:@|.)&(]\)
— 마일을
1

PHP, 117109 바이트

for($i=strlen($a=$argv[1]);$i>1;)echo" ".substr($a,0,$i--);
for(;$j<strlen($b=$argv[2]);)echo" ".$c.=$b[$j++];


for($i=strlen($a=$argv[1]);$i>1;)echo substr($a,0,$i--)." ";
for(;$i<=strlen($b=$argv[2]);)echo substr($b,0,$i++)." ";

PHP, 107 바이트 (를 포함하는 문자열로는 작동하지 않음 0)

for($a=$argv[1];$a[$i];)echo substr($a.a,0,-++$i)." ";
for($b=$argv[2];$b[$j];)echo substr($b,0,++$j+1)." ";
— 암호화
소스
1

C, 111 바이트

f(char*a, char*b){int l=strlen(a),k=1;while(*a){printf("%s\n",a);a[--l]=0;}while(b[k]) printf("%.*s\n",++k,b);}

비 골격 테스트

#include <stdio.h>
#include <string.h>

f(char*a, char*b) {
  int l=strlen(a), k=1;
  while(*a) {
    printf("%s\n",a);
    a[--l]=0;
  }
  while(b[k])
    printf("%.*s\n",++k,b);
}

int main() {
  char a[10] = {0};
  char b[10] = {0};

  for (int i=0; i<5; ++i) {
    a[i] = 'a' + i;
    b[i] = 'a' + i*2;
  }

  f(&(a[0]), &(b[0]));
}
— 영국 몽키
소스
1

brainfuck, 162 바이트

,[>,]++++++++++[[-<]>[->]<]++++++++++[<[+<]<[+<]>[+>]>[+>]<---]<[<]<[<]>[[.>]++++++++++.----------<[-]<[[->+<]<]>>]>[<+>-]>[[<+>-]<[<]>[.>]++++++++++.---------->]

여기 사용해보십시오

입력은 두 개의 문자열을 줄 바꿈으로 구분하여 가져옵니다.

brianfuck 및 첫 번째 코드 골프를 사용한 첫 번째 프로그램이므로 수행해야 할 최적화가 많이 있습니다. 그래도 재미있었습니다.

언 골프

,[>,] Read all input
++++++++++ Flag for 10
[                   Subtract 10 from each cell to flag space for blank
    [-<]            
    >
        [->]
        <
]
++++++++++ Flag for 10
[                   Add 10 back to each cell with value in it
    <[+<]<[+<]
    >[+>]>[+>]<---
]
<[<]<[<]>               goto first cell in first string string      

[                           Print first word subtracting one each time
    [.>]                    Print first string
    ++++++++++.----------   Print new line
    <[-]                    Kill last letter of first string
    <                       Back one
    [                       Move each first string character up one
          [->+<]
          <
    ]>>
]
>[<+>-]>                    Move to first letter of scond string back one goto second letter
[                               
    [<+>-]                  Move next letter back
    <[<]>                   Move to start of string
    [.>]                    Print string
    ++++++++++.----------   Print new line
    >
]
— gtwebb
소스
PPCG에 오신 것을 환영합니다! 인상적인 첫 번째 게시물!
— Rɪᴋᴇʀ
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.