이 과제는 특정 깊이의 아바 카바 시퀀스를 인쇄하는 것입니다.

다음은 처음 5 개 시퀀스의 다이어그램입니다 ( a(N)깊이 N의 아바 카바 시퀀스입니다. 대문자 / 소문자는 패턴을 보여주기위한 것으로 프로그램의 출력에는 필요하지 않습니다).

a(0) = A
a(1) = aBa
a(2) = abaCaba
a(3) = abacabaDabacaba
a(4) = abacabadabacabaEabacabadabacaba
...
a(25) = abacabadabacabaeabacabadabacabafabacabadabacabaeabacabadabacabagabacabadabacabaeabacabadabacabafabacabadabacabaeabacabadabacabahabacabadabacabaeabacabadabacabafabacabadabacabaeabacabadabacabagabacabadabacabaeabacabadabacabafabacabadabacabaeabacabadabacabaiabacabadabacabaeabacabadabacabafabacabadabacabaeabacabadabacabagabacabadabacabaeabacabadabacabafabacabadabacabaeabacabadabacabahabacabadabacabaeabacabadabacabafabacabadabacabaeabacabadabacabagabacabadabacabaeabacabadabacabafabacabadabacabaeabacabadabacabajabacabadabacabaeabacabadabacabafabacabadabacabaeabacabadabacabagabacabadabacabaeabacabadabacabafabacabadabacabaeabacabadabacabahabacabadabacabaeabacabadabacabafabacabadabacabaeabacabadabacabagabacabadabacabaeabacabadabacabafabacabadabacabaeabacabadabacabaia...

아시다시피, n 번째 abacaba 시퀀스는 n 번째 문자가있는 마지막 시퀀스이며 다시 추가됩니다. ( a(n) = a(n - 1) + letter(n) + a(n - 1))

당신의 임무는 정수를 취하고 그 깊이의 아바 카바 시퀀스를 인쇄하는 프로그램이나 함수를 만드는 것입니다. 출력은 15 이하의 값에 대해 정확해야합니다.

Pyth, 11 바이트

u++GHG<GhQk

간단한 축소.

파이썬, 44 바이트

f=lambda n:"a"[n:]or f(n-1)+chr(97+n)+f(n-1)

의심 할 여지없이 골프를 치는 것 같습니다.

하스켈, 39 37 바이트

a 0="a"
a n=a(n-1)++['a'..]!!n:a(n-1)

사용 예 : a 3-> "abacabadabacaba".

편집 : @Angs는 저장할 두 바이트를 찾았습니다. 감사!

Pyth, 14 13 바이트

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

VhQ=+k+@GNk;k

