Mensajes

Saludos, si tengo una matriz en C, en la cual tengo que posicionarme en alguna de las casillas( le pido la fila y la columna al usuario), y despues a apartir de esa casilla quiero moverme x numero de celdas en el eje de las filas y x numero de celdas en el eje de las columnas, ¿Cual es a manera correcta de validar que la nueva posicion en la que me encuentro es una celda valida para que no se desborde el arreglo???,podria ser algo como esto?

Código (c) [Seleccionar] Expandir

void verificarCelda(char **arreglo,int filaInicial,int columnaInicial)
{
    if(arreglo[filaInicial + 2][columnaInicial - 1] != -1)
       printf("Celda valida");
}


[rir3760]

muchas gracias rir3760, con respecto a sizeof(char), o sizeof(int) o el tipo que sea, me he fijado que cuando le asignan dinamicamente memoria en algunos casos lo ponen como:

Código (c) [Seleccionar] Expandir

int main()
{
   char **tablero;
   tablero = (char**)malloc(n*sizeof(char*));
   return 0;
}
indicando que es un puntero a char en el sizeof, y en otros casos lo ponen as,(suponiendo que ahora la variable es de tipo int):

variable = (int**) malloc(n*sizeof(int));

por que en algunas ocasiones lo ponen como puntero y en otras no

Saludos

si tengo  una matriz n x n, a la que quiero asignarle memoria dinamicamente porque su tamaño solo se puede saber en tiempo de ejecucion, cual es la manera correcta de hacerlo?

Código (c) [Seleccionar] Expandir

