Thử thách này là về việc in trình tự abacaba ở độ sâu cụ thể.

Dưới đây là sơ đồ của 5 chuỗi đầu tiên ( a(N)là chuỗi abacaba có độ sâu N, chữ hoa / chữ thường chỉ để hiển thị mẫu, điều này không cần thiết trong đầu ra của chương trình của bạn):

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

Như bạn có thể nói, chuỗi abacaba thứ n là cái cuối cùng có chữ cái thứ n và chính nó lại được thêm vào nó. ( a(n) = a(n - 1) + letter(n) + a(n - 1))

Nhiệm vụ của bạn là tạo một chương trình hoặc hàm lấy một số nguyên và in chuỗi abacaba của độ sâu đó. Đầu ra phải chính xác ít nhất là cho các giá trị lên đến và bao gồm 15.

Bình thường, 11 byte

u++GHG<GhQk

Giảm đơn giản.

Python, 44 byte

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

Trông đáng ngờ có thể là golf.

Haskell, 39 37 byte

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

Ví dụ sử dụng: a 3-> "abacabadabacaba".

Chỉnh sửa: @Angs tìm thấy hai byte để lưu. Cảm ơn!

Bình thường, 14 13 byte

Cảm ơn Jakube vì đã tiết kiệm một byte!

VhQ=+k+@GNk;k

Một giải pháp có 14 byte : VhQ=ks[k@GNk;k.

Giải trình:

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

Hãy thử nó ở đây !

Võng mạc , 37 32 byte

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

Các linefeed trailing là đáng kể. Đầu vào được thực hiện trong unary .

Hãy thử trực tuyến!

Brainfuck, 157 byte

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

Đầu vào được đưa ra trong nhị phân.

Ý tưởng cơ bản là lặp lại nhiều lần chuỗi hiện tại (bắt đầu bằng "a") và tăng phần tử cuối cùng sau mỗi lần lặp:

1. a → aa → ab

2. ab → abab → abac

3. abacabac → abacabac → abacabac

4. ...

Khi tất cả điều này đã được thực hiện với số lần được chỉ định, kết quả sẽ được in trừ phần tử cuối cùng.

Giải thích sâu sắc

Bộ nhớ được sắp xếp theo cách sau:

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

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

Đếm ngược giữ số chu kỳ sao chép chưa được thực hiện. Trình tự ABACABA được lưu trữ trong các khối liên kết, mỗi khối được tạo thành từ 3 ô. Giá trị giữ đặc tính của phần tử (tức là "A", "B", "C" ...). Các Sao chép cờ chỉ có hay không các yếu tố tương ứng cần phải được sao chép trong chu kỳ sao chép hiện tại (0 = sao chép, 1 = không). Các End cờ được đặt thành 0 cho yếu tố cuối cùng trong khi nó đang được sao chép (đó là 1 trong tất cả các trường hợp khác).

Bây giờ đến chương trình thực tế (hơi vô dụng):

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

Haskell , 36 byte

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

Hãy thử trực tuyến!

Điều này sử dụng một phương pháp đệ quy khác với hầu hết các câu trả lời khác. Để có được chuỗi tiếp theo trong chuỗi, chúng tôi không tham gia hai bản sao trong chuỗi trước đó với một chữ cái mới ở giữa, mà thay vào đó, tăng từng chữ cái và xen kẽ a.

aba -> bcb -> abacaba

05AB1E , 12 byte (không cạnh tranh)

Mã số:

'aIGDN>.bsJl

Tôi sẽ bị nguyền rủa. Tôi đã sửa rất nhiều lỗi nhờ thử thách này haha.

Giải trình:

'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

JavaScript (ES6), 43 42 byte

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

Một byte được lưu nhờ vào @Neil !

Một giải pháp đệ quy đơn giản khác ...

CJam (14 byte)

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

Bản demo trực tuyến

Ruby (1.9 trở lên), 38 byte

?alà một cách viết golf hơn "a"nhưng trông lạ khi trộn lẫn với chim nhạn?:

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

R , 48 byte

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

Hãy thử trực tuyến!

Đệ quy đơn giản.

C #, 59 byte

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

Chỉ là một giải pháp C # khác ...

Perl, 33 byte

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

Không có nhu cầu thực sự cho việc không chơi golf. Xây dựng chuỗi lên bằng cách lặp lại ký tự tiếp theo theo chuỗi cộng với đảo ngược chuỗi cho đến nay, sử dụng giá trị ASCII của 'a' làm điểm bắt đầu. Sử dụng $\để lưu một vài nét, nhưng đó là khó khăn như nó được.

Hoạt động cho a(0)thông qua a(25)và thậm chí xa hơn. Mặc dù bạn đã vào ASCII mở rộng sau đó a(29), bạn sẽ hết bộ nhớ rất lâu trước khi hết mã ký tự:

a(25)là ~ 64MiB. a(29)là ~ 1GiB.

Để lưu trữ kết quả của a(255)(chưa được kiểm tra!), Người ta sẽ cần 2 ^ 256 - 1 = 1.15x10 ^ 77 byte, hoặc khoảng 1.15x10 ^ 65 ổ 1 terabyte.

Java 7, 158 byte

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);}}}

