elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Guía rápida para descarga de herramientas gratuitas de seguridad y desinfección


  Mostrar Temas
Páginas: [1]
1  Programación / .NET (C#, VB.NET, ASP) / calculadora por jerarquia ()*/+- ...C#... en: 30 Julio 2009, 05:41 am
es una calculadora basica lo unico que hace es operaciones por jerarquia como las calculadoras de mano donde primero resuelve las operaciones dentro de los parentesis en su orden de jerarquia */+- y asi va destruyendo parentesis hasta desmenusar todo lo digitado, para mayor funcionalidad lee toda la expresion de una vez.

orden primero las multiplciaiciones y diviciones y luego las sumas y las resta



codigo
Código:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace comienzo
{
    class parte3
    {
        
        public void imprimir(string [] operacion)
        {
            /*Console.Clear();
            byte posx = 5;
            for (int i = 0; i <= 19; i++)
            {
                Console.SetCursorPosition(posx, 6); Console.WriteLine(operacion[i]);
                posx += 1;
            }*/

            Console.SetCursorPosition(18,6); Console.WriteLine("Resultado = " + operacion[1]);
            Console.ReadKey();
        }///fin  public void imprimir
      
    }

    class partedos
    {
      

        public void buscaresp(byte pcdo, byte pato, string[] operacion)///busca los espacion dentro del parentesis
        {
            string cambio;
            pcdo -= 2;
            
            for (; pato <= pcdo; pato++) ////for 1-3
            {
                if (operacion[pato] == " ")////if 1-3
                {
                     pato += 2;
                     cambio = operacion[pato];
                     pato -= 2;
                     operacion[pato] = cambio;
                     pato += 2;
                     operacion[pato] = " ";
                     pato -= 2;
                }///fin if 1-3
            }////fin for 1-3

            

            //Console.WriteLine(operacion[2]);
        
        }///fin buscaresp


        public void organiza(byte pcdo, byte pato, string[] operacion)////organiza toda la expresion quitando los espacios en blanco
        {
            byte ultimo = 0; string cambio; byte posb =0;
            pcdo = 19;
            while (pcdo >= 1)
            {
                ultimo = pcdo;
                while (ultimo >= 1)
                {
                    posb = Convert.ToByte(ultimo - 1);
                    if (posb != 255)
                    {
                        while ( ((posb != 255) &&(posb >= 0) ) && (operacion[posb] == " ") )
                        {
                            cambio = operacion[ultimo];
                            operacion[posb] = cambio;
                            operacion[ultimo] = " ";
                            posb--;
                        }///fin while que bsuca las posiciones vacias
                    }
                    ultimo--;

                }///fin while que busca desde el ultimo      

                pcdo--;
            }///fin pcdo

           // Console.WriteLine(operacion[2]);
        }///fin opublic void organiza

        
        public void parentesis (string [] operacion, byte pfin)
        {
            byte abierto = 0, pcdo = 0, pato = 0,a,b,k,contar;  ///k revisa la operacion antes del aprentesis
            double x=0, y=0, resultado=0;
            partedos organizar = new partedos();
            partedos acomodar = new partedos();

            while(abierto==0)///while1---crear un siclo que busque lso parentesis si no los hay coloca el abierto en 0
            {
                for (byte i = 0; i <=pfin ; i++)///for que recorre////cambiar por un while
                {
                    if ( (operacion[i] == "(") )//if-1
                    {
                        pato = i; pcdo = i; pcdo += 1;
                        while( (operacion[pcdo] !="(") && (operacion[pcdo]!=")"))//while que busca la termiancion dle aprentesis
                        {
                            pcdo += 1;
                        }///fin while que bsuca la termiancion del aprentesis

                        if (operacion[pcdo] != "(")
                        {
                            byte j=Convert.ToByte (pato + 1);
                            for (; j <= pcdo;j++ )///for-2 como primeor se realizan las * & / hago este for
                            {
                                if (operacion[j] == "*")//if-2
                                {
                                    a = j; b = j;
                                    a -= 1; b += 1;
                                    x = Convert.ToDouble(operacion[a]); y = Convert.ToDouble(operacion[b]);
                                    resultado = x * y;

                                    //// ahora escribo el resultado en la posicion  anteriro al asterisco
                                    //// & borro las otras dos posiciones                            /**/
                                    /**/ a = j; b = j;                                              /**/
                                    /**/ a -= 1; b += 1;                                           /**/
                                    /**/ operacion[a] = Convert.ToString(resultado);              /**/
                                    /**/ operacion[j] = " "; operacion[b] = " ";                 /**/
                                    ////////////////////////////////////////////////////////////////
                                    j = a;
                                    organizar.buscaresp(pcdo, pato, operacion);
                                    acomodar.organiza(pcdo, pato, operacion);
                                    pcdo -= 2;
                                }//fin if-2
                                else
                                {
                                    if (operacion[j] == "/")//if-3
                                    {
                                        a = j; b = j;
                                        a -= 1; b += 1;
                                        x = Convert.ToDouble(operacion[a]); y = Convert.ToDouble(operacion[b]);
                                        resultado = x / y;

                                        //// ahora escribo el resultado en la posicion  anteriro al asterisco
                                        //// & borro las otras dos posiciones                            /**/
                                        /**/ a = j; b = j;                                              /**/
                                        /**/ a -= 1; b += 1;                                           /**/
                                        /**/ operacion[a] = Convert.ToString(resultado);              /**/
                                        /**/ operacion[j] = " "; operacion[b] = " ";                 /**/
                                        ////////////////////////////////////////////////////////////////
                                        j = a;
                                        organizar.buscaresp(pcdo, pato, operacion);
                                        acomodar.organiza(pcdo, pato, operacion);

                                        pcdo -= 2;
                                    }//fin if-3
                                    
                                }///fin else que em conduce a la divicion
                                
                            
                            }///fin for-2
                             ///



                            ////////////////operaciones segundarias
                            j = Convert.ToByte(pato + 1);
                            for (; j <= pcdo; j++)///for-3 con este for realizo las operaciones segundarias
                            {
                                if (operacion[j] == "+")//if-4
                                {
                                    a = j; b = j;
                                    a -= 1; b += 1;
                                    x = Convert.ToDouble(operacion[a]); y = Convert.ToDouble(operacion[b]);
                                    resultado = x + y;

                                    //// ahora escribo el resultado en la posicion  anteriro al asterisco
                                    //// & borro las otras dos posiciones                            /**/
                                    /**/ a = j; b = j;
                                    /**/ a -= 1; b += 1;                                           /**/
                                    /**/ operacion[a] = Convert.ToString(resultado);              /**/
                                    /**/ operacion[j] = " "; operacion[b] = " ";                 /**/
                                    ////////////////////////////////////////////////////////////////
                                    j = a;
                                    organizar.buscaresp(pcdo, pato, operacion);
                                    acomodar.organiza(pcdo, pato, operacion);
                                    pcdo -= 2;
                                }//fin if-4
                                else
                                {
                                    if (operacion[j] == "-")//if-5
                                    {
                                        a = j; b = j;
                                        a -= 1; b += 1;
                                        x = Convert.ToDouble(operacion[a]); y = Convert.ToDouble(operacion[b]);
                                        resultado = x - y;

                                        //// ahora escribo el resultado en la posicion  anteriro al asterisco
                                        //// & borro las otras dos posiciones                            /**/
                                        /**/ a = j; b = j;                                              /**/
                                        /**/ a -= 1; b += 1;                                           /**/
                                        /**/ operacion[a] = Convert.ToString(resultado);              /**/
                                        /**/ operacion[j] = " "; operacion[b] = " ";                 /**/
                                        ////////////////////////////////////////////////////////////////
                                        j = a;
                                        organizar.buscaresp(pcdo, pato, operacion);
                                        acomodar.organiza(pcdo, pato, operacion);
                                        pcdo -= 2;
                                    }//fin if-5

                                }///fin else que em conduce a la divicion


                            }///fin for-2
                            ///


                            ///////////////fin for-3
                            if (pato >= 1)
                            {
                                k = Convert.ToByte(pato - 1);
                                if (operacion[k] == "+" || operacion[k] == "(" || operacion[k] == ")" || operacion[k] == "-" || operacion[k] == "*" || operacion[k] == "/")
                                {
                                    operacion[pato] = " "; operacion[pcdo] = " ";
                                    acomodar.organiza(pcdo, pato, operacion);

                                }
                                else
                                {
                                    operacion[pato] = "*"; operacion[pcdo] = " ";
                                    acomodar.organiza(pcdo, pato, operacion);
                                }
                            }///fin pto>=1
                              
                               //Console.SetCursorPosition(15, 12); Console.WriteLine(operacion[0]);
                            contar=0;
                            for (int z = 0; z <= 19; z++)///for que busca haber cuantos parentesis hay
                            {
                                if (operacion[z] == "(")
                                {
                                    contar++;
                                }
                            }///fin for que busca haber cuantos parentesis hay

                            if (contar == 1)  abierto = 1;

                        }///fin si del parentesis != abierto
                         ///


                        ///como termino las operaciones dentro de los parentesis los borro
                        
                    }///fin if-1
                }///fin for que recorre
            }///fin while1

        }///fin public void parentesis
    
    }///fin class partedos

    class parteuno
    {
        static void Main(string[] args)
        {
            Console.Title = ("calculadora jerarquica----Clipto");
            string [] operacion = new string[23];
            byte pos = 1,pfin=0;
            string temp1,temp2=" ";
            partedos enviar = new partedos();
            parte3 final = new parte3();

            operacion[0] = "("; operacion[19] = ")";

            do
            {
                temp1 = Convert.ToString(Console.ReadKey().KeyChar);

                if (temp1 != "\r")
                {
                    if (temp2 == " ")
                    {

                        if (temp1 == "+" || temp1 == "(" || temp1 == ")" || temp1 == "-" || temp1 == "*" || temp1 == "/")
                        {
                            operacion[pos] = temp1;
                            pos++;

                        }
                        else
                        {
                            operacion[pos] = operacion[pos] + temp1;
                        }

                    }///fin temp2==" "
                    else
                    {
                        if (temp1 == "+" || temp1 == "(" || temp1 == ")" || temp1 == "-" || temp1 == "*" || temp1 == "/")
                        {
                            if (temp2 == "+" || temp2 == "(" || temp2 == ")" || temp2 == "-" || temp2 == "*" || temp2 == "/")
                            {
                                operacion[pos] = temp1;
                                pos++;
                            }
                            else
                            {
                                pos++; operacion[pos] = temp1; pos++;
                            }

                        }
                        else
                        {
                            operacion[pos] = operacion[pos] + temp1;
                        }
                    }//fin else de temp2==" "


                }///fin temp1 != /r
                else
                {
                    pfin = pos;
                }

                temp2 = Convert.ToString(Console.ReadKey().KeyChar);
                if (temp2 != "\r")
                {
                    if (temp2 == "+" || temp2 == "(" || temp2 == ")" || temp2 == "-" || temp2 == "*" || temp2 == "/")
                    {
                        if (temp1 == "+" || temp1 == "(" || temp1 == ")" || temp1 == "-" || temp1 == "*" || temp1 == "/")
                        {
                            operacion[pos] = temp2;
                            pos++;
                        }
                        else
                        {
                            pos++; operacion[pos] = temp2; pos++;
                        }

                    }
                    else
                    {
                        operacion[pos] = operacion[pos] + temp2;
                    }


                }///fin temp2 != /r
                else
                {
                    pfin = pos;
                }

            } while ((pos < 19) && (temp1 != "\r") && (temp2 != "\r"));

           /* Console.SetCursorPosition(2, 4);Console.WriteLine(" ------ ");
            for (int i = 0; i <= 9; i++)
            {
                
                Console.WriteLine(operacion[i]);

            }*/


            enviar.parentesis(operacion,pfin);
            final.imprimir(operacion);

            Console.Clear();
            byte posx = 5;
            for (int m = 0; m <= 19; m++)
            {
                Console.SetCursorPosition(posx, 6); Console.WriteLine(operacion[m]);
                posx += 1;
            }
            //Console.ReadKey();
        }///fin main
    }///fin class
}///fin namespace


Nota: para hacerlo ultilice vectores no se me ocurrio +nada, si alguien sabe de otro metodo me comenta
2  Programación / .NET (C#, VB.NET, ASP) / Simulador de encuestas autopersonalizables en: 1 Marzo 2009, 17:25 pm
Nota: un programa de encuestas autopersonalisables consiste en q el usuario encargado de administrar el programa pueda decir q la pregunta1 es respondia por el usuario & q la pregunta 2 es de selección múltiple con única respuesta & así sucesivamente.
 Aplicando la Logica del calculo, la cual aplique tanto para programar el simulador la hare para explicarlo
 Vamos
 Primero q todo: tengo un amigo q me conto q tenia q hacer un programa para una compañía X, q se encarga de hacer encuetas en las distintas partes de colombia, y me dijo q el programa consistía en generar encuestas en ambiente web para q las personas las pudieras hacer desde internet y una aplicación extra par alos blackberrys para q la pudieras ejecutar en los pueblos donde se cae el internet & muchas cosas mas como se deben imagina, de ahi viene el nombre simulador ya q a mi me causo intriga lo de las "encuestas autopersonalisables" & lo mio esta echo en C#, y además solo es un algoritmo q implemente para generar tales encuestas.
- ahora yo no uso BD ya q solo es un simulador, solo ultilizo vectores & matrices ya verán porq.
Leer mas http://rapidshare.com/files/203870200/Planteamiento.pdf
agrego una imagen del programa

 

Nota: es el primer programa q hago orientado objeto donde aplico las clases,  claro no es gran nivel porq ya entre a la u & no me dio tiempo de seguir leyendo msdn pero ami me guta bastante el modo enq trabaje, creo q le saque el jugo alo q leei,

post original en: http://proyeccionclipto.blogspot.com/

3  Media / Multimedia / grabar conferencia en: 20 Enero 2009, 21:42 pm
pues miren mi problema es que estoy trantando de grabar una conferencia & pues lacalidad de la imagen y audio no es muy buena, estoy usando cantasia y con las cofiguracions que leei enun tuto pero aun asi no funciona la url es:
https://www112.livemeeting.com/cc/microsoft/viewFormatHFF/6htqmwlqlf22zt0s/Engine/Default.htm?https%3A%2F%2Fwww112.livemeeting.com%2Fcc%2Fmicrosoft%2FviewFormatHFF%2F6htqmwlqlf22zt0s%2F

es programacion con C#  pero no veo modo de poder guardar estas conferencias agradezco alguien pueda ayudarme

nota: tambien tengo la opcion de reproducirlo con el reproductor de windows pero no se si se pueda ir grabando el video miestras se reproduce
4  Programación / .NET (C#, VB.NET, ASP) / Modificadores de acceso en Visual Studio.NET by clipto en: 6 Enero 2009, 00:57 am
MODIFICADORES DE ACCESO By Clipto

Modificadores de Acceso de una Clase (Encapsulamiento):
Para empezar hare referencia a algo del curso 5 estrellas de Microsoft no del mismo modo pero trata de reflejar la misma idea, y es lo siguiente: En el mundo de programación y de acuerdo a las actuales tendencias, imaginemos que vamos manejando un carro “personalmente quisiera que fuere verdad pero en fin…”, ahora sabemos que este posee motor, pistones  y un gran número de elementos que son los encargados de que este funcione, todos estos aparatos como les venía diciendo dado a las tendencias actuales estos son simplemente objetos, y el compartimiento que contiene estos objetos es una clase “Compartimiento mencionado: donde va el motor y esas cosas, no lo menciono porque no sé cómo se llama” , en fin, para nosotros saber manejar no necesitamos saber cómo funciona esa  clase, ósea cual es su comportamiento, solo necesitamos algo que nos haga referencia a esa clase “esa parte del carro”, y que la podamos hacer funcionar, creo que se puede entender la idea del ejemplo, ahora lo explicare un de una forma más compleja. Entre los pilares de la programación orientada a objetos tenemos, Abstracción, Relaciones, Herencia, & el tema a tratar Encapsulamiento, El cual básicamente nos permite abstraer el código de una clase del resto de mundo “de las demás clases”, ¿se preguntaran aja y porque es un pilar de la POO o porque es tan importante? si recordamos el ejemplo del carro el encapsulamiento es el que nos permite que podamos usar una clase sin tener que saber que ocurre dentro de esta o como funciona, lo que en el ejemplo nos permitiría manejar el carro sin ser mecánicos, ahora los modificadores de acceso son los que nos permiten saber qué acceso podemos tener a una clase X, ya definido esto podemos pasar a decir cuáles son los modificadores de acceso  existentes  que puede tener una clase:
1.   Public (publico): como su nombre lo indica, con este modificador estaríamos indicando una clase de tipo publica es decir que desde cualquier otra clase o lo que sea podemos tener acceso a los miembros públicos de esta clase.
2.   Protected (protegido): MSDN lo considera un tipo de acceso derivado, pero ¿por qué derivado? Pues miren al ser un tipo de acceso protected solo esa clase puede tener acceso al elemento protegido,  y, lo derivado porque también una clase derivada de esta “herencia”  puede tener acceso a estos miembros protegidos.
3.   Prívate (privado): esto realmente hace referencia a su nombre, porque solo la clase puede ver sus propios elementos privados, es decir solo esta tiene acceso a tales elementos.
4.   Paquete: pues no sabría darles una definición distinta a la que leí, y es que es una clase que solo puede ser accedida desde el mismo árbol de paquete, es decir una biblioteca. dll, o un .exe.

La otra parte esta en el PDF, es que por las imagenes es mejor leerlos en el pdf original http://rapidshare.com/files/180190792/MODIFICADORES_DE_ACCESO.pdf
5  Programación / .NET (C#, VB.NET, ASP) / introduccion a .NET by CBX en: 6 Enero 2009, 00:56 am
El siguiente texto es para explicar que es .net, cabe aclarar esto porque pueden haber personas que se hayan confundido y piensan que es una introducción a la programación en .net.  ¿Por qué ha de haber un texto como este?, es sencillo nos mostrara con más claridad en que es lo que estamos trabajando, sabremos que lo componen  como y cuál es la función de cada componente lo cual nos dará mas destreza a la hora de trabajar con .Net
DEFINICION DE  .NET: hay personas que suelen decir que .net es un lenguaje de programación incluso yo lo creía así, entonces como primera parte lo que haremos será quitarnos todas estas ideas y para ello empezaremos diciendo que no es .NET
Definición formal, complementada con la información dada por Microsoft:
1.   .Net no es un sistema operativo: bueno creo que ya esa sería la última opción que se nos ocurriría porque bien conocemos lo que es un S.O  y los podemos identificar además sabemos que .net no cumple ninguna de estas cualidades
2.   .Net no es un producto que se pueda comprar como tal:  debido a la definición que daremos mas adelante nos daremos cuenta que este en realidad no es un producto como tal, sino que es un conjunto de aplicaciones y servicios por lo que podemos deducir que el concepto de .net va mas allá de un simple producto
3.   .NET no es un entorno de de desarrollo: desde aquí no podemos ir haciendo una idea breve de lo que es .NET, miren .NET no es un entorno de desarrollo, pero .NET incluye distintos entornos de Desarrollo llamados también IDES, tampoco es decir entonces que .NET es un conjunto de entorno de desarrollo jajá, porque aun el concepto de .net va mas allá.
4.   .NET no es un lenguaje de programación: al igual que hablamos de entornos de desarrollo contenidos en .net podemos enseguida deducir porque este no es un lenguaje de programación, sino que este contiene distintos lenguajes de programación que nos permitirán desarrollar aplicaciones según la necesidad, aclarando nuevamente que el concepto de .NET va mas allá.
Creo que hasta el momento nos hemos hecho una definición más clara al hablar de lo que no es .NET y hemos borrado todas aquellas ideas que teníamos sobre lo que pensábamos que era .NET, desde este momento mostraremos lo que en realidad es .NET
¿QUE ES .NET?: .NET es una plataforma de desarrollo estrictamente orientada a objetos compuesta por distintos elementos que por la abreviación que pretende tener este articulo no serán definidos solamente nombrados, buscando con esto tener una IDEA BASICA pero clara de lo que es .NET
1.   Entorno de ejecución (Runtime).
2.   Bibliotecas de funcionalidad (Class Library).
3.   Lenguajes de Programación.
4.   Compiladores.
5.   Herramientas de desarrollo (IDE & Tools).
6.   Guías de arquitectura.
y lo más importante es que

7.   .NET es La evolución de la plataforma COM: Al ser esto tan importante para la definición de lo que es  .NET esta será definida atreves de un cuadro comparativo de lo que era la COM y de lo que ahora es .NET



Pues pensaba dejarlo hasta aquí pero debido a la mucha info que falta para  hacernos una idea clara no solo de lo que es .net sino de cómo trabaja decidí extender un poco el artículo, que aunque sé que es un poco largo le recomiendo a los lectores seguir el curso de este articulo que bien pagara el tiempo que hemos  gastado leyendo el tema.

¿QUE ES EL CLR?:  la única definición formal que se debe tener en cuenta es que el CLR es el que nos determina la arquitectura de ejecución de cualquier programa desarrollado en cualquiera de los IDES soportados por .NET o en pocas palabra como dice Microsoft el CLR  es  el motor de ejecución (Runtime o maquina virtual) de .NET,  pero se preguntaran aja y cómo funciona el tal CLR,  pues miren el CLR cumple ciertas características que serán resumidas pero antes de eso hablemos de su arquitectura de ejecución, como ya definimos .NET es la evolución de la COM la cual funciona con Windows pero en .NET las aplicaciones corren por encima del sistema operativo de es que se encarga el CLR esto trae muchas ventajas ya que Windows no controla el siclo de vida de estas aplicaciones además ningún error  producido en estas aplicaciones debe afectar a las otras ya que todo el soporte lo da el CLR, aplicaciones ahora un detalle también importante es saber que los componentes de software ejecutados de esta manera (por medio  del CLR) se llaman componentes manejados. Ahora sin más rodeo vamos directo al grano, la arquitectura de ejecución de las aplicaciones es la siguiente:

Componentes Manejados >>>Servicios  y Apis  del entorno de ejecución intermedio (CLR)>>>>Servicios y Apis del S.O>>>Hardware.

Seguro muchos dirán que por el CLR, nuestro equipo no soportara tanto gasto de memoria pues les informo que no es así, entornos como .NET hacen parte de la actualidad y lo más usado en los próximos años y se darán cuenta  las características que posee el CLR nos muestran que es al contrario y que no hay tanto gasto de memoria sino mas bien, ejecución controlada observen.

Características del CLR:
1.   Compilación Just-In-Time (JIT): nuestra primera característica nos mostrara que en realidad no hay tanto gasto de memoria ya que just-in-time significa justo a tiempo queriendo decir con esto que el CLR se encarga de compilar las aplicación de la plataforma .Net en el momento que se necesite evitando con esto el gasto de RAM innecesario.
2.   Garbaje  Collector: este sirve para la gestión automática de memoria, como muchos ya sabe esto quiere decir recolector de basura, y para los que no saben los recolectores de basura se encargan de liberar periódicamente la memoria de procesos que ya no están siendo usados por ninguna aplicación. Ahora ven lo interesante de la plataforma .NET nos llena de muchas ventajas a nuestro favor ya que el usuario no tendrá que estar pidiendo liberación de memoria por miedo de que sus procesos llenen toda la RAM y se bloquee el equipo.
3.   Gestión de errores: ya que los aplicaciones desarrolladas en la plataforma .NET son componentes manejados por el CLR (Runtime) lo errores producidos en tiempo de ejecución no serán  atrapados por el sistema operativo  causando problemas con otras aplicación sino que estos errores serán atrapados por el CLR.
4.   Gestión de Seguridad: permite establecer reglas de seguridad con las que serán ejecutadas las aplicaciones de .Net en una determinada maquina.
Para terminar la introducción al CLR cabe destacar que el proceso de compilación del CLR produce código MSIL, el MSIL es un conjunto de instrucciones que pueden ser convertidas a código nativo muy eficientemente.

Bueno para no alargar el tema dejemos hasta aquí, para algunos ha sido bueno hacerse una idea de que es y cómo trabaja en parte .NET, pero para los que quieran mas información resumida como la anterior pueden pedir que se continúe la introducción y eso hare o hará cualquier user del foro, espero les haya gustado el articulo y por favor dejar sus comentarios con el cual podremos sentir que hicimos bien o que debemos profundizar o cambiar algunos aspectos del articulo.
Comunidad: Tooltipsweb.net
Autor: Clipto

Descargar en pdf http://rapidshare.com/files/180189849/introduccionapuntonet.pdf
6  Programación / .NET (C#, VB.NET, ASP) / Reversi en consola en: 31 Diciembre 2008, 06:13 am
muchos ya conosen lo que es el reersi en internet de windows pues este es una pequeña  aplicasion de este juego pero en consola C· multijugador por ser la primera version, el mio se ve algo asi:





Contenido del .rar:
-Manual de juego
-Algoritmo
-Codigo

url de descarga:http://rapidshare.com/files/178339224/comefichas.rar.html

bueno como dije toda la info esta en el .rar y dejo hasta aqui antes qeu se caiga la conexion.
PD: ayudenme con su opinion a corregir posibles fallos, Leer el manual para orientarse en como se debe jugar


NOTA: hay mucha palabreria porque hace parte como aun examenn digamolo asi apra admision en un semillero de investigacion qeu usa tecnologia .net
7  Programación / Ingeniería Inversa / no ser detectado. en: 25 Febrero 2008, 05:24 am
bueno estoy viendo uno de los crackmes aqui puestos aunque tiene el enalce verde osea ya resuelto quiero resolverlo pro mi mismo, pero al debugear detecta el ollydb alguna forma para no ser detectado y seguir debugeando.

espero me ayuden.
Páginas: [1]
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines