Determinare se una macchina di Turing si ferma è noto per essere indecidibile, ma ciò non è necessariamente vero per le macchine più semplici.

Una macchina Foo è una macchina con un nastro finito, in cui ogni cella sul nastro ha un numero intero o il simbolo di arresto h, ad es.

2 h 1 -1

Il puntatore dell'istruzione inizia puntando alla prima cella:

2 h 1 -1
^

Ad ogni passo, il puntatore dell'istruzione si sposta in avanti del numero a cui punta, quindi annulla quel numero. Quindi, dopo un passaggio, si sposterebbe in avanti le 2celle e trasformerebbe 2in un -2:

-2 h 1 -1
     ^

La macchina Foo continua a farlo finché il puntatore dell'istruzione non punta al simbolo di arresto ( h). Quindi, ecco la piena esecuzione di questo programma:

2 h 1 -1
^

-2 h 1 -1
     ^

-2 h -1 -1
         ^

-2 h -1 1
      ^

-2 h 1 1
   ^

Anche il nastro è circolare, quindi se il puntatore dell'istruzione si sposta da un lato del nastro, va dall'altro lato, ad esempio:

3 h 1 3
^
-3 h 1 3
       ^
-3 h 1 -3
     ^
-3 h -1 -3
         ^
-3 h -1 3
 ^
3 h -1 3
  ^

Una cosa interessante di queste macchine Foo è che alcune non si fermano, ad esempio:

1 2 h 2
^
-1 2 h 2
   ^
-1 -2 h 2
        ^
-1 -2 h -2
    ^
-1 2 h -2
        ^
-1 2 h 2
   ^

Questo programma continuerà in loop negli ultimi quattro stati per sempre.

Quindi, scrivi un programma che determina se una macchina Foo si ferma o no! Puoi usare qualsiasi formato di input (ragionevole) che ti piace per le macchine Foo e puoi scegliere di usare 0come simbolo di arresto. È possibile utilizzare due uscite distinte per il caso in cui si ferma e per il caso in cui non si ferma. Ovviamente il tuo programma deve fornire una risposta in un tempo limitato per tutti gli input validi.

Questo è code-golf , quindi cerca di rendere il tuo programma il più breve possibile!

Casi test

2 h 1 -1
Halts
3 h 1 3
Halts
h
Halts
1 1 1 1 h
Halts
2 1 3 2 1 2 h
Halts
3 2 1 1 4 h
Halts
1 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16 -17 -18 h -20 -21 -22 -23 -24 -25 -26 -27 -28 -29 -30 -31 -32 -33 -34 -35 -36
Halts

2 h
Does not halt
1 2 h 2
Does not halt
8 1 2 3 3 4 8 4 3 2 h
Does not halt
1 2 4 3 h 2 4 5 3
Does not halt
3 1 h 3 1 1
Does not halt
1 2 h 42
Does not halt

C # (compilatore interattivo Visual C #) , 71 byte

x=>{for(int i=0,k=0,f=x.Count;i++<1<<f;k%=f)k-=(x[k]*=-1)%f-f;i/=x[k];}

Provalo online!

Non so se quanto segue sia valido, poiché richiede un delegato personalizzato con una firma di unsafe delegate System.Action<int> D(int* a); e deve essere racchiuso in un unsafeblocco per essere utilizzato, ma qui è comunque:

C # (.NET Core) , 64 byte

x=>f=>{for(int i=0,k=0;i++<1<<f;k%=f)k-=(x[k]*=-1)%f-f;k/=x[k];}

Provalo online!

Questa funzione accetta un int * e restituisce un'azione; in altre parole, è una funzione al curry. L'unica ragione per cui utilizzo i puntatori è a causa di codegolf.meta.stackexchange.com/a/13262/84206, che mi consente di salvare i byte avendo già una variabile già definita con la lunghezza dell'array.

Salvataggio di 9 byte grazie a @someone

Python 3 , 63 89 byte

def f(x):
 for i in range(2**len(x)):a=x[0];x[0]=-a;b=a%len(x);x=x[b:]+x[:b]
 return a==0

Provalo online!

Funziona anche con Python 2; un byte può essere salvato in Python 2 sostituendo return con print e facendo stampare la funzione su stdout invece di return. R giraTrue per fermarsi e Falseper non fermarsi.

