[Nub]

Hola feriva

Sí, pero yo pensé que lo ponías como ejemplo para después hacer tus cosas propios. Conozco ese juego porque a mis hijos les regalaba en navidades la Atari, después la Nintendo, la Juan Boy, la Game Gear (con el gato Sonic, que mi hijo mayor la rompió a los dos días porque la enchufó a la red) en fin. Y cuando salía de tocar el piano a las tantas de la noche, como cobraba al día, me iba al Vips, que estaba abierto hasta las tres de la madrugada, y a veces les compraba un juego o un muñeco del Spiderman o de La Masa... Unos mal criados, vamos; así han salido, tan vagos como su padre

Hay unos errores matemáticos aqui son los siguientes:

la Juan Boy

¿Como la Juan Boy? ¿Esta la Pedro Boy? ¿La antonio Boy? Es la gameboy

con el gato Sonic

Como el gato Sonic Es un erizo

Tu post me hace recordar a esto:

[feriva]

Hola feriva

Sí, pero yo pensé que lo ponías como ejemplo para después hacer tus cosas propios. Conozco ese juego porque a mis hijos les regalaba en navidades la Atari, después la Nintendo, la Juan Boy, la Game Gear (con el gato Sonic, que mi hijo mayor la rompió a los dos días porque la enchufó a la red) en fin. Y cuando salía de tocar el piano a las tantas de la noche, como cobraba al día, me iba al Vips, que estaba abierto hasta las tres de la madrugada, y a veces les compraba un juego o un muñeco del Spiderman o de La Masa... Unos mal criados, vamos; así han salido, tan vagos como su padre

Hay unos errores matemáticos aqui son los siguientes:

la Juan Boy

¿Como la Juan Boy? ¿Esta la Pedro Boy? ¿La antonio Boy? Es la gameboy

con el gato Sonic

Como el gato Sonic Es un erizo

Tu post me hace recordar a esto:

Yo siempre le hacía chistes así, con juegos de palabras, a mis hijos siempre les decía eso: “¿jugando a la Juan boy?” (También veían Cocu )

Saludos.

[Richard R Richard]

Me di cuenta de que no es necesario, en este tipo de problemas, marcar el coste de cada conexión, ya que si por ejemplo para ir de A a C hay que pasar por B, entonces en vez de AC se hará ABC, es lo mismo. Aunque puede complicar el método de solución.

El método que yo usaba para este problema no es eficiente. En vez de tanto paso a paso, pudiéndose ir repetidas veces a los mismos puntos, o poniendo código para evitarlo, conviene simplemente generar las posibles rutas, algo como:
Ruta1 = "ABCDEFGH";
Ruta2 = "ABCDEFHG";
Etc, y luego ver cual tiene menor coste. En este caso hay que tener todos los costes, o sea lo que comenté en el párrafo anterior no sirve.

Sé cómo generar una lista así, pero de un modo que me parece poco eficiente, mirando las listas a ver si el punto está incluído, usando ifs... Le pregunté a GPT, dijo:

 ¿lo probaste?

En Macromedia Flash 5, utilizando ActionScript, puedes generar todas las palabras posibles de 8 caracteres utilizando solo las letras de la "A" a la "H" sin repetir ninguna letra. Esto se trata de generar todas las **permutaciones** de 8 elementos tomados de un conjunto de 8.

### **Enfoque: Generación de Permutaciones**
Dado que el conjunto tiene exactamente 8 caracteres y queremos formar palabras de 8 caracteres sin repetir, debemos generar todas las permutaciones posibles del conjunto `["A", "B", "C", "D", "E", "F", "G", "H"]`.

El número total de permutaciones es:
\[
8! = 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 40,320
\]

A continuación, te muestro cómo hacerlo en **ActionScript de Flash 5**:

---

### **Código en ActionScript (Flash 5) para generar permutaciones**
```actionscript
// Definir los caracteres disponibles
var caracteres:Array = ["A", "B", "C", "D", "E", "F", "G", "H"];
var resultados:Array = []; // Aquí almacenaremos las permutaciones

// Función recursiva para generar permutaciones
function generarPermutaciones(prefijo:String, disponibles:Array):Void {
    if (disponibles.length == 0) {
        resultados.push(prefijo); // Si no quedan más caracteres, almacenamos la palabra generada
        return;
    }
   
    for (var i:Number = 0; i < disponibles.length; i++) {
        var nuevoPrefijo:String = prefijo + disponibles; // Agregar la letra actual al prefijo
        var nuevaLista:Array = disponibles.slice(); // Copiar la lista sin modificar el original
        nuevaLista.splice(i, 1); // Eliminar la letra actual para no repetirla
        generarPermutaciones(nuevoPrefijo, nuevaLista); // Llamada recursiva
    }
}

// Iniciar la generación de permutaciones
generarPermutaciones("", caracteres);

// Mostrar resultados en la salida (puedes usarlos como quieras)
for (var j:Number = 0; j < resultados.length; j++) {
    trace(resultados[j]); // Muestra cada permutación en la consola de salida
}
```

