Mensajes

[¡quien los pillara!.]

Como ya les dije apenas estoy empezando tengo 15 años y me esta empezando a fascinar el mundo de las computadoras..........................

15 añitos, ¡quien los pillara!. Mejor imposible, tienes todo el tiempo del mundo, ilusión frescura de mente y encima supongo te hacen las cosas cotidianas. Yo en cambio tengo 59, con lo que conlleva en falta de tiempo por dedicación a la familia, amigos, estudios varios, tareas del hogar,etc. Y aún no llevo un año neto con esto del C. Aunque empecé hace cosa de dos años,  la enfermedad me resta mucho tiempo: operaciones, sesiones de quimioterapia, rehabilitación, deshidrataciones .... pero no me falta el animo y los usuarios del foro ayudan mucho, y no lo digo por mí. ¡Animo!.

........................................
Eso de cambiar el Turbo C 2.0 no lo voy ha hacer ..................
.........................................

Déjate de tonterías, estas hablado de la edad de piedra. No hay motivo justificado que te conduzca a esa triste y primitiva opción. Mi consejo, usa un entorno de programación actual, potente, gratuito y cómodo:Code::Blocks

Elige la de 96.8 MB, la codeblocks-13.12mingw-setup-TDM-GCC-481.exe.

...........................................
ya que pienso dominar el C en MS-DOS para lograr hacer programas buenos con unos 640 KB
................................................

¿Otra vez?, ¿MS-DOS?. ¡Tá loco boludo!, dicho con respeto y cariño,y no soy argentino sino canarión, pero es que en Canarias los del otro lado del charco son como hermanos nuestros. Pero a lo que iba, ¿no te has enterado que el MS-DOS dejo de usarse desde que se paso del Windows Media al Xp y subsiguientes versiones, alias Windows 7 y 8?.El MS-DOS actual es una capa de emulación, no es ya un sistema operativo independiente. Eso estaría cuasi justificado  por mi edad, en mi caso ya que yo si lo manejaba y tengo multitud de cositas que corren en MS.DOS, pero todas ya desfasadas y/o superadas, Deja, deja, eres joven y tienes que pensar hacia delante, como se suele decir, pá tras ni pá coger impulso.

...................................
para lograr hacer programas buenos con unos 640 KB. Es algo loco lo se ,hacer programas buenos con unos cuantos KB
...........................................

¡Pero bueno!, ¿en qué mundo vives?. Si hoy en día es hasta difícil encontrar un ordenata que tenga menos de 1 GB de memoria. El mío como ejemplo empieza a ser ya un  carcamal, tiene más de tres años, y sin embargo posee 8 GB de memoria. Otra cosa distinta es el tamaño de los programas que hagas, que pueden ser de unos pocos ciento KB , si es eso lo que quieres. Pero no te pongas límites de entrada, ¡piensa siempre a lo grande!, que ya luego la vida nos pone en su sitio.

jo-der leosansan ole tus cojones de verdad  

Gracias, gracias, pero no es para tanto.

  Felices Navidades y Próspero Año Nuevo.    

¡¡¡¡ Saluditos! ..... !!!!

[vangodp]

Perdonen que reviva el tema, pero la aportación es diferente.

Por un lado un código que no resuelve directamente el laberinto, pero permitir "ver" los caminos de salida al estar el laberinto "coloreado". Como ejemplo, a mi nietillo le encanta buscar las soluciones y como es muy fácil cambiar el laberinto, cada vez que quiere jugar tiene   un laberinto diferente.

Y de muestra un pantallazo:

Sí ya lo sé, no resuelve nada pero permite a simple vista localizar los caminos de salida. Es como un juego, repito.

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>

void mostrar(char a[][28],char *msg);
void color (int n)

