这个挑战是关于打印特定深度的算盘序列。

这是前5个序列a(N)的图表（深度为N的abacaba序列，大/小写只是用来显示模式，在程序的输出中不需要）：

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

您可能会说，第n个算盘序列是最后一个带有第n个字母的序列，它本身又被添加到其中。（a(n) = a(n - 1) + letter(n) + a(n - 1)）

您的任务是制作一个使用整数的程序或函数，并打印该深度的abacaba序列。输出必须至少在15以上（包括15）正确。

Pyth，11个字节

u++GHG<GhQk

简单还原。

Python，44个字节

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

看起来可疑可打。

Haskell，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. 算盘→算盘→算盘

4. ...

当所有这些操作都已完成指定的时间后，将打印结果（不包括最后一个元素）。

深入的解释

内存按以下方式排列：

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

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

倒数计时包含尚未执行的复制周期数。ABACABA序列存储在相邻的块中，每个块由3个单元组成。值保存元素的字符（即“ A”，“ B”，“ C” ...）。该复制标志表示相应的元素是否需要被当前复制周期内（0 =复制，1 =不）被复制。复制最后一个元素的End标志设置为0（在所有其他情况下为1）。

现在进入实际的（略微偏离）程序：

,                       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个字节

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

在线尝试！

这使用了与大多数其他答案不同的递归方法。为了获得序列中的下一个字符串，我们不将前一个字符串中的两个副本连接在一起，而在两个副本之间插入一个新字母，而是将每个字母递增并穿插a。

aba -> bcb -> abacaba

05AB1E，12个字节（非竞争性）

码：

'aIGDN>.bsJl

我完蛋了。由于这个挑战，我修复了许多错误。

说明：

'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字节

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

@Neil节省了一个字节！

另一个简单的递归解决方案...

CJam（14字节）

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

在线演示

Ruby（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＃解决方案...

Perl，33个字节

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

真正不需要取消高尔夫。通过使用“ a”的ASCII值作为起点，迭代地依次添加下一个字符和到目前为止的字符串反向来构建字符串。用途$\保存一些笔画，但这几乎是棘手的。

适用于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 TB的驱动器。

Java 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吗？

Python，62 54 46 45字节

我想认为，此代码仍然可以以某种方式使用。

编辑：修复错误，感谢Lynn。-1个字节，感谢鱿鱼。

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

在线尝试！

Mathematica，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（`c$66+!）的字母字符。该函数在右参数（{x,y,x}）的任一侧连接左参数。

实际上：

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

JavaScript，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-感谢Neil保存8个字节}

Japt，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^_^`^_^

Java，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

编辑

在线尝试！

的powershell，53，46，44，41字节

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

粘贴到控制台将在第二次运行时产生错误的输出，因为$d尚未重新初始化。

使用+ =保存2个字节感谢@TimmyD，节省3个字节

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

在线尝试！