Intro

La séquence de commutation est définie comme suit:

Commencez avec des npersonnes debout en cercle ( 6pour cet exemple).

 1  2
6    3
 5  4

En partant de personne 1, la personne qui se trouve à gauche de la personne "choisie" est supprimée.

 1
6    3
 5  4

La personne retirée peut "changer" la méthode de suppression:

• Si la personne retirée est paire (ce qui est le cas dans ce cas), la prochaine personne retirée sera à la droite de la prochaine personne "choisie".
• Si la personne retirée est étrange, la prochaine personne retirée sera à gauche de la prochaine personne "choisie".

La prochaine personne choisie dépend également de la personne précédemment supprimée.

• Si la personne retirée est paire, la prochaine personne choisie sera à la droite de la précédente personne choisie.
• Si la personne retirée est étrange, voir ci-dessus, mais remplacez "droite" par "gauche".

Ainsi, la prochaine personne choisie est alors 6.

Maintenant , nous enlevons la personne à droite de 6, qui est 5:

 1
6    3
    4

Parce que 5c'est étrange, la personne retirée est maintenant à gauche. La nouvelle personne choisie est 1.

Nous supprimons maintenant 3:

 1
6
    4

Nous continuons ce processus jusqu'à ce qu'il nous reste 1 chiffre - dans cet exemple, le nombre final est 1. Donc donc S(6) = 1.

Les premiers chiffres sont:

 n | S(n)
---------
 1 | 1
 2 | 1
 3 | 3
 4 | 1
 5 | 5
 6 | 1
 7 | 3
 8 | 6
 9 | 5
10 | 6
11 | 9

Tâche

Votre tâche consiste à créer un programme (ou une fonction) qui renvoie S(n)(le nnuméro e dans la séquence de commutation) lorsqu'il est donné n, en utilisant le moins d'octets.

Exemples d'entrées et sorties:

1  -> 1
10 -> 6
13 -> 13

Vous êtes assuré d'obtenir un entier positif.

C'est le code-golf , donc le code le plus court en octets gagne!

Remarque: Il n'y a pas de séquence OEIS (quoi?), Pour vous éviter d'avoir à chercher.

Python 2, 183 94 octets

-4 octets grâce à Artyer (utiliser input()et printplutôt que defet return)
-1 octet grâce à FlipTack (utiliser print-~p[0]plutôt que print p[0]+1)

p=range(input())
d=i=1
while p[1:]:m=p.pop(i)%2;i-=m+m-(d<0);d=-m|1;i+=d;i%=len(p)
print-~p[0]

repl.it

Cela suit simplement les instructions données, j'ai remarqué un modèle, peut-être qu'il pourrait être exploité?

Les seuls changements sont:

• d'utiliser l' 0indexation basée (donc même les gens sont bizarres et vice-versa) - cela économise 5 octets dans la logique du golf et est corrigé à la fin avec+1
• à utiliser 1à gauche et -1à droite (pour utiliser une plage - tout comme tout le monde est tourné vers l'extérieur à la place)
• pour changer la logique de l'étape où l'on trouve que la personne choisie suivante tient compte popde la liste, ce qui fait que l'index "pointeur" est déjà une étape vers la droite dans la liste (ou vers la gauche dans la terminologie originale).

Non golfé:

def circle(n):
    people = range(n) # p
    direction = 1 # d
    removeIndex = 1 # i
    while n > 1:
        removingMod2 = people.pop(removeIndex) % 2 # m
        removeIndex -= removingMod2 + removingMod2 - (direction == -1)
        direction = -removingMod2 or 1
        removeIndex += direction
        n -= 1
        removeIndex %= n
    return people[0] + 1