funcion TodasLasRutasDeUnGrafo(string alfabeto) // sin repetir nodo.
    array bytes pila()  // realmente no es una pila, pero acomoda llamarlo así.
    array string prod= GetProducciones  //las producciones BNF, como un array de strings.

    // Albabeto = ABCDFHL  la primera letra debe ser el estado inicial
    Bucle k desde 2letra de alfabeto hasta última-1 //y la última debe ser el estado final.
        x = alfabeto(k)  //letra enésima del alfabeto
        c= caracter kesimo en alfabeto
        Hacer  
            pila = LlenarPila(alfabeto)   //vuelve visitable todos sus nodos.
            //pila(ASCII(c)) = FALSE // excepto la letra inicial de la que partimos esta vez, 
            // pero esto mejor se traslada a la función invocada.            
            token = SiguienteToken(prod, pila, c)
            Si token <> ""
                imprimir "A --> " + token
            sino
                salir del bucle interno    
            fin si
        Repetir //mientras token distinto de nulo 
    Siguiente

// el array es fijo según el grafo, y tal como se indico en las producciones.
// al caso se 'montan' en un array de strings, 
array de String = Funcion GetProducciones  
    array de string p(0 a 255)

    //Cada valor está en la casilla cuyo ASCII representa y su contenido son la representación de cada nodo al que se accede desde él, 
    // cada letra representa un nodo, al caso se han ordenado alfabéticamente, pero puede seguirse el orden en que aparecen sobre el grafo girando en uno u otro sentido, no importa...
    p(ASCII(A)) = CF
    p(ASCII(B)) = CD
    p(ASCII(C)) = ABLF
    p(ASCII(D)) = BH
    p(ASCII(F)) = AH
    p(ASCII(H)) = DF
    //p(ASCII(L))  
    
    devolver p
fin funcion

array de bytes = funcion LlenarPila(string alfabeto)
    array de bytes x(0 a 255)
    byte k

    Por cada letra en Alfabeto
        x(ASCII(letra)) = TRUE   //por ejemplo si letra es A: x(65) = TRUE, porque A es el carácter ASCII 65
    siguiente
    devolver X
fin funcion

enumeracion Estados
    ESTADO_ERROR = 0
    ESTADO_INICIAL = 1
    ESTADO_TRANSICION = 2
    ESTADO_FINAL = 3
fin enumeracion 

// de entrada sabemos que el estado inicial es 1, y el primer carácter-nodo es A, que puede obviarse.
string = funcion SiguienteToken(array string P(),  array bytes Pila(), char letra)
   Estados  e= ESTADO_INICIAL
   string t = letra // la letra inicial, para esta vez.
   
   letra = siguiente letra en p(ASCII(letra)) // esto exige recursión ya que una producción engloba a otra.
   // Si pila(ASCII(letra)) = TRUE si el nodo de dicha letra es visitable
   //     t += letra
   //     Si letra = "L"
   //         e = ESTADO_FINAL
   //         devolver t
   //     sino
   //         e = ESTADO_TRANSICION
   //         marcar letra no visitable  pila(ASCII(letra)) = False
   //     fin si
   // sino 
   //     volver atras, si es recursivo, implica devolver
   // fin si  
   
   // Si un nodo no es visitable, volver atrás, y si ya no quedan más nodos hacia adelante devolver false.  
fin funcion

    string permutacion, ruta
    array de string p()  // el array de producciones que se generó el en otro pseudocódigo... traer la función aquí.
    por cada permutacion sobre el alfabeto //BCDFHL, nota que retiramos la A, pués siempre es el nodo inicial
       
        ruta = Substring(permutacion, hasta "L")  // obtenemos la subcadena hasta L, lo que tenga detrás sobra
        si EsCamino(ruta, p ) = TRUE
            imprimir "A" + ruta
        fin si
    siguiente

buleano = EsCamino(string ruta, array strings p)  // p son el array de las producciones generadas en el otro pseudocódigo
   char c = ruta(0)
   char n
    //... recorrer todo el string, viendo si desde la letra actual, hay conexión al otro nodo (siguiente letra)
    bucle para k desde 1 hasta largo de ruta
        n = ruta(k)
        si p(ASCII(c)) contiene n
            c = n
        sino
            devolver false
        fin si
    siguiente
    devolver TRUE   // c = "L"
fin funcion 

// OJO: Alfabeto aquí deja fuera la letra A, no queremos que cambie de posición porque sabemos que siempre ha de ser el primero, no cabe en otra posición.
// alfabeto = "BCDFHL"
string = SiguientePermutacion(string alfabeto , string permutacion)
   ... calcula y devuelve la siguiente permutacion a la recibida. inicialmente permutacion = alfabeto
fin funcion