Propuesta para desafíos javascript 2014

[HackmanC]

Hola,

Una solución al primer reto, lineal, en el peor de los casos tendría que ser más eficiente que cualquier ordenamiento puesto que no ordena todo el Array. No intercambia ningún valor de posición, solamente asigna los indices correspondientes.

Código Javascript:

function tercero(a) {
    var m1 = 0;
    var m2 = 1;
    var m3 = 2;
    for (var i = 2; i < a.length; i++) {
        if (a[i] === a[m1] || a[i] === a[m2] || a[i] === a[m3]) {
            continue;
        }
        if (a[i] < a[m1] || a[i] < a[m2] || a[i] < a[m3]) {
            if (a[m3] > a[m2] && a[m3] > a[m1]) {
                m3 = i;
            } else {
                if (a[m2] > a[m1]) {
                    m2 = i;
                } else {
                    m1 = i;
                }
            }
        }
    }
    if (a.length > 2) {
        if (a[m3] > a[m2] && a[m3] > a[m1]) {
            return a[m3];
        } else {
            if (a[m2] > a[m1]) {
                return a[m2];
            } else {
                return a[m1];
            }
        }
    }
    return false;
}
 
var a = [4,3,2,4,-245,4,1,5,-124,-245,-308];
console.log("valor : " + tercero(a));
 

Se puede implementar de esa forma porque es el 3 valor, escalar al 10 valor sería bastante mas complicado, y sería mas fácil ordenar,

Saludos,

[marlanga]

No funciona bien porque dije que los valores repetidos sólo cuentan como uno.
En [1,1,1,1,1,1,2,3] el tercero es 3.

[NSD]

al problema de la inteligencia dejo mi propuesta.
funca bien y ademas, propone diferentes caminos para lograr el objetivo cambiando un unico parametro.

Código Javascript:

TRON.prototype.ia=function()
{
    // Aumentar este valor hace mas inteligente a la ia pero recarga la pila de recursion pudiendo explotar y/o ser leeeeeeento.
    // Una gran mejora seria que en lugar de ser fijo, aumentara a medida que disminuyen los espacios libres, esto la haria mas versatil.
    // Notese que cambiando este numero se obtienen diferentes soluciones de dominacion total.
    // Ej: 3, 4. 
    // Con un valor menor a 2 no es lo sufientemente inteligente como para encontrar un camino correcto.
    var maximunCall = 3;
    
    // Este valor es un parchesito para no complicar el algoritmo. con que sea mayor o igual a la longitud del mapa es suficiente.
    // Otra gran mejora, seria que en lugar de ser fijo se calculara segun las dimenciones de la matriz.    
    var incrementoAgresivo = 25;
 
    function mejorPosicion(arr, min, pred)
    {
        var max = min;
        var dir = pred;
        for(var i=0; i< arr.length; i++)
        {
            if(arr[i] > max)
            {
                max = arr[i];
                dir = i;
            }
        }
 
        return dir;
    }
 
    function recursiveMejorCamino(pos, mapa, movTmp, nroCall)
    {
        nroCall++;
        if((mapa[pos[0]][pos[1]] == 0) && (nroCall < maximunCall))
        {
            movTmp++;
            var movT = new Array();
            movT[0] = recursiveMejorCamino([(pos[0]-1), pos[1]], mapa, movTmp , nroCall) + (((nroCall > 1) && (mapa[(pos[0]-((pos[0]-2) >= 0 ? (pos[0]-2) : 0))][pos[1]] == 2)) ? incrementoAgresivo : 0);                                  // Arriba
            movT[1] = recursiveMejorCamino([(pos[0]+1), pos[1]], mapa, movTmp , nroCall) + (((nroCall > 1) && (mapa[((pos[0]+2) < mapa.length ? (pos[0]+2) : (mapa.length-1))][pos[1]] == 2)) ? incrementoAgresivo : 0);                    // Abajo
            movT[2] = recursiveMejorCamino([pos[0], (pos[1]-1)], mapa, movTmp , nroCall) + (((nroCall > 1) && (mapa[pos[0]][(pos[1]-((pos[1]-2) >= 0 ? (pos[1]-2) : 0))] == 2)) ? incrementoAgresivo : 0);                                  // Izquierda
            movT[3] = recursiveMejorCamino([pos[0], (pos[1]+1)], mapa, movTmp , nroCall) + (((nroCall > 1) && (mapa[pos[0]][((pos[1]+2) < mapa[pos[0]].length ? (pos[1]+2) : (mapa[pos[0]].length-1))] == 2)) ? incrementoAgresivo : 0);    // Derecha
            var dir = mejorPosicion(movT, 0 , 3);
            
            return ((movTmp*1) + (movT[dir]*1));
        } else
            return 0;
    }
 
    var movP = new Array();
    movP[0] = recursiveMejorCamino([(this.jugador[0]-1), this.jugador[1]], this.mapa,   0,  0); // Arriba
    movP[1] = recursiveMejorCamino([(this.jugador[0]+1), this.jugador[1]], this.mapa,   0,  0); // Abajo
    movP[2] = recursiveMejorCamino([this.jugador[0], (this .jugador[1]-1)], this.mapa,  0,  0); // Izquierda
    movP[3] = recursiveMejorCamino([this.jugador[0], (this.jugador[1]+1)], this.mapa,   0,  0); // Derecha
 
    var dir = mejorPosicion(movP,0 , 0);
 
    switch (dir)
    {
        case 0 :
            return DIRECCION.arriba;
        break;
        case 1 :
            return DIRECCION.abajo;
        break;
        case 2 :
            return DIRECCION.izquierda;
        break;
        case 3 :
            return DIRECCION.derecha;
        break;
    }
};
 