int main (){

   char a[24][28]={
   "000000000000000000000000000",
   "012222222222222222222222220",
   "022020200020002000000000020",
   "022202022020202000000000020",
   "020000000020202000000000020",
   "020222220020220200022222220",
   "022000000000000200020000020",
   "022222222222200200020000020",
   "022200000000200222222222000",
   "022222222200200000020002020",
   "022200000020222222222222220",
   "022222222200200000000000020",
   "020000000000222222222222220",
   "022000022200200000000000020",
   "020000000000200222222222220",
   "022222222222222200000000020",
   "020000000000000222222202020",
   "020000000000000200000202020",
   "022222222222222200000202020",
   "000002000000000200002222220",
   "020222222222222222222200000",
   "020000000000000000000222220",
   "022222222222222222222220010",
   "000000000000000000000000000"
   };
   mostrar(a,"LABERINTO");
   return 0;
}


void mostrar(char a[][28],char *msg){
   system ("cls");
   int i,j;
   for( i=0;i<24;i++) {
       for( j=0;j<27;j++) {
           if ((i==22 && j==25) ||(i==1 && j==1))
               color(215);
           else if (a[i][j]=='X')
               color(125);
           else if (a[i][j]=='0')
               color(175);
           else
           color(7);
           printf("%c ",a[i][j]);
           fflush(stdout);
       }
       putchar('\n');
   }
   color(7);
   printf ("\n\t\t%s\n\n",msg);
   system ("pause");
}

void color (int n)
{
       SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
}


Y a la espera de que vangodp saque su versión 2.0, la 1.0 no furula ni pá dios, dejo una opción muy simple. Se trata de que de forma totalmente aleatoria el ordenador busque la salida .... y siempre la encuentra y mas de una combinación posible en general. Tiene el inconveniente de que muestra todos los movimientos, incluso los de retroceso. Pero en fin, si vangodp no veo que se anime me pondré yo a ello.

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>

void mostrar(char a[][27],char *msg);
void color (int n);

int main (){

   char a[24][27]={
   "000000000000000000000000000",
   "012222222222222222222222220",
   "022020200020002000000000020",
   "022202022020202000000000020",
   "020000000020202000000000020",
   "020222220020220200022222220",
   "022000000000000200020000020",
   "022222222222200200020000020",
   "022200000000200222222222000",
   "022222222200200000020002020",
   "022200000020222222222222220",
   "022222222200200000000000020",
   "020000000000222222222222220",
   "022000022200200000000000020",
   "020000000000200222222222220",
   "022222222222222200000000020",
   "020000000000000222222202020",
   "020000000000000200000202020",
   "022222222222222200000202020",
   "000002000000000200002222220",
   "020222222222222222222200000",
   "020000000000000000000222220",
   "022222222222222222222220010",
   "000000000000000000000000000"
   };
   int i,j,incre_i,incre_j;
   i=1,j=1;
   a[1][1]='I';
   a[22][25]='F';
   srand((unsigned) time(NULL));
   mostrar(a,"LABERINTO");
   system ("cls");
   while (i!=21 || j!=25){
       incre_i=rand()%3;
       if (incre_i==2)
           incre_i=-1;
       incre_j=rand()%3;
       if (incre_j==2)
           incre_j=-1;
       if ((incre_i==0 || incre_j==0) && (incre_i!=incre_j)  && (incre_i!=-incre_j)){
           i+=incre_i;
           if (i<0)
               i++;
           j+=incre_j;
           if (j<0)
               j++;
           if (i>22)
               i--;
           if (j>25)
               j--;
           if (a[i][j]=='2' || a[i][j]=='X' || a[i][j]=='I') {
               a[i][j]='X';
           }
           else {
               i-=incre_i;
               j-=incre_j;
           }
       }
   }
   mostrar(a,"SOLUCION");
   return 0;
}


void mostrar(char a[][27],char *msg){
   int i,j;
   system ("cls");
   for( i=0;i<24;i++) {
       for( j=0;j<27;j++) {
           if ((i==22 && j==25) ||(i==1 && j==1))
               color(215);
           else if (a[i][j]=='X')
               color(125);
           else if (a[i][j]=='0')
               color(175);
           else
           color(7);
           printf("%c ",a[i][j]);
           fflush(stdout);
       }
       putchar('\n');
   }
   color(7);
   printf ("\n\t\t%s\n\n",msg);
   system ("pause");
}

void color (int n)
{
       SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
}


