Tengo un problema con el siguiente codigo.
Basicamente.
1) Leo desde un archivo cierta información y la guardo en un arreglo de char.
2) Lo imprimo en pantalla (Hasta aca todo joya)
3) Cuando llamo a la funcion auxiliares lo que hace es abrir otro archivo y guardar esa informacion en otro arreglo de char.
4) No se porque cuando llamo a esta ultima funcion (auxiliares), al hacer un printf del contenido en la posicion 0 del primer arreglo, se borra.
Adjunto informacion de los 2 archivos al final
Espero que alguien pueda ayudarme porque no encuentro el error.

#include <stdio.h>
#include <stdlib.h>
#define F 10
#define C 50
void lectura(char arreglo[F][C]);
void imprimir(char arreglo[F][C]);
void auxiliares(char arreglo[2][C]);
int main()
{
    char arreglo[F][C];
    char aux[2][C];
    lectura(arreglo);
    printf("Imprimir:\n \n");
    imprimir(arreglo);
    printf("El valor 0 del arreglo es: %s\n",arreglo[0]);  ///Aca imprime perfecto el contenido
    auxiliares(aux);
    printf("El valor 0 del arreglo es: %s\n",arreglo[0]);  ///Aca el mismo contenido ya no lo imprime, aparece vacio
    printf("El valor 0 del arreglo es: %s",arreglo[1]);    ///Aca los demas elementos si los tiene, pero no el de la posicion 0
    return 0;
}
void lectura(char arreglo[F][C])
{
    int i=0,j=0,r;
    char letra;
 
    FILE*arch=NULL;
    arch=fopen("nomina.txt","r");
    letra=fgetc(arch);
    while(letra!=EOF && i<F)
    {
        while(letra!='\n' && j<C)
        {
            arreglo[i][j]=letra;
            j++;
            letra=fgetc(arch);
        }
        arreglo[i][j]='\0';
        j=0;
        i++;
        letra=fgetc(arch);
    }
    arreglo[i][0]=0;
}
 
void imprimir(char arreglo[F][C])
{
    int i=0;
    while(arreglo[i][0]!=0)
    {
        printf("%s\n",arreglo[i]);
        i++;
    }
}
void auxiliares(char aux[2][C])
{
    int i=0,j=0;
    char letra;
    FILE*arch=NULL;
    arch=fopen("actualizaciones.txt","r");
    letra=fgetc(arch);
    while(letra!=EOF)
    {
        while(letra!='\n' && j<C)
        {
            aux[i][j]=letra;
            j++;
            letra=fgetc(arch);
        }
        aux[i][j]='\0';
        i++;
        j=0;
        letra=fgetc(arch);
    }
    aux[i][j]='\0';
}
 
 

Archivo "nomina.txt" --->Contenido:
Juan Perez
Marta Saldiva
Juana Dorrego
Juan Perez
Susana Rodriguez
Pilar Santoro   
Juan Perez

Archivo "actualizaciones.txt" --->Contenido:
Juan Perez
Graciela Arpe

Hola.

Tengo el siguiente problema, al intentar usar el strcpy me marca error, dice "Incompatible type for argument 1 of strcpy".
No subi todo el codigo, solo esta función porque mi problema esta solo ahi en el strcpy, creo que tengo algun error conceptual.

void ordenado1(t_persona datos [N])
{
    int i=0,j=0;
    t_persona aux;
    for (i=0;datos[i].documento!=0;i++)
    {
        for(j=i+1;datos[i].documento!=0;j++)
        {
            if(datos[i].documento>datos[j].documento)
            {
                strcpy(aux,datos[i]);
                strcpy(datos[i],datos[j]);
                strcpy(datos[j],aux);
            }
        }
    }
}

Tengo el siguiente codigo de un formulario (creo q es html) y necesito cambiar el boton que dice "Comprar" que aparece todo gris y feo, por una imagen o un icono para que quede mas bien.
Como se puede hacer esto?.
Basicamente quiero dejarlo mas lindo.

<FORM target=_blank action="https://www.cuentadigital.com/api.php" METHOD="get">
<table border="0" cellpadding="0" cellspacing="0" style="border-collapse: collapse" width="100%" id="table1">
<input type="hidden" value="5029392" name="id">
<input type="hidden" value="7" name="venc">
<tr>
<td width="180">Nombre y Apellido:</td>
<td><input type="text" name="codigo"></td>
</tr>
 