con esto califico para entrar al concurso?

[marlanga]

Sí, pero pon el código completo funcionando en jsfiddle, para que cualquiera pueda probarlo abriendo simplemente el enlace. No requiere registrarse para guardar códigos, simplemente aprieta el "save" de arriba a la izquierda.

Y cuidado, las pruebas las haré en varias coordenadas, buscando puntos flacos. Por ejemplo, si pongo la posición inicial del jugador en [1,1], en la línea 24 de mi enlace jsfiddle con el juego, tu algoritmo obtiene 32 puntos, que es la mitad de los puntos totales.

Tu algoritmo es correcto, pero en cuanto a puntuación, te pueden batir. No obstante ser el primero en resolver un ejercicio suele tener mayor mérito xd. Si quieres, puedes reenviar tu solucion tantas veces como quieras, en la lista de resultados utilizaré tu último envío.


Por otro lado, y como posible consejo a seguir, se puede sacar todo el código aparte, y utilizarlo dentro del método IA de tron. En realidad sólo se necesitaría calcular el mejor camino una sola vez.
Así que un esqueleto de IA podría ser:

Código Javascript:

TRON.prototype.ia=function()
{
    if (camino==null)
    {
       camino=crearCamino(copia de posicion, copia de mapa);
    }
 
    //Código para procesar el objeto "camino" con el
   //objetivo de devolver la mejor direccion en esta llamada
}
 

La variable camino y la función crearCamino habría que declararlas globalmente, arriba del todo, como primera línea de todo el javascript, para que sean visibles dentro de TRON.

[NSD]

Ésta es una burda imitación del juego de las motos de TRON. El juego consiste en varias motos que se mueven por un mapa, con el objetivo de sobrevivir el máximo de tiempo posible. Las motos van dejando una estela por donde pasan, y si otra moto se topa con una estela, o contra una pared, muere. Por supuesto, las motos no pueden detenerse, siempre avanzan a la misma velocidad, si no, no tendría gracia.

En este primer intento no hay enemigos: La moto correrá sola en el mapa. El reto consiste en hacer los máximos puntos posibles. Y cada punto se gana moviéndose a otra casilla sin morir.

si hay varias motos si es nesesario calcularlo cada vez, tu razonamiento es correcto si solo existe una, pero vamos, ¿Quien se pondra a mirar un juego de motos manejada por un autonomo? no tiene sentido. mejor seria que una moto la controle el usuario y en un tablero de 400X400 corra contra dos 3 autonomas, eso si serviria de algo, como dijiste "en un principio" asumi que el algoritmo deberia ser escalable por eso no esta optimizado para este caso particular.

ya que tu eres el coordinar de este desafio, te propongo algo para que tu hagas. arma el tablero que ocupe toda la pantalla y haz que el TRON funcione con muchas IA (osea varias motos cn colores diferentes) asi, en cada IA ponemos el algoritmo de los que vallan resolviendo y luego, ponemos a todos a correr juntos a ver quien saca mas puntos que te parece? y, para darle mas vista, el cuadradito principal de la moto podria ser el avatar de cada usuario jajaja