Cada vez que ejecutas el programa la solución puede variar al ser los movimientos totalmente aleatorios.


  Felices Navidades y Próspero Año Nuevo.    

¡¡¡¡ Saluditos! ..... !!!!

REEDITADO

[y quiero que se mantenga esa idea.]

...........................................
quisiera que me digan en que estoy mal o como lo puedo mejorar y si se puede que modifiquen el código y me lo manden para compartir ideas. Según yo el código es claro de entender y quiero que se mantenga esa idea.
...............

* Para empezar el programa arranca con unas flechitas <----> que sólo el que ha hecho el código sabe lo que representan.  Faltaría en principio algunos printf  que expliquen que se va hacer. Como ejemplo el primer goto fin; tal como tienes el arranque del código el usuario tiene que "adivinar qué introducir e ídem para las siguientes flechitas que aparecen.

* Como ya te ha comentado IEAX el uso de goto no es nada aconsejable, se pierde legibilidad y se presta a equivocaciones y/o confusión. Fíjate que si introduces 'S' te lleva a fin y este a return 0, o sea fin del programa. Y así en otros lugares.

* Por claridad convendría usar dos variables al comienzo, una para la opción salir o no y otra para la operación elegida.

* Respeto el uso de las variables globales por suponer que no has visto punteros.

* Te sobran un par de "return 0" en las funciones porque no devuelven nada ni interrumpen el programa.

* En el caso raíz te falto el break.

* Tienes que acostumbrarte a indentar o sangrar el código, si no no hay quien se aclare donde empiezan y terminan los bucles y las funciones.

* Te hace falta un bucle en el caso de introducir los números para que no se bloquee el programa si introduces un caracter no numérico.

* Te falta indicar el tipo de las funciones, void en tu caso.

* La variable "op" es un caracter ,+ o - * o/ o R o r, por lo que no tiene mucho sentido el %s1 en su scanf, más bien %c ya que lo tienes asignado como un simple char.

* ¿Pero que pasa si al pedir s o n introduces asd o 325?. Pues como op está definido como un solo caracter tomaría el primero, es decir la a o el 3, y sería equivalente a no. Es decir, sería más correcto definir op como una cadena y si es mayor de 1 que vuelva a preguntar si sí o no. Y lo mismo en el apartado de Indique operación a realizar. Para comprobar si es más de un caracter uso la función longitud_cadena, que puede ser sustituda por strlen (cadena) , incluyendo a cambio la librería <string.h> (Si a alguien se le ocurre una validación mejor por favor comentarmelo)

* Lo que nos lleva a tener que trabajar con op[0] y opc[0] en lugar de op y opc.

* Uso el formato para imprimir los double o float "%g" ya que evita que salgan un porrón de ceros a la derecha del punto decimal después de la última cifra significativa.

* Y aún así, además de entrar en un bucle infinito al introducir una cadena en los scanf de los números también podría darse el caso de aceptar 2asd como 2. Una posible solución es tomar el número, que a lo mejor no lo es -ejemplo mencionado de 2asd- como una cadena y comprobar que no hay carateres no numéricos, y luego transformar la cadena a double, cosa que hago en la función "comprobar_cadena_como_numero". (Repito, si a alguien se le ocurre una validación mejor por favor comentármelo)

* Eliminé la función "tardansa" porque no le encuentro sentido. Los cálculos planteados son cuasi-instantáneos.

* Y ya puestos, ¿por qué limitarlo al cálculo sólo de raíces cuadradas?.

Por favor, admito toda clase de sugerencias a las validaciones, pero es que en la mayoría de los casos en que se hace uso de scanf no se tiene en cuenta las posibles entradas erróneas de los usuarios y que, en el mejor de los casos, son causa de bucles o cuelgues y en el peor de los casos obtener resultados erróneos; pongo por caso que el usuario quiera introducir 43 y en su lugar introduzca 4w pudiendo en este caso tomar el scanf el 4 como número introducido lo que llevará a un resultado erróneo.

Para hacerlo más rico he usado tanto un while como un do-while e incluso un if con un break y otro con un return 1 pero he buscado respetar el código original. Partiendo de cero saldría otra cosa.  

