Este desafío se trata de imprimir la secuencia de abacaba de una profundidad específica.

Aquí hay un diagrama de las primeras 5 secuencias ( a(N)es la secuencia abacaba de profundidad N, mayúsculas / minúsculas es solo para mostrar el patrón, esto no es necesario en la salida de su programa):

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

Como probablemente pueda ver, la secuencia de la enésima abacaba es la última con la enésima letra y se le agrega nuevamente. ( a(n) = a(n - 1) + letter(n) + a(n - 1))

Su tarea es hacer un programa o función que tome un número entero e imprima la secuencia de abacaba de esa profundidad. La salida debe ser correcta al menos para valores de hasta 15 inclusive.

Pyth, 11 bytes

u++GHG<GhQk

Reducción simple

Python, 44 bytes

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

Parece sospechosamente podría ser golfable.

Haskell, 39 37 bytes

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

Ejemplo de uso: a 3-> "abacabadabacaba".

Editar: @Angs encontró dos bytes para guardar. ¡Gracias!

Pyth, 14 13 bytes

¡Gracias a Jakube por guardar un byte!

VhQ=+k+@GNk;k

Una solución con 14 bytes: VhQ=ks[k@GNk;k.

Explicación:

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

Pruébalo aquí !

Retina , 37 32 bytes

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

El avance de línea final es significativo. La entrada se toma en unario .

Pruébalo en línea!

Brainfuck, 157 bytes

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

La entrada se da en binario.

La idea básica es duplicar repetidamente la secuencia actual (comenzando con "a") e incrementar el último elemento después de cada iteración:

1. a → aa → ab

2. ab → abab → abac

3. abac → abacabac → abacabac

4. ...

Cuando todo esto se ha realizado la cantidad de veces especificada, el resultado se imprime excluyendo el último elemento.

Explicación en profundidad

La memoria se organiza de la siguiente manera:

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

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

La cuenta regresiva contiene el número de ciclos de copia que aún deben ejecutarse. La secuencia ABACABA se almacena en bloques adyacentes, cada uno formado por 3 celdas. El valor contiene el carácter del elemento (es decir, "A", "B", "C" ...). El indicador Copiar indica si el elemento correspondiente debe copiarse dentro del ciclo de copia actual (0 = copiar, 1 = no). El indicador Fin se establece en 0 para el último elemento mientras se está copiando (es 1 en todos los demás casos).

Ahora al programa real (un poco descuidado):

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

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

Pruébalo en línea!

Esto utiliza un método recursivo diferente de la mayoría de las otras respuestas. Para obtener la siguiente cadena en la secuencia, no unimos dos copias en la cadena anterior con una nueva letra en el medio, sino que incrementamos cada letra y las letras intercaladas a.

aba -> bcb -> abacaba

05AB1E , 12 bytes (no competitivo)

Código:

'aIGDN>.bsJl

Voy a ser condenado. Solucioné muchos errores gracias a este desafío jaja.

Explicación:

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

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

Un byte guardado gracias a @Neil !

Sin embargo, otra solución recursiva simple ...

CJam (14 bytes)

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

Demostración en línea

Ruby (1.9 y superior), 38 bytes

?aes una forma más elegante de escribir, "a"pero se ve raro cuando se mezcla con ternary?:

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

R , 48 bytes

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

Pruébalo en línea!

Recurrencia simple

C #, 59 bytes

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

Solo otra solución de C # ...

Perl, 33 bytes

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

No hay necesidad real de no jugar al golf. Construye la cadena agregando iterativamente el siguiente carácter en secuencia más el reverso de la cadena hasta el momento, utilizando el valor ASCII de 'a' como punto de partida. Utiliza $\para guardar algunos golpes, pero eso es lo más complicado posible.

Trabaja para a a(0)través a(25)e incluso más allá. Aunque luego ingrese a ASCII extendido a(29), se quedará sin memoria mucho antes de quedarse sin códigos de caracteres:

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

Para almacenar el resultado de a(255)(¡no probado!), Se necesitarían 2 ^ 256 - 1 = 1.15x10 ^ 77 bytes, o aproximadamente 1.15x10 ^ 65 unidades de 1 terabyte.

Java 7, 158 bytes

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

Me gusta acechar a PPCG y me gustaría poder votar / comentar otras respuestas.

La entrada se proporciona como parámetros del programa. Esto sigue el mismo formato que muchas otras respuestas aquí en que es una implementación recursiva directa. Hubiera comentado la otra respuesta, pero todavía no tengo el representante para comentar. También es ligeramente diferente en que la llamada recursiva se realiza dos veces en lugar de construir una cadena y pasarla.

Mathematica, 36 32 bytes

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

¿Alguna vez has visto TWOW 11B?

Python, 62 54 46 45 bytes

Me gustaría pensar que este código todavía se puede reducir de alguna manera.

Editar: corrección de errores gracias a Lynn. -1 byte gracias a los calamares.

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

Pruébalo en línea!

Mathematica, 46 bytes

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

Función recursiva simple. Otra solución:

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

K5, 18 bytes

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

Aplica repetidamente una función a un valor transportado ( "A") y a cada elemento de una secuencia. La secuencia son los caracteres alfabéticos desde B hasta algún número N ( `c$66+!). La función une el argumento izquierdo a cada lado del argumento derecho ( {x,y,x}).

En acción:

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

JavaScript, 65 57 ¹ bytes

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

Manifestación:

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

^{1 - gracias Neil por guardar 8 bytes}

Japt, 20 17 bytes

97oU+98 r@X+Yd +X

¡Pruébelo en línea!

Cómo funciona

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

Versión no competitiva, 14 bytes

97ôU r@X+Yd +X

La ôfunción es como o, pero crea el rango en [X..X+Y]lugar de [X..Y).¡Pruébelo en línea!

Prefiero cambiar el 97 a 94, en cuyo caso la salida para se 5ve así:

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

Java, 219 bytes

Mi primer intento de golf de código. Probablemente se pueda jugar más al golf, pero tengo hambre y salgo a almorzar.

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

Sin golf:

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 recursivo de fuerza bruta bastante sencillo, utiliza charmanipulación.

MATL , 14 bytes

0i:"t@whh]97+c

Utiliza la versión 8.0.0 del lenguaje / compilador, que es anterior al desafío.

Ejemplo

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

Explicación

El secuence se crea por primera vez con los números 0, 1, 2, ... Estos se convierten en letras 'a', 'b', 'c'al final.

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

Editar

Pruébalo en línea!

Powershell, 53 , 46 , 44 , 41 Bytes

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

Pegar en la consola generará resultados erróneos en la segunda ejecución ya $dque no se reinicia.

Ahorre 2 bytes usando + = Ahorre 3 bytes gracias a @TimmyD

Gaia , 14 bytes

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

Pruébalo en línea!

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

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

Pruébalo en línea!

Japt , 8 bytes

;gCåÈ+iY

Intentalo

;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

Casco , 12 bytes

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

Pruébalo en línea!

Utiliza indexación basada en 1, que espero que esté bien.

Explicación

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

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

APL (NARS), 24 caracteres, 48 ​​bytes

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

prueba:

  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 bytes

register_argc_argv debe estar habilitado para que esto funcione.

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

Pruébalo en línea!

PHP , 51 bytes

Una función anónima que imprime la salida directamente.

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

Pruébalo en línea!