生成Abacaba序列


35

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

这是前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)正确。


3
𝑎₅之后的序列是否不确定?
LegionMammal978 '16

3
@nicael我知道,我只是想知道如何定义𝑎(∞)。
LegionMammal978 '16

2
也称为标尺序列(但用字母代替数字),以便于Google轻松进行搜索。
user253751'1

4
值得一提的是,任何有效解决此问题的方法,也是针对N个磁盘的Hanoi塔难题的解决方案。
杰夫·齐特林

3
我们可以使用基于1的索引而不是基于0的索引吗?
硕果累累

Answers:


8

Pyth,11个字节

u++GHG<GhQk

简单还原。


2
@Loovjo哦。毫无意义,0应该是空序列IMO,但我会顺应这个问题……
orlp

4
是的,很简单。去,刘海撞墙
J Atkin

@JAtkin rev-doc.txt在此答案旁边打开Pyth ,它应该很简单。
orlp

呵呵,不是我的意思(我不了解pyth,所以...)
J Atkin

7

Python,44个字节

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

看起来可疑可打。


7

Haskell,39 37字节

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

用法示例:a 3-> "abacabadabacaba"

编辑:@Angs发现要保存两个字节。谢谢!


不行a n=a(n-1)++[97+n]++a(n-1)吗 目前无法测试。
seequ

@Seeq:没有,[97+n]是的名单Integer,并a(n-1)为列表Char(又名String)。您不能串联具有不同类型的列表。toEnum使得Char出来的Integer
nimi 2016年

啊,我一直以为Char只是Haskell中一个专门的整数。
seequ 2016年

['a'..]!!ntoEnum(97+n)
Angs

@Angs:很好!谢谢!
nimi 2016年

6

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

在这里尝试!


不应该在范围内“ N” V吗?hQ只是eval(input) + 1
Loovjo,

@Loovjo是的,这更好一点,也更少混淆了:)
Adnan

您可以缩短=k=。Pyth将自动将结果分配给它k,因为它k是表达式中的第一个变量+k+@GNk
雅库布

@Jakube非常感谢!:)
Adnan'1

对于这个挑战,我有不同的答案。它不会胜过这个解决方案,但是它确实说明了一种用于给出序列的前n个字符的技术:(Vt^2Q=+k@Gx_.BhN`1)k在这种情况下,根据挑战的要求,它设置为给出前2个Q-1个字符,但是您可以看到如何更改它。)
quintopia'1


5

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)

2
欢迎光临本站!我会对更详细的细分感兴趣!
小麦向导

1
@ SriotchilismO'Zaic感谢您的回复:)我现在添加了详细的解释。
Orthoplex

5

Haskell,36个字节

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

在线尝试!

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

aba -> bcb -> abacaba

1
你的意思bcb不是cbc
Jo King

4

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

为什么不具有竞争力?
Loovjo

@Loovjo我在发布挑战修复了错误,因此这是非竞争性的:(
Adnan

4

JavaScript(ES6),43 42字节

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

@Neil节省了一个字节!

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


(n+11).toString(36)为您节省1个字节,最多可使用a(25)!
尼尔

@Neil已实现。谢谢!
user81655'1


3

Ruby(1.9及更高版本),38字节

?a是一种高尔夫球手的书写方式,"a"但与三元混合时看起来很奇怪?:

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


2

C#,59个字节

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

只是另一个C#解决方案...


2

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的驱动器。


1
现在,我们需要那些原子振荡的yottabyte驱动器
CalculatorFeline

2

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周围,我很高兴能够对其他答案进行投票/评论。

输入作为程序参数给出。它遵循与此处许多其他答案相同的格式,因为它是直接递归的实现。我会在其他答案上发表评论,但我没有代表对此发表评论。它也稍有不同,因为递归调用执行了两次,而不是构建字符串并传递。


欢迎来到PPCG!我希望您将来可以做更多的事情,而不是投票和发表评论(但不必那样做)。:)
Martin Ender

2

Mathematica,36 32字节

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

您看过TWOW 11B吗?


不需要"",,然后您可以使用中缀表示法Fold
马丁·恩德

#1导致null <>,而#2仅适用于二进制函数。
CalculatorFeline

您是否在想要的答案上发表了此评论?因为我不知道你的意思。:)
Martin Ender

*#1导致StringJoin连接null,而#2仅适用于二进制或关联函数。(x〜Fold〜y〜Fold〜z = Fold [x,Fold [y,z]]而不是Fold [x,y,z])
CalculatorFeline

哦,您的意思是“建议1”。不,它不会导致Null。为什么会这样?
Martin Ender

2

Python,62 54 46 45字节

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

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

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

在线尝试!


输出应全部小写。问题中的大写字母只是为了使重复清晰。
Loovjo

哎呀 感谢您的澄清。
Sherlock9年

lar 感谢@ user81655
Sherlock9

这是无效的(它永远不会终止,请尝试一下)。即使在基本情况下,也会计算表达式的递归部分。
Lynn

固定。谢谢@琳!
夏洛克9

1

Mathematica,46个字节

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

简单的递归函数。另一个解决方案:

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

1

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

我认为该序列应为小写,但不花费任何字节。
user48538 '16

1

JavaScript,65 57 1字节

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


(i+11).toString(36)为您节省6个字节。
尼尔

@Neil Haha,这是一个聪明的破解
Nicael

哦,如果您将分配s="a";移到之前,for则它将成为默认返回值,您可以删除尾随;s以节省另外2个字节。
尼尔

@Neil尼斯,不知道那件事。
nicael

我认为您可以通过递增i内联并在for循环中删除增量来节省一个字节。所以...for(i=0;i<n;)s+=(i+++11)...
并不是查尔斯

1

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

1

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操纵。


您可以publicaaddLetter/ 省略关键字j
dorukayhan希望莫妮卡回到

1

MATL,14个字节

0i:"t@whh]97+c

这使用的语言/编译器版本为8.0.0,比挑战更早。

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

说明

该secuence创建第一个以数字012,......这些都转换为字母'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

编辑

在线尝试!


1

的powershell,534644,41字节

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

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

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


@TimmyD实际上得到它下降到41,因为我不需要了()
乔纳森·里奇·佩平

不,那是我的错,即使我说我做到了,但实际上我忘了更新它。
乔纳森·里奇·佩平

该脚本不会以0摇摆,并且不会生成大写字母
mazzy

1

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


1

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

1

外壳,12个字节

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

在线尝试!

使用基于1的索引,我希望可以。

说明

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

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

1

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

1
APL不会在每个字符一个字节的情况下使用它自己的代码页,使之成为24个字节吗?
Loovjo

@Loovjo,我知道Nars Apl的字符集为字符2个字节
RosLuP

1

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

在线尝试!

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.