También he usado el código ASCII para el acento en la o y en la a.

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define MAX_DIGITOS 10

int cont=0;
double a,b,x,rad,r;
char n_1[MAX_DIGITOS],n_2[MAX_DIGITOS],op[10],opc[10];

int longitud_cadena (char cadena[10]){
   int i;
   for (i=0;cadena[i];i++);
   return i;
}

void comprobar_cadena_como_numero (char numero[MAX_DIGITOS]){
   int i;
   cont=0;
   for (i=0;numero[i];i++)
       if (numero[i]<'0' || numero[i]>'9'){
           cont++;
           break;
       }
}

void capturar(char op[10])
{
   do {
       if (op[0]=='R' || op[0]=='r'){
           printf("\n\nRadicando = ");
           fflush (stdout);
           }
       else {
           printf("\n\nPrimer numero = ");
           fflush (stdout);
       }
       scanf("%s",n_1);
       comprobar_cadena_como_numero (n_1);
   }while (cont > 0);
   a = atof(n_1);
   do {
       if (op[0]=='R' || op[0]=='r'){
           printf("\n\nIndice raiz = ");
           fflush (stdout);
           }
       else {
           printf("\n\nSegundo numero = ");
           fflush (stdout);
       }
       scanf("%s",n_2);
       comprobar_cadena_como_numero (n_2);
   }while (cont > 0);
   b = atof(n_2);
}

void operacion(char op[10])
{
   switch (op[0]){
       case '+' :
           x = a + b;
           break;
       case '-' :
           x = a - b;
           break;
       case '*':
           x = a * b;
           break;
       case '/':
           x = a / b;
       case 'R':
           x = pow(a,1/b);
           break;
       case 'r':
           x = pow(a,1/b);
           break;
       default:
           break;
    }
    if (op[0]=='R' || op[0]=='r'){
       printf("\n\nRaiz %g de %g = %g  \n\n",b,a,x);
    }
    else
       printf("\n\n%g %c %g = %g \n\n",a,op[0],b,x);
       system ("pause");
       system ("cls");

}

int main()
{
   int longitud=0;
   cont=0;
   do{
       printf("\n\nDesea realizar alguna operaci%cn ( SI = S(s) NO = cualquier otro valor): ",162);
       fflush (stdout);
       do {
       cont = (scanf("%s",opc));
       longitud =longitud_cadena(opc);
       if (longitud>1)
           printf("\n\nIntroduzca UN caracter v%clido :  ",160);
       }while (cont == 0 || longitud>1  );
       if (opc[0]!='S'&& opc[0]!='s')
           return 1;

       while (1) {
           printf("\n\nIndique la operaci%cn a realizar( + - * / Raiz = R o r):  ",162);
           cont = (scanf("%s",op));
           longitud =longitud_cadena(op);
           if (( op[0]=='+' || op[0]=='-' || op[0]=='*' || op[0]=='/' || op[0]=='R' || op[0]=='r') && ( cont!= 0 || longitud==1 ))
               break;
       }
           capturar(op);
           operacion(op);
   }while(opc[0]=='S'||opc[0]=='s');
return 0;
}

[/size]

Sí ya lo sé, queda el caso del no o N, pero algo hay que dejarle a los demás.

  Felices Navidades y Próspero Año Nuevo.    

¡¡¡¡ Saluditos! ..... !!!!

[GNU MP]

Esque hay una clase ya creada para numeros grandes???

Una clase no sé, pero librerías sí, por ejemplo GNU MP

Saluditos! ..... !!!!        

[¡¡¡¡ Saluditos! ..... !!!!]

¿Intentas guardar un número con 19 digitos? Eso no te cabe en ninguna variable.
..................................................

En realidad no tienes problema usando long long int, siempre que no sobrepase el conjunto de operaciones entre los números el límite 9223372036854775807:

Código (cpp) [Seleccionar] Expandir


    a=9223372036854775807
    total = 5761455
    Process returned 0 (0x0)   execution time : 6.535 s
    Press any key to continue.



El segundo número es de otra operación.... pero no sobrepases ese valor o tendrás que usar librerías externas.

¡¡¡¡ Saluditos! ..... !!!!

