Définition

De la description sur OEIS A006345 :

Pour trouver a(n), considérez un 1ou un 2. Pour chacun, recherchez le suffixe répété le plus long, c'est-à-dire pour chacun a(n)=1,2, trouvez la séquence la plus longue savec la propriété avec laquelle la séquence a(1),...,a(n)se termine ss. Utilisez le chiffre qui donne le suffixe le plus court. a(1) = 1.

Exemple élaboré

a(1)=1.

Si a(2)=1, nous aurons la séquence 1 1où se trouve la sous-chaîne doublée la plus longue de la fin 1. Si à la a(2)=2place, ce serait la sous-chaîne vide. Par conséquent a(2)=2.

Quand n=6, on choisit entre 1 2 1 1 2 1et 1 2 1 1 2 2. Dans le premier choix, 1 2 1est doublé consécutivement depuis la fin. Dans le deuxième choix, c'est 2plutôt. Par conséquent, a(6)=2.

Quand n=9, on choisit entre 1 2 1 1 2 2 1 2 1 et 1 2 1 1 2 2 1 2 2. Dans le premier choix, la sous-chaîne consécutive doublée la plus longue est 2 1, tandis que dans le second choix 1 2 2est doublée consécutivement à la fin. Par conséquent a(9)=1.

Tâche

Étant donné n, revenez a(n).

Spécifications

• n sera positif.
• Vous pouvez utiliser l'index 0 au lieu de l'index 1. Dans ce cas, veuillez l'indiquer dans votre réponse. Aussi, dans ce cas, npeut l'être 0également.

Cas de test

Les cas de test sont indexés 1. Cependant, vous pouvez utiliser l'index 0.

n  a(n)
1  1
2  2
3  1
4  1
5  2
6  2
7  1
8  2
9  1
10 1
11 2
12 1
13 2
14 2
15 1
16 1
17 2
18 1
19 1
20 1

Les références

• WolframMathWorld
• Obligatoire OEIS A006345

Haskell, 146 140 137 133 118 118 octets

s!l|take l s==take l(drop l s)=l|1<2=s!(l-1)
g[w,x]|w<x=1|1<2=2
a 1=1
a n=g$(\s x->(x:s)!n)(a<$>[n-1,n-2..1])<$>[1,2]

Python, 137 octets

def a(n,s=[0],r=lambda l:max([0]+filter(lambda i:l[-i:]==l[-i*2:-i],range(len(l))))):
 for _ in[0]*n:s+=[r(s+[0])>r(s+[1])]
 return-~s[n]

Cette solution utilise une indexation basée sur 0.

Gelée , 25 24 22 20 octets

2 octets grâce à Dennis.

2;€µḣJf;`€$ṪLµÞḢ
Ç¡Ḣ

Essayez-le en ligne!

Un portage de ma réponse en Pyth .

Ç¡Ḣ   Main chain

 ¡    Repeat for (input) times:
Ç         the helper chain
  Ḣ   Then take the first element



2;€µḣJf;`€$ṪLµÞḢ  Helper chain, argument: z

2;€               append z to 1 and 2, creating two possibilities
   µ         µÞ   sort the possibilities by the following:
    ḣJ                generate all prefixes from shortest to longest
       ;`€            append the prefixes to themselves
      f   $           intersect with the original set of prefixes
           Ṫ          take the last prefix in the intersection
            L         find its length
                 Ḣ   take the first (minimum)

Mathematica, 84 octets

a@n_:=a@n=First@MinimalBy[{1,2},Array[a,n-1]~Append~#/.{___,b___,b___}:>Length@{b}&]

Gelée , 30 29 28 27 24 octets

;€¬;\€Z;/f;`€$ṪḢ;
1Ç¡o2Ḣ

Essayez-le en ligne! ou vérifiez tous les cas de test .

MATL , 34 octets

vXKi:"2:"K@h'(.+)\1$'XXgn]>QhXK]0)

Essayez-le en ligne! ou vérifiez tous les cas de test .

Explication

