Menú

Mostrar Mensajes

Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.

Mostrar Mensajes Menú

Mensajes - DarK_FirefoX

#411
Programación C/C++ / Re: La palabra mas larga
14 Junio 2015, 15:29 PM
Puedes ir contando los caracteres a medida que recorres la cadena, esto haría que el orden de la complejidad temporal sea de O(n) [orden lineal]

Te dejo un pseudocódigo:

CalculaPalabraMasLarga(cadena)
begin
cadena max = "";
cadena checking = "";
for i=0 to Length(cadena) do
begin
 if(cadena[i]!=' ')
   begin
     concat(checking, checking[i]);
   end
 else
   begin
     if(Length(checking)>Length(max))
       begin
          max = checking;
       end
     checking = "";
   end
end
return max;
end;


Mod: El pseudocódigo está completo, le había dado guardar sin haber terminado de escribirlo :P

Salu2s
#412
Foro Libre / Re: Una peli para ver esta noche?
13 Junio 2015, 05:42 AM
¿Ya vieron Ex-Machina?

Por otro lado, Chappie no me gusto para nada, la terminé de ver por no dejarla a medias, pero la verdad que no fue de mi agrado.
#413
Cita de: Man-In-the-Middle en 12 Junio 2015, 21:12 PM
Falso!
Las barras se instalan , cuando uno ejecuta cualquier setup de un programa gratuito, y le da next, next a los pantallasos de instalacion y bien claro sale ahi, quieres instalar ask en tu computadora? y por  no leer, puff, te clava Ejm  U Catcher, etc

Si, generalmente a veces pasamos de leer los Next Next Next de los setups, pero generalmente siempre se nota cuando sale Ask, no lo instalaría ni jugando. Hace poco pase trabajo desinstalándola en la laptop de un familiar. Actualmente siempre leo los setups (cuando es algo que instalo por primera vez  :silbar:)!

Cita de: dimitrix en 12 Junio 2015, 19:42 PM
pero todos los que tienen esta barra dicen "no sé, yo no hice nada".

Asímismo! Jajaja
#414
Hardware / Re: HDD ¿Alguna idea?
13 Junio 2015, 05:26 AM
Cita de: Orubatosu en 12 Junio 2015, 22:42 PM
Veo un disco duro

O das mas pistas, o no se yo

Pues me dá a que a mi tampoco me dicen nada! O yo no se!  :silbar:
#415
Hardware / Re: Ordenador no arranca
13 Junio 2015, 05:22 AM
Cita de: Javi Metal en 12 Junio 2015, 17:19 PM
Hola de nuevo. Lo he hecho, me ha bastado quitar dos de los 4 módulos que tengo instalados y, al menos de momento, ha vuelto a funcionar. Si hubiese novedades, lo pondré por aquí. Un saludo a todos.

Intenta limpiar esos dos módulos que has quitado y probando combinaciones poniendo uno primero y el otro después, también limpia el slot donde se conecta. Quizás no es que están estropeados, sino que están sucios.

Salu2s
#416
Voy a adentrarme ahora en lo que se conoce por combinatoria, exponiendo ejemplos sencillos y clásicos de esta rama de las matemáticas discretas.

23 - Variaciones con repetición

Lo primero que voy a hacer es poner un ejemplo:

Si quisiéramos hallar todas las variaciones con repetición en secuencias de 3 de este array:

Código (csharp) [Seleccionar]
string[] valores = {"a", "b", "c", "d", "e"};

Obtendríamos el siguiente resultado:

Citara a a
a a b
a a c
a a d
a a e
a b a
a b b
a b c
a b d
a b e
...
...
e e a
e e b
e e c
e e d
e e e

El orden de la complejidad temporal sería un equivalente a NM, siendo N la cantidad de elementos y M el tamaño de la secuencia. Esto es deducible de la posibilidad de por cada espacio de la secuencia (M), en este caso 3, se pueden poner (N), en este caso 5 posibles elementos. Por lo tanto sería 5 * 5 * 5 = 53.

Veamos el código:

