Mensajes

Ok, veo porque usa un puntero doble. Quiere hacer un int array dentro de un struct. Debe hacer asi:

Código [Seleccionar] Expandir


typedef struct Humano
{
   int* Trabajos;          
} HUMANO, *PHUMANO;    
   
int main ()
{
      // eso coresponde al tomano de su array
      int NumeroDeElementos = 30;
      PHUMANO Primera = (PHUMANO)malloc(sizeof(HUMANO));

      Primera->Trabajos = (int*)malloc(sizeof(int) * NumeroDeElementos);
     
      // nunca debe hacer eso por que es allocacion dinamica y eso es un valor estatico pero
     // solo es pra mostrar como funciona
      Primera->Trabajos[15] = 248;

      printf("Primera->Trabajos = %i\n", Primera->Trabajos[15]);
     
      free((int*)Primera->Trabajos);
      free(Primera);
      return 0;
}




modificaion - se me olvido poner un *

Primero muchas gracias por darte el tiempo de sacarme esta duda hermano, en verdad te lo agradezco.

1-Porque el vector de tipo  persona es dinámico y contiene otro vector dinámico en su interior.

2- Pero cada persona será representada por la casilla del vector, y esa casilla/persona tiene asignadas muchas tareas (que en este caso es 4 por ej), según el programa y los for que tengo, puedo moverme por las tareas pero no por las personas (pues no puedo agregar un contador "i" a la persona para irla recorriendo (la idea es no agregar variables al struct y usar lo que está).

Este ejemplo de 32 es sumamente improvisado, es sólo para tener la idea, pero ud que cambiaría para que el programa pueda imprimir del 1 al 32 y que no imprima el 29,30,31 y 32 ocho veces?

Así como ejemplo mi programa está así:

Código (c) [Seleccionar] Expandir

#include <stdio.h>

typedef struct humano{

int *trabajos;

}persona;

int main(){

int i,j,cont=1;
int cantidad_personas=8;
int cantidad_trabajos=4;
persona *primera;
primera=(persona *)malloc(sizeof(persona)*cantidad_personas);

primera->trabajos=(int *)malloc(sizeof(int)*cantidad_trabajos);


for (i = 0; i < cantidad_personas; i++){
for (j = 0; j < cantidad_trabajos; j++){

primera->trabajos[j]=cont;
cont++;
}
}

for (i = 0; i < cantidad_personas; i++){
for (j = 0; j < cantidad_trabajos; j++){

printf("%d ",primera->trabajos[j]);
}
printf("\n");
}

return 0;
}

Y en un mundo ideal, lo que yo quiero es que avance por las personas y los trabajos así (aclaro este no compila pero si compilara haría lo que yo quiero(bajo una logica algoritmica)):

Código (c) [Seleccionar] Expandir

#include <stdio.h>

typedef struct humano{

int *trabajos;

}persona;

int main(){

int i,j,cont=1;
int cantidad_personas=8;
int cantidad_trabajos=4;
persona *primera;
primera=(persona *)malloc(sizeof(persona)*cantidad_personas);

primera->trabajos=(int *)malloc(sizeof(int)*cantidad_trabajos);


for (i = 0; i < cantidad_personas; i++){
for (j = 0; j < cantidad_trabajos; j++){

primera[i]->trabajos[j]=cont;
cont++;
}
}

for (i = 0; i < cantidad_personas; i++){
for (j = 0; j < cantidad_trabajos; j++){

printf("%d ",primera[i]->trabajos[j]);
}
printf("\n");
}

return 0;
}


Ud cómo le haría/modificaría tomando en cuenta el mismo ejemplo que le muestro?

Simple:

Código (c) [Seleccionar] Expandir

primera -> trabajos = malloc(...);

Saludos

Por ahí como que funciona pero con errores. Por ejemplo hice esta cosa que tiene que imprimir por pantalla del 1 al 32, pero sólo imprime los últimos 4 números(29,30,31,32) ocho veces.

Código (c) [Seleccionar] Expandir

#include <stdio.h>

typedef struct humano{

int *trabajos;

}persona;

int main(){

int i,j,cont=1;
int cantidad_personas=8;
int cantidad_trabajos=4;
persona *primera;
primera=(persona *)malloc(sizeof(persona)*cantidad_personas);

primera->trabajos=(int *)malloc(sizeof(int)*cantidad_trabajos);


for (i = 0; i < cantidad_personas; i++){
for (j = 0; j < cantidad_trabajos; j++){

primera->trabajos[j]=cont;
cont++;
}
}

for (i = 0; i < cantidad_personas; i++){
for (j = 0; j < cantidad_trabajos; j++){

printf("%d ",primera->trabajos[j]);
}
printf("\n");
}

return 0;
}

Y si le pongo un contador a primera (es decir

Código (c) [Seleccionar] Expandir

primera [i] -> no me compila ) qué pasa?

Que tal chicos y chicas,disculpen la pregunta pero me puse ante los diversos casos en el manejo de structs y éste (que creo que es básico) no lo puedo hacer.

Código (c) [Seleccionar] Expandir

#include <stdio.h>

typedef struct humano{

int *trabajos;

}persona;

int main(){

int cantidad_personas=8;
int cantidad_trabajos=4;
persona *primera;
primera=(persona *)malloc(sizeof(persona)*cantidad_personas);

/* Hasta este punto por lo que entiendo hice un arreglo dinamico en donde
  ubicamos a la persona en un espacio del arreglo*/

//Ahora bien cada persona tendrá más de un trabajo por lo cual el puntero
//trabajo (*trabajos) debemos convertirlo en un vector.

return 0;
}

Mi pregunta es ¿cómo hago eso? el *primera que es de tipo persona lo transformamos en un vector dinámico, pero una vez hecho eso ¿Cómo transformo el puntero que ésta dentro de *primera en otro vector?

De antemano muchas gracias.

Recomendación personal amigo. Siempre cuando estés leyendo muchas cadenas de caracteres ocupa

Código (c) [Seleccionar] Expandir

fflush(stdin);

antes y/o despues de los scanf o los getch. Lo que hace esa función es limpiarte el buffer para que la próxima lectura no se vea afectada en ninguna medida por la lectura anterior. Siempre que quieras prevenir que algo malo pase con las lecturas de cadenas, ponlo (funciona como un parche por decirlo así  ). Si eso no lo soluciona entonces es un problema del código en si.


Eso, espero te sirva para afrontar futuros casos  .

lo que no entiendo es por qué no puedes adaptar el codigo... si es por las variables solo haces array y listo, busca sobre array en c++ y el pase como parametro

Perdón por no expresarme tan bien amigo, error mio .Ya se ocupar los arrays, eso no es problema.

Ya Hice todo lo que debía, adapté el programa anterior en C pero el programa no me funciona como quiero...

Aquí están las funciones adaptadas en C, espero me puedan decir si ven algo mal...

Código (c) [Seleccionar] Expandir

typedef struct nino{
int X;
int Y;
}nino;

typedef struct muro{
int X1;
int X2;
int Y1;
int Y2;
}muro;

void Analizar(nino vec_nino[] , muro vec_muro[], int cant_ninos, int cant_muros, int nino_bus,int cant_vistos[]);
int Interseccion(nino vec_nino[],muro vec_muro[],int i,int j,int cant_muros);
float formula_heron(float dis1, float dis2, float dis3);
int lado_punto(float Area_trian);

Código (c) [Seleccionar] Expandir

int main(){

int nino_bus,cant_ninos,cant_muros,i;

nino vec_nino[10000];
muro vec_muro[10000];
int cant_vistos[10000];

scanf("%d",&nino_bus);
scanf("%d",&cant_ninos);
scanf("%d",&cant_muros);

for (i = 0; i < cant_ninos; i++){

scanf("%d %d",&vec_nino[i].X,&vec_nino[i].Y);
}

for (i = 0; i < cant_muros; i++){

scanf("%d %d %d %d",&vec_muro[i].X1,&vec_muro[i].Y1,&vec_muro[i].X2,&vec_muro[i].Y2);
}

Analizar(vec_nino,vec_muro,cant_ninos,cant_muros,nino_bus,cant_vistos);

printf("\n");

for (i = 0; i < nino_bus; i++){
printf("%d\n",cant_vistos[i]);
}

return 0;
}

Código (c) [Seleccionar] Expandir

void Analizar(nino vec_nino[] , muro vec_muro[], int cant_ninos, int cant_muros,int nino_bus, int cant_vistos[]){

int i,j;

for (i = 0; i < nino_bus; i++){

for (j = 0; j < cant_ninos; j++){

if (i!=j){

cant_vistos[i]=cant_vistos[i]+Interseccion(vec_nino,vec_muro,i,j,cant_muros);

}
}
}
}


Código (c) [Seleccionar] Expandir

int Interseccion(nino vec_nino[],muro vec_muro[],int i,int j,int cant_muros){

int k=0;
float dis1;
float dis2;
float dis3;
float Area_trian;
int lado[4];
int cont=0;
int salida=0;
int basura;

do{


dis1=sqrt((pow((vec_muro[k].X2-vec_muro[k].X1),2) + pow((vec_muro[k].Y2-vec_muro[k].Y1),2)));
dis2=sqrt((pow((vec_muro[k].X2-vec_nino[i].X),2) + pow((vec_muro[k].Y2-vec_nino[i].Y),2)));
dis3=sqrt((pow((vec_muro[k].X1-vec_nino[i].X),2) + pow((vec_muro[k].Y1-vec_nino[i].Y),2)));

Area_trian=formula_heron(dis1,dis2,dis3);
lado[cont]=lado_punto(Area_trian);

cont++;
dis1=sqrt((pow((vec_muro[k].X2-vec_muro[k].X1),2) + pow((vec_muro[k].Y2-vec_muro[k].Y1),2)));
dis2=sqrt((pow((vec_muro[k].X2-vec_nino[j].X),2) + pow((vec_muro[k].Y2-vec_nino[j].Y),2)));
dis3=sqrt((pow((vec_muro[k].X1-vec_nino[j].X),2) + pow((vec_muro[k].Y1-vec_nino[j].Y),2)));

Area_trian=formula_heron(dis1,dis2,dis3);
lado[cont]=lado_punto(Area_trian);

cont++;
dis1=sqrt((pow((vec_nino[i].X-vec_nino[j].X),2) + pow((vec_nino[i].Y-vec_nino[j].Y),2)));
dis2=sqrt((pow((vec_muro[k].X1-vec_nino[i].X),2) + pow((vec_muro[k].Y1-vec_nino[i].Y),2)));
dis3=sqrt((pow((vec_muro[k].X1-vec_nino[j].X),2) + pow((vec_muro[k].Y1-vec_nino[j].Y),2)));

Area_trian=formula_heron(dis1,dis2,dis3);
lado[cont]=lado_punto(Area_trian);

cont++;
dis1=sqrt((pow((vec_nino[i].X-vec_nino[j].X),2) + pow((vec_nino[i].Y-vec_nino[j].Y),2)));
dis2=sqrt((pow((vec_muro[k].X2-vec_nino[i].X),2) + pow((vec_muro[k].Y2-vec_nino[i].Y),2)));
dis3=sqrt((pow((vec_muro[k].X2-vec_nino[j].X),2) + pow((vec_muro[k].Y2-vec_nino[j].Y),2)));

Area_trian=formula_heron(dis1,dis2,dis3);
lado[cont]=lado_punto(Area_trian);

if (lado[0]==2 || lado[1]==2 || lado[2]==2 || lado[3]==2){

return 1;


}else if (((lado[0]==1 && lado[1]==0) || (lado[0]==0 && lado[1]==1)) && ((lado[2]==0 && lado[3]==1) || (lado[2]==1 && lado[3]==0))){

salida=1;
}else{
}

cont=0;
k++;

}while(k!=cant_muros-1 || salida!=1 );

if (k==cant_muros-1 && salida!=1){

return 1;
}else{

return 0;
}

}

Código (c) [Seleccionar] Expandir

float formula_heron(float dis1, float dis2, float dis3){

float s,resultado;

s=(dis1+dis2+dis3)/2;
resultado = sqrt(s*(s-dis1)*(s-dis2)*(s-dis3));
return resultado;
}

Código (c) [Seleccionar] Expandir

int lado_punto(float Area_trian){

int lado;

if (Area_trian >0){

lado=1;
}else if (Area_trian<0){

lado=0;
}else{

lado=2;
}

return lado;
}


Puse todo para que se entendiera de donde saqué las cosas simplemente. Me parece que la función Intersección tiene un fallo al momento de realizar los operadores lógicos en el If y else(recordar que es una adaptación del código python que postee).

Si pueden ver algo malo en la adaptación de la función intersección porfavor digame, aunque sea una idea puede que sea acertada.

[!=]

Si (y2 - y1 ) / ( x2 - x1 ) !=  (y4 - y3 )  / ( x4 - x3 ) ==> Se cortan.

Si (y2 - y1 ) / ( x2 - x1 ) =  (y4 - y3 )  / ( x4 - x3 ) ==> Son paralelas o coincidentes.

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

Primero que todo, muchas gracias por darte el tiempo de contestar amigo, se agradece . La formula que me dio hermano es para rectas, y como yo estoy trabajando con segmentos (es decir que tienen limite/extremos) no me sirve...

Igual muchas gracias

Sólo ve que parámetros quieres seguir (depende que tanto quieras redondear un número).

Si tu enfoque sólo va a los primeros 2 dígitos (de derecha a izquierda obviamente), enfocate en el tercer dígito (que es el que se terminará alterando o no por la aproximación).

algo como:

char num_en_caracteres[10];
int num=2437;
int cant_dig;

num_en_caracteres[10]=atoi(num) //Atoi transforma un numero a cadena.
cant_dig=strlen(num_en_caracteres); //Cuenta la cantidad de digitos que tiene el numero ingresado.

//Ya que la variable num tiene el numero 2437 que son 4 digitos, la variable cant_dig tendra el valor 4.

Ahora ocupas un for para mover bien los indices y dentro de él ocupas un if que tenga la condición (considerando sólo los dos primeros digitos de num) si el numero es mayor o menor a cincuenta) sume uno a al tercer digito y deje los primeros dos en 0 o simplemente que deje los primeros dos en cero (dependiendo de si era mayor o no a 50).