Grazie a @Neil e @Arnauld per aver notato che dovevo controllare più a lungo per fermarmi. Grazie a @Jitse per aver segnalato un problema con [2,0]. Grazie a @mypetlion per aver notato che i valori assoluti dei valori del nastro potrebbero superare la lunghezza del nastro.

Gelatina , 15 11 byte

N1¦ṙ⁸ḢƊÐLḢẸ

Provalo online!

Un collegamento monadico che accetta l'input come un elenco di numeri interi che usano 0 per indicare l'arresto. Restituisce 0 per arrestare gli input e 1 per quelli che non si arrestano.

Evita il problema della necessità di elaborare il numero di iterazioni a causa dell'uso di ÐLcui verrà eseguito il ciclo fino a quando non viene visualizzato alcun nuovo risultato.

Grazie a @JonathanAllan per aver salvato un byte!

Spiegazione

      ƊÐL   | Loop the following as a monad until the result has been seen before:
N1¦         | - Negate the first element
   ṙ⁸       | - Rotate left by each of the elements
     Ḣ      | - Take just the result of rotating by the first element
         Ḣ  | Finally take the first element
          Ẹ | And check if non-zero

Python 3 , 91 byte

def f(a):
	s={0,};i=0
	while{(*a,)}-s:s|={(*a,)};a[i]*=-1;i-=a[i];i%=len(a)
	return a[i]==0

Provalo online!

-40 byte grazie a JoKing e Jitse

Perl 6 , 46 43 36 byte

{$_.=rotate(.[0]*=-1)xx 2**$_;!.[0]}

Provalo online!

Rappresenta l'arresto da 0e restituisce vero se la macchina si ferma. Questo ripete i 2**(length n)tempi logici , dove se il puntatore finisce sulla cella di arresto, rimane lì, altrimenti si troverà su una cella non ferma. Questo funziona perché ci sono solo 2**nstati possibili (ignorando le celle di arresto) in cui si trova la macchina Foo, poiché ogni cella non di arresto ha solo due stati. Va bene sì, ci sono stati di questo, ma a causa delle limitate possibili transizioni tra puntatori (e quindi stati) ci saranno meno di 2 ** $ _ stati ... Penso

Spiegazione

{                                  }  # Anonymous codeblock
                     xx 2**$_         # Repeat 2**len(n) times
            .[0]*=-1                  # Negate the first element
 $_.=rotate(        )                 # Rotate the list by that value
                             ;!.[0]   # Return if the first element is 0

05AB1E , 14 13 byte

goFć©(š®._}®_

Provalo online!

Prende l'input come un elenco di numeri interi con 0 come istruzione di arresto. Restituisce 1 per l'arresto e 0 per non arresto.

Grazie a @KevinCruijssen per aver salvato 2 byte!

Java 8, 78 79 73 byte

a->{int k=0,l=a.length,i=0;for(;i++<1<<l;k%=l)k-=(a[k]*=-1)%l-l;k/=a[k];}

Porta diretta della risposta C # .NET di @EmbodimentOfIgnorance , quindi assicurati di votarlo!
Grazie a @Arnauld per aver trovato due bug (che si applica anche ad altre risposte).

Si verifica un java.lang.ArithmeticException: / by zeroerrore quando è in grado di arrestarsi o nessun errore in caso contrario.

Provalo online.

Spiegazione:

a->{                   // Method with integer-array as parameter and no return-type
  int k=0,             //  Index integer, starting at 0
      l=a.length,      //  The length `l` of the input-array
  i=0;for(;i++<1<<l;   //  Loop 2^length amount of times:
          k%=l)        //    After every iteration: take mod `l` of `k`
    k-=                //   Decrease `k` by:
       (a[k]*=-1)      //    Negate the value at index `k` first
                 %l    //    Then take modulo `l` of this
                   -l; //    And then subtract `l` from it
                       //  (NOTE: the modulo `l` and minus `l` are used for wrapping
                       //  and/or converting negative indices to positive ones
  k/=a[k];}            //  After the loop: divide `k` by the `k`'th value,
                       //  which will result in an division by 0 error if are halting

Haskell , 79 byte

s x|m<-length x,let g(n:p)=(drop<>take)(mod n m)(-n:p)=iterate g x!!(2^m)!!0==0

Provalo online!

Restituisce Trueper fermare le macchine, e Falsealtrimenti. Input sotto forma di un elenco, con 0rappresentazione di uno stato di arresto.

Presuppone una versione di GHC successiva alla 8.4 (rilasciata a febbraio 2018).

