Ce défi consiste à imprimer la séquence abacaba d'une profondeur spécifique.

Voici un diagramme des 5 premières séquences ( a(N)la séquence abacaba de profondeur N, les majuscules / minuscules servent simplement à montrer le motif, cela n’est pas nécessaire dans la sortie de votre programme):

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

Comme vous pouvez probablement le constater, la nième séquence abacaba est la dernière avec la nième lettre et s'ajoute à elle. ( a(n) = a(n - 1) + letter(n) + a(n - 1))

Votre tâche consiste à créer un programme ou une fonction prenant un entier et imprimant la séquence abacaba de cette profondeur. La sortie doit être correcte au moins pour les valeurs inférieures ou égales à 15.

Pyth, 11 octets

u++GHG<GhQk

Réduction simple.

Python, 44 octets

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

On dirait avec méfiance qu'on pourrait jouer au golf.

Haskell, 39 37 octets

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

Exemple d'utilisation: a 3-> "abacabadabacaba".

Edit: @Angs a trouvé deux octets à sauvegarder. Merci!

Pyth, 14 à 13 octets

Merci à Jakube d'avoir sauvegardé un octet!

VhQ=+k+@GNk;k

Une solution à 14 Octets VhQ=ks[k@GNk;k.

Explication:

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

Essayez-le ici !

Retina , 37 32 octets

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

Le retour à la ligne est important. L'entrée est prise en unaire .

Essayez-le en ligne!

Brainfuck, 157 octets

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

L'entrée est donnée en binaire.

L'idée de base est de dupliquer à plusieurs reprises la séquence en cours (en commençant par "a") et d'incrémenter le dernier élément après chaque itération:

1. a → aa → ab

2. ab → abab → abac

3. abac → abacabac → abacabac

4. ...

Lorsque tout cela a été fait le nombre de fois spécifié, le résultat est imprimé en excluant le dernier élément.

Explication approfondie

La mémoire est organisée de la manière suivante:

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

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

Le compte à rebours contient le nombre de cycles de copie à exécuter. La séquence ABACABA est stockée dans des blocs adjacents, chacun composé de 3 cellules. La valeur contient le caractère de l'élément (c'est-à-dire "A", "B", "C" ...). L' indicateur Copier indique si l'élément correspondant doit ou non être copié dans le cycle de copie en cours (0 = copie, 1 = pas). L' indicateur de fin est mis à 0 pour le dernier élément en cours de copie (c'est 1 dans tous les autres cas).

Passons maintenant au programme actuel (légèrement non-golfé):

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

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

Essayez-le en ligne!

Ceci utilise une méthode récursive différente de la plupart des autres réponses. Pour obtenir la chaîne suivante de la séquence, nous ne joignons pas deux copies de la chaîne précédente avec une nouvelle lettre entre elles, mais au lieu de cela, nous incrémentons toutes les lettres et celles qui les séparent a.

aba -> bcb -> abacaba

05AB1E , 12 octets (non concurrentiel)

Code:

'aIGDN>.bsJl

Que je sois damné. J'ai corrigé beaucoup de bugs grâce à ce challenge haha.

Explication:

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

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

Un octet enregistré grâce à @Neil !

Encore une autre solution récursive simple ...

CJam (14 octets)

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

Démo en ligne

Ruby (1.9 et plus), 38 octets

?aest une manière plus golfeuse d’écrire "a"mais qui a l’air bizarre quand il est mélangé avec ternary?:

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

R , 48 octets

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

Essayez-le en ligne!

Récursion simple.

C #, 59 octets

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

Juste une autre solution C # ...

Perl, 33 octets

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

Pas vraiment besoin de dé-golfer. Construit la chaîne en ajoutant de manière itérative le caractère suivant dans la séquence, ainsi que l’inverse de la chaîne jusqu’à présent, en utilisant la valeur ASCII de «a» comme point de départ. Utilise $\pour sauver quelques coups, mais c'est à peu près aussi difficile que cela devient.

Fonctionne pour à a(0)travers a(25)et même au-delà. Bien que vous passiez à l'ASCII étendu après a(29), vous manquerez de mémoire bien avant de manquer de codes de caractères:

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

Pour stocker le résultat de a(255)(non testé!), Il faut 2 ^ 256 - 1 = 1,15 x 10 ^ 77 octets, soit environ 1,15 x 10 ^ 65 lecteurs de 1 téraoctet.

Java 7, 158 octets

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

J'aime me promener dans PPCG et j'aimerais pouvoir voter / commenter d'autres réponses.

L'entrée est donnée en tant que paramètres du programme. Cela suit le même format que beaucoup d'autres réponses ici, en ce sens qu'il s'agit d'une implémentation récursive simple. J'aurais commenté l'autre réponse mais je n'ai pas encore le représentant à commenter. Il est également légèrement différent en ce sens que l'appel récursif est effectué deux fois plutôt que de construire une chaîne et de la transmettre.

Mathematica, 36 32 octets

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

Avez-vous déjà regardé TWOW 11B?

Python, 62 54 46 45 octets

J'aimerais penser que ce code peut encore être utilisé d'une manière ou d'une autre.

Edit: correction de bug grâce à Lynn. -1 octet grâce au calmar.

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

Essayez-le en ligne!

Mathematica, 46 octets

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

Fonction récursive simple. Une autre solution:

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

K5, 18 octets

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

Appliquez de manière répétée une fonction à une valeur transportée ( "A") et à chaque élément d'une séquence. La séquence est constituée des caractères alphabétiques de B à un certain nombre N ( `c$66+!). La fonction joint l'argument de gauche de part et d'autre de l'argument de droite ( {x,y,x}).

En action:

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

JavaScript, 65 57 ¹ octets

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

Démo:

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

^{1 - merci Neil d'avoir économisé 8 octets}

Japt, 20 17 octets

97oU+98 r@X+Yd +X

Testez-le en ligne!

Comment ça marche

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

Version non concurrente, 14 octets

97ôU r@X+Yd +X

La ôfonction est comme o, mais crée la plage [X..X+Y]au lieu de [X..Y). Testez-le en ligne!

Je préfère de loin changer le 97 au 94, auquel cas la sortie 5ressemble à ceci:

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

Java, 219 octets

Ma première tentative de golf de code. Je peux probablement jouer au golf plus loin, mais j'ai faim et je sors déjeuner.

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

Algorithme récursif de force brute assez simple, utilise la charmanipulation.

MATL , 14 octets

0i:"t@whh]97+c

Ceci utilise la version 8.0.0 du langage / compilateur, qui est antérieure au défi.

Exemple

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

Explication

Le secuence est créé d' abord avec des nombres 0, 1, 2... Ceux - ci sont converties en lettres 'a', 'b', 'c'à la fin.

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

modifier

Essayez-le en ligne!

Powershell, 53 , 46 , 44 , 41 octets

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

Coller dans la console générera une sortie erronée lors de la deuxième exécution car $dn’est pas réinitialisé.

Économisez 2 octets en utilisant + = Économisez 3 octets grâce à @TimmyD

Gaia , 14 octets

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

Essayez-le en ligne!

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

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

Essayez-le en ligne!

Japt , 8 octets

;gCåÈ+iY

L'essayer

;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

Husk , 12 octets

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

Essayez-le en ligne!

Utilise l'indexation 1, ce qui, je l'espère, est OK.

Explication

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

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

APL (NARS), 24 caractères, 48 ​​octets

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

tester:

  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 octets

register_argc_argv doit être activé pour que cela fonctionne.

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

Essayez-le en ligne!

PHP , 51 octets

Une fonction anonyme qui imprime directement la sortie.

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

Essayez-le en ligne!