Eso, Te lo dejé muy detallado. Ahora sólo queda poner de tu parte para hacer el código y lo adaptes a lo que quieres.

Saludos.

aplica las ecuaciones de recta para los puntos y la intercepciones de rectas

Si se eso amigo, pero me joden ciertas cosas. Por ejemplo, tengo un prototipo en paython que ya me dio la idea, el cual es éste:

Código (python) [Seleccionar] Expandir

def area_triang(a,b,c):
      return (b[0]-a[0])*(c[1]-a[1])-(c[0]-a[0])*(b[1]-a[1])

def side_p_to_seg(v1,v2,p):
    area = area_triang(v1,v2,p)
    if area > 0 :
        lado = "izq"
    elif area < 0 :
        lado = "der"
    else:
        lado = "col"
    return lado


def seg_intersection(u1,u2,v1,v2):
if (side_p_to_seg(u1,u2,v1) == "col" or
     side_p_to_seg(u1,u2,v2) == "col" or
     side_p_to_seg(v1,v2,u1) == "col" or
     side_p_to_seg(v1,v2,u2) == "col"):
     return False
elif (((side_p_to_seg(u1,u2,v1) == "izq" and
         side_p_to_seg(u1,u2,v2) == "der") or
        (side_p_to_seg(u1,u2,v1) == "der" and
         side_p_to_seg(u1,u2,v2) == "izq"))and
       ((side_p_to_seg(v1,v2,u1) == "der" and
         side_p_to_seg(v1,v2,u2) == "izq") or
        (side_p_to_seg(v1,v2,u1) == "izq" and
         side_p_to_seg(v1,v2,u2) == "der"))):
  return True