14 바이트의 솔루션 : VhQ=ks[k@GNk;k.

설명:

VhQ=+k+@GNk;k

               # Implicit: k = empty string
VhQ            # For N in range input + 1      
   =           # Assign k
      +@GNk    # Position N at alphabet + k
    +k         # k + above
           ;   # End loop
            k  # Print k

여기에서 보십시오 !

망막 , 37 32 바이트

$
aa
(T`_l`l`.$
)`1(a.*)
$1$1
z

후행 줄 바꿈이 중요합니다. 입력은 단항으로 이루어 집니다.

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

Brainfuck, 157 바이트

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

입력은 이진수로 제공됩니다.

기본 아이디어는 현재 시퀀스를 반복적으로 복제하고 ( "a"로 시작) 각 반복 후에 마지막 요소를 증가시키는 것입니다.

1. a → aa → ab

2. ab → abab → abac

3. abac → abacabac → 아 바카 박

4. ...

이 모든 작업이 지정된 횟수만큼 완료되면 마지막 요소를 제외한 결과가 인쇄됩니다.

심층적 인 설명

메모리는 다음과 같은 방식으로 배열됩니다.

.---------.-.-----.----.---.-----.----.---.---
|Countdown|0|Value|Copy|End|Value|Copy|End|...
'---------'-'-----'----'---'-----'----'---'---

            |--Element 1---|--Element 2---|

카운트 다운 에는 아직 실행되지 않은 복사주기 수가 있습니다. ABACABA 서열은 각각 3 개의 세포로 구성된 인접 블록에 저장된다. 값 은 요소의 문자를 보유합니다 (예 : "A", "B", "C"...). 복사 플래그는 해당 요소 (0 = 1 = 그렇지, 복사) 현재의 복사 사이클 내에서 복사 할 필요가 있는지 여부를 나타냅니다. 끝 이 복사되는 동안 플래그가 마지막 요소를 0으로 설정 (다른 모든 경우에 1이다).

이제 실제 (약간 ungolfed) 프로그램으로 :

,                       read Countdown from input
+                       add 1 to avoid off-by-one error
>-[>++<-----]>-----     initialize value cell of first element to 97 ("a")
>>+                     set End flag of first element to 1
<<<<                    move to Countdown
[                       loop until Countdown hits 0 (main loop)
    -                   decrement Countdown
    >>                  move to Value cell of first element
    [                   copying loop
        [               duplication sub-loop
            -           decrement Value cell of the element to copy
            >>          move to End flag
            [>>>]       move to End flag of the last element
            <+<+        increment Copy and Value cell of last element (Copy cell is temporarily abused)
            <           move to End flag of second to last element
            [<<<]>>     move back to Copy cell of first element
            [>>>]<      move to Value cell of the first element where the Copy flag is 0
        ]
        >>[>>>]<        move to (abused) Copy flag of the last element
        [               "copy back" sub-loop
            -           decrement Copy flag
            <<          move to End flag of second to last element
            [<<<]>>     move back to Copy cell of first element
            [>>>]<      move to Value cell of the first element where the Copy flag is 0
            +           increment Value cell
            >>[>>>]<    move back to Copy flag of the last element
        ]
        +>+             set Copy and End flag to 1
        <<<             move to End flag of second to last element
        [<<<]>>         move back to Copy cell of first element
        [>>>]<          move to Value cell of the first element where the Copy flag is 0
        >+<             set Copy flag to 1
        >[>>>]<         move to Value cell of the next element to copy
    ]                   loop ends three cells behind the last "valid" Value cell
    <<<+                increment Value cell of last element
    >>                  move to End flag
    [<-<<]              reset all Copy flag
    <                   move to Countdown
]
>>>>                    move to End flag of first element
[>>>]<<<                move to End flag of last element                
<<<                     skip the last element
[<<.<]                  output Value cells (in reverse order, but that doesn't matter)

하스켈 , 36 바이트

tail.(iterate((:"a").succ=<<)"_a"!!)

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

이것은 대부분의 다른 답변과 다른 재귀 방법을 사용합니다. 시퀀스에서 다음 문자열을 얻으려면 이전 문자열에서 두 개의 사본을 새 문자로 결합하지 않고 모든 문자를 늘리고 산포 a합니다.

aba -> bcb -> abacaba

05AB1E , 12 바이트 (비경쟁)

암호:

'aIGDN>.bsJl

난 망할 것이다. 이 도전 haha ​​덕분에 많은 버그를 수정했습니다.

설명:

'aIGDN>.bsJl

'a             # Push the character 'a'
  I            # User input
   G           # For N in range(1, input)
    D          # Duplicate the stack
     N         # Push N
      >        # Increment
       .b      # Convert to alphabetic character (1 = A, 2 = B, etc.)
         s     # Swap the last two elements
          J    # push ''.join(stack)
           l   # Convert to lowercase
               # Implicit: print the last item of the stack

자바 스크립트 (ES6), 43 42 바이트

a=n=>n?a(--n)+(n+11).toString(36)+a(n):"a"

@Neil 덕분에 바이트가 절약되었습니다 !

또 다른 간단한 재귀 솔루션 ...

CJam (14 바이트)

'aqi{'b+1$++}/

온라인 데모

루비 (1.9 이상), 38 바이트

?a작성하는 골퍼 방법 "a"이지만 삼항과 혼합하면 이상하게 보입니다.?:

a=->n{n<1??a:a[n-1]+(97+n).chr+a[n-1]}

R , 48 바이트

f=function(n)if(n)paste0(a<-f(n-1),letters[n],a)

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

간단한 재귀.

C #, 59 바이트

string a(int n){return n<1?"a":a(n-1)+(char)(97+n)+a(n-1);}

또 다른 C # 솔루션 ...

펄, 33 바이트

map$\.=chr(97+$_).$\,0..pop;print

언 골프 할 필요가 없습니다. ASCII 값 'a'를 시작점으로 사용하여 다음 문자를 순서대로 추가하고 문자열의 역순을 반복해서 추가하여 문자열을 작성합니다. $\몇 번의 획을 저장하는 데 사용 하지만 점점 까다로워집니다.

a(0)통해 a(25)그리고 심지어 넘어서 작동합니다 . 이후에 확장 ASCII가 발생하더라도 a(29)문자 코드가 부족하기 오래 전에 메모리가 부족합니다.

a(25)~ 64MiB입니다. a(29)~ 1GiB입니다.

a(255)(unested!) 의 결과를 저장하려면 2 ^ 256-1 = 1.15x10 ^ 77 바이트 또는 대략 1.15x10 ^ 65 1 테라 바이트 드라이브가 필요합니다.

자바 7, 158 바이트

class B{public static void main(String[]a){a('a',Byte.valueOf(a[0]));}static void a(char a,int c){if(c>=0){a(a,c-1);System.out.print((char)(a+c));a(a,c-1);}}}

나는 PPCG 주위에 숨어 있고 다른 답변에 투표 / 댓글을 작성하는 것을 좋아합니다.

입력은 프로그램 매개 변수로 제공됩니다. 이것은 간단한 재귀 구현이라는 점에서 다른 답변과 동일한 형식을 따릅니다. 다른 답변에 대해서는 언급했지만 아직 언급 할 담당자가 없습니다. 또한 재귀 호출이 문자열을 작성하고 전달하는 대신 두 번 수행한다는 점에서 약간 다릅니다.

Mathematica, 36 32 바이트

##<>#&~Fold~Alphabet[][[;;#+1]]&

TWOW 11B를 본 적이 있습니까?

파이썬, 62 54 46 45 바이트

나는이 코드가 여전히 어떻게 든 골프를 칠 수 있다고 생각하고 싶습니다.

편집 : Lynn 덕분에 버그 수정. 오징어 덕분에 -1 바이트.

a=lambda n:n and a(n-1)+chr(97+n)+a(n-1)or'a'

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

수학, 46 바이트

If[#<1,"a",(a=#0[#-1])<>Alphabet[][[#+1]]<>a]&

간단한 재귀 함수. 다른 해결책 :

a@0="a";a@n_:=(b=a[n-1])<>Alphabet[][[n+1]]<>b

K5, 18 바이트

"A"{x,y,x}/`c$66+!

캐리 된 값 ( "A")과 시퀀스의 각 요소에 함수를 반복해서 적용합니다 . 순서는 B에서 알파벳 N까지의 알파벳 문자입니다 (N `c$66+!). 이 함수는 오른쪽 인수 ( {x,y,x}) 의 양쪽에서 왼쪽 인수를 결합합니다 .

실제로 :

 ("A"{x,y,x}/`c$66+!)'!6
("A"
 "ABA"
 "ABACABA"
 "ABACABADABACABA"
 "ABACABADABACABAEABACABADABACABA"
 "ABACABADABACABAEABACABADABACABAFABACABADABACABAEABACABADABACABA")

자바 스크립트, 65 57 ¹ 바이트

n=>eval('s="a";for(i=0;i<n;i++)s+=(i+11).toString(36)+s')

데모:

function a(n){
  return eval('s="a";for(i=0;i<n;i++)s+=(i+11).toString(36)+s')
}
alert(a(3))

^{1-8 바이트를 절약 해 준 Neil에게 감사}

apt, 20 17 바이트

97oU+98 r@X+Yd +X

온라인으로 테스트하십시오!

작동 원리

         // Implicit: U = input integer
65oU+66  // Generate a range from 65 to U+66.
r@       // Reduce each item Y and previous value X in this range with this function:
X+Yd     // return X, plus the character with char code Y,
+X       // plus X.

         // Implicit: output last expression

비경쟁 버전, 14 바이트

97ôU r@X+Yd +X

ô기능은 비슷 o하지만, 범위 작성 [X..X+Y]대신이 [X..Y). 온라인으로 테스트하십시오!

97에서 94로 변경하는 것을 선호합니다.이 경우 출력은 5다음과 같습니다.

^_^`^_^a^_^`^_^b^_^`^_^a^_^`^_^c^_^`^_^a^_^`^_^b^_^`^_^a^_^`^_^

자바, 219 바이트

내 첫 번째 코드 골프 시도. 아마 골프를 더 할 수 있지만 배가 고파서 점심을 먹습니다.

public class a{public static void main(String[]a){String b=j("a",Integer.parseInt(a[0]),1);System.out.println(b);}public static String j(String c,int d,int e){if(d>=e){c+=(char)(97+e)+c;int f=e+1;c=j(c,d,f);}return c;}}

언 골프 드 :

public class a {
    public static void main(String[] a) {
        String string = addLetter("a", Integer.parseInt(a[0]), 1);
        System.out.println(string);
    }

    public static String addLetter(String string, int count, int counter) {
        if (count >= counter) {
            string += (char) (97 + counter) + string;
            int f = counter + 1;
            string = addLetter(string, count, f);
        }
        return string;
    }
}

매우 간단한 무차별 재귀 알고리즘은 char조작을 사용 합니다.

MATL , 14 바이트

0i:"t@whh]97+c

이것은 언어 / 컴파일러 8.0.0 버전을 사용하며 , 이는 도전보다 빠릅니다.

예

>> matl
 > 0i:"t@whh]97+c
 >
> 3
abacabadabacaba

설명

secuence 숫자와 처음 생성 0, 1, 2, ... 이들은 문자로 변환 'a', 'b', 'c'말.

0         % initiallize: a(0)
i:        % input "N" and create vector [1, 2, ... N]
"         % for each element of that vector
  t       % duplicate current sequence
  @       % push new value of the sequence
  whh     % build new sequence from two copies of old sequence and new value
]         % end for
97+c      % convert 0, 1, 2, ... to 'a', 'b', 'c'. Implicitly print

편집하다

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

파워 쉘, 53 , 46 , 44 , 41 바이트

1..$args[0]|%{}{$d+=[char]($_+96)+$d}{$d}

콘솔에 붙여 넣으면 $d다시 실행 되지 않으므로 두 번째 실행에서 잘못된 출력이 생성됩니다 .

@TimmyD 덕분에 + = 3 바이트 저장을 사용하여 2 바이트 저장

가이아 , 14 바이트

₵aØ@⟪¤ṇ3ṁ¤+ṫ⟫ₓ

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

₵a		| Push lowercase alphabet
  Ø		| push lowercase string
   @         ₓ	| push the input and do everything between ⟪⟫ that many times
    ⟪¤		| swap
      ṇ		| take the last (first) character
       3ṁ	| push the 3rd item on the stack
         ¤+	| swap and concatenate
           ṫ⟫	| and palindromize

PowerShell , 54 바이트

param($n)for(;$n+1){$d+=[char]($i+++97-32*!$n--)+$d}$d

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

Japt , 8 바이트

;gCåÈ+iY

시도 해봐

;gCåÈ+iY     :Implicit input of integer
 g           :Index into
; C          :  Lowercase alphabet
   å         :  Cumulatively reduce, with an initial value of an empty string
    +        :    Append a copy of the current value
     i       :    Prepended with
      Y      :    The current letter

껍질 , 12 바이트

!¡S+oṠ:o→▲"a

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

1 기반 인덱싱을 사용하면 좋습니다.

설명

!             (                                          !!)
 ¡             iterate(                              )
  S                        <*>
   +                   (++)
    o                         (                     )
     Ṡ                         join$   .
      :                             (:)
       o                                    .
        →                               succ
         ▲                                   maximum
          "a                                          "a"

              (iterate((++)<*>(join$(:).succ.maximum))"a"!!)

APL (NARS), 24 자, 48 바이트

{⍵<0:⍬⋄k,⎕A[⍵+1],k←∇⍵-1}

테스트:

  f←{⍵<0:⍬⋄k,⎕A[⍵+1],k←∇⍵-1}
  f 0
A
  f 1
ABA
  f 2
ABACABA
  f 3
ABACABADABACABA
  f 4
ABACABADABACABAEABACABADABACABA

PHP -r , 43 바이트

register_argc_argv 이 기능을 사용하려면 활성화해야합니다.

for($a=$b=a;$argv[1]--;$a.=++$b.$a);echo$a;

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

PHP , 51 바이트

출력을 직접 인쇄하는 익명 함수입니다.

function($n){for($a=$b=a;$n--;$a.=++$b.$a);echo$a;}

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