Hola

Estoy haciendo un programa en el cual tengo que agregar elementos a una lista, luego imprimir la lista y luego crear otra lista en el cual se rellene con los valores de la lista anterior de manera invertida.
El ejercicio parece simple. El problema es que yo uso la funcion pop, que tengo entendido que retorna el ultimo valor de la lista y no me esta retornando el ultimo elemento, sino que primero retorna el primero, luego el segundo y asi...
Dejo mi codigo, supongo que sera algo muy facil pero no le encuentro el defecto a las funciones que programe.

/*Ejercicio 5.6
Programar una función que invierta una lista de enteros. Considere que la lista puede estar vacía*/
 
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
 
struct s_nodo
{
    int valor;
    struct s_nodo*sig;
};
typedef struct s_nodo *t_nodo;
 
void agregar(t_nodo*,int);
void imprimirLista(t_nodo);
void invertirLista(t_nodo*,t_nodo*);
int pop(t_nodo*);
 
int main()
{
    t_nodo lista=NULL;
    t_nodo inversa=NULL;
    agregar(&lista,1);
    agregar(&lista,3);
    agregar(&lista,5);
    agregar(&lista,7);
    printf("\nLista impresa = ");
    imprimirLista(lista);
    invertirLista(&lista,&inversa);
    printf("\nLista inversa = ");
    imprimirLista(inversa);
    return 0;
}
 
void agregar(t_nodo* nodo,int valor)
{
    if(*nodo==NULL)
    {
        *nodo=(t_nodo)malloc(sizeof(struct s_nodo));
        if(*nodo==NULL)
            return;
        (*nodo)->valor=valor;
        (*nodo)->sig=NULL;
    }
    else
        agregar(&((*nodo)->sig),valor);
}
 
void imprimirLista(t_nodo lista)
{
    while(lista!=NULL)
    {
        printf(" %d  ",lista->valor);
        lista=lista->sig;
    }
}
 
void invertirLista(t_nodo *lista,t_nodo* inversa)
{
    int valor;
    while(*lista!=NULL)
    {
        valor=pop(lista);
        agregar(inversa,valor);
    }
}
 
int pop(t_nodo* nodo)
{
    t_nodo aux=*nodo;
    int valor=aux->valor;
    *nodo=aux->sig;
    free(aux);
    return valor;
}

Hola


Tengo una duda con respecto al tratamiento de estructuras en pilas en C.
Si tengo las siguientes estructuras declaradas

struct s_persona
{
    char nombre[25];
    int edad;
    int fnacimiento;
};
typedef struct s_persona tPers;
 
struct s_nodo
{
    struct s_persona prs;
    struct s_nodo *sig;
};
typedef struct s_nodo *t_nodo;
 

Si yo quiero insertar en una pila elementos de tipo tPers

Cual seria la opcion correcta... Esta

void push(t_nodo* pila,tPers persona)
{
    t_nodo aux=NULL;
    aux=(t_nodo)malloc(sizeof(struct s_nodo));
    if(aux==NULL)
        return;
    aux->prs=persona;
    aux->sig=*pila;
    *pila=aux;
}

Osea asignando directamente toda la estructura o pasando cada dato de la estructura de manera individual como en el siguiente codigo

void push(t_nodo* pila,tPers persona)
{
    t_nodo aux=NULL;
    aux=(t_nodo)malloc(sizeof(struct s_nodo));
    if(aux==NULL)
        return;
    strcpy(((*pila)->prs).nombre,persona.nombre);
    aux->prs.edad=persona.edad;
    aux->prs.fnacimiento=persona.fnacimiento;
    aux->sig=*pila;
    *pila=aux;
}

Hola

Tengo el siguiente ejercicio:

Desarrollar una funcion ordenarArr que reciba como parámetro un arreglo dinámico del tipo t_persona.
La función deberá ordenar el arreglo por número de categoría en forma descendente. El números de categoría
se encuentra dentro del unsigned char cat en los cuatro bit mas significativos (los de la izquierda).
El prototipo de la función que deberá utilizar es:

void ordenarArr(t_persona* arr);


Lo que hice fue lo siguiente

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
 
///Estructura
 
struct s_persona
{
    long int dni;
    unsigned char cat;
    char *nombre;
};
typedef struct s_persona t_persona;
 
void ordenarArr(t_persona* arr);
int categoria(unsigned char);
void imprimirArr(t_persona*);
 