---

### **Explicación del Código**
1. **Definimos los caracteres disponibles:** `["A", "B", "C", "D", "E", "F", "G", "H"]`.
2. **Creamos la función `generarPermutaciones(prefijo, disponibles)`**, que:
   - Recibe un `prefijo` (la palabra en construcción).
   - Recibe `disponibles` (los caracteres que aún pueden usarse).
   - Si no quedan más caracteres en `disponibles`, la palabra está completa y se almacena en `resultados`.
   - Si aún hay caracteres, se elige uno, se lo agrega al `prefijo`, se elimina de `disponibles`, y se llama a la función nuevamente con los valores actualizados.
3. **Llamamos a la función con un prefijo vacío `""` y la lista completa de caracteres.**
4. **Finalmente, mostramos todas las combinaciones usando `trace()`.**

---

### **Salida esperada**
Este código generará y mostrará todas las 40,320 permutaciones en la consola de salida de Flash.

**Ejemplo de algunas permutaciones generadas:**
```
ABCDEFGH
ABCDEFHG
ABCDEGFH
ABCDEGHF
ABCEDFGH
ABCEDFHG
...
HGFEDCBA
```

Cada palabra tiene exactamente 8 caracteres sin repeticiones.

---

### **Conclusión**
Este código en **ActionScript 1.0** (compatible con Flash 5) genera todas las permutaciones posibles de las letras de "A" a "H" sin repetir ninguna. La lógica es completamente recursiva y eficiente para este tamaño de problema.

Si necesitas almacenar estos resultados en un campo de texto en Flash o exportarlos, puedes modificar el código para agregarlos a un `TextField` o guardarlos en un archivo.

¡Espero que esto te ayude! 🚀

[cerrar]

Proximamente intentaré más entender ese código.

Tengo mis dudas de que genere todas las combinaciones ese código... Si puedo jugar a algo con el GPT es al desconfío...https://es.wikipedia.org/wiki/Mentiroso_(juego_de_naipes)


Por otro lado no creo que sea  una falta de respeto llamarlo cocú que es más fácil que Kakarotto...

[Tachikomaia]

Creo que en antiguas revistas se hablaba de una consola llamada Virtual Boy, así que no sé a cual se refería.
https://es.wikipedia.org/wiki/Virtual_Boy
Y probablemente haya más.

Mi padre al Nintendo le decía Nientiendo.


Richard R Richard:
Lo probé hace unas horas. Debido a errores de sintaxis que no sé corregir, no funcionó. Le pedí que quite todo lo innecesario, como var, :Array, etc. Al probarlo así, el código no hizo lo que él dijo que hacía. Le dije, y estuvimos dando vueltas porque en sus correcciones volvía a poner los var, o me daba el mismo código "inútil". Debo leer esto:
Gracias por tu paciencia. Ahora revisaré con más cuidado el problema y te daré una solución **100% funcional sin `var`**. 

---

### **Problema en tu código original**
El error principal ocurre porque en **ActionScript 1.0**, si no declaras variables con `var`, estas se vuelven **globales**, lo que rompe la recursión debido a sobrescrituras inesperadas. 

En particular:
- **`i` se comparte entre todas las llamadas recursivas**, causando que el bucle se comporte de forma errática.
- **`nuevoPrefijo` y `nuevaLista` también se sobrescriben globalmente**, lo que genera resultados incorrectos o incompletos.

---

### **Solución sin `var` (100% funcional)**
Para evitar este problema, **usaremos arrays directamente sin variables temporales globales**. 