v             % Concatenate stack vertically: produces empty array
XK            % Copy to clipboard K. This clipboard holds the current sequence
i:            % Take input n. Generate vector [1 2 ... n]
"             % For each k in [1 2 ... n]
  2:          %   Push [1 2]. These are the possible digits for extending the sequence
  "           %     For each j in [1 2]
    K         %       Push contents of clipboard K (current sequence)
    @         %       Push j (1 or 2)
    h         %       Concatenate horizontally: gives a possible extension of sequence
    '(.+)\1$' %       String to be used as regex pattern: maximal-length repeated suffix
    XX        %       Regex match
    gn        %       Convert to vector and push its length: gives length of match
  ]           %    End. We now have the suffix lengths of the two possible extensions
  >           %    Push 1 if extension with "1" has longer suffix than with "2"; else 0 
  Q           %    Add 1: gives 2 if extension with "1" produced a longer suffix, or 1
              %    otherwise. This is the digit to be appended to the sequence
  h           %    Concatenate horizontally
  XK          %    Update clipboard with extended sequence, for the next iteration
]             % End
0)            % Get last entry (1-based modular indexing). Implicitly display

Python 2, 94 octets

import re
s='1'
exec"s+=`3-int(re.search(r'(.*)(.)\\1$',s).groups()[1])`;"*input()
print s[-1]

Utilise l'indexation basée sur 0. Testez-le sur Ideone .

Pyth , 26 octets

huh.mleq#.<T/lT2._b+RGS2QY

Suite de tests.

Explication

Quand n = 6, on choisit entre 1 2 1 1 2 1et 1 2 1 1 2 2.

Nous générons ces deux possibilités, puis examinons leurs suffixes.

Pour la première, les suffixes sont: 1, 2 1, 1 2 1, 1 1 2 1, 2 1 1 2 1, 1 2 1 1 2 1.

On filtre les suffixes doublés en vérifiant s'ils sont les mêmes après les avoir tournés pour leur longueur divisée par 2 (il s'avère que cette vérification n'est pas parfaite, car elle confirme 1et 2aussi).

Nous prenons le dernier suffixe doublé, puis prenons sa longueur.

Nous choisissons ensuite la possibilité qui correspond à une longueur minimale générée ci-dessus.

Ensuite, nous passons à la valeur suivante de n.

Aux fins de ce programme, il était préférable que golfier génère le tableau inversé.

huh.mleq#.<T/lT2._b+RGS2QY
 u                      QY   repeat Q (input) times,
                             start with Y (empty array),
                             storing the temporary result in G:
                   +RGS2         prepend 1 and 2 to G,
                                 creating two possibilities
   .m             b              find the one that
                                 makes the following minimal:
                ._                   generate all prefixes
       q#                            filter for prefixes as T
                                     that equals:
         .<T/lT2                         T left-rotated
                                         by its length halved
      e                              take the last one
     l                               generate its length
  h                              take the first minimal one
h                                take the first one from the generated
                                 array and implicitly print it out

Pyth, 46 29 octets

Inspiré de l'excellente réponse Pyth de @Leaky Nun. J'ai essayé de voir s'il y avait un moyen plus court d'utiliser des chaînes. Encore 3 octets courts!

huh.melM+kf!x>blTT._bm+dGS2Qk

Vous pouvez l'essayer ici .

Rétine , 51 42 octets

9 octets grâce à Martin Ender.

.+
$*x
+`((.*)(^|2|(?<3>1))\2)x
$1$#3
!`.$

Essayez-le en ligne!

Un port de cette réponse .

Perl, 40 octets

$a.=/(.*)(.)\1$/^$2for($a)x$_;$_=$a%5+1

Le code fait 39 octets et nécessite le -pcommutateur ( +1 octet).

La boucle est inspirée de la solution Perl sur le page OEIS , bien que j'aie trouvé indépendamment l'expression régulière.

Testez-le sur Ideone .

JavaScript (ES6), 84

Base d'index 0

n=>eval("s='1';for(r=d=>(s+d).match(/(.*)\\1$/)[0].length;n--;s+=c)c=r(1)>r(2)?2:1")

Moins golfé

n=>{
  r = d => (s+d).match(/(.*)\1$/)[0].length;
  c = '1';
  for(s = c; n--; s += c)
    c = r(1) > r(2) ? 2 : 1;
  return c;
}

Tester

F=
n=>eval("s='1';for(r=d=>(s+d).match(/(.*)\\1$/)[0].length;n--;s+=c)c=r(1)>r(2)?2:1")

for(n=0;n<20;n++)console.log(n,F(n))