<tr>
<td width="180">Precio:</td>
<td><input type="text" name="precio"></td>
</tr>
<tr>
<td width="180">E-Mail:</td>
<td><input type="text" name="hacia"></td>
</tr>
<tr>
<td width="180">Concepto:</td>
<td><input type="text" name="concepto"></td>
</tr>
<tr>
<td width="180">
<input type="submit" value="Comprar"></td>
<td> </td>
</tr>
</table>
</form>

Disculpa por las variables, son horribles, ya lo se.
Y si quisiera asignar espacio en memoria para que funcione el strcpy que tendria que hacer?.
Porque la solucion que encontre es   (nuevo+k)->nombre=arreglo.nombre)

Tengo que hacer un programa en el cual recibo por funcion un arreglo estatico de estructura y una letra.
Luego, tengo que crear un arreglo dinamico de estructura en el cual tengo que guardar los datos del arreglo estatico en el cual el codigo que tenga sea igual al pasado por parametro.
Luego, tengo que guardarlo en orden ascendente e imprimirlo por pantalla.
El problema es que en un momento del programa, creo que el problema esta en el while que esta entre la linea 51 y 64.

#include <stdio.h>
#include <stdlib.h>
#define T 3
struct s_alumno
{
    int leg;
    char*nombre;
    unsigned char cod_car
};
typedef struct s_alumno t_alumno;
t_alumno*filtrar(t_alumno[T],char cod_car);
int main()
{
    t_alumno arreglo[T];
    t_alumno*lista=NULL;
    int i=0;
    arreglo[0].leg=3;
    arreglo[1].leg=4;
    arreglo[2].leg=5;
    arreglo[0].nombre="Claudio";
    arreglo[1].nombre="Hernan";
    arreglo[2].nombre="Pablo";
    arreglo[0].cod_car='A';
    arreglo[1].cod_car='B';
    arreglo[2].cod_car='C';
 
    printf("Legajo: %d  - Nombre: %s - Codigo Carrera: %c\n",arreglo[0].leg,arreglo[0].nombre,arreglo[0].cod_car);
    printf("Legajo: %d  - Nombre: %s - Codigo Carrera: %c\n",arreglo[1].leg,arreglo[1].nombre,arreglo[1].cod_car);
    printf("Legajo: %d  - Nombre: %s - Codigo Carrera: %c\n",arreglo[2].leg,arreglo[2].nombre,arreglo[2].cod_car);
 
    lista=filtrar(arreglo,'B');
 
    while((lista+i)->leg!=0)
    {
        printf("Legajo: %d  - Nombre: %s - Codigo Carrera: %c\n",(lista+i)->leg,(lista+i)->nombre,(lista+i)->cod_car);
        i++;
    }
 
    return 0;
}
t_alumno*filtrar(t_alumno arreglo[T],char cod_car)
{
 
    t_alumno*nuevo=NULL;
    t_alumno aux;
    nuevo=malloc(sizeof(struct s_alumno));
    int i=0,j=0,k=0,maximo=0;
    char codigo;
 
 
    while(i<T)
    {
        if(arreglo[i].cod_car==cod_car)
        {
            (nuevo+k)->leg=arreglo[i].leg;
            (nuevo+k)->cod_car=arreglo[i].cod_car;
            strcpy((nuevo+k)->nombre,arreglo[i].nombre);
            printf("Legajo: %d  - Nombre: %s - Codigo Carrera: %c\n",(nuevo+k)->leg,(nuevo+k)->nombre,(nuevo+k)->cod_car);
            k++;
            nuevo=realloc(nuevo,(1+k)*sizeof(struct s_alumno));
        }
        i++;
    }
    (nuevo+k)->leg=0;
    printf("El legajo en el ultimo es %d",(nuevo+k)->leg);
 
            /// ORDENAR///
            for(maximo=0;(nuevo+maximo)->leg!=0;maximo++);
            printf("Maximo es %d",maximo);
            for(i=1;i<maximo;i++)
            {
                for(j=0;j<maximo-1;j++)
                {
                    aux=*(nuevo+j);
                    *(nuevo+j)=*(nuevo+j+1);
                    *(nuevo+j+1)=aux;
                }
            }
 
 
            return nuevo;
 
}

Muchas gracias, ahi funciono perfecto. Tenes razon, me equivoque y estaba pensando en listas con el puntero al siguiente.

---

Y si tengo que ordenar un arreglo dinamico y no se la longitud de ese arreglo dinamico...Hasta que punto tengo que recorrerlo?.