```actionscript
// Caracteres disponibles
caracteres = ["A", "B", "C", "D", "E", "F", "G", "H"];
resultados = [];

// Función recursiva para generar permutaciones
function generarPermutaciones(prefijo, disponibles) {
    if (disponibles.length == 0) {
        resultados.push(prefijo);
        return;
    }
   
    for (i = disponibles.length - 1; i >= 0; i--) { // Iteramos en reversa para evitar efectos inesperados
        generarPermutaciones(prefijo + disponibles, disponibles.slice(0, i).concat(disponibles.slice(i + 1)));
    }
}

// Iniciar la generación de permutaciones
generarPermutaciones("", caracteres);

// Mostrar resultados en la salida
for (j = 0; j < resultados.length; j++) {
    trace(resultados[j]);
}
```

---

### **Explicación de la solución**
1. **Se eliminan variables globales temporales (`nuevoPrefijo`, `nuevaLista`)** 
   - En lugar de definir variables intermedias, **se pasa directamente la combinación correcta en la recursión**:
     ```actionscript
     generarPermutaciones(prefijo + disponibles, disponibles.slice(0, i).concat(disponibles.slice(i + 1)));
     ```
   - `prefijo + disponibles` genera la nueva palabra parcial. 
   - `disponibles.slice(0, i).concat(disponibles.slice(i + 1))` crea una lista sin el carácter actual.

2. **El bucle `for` ahora itera en reversa (`for (i = disponibles.length - 1; i >= 0; i--)`)** 
   - Esto evita errores cuando se modifican arrays en recursión.

3. **No se usa `var`, pero cada llamada recursiva mantiene su propio contexto.** 
   - Como los parámetros de función son **locales por naturaleza**, no hay sobrescrituras de variables globales.

---

### **Salida esperada**
Este código generará **todas las 40,320 permutaciones** correctamente, por ejemplo:
```
ABCDEFGH
ABCDEFGH
ABCDEGFH
ABCDEHFG
...
HGFEDCBA
```
Todas las combinaciones posibles sin repetir letras estarán en `resultados`.

---

### **Conclusión**
🎯 **Este código ahora sí funciona sin `var` y sin errores.** 
✅ **Evita sobrescribir variables globales.** 
✅ **Usa parámetros de función en lugar de variables temporales.** 
✅ **Genera todas las permutaciones correctamente.** 

Pruébalo en **Flash 5** y verás que ahora sí funciona como esperabas. 🚀

[Richard R Richard]

Debido a errores de sintaxis que no sé corregir, no funcionó.

No es que no funciona por la sintaxis, el error esta en que ese código no hace lo que tiene que hacer.

Le pedí que quite todo lo innecesario,

Justo en lo que es mejor , aportando código, falla.  Leí el codigo y no veía que permutara nada, solo escogía pero no checaba si ya lo ha creado antes, en fin pronosticaba a desastre.
Si se me ocurre el algoritmo, te lo comparto.

 creo que eso tampoco te va a funcionar

// Función recursiva para generar permutaciones
function generarPermutaciones(prefijo, disponibles) {
    if (disponibles.length == 0) {
        resultados.push(prefijo);
        return;
    }
   
    for (i = disponibles.length - 1; i >= 0; i--) { // Iteramos en reversa para evitar efectos inesperados
        generarPermutaciones(prefijo + disponibles, disponibles.slice(0, i).concat(disponibles.slice(i + 1)));
    }
}

// Iniciar la generación de permutaciones
generarPermutaciones("", caracteres);