else:
  return False


Entiendo todo, pero mi problema es que en el programa (y en muchas otras partes que he buscado) definen cada punto del segmento con una sola variable:

EJ: R1=A ,B (siendo A un punto y B otro)

Y lo que yo debo usar es:

R1=(x1,y1) (x2,y2) [siendo dos variables cartesianas (x e y) un punto, y otros dos el otro punto.

Entonces, como puedo decir que un punto es mayor o menor a otro si ocupo coordenadas cartesianas para definir a cada punto?

Se me ocurrió que x1>x2 && y1>y2, si se cumple entonces el punto (x1,y1) es mayor, y de forma analoga si x1<x2 && y1<y2 entonces el punto (x2,y2 es mayor). Pero que ocurre si por ejemplo x1<x2 && y1>y2? entonces el punto es mayor, menor o que?

Necesito dilucidar eso...

Hola, disculpen las molestias pero me gustaría saber como se hace esto en lenguaje C:

Tengo 4 puntos que representan dos segmentos en el plano cartesiano y cada uno de estos puntos está definido obviamente por dos coordenadas x e y.

EJ:

R1= (x1,y1) (x2,y2)
R2= (x3,y3) (x4,y4)

Bueno, en si tengo que hacer un programa que me pide muchas cosas, pero ésta parte en especifico (ver si dos segmentos se intercectan o no) no se me ha podido ocurrir. Alguien me puede orientar porfavor?

Mi problema fundamental es como se definen los puntos...

EJ: R1=A ,B (siendo A un punto y B otro)

Y lo que yo debo usar es:

R1=(x1,y1) (x2,y2) [siendo dos variables cartesianas (x e y) un punto, y otros dos el otro punto.

Entonces, como puedo decir que un punto es mayor o menor a otro si ocupo coordenadas cartesianas para definir a cada punto?

Se me ocurrió que x1>x2 && y1>y2, si se cumple entonces el punto (x1,y1) es mayor, y de forma analoga si x1<x2 && y1<y2 entonces el punto (x2,y2 es mayor). Pero que ocurre si por ejemplo x1<x2 && y1>y2? entonces el punto es mayor, menor o que?

Necesito dilucidar eso...


Muchas gracias de antemano por las molestias.