[Felices Navidades y Próspero Año Nuevo.]

Eso si lo puedo hacer... el problema que es una tarea escolar.. y me prohibieron realizarlo de esa forma.. tiene que ser con alguna funcion creada por mi...

Si te piden restar supongo que es porque sabes sumar.

Para restar sólo tienes que saber sumar, sólo que el que resta lo transformas en complemento a dos. O más fácil en complemento a 1 cambiando en el negativo los ceros por uno y al revés,  luego a ese  resultado le sumas un uno. De esa manera sumas a ese el otro que era positivo

También puedes hacerlo directo, es más fácil, pero tienes que tener en cuenta el acarreo.

Más información aquí.

  Felices Navidades y Próspero Año Nuevo.   

¡¡¡¡ Saluditos! ..... !!!!

[de forma contigua]

.....................................................

El problema no está en malloc. El problema son estos dos:

- Estás pidiendo memoria de forma contigua es muy posible que tengas 1 gb libre de memoria ram, el problema es que la memoria libre estará "dispersa". Es muy díficil que te encuentres 1 gb de espacio libre contiguo. Se podría suplir esto usando listas o varios vectores.
- En una aplicación de 32 bits, la máxima memoria permitida es de 2GB (si la compilas en 64 bits llegarías a los 16 tb)
......................................

Seré pardillo ........ mi memoria es la que si falla.

¡¡¡¡ Saluditos! ..... !!!!

[¡¡¡Me encantan que los planes salgan bien !!!]

Cierto, actualice mi codeblocks, y funciona perfectamente.

Muchas gracias

¡¡¡Me encantan que los planes salgan bien !!!

Saluditos! ..... !!!!       

[¡¡¡¡ Saluditos! ..... !!!!]

.........................................................
Pero aún así es más eficiente, entre otras cosas porque no tienes llamadas a función y esas cosas. El algoritmo es el mismo básicamente.
El problema esque yo meto los datos en la pila y tú usas memoria dinámica (malloc).
.............................................................

El mismo código tuyo, con mis modificaciones en cuanto a ir de dos en dos, y manteniendo el uso de la pila así como de las funciones es similar al mío:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#define COMPUESTO 0

const int MAX = 1000000;

void tacharMultiplos(char Tabla[],int i)
{
    int j;
    for (j = i;(i*j) <= MAX;j+=2)
    {
        Tabla[j*i] = COMPUESTO;
    }
}

void mostrarTabla(char Tabla[])
{
    int i = 3,cont=1;

    for (i = 3; i <= MAX;i+=2)
    {
        if (Tabla[i] != COMPUESTO)
        {
            /*printf("%d  ",Tabla[i]);*/
            cont++;
        }

    }

    printf("\ncont= %d\n",cont);
}

int main()
{
    // Generar Criba de erastotenes

    char Tabla[MAX+1]; // tabla booleana
    int i = 0;

    // valor inicial

    for (i = 3; i<= MAX;i++)
    {
        Tabla[i] = i;
    }
       

    for (i = 3;i*i<=MAX;i+=2)
    {
            tacharMultiplos(Tabla,i);
    }

    mostrarTabla(Tabla);
    return 0;
}


Eso sí, creo que el uso de la pila penaliza el tamaño del array ya que en mi caso puedo llegar a 10^8 y en el tuyo a 10^6, al menos en mi ordenador.

Y como verás he respetado el uso que haces de las llaves ..... que se me antoja excesivo. 

¡¡¡¡ Saluditos! ..... !!!!

[solo una duda]

Entonces ok, dejo el tema en paz, solo una duda, si la biblioteca fstream es parte del la biblioteca stantart de c++ no se podra agregar en un fichero .c cierto? Y esta claro que esta trabajando con C puesto que las otras bibliotecas conservan el .h

Aunque no lo parezca por las librerías .h y el uso de printf y scanf, más propios del C, la inclusión de la librería <fstream> pone de manifiesto que trabaja en C++, ya que no existe la correspondiente librería <fstream.h> en C.

  Felices Navidades y Próspero Año Nuevo.   

¡¡¡¡ Saluditos! ..... !!!!