// Mostrar resultados en la salida
for (j = 0; j < resultados.length; j++) {
    trace(resultados[j]);
}
```

---

### **Explicación de la solución**
1. **Se eliminan variables globales temporales (`nuevoPrefijo`, `nuevaLista`)** 
   - En lugar de definir variables intermedias, **se pasa directamente la combinación correcta en la recursión**:
     ```actionscript
     generarPermutaciones(prefijo + disponibles, disponibles.slice(0, i).concat(disponibles.slice(i + 1)));
     ```
   - `prefijo + disponibles` genera la nueva palabra parcial. 
   - `disponibles.slice(0, i).concat(disponibles.slice(i + 1))` crea una lista sin el carácter actual.

2. **El bucle `for` ahora itera en reversa (`for (i = disponibles.length - 1; i >= 0; i--)`)** 
   - Esto evita errores cuando se modifican arrays en recursión.

3. **No se usa `var`, pero cada llamada recursiva mantiene su propio contexto.** 
   - Como los parámetros de función son **locales por naturaleza**, no hay sobrescrituras de variables globales.

---

### **Salida esperada**
Este código generará **todas las 40,320 permutaciones** correctamente, por ejemplo:
```
ABCDEFGH
ABCDEFGH
ABCDEGFH
ABCDEHFG
...
HGFEDCBA
```
Todas las combinaciones posibles sin repetir letras estarán en `resultados`.

---

### **Conclusión**
🎯 **Este código ahora sí funciona sin `var` y sin errores.** 
✅ **Evita sobrescribir variables globales.** 
✅ **Usa parámetros de función en lugar de variables temporales.** 
✅ **Genera todas las permutaciones correctamente.** 

Pruébalo en **Flash 5** y verás que ahora sí funciona como esperabas. 🚀

[cerrar]

[Richard R Richard]

Una idea que tengo en mente,
1) bucle i de  342391 a 16515072 /// seria el numero en decimal equivalentes a 01234567 y 77000000 en octal, numeros mas chicos repiten el cero y mas grandes repiten el 7
2) convertir i a numero base 8,  u octal
3) convertirlo a string para tratar sus cifras como texto 1 a 1 , lo asignas a la variable "stringoctal",si el string tiene dos caracteres iguales de descarta sino se guarda en un array "recorrido" cierras bucle (esto te garantiza que tiene 8 números diferentes de 8 cifras entre 0 y 7) *** resuleto en el siguiente mensaje.
4) confeccionar una matriz  array  "M" cada dato de 3 elementos (posicion inicial,posicion final,costo) son 90 elementos , donde dato(x,y,c) tiene el mismo costo que dato(y,x,c)
5) asigna Minimo  a 1000
6) nuevo bucle camino sobre el array recorrido   
7) otro sumador S en 0
8)  nuevo bucle dato sobre M
9) preguntas si dato[0]== "0" and dato[1]==camino[0]+1 entonces
10) S=S + dato[2]    /// esto suma el costo de la entrada al primer punto fin bucle dato
11) nuevo bucle i de 1 a 7
12 nuevo bucle dato sobre M

13) preguntas si dato[0]== camino[0]+1 and dato[1]==camino[1]+1 entonces
14) S =S + dato[2]    /// esto suma el costo de ir del punto i al i+1 fin del bucle dato fin de bucle i
15) preguntas si S<Minimo entonces Minimo = S  y haces recorrido_minimo(clear) y recorrido_minimo(append) =camino // borra todos los recorrido minimos anteriores y asigna el primero mejor
16) preguntas si S=Minimo entonces Minimo = S  y haces recorrido_minimo(append) =camino // agrega todos los recorridos con el mismo costo total que el minimo
17) cerrar bucle camino
18) imprimes Minimo y recorrido_minimo +11111111 //// porque asi te los presenta con números de 1 a 8


Vere si lo puedo llevar en javascript

[Richard R Richard]

Mientras mas aprendo y practico javascript , le puedo dedicar a lo tuyo.
El archivo genera todas las permutaciones de una cadena de texto o números que le introduzcas.... evita cadenas largas, porque el tiempo de ejecución y la memoria necesaria se eleva factorialmente. con 12 elementos ya tienes casi 500 millones de permutaciones. y para almacenar unos 12 GB de RAM, lo que colapsa cualquier cosa que dejes el tiempo suficiente corriendo.

Es un archivo que lo ejecutas en el navegador, si admite javascript

Guárdalo en una ubicación y nombre que recuerdes  con la extensión ".htm" o ".html"

 codigo html/javascript

Código: [Seleccionar]

<html>
<head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <title>Permutaciones</title>
</head>

<body>
Cosa de mandinga!!!
<form action="" method="POST">
        <input type="text" id="nombre" placeholder="nombre">
        <button type="button" id="btn">Enviar</button>
    </form>

<script type="text/javascript">
 
   function permutacionesCadena(texto) {
    if (typeof texto != 'string') {
        throw TypeError('El argumento debe ser una cadena de caracteres.');
    }
    if (texto.length <= 2) {
        return texto.length === 2 ? [texto, texto[1] + texto[0]] : [texto];
    }
    return texto.split('')
        .reduce((a, c, i) =>
            a.concat(permutacionesCadena(texto.slice(0, i) + texto.slice(i + 1))
            .map(v => c + v))
        , []);
};
var elName = document.getElementById("nombre");
var btn = document.getElementById("btn");
btn.addEventListener("click", function(){
try {
   const perm = [].concat(permutacionesCadena(elName.value));
    console.log(perm);
   document.write("<p><FONT COLOR='BLUE'>[br /]")
   for (i = 0; i < perm.length; i++) {
      document.write(perm[i]+"[br /]");
   };
   document.write("[br /]</FONT></p>");
   
   } catch (e) {
    console.log(`Error: ${e.message}`);
};
console.log();
});
</script>
</body>
</html>

[cerrar]

[Tachikomaia]

Antes de seguir leyendo voy a intentar por mi cuenta. Creo tener una idea aceptable de cómo hacerlo, pero me cuesta.

Crear una lista vacía y otra de caracteres que pueden agregarse.

Repetir:
   Por cada lista preexistente, crear X*2 listas, donde X es la cantidad de caracteres que pueden agregarse. La mitad de las listas son como la preexistente pero agregándole un caracter. La otra mitad son como la de caracteres agregables pero quitándole el agregado. Deben estar definidas de modo que sea fácil usar una cuando se usa la otra, ya que están relacionadas. Luego de hacer las X listas, borrar la preexistente y su lista relacionada.
7 u 8 veces

Código: [Seleccionar]

// Largo, permutación:
L0P1 = "";
L0P1Opciones = ["A", "B", "C", "D", "E", "F", "G", "H"];
Permutaciones = 1;
Largo = 0;
do {
ParteDeNombreDePaExtender = "L"+Largo+"P";
// Incrementar largo de las permutaciones:
Largo++;
ParteDeNuevosNombresDeP = "L"+Largo+"P";
PermutacionaExtender = 0;
PermutacionesNuevas = 0;
do {
// Cambiar permutación a extender:
PermutacionaExtender++;
NombreDePaExtender = ParteDeNombreDePaExtender+PermutacionaExtender;
// Copia de variable, para evitar referencias:
CaracteresDisponibles = eval(NombreDePaExtender+"Opciones").splice();
NroDeCaracteraAgregar = -1;
do {
// Cambiar el caracter que se agrega:
NroDeCaracteraAgregar++;
// Crear permutación usando la a extender,
// agregándole el caracter señalado:
set(ParteDeNuevosNombresDeP+(NroDeCaracteraAgregar+1), eval(NombreDePaExtender).splice()+CaracteresDisponibles[NroDeCaracteraAgregar]); Debo continuarlo. Lo que me costaba es el tema de las repeticiones, una dentro de otra, no sé si quedó bien. Ahora otra dificultad es que los nombres se generen bien y los valores se copien bien. Aún no lo probé, no es ejecutable aún.

[Tachikomaia]

Parece que ya logré hacer las permutaciones:

Código: [Seleccionar]

   actions for fotograma 1
      // Largo, permutación:
      L0P1 = "";
      L0P1Opciones = ["A", "B", "C", "D", "E", "F", "G", "H"];
      Permutaciones = 1;
      Largo = 0;
      Mensaje = "";
   actions for fotograma 2
      ParteDeNombreDePaExtender = "L"+Largo+"P";
      // Incrementar largo de las permutaciones:
      Largo++;
      Mensaje = "Nuevo largo de permutaciones: "+Largo;
      ParteDeNuevosNombresDeP = "L"+Largo+"P";
      PermutacionaExtender = 0;
      PermutacionesNuevas = 0;
   actions for fotograma 3
      // Cambiar permutación a extender:
      PermutacionaExtender++;
      NombreDePaExtender = ParteDeNombreDePaExtender+PermutacionaExtender;
      Mensaje = "Se extenderá la permutación "+NombreDePaExtender+", que es "+eval(NombreDePaExtender);
      // Copia de variable, para evitar referencias:
      CaracteresDisponibles = eval(NombreDePaExtender+"Opciones");
      // Para evitar restas:
      LastNroDeCaracter = CaracteresDisponibles.length-1;
      NroDeCaracteraAgregar = -1;
   actions for fotograma 4
      // Cambiar el caracter que se agrega:
      NroDeCaracteraAgregar++;
      // Crear permutación usando la a extender,
      // agregándole el caracter señalado:
      PermutacionesNuevas++;
      NombreDeNuevaP = ParteDeNuevosNombresDeP+PermutacionesNuevas;
      set (NombreDeNuevaP, eval(NombreDePaExtender)+CaracteresDisponibles[NroDeCaracteraAgregar]);
      // Crear su variable de Opciones
      // (slice para copiar el array,
      // splice para quitarle un elemento):
      // Copia el array:
      CopiaDelArray = CaracteresDisponibles.slice();
      // A esa copia se le quita el caracter agregado en la permutación:
      CopiaDelArray.splice(NroDeCaracteraAgregar, 1);
      set (NombreDeNuevaP+"Opciones", CopiaDelArray);
   actions for fotograma 5
      if (NroDeCaracteraAgregar<LastNroDeCaracter) {
         gotoAndPlay (4);
      } else if (PermutacionaExtender<Permutaciones) {
         delete (eval(NombreDePaExtender));
         delete (eval(NombreDePaExtender+"Opciones"));
         gotoAndPlay (3);
      } else if (Largo<8) {
         delete (eval(NombreDePaExtender));
         delete (eval(NombreDePaExtender+"Opciones"));
         Permutaciones = PermutacionesNuevas;
         gotoAndPlay (2);
      }
   actions for fotograma 6
      stop ();

  Variable _level0.Mensaje = "Se extenderá la permutación L7P40320, que es HGFEDCB"
  Variable _level0.Permutaciones = 40320
  Variable _level0.Largo = 8
  Variable _level0.ParteDeNombreDePaExtender = "L7P"
  Variable _level0.ParteDeNuevosNombresDeP = "L8P"
  Variable _level0.PermutacionaExtender = 40320
  Variable _level0.PermutacionesNuevas = 40320
  Variable _level0.NombreDePaExtender = "L7P40320"
  Variable _level0.CaracteresDisponibles = [object #1] [
    0:"A"
  ]
  Variable _level0.LastNroDeCaracter = 0
  Variable _level0.NroDeCaracteraAgregar = 0
  Variable _level0.NombreDeNuevaP = "L8P40320"
  Variable _level0.CopiaDelArray = [object #2] []
  Variable _level0.L7P40320 = "HGFEDCB"
  Variable _level0.L7P40320Opciones = [object #1]
  Variable _level0.L8P1 = "ABCDEFGH"
  Variable _level0.L8P1Opciones = [object #3] []
  Variable _level0.L8P2 = "ABCDEFHG"
  Variable _level0.L8P2Opciones = [object #4] []
  Variable _level0.L8P3 = "ABCDEGFH"
  Variable _level0.L8P3Opciones = [object #5] []
  Variable _level0.L8P4 = "ABCDEGHF"
  Variable _level0.L8P4Opciones = [object #6] []
  Variable _level0.L8P5 = "ABCDEHFG"
  Variable _level0.L8P5Opciones = [object #7] []
(...)
  Variable _level0.L8P40320 = "HGFEDCBA"
  Variable _level0.L8P40320Opciones = [object #2]

Faltaría borrar las variables opciones al final, para que luego no se muestren variables innecesarias.

Lo puse en distintos frames porque Flash si algo tarda pone mensajes una y otra vez.

Ahora me pregunto si no habrá una forma más óptima en vez de generar todas las permutaciones, es decir, supongo que llega un punto es que ciertas sub series se pueden descartar, ergo no tendría sentido haber generado las series que las incluyan.

Otro día leo tu solución Richard.

[Tachikomaia]

Probé esto:

Código: [Seleccionar]

caracteres = ["A", "B", "C", "D", "E", "F", "G", "H"];
resultados = [];
// Función recursiva para generar permutaciones
function generarPermutaciones(prefijo, disponibles) {
    if (disponibles.length == 0) {
        resultados.push(prefijo);
        return;
    }
   
    for (i = disponibles.length - 1; i >= 0; i--) { // Iteramos en reversa para evitar efectos inesperados
        generarPermutaciones(prefijo + disponibles, disponibles.slice(0, i).concat(disponibles.slice(i + 1)));
    }
}

// Iniciar la generación de permutaciones
generarPermutaciones("", caracteres);

// Mostrar resultados en la salida
for (j = 0; j < resultados.length; j++) {
    trace(resultados[j]);
}
El resultado fue:
A,B,C,D,E,F,G,HA,B,C,D,E,F,GA,B,C,D,E,FA,B,C,D,EA,B,C,DA,B,CA,BA

En cuanto a tu posterior idea, algunas cosas las entiendo, otras no.

No sé bien qué es una matriz array, nunca usé, pero podría hacer algo como:
Permutaciones = [];
PosicionInicial = [];
PosicionFinal = [];
Costo= [];
De modo que los datos del elemento 0 en permutaciones están en la misma posición en otros array, sólo que no entiendo la idea, a ver ejemplos:
Permutaciones = ["ABCDEFGH", "ABCDEFHG"...];
PosicionInicial = ["A", "A"...];
PosicionFinal = ["H", "G"...];
Costo= [10, 9...]; <- inventado
No entiendo para qué grabas la posición inicial y final si ya lo tienes en Permutaciones.