int main()
{
    t_persona *arreglo=NULL;
 
    arreglo=malloc(4*sizeof(t_persona));
 
    (arreglo)->dni=746;
    (arreglo)->cat='j';
    (arreglo)->nombre="Marisol";
 
    (arreglo+1)->dni=159;
    (arreglo+1)->cat='f';
    (arreglo+1)->nombre="Juan Martin";
 
    (arreglo+2)->dni=691;
    (arreglo+2)->cat='z';
    (arreglo+2)->nombre="Griselda";
 
    (arreglo+3)->dni=489;
    (arreglo+3)->cat='e';
    (arreglo+3)->nombre="Romeo";
 
    imprimirArr(arreglo);
 
    ordenarArr(arreglo);
 
    imprimirArr(arreglo);
 
    return 0;
}
 
void imprimirArr(t_persona* arreglo)
{
    int i;
    printf("\nImpresion:\n");
    for(i=0;i<4;i++)
    {
        printf("\nDNI = %li",(arreglo+i)->dni);
        printf("\nCat = %c - %d",(arreglo+i)->cat,(arreglo+i)->cat);
        printf("\nNombre = %s",(arreglo+i)->nombre);
        printf("\n\n");
    }
}
 
///FUNCION QUE ME PIDEN
 
 
void ordenarArr(t_persona* arr)
{
    int i,j;
    t_persona aux;
    for(i=0;(arr+i)->dni!=0;i++)
    {
        for(j=i+1;(arr+j)->dni!=0;j++)
        {
            if(((((arr+i)->cat)>>4)&15)<((((arr+j)->cat)>>4)&15))
            {
                aux=*(arr+i);
                *(arr+i)=*(arr+j);
                *(arr+j)=aux;
            }
        }
    }
}

El problema es que hace cualquier cosa menos ordenar y tira error de ejecucion. Nose que hacer.

Gracias, ahi ya entendi.

Disculpa, pense que sabia el tema pero tenia esta duda. No logro entender porque se pasan los 4 bits totalmente hacia la derecha, porque si los paso a la derecha me da un 7 y si yo paso los 4 bits mas significativos a la derecha, hago una mascara y luego los paso nuevamente hacia los bits mas significativos(hacia su posicion inicial), me daria un 112.

Te voy a decir los cambios que haria yo , porque hay algunas cosas que no las se como x ejemplo  flusha, nunca lo use.

1) En el primer for cuando estas cargando los datos del arreglo yo pediria la letra y haria letra=getche(); en vez de usar el scanf y entonces cuando lo queres guardar quedaria

for(i=0;i<20;i++)
{
printf("Ingrese letra");
letra=getche();
vect[i]=letra;
}

Porque yo estoy viendo que lo queres guardar, pero no le pones en que posicion especifica lo queres guardar.

2) En el segundo for que es el ordenamiento o burbujeo en esta linea