Tengo 2 arreglos de estructuras estaticos y tengo que crear un tercer arreglo de estructura de manera dinamica, que contenga los valores que no estan en ambos arreglos estaticos.
El problema me esta saliendo, el problema viene cuando quiero verificar para que no me pase ningun repetido.
Por eso cree la funcion esta que es una booleana, pero al poner esta funcion el programa se rompe.
No se en que le estoy pifiando.

#include <stdio.h>
#include <stdlib.h>
#define T 4
#define N 5
struct s_alumno
{
    int numero;
};
typedef struct s_alumno t_alumno;
 
t_alumno* CARGA (t_alumno arreglo1[T],t_alumno arreglo2[N]);
int esta(t_alumno*,int);
 
int main()
{
    int i=0;
    t_alumno*liston=NULL;
    t_alumno arreglo1[T];
    t_alumno arreglo2[N];
    arreglo1[0].numero=1;
    arreglo1[1].numero=7;
    arreglo1[2].numero=3;
    arreglo1[3].numero=5;
 
    arreglo2[0].numero=2;
    arreglo2[1].numero=8;
    arreglo2[2].numero=5;
    arreglo2[3].numero=9;
    arreglo2[4].numero=7;
 
    printf("Conjunto A : %d - %d - %d - %d\n", arreglo1[0].numero,arreglo1[1].numero,arreglo1[2].numero,arreglo1[3].numero);
    printf("Conjunto B : %d - %d - %d - %d - %d \n",arreglo2[0].numero,arreglo2[1].numero,arreglo2[2].numero,arreglo2[3].numero,arreglo2[4].numero);
    liston=CARGA(arreglo1,arreglo2);
    printf ("\nImprimimos Lista:\n");
    while((liston+i)->numero!=0)
    {
        printf(" %d -",(liston+i)->numero);
 
        i++;
    }
 
 
    return 0;
}
t_alumno* CARGA(t_alumno arreglo1[T],t_alumno arreglo2[N])
{
    int i=0,j=0,k=0,maximo=0,bandera=1;
 
    t_alumno* lista=NULL;
    lista=malloc(sizeof(struct s_alumno));
 
    for(i=0;i<T;i++)
    {
 
        for(j=0;j<N;j++)
        {
            if(arreglo1[i].numero==arreglo2[j].numero)
            {
                bandera=0;
            }
        }
        if(bandera==1)
 
        {
                if(!esta(lista,arreglo1[i].numero))
                {
                    (lista+k)->numero=arreglo1[i].numero;
                k++;
                lista=realloc(lista,(1+k)*sizeof(struct s_alumno));
                }
 
 
 
        }
        bandera=1;
    }
 
    /// Proceso Inverso
 
 
    for(i=0;i<N;i++)
    {
        for (j=0;j<T;j++)
        {
            if(arreglo2[i].numero==arreglo1[j].numero)
            {
                bandera=0;
            }
        }
            if(bandera==1)
            {
                (lista+k)->numero=arreglo2[i].numero;
                k++;
                lista=realloc(lista,(1+k)*sizeof(struct s_alumno));
            }
            bandera=1;
    }
 
    (lista+k)->numero=0;
 return lista;
}
 
int esta (t_alumno*lista ,int numero)
{
 
 
    int k=0;
    while((lista+k)!=NULL)
    {
        if((lista+k)->numero==numero)
        {
            printf("%d - ",(lista+k)->numero);
            return 1;
        }
        k++;
 
    }
    return 0;
}
 

Hola

Tengo que hacer un ejercicio en el cual tengo que ir recorriendo un arreglo dinamico de caracteres en forma recursiva para saber si es palindromo o no.
La funcion recibe el arreglo dinamico y la longitud de la palabra.
Mi problema creo que es el IF, voy printeando lo que sucede y nose porque la funcion sigue mas alla de lo que yo querria...es decir..la idea es que corte cuando la longitud sea mayor a cero, y voy viendo que llega hasta el -5 y no se porque...hice el recorrido de la funcion en  papel, y tampoco encuentro el error..es como que sigue y no se porque

#include <stdio.h>
#include <stdlib.h>
int palindromo(char*arreglo,unsigned int longitud);
int main()
{
    char*arreglo=NULL;
    int r;
    arreglo=malloc(sizeof(500));
    arreglo="ana";
    printf("%s",arreglo);
    r=palindromo(arreglo,3);
    printf("\nEl valor es %d",r);
    return 0;
}
 
int palindromo(char*arreglo,unsigned int longitud)
{
    printf("Longitud: %d",longitud);
    if(longitud>0)
    {
        printf("La letra del arreglo es: %c - La letra a comparar al final es: %c - La longitud es: %d \n",*(arreglo),*(arreglo+longitud-1),longitud);
        if((*arreglo)==(*(arreglo+longitud-1)))
        {
 
            return palindromo(arreglo+1,longitud-2);
        }
        else
        {
            return 0;
        }
    }
    else
    {
     return 1;
    }
 
}