EDITO: Para que lo gane desde la posicion 1 1 nesesita mas inteligencia con poner

Código Javascript:

var maximunCall = 5;
 

alcanza para que lo resuelva

[marlanga]

Ese cambio lo haré en un futuro incierto si hay varios participantes, si no, es un trabajo inútil por mi parte xd.

Y por esa misma razón, el inmenso costo de tiempo, usar backtracking es muy ineficiente en javascript para IA's con mucha libertad, tendremos que pensar algoritmos voraces que con poca información hagan un trabajo aceptable xd, o alguna otra técnica liviana.

Por otro lado, ahora sólo hay una moto y no hay obstáculos, asi que es posible crear un supuesto recorrido sin demasiada complejidad algorítmica. Creo, no lo he programado ni pensado, pero lo presiento con mi sentido arácnido.


PD. Y si te pongo la posición en [8,8], aún con el maximunCall a 5, te dejas casillas en blanco xd. O en [5,5]. Ya digo que no hay que fiarse del ejemplo.

[HackmanC]

Hola,

Iniciado por marlanga

No funciona bien porque dije que los valores repetidos sólo cuentan como uno.
En [1,1,1,1,1,1,2,3] el tercero es 3.

Es cierto no funciona en ese caso.

Bueno, ni modo, creo que el mejor caso es ordenar completamente. Dejo otro, en este caso estoy seguro que funciona bien pero no es muy eficiente en general.

http://jsfiddle.net/z4Zcg/2/

No sé cuanto tiempo dejan el código en jsfiddle,
Saludos,

[marlanga]

No sé cuanto duran los códigos en jsfiddle, pero creo que años.
Ok, ahora tu envío funciona, caundo actualice la lista de envíos lo incluyo. Si quieres puedes ir resolviendo algún otro.

[NSD]

bueno como sea, aca dejo un fiddle con 3 ia en un tablero de 38 x 38. a ver si otros ponen sus algoritmos y los comparamos entre ellos http://jsfiddle.net/ProyectoNSD/dssvt/

[marlanga]

El objetivo de este reto es hacer puntos en un tablero controlado. La IAs que se presenten pueden no ser buenas para competir contra otras motos en el mismo tablero, porque es posible que sus algoritmos no necesiten leer contínuamente el estado del tablero.

[Pantaláimon]

Bueno, aquí mi primera solución parcial:
http://jsfiddle.net/jefebrondem/7ZQcT/2/
Recorre todas las casillas cuando almenos uno de los lados del tablero es par. En caso contrario aún no hay algoritmo implementado( puede petar, no lo he probado ).

El caso en que ambos lados del tablero sea impar tengo que pensarlo un poco más. Pues habrá casos en que no se podrán recorrer todas las casillas.

Por cierto marlanga, al copy-past tal cual de tu código inicial en un nuevo proyecto: http://jsfiddle.net/jefebrondem/2mt8q/, no sé porque no se muestra el tablero. He tenido que actualizar directamente de tu proyecto para que pudiera verse. Por eso el /2/ final.

Un saludo!

[marlanga]

Da errores fatales cuando cambias los tamaños del mapa, como ya dices. Pero cuando funciona, lo hace perfecto.

Arriba a la izquierda del jsfiddle hay dos selects. El primero sirve para elegir librería de javascript que quieres que se cargue, que en este demo no vale para nada. Pero el segundo select sirve para decir cuándo cargar el código javascript. Por defecto está puesto "onload", pero a mí me gusta ponerlo siempre en "No warp - in head", que significa que lo va a incluir en el head de la página, y ya decidiré yo si usar window.onload o no.
El tron usa window.onload para iniciarse, asi que si no cambias ese select, el evento "load" no se disparará nunca en el código porque ya lo usó jsfiddle para cargar el código js del textarea.

[Pantaláimon]

Bueno, ya he conseguido hacer un algoritmo único para cualquier dimensión del tablero y posición inicial que recorra el máximo de casillas posibles... o eso creo:
http://jsfiddle.net/jefebrondem/2mt8q/1/

¡Feliz navidad y fiestas por venir!

[NSD]