Tôi muốn lẩn quẩn quanh PPCG và tôi rất thích có thể bỏ phiếu / nhận xét về các câu trả lời khác.

Đầu vào được đưa ra dưới dạng tham số chương trình. Điều này tuân theo định dạng giống như nhiều câu trả lời khác ở đây, đó là cách triển khai đệ quy thẳng. Tôi đã có ý kiến ​​về câu trả lời khác nhưng tôi chưa có đại diện để bình luận. Nó cũng hơi khác ở chỗ cuộc gọi đệ quy được thực hiện hai lần thay vì xây dựng một chuỗi và chuyển nó theo.

Toán học, 36 32 byte

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

Bạn đã bao giờ xem TWOW 11B chưa?

Python, 62 54 46 45 byte

Tôi muốn nghĩ rằng mã này vẫn có thể được đánh xuống bằng cách nào đó.

Chỉnh sửa: Sửa lỗi nhờ Lynn. -1 byte nhờ mực.

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

Hãy thử trực tuyến!

Toán học, 46 byte

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

Hàm đệ quy đơn giản. Giải pháp khác:

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

K5, 18 byte

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

Liên tục áp dụng một hàm cho một giá trị mang ( "A") và từng phần tử của chuỗi. Trình tự là các ký tự chữ cái từ B cho đến một số N ( `c$66+!). Hàm tham gia đối số bên trái ở hai bên của đối số bên phải ( {x,y,x}).

Trong hành động:

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

JavaScript, 65 57 ¹ byte

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

Bản giới thiệu:

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

^{1 - cảm ơn Neil vì đã lưu 8 byte}

Japt, 20 17 byte

97oU+98 r@X+Yd +X

Kiểm tra nó trực tuyến!

Làm thế nào nó hoạt động

         // 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

Phiên bản không cạnh tranh, 14 byte

97ôU r@X+Yd +X

Các ôchức năng là như thế o, nhưng tạo ra phạm vi [X..X+Y]thay vì [X..Y). Kiểm tra nó trực tuyến!

Tôi rất thích thay đổi 97 thành 94, trong trường hợp đó, đầu ra cho 5giống như vậy:

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

Java, 219 byte

Mã golf đầu tiên của tôi cố gắng. Có lẽ có thể chơi gôn xa hơn, nhưng tôi đói và đi ăn trưa.

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;}}

Ung dung:

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;
    }
}

Thuật toán đệ quy khá đơn giản, sử dụng charthao tác.

MATL , 14 byte

0i:"t@whh]97+c

Cái này sử dụng phiên bản 8.0.0 của ngôn ngữ / trình biên dịch, sớm hơn so với thử thách.

Thí dụ

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

Giải trình

Các secuence được tạo ra đầu tiên với những con số 0, 1, 2, ... Đây là những chuyển đổi sang chữ 'a', 'b', 'c'ở cuối.

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

Chỉnh sửa

Hãy thử trực tuyến!

Powershell, 53 , 46 , 44 , 41 byte

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

Việc dán vào bàn điều khiển sẽ tạo ra đầu ra sai lệch trong lần chạy thứ hai do $dkhông được khởi tạo lại.

Lưu 2 byte bằng cách sử dụng + = Lưu 3 byte nhờ @TimmyD

Gaia , 14 byte

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

Hãy thử trực tuyến!

₵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 byte

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

Hãy thử trực tuyến!

Japt , 8 byte

;gCåÈ+iY

Thử nó

;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

Husk , 12 byte

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

Hãy thử trực tuyến!

Sử dụng lập chỉ mục dựa trên 1, mà tôi hy vọng là OK.

Giải trình

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

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

APL (NARS), 24 ký tự, 48 byte

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

kiểm tra:

  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 byte

register_argc_argv phải được kích hoạt để làm việc này.

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

Hãy thử trực tuyến!

PHP , 51 byte

Một chức năng ẩn danh in trực tiếp đầu ra.

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

Hãy thử trực tuyến!