Tengo el siguiente ejercicio que no se que es lo que esta fallando. 
Tengo una estructura  en la cual tengo:

- Una variable int que carga el legajo de un alumno (un numero cualquiera)
- Un puntero char, en donde se va a guardar el nombre del alumno (Ejemplo Juan)
- Un unsigned char en donde se guarda el codigo de una materia. (Ejemplo CATEGORIA B).

En el main lo que hago es cargar un arreglo estatico de esta estructura.
Lo que tengo que hacer con la funcion filtrar es crear un arreglo dinamico que cree e incluya los valores del arreglo estatico que tengan la categoria B.
No se cual es el error, pensaba que era algo de memoria dinamica que estaba fallando, pero puse una memoria grande e igualmente el programa falla.

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define T 3
struct s_alumno
{
    unsigned int leg;
    char*nombre;
    unsigned char cod_car;
};
typedef struct s_alumno t_alumno;
t_alumno* filtrar(t_alumno arr[T],char cod_car);
void IMPRIMIR(t_alumno*);
 
int main()
{
    t_alumno arr[T];
    int i=0;
    char letra;
    t_alumno* listado=NULL;
    arr[0].nombre="Fabian";
    arr[1].nombre="Pablo";
    arr[2].nombre="Manuel";
    while(i<T)
    {
        printf("\nCARGAR NUMERO LEGAJO:\n ");
        scanf("%d",&arr[i].leg);
        printf("CARGAR CODIGO CARRERA\n");
        letra=getche();
        arr[i].cod_car=letra;
        i++;
    }
    printf("\n");
    printf("El nombre cargado es %s - CODIGO DE CARRERA: %c\n",arr[0].nombre,arr[0].cod_car);
    printf("El nombre cargado es %s - CODIGO DE CARRERA: %c\n",arr[1].nombre,arr[1].cod_car);
    printf("El nombre cargado es %s - CODIGO DE CARRERA: %c\n",arr[2].nombre,arr[2].cod_car);
    listado=filtrar(arr,'B');
    IMPRIMIR(listado);
 
    return 0;
}
 
 
t_alumno* filtrar(t_alumno arr[T],char cod_car)
{
    int i=0,j=0,fin=0;
    t_alumno*lista=NULL;
    lista=malloc(sizeof(struct s_alumno));
    while(i<T)
    {
        if((cod_car)==arr[i].cod_car)
        {
            (lista+j)->leg=arr[i].leg;
            strcpy((lista+j)->nombre,arr[i].nombre);
            (lista+j)->cod_car=arr[i].cod_car;
            j++;
           lista=realloc(lista,(j+1)*sizeof(struct s_alumno));
        }
        i++;
    }
    (lista+j)->leg=0;
    printf("\nTERMINO EL FILTRADO\n");
    return lista;
 
}
 
void IMPRIMIR(t_alumno* listado)
 
{
 int i=0;
 printf ("\nIMPRESION DEL ARREGLO\n");
 while(listado[i].leg!=0)
 {
     printf("NOMBRE: %s - CODIGO DE CARREA: %c\n",(listado+i)->nombre,(listado+i)->cod_car);
     i++;
 }
}
 

Hola.
Tengo el siguiente codigo para que me de el minimo de un arreglo dinamico.
Mi consulta es, si hay alguna forma mas simple de hacerlo, ya que para usar esto, tendria que mandarle desde el main 2 veces el arreglo para que compare...

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 5
int * minArrHeap(int *, int *);
 
int main()
{
    int * arrHeap, i;
    arrHeap=malloc(N*sizeof(int));
    srand(time(NULL));
    for(i=0; i<N-1; i++)
    {
        arrHeap[i]=rand()%9+1;
    }
    arrHeap[i]=0;
    printf("Arreglo al azar: \n");
    for(i=0; i<N; i++)
    {
        printf("%d ", arrHeap[i]);
    }
    printf("\n\nMinimo: %d direccion:%p \n\n", *minArrHeap(arrHeap, arrHeap),  dirMinArrHeap(arrHeap, arrHeap));
 
    return 0;
}
 
int * minArrHeap(int * ptr, int *min)
{
    if(*ptr==0)
    return min;
    if(*ptr<*min)
    minArrHeap(ptr+1, ptr);
    else
    minArrHeap(ptr+1, min);
}