El objetivo de este reto es hacer puntos en un tablero controlado. La IAs que se presenten pueden no ser buenas para competir contra otras motos en el mismo tablero, porque es posible que sus algoritmos no necesiten leer contínuamente el estado del tablero.

Bueno, ya he conseguido hacer un algoritmo único para cualquier dimensión del tablero y posición inicial que recorra el máximo de casillas posibles... o eso creo:

Si el TRON va a correr solo en el tablero, no hace falta nada eleborado, ni siquiera pensar mucho. de hecho con estas 8 lineas alcanza. Lo interesante es cuando mas de una moto corren juntas en el tablero

Código Javascript:

TRON.prototype.ia=function()
{   
    if(this.mapa[this.jugador[0]][(this.jugador[1]+1)] == 0)
        return DIRECCION.derecha;
    else if(this.mapa[(this.jugador[0]+1)][this.jugador[1]] == 0)
        return DIRECCION.abajo;
    else if(this.mapa[(this.jugador[0]-1)][this.jugador[1]] == 0)
        return DIRECCION.arriba;
    else
        return DIRECCION.izquierda;
};
 

[Pantaláimon]

Matando moscas a cañonazos. Que burro soy.

Sólo puedo objetar que para un tablero de 1xn o mx1 no hallará siempre el máximo de casillas. Pero esto es fácil de solucionar.

[NSD]

Si tienes una sola fila, o una sola columna solo se puede ir para una lado, salvo que inicies en un extremo es imposible conseguir todos. si embargo ese caso particular es curioso, ya que ahi hay que elegir correctamente hacia que lado ir.

El codigo que puse tiene una falla, y es que hay dos casos particulares de tableros cuadrados que no resulve. aqui la vercion mejorada y que contempla esas posibilidades.

Código Javascript:

TRON.prototype.ia=function()
{       
    // Casos de tablero particulares.
    if(this.mapa.length == 1)
    {
        if(this.jugador[1] > (this.mapa[0].length/2))
            return DIRECCION.arriba;
        else
            return DIRECCION.abajo; 
    }
    else if(this.mapa[0].length == 1)
    {
        if(this.jugador[0] > (this.mapa.length/2))
            return DIRECCION.izquierda;
        else
            return DIRECCION.derecha;   
    }
    else
    {       
        // Casos especiales.
        if  (
                (
                    // Esta en la primer columna.
                    (this.jugador[1] == 1) 
                    || 
                    // Esta en la esquina superior derecha.
                    (
                        (((this.jugador[0]-2) >= 0 ? this.mapa[this.jugador[0]-2][this.jugador[1]] : 3) > 0) 
                        && (((this.jugador[0]+2) < this.mapa[0].length ? this.mapa[this.jugador[0]][this.jugador[1]+2] : 3) > 0) 
                        && (this.mapa[this.jugador[0]+1][this.jugador[1]+1] == 0)
                    )
                )           
                // Y esta libre.
                && (this.mapa[this.jugador[0]-1][this.jugador[1]] == 0)
            )
            return DIRECCION.arriba;
        else
        {
            if(this.mapa[this.jugador[0]][this.jugador[1]+1] == 0)
                return DIRECCION.derecha;
            else if(this.mapa[this.jugador[0]+1][this.jugador[1]] == 0)
                return DIRECCION.abajo;
            else if(this.mapa[this.jugador[0]-1][this.jugador[1]] == 0)
                return DIRECCION.arriba;
            else
                return DIRECCION.izquierda;
        }
    }
};
 

[Pantaláimon]

Iniciado por NSD

El codigo que puse tiene una falla, y es que hay dos casos particulares de tableros cuadrados que no resulve. aqui la vercion mejorada y que contempla esas posibilidades.

No se a que dos casos particulares te refieres. Pero, cierto, ahora me he fijado que el primer algoritmo que presentabas fallaba para tableros mxn con m > 2 y posición inicial (y,1) con y distinto de 1 y de m.

El segundo tengo que analizarlo. Sin embargo estas condiciones:

Código Javascript:

this.mapa.length == 1
this.mapa[0].length == 1
 

me parecen extrañas con la implementación del tablero propuesta por marlanga. Donde un tablero fila de zeros se corresponderia con

Código Javascript:

this.mapa.length == 3
 

y un tablero columna de ceros se correspondería con

Código Javascript:

this.mapa[0].length == 3
 

Edit: en la esquina superior derecha, con lápiz y papel no veo ninguna razón para que falle el algoritmo.