JavaScript (Node.js) , 71 67 byte

x=>{for(p=l=x.length,i=2**l;i--;)p+=l-(x[p%l]*=-1)%l;return!x[p%l]}

Praticamente lo stesso della risposta C # .NET di @EmbodimentOfIgnorance

Risparmio di 4 byte grazie a @Arnaud

Provalo online!

JavaScript (Node.js) , 61 byte

x=>{for(p=l=x.length,i=2**l;i--;p+=l-(x[p%l]*=-1)%l)x[p%l].f}

Questa versione utilizza undefinedcome simbolo di arresto e genera un TypeError: Cannot read property 'f' of undefinedquando la macchina si ferma e termina silenziosamente quando la macchina non si ferma.

Provalo online!

Scala , 156 byte

IMO ancora giocabile a golf, ma per ora sto bene. Restituisce 0per Foos senza sosta e 1per fermata Foo. Accetta l'ingresso acome un Array[Int], quindi hviene considerato come 0.

var u=Seq[Array[Int]]()//Keep track of all states
var i=0//Index
while(u.forall(_.deep!=a.deep)){if(a(i)==0)return 1//Check if we are in a previously encountered step ; Halt
u:+=a.clone//Add current state in the tracker
var k=i//Stock temp index
i=(a(i)+i)%a.length//Move index to next step
if(i<0)i+=a.length//Modulus operator in Scala can return a negative value...
a(k)*=(-1)}//Change sign of last seen index
0//Returns 0 if we met a previous step

È piuttosto lungo da eseguire (circa 4 secondi per tutti i casi di test) a causa delle molteplici ricerche full-array che ho fatto, oltre a quelle .deepche creano copie ... Ma puoi ancora provarlo online.

Perl 5 -ap , 88 byte

for(;$F[$i]&&!$k{"$i|$F[$i]"};$i=($i+$F[$i])%@F){$k{"$i|$F[$i]"}=1;$F[$i]*=-1}$_=!$F[$i]

Provalo online!

Attache , 40 byte

Not@&N@Periodic[{On[0,`-,_]&Rotate!_@0}]

Provalo online!

Spiegazione

{On[0,`-,_]&Rotate!_@0}

Ciò esegue una singola iterazione della macchina Foo; nega il primo membro, quindi ruota l'array dal primo elemento (originale, non negato) dell'array.

Periodicapplicherà questa funzione fino ad accumulare un risultato duplicato. Una macchina si ferma o entra in un banale ciclo infinito. Se si ferma, il primo elemento sarà 0. Altrimenti, sarà diverso da zero.

&Nè un modo da golf per ottenere il primo elemento di un array numerico. Quindi, Notrestituisce true0 (macchine fermatrici) e falsequalsiasi altra cosa (macchine non fermatrici).

Carbone , 28 byte

≔⁰ηＦＸ²Ｌ諧≔θ籧θη≧⁻§θη绬§θη

Provalo online! Il collegamento è alla versione dettagliata del codice. Output usando l'output booleano predefinito di Charcoal, che è -vero e nulla è falso. Spiegazione:

≔⁰η

Inizializza il puntatore dell'istruzione.

ＦＸ²Ｌθ«

Ripeti ciclicamente quante volte ci sono stati teoricamente possibili.

§≔θ籧θη

Negare il valore nel puntatore dell'istruzione.

≧⁻§θηη

Sottrai il nuovo valore dal puntatore dell'istruzione. Gli accessi all'array di carbone sono ciclici, quindi questo emula automaticamente il nastro circolare di Foo.

»¬§θη

Alla fine del ciclo, emettere se il programma si è fermato.

Stax , 11 byte

Ç₧┬òE▐tµ|⌡1

Esegui ed esegui il debug

Prende l'input sotto forma di un array intero, con 0rappresentazione di arresto.

Produce 1per una fermata e 0per una macchina senza sosta.

Pyth , 12 byte

!hu.<+_hGtGh

Suite di test!

Utilizza l'approccio diretto. Riprova finché non vediamo l'elenco due volte in uno stato identico. Per i programmi che si arrestano, l'elenco alla fine avrà un vantaggio 0perché è lì che si interrompe la ricorsione. Per i programmi che non si fermano, l'elenco non inizierà con 0, ma piuttosto si troverà in uno stato dal quale il processo sarebbe periodico e quindi la macchina Foo non si fermerebbe.