char **tablero;
     tablero = (char**)malloc(tamanio*sizeof(char*);

o esta otra:

Código (c) [Seleccionar] Expandir


char **tablero;
tablero = (char**)malloc(n*sizeof(char));
   for(i = 0;i < n;i++)
      tablero[i] = (char*)malloc(n*sizeof(char));

otra duda, estaba leyendo un manual sobre memoria dinamica y me decia que si hacia algo como esto me iba a dar error de compilacion que porque el compilador requiere que el tamaño del array o de la matriz sea constante:

Código (c) [Seleccionar] Expandir

int main()
{

    int num_estudiantes,i;
    printf("Dame numero de estudiantes: ");
    scanf("%d",&num_estudiantes);
    int asignatura[num_estudiantes];
    for(i = 0;i < num_estudiantes;i++)
    {
        printf("Dame un numero \n");
        scanf("%d",&asignatura[i]);
    }
pero ya lo probe y me compila correctamente, a que se debe esto??

gracias

Saludos

Tengo un arreglo de enteros y quiero copiarlo a otro arreglo, pense que lo podia hacer con la funcion strcpy(), pero despues me di cuenta que esta solo se usa para cadenas. Entonces que otra manera hay de hacer esto??

gracias

Saludos tengo una lista doblemente ligada que me inserta por la cabeza, por el final, despues y antes de un elemento que se le pide al usuario, todavia no esta terminado pero el problema que tengo es con el caso de insertar antes de un elemento dado, que me truena el programa y no entiendo por que, creo que el problema es que una vez que le pido al usuario el numero antes del que quiero ingresar mando llamar a la funcion anterior

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#define INSERTAR_CABEZA 1
#define INSERTAR_ANTES 2
#define INSERTAR_DESPUES 3
#define INSERTAR_FINAL 4
#define SALIR 5

typedef struct nodo
{
    int elemento;
    struct nodo *sig;
    struct nodo *ant;
}Nodo;

Nodo *crearNodo(int insertable);
void insertarCabeza(int insertable,Nodo **cabeza);
void insertar_antes(Nodo *anterior,int insertable);
void insertar_despues(Nodo *posterior,int insertable);
void insertarFinal(Nodo *ultimo,int insertable);
Nodo *buscarElemento(int elementoBuscado,Nodo *cabeza);
void imprimirLista(Nodo *cabeza);
Nodo *ultimoElemento(Nodo *cabeza);
Nodo *Anterior(Nodo *p);

int main()
{
    Nodo *cabeza,*anterior,*posterior,*p,*ultimo;
    cabeza = NULL;
    int continuar = 1,opcion,numElementos,insertable,elementoBuscado,i;
    printf("Lista Doblemente Enlazada!\n\n");
    do
    {
        printf("\nMenu\n");
        printf("1) Insertar cabeza de Lista\n");
        printf("2) Insertar antes de elementento\n");
        printf("3) Insertar despues de elemento\n");
        printf("4) Insertar final de Lista\n");
        printf("5) Salir\n");
        scanf("%d",&opcion);
        switch(opcion)
        {
            case INSERTAR_CABEZA:
               printf("Dame el numero de elementos de la lista: ");
               scanf("%d",&numElementos);
               for(i=0;i < numElementos;i++)
               {
                   printf("Dame el elemento a insertar: ");
                   scanf("%d",&insertable);
                   insertarCabeza(insertable,&cabeza);
                   system("cls");
               }
               imprimirLista(cabeza);
               break;
            case INSERTAR_ANTES:
               printf("Antes de que elemento se quiere insertar: ");
               scanf("%d",&elementoBuscado);
               if((p = buscarElemento(elementoBuscado,cabeza))!=NULL)
               {
                   printf("Dame el elemento a insertar: ");
                   scanf("%d",&insertable);
                   anterior = Anterior(p);
                   insertar_antes(anterior,insertable);
               }
               else
                  printf("No se encontro elemento!\n");
               imprimirLista(cabeza);
               break;
            case INSERTAR_DESPUES:
               printf("Despues de que elemento deseas insertar: ");
               scanf("%d",&elementoBuscado);
               if((posterior = buscarElemento(elementoBuscado,cabeza))!=NULL)
               {
                   printf("Dame el elemento a insertar: ");
                   scanf("%d",&insertable);
                   insertar_despues(posterior,insertable);
               }
               else
                  printf("No se encontro elemento!\n");
               imprimirLista(cabeza);
               break;
            case INSERTAR_FINAL:
               printf("Dame el numero de elementos de la lista: ");
               scanf("%d",&numElementos);
               if(estaVacia(cabeza))
               {
                   printf("Dame el elemento a insertar: ");
                   scanf("%d",&insertable);
                   cabeza = crearNodo(insertable);
                   numElementos--;
               }
               for(i = 0;i < numElementos;i++)
               {
                   ultimo = ultimoElemento(cabeza);
                   printf("Dame el elemento a insertar: ");
                   scanf("%d",&insertable);
                   insertarFinal(ultimo,insertable);
               }
               imprimirLista(cabeza);
               break;
            case SALIR:
               continuar = 0;
               break;
        }
        if(continuar)
            system("pause");
    }while(continuar);
    return 0;
}

Nodo *crearNodo(int insertable)
{
    Nodo *p;
    p = (Nodo*)malloc(sizeof(Nodo));
    p->elemento = insertable;
    p->sig = NULL;
    p->ant = NULL;
    return p;
}

void insertarCabeza(int insertable,Nodo **cabeza)
{
    Nodo *nuevo;
    nuevo = crearNodo(insertable);
    nuevo->sig = *cabeza;
    nuevo->ant = NULL;
    *cabeza = nuevo;
}

void insertar_antes(Nodo *anterior,int insertable)
{
    Nodo *nuevo;
    nuevo = crearNodo(insertable);
    anterior->sig->ant = nuevo;
    nuevo->ant = anterior;
    nuevo->sig = anterior->sig;
    anterior->sig = nuevo;
}

void insertar_despues(Nodo *posterior,int insertable)
{
    Nodo *nuevo;
    nuevo = crearNodo(insertable);
    posterior->sig->ant = nuevo;
    nuevo->ant = posterior;
    nuevo->sig = posterior->sig;
    posterior->sig = nuevo;
}

void insertarFinal(Nodo *ultimo,int insertable)
{
    ultimo->sig = crearNodo(insertable);
    ultimo->sig->sig = NULL;
    ultimo->sig->ant = ultimo;
}

void imprimirLista(Nodo *cabeza)
{
    Nodo *ptr;
    for(ptr = cabeza;ptr!=NULL;ptr = ptr->sig)
       printf("%d\t",ptr->elemento);
}

Nodo *buscarElemento(int elementoBuscado,Nodo *cabeza)
{
    Nodo *ptr;
    for(ptr = cabeza;ptr!=NULL;ptr = ptr->sig)
    {
        if(ptr->elemento == elementoBuscado)
           return ptr;
    }
    return NULL;
}

Nodo *ultimoElemento(Nodo *cabeza)
{
    Nodo *ptr;
    ptr = cabeza;
    while(ptr->sig!=NULL)
       ptr = ptr->sig;
    return ptr;
}

int estaVacia(Nodo *cabeza)
{
    if(cabeza == NULL)
       return 1;
    else
       return 0;
}

Nodo *Anterior(Nodo *p)
{
    return p->ant;
}


gracias

[rir3760]

muchas gracias rir3760 por tu respuesta, estuve leyendo el enlace que pusiste y ahi dice que se puede resolver el problema utilizando solamente arrays y busqueda binaria, pero que la busqueda binaria no es solo para los array ordenados?? o sea que tengo antes que nada ordenar el vector y despues realizar la busqueda binaria del elemento menor del arreglo?? el parrafo dice:

procesa la secuencia de elementos en orden, manteniendo la subsecuencia de incrementos mas larga obtenida hasta ahora. Aqui no se a que se refiere con subsecuencia obtenida, obtenida cuando?? si hasta ahora solo se ha ordenado el arreglo

de nuevo gracias

[encontrar el menor numero de tarjetas que se pueden eliminar]

Saludos

Tengo el siguiente programa que dice:

Tengo n tarjetas numeradas en cierto orden(al azar), y hay que eliminar algunas de esas tarjetas, de tal forma que las que queden esten ordenadas ascendentemente,  y cuyos valores esten entre el rango 1 <= valores <= 100,000, esto ya lo codifique pero el problema que tengo es que me pide encontrar el menor numero de tarjetas que se pueden eliminar y es lo que no entiendo como hacerlo, o sea que tengo que buscar todas las posibilidades y despues verificar cual es la que puede eliminar el menor numero de tarjetas?? el codigo es el siguiente:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define VALORES 100000

typedef struct nodo
{
   int dato;
   struct nodo *sig;
}Nodo;

void agregarTarjetas(int x,Nodo **cabeza);
void imprimirTarjetas(Nodo *cabeza);
void eliminarTarjetas(Nodo *cabeza);
Nodo *crearNodo(int x);


int main()
{
   int numeroTarjetas,i,x;
   Nodo *cabeza;
   cabeza = NULL;
   srand(time(NULL));
   do
   {
       printf("Dame numero de tarjetas: ");
       scanf("%d",&numeroTarjetas);
       system("cls");
   }while((numeroTarjetas < 1)||(numeroTarjetas > 100));
   for(i = 0;i < numeroTarjetas;i++)
   {
       x = rand()% VALORES+1;
       agregarTarjetas(x,&cabeza);
   }
   printf("Archivo original\n");
   imprimirTarjetas(cabeza);
   eliminarTarjetas(cabeza);
   printf("despues\n");
   imprimirTarjetas(cabeza);
   return 0;
}

void agregarTarjetas(int x,Nodo **cabeza)
{
   Nodo *nuevo;
   nuevo = crearNodo(x);
   nuevo->sig = *cabeza;
   *cabeza = nuevo;
}

Nodo *crearNodo(int x)
{
   Nodo *p;
   p = (Nodo*)malloc(sizeof(Nodo));
   p->dato = x;
   p->sig = NULL;
   return p;
}

void imprimirTarjetas(Nodo *cabeza)
{
   Nodo *ptr;
   for(ptr = cabeza;ptr!=NULL;ptr = ptr->sig)
      printf("[%d]",ptr->dato);
}

void eliminarTarjetas(Nodo *cabeza)
{
   Nodo *ptr1,*ptr2;
   for(ptr1 = cabeza,ptr2 = ptr1->sig;ptr2!=NULL;ptr2 = ptr2->sig)
   {
       if(ptr2->dato < ptr1->dato)
          ptr1->sig = ptr2->sig;
       else
          ptr1 = ptr1->sig;
   }
}


esta la hice con listas con apuntadores porque pense que seria mas facil hacer las eliminaciones, aunque tambien lo habia hecho de esta otra manera, y las dos funcionan solo que no se como hacer un algoritmo que me determine cual es el menor numero de tarjetas que se pueden eliminar

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define VALORES 100000

int *ingresarValores(int numeroTarjetas,FILE *fd);
void eliminarTarjetas(int tarjetas[],int numeroTarjetas,FILE *fd);

int main()
{
   FILE *fd;
   int numeroTarjetas,*tarjetas;
   srand(time(NULL));
   if((fd = fopen("F:\\Archivo_Analisis_Algoritmos.txt","w"))!= NULL)
   {
       do
       {
           printf("Dame el numero de tarjetas: ");
           scanf("%d",&numeroTarjetas);
           system("cls");
       }while((numeroTarjetas < 1)||(numeroTarjetas > 1000));
       fprintf(fd,"Archivo de Texto:\n\n");
       tarjetas = ingresarValores(numeroTarjetas,fd);
       eliminarTarjetas(tarjetas,numeroTarjetas,fd);
   }
   else
      printf("No se pudo crear archivo\n");
   return 0;
}

int *ingresarValores(int numeroTarjetas,FILE *fd)
{
   int i,*buffer;
   buffer = (int*)malloc(numeroTarjetas*sizeof(int));
   for(i = 0;i < numeroTarjetas;i++)
   {
       buffer[i] = rand()% VALORES+1;
       printf("[%d]",buffer[i]);
       fprintf(fd,"%d,",buffer[i]);
       if((i%10==0)&&(i!=0))
          fprintf(fd,"\n");
   }
   return buffer;
}

void eliminarTarjetas(int tarjetas[],int numeroTarjetas,FILE *fd)
{
   int i,j;
   for(i=0;i < numeroTarjetas;i++)
   {
       for(j=i+1;j < numeroTarjetas;j++)
       {
           if(tarjetas[j] < tarjetas[i])
              tarjetas[i] = -1;
       }
   }
   fprintf(fd,"\n\nTarjetas eliminadas\n");
   for(i=0;i < numeroTarjetas;i++)
   {
       if(tarjetas[i] != -1)
          fprintf(fd,"[%d]",tarjetas[i]);
   }

}


por ejemplo si tengo los numeros [11,500][22,924][13,449][21,933][13,150][1,858][11,516], se que el menor numero de eliminaciones serian 4, y quedaria asi:

[11,500][13,449][21,933], pero trate de buscarle la logica y no supe como

de antemano gracias

si lo cheque, ya habia visto ese post, pero ni asi el codigo funciona como quiero que funcione:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define ASISTENCIA_MINIMA 80
#define PORCENTAJE_TAREAS 10
#define PORCENTAJE_EXAMEN 10
#define PORCENTAJE_MINIPRACTICAS 18
#define PORCENTAJE_SENCILLAS 12
#define PORCENTAJE_INTERESANTE 5
#define PRACTICAS_INTERESANTES 9
#define PRACTICAS_SENCILLAS 6
#define TAREAS 4
#define RETARDOS 3
#define MINITAREAS 5
#define MINIPRACTICAS 9
#define ASISTENCIAS 17
#define MAXIMA 100
#define MINIMA 60

int main()
{
    //Declaracion y definicion por defecto de variables(a usar para entrada de datos)
    int i;
    float total_faltas,total_retardos,total_minitareas,total_tareas,total_examen,total_minipracticas,
    total_practicas_sencillas,practica_interesante,total_practica_interesante = 0;
    //Declaracion de variable (para computo)
    float tareas,examen,practicas,total_asistencias,porcentaje_asistencias,calificacion_final;
    //Entrada de Datos
    printf("Evaluador del Taller de Estructura de Datos v1.0\n\n");
    printf("Cuantas faltas acumulaste? ");
    scanf("%f",&total_faltas);
    printf("Cuantos retardos acumulaste? ");
    scanf("%f",&total_retardos);
    printf("Cuantas minitareas realizaste? ");
    scanf("%f",&total_minitareas);
    printf("Cuantas tareas realizaste? ");
    scanf("%f",&total_tareas);
    printf("Cuanto obtuviste en el examen? ");
    scanf("%f",&total_examen);
    printf("Cuantas minipracticas realizaste? ");
    scanf("%f",&total_minipracticas);
    printf("Cuantas practicas sencillas realizaste? ");
    scanf("%f",&total_practicas_sencillas);
    for(i=0;i < PRACTICAS_INTERESANTES;i++)
    {
        printf("Cuanto obtuviste en la practica interesante #%d? ",i+1);
        scanf("%f",&practica_interesante);
        total_practica_interesante+=practica_interesante;
    }
    //Computo de Tareas
    tareas = total_minitareas+((total_tareas*PORCENTAJE_TAREAS)/TAREAS);
    //Computo de Examen
    examen = (total_examen*PORCENTAJE_EXAMEN)/MAXIMA;
    //Computo de Practicas
    practicas = ((total_minipracticas*PORCENTAJE_MINIPRACTICAS)/MINIPRACTICAS)+
                ((total_practicas_sencillas*PORCENTAJE_SENCILLAS)/PRACTICAS_SENCILLAS)+
                ((total_practica_interesante*PORCENTAJE_INTERESANTE)/MAXIMA);
    //Computo de Asistencias
    total_asistencias = ASISTENCIAS-total_faltas-(total_retardos/RETARDOS);
    porcentaje_asistencias = (total_asistencias*100)/ASISTENCIAS;
    //Computo General
    calificacion_final = tareas + examen + practicas;
    printf("\nTareas\tExamen\tPracticas\n");
    printf("%.2f\t",tareas);
    printf("%.2f\t",examen);
    printf("%.2f\n\n",practicas);
    printf("Total de asistencias=\t\t%.2f\n",total_asistencias);
    printf("Porcentaje de asistencias=\t%.2f\t",porcentaje_asistencias);
    if(porcentaje_asistencias < ASISTENCIA_MINIMA)
    {
        system("04");
        printf("No tiene derecho\n");
    }
    else
    {
        system("02");
        printf("Si tiene derecho\n");
    }
    printf("Calificacion Final=\t\t%.2f\t",calificacion_final);
    if(calificacion_final < MINIMA)
       printf("Calificacion no aprobatoria\n");
    else
       printf("Calificacion aprobatoria\n");
    return 0;
}


quiero que el texto: Si tiene derecho me lo imprima en verde y no tiene derecho lo imprima en rojo, pero no funciona y ya le agregue conio

gracias

Saludos

Si tengo un codigo con varios printf, y quiero cambiarle el color de fuente a solo uno de esos printf, como lo haria, intente con system("color"); pero imprime todo de ese color y no solo el printf que yo quiero,tendria que agregar alguna libreria o algo asi??

gracias

gracias por sus respuestas, el programa me dice:

Crear un "struct" que almacene los siguientes datos de una persona: nombre, edad, ciudad de residencia. Pedir al usuario esos datos de una persona y guardarlos en un fichero llamado "gente.dat", usando "fwrite". Cerrar el fichero, volverlo a abrir para lectura y mostrar los datos que se habían guardado, que se deben leer con "fread".

ya entendi como usar el fwrite para escribir en el archivo.dat, pero ahora el problema que tengo es con el fread() que me tiene que recibir los datos leidos del stream y almacenarlos en un buffer o una estructura, pero me aparece basura todavia

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 35
#define TAM 50
/*
   Crear un "struct" que almacene los siguientes datos de una persona: nombre, edad, ciudad de residencia.
   Pedir al usuario esos datos de una persona y guardarlos en un fichero llamado "gente.dat", usando "fwrite".
   Cerrar el fichero, volverlo a abrir para lectura y mostrar los datos que se habían guardado,
   que se deben leer con "fread".
*/

typedef struct
{
    char nombre[MAX];
    int edad;
    char ciudad_residencia[MAX];
}Persona;

void agregarDatos(Persona *p);

int main()
{
    FILE *fd,*ap;
    Persona p,persona;
    agregarDatos(&p);
    if((fd = fopen("F:\\gente.dat","w"))!=NULL)
    {
        fwrite(&p,sizeof(p),1,fd);
        fclose(fd);
        if((ap = fopen("F:\\gente.dat","r"))!=NULL)
        {
            fread(&persona,sizeof(p),1,ap);
            printf("%s",persona.nombre);
            printf("%d",persona.edad);
            printf("%s",persona.ciudad_residencia);
        }
    }
    else
       printf("No se pudo crear archivo\n");
    return 0;
}

void agregarDatos(Persona *p)
{
    char buffer[MAX];
    printf("Dame nombre: ");
    fgets(p->nombre,MAX,stdin);
    printf("Dame edad: ");
    fgets(buffer,MAX,stdin);
    sscanf(buffer,"%d",&p->edad);
    printf("Dame ciudad de residencia: ");
    fgets(p->ciudad_residencia,MAX,stdin);
}


gracias