Un saludo!

[NSD]

Correcto, tienes razon, hay que preguntar por 3, escribi sin pensar (y sin probarlo)

en la esquina superior derecha fallaba si arranca ahi, si arranca en esa posicion se hace un nudo y termina, no obstante analizandolo mejor, el nudo no solo se hace en esa esquina sino en cualquier caso similar. por lo tanto la condicion general y definitiva seria:

Código Javascript:

// Casos especiales.
        if  (
                (
                    // Esta en la primer columna.
                    (this.mapa[this.jugador[0]][this.jugador[1]-1] == 1) 
                    || 
                    // Esta en un escalon.
                    (
                        (((this.jugador[0]-2) >= 0 ? this.mapa[this.jugador[0]-2][this.jugador[1]] : 3) > 0) 
                        && (((this.jugador[0]+2) < this.mapa[0].length ? this.mapa[this.jugador[0]-1][this.jugador[1]+1] : 3) > 0) 
                    )
                    || 
                    // Tiene que dar un rodeo.
                    (
                        (((this.jugador[0]-2) >= 0 ? this.mapa[this.jugador[0]-2][this.jugador[1]] : 3) > 0) 
                        && (((this.jugador[0]+2) < this.mapa[0].length ? this.mapa[this.jugador[0]-1][this.jugador[1]+1] : 3) > 0) 
                        && (this.mapa[this.jugador[0]+1][this.jugador[1]+1] == 0)
                    )
                )           
                // Y esta libre.
                && (this.mapa[this.jugador[0]-1][this.jugador[1]] == 0)
            )
            return DIRECCION.arriba;
        else
        {
...
 

EDITO: eh aqui el fiddle con un random, hasta ahora nunca fallo: http://jsfiddle.net/ProyectoNSD/dssvt/2/
EDITO 2: y he aqui 3 ia compitiendo juntas: http://jsfiddle.net/ProyectoNSD/dssvt/3/

[Pantaláimon]

NSD, aquí tienes un fallo con tu algoritmo.
Tablero 7x8, inicio (4,3)
http://jsfiddle.net/jefebrondem/7ZQcT/5/

[marlanga]

Para probar mapas sin tener que escribir el mapa a mano, hice cambios en el código:

http://jsfiddle.net/marlanga/25Upk/

Ahora el tamaño del mapa se crea en el constructor del juego, en la última línea del código.
El orden de los argumentos son: id del canvas, filas del mapa, columnas del mapa, y un array con la fila y la columna del jugador.
Las filas y columnas incluyen las "paredes" negras que envuelven a todo el mapa. Es decir, si pones 3,3, en realidad solo habrá 1 celda del mapa en blanco para recorrer.


Tu código, pantalaimon, parece que da soluciones óptimas en todos los casos. Felicidades.

Y el tuyo, NSD, sigue centrándose en luchar contra otras motos xd así que sabiendo cómo funciona tu IA, es posible crear un mapa y una situación inicial que haga que la IA se deje casillas libres, al menos con la que tienes hasta el momento. Es eficaz, pero no óptimo. Pero ya tienes una base con la que trabajar si se hace el reto de carreras de TRON entre IA's xd.

Mi código aún no he empezado a hacerlo, a ver si me pongo ya de una vez xd. Aunque no es nada sencillo el reto, otra vez me pasé con el nivel de dificultad xd.

Así que mientras tanto, supongo que pondré otro reto javascript mas sencillito para abrir la puerta a nuevos participantes:

RETO NUEVO
Una aproximación al número PI

El ejercicio consiste en crear un código cuyo objetivo sea obtener el número PI, o una aproximación de él. Cualquier método para obtener el número PI será válido, aunque para evaluar este reto, me basaré en la "originalidad" o "rareza" del método empleado.
Obviamente, para obtener PI no se podrá utilizar valores "mágicos" o "precalculados" sin dar explicaciones válidas. Por ejemplo, todos sabemos que el (radio x 2 x PI) es el perímetro de la circunferencia, así que una aproximación incorrecta sería dividir el perímetro de una circunferencia ya calculada de antemano por el doble de su radio.

Lo ideal sería crear un método que cuantas mas veces ejecutes, mejor aproximación de PI dará.

Y aquí la música de ambientación: http://www.youtube.com/watch?v=lEpX5NQSEz0

Ale, a currar.

[jonni09lo]

Bueno al ultimo reto me le mido . Siempre he considerado de que la secuencia Fibonacci tiene un impacto importante en todo lo que nos rodea.

Con la secuencia de Fibonacci se puede obtener la siguiente igualdad



Si observamos los denominadores que aparecen en cada una de las fracciones, son cada uno de los términos impares de la sucesión de Fibonnaci comenzando desde la posición número 3 (que equivale al número 2) en adelante.

Bueno dejo el siguiente demo, para quien quiera mejorarlo (quiero trabajar sobre precisiones)...

DEMO1: http://jsfiddle.net/87cFg/

Saludos

[marlanga]

Cuando puse el reto tenía en mente la aproximación de montecarlo, que es tener un círculo de radio 1 inscrito en un cuadrado de lado 2, y llenar el área cuadrada de puntos al azar. El área del cuadrado es lado x lado = 2 x 2 = 4 unidades. El área del círculo es radio * radio * PI = 1 * 1 * PI = PI. La ley de laplace de probabilidad dice que Probabilidad es igual a la cantidad de casos de éxito de las que queremos saber el porcentaje de probabilidad partido por la cantidad de casos totales posibles. Así que aplicado laplace al problema, la probabilidad de que un punto caiga en el círculo es P = area circulo / area cuardrado = PI / 4.

Así que aplicanddo laplace al problema, sabemos que PI / 4 = puntos dentro del circulo / puntos totales.
PI = (puntos dentro del circulo / puntos totales)*4.

Así que cuantos más puntos ponga, mejor aproximación de PI dará.
http://jsfiddle.net/marlanga/GLpcw/

[jonni09lo]

Iniciado por marlanga

Cuando puse el reto tenía en mente la aproximación de montecarlo, que es tener un círculo de radio 1 inscrito en un cuadrado de lado 2, y llenar el área cuadrada de puntos al azar. El área del cuadrado es lado x lado = 2 x 2 = 4 unidades. El área del círculo es radio * radio * PI = 1 * 1 * PI = PI. La ley de laplace de probabilidad dice que Probabilidad es igual a la cantidad de casos de éxito de las que queremos saber el porcentaje de probabilidad partido por la cantidad de casos totales posibles. Así que aplicado laplace al problema, la probabilidad de que un punto caiga en el círculo es P = area circulo / area cuardrado = PI / 4.

Así que aplicanddo laplace al problema, sabemos que PI / 4 = puntos dentro del circulo / puntos totales.
PI = (puntos dentro del circulo / puntos totales)*4.

Así que cuantos más puntos ponga, mejor aproximación de PI dará.
http://jsfiddle.net/marlanga/GLpcw/

Es bastante interesante el código... el único inconveniente que le veo es que requiere muchos puntos para poder tener una mayor precisión y que esta sea constante (cerca de 310.000 puntos para el 3.14 y mas o menos cerca de 80 millones de puntos para el 3.141)

Saludos

[Pantaláimon]

Supongo que el algoritmo será más o menos bueno dependiendo de lo buena que sea la función que te dé los números pseudoaleatorios.

A mi ahora no se me ocurre ninguna solución. Bueno, se me ocurren varias, pero supongo que si no eres el Ramanujan del siglo XXI, todas ya estarán inventadas. Seguiré pensando a ver si le puedo dar un punto de vista distinto a este problema.

[NSD]

Otra forma mucho mas rapida (aunque no hay forma directa de aproximar a n decimales) es mediante funciones trigonometricas.
La formula seria: n * seno (180º / n) < PI < n * tangente (180º / n)

Para n = 3 => 2.598 < PI < 5.196
Para n = 4 => 2.828 < PI < 4
Para n = 5 => 2.938 < PI < 3.632
Para n = 6 => 3 < PI < 3.464
Para n = 10 => 3.09 < PI < 3.249
Para n = 20 => 3.128 < PI < 3.167
Para n = 60 => 3.14 < PI < 3.144
Para n = 90 => 3.14 < PI < 3.142
Para n = 360 => 3.1415 < PI < 3.1416
Para n = 720 => 3.14158 < PI < 3.14161
Para n = 1800 => 3.141591 < PI < 3.141958
Para n = 3600 => 3.1415922 < PI < 3.1415934
Para n = 9000 => 3.14159259 < PI < 3.141592781
Para n = 18000 => 3.141592638 < PI < 3.141592685
y para n = 72000=> 3.141592653 < PI < 3.141592656

el costo del calculo es fijo y la precicion depede de n.

no escribi el fiddle ya es que es solo un calculo matematico simple.

[jonni09lo]

Iniciado por NSD

Otra forma mucho mas rapida (aunque no hay forma directa de aproximar a n decimales) es mediante funciones trigonometricas.
La formula seria: n * seno (180º / n) < PI < n * tangente (180º / n)

Para n = 3 => 2.598 < PI < 5.196
Para n = 4 => 2.828 < PI < 4
Para n = 5 => 2.938 < PI < 3.632
Para n = 6 => 3 < PI < 3.464
Para n = 10 => 3.09 < PI < 3.249
Para n = 20 => 3.128 < PI < 3.167
Para n = 60 => 3.14 < PI < 3.144
Para n = 90 => 3.14 < PI < 3.142
Para n = 360 => 3.1415 < PI < 3.1416
Para n = 720 => 3.14158 < PI < 3.14161
Para n = 1800 => 3.141591 < PI < 3.141958
Para n = 3600 => 3.1415922 < PI < 3.1415934
Para n = 9000 => 3.14159259 < PI < 3.141592781
Para n = 18000 => 3.141592638 < PI < 3.141592685
y para n = 72000=> 3.141592653 < PI < 3.141592656

el costo del calculo es fijo y la precicion depede de n.

no escribi el fiddle ya es que es solo un calculo matematico simple.

Jajajaja pero independientemente de si es un calculo matemático simple esto son desafíos de programación así que antes de que el gato gruñón te de unos azotes has el fiddle

Saludos

[NSD]

Obviamente, para obtener PI no se podrá utilizar valores "mágicos" o "precalculados" sin dar explicaciones válidas.

Como Math.sin y las demas trigonometricas toman sus argumentos en radianes y no en grados, es imposible escribir un algoritmo en javascript que aplique esta forma sin recurrir a la constante Math.pi para realizar la transformcion. Es solo un metodo interesante pero que no se puede emplear debido a la consigna del problema.

No se si hay una forma de pasar de grados a radianes sin PI, si la hay entonces lo que dije antes es erroneo, no obstante si existe la desconozco.

[danny_]

Agrego una solución más al desafío y desde luego también me encantaría sumarme.

Código Javascript:

Array.prototype.unique=function(a){
  return function(){return this.filter(a)}}(function(a,b,c){return c.indexOf(a,b+1)<0
});
 
function getThirthMinorValue(data){
    if(data.length != 0){   
        var unique=data.unique();
     unique.sort();
        
    }else{
        return false;
    }
    return unique[2];
}
 
var collection=[5,2,9,10,8,2,5];
var a=getThirthMinorValue(collection);
 
alert(a);
 

Saludo a todos y feliz año nuevo!

[Pantaláimon]

Al final he optado por utilizar serie de Taylor para aproximarme a pi. La típica sería usar la del arcotangente de 1:

pi = 1 - 1/3 + 1/5 -1/7 ...

Pero al final he optado por calcular la serie de Taylor de la integral de sqrt(1-x²) entre 0 y 1/2 que vale pi/12 + sqrt(3)/8 y converge un poco más rápido:

Código Javascript:

var n = 21;
 
var a = -1;
var b = 2;
var term = 1;
var x = 0.5;
var sum = 0;
for( var i = 0; i < n; ++i ) {
    sum += term*x/(b-1);
    term *= a/b;
    x /= 4;
    a += 2;
    b += 2;    
}
 
var picalc = 12*sum - 1.5*Math.sqrt(3);
console.log( picalc );
console.log( Math.PI );
 

http://jsfiddle.net/BTSzq/

Edit: por cierto, me pareció muy bonita la relación entre pi y los números de Fibonacci. Aunque perdió un poco la magia cuando vi que daba pi básicamente porque 4*arctan(1) = pi. http://www.maths.surrey.ac.uk/hosted....html#piandfib

Un saludo!

[jonni09lo]

@Pantaláimon apenas hoy he visto el link que muestras sobre la secuencia Fibonacci. Es cierto pierde la magia, anque me encantó el link que dejaste, está mucho mejor explicado el funcionamiento de la formula que usé para hacer el calculo.

Saludos