Código (csharp) [Seleccionar]
//Variaciones con repetición de N elementos en M
       /// <summary>
       ///  Método portal
       /// </summary>
       static void VariacionesConRepeticion(string[] original, int size)
       {
           VariacionesConRepeticion(original, new string[size], 0);
       }

       static void VariacionesConRepeticion(string[] original, string[] variacion, int pos)
       {
           if (pos == variacion.Length)
           {
               Print(variacion); //Llama al método Print(), el cual lo que hace es imprimir un array en pantalla.
               Console.WriteLine();
           }
           else
           {
               for (int i = 0; i < original.Length; i++)
               {
                   variacion[pos] = original[i];
                   VariacionesConRepeticion(original, variacion, pos + 1);
               }
           }
       }


Primero que todo, veamos que utilizamos un método portal, el cual recibe el array (en este caso es de string para facilidad, pero se puede hacer de cualquier otro tipo incluso lo pueden implementar para que el método sea genérico). Lo otro que recibe es el tamaño de la variación (M) (M<=N) (N -> Cantidad de elementos).

En el método portal llamamos al método recursivo pasándole como parámetro el array original, un array "variacion" vacío con longitud M y una variable "pos" para iterar sobre este array "variacion"

Ahora, veamos, como todo método recursivo, tenemos una condición de parada que se cumplira cuando la variable "pos" (la cual itera sobre "variacion") sea igual al Length del array "variacion" (o lo que es lo mismo, que ya se ha haya rellenado ese array). En este caso, ya tenemos una variación completa, por lo tanto lo que haremos será Imprimirla en pantalla (lo que se haga puede variar de acuerdo al problema que estemos tratando de resolver.

Para imprimirlo en pantalla, utilizamos un método:

Código (csharp) [Seleccionar]
static void Print<T>(T[] array)
       {
           for (int i = 0; i < array.Length; i++)
           {
               if (i == array.Length - 1)
                   Console.Write(array[i]); //Imprimimos el elemento del array es el último elemento
               else
                   Console.Write(array[i] + " "); //Imprimimos el elemento del array más un espacio si no es el último elemento
           }
       }


Ahora, en caso de que no se cumpla la condición de parada significa que todavía estamos "armando" la variación.

Para armar tenemos un ciclo for, que recorre el array "original", y lo que hacemos es asignarle al array "variacion" en la posición "pos" (que itera sobre "variacion") el valor del array original en la posición i (itera sobre el array "original" utilizando el ciclo for.

Luego lo que hacemos es llamar recursivo pasándole al método el array "original", "variacion" y la variable "pos" incrementada en 1 (pos + 1), ya que pusimos un elemento en el array y ahora vamos a poner otro en la siguiente posición.

Voy a poner un ejemplo:

Imaginen el array "original" como había dicho:

Código (csharp) [Seleccionar]
string[] valores = {"a", "b", "c", "d", "e"};

Y ahora, el array "variacion" estaría así en un principio

[ ] | [ ] | [ ]

O sea, vacío

[ a ] | [ ] | [ ]    - pos = 0

[ a ] | [ a ] | [ ]    - pos = 1

[ a ] | [ a ] | [ a ]    - pos = 2

Luego se retorna la llamada y entonces  pos=3, aquí se imprime la variación pues ya está completa. Luego el ciclo for camina y entonces la próxima asignación que se hace es:

[ a ] | [ a ] | [ b ]  - pos = 2

Espero esto se haya entendido.
Si tienen alguna duda pregunten, pues esto a veces es enredado para verlo si no se ha visto alguna vez y/o no entienden bien la recursividad. Sobre todo, también es algo difícil explicarlo así en plan texto.




Seguimos con combinatoria (espero hayan entendido el anterior, pues no explicaré tan a fondo debido a la similitud

24 - Variaciones sin repetición

Este algoritmo es algo parecido, simplemente que no vamos a repetir elementos en cada variación.

Lo primero que voy a hacer es poner un ejemplo:

Utilicemos el mismo array que teníamos en el código anterior:

Código (csharp) [Seleccionar]
string[] valores = {"a", "b", "c", "d", "e"};

Si quisiéramos hallar todas las variaciones sin repetición en secuencias de 3 de este array obtendríamos:

Citara a a
a b c
a b d
a b e
a c b
a c d
a c e
a d c
a d b
a d e
...
...
e a c
e a d
e a b

El orden de la complejidad temporal sería un equivalente a N!/(N-M)!, siendo N la cantidad de elementos y M el tamaño de la secuencia. Esto es deducible de la posibilidad de por cada espacio de la secuencia (M), en este caso 3, se pueden poner (N-1), este caso 4 elementos posibles en la próxima posición, y después en la próxima (N-2), y asi sucesivamente, por lo que quedaría algo como: 5*4*3 = 5*(5-1)*(5-2) = 5!/(5-3)! = N!/(N-M)!

Primero voy a explicar un método que vamos a utilizar aquí. Utilizaremos un método para hacer Swap entre dos elementos. Este método ya lo había explicado anteriormente en otro código, pero este tiene dos peculiaridades diferentes, primero que lo hice genérico para mostrar esto, y segundo que hace el intercambio pero de las referencias.

Este es el código:

Código (csharp) [Seleccionar]
static void Swap<T>(ref T a, ref T b)
       {
           T temp = a;
           a = b;
           b = temp;
       }


Primero explico la palabra clave (keyword) ref. Esta palabra clave a un argumento causa que el argumento sea pasado al método por referencia y no por valor. El efecto de pasar un argumento por referencia implica que cualquier cambio que se realice al parámetro dentro del método es reflejado en el argumento en el método desde cual fue llamado.

Para llamar a un método pasándole un argumento por referencia se haría algo así:

Código (csharp) [Seleccionar]
static void Main(string[] args)
{
    int numberOne = 1;
    Inc(ref numberOne);
    Console.WriteLine(numberOne); //El valor que se imprimirá será 2
}

public static void Inc(ref int number)
{
    number++;
}


Ahora, que el método sea genérico, implica que se utilizará un placeholder, dentro de todo el método para las operaciones con este tipo de datos dentro del método. Se podrá utilizar el método con cualquier tipo de dato siempre que no cause error en tiempo de ejecución de acuerdo a la función que se realice con él. Genéricas pueden ser clases, estructuras, interfaces y métodos.

Esto es una forma EXTREMADAMENTE lazy de explicarla, recomiendo ir a la MSDN para leer sobre esto.

Una vez visto, solo resta decir sobre este método que funciona intercambiando las referencias de las variables.

Ahora veamos el método como tal:

Código (csharp) [Seleccionar]
//Variaciones sin repetición de N elementos en M
       /// <summary>
       ///  Método portal
       /// </summary>
       static void VariacionesSinRepeticion(string[] original, int size)
       {
           VariacionesSinRepeticion(original, size, 0);
       }

       static void VariacionesSinRepeticion(string[] original, int size, int pos)
       {
           if (pos == size)
           {
               Print(original, size);
               Console.WriteLine();
           }
           else
           {

               for (int i = pos; i < original.Length; i++)
               {
                   Swap(ref original[pos], ref original[i]);
                   VariacionesSinRepeticion(original, size, pos+1);
                   Swap(ref original[pos], ref original[i]);
               }
               
           }
           
       }


Primero que todo démonos cuenta que es bastante parecido al otro método (VariacionesConRepeticion()). Tenemos el método portal y el método recursivo, pero vemos que solo trabajamos sobre un array, pues por eso utilizamos un método Swap para hacer intercambio de valores (que después lo volvemos a intercambiar para ponerlos en la posición original. Tenemos la condición de parada que se cumple cuando "pos" sea igual al tamaño (M) de la variación que viene dado por la variable "size"

Ahora, hay un pequeño cambio en el ciclo for, y es que el ciclo no empieza con la variable i en 0, sino que empieza con el valor de "pos". Y se hace un Swap antes del llamado recursivo y uno después, el cual pone los valores en la posición anterior a cambiarlo. Igual que en el método anterior se llama recursivo incrementando la variable "pos"

Veamos un ejemplo utilizando el siguiente array y calculando las variaciones con tamaño 3:

Código (csharp) [Seleccionar]
string[] letras = { "a", "b", "c" };

Como trabajamos sobre le array "original", el mismo estaría así al principio:

[ a ] | [ b ] | [ c ] - i= 0 y pos = 0
[ a ] | [ b ] | [ c ] - i= 0 y pos = 1
[ a ] | [ b ] | [ c ] - i= 0 y pos = 2

[ a ] | [ b ] | [ c ] - i= 0 y pos = 3 (Se cumplió la condición de parada y por lo tanto se tiene una variación, se imprime)

Luego, cuando se retorne el llamado tenemos a pos = 2 e i = 2 y cuando se incremente en el ciclo no se va a cumplir la condición del ciclo, va a terminar y va retornar la llamada, donde tendremos a pos = 1 e i = 1. Aquí ahora se va a incrementar i, pues va a cumplirse la condición del ciclo y tendremos a pos = 1 e i = 2, y por lo tanto se va a hacer el Swap y va a quedar así:

[ a ] | [ c ] | [ b ] - i= 2 y pos = 1

Y después de se cumplirá la condición de parada y tendremos la variación lista. Así es prácticamente el funcionamiento del algoritmo, les recomiendo que le hagan un Debug Step-By-Step para entenderlo mejor.

Nota: Como ven en ningón momento tenemos una variación en un array nuevo, si nuestro problema requiere devolver esta variación debemos hacer una copia del array original a uno nuevo copiando "size" elementos.

Código (csharp) [Seleccionar]
string[] destino = new string[size];
Array.Copy(original, destino, size);





25 - Combinaciones

Primero que todo, veamos un ejemplo:

Si quisiéramos hallar todas las combinaciones posibles de secuencias de 5 de este array:

Código (csharp) [Seleccionar]
string[] valores = {"a", "b", "c", "d", "e"};

Obtendríamos:

Citara b c d e

En caso de que quisiéramos hallarlas en secuencias de 3, obtendríamos:

Citara b c
a b d
a b e
a c d
a c e
a d e
b c d
b c e
b d e
c d e

Consideremos cada secuencia un subconjunto del conjunto original (el array valores). Cada uno de estos subconjuntos son diferentes dos a dos.

Llamemos "combinaciones" a todas las formas posibles de tomar un subconjunto de elementos de un conjunto con un tamaño predefinido donde ninguno de estas formas son iguales y cada subconjunto no repite elemento.

Nota: Tengan en cuenta que vamos a utilizar el método Print() que declaramos y utilizamos arriba (Variaciones con repetición)

Como en casos anteriores vamos a tener un método portal, al cual le pasaremos como parámetro el array con los elementos. Ambos métodos los declaré genéricos. Repito, para entender mejor cómo funciona la genericidad de parámetros les recomiendo ir a la MSDN

Código (csharp) [Seleccionar]
        /// <summary>
        /// Método portal
        /// </summary>
        static void Combinaciones<T>(T[] letras, int m)
        {
            Combinaciones(letras, new T[m], 0, 0);
        }


Esté método recibe como parámetro el array con los elementos y un int que representa el tamaño de las combinaciones a buscar. Este int debe ser menor o igual que la cantidad de elementos del array. Por lo tanto les recomiendo que hagan una validación a este parámetro en el método portal.

El método recursivo recibe 4 parámetros, dos array y dos int. El primer array es el original, el segundo es el array para ir creando cada combinación, por lo tanto lo que se le pasa es un array nuevo con tamaño igual al int que recibió el método portal (new T[m]]. Ahora, los int que recibe son para iterar sobre los array original y combinacion respectivamente.

Luego, veamos el código del método recursivo:

Código (csharp) [Seleccionar]
static void Combinaciones<T>(T[] original, T[] combinacion,
            int posOriginal, int posCombinacion )
        {
            if (posCombinacion == combinacion.Length)
            {
                Print(combinacion); //Imprimimos la combinación
                Console.WriteLine(); //Hacemos un salto de linea en la consola
            }
            else if (posOriginal == original.Length)
                return;
            else
            {
                combinacion[posCombinacion] = original[posOriginal];
                Combinaciones(original, combinacion, posOriginal + 1, posCombinacion + 1);
                Combinaciones(original, combinacion, posOriginal + 1, posCombinacion);
            }
        }


En este método lo primero que hacemos es establecer las condiciones de parada (para la recursividad).

La primera es si se completó una combinación, por lo tanto vemos que la variable que itera sobre el array combinacion llego a la longitud del array. En tal caso, imprimimos la combinación.

La segunda condición es si ya se utilizaron todos los elementos originales en las combinaciones que antecedían con un elemento fijo.

Veamos un ejemplo de cómo funcionaría la otra parte del código:

Supongamos que el array original es:

Código (csharp) [Seleccionar]
string[] original = {"a", "b", "c", "d", "e"};

Antes de que se ejecute la línea:

Código (csharp) [Seleccionar]
combinacion[posCombinacion] = original[posOriginal];

Tendremos el array combinacion:

[ null ] | [ null ] | [ null ]

Luego:

[ a ] | [ null ] | [ null ]

Luego se ejecutará el llamado recursivo:

Código (csharp) [Seleccionar]
Combinaciones(original, combinacion, posOriginal + 1, posCombinacion + 1);

Y despues tendremos esto:

[ a ] | [ b ] | [ null ]

[ a ] | [ b ] | [ c ]

Y al llamar recursivo se cumplirá la primera condición de parada pues ya tenemos la primera combinación. Luego al salir de la recursividad, se llama recursivo de nuevo:

Código (csharp) [Seleccionar]
Combinaciones(original, combinacion, posOriginal + 1, posCombinacion);

Pero esta vez solo incrementamos la variable que itera sobre el array original. Por lo tanto esa variable estará apuntando al elemento (d) del array original

Y tras hacer:

Código (csharp) [Seleccionar]
combinacion[posCombinacion] = original[posOriginal];

Tendremos:

[ a ] | [ b ] | [ d ]

Luego:

[ a ] | [ b ] | [ e ]

Y Luego se cumplirá la segunda condición de parada, por lo tanto saldremos de la recursividad hasta que la variable que itere por el array combinacion este sobre el elemento 1.

Todo ira funcionando de esa manera.

Espero que se entienda, es un poco enredado, pero una vez que le hagas un step-by-step debug lo entenderán.




Luego continúo con los códigos.

Salu2s
#417
Cita de: dimitrix en 12 Junio 2015, 14:57 PM

Pero... ¿Y si lo miramos con la felicidad que logran con la tecnología que tienen?

La pregunta es ¿Ahora la gente es más feliz con la Nintendo 3Di que con la primera Game Boy?

Pues claro, la felicidad no está supeditada al consumismo tecnológico. De hecho la tecnología en ocasiones te priva de momentos felices relacionándote con personas y ha cambiado un poco la manera de relacionarte.

Solo que en cuanto a tecnología en las telecomunicaciones, si que están un poco atrasado. En cuanto a equipos de cómputo y/o videojuegos no tanto. Siempre se las ingenian para importarlas al país. Aunque si, no de manera comercial, sino más bien personal.

Salu2s
#418
Cita de: engel lex en 12 Junio 2015, 05:44 AM
no tanto... la regla del foro "está bien en el subforo, siempre que no haya uno más especifico", ejemplo...

está Programación General, Desarrollo Web, Scripting, Python y Java

si estás haciendo una web en java donde va? o si es un script web en python?



En parte es cierto, pero creo que dependería del enfoque de la pregunta! Si estás haciendo una web en Java y tu pregunta va enfocada a una duda de sintaxis de Java, creo que iría en Java, pero si la pregunta se trata sobre algo web (utilizando Java) iría en Desarrollo Web. Eso ya es cuestión del creador del tema.

Pero creo, que un subforo tan amplio crearía "confusión". Desde mi punto de vista con el "Foro Libre" por ahora está bien. Hace que el enfoque del foro sea más preciso.

Repito, lo que digo es solo mi opinión. Sea lo que sea, será bienvenido.

Salu2s
#419
Cita de: dimitrix en 12 Junio 2015, 05:26 AM
Nosotros teníamos la Encarta, ellos tienen la Wikipedia bajada en cada PC ^^

Pues yo tuve Encarta (en CDs, todavía la tengo por ahí, eran como 4 CDs) y ahora tengo Wikipedia también bajada en la PC, gracias Kiwix! xD  :silbar:

Nada, lo cierto que se puede decir que están años atrás en muchas cosas tecnológicas. Pero poco a poco creo que irán avanzando en eso!

Salu2s
#420
Desde mi punto de vista lo veo algo redundante, pues que pasa, "la ciencia y la tecnología" es muy amplia! De hecho: la informática es una ciencia! la física es una ciencia, la biología es una ciencia. Al crear un subforo de "Ciencia y Tecnología" creo que estaría algo desorganizando, de hecho, sería algo recursivo, pues ahi adentro estaría "bien" hablar de cualquier cosa de lo que se habla en el foro!

No creen?

Salu2s