[Tachikomaia]

Tal vez es un error de programación no sólo de Matemática, fíjense.

Cuando Hijos es 2, los objetos deben colocarse en las posiciones -16.5 y 16.5.
Cuando son 3, en -33, 0 y 33.
Cuando son 4, en -49.5, -16.5, 16.5 y 49.5.

Parece que el 1er objeto debe colocarse en (Hijos-1)*16.5.
Y con cada hijo la posición aumenta 33.
¿Cual es la dichosa fórmula para que se coloquen así?

Lo último que intenté fue en resumen esto:

Código: [Seleccionar]

Resta = 49.5*(Hijos-1);
do {
Hijo = Hijo+1;
Posicion = Hijo*33-Resta;
} while ( Hijo < Hijos );
Cuando son 2 hijos funciona bien, pero cuando son más inicia cada vez más en la izquierda, demasiado:

Debería aparecer el 10 (objeto 1) en la izquierda, el 9 (2) en el medio, y el 8 (3) en la derecha.

[ingmarov]

Hola Tachikomaia

He probado con el siguiente código y me funciona. Debe tener alguna falla, te lo comparto para que lo veas.

Lo hice el python

Código: [Seleccionar]

def posiciones(n):
    posicion=-16.5*(n-1)
    lista=[]
    if n!=0:
        for i in range(n):
            lista.append(posicion+33*i)
    return(lista)

a=posiciones(5)

print(a)


Saludos

[Tachikomaia]

Bien, tuve que agregar algo pero logré que funcionara gracias a ti:

Código: [Seleccionar]

function InsertarNodo () {
Imagenes = Imagenes+1;
Nodos = Nodos+1;
Grafo.attachMovie("mNodo", "Nodo"+Nodos, Imagenes);
// Especificar la situación que representa:
set ("Grafo.Nodo"+Nodos+".EnHP", EnHP);
// Insertar flecha:
Imagenes = Imagenes+1;
Grafo.attachMovie("mFlecha", "Flecha"+Nodos, Imagenes);
// Especificar el sitio donde se insertan:
setProperty ("Grafo.Nodo"+Nodos, _y, PosicionY+33);
setProperty ("Grafo.Flecha"+Nodos, _x, PosicionX);
setProperty ("Grafo.Flecha"+Nodos, _y, PosicionY+6.5);
Hijos = Hijos+1;
if ( Hijos == 1 ) {
setProperty ("Grafo.Nodo"+Nodos, _x, PosicionX);
} else {
Hijo = 0;
PosicionBase = -16.5*(Hijos-1);
do {
Hijo = Hijo+1;
Posicion = PosicionBase+(Hijo-1)*33;
setProperty ("Grafo.Nodo"+(Nodos-Hijos+Hijo), _x, Posicion);
// Rotación y tamaño de flecha.
DistanciaXPadreHijo = Math.abs(Posicion);
setProperty ("Grafo.Flecha"+(Nodos-Hijos+Hijo), _height, Math.sqrt(Math.pow(DistanciaXPadreHijo, 2)+20*20));
Rotacion = 180/Math.PI*Math.atan (DistanciaXPadreHijo/20*-1);
if ( Posicion<0 ) {
Rotacion = Rotacion*-1;
}
setProperty ("Grafo.Flecha"+(Nodos-Hijos+Hijo), _rotation, Rotacion);
} while ( Hijo < Hijos );
}
}
A ver si lo entendí y lo puedo simplificar, porque hay mucho -1 por ahí.

Primero se calcula la posición mínima:
PosicionBase = -16.5*(Hijos-1);
Eso te lo copié.

Luego se calcula la posición de cada objeto, usando el cálculo anterior:
Posicion = PosicionBase+(Hijo-1)*33;
Puse ese -1 porque tu código me daba 16.5 y 49.5, entonces supuse que era porque N lo definiste como 0, pero yo Hijo lo defino como 1. No sé si es eso pero me funcionó.

Esto es basicamente Z = -16.5*(X-1)+(Y-1)*33
¿no?

Z es la posición.
X es la cantidad de objetos.
Y es el objeto al cual se le asigna la posición.

¿O puede simplificarse? No me doy cuenta cómo.

Ahora veo, me parece, que es imposible. Lo que se podría hacer es:
-16.5*X+16.5+Y*33-33
¿no? Pero no sé si es más simple, intuía que sí porque no tiene paréntesis, pero supongo que da igual, es incluso una fórmula más larga.

Bueno, solucionado.