if (vect[j]<vect){  

Te falta agregar los corchetes al otro

Quedaria

if (vect[j]<vect[i]){  

Y asi con el resto del for.

3) En el ultimo for, tambien te falta los corchetes, porque vos queres que imprima una letra pero le estas pasando todo el arreglo tenes que poner vect, sino no te sirve para nada hacer un for hasta 20.

Hola

No se nada de C++ pero vos tenes declaradas 3 funciones que son imprime, recibe, burbuja. En los parametros les pasas un arreglo de enteros llamados A[]  , a la otra B[] y en la otra C[].

En el main cuando llamas a las 3 funciones siempre le estas pasando el arreglo nuevo que creaste en el main y al momento de entrar en el cuerpo de cada funcion lo que estas usando es siempre el mismo arreglo, en el prototipo de la funcion le podes cambiar el nombre pero siempre estas usando el mismo arreglo.

Cuando estes en la funcion recibe, esta funcion va a recibir como parametro un arreglo y lo va a nombrar B, pero siempre estas usando el mismo arreglo y los valores que cambies dentro de esa funcion van a modificar al arreglo.

Es decir que si vos a esas 3 funciones que tenes ahi, en vez de ponerles como parametros A,B,C y le pones como parametro por ejemplo "void recibe(int arreglo[]); y le pones de nombre a cada una arreglo, va a funcionar igual, de hecho es mas recomendable que lo hagas asi no te confundis tanto.

En cuanto al codigo es simplemente cargar un arreglo, imprimirlo y hacer el burbujeo para ordenarlo de mayor a menor o de menor a mayor.

Hola

Tengo una duda con respecto a bits en C.

Me piden que haga un programa en donde cada persona ingresada tenga un numero de categoria.

Es decir..

Persona 1 = Horacio
Categoria= W

El problema es que la categoria no me la dan con numeros y me piden que halle la categorai, copio textual "El numero de categoria se encuentra dentro del unsigned char en los cuatro bits mas significativos(los de la izquierda). Entonces me piden que a traves de la letra que ingresaron, que con operaciones de bits, halle la categoria.

Entonces yo hago esto

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
int main()
{
    char letra='w';
    int numero;
 
    numero=letra&(15<<4);
 
    printf("\nEl numero es %d",numero);
 
 
 
    return 0;
}
 

Osea, agarro la letra, uso una mascara de 15 y la corro cuatro lugares y me evalua en esos 4 bits si estan prendidos o no.
El resultado de "w" seria 112, seria la categoria.

El problema es que no se si esa es la categoria correcta.
Porque yo puedo hacer que esos 4 bits mas significativos ponerlos los 4 en la posicion menos significativa y aplicar la mascara de 15, y dejarlos ahi y me daria una categoria 7.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
int main()
{
    char letra='w';
    int numero;
 
    numero=(letra>>4)&15;
 
    printf("\nEl numero es %d",numero);
 
 
 
    return 0;
}
 

Entonces esa es mi duda, cual seria la respuesta correcta?

Hola

Nose que lenguaje estas usando pero con la funcion pow que esta en la libreria math.h del lenguaje C podes hacer lo que queres

pow(base,exponente). Tene en cuenta que devuelve un double.

Por otra parte, para que muestre por pantalla las veces que lo multiplica tendrías que hacer un ciclo de repetición.

While(contador<=exponente)
{
if(contador==0)
{
printf("%d",base);
contador++
}
else
printf("*%d");
contador++;
}
 

Suponiendo que la base es 2 y lo queres elevar a la 7.
Si el contador es un 0 solo imprime el 2.
Luego cuando aumenta el contador, en la proxima vuelta, te imprime el mismo numero pero con el simbolo de la multiplicacion. De esa manera imprimirias.
No lo probe pero si falla hacele alguna que otra modificacion, esa seria la base del programa.

Hola

Modifique la el programa de manera que en vez de cargar directamente la palabra vaya pidiendola.
De esta forma, logro imprimir la lista original, pero no la otra.

Con lo que dijiste tengo dudas en la linea que dice

strcpy(aux->txt,txt);

Nose como modificarlo para que copie el contenido pidiendo memoria como decis.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
 
struct s_nodo
{
    char*txt;
    struct s_nodo*sig;
};
typedef struct s_nodo* t_nodo;
 
char*CARGA();
void AGREGAR(t_nodo*);
t_nodo* filtrar_palabras(t_nodo,t_nodo*,int);
void insertar_ordenado(t_nodo*,char*);
void imprimir(t_nodo);
 
 
int main()
{
    t_nodo original=NULL;
    t_nodo filtrado=NULL;
    int limite;
 
    AGREGAR(&original);
    AGREGAR(&original);
    AGREGAR(&original);
    AGREGAR(&original);
    AGREGAR(&original);
    AGREGAR(&original);
    printf("\nIngrese el limite: ");
    scanf("%d",&limite);
    printf("\nLa lista original es \n");
    imprimir(original);
    filtrado=filtrar_palabras(original,&filtrado,limite);
    printf("\nLa lista filtrada es: \n");
    imprimir(filtrado);
 
 
 
    return 0;
}
 
 
void AGREGAR(t_nodo*nodo)
{
    if(*nodo==NULL)
    {
        *nodo=malloc(sizeof(struct s_nodo));
        (*nodo)->txt=CARGA();
        (*nodo)->sig=NULL;
    }
    else
    {
        AGREGAR(&(*nodo)->sig);
    }
}
 
char*CARGA()
{
    char*texto=NULL;
    char letra;
    int i=0;
    texto=malloc(sizeof(struct s_nodo));
    if(texto==NULL)
    {
        printf("Memoria insuficiente");
        return texto;
    }
 
    letra=getche();
 
    while(letra!='\r')
    {
        *(texto+i)=letra;
        i++;
        texto=realloc(texto,(i+1)*sizeof(char));
        letra=getche();
    }
    *(texto+i)='\0';
    printf("\n");
    return texto;
}
 
 
t_nodo* filtrar_palabras(t_nodo original,t_nodo*filtrado,int longitud)
{
    while(original!=NULL)
    {
        if((strlen(original->txt))>=longitud)
        {
            insertar_ordenado(filtrado,original->txt);
        }
        original=original->sig;
    }
    return filtrado;
}
 
 
void insertar_ordenado(t_nodo*nodo,char* txt)
{
    t_nodo aux=NULL;
    if(*nodo==NULL || ((strcmp((*nodo)->txt,txt))>0))
    {
        aux=malloc(sizeof(struct s_nodo));
        if(aux=NULL)
        {
            printf("Memoria insuficiente");
        }
 
        strcpy(aux->txt,txt);
        aux->sig=*nodo;
        *nodo=aux;
    }
    else
    {
        insertar_ordenado(&(*nodo)->sig,txt);
    }
}
 
void imprimir(t_nodo nodo)
{
    while(nodo!=NULL)
    {
        printf(" - %s - ",nodo->txt);
        nodo=nodo->sig;
    }
}