Intro

La sequenza di commutazione è definita in questo modo:

Inizia con le npersone in piedi in un cerchio ( 6per questo esempio).

 1  2
6    3
 5  4

A partire dalla persona 1, la persona che si trova alla sinistra della persona "scelta" viene rimossa.

 1
6    3
 5  4

La persona rimossa può "cambiare" il metodo di rimozione:

• Se la persona rimossa è pari (come in questo caso), la persona rimossa successiva sarà alla destra della persona "scelta" successiva.
• Se la persona rimossa è dispari, la persona rimossa successiva sarà alla sinistra della persona "scelta" successiva.

La persona scelta successiva dipende anche dalla persona precedentemente rimossa.

• Se la persona rimossa è pari, la persona scelta successiva sarà alla destra della persona scelta in precedenza.
• Se la persona rimossa è dispari, vedi sopra, ma sostituisci "destra" con "sinistra".

Quindi la prossima persona scelta è allora 6.

Ora rimuoviamo la persona a destra di 6, che è 5:

 1
6    3
    4

Perché 5è strano, la persona rimossa è ora a sinistra. La nuova persona scelta è 1.

Ora rimuoviamo 3:

 1
6
    4

Continuiamo questo processo, fino a quando non ci resta 1 numero - in questo esempio, il numero finale è 1. Quindi quindi S(6) = 1.

I primi numeri sono:

 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

Compito

Il tuo compito è creare un programma (o una funzione) che ritorni S(n)(il nnumero th nella sequenza Switching) quando viene dato n, usando il minor numero di byte.

Ingressi e uscite di esempio:

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

Hai la garanzia di ottenere un numero intero positivo.

Questo è code-golf , quindi vince il codice più breve in byte!

Nota: non esiste una sequenza OEIS (cosa?), Per risparmiare il disturbo della ricerca.

Python 2, 183 94 byte

-4 byte grazie ad Artyer (usa input()e printpiuttosto che defe return)
-1 byte grazie a FlipTack (usa print-~p[0]piuttosto che 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

Questo segue solo le istruzioni fornite, ho notato qualche schema, forse potrebbe essere sfruttato?

Le uniche modifiche sono:

• utilizzare l' 0indicizzazione basata (quindi anche le persone sono dispari e viceversa) - questo consente di risparmiare 5 byte nella logica del golf e viene corretto alla fine con+1
• da usare 1come a sinistra e -1a destra (per usare un intervallo - proprio come tutti invece sono rivolti verso l'esterno)
• per cambiare la logica del passaggio in cui si trova il prossimo individuo scelto per tenere conto popdell'ing dall'elenco rendendo l'indice "puntatore" già un passo a destra nell'elenco (o a sinistra nella terminologia originale).

Ungolfed:

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