Il programma Java errato cerca di passare un oggetto di una classe Seconda a un metodo che stampa la componente x di un oggetto Primo. È un errore nonostante la classe Secondo abbia la componente x intera che serve al metodo.

class Prima {
	int x;
}
class Seconda {
	int x;
}
class Main {
	static void esempio(Prima p) {
		System.out.println(p.x);
	}
	public static void int main(String[] args) {
		Seconda s;
		esempio(s);
	}
}

In Python questo errore non si verifica perché il controllo del tipo degli oggetti è basato sulla presenza della componente p.x, che esiste anche negli oggetti della classe Seconda.

La conversione in complemento a due si ottiene convertendo il valore assoluto 23 e complementando il risultato.

23 | 1
11 | 1
5  | 1
2  | 0
1  | 1  ⇒  010111

010111  ⇒  101000 +
                1
           ------
           101001

Per diminuirlo di uno, si somma -1. Il suo valore assoluto 1 in binario è 000001, il cui complemento è 111110+1=1111111.

 11111
 101001 +
 111111
 ------
 101000

Questo è il numero -23 diminuito di uno. La sua conversione in decimale produce:

  1   0   1   0   0   0
  ×   ×   ×   ×   ×   ×
-32  16   8   4   2   1
-----------------------
-32   +   8             = -24

Il problema si può risolvere con un metodo che verifica se una sequenza di n nodi è un percorso in cui l'ultimo elemento è collegato al primo, richiamandolo su tutte le permutazioni di n nodi.

Il primo metodo verifica se una sequenza di nodi è un ciclo, ossia un percorso in cui l'ultimo nodo è collegato al primo. Un singolo nodo non collegato al seguente dimostra che la sequenza non è un ciclo.

# verifica di ciclo
def ciclo(grafo, ciclo):
	for i in range(len(ciclo) - 1):
		if not grafo.arco(ciclo[i], ciclo[i + 1]):
			return False
	if not grafo.arco(ciclo[len(ciclo) - 1], ciclo[0]):
		return False
	return True

Il secondo metodo richiama il primo su tutte le permutazioni di n nodi.

# presenza di un ciclo grande n
def ciclon(grafo, n):
	for c in itertools.permutations(grafo.insiemenodi(), n):
		if ciclo(grafo, c):
			return True;
	return False;

L'automa deve memorizzare la cifra che compare come primo carattere e poi verificare che effettivamente segua quel numero di lettere a. L'unico modo che hanno gli automi di memorizzare è andare in un stati diversi. In questo caso, l'automa va in uno stato diverso a seconda se il primo carattere è 1, 2 o 3.

Se la cifra che compare come primo carattere è 1, l'automa va in uno stato in cui accetta solo una sequenza di una singola lettera a. Con il carattere 2 va in un altro stato in cui accetta due a e con 3 in un ulteriore stato da cui accetta solo tre a.

Per permettere numeri qualsiasi servirebbe uno stato per ogni numero. I numeri sono infiniti mentre gli automi a stati finiti hanno per definizione un numero finito di stati. Quindi un automa a stati finiti non può riconoscere tutte le stringhe del tipo richiesto.

La sequenza di stati della macchina è la seguente:

1. inizia nello stato 0; sul nastro si trova …␣aba␣…; la testina è posizionata sulla prima a;
2. il carattere sotto la testina è il primo della stringa, quindi a; segue l'arco a/Db: scrive b sul nastro e sposta la testina a destra;
3. il carattere sotto la testina è il secondo della stringa, quindi b; segue l'arco b/Da: scrive a sul nastro e sposta la testina a destra;
4. il carattere sotto la testina è l'ultimo, a; segue l'arco a/Db: scrive b sul nastro e sposta la testina a destra;
5. il carattere sotto la testina è il primo blank ␣ che segue la stringa; essendo un blank, l'automa va nello stato accettante A
   .