Questa sfida riguarda la stampa della sequenza abacaba di una profondità specifica.

Ecco un diagramma delle prime 5 sequenze ( a(N)è la sequenza abacaba di profondità N, maiuscole / minuscole è solo per mostrare il modello, questo non è necessario nell'output del tuo programma):

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

Come probabilmente puoi dire, l'ennesima sequenza di abacaba è l'ultima con l'ennesima lettera e si aggiunge di nuovo ad essa. ( a(n) = a(n - 1) + letter(n) + a(n - 1))

Il tuo compito è creare un programma o una funzione che prende un numero intero e stampa la sequenza abacaba di quella profondità. L'output deve essere corretto almeno per i valori fino a 15 inclusi.

Pyth, 11 byte

u++GHG<GhQk

Semplice riduzione.

Python, 44 byte

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

Sembra sospettosamente potrebbe essere golfabile.

Haskell, 39 37 byte

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

Esempio di utilizzo: a 3-> "abacabadabacaba".

Modifica: @Angs ha trovato due byte da salvare. Grazie!

Pyth, 14 13 byte

Grazie a Jakube per aver salvato un byte!

VhQ=+k+@GNk;k

Una soluzione con 14 byte: VhQ=ks[k@GNk;k.

Spiegazione:

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

Provalo qui !

Retina , 37 32 byte

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

L'alimentazione di linea finale è significativa. L'input è preso in unario .

Provalo online!

Brainfuck, 157 byte

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

L'input è dato in binario.

L'idea di base è duplicare ripetutamente l'attuale sequenza (iniziando con "a") e incrementare l'ultimo elemento dopo ogni iterazione:

1. a → aa → ab

2. ab → abab → abac

3. abac → abacabac → abacabac

4. ...

Quando tutto ciò è stato fatto per il numero di volte specificato, il risultato viene stampato escludendo l'ultimo elemento.

Spiegazione approfondita

La memoria è organizzata nel modo seguente:

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

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

Il conto alla rovescia contiene il numero di cicli di copia che devono ancora essere eseguiti. La sequenza ABACABA è memorizzata in blocchi adiacenti, ciascuno composto da 3 celle. Il valore contiene il carattere dell'elemento (ovvero "A", "B", "C" ...). Il flag Copia indica se l'elemento corrispondente deve essere copiato o meno all'interno del ciclo di copia corrente (0 = copia, 1 = non farlo). Il flag End è impostato su 0 per l'ultimo elemento mentre viene copiato (è 1 in tutti gli altri casi).

Ora al programma attuale (leggermente non golfizzato):

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

Provalo online!

Questo utilizza un metodo ricorsivo diverso dalla maggior parte delle altre risposte. Per ottenere la stringa successiva nella sequenza, non uniamo due copie nella stringa precedente con una nuova lettera in mezzo, ma incrementiamo invece ogni lettera e quella dell'intersperso a.

aba -> bcb -> abacaba

05AB1E , 12 byte (non competitivo)

Codice:

'aIGDN>.bsJl

Sarò dannato. Ho risolto molti bug grazie a questa sfida ahah.

Spiegazione:

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

Un byte salvato grazie a @Neil !

Ancora un'altra semplice soluzione ricorsiva ...

CJam (14 byte)

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

Demo online

Rubino (1.9 e versioni successive), 38 byte

?aè un modo più golfista di scrivere "a"ma sembra strano se mescolato a ternario?:

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)

Provalo online!

Ricorsione semplice.

C #, 59 byte

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

Solo un'altra soluzione C # ...

Perl, 33 byte

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

Nessun reale bisogno di non golf. Costruisce la stringa aggiungendo iterativamente il carattere successivo in sequenza più il retro della stringa finora, usando il valore ASCII di 'a' come punto di partenza. Utilizza $\per salvare alcuni tratti, ma è più difficile che mai.

Funziona per a(0)tutto a(25)e anche oltre. Sebbene dopo entri in ASCII esteso a(29), rimarrai senza memoria molto prima di esaurire i codici carattere:

a(25)è ~ 64 MiB. a(29)è ~ 1GiB.

Per memorizzare il risultato di a(255)(non testato!), Occorrerebbero 2 ^ 256 - 1 = 1,15x10 ^ 77 byte o circa 1,15x10 ^ 65 unità da 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);}}}

Mi piace nascondermi attorno a PPCG e mi piacerebbe poter votare / commentare altre risposte.

L'immissione viene fornita come parametri del programma. Questo segue lo stesso formato di molte altre risposte qui in quanto si tratta di un'implementazione ricorsiva diretta. Avrei commentato l'altra risposta ma non ho ancora il rappresentante per commentare. È anche leggermente diverso in quanto la chiamata ricorsiva viene eseguita due volte anziché costruire una stringa e passarla.

Mathematica, 36 32 byte

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

Hai mai visto TWOW 11B?

Python, 62 54 46 45 byte

Vorrei pensare che in qualche modo questo codice possa ancora essere risolto.

Modifica: correzione di errori grazie a Lynn. -1 byte grazie a calamari.

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

Provalo online!

Mathematica, 46 byte

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

Semplice funzione ricorsiva. Un'altra soluzione:

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

K5, 18 byte

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

Applicare ripetutamente una funzione a un valore trasportato ("A" ) e a ciascun elemento di una sequenza. La sequenza è costituita dai caratteri alfabetici da B fino ad alcuni numeri N ( `c$66+!). La funzione unisce l'argomento sinistro su entrambi i lati dell'argomento destro ( {x,y,x}).

In azione:

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

demo:

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

^{1 - grazie Neil per aver salvato 8 byte}

Japt, 20 17 byte

97oU+98 r@X+Yd +X

Provalo online!

Come funziona

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

Versione non competitiva, 14 byte

97ôU r@X+Yd +X

La ôfunzione è simile o, ma crea l'intervallo [X..X+Y]anziché [X..Y).Provalo online!

Preferisco di gran lunga cambiare 97 a 94, nel qual caso l'output per 5appare così:

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

Java, 219 byte

Il mio primo tentativo di golf a codice. Probabilmente si può andare oltre, ma ho fame e vado a pranzo.

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

Algoritmo ricorsivo di forza bruta piuttosto semplice, usa la charmanipolazione.

MATL , 14 byte

0i:"t@whh]97+c

Questo usa versione 8.0.0 del linguaggio / compilatore, che è precedente alla sfida.

Esempio

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

Spiegazione

Il secuence viene creato per primo con i numeri 0, 1, 2, ... Questi vengono convertiti in lettere 'a', 'b', 'c'alla fine.

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

modificare

Provalo online!

Powershell, 53 , 46 , 44 , 41 byte

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

Incollare nella console genererà un output errato alla seconda esecuzione poiché $dnon viene reinizializzato.

Salva 2 byte utilizzando + = Salva 3 byte grazie a @TimmyD

Gaia , 14 byte

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

Provalo online!

₵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

Provalo online!

Japt , 8 byte

;gCåÈ+iY

Provalo

;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

Buccia , 12 byte

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

Provalo online!

Utilizza l'indicizzazione basata su 1, che spero sia OK.

Spiegazione

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

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

APL (NARS), 24 caratteri, 48 byte

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

test:

  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 deve essere abilitato affinché questo funzioni.

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

Provalo online!

PHP , 51 byte

Una funzione anonima che stampa direttamente l'output.

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

Provalo online!