Bu zorluk, belirli bir derinlikteki abakaba dizisini basmakla ilgilidir.

İşte ilk 5 dizinin bir şeması ( a(N)N derinliğinin abakaba dizisidir, büyük / küçük harf sadece deseni göstermek içindir, programınızın çıktısına gerek yoktur):

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

Muhtemelen söyleyebileceğin gibi, n'ci abakaba dizisi, n'ci harfli sonuncusu ve yine kendisine eklendi. ( a(n) = a(n - 1) + letter(n) + a(n - 1))

Göreviniz bir tamsayı alan ve bu derinliğin abakaba sırasını basan bir program veya işlev yapmak. Çıktı en azından 15'e kadar olan değerler için doğru olmalıdır.

Pyth, 11 bayt

u++GHG<GhQk

Basit azaltma

Python, 44 bayt

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

Şüpheli bir şekilde golf oynayabilecek gibi görünüyor.

Haskell, 39 37 bayt

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

Kullanım örneği: a 3-> "abacabadabacaba".

Düzenleme: @Angs kaydetmek için iki bayt buldu. Teşekkürler!

Pyth, 14 13 bayt

Bayt kaydettiğiniz için Jakube'ye teşekkürler!

VhQ=+k+@GNk;k

14 olan bir çözelti, bayt: VhQ=ks[k@GNk;k.

Açıklama:

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

Burada dene !

Retina , 37 32 bayt

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

Sondaki satır besleme hızı önemli. Giriş unary olarak alınmıştır .

Çevrimiçi deneyin!

Brainfuck, 157 bayt

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

Giriş ikili olarak verilir.

Temel fikir, geçerli diziyi art arda çoğaltmak ("a" ile başlayan) ve her yinelemeden sonra son elemanı arttırmaktır:

1. a → aa → ab

2. ab → abab → abac

3. abak → abakabak → abakabak

4. ...

Bunların hepsi belirtilen sayıda yapıldıktan sonra, son eleman hariç sonuç yazdırılır.

Derinlemesine açıklama

Hafıza şu şekilde düzenlenir:

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

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

Geri sayım henüz gerçekleştirilmemiş kopya döngüsü sayısını tutar. ABACABA dizisi, her biri 3 hücreden oluşan bitişik bloklarda saklanır. Değer , öğenin karakterini tutar (yani "A", "B", "C" ...). Kopyalama bayrağı karşılık gelen elemanın (0 = 1 = yok, kopya) geçerli kopyalama çevrimi içinde kopyalanması gereken olup olmadığını gösterir. Bitiş o kopyalanırken bayrak son element için 0 olarak ayarlanır (tüm diğer durumlarda 1 var).

Şimdi asıl (biraz ungolfed) programa:

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

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

Çevrimiçi deneyin!

Bu, diğer cevapların çoğundan farklı bir özyinelemeli yöntem kullanır. Sıradaki dizgiyi almak için, önceki dizideki iki kopyayı aralarında yeni bir harfle birleştirmiyoruz, bunun yerine her harfi ve kesişimi arttırıyoruz a.

aba -> bcb -> abacaba

05AB1E , 12 bayt (rekabetçi değil)

Kod:

'aIGDN>.bsJl

Lanetleneceğim Bu meydan okuma haha ​​sayesinde birçok hata düzelttim.

Açıklama:

'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 bayt

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

Bir bayt sayesinde kurtardı @Neil !

Yine bir başka basit özyinelemeli çözüm ...

CJam (14 bayt)

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

Çevrimiçi demo

Yakut (1.9 ve üstü), 38 bayt

?ayazmak için bir golf yolu "a"ama üçlü karıştığında garip görünüyor?:

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

R , 48 bayt

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

Çevrimiçi deneyin!

Basit özyineleme.

C #, 59 bayt

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

Bir başka C # çözümü ...

Perl, 33 bayt

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

Golf oynamak için gerçek bir ihtiyaç yok. 'A' ASCII değerini başlangıç ​​noktası olarak kullanarak sırayla bir sonraki karakteri sırayla artı dizenin tersine ekleyerek dizeyi oluşturur. $\Birkaç vuruş kaydetmeyi kullanır , ancak bu onun kadar zor.

İçin çalışır a(0)yoluyla a(25)ve hatta ötesinde. Ardından ASCII'ye genişlemenize rağmen a(29), karakter kodlarını çalıştırmadan çok önce bellek yetersiz kalır:

a(25)~ 64MiB'dir. a(29)~ 1GiB'dir.

a(255)(Test edilmemiş!) Sonucunu saklamak için , 2 ^ 256 - 1 = 1.15x10 ^ 77 bayt veya kabaca 1.15x10 ^ 65 1-terabayt sürücüye ihtiyaç duyulur.

Java 7, 158 bayt

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 etrafında dolaşmayı seviyorum ve diğer cevaplar hakkında oy kullanmak / yorumda bulunmaktan keyif alacağım.

Giriş, program parametreleri olarak verilir. Bu, burada ileriye dönük bir özyinelemeli uygulama olduğu için diğer birçok cevapla aynı formatı izler. Diğer cevap hakkında yorumda bulunacaktım ancak yorum yapacak cevabım yok. Özyinelemeli çağrının bir dize oluşturmak ve onu iletmek yerine iki kez yapılması bakımından da biraz farklıdır.

Mathematica, 36 32 bayt

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

TWOW 11B'i hiç izledin mi?

Python, 62 54 46 45 bayt

Bu kodun bir şekilde hala golf oynayabileceğini düşünmek istiyorum.

Düzenleme: Lynn sayesinde hata düzeltme. Kalamar sayesinde -1 bayt.

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

Çevrimiçi deneyin!

Mathematica, 46 bayt

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

Basit özyinelemeli fonksiyon. Başka bir çözüm:

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

K5, 18 bayt

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

Bir işlevi bir değere ( "A") ve bir dizinin her bir elemanına tekrar tekrar uygulayın . Dizi, B'den bazı sayılara N ( `c$66+!) kadar olan alfabetik karakterlerdir . İşlev, sağ argümanın ( {x,y,x}) her iki tarafındaki sol argümana katılır .

Eylemde:

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

JavaScript, 65 57 ¹ bayt

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

Demo:

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

^{1 - 8 bayt kaydettiğiniz için Neil teşekkür}

Japt, 20 17 bayt

97oU+98 r@X+Yd +X

Çevrimiçi test edin!

Nasıl çalışır

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

Rekabet etmeyen sürüm, 14 bayt

97ôU r@X+Yd +X

ôFonksiyonu gibidir o, ancak aralık oluşturur [X..X+Y]yerine [X..Y). Çevrimiçi test edin!

Ben 97'yi 94'e değiştirmeyi tercih ediyorum, bu durumda çıktı 5şöyle görünüyor:

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

Java, 219 bayt

İlk kod golf denemem. Muhtemelen golf oynayabilir ama açım ve öğlen yemeğine çıkıyorum.

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

Ungolfed:

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

Oldukça basit kaba kuvvet özyinelemeli algoritması, charmanipülasyon kullanır .

MATL , 14 bayt

0i:"t@whh]97+c

Bu , meydan okumadan önceki dil / derleyicinin 8.0.0 sürümünü kullanır .

Örnek

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

açıklama

Secuence numaraları ile ilk oluşturulduğunda 0, 1, 2, ... Bu harflere dönüştürülür 'a', 'b', 'c'sonunda.

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

Düzenle

Çevrimiçi deneyin!

Powershell, 53 , 46 , 44 , 41 Bayt

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

Konsola yapıştırmak, ikinci çalıştırmada $dyeniden başlatılmadığından hatalı çıktı üretecektir .

@TimmyD sayesinde + = 3 bayt kullanarak 2 bayt kazan

Gaia , 14 bayt

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

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

Japt , 8 bayt

;gCåÈ+iY

Dene

;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

Kabuğu , 12 bayt

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

Çevrimiçi deneyin!

Tamam, umarım 1 tabanlı dizinleme kullanır.

açıklama

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

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

APL (NARS), 24 karakter, 48 bayt

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

Ölçek:

  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 bayt

register_argc_argv Bunun çalışması için etkinleştirilmelidir.

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

Çevrimiçi deneyin!

PHP , 51 bayt

Çıktıyı doğrudan basan anonim bir işlev.

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

Çevrimiçi deneyin!