Accoppiamenti..

di il
20 risposte

Accoppiamenti..

Devo scrivere un programma in linguaggio C date tre liste di numeri interi casuali costruite con la funzione /inserisci_testa,
determini la lista con il minor nuero di nodi tra le tre liste,
costruisca una lista degli accoppiamenti' possibili delle tre liste tramite una funzione, stampi la lista degli accoppiamenti tramite una funzione, rimuova dagli accoppiamenti tutti i nodi la cui somma sia un numero pari tramite una funzione, si conti il numero di nodi delle singole liste tramite una opportuna funzione. MI SONO PERSO SUGLI ACCOPPIAMENTI DELLE 3 LISTE, QUALCUNO PUÒ AIUTARMI SULLA FUNZIONE CON I 3 CICLI DI WHILE… Grazie anticipatamente.
ps: ho già svolto praticamente tutto il programma (a penna) ora dovrei solo fare il punto della funzione degli accoppiamenti, se avessi scritto il programma intero su kate, lo manderei .

20 Risposte

  • Re: Accoppiamenti..

    Non ho capito che intendi per accoppiamenti. In ogni nodo della nuova lista ci devono stare i valori di due liste? Puoi postare il codice di almeno un accoppiamento e delle strutture dei nodi?
  • Re: Accoppiamenti..

    Es. L1=(1,2,3), L2=(4,5), L3-(6,7) L1xL.2XL3-[(1,4,6), (1,4,7), (1,5,6), (1,5,7), ....)
  • Re: Accoppiamenti..

    A me dalla traccia sembra più una cosa del genere:
    Es. L1xL2= [(1,4), (2,5)]
    Infatti chiede anche di trovare la lista più breve.

    Comunque se è come dici tu, i 3 cicli devono essere annidati e quelli più esterni devono resettare quelli più interni quando questi finiscono.
  • Re: Accoppiamenti..

    Si devo fare 3 cicli annidati..
    while(L1!=NULL)
    {
    while(L2!=NULL)
    {
    while(L3!=NULL)
    {
    }
    }
    }

    però non so cosa scrivere nei cicli per unire (ad es l’elemento 1 della lista 1 con lelemento 1 della lista 2 3 poi 1-1-2 poi -123 e così via)….
  • Re: Accoppiamenti..

    Intanto la lista risultante deve avere nodi con tre valori. Una cosa del genere:
    
    struct List3{
        int v1;
        int v2;
        int v3;
        struct List3* next;
    } 
    

    Come prendi i 3 valori? L1->val e prendi il valore corrente della prima lista, ecc... E li usi per costruire il nuovo nodo.

    Si può anche fare una lista dove ogni nodo contiene un'altra lista, ma così è più semplice.
  • Re: Accoppiamenti..

    Ora ti mando il codice del programma così guardi e vedi meglio..
    #include<stdio.h>
    #include<time.h>
    #include<stdlib.h>

    typedef struct nodo
    {
    int valore;
    struct nodo *next;
    }
    }nodoP;
    //struttura


    //prototipi

    nodoP *inserisci_testa(nodoP *testa,int dato); int conta_nodi(nodoP *testa); nodoP *accoppiamenti(nodo *testa1,nodoP *testa2,nodoP *testa3);
    int main()
    {
    srand(time(NULL));

    nodoP *testa1=NULL;
    nodoP *testa2=NULL;
    nodoP *testa3=NULL;
    nodoP *accoppiamento=NULL;
    int num_nodi1;
    int num_nodi2;
    int num_nodi3;
    int i;
    int dato;
    //dichiarazioni + 3 liste + lista accoppiamento

    printf("inserisci numero dei nodi della prima lista: ");
    scanf("%d";num_nodi1);
    printf("inserisci numero dei nodi della seconda lista: ");
    scanf("%d";num_nodi2);
    printf("inserisci numero dei nodi della terza lista: ");
    scanf("%d";num_nodi3);
    //inserimento numero dei nodi delle 3 liste

    for(i=0;i<num_nodi1;i++)
    {
    dato=rand()%100;
    testa1=inserisci_testa(testa1, dato);
    }
    for(i=0;i<num_nodi2;i++)
    {
    dato=rand()%100;
    testa2=inserisci_testa(testa2, dato);
    }
    for(i=0;i<num_nodi3;i++)
    {
    dato=rand()%100;
    testa3=inserisci_testa(testa3, dato);
    }
    //inserimento dati casuali nelle 3 liste

    num_nodi1=conta_nodi(testa1);
    num_nodi2=conta_nodi(testa2);
    num_nodi3=conta_nodi(testa3);
    //conta nodi

    if(conta_nodi(testa1)<conta_nodi(testa2) && conta_nodi(testa1)<conta_nodi(testa3))
    {
    printf("la prima lista è la minore");
    }

    else if(conta_nodi(testa2)<conta_nodi(testa1) && conta_nodi(testa2)<conta_nodi(testa3))
    {
    printf("la seconda lista è la minore");
    }
    else
    {
    printf("la terza lista è la minore");
    }
    //if e else per la lista con minori nodi


    }







    //funzioni
    nodoP *inserisci_testa(nodoP *testa; int dato)
    {
    nodoP *p=NULL;
    p=maccol(sizeof(nodoP));
    p->valore=dato;
    p->next=testa;
    testa=p;
    return testa;
    }

    int conta_nodi(nodoP *testa)
    {
    int num_nodi=0;
    nodoP *p=testa;
    while(p!=NULL)
    {
    num_nodi=num_nodi+1;
    p=p->next;
    }
    return num_nodi;
    }

    void stampa_accoppiamento(nodoP *p)
    {
    while(p!=NULL)
    {
    printf("valore : %d ", accoppiamento->valore);
    p=p->next;
    }
    }
  • Re: Accoppiamenti..

    Il codice va messo nel tag code come ho fatto io sopra e possibilmente indentato, che è più leggibile.

    Comunque non serviva, stavamo dicendo cosa mettere in quei tre while. Nel terzo while devi prendere i valori puntati da L1, L2 e L3 e aggiungerli a una quarta lista.
  • Re: Accoppiamenti..

    È questo il punto… ho provato in varie scritture le cose da inserire nel while in modo che 1(2,3) 2(6,7) 3(5,9) diventi 4 (2,6,5; 2,6,9 ; 2,7,5 ; 2,7,9; 3,6,5 …) ma non trovo i codici giusti…potresti aiutarmi tu nel dettaglio
  • Re: Accoppiamenti..

    Però attenzione deve essere una funzione
  • Re: Accoppiamenti..

    umbo ha scritto:


    è questo il punto… ho provato in varie scritture le cose da inserire nel while in modo che 1(2,3) 2(6,7) 3(5,9) diventi 4 (2,6,5; 2,6,9 ; 2,7,5 ; 2,7,9; 3,6,5 …) ma non trovo i codici giusti…potresti aiutarmi tu nel dettaglio
    Postane una. Solo i while, non tutto il resto.
  • Re: Accoppiamenti..

    NodoP *accoppiamenti(nodoP *testa1,nodoP *testa2,nodoP *testa3)
    {
    nodoP *p=testa1;
    nodoP *p=testa2;
    nodoP *p=testa3;
    nodoP *p=accoppiamento;
    p=valore->dato;
    while(accoppiamento!=NULL)
    accoppiamento
    while(testa1!=NULL)
    {
    p=accoppiamento;
    while(testa2!=NULL)
    {
    p=accoppiamento
    p=p->next;
    while(testa3!=NULL)
    {
    p=accoppiamento
    p=p->next;
    }
    }
    p=p->next;
    }
    p=p->next;
    }
    }

    Bozza molto lontana…
  • Re: Accoppiamenti..

    Non puoi dichiarare 3 variabili con lo stesso nome (p). Chiamale p1, p2 e p3.
    L'unica cosa che devi fare, nel terzo while, è inserire in "accoppiamento" p1->valore, p2->valore e p3->valore. Per farlo chiama la funzione "inserisci_testa" 3 volte.

    PS: quanto posti il codice usa il tag che. Selezionalo è premi il pulsante in alto "</>"
  • Re: Accoppiamenti..

    
    
    #include<stdio.h>
    #include<time.h>
    #include<stdlib.h>
    
    typedef struct nodo
    {
      int valore;
      struct nodo *next;
    }nodoP;
    //struttura 
    
    
    //prototipi
    nodoP *inserisci_testa(nodoP *testa,int dato);
    int conta_nodi(nodoP *testa); 
    void stampa_testa (nodoP *testa);
    void stampa_accoppiamenti (nodoP *accoppiamenti);
     nodoP *accoppiamenti(nodoP *testa1,nodoP *testa2,nodoP *testa3, int dato);
    
    int main()
    {
      srand(time(NULL));
      
      nodoP *testa1=NULL;
      nodoP *testa2=NULL;
      nodoP *testa3=NULL;  
      nodoP *accoppiamenti=NULL;
      testa1=malloc(sizeof(nodoP));
      testa2=malloc(sizeof(nodoP));
      testa3=malloc(sizeof(nodoP));
      accoppiamenti=malloc(sizeof(nodoP));
      int num_nodi1;
      int num_nodi2;
      int num_nodi3;
      int i;
      int dato;
        
      printf("inserisci numero dei nodi della prima lista: ");
      scanf("%d",&num_nodi1);
      printf("inserisci numero dei nodi della seconda lista: ");
      scanf("%d",&num_nodi2);
      printf("inserisci numero dei nodi della terza lista: ");
      scanf("%d",&num_nodi3);
       
        for(i=0;i<num_nodi1;i++)
        {
          dato=rand()%100;
          testa1=inserisci_testa(testa1, dato);
      }
       for(i=0;i<num_nodi2;i++)
        {
          dato=rand()%100;
          testa2=inserisci_testa(testa2, dato);
      }
       for(i=0;i<num_nodi3;i++)
        {
          dato=rand()%100;
          testa3=inserisci_testa(testa3, dato);
      }
    
        num_nodi1=conta_nodi(testa1);
        num_nodi2=conta_nodi(testa2);
        num_nodi3=conta_nodi(testa3);
    
    
        if(conta_nodi(testa1)<conta_nodi(testa2) && conta_nodi(testa1)<conta_nodi(testa3)) 
      {
        printf("la prima lista è la minore \n");
      } 
         
      else if(conta_nodi(testa2)<conta_nodi(testa1) && conta_nodi(testa2)<conta_nodi(testa3)) 
      {
        printf("la seconda lista è la minore \n");
      }  
      else
      {
        printf("la terza lista è la minore \n");
      }  
    
    
    stampa_testa(testa1);
    stampa_testa(testa2);
    stampa_testa(testa3);
    stampa_accoppiamenti(accoppiamenti);
    }
    
    
    
    
    
    
    
    //funzioni
    nodoP *inserisci_testa(nodoP *testa, int dato)
    {
      nodoP *p=NULL;
      p=malloc(sizeof(nodoP));
      p->valore=dato;
      p->next=testa;
      testa=p;
      return testa;
    }
    
    int conta_nodi(nodoP *testa)
    {
      int num_nodi=0;
      nodoP *p=testa;
      while(p!=NULL)
      {
        num_nodi=num_nodi+1;
        p=p->next;
      }
      return num_nodi;
    }
    
    void stampa_accoppiamenti (nodoP *accoppiamenti) {
      printf("valori degli accoppiamenti: \n");
    nodoP *p=accoppiamenti;
     while (p->next!=NULL) {
     printf ("%d\n",p->valore);
     p=p->next;}
    }
    
    
    void stampa_testa (nodoP *testa) {
     printf("valori della lista: \n");
     nodoP *p=testa;
     while (p->next!=NULL) {
     printf ("%d\n",p->valore);
     p=p->next;}
    }
     
     nodoP *accoppiamenti(nodoP *testa1,nodoP *testa2,nodoP *testa3, int dato)
     {
    
    nodoP *p1=testa1;
    nodoP *p2=testa2;
    nodoP *p3=testa3;
    nodoP *p=accoppiamenti;
     p->valore=dato;
    while(accoppiamenti!=NULL)
    {
    
    
    while(testa1!=NULL)
    {
    p1=p;
    
    while(testa2!=NULL)
    {
    p2=p;
    
    
    while(testa3!=NULL)
    {
    p3=p;
    p3=p3->next;
    }
    
    p2=p2->next;
    }
    
    p1=p1->next;
    }
          testa1=inserisci_testa(testa1, dato);
          p1->valore;
          testa2=inserisci_testa(testa2, dato);
          p2->valore;
          testa3=inserisci_testa(testa3, dato);
          p3->valore;
    }
     }
    
    
    ho fatto tutto, lo stesso nn va…
  • Re: Accoppiamenti..

    Prova così (do per scontato che il resto funzioni)

    nodoP *accoppiamenti(nodoP *testa1,nodoP *testa2,nodoP *testa3)
    {
       nodoP *accoppiamento;
       
       nodoP *p1=testa1;
       while(p1 != NULL)
       {
            nodoP *p2=testa2;
            while(p2 != NULL)
            {
                nodoP *p3=testa3;
                while(p3 != NULL)
                {
                    accoppiamento = inserisci_testa(accoppiamento, testa1->valore);
                    accoppiamento = inserisci_testa(accoppiamento, testa2->valore);
                    accoppiamento = inserisci_testa(accoppiamento, testa3->valore);
                    p3 = p3->next;
                }
                p2 = p2->next;
                
            } //while(p2 != NULL)
            
           p1 = p1->next;
       } //while(p1 != NULL)
       
       return accoppiamento;
    }

    Tieni presente, però, che con l'inserimento in testa il primo elemento (la testa) corrisponde all'ultimo inserito.

Devi accedere o registrarti per scrivere nel forum
20 risposte