[C++] esercizio diagonali matrici

Messaggioda selfmademan » 22/09/2017, 13:57

Devo ancora superare l'esame quindi ho continuato a fare esercizi.
"Siano date in ingresso due matrici quadrate di numeri interi M1 e M2,entrambe aventi la stessa dimensione. Scrivere un programma che verifichi se esistono due diagonali , una in M1 e l'altra in M2, che includono gli stessi valori indipendentemente dalla loro posizione e dalla loro frequenza di occorrenza. Per lo svolgimento di tale operazione si considerino solo le diagonali parallele alla diagonale principale. Stampare infine gli elementi delle due diagonali trovate.
Si organizzi il programma in sottoprogrammi."

L'ho risolto e pare che funziona, ma come sempre vorrei avere dei pareri.
EDIT: Piccola modifica al codice.

Codice:
#include <iostream>
#include<cstdlib>
#define nmax 100
using namespace std;
void leggi_vettore(int dim,int V[])
{
    for(int i=0;i<dim;i++)
    {
        cout<<"\nInserisci l'elemento "<<i+1<<" ";
        cin>>V[i];
    }
}
void stampa_vettore(int dim,int V[])
{
    for(int i=0;i<dim;i++)
    {
        cout<<"  "<<V[i];
    }
}
void leggi_matrice(int nrig,int ncol,int M[][nmax])
{
    for(int i=0;i<nrig;i++)
    {
        cout<<"\n";
        for(int j=0;j<ncol;j++)
        {
            cout<<"Inserisci l'elemento posto alla riga "<<i+1<<" e alla colonna "<<j+1<<"\n";
            cin>>M[i][j];
        }
    }
}
void stampa_matrice(int nrig,int ncol,int M[][nmax])
{
    for(int i=0;i<nrig;i++)
    {
        cout<<"\n";
        for(int j=0;j<ncol;j++)
        {
            cout<<"   "<<M[i][j]<<"   ";
        }
    }
}
void elimina_k_elementi(int k,int pos,int & dim,int V[])
{
    int j=pos-1;
    for(int i=j;i<dim-k;i++)
    {
        V[i]=V[i+k];
    }
    dim=dim-k;
}
void ordina_crescente(int dim,int V[])
{
    int min;
    int posmin;
    for(int j=0;j<dim-1;j++)
    {
        min=V[j];
        posmin=j;
        for(int i=j+1;i<dim;i++)
        {
            if(V[i]<min)
            {
                min=V[i];
                posmin=i;
            }
        }
        V[posmin]=V[j];
        V[j]=min;
    }
}
void elem_dist(int dim, int V[])
{
    ordina_crescente(dim,V);
    int j=0;
    while(j<dim-1)
    {
        if(V[j]==V[j+1])
        {
            elimina_k_elementi(1,j+1,dim,V);
        }
        else
            ++j;
    }
}
bool controlla_uguaglianza_vettori(int dim1, int V1[], int dim2, int V2[])
{
    if(dim1!=dim2)
    {
        return 0;
    }
    int j=0;
    while(j<=dim1-1)
    {
        if(V1[j]==V2[j])
            ++j;
        else
        {
            return 0;
        }
    }
    return 1;
}
int main()
{
  int M1[nmax][nmax];
  int M2[nmax][nmax]; 
  cout<<"Scegliere la dimensione di 2 matrici quadrate M1 e M2\n";
  int dim;
  cin>>dim;
  leggi_matrice(dim,dim,M1);
  cout<<"M1 = ";
  stampa_matrice(dim,dim,M1);
  leggi_matrice(dim,dim,M2);
  cout<<"M2 = ";
  stampa_matrice(dim,dim,M2);
  //creo un vettore di supporto V1 in cui memorizzare una diagonale di M1 e un vettore di supporto V2 in cui memorizzare una diagonale di M2
  int V1[nmax];
  int dim1;
  int V2[nmax];
  int dim2;
  //INIZIO PRIMO PEZZO
  for(int h=2;h<dim;h++)
  {
     dim1=h;
     for(int i=0;i<h;i++)
     {
         V1[i]=M1[dim-h+i][i];
     }
     elem_dist(dim1,V1);
     //ciclo che memorizza in V2 la diagonale di M2 che va dalla prima diagonale a partire da sinistra alla diagonale immediatamente a sinistra della principale
     for(int k=2;k<dim;k++)
     {
         dim2=k;
         for(int i=0;i<k;i++)
         {
             V2[i]=M2[dim-k+i][i];
         }
         elem_dist(k,V2);
         if(controlla_uguaglianza_vettori(dim1,V1,k,V2))
         {
            cout<<"\nHo trovato due diagonali!";
            cout<<"\nd1 = ";
            for(int i=0;i<h;i++)
            {
                cout<<"   "<<M1[dim-h+i][i];
            }
            cout<<"\nd2 = ";
            for(int i=0;i<k;i++)
            {
                cout<<"   "<<M2[dim-k+i][i];
            }
            exit(0);
         }
     }
     //ciclo che memorizza in V2 la diagonale di M2 che va da quella immediatamente a destra della principale all'ultima
     for(int j=dim-1;j>1;j--)
     {
         dim2=j;
         for(int i=0;i<j;i++)
         {
             V2[i]=M2[i][dim-j+i];
         }
         elem_dist(j,V2);
         if(controlla_uguaglianza_vettori(dim1,V1,j,V2))
         {
            cout<<"\nHo trovato due diagonali!";
            cout<<"\nd1 = ";
            for(int i=0;i<h;i++)
            {
                cout<<"   "<<M1[dim-h+i][i];
            }
            cout<<"\nd2 = ";
            for(int i=0;i<j;i++)
            {
                cout<<"   "<<M2[dim-j+i][i];
            }
            exit(0);
         }
     }
}
  //INIZIO SECONDO PEZZO
  for(int h=dim-1;h>1;h--)
  {
     dim1=h;
     for(int i=0;i<h;i++)
     {
         V1[i]=M1[i][dim-h+i];
     }
     elem_dist(dim1,V1);
     //ciclo che memorizza in V2 la diagonale di M2 che va dalla prima diagonale a partire da sinistra alla diagonale immediatamente a sinistra della principale
     for(int k=2;k<dim;k++)
     {
         dim2=k;
         for(int i=0;i<k;i++)
         {
             V2[i]=M2[dim-k+i][i];
         }
         elem_dist(k,V2);
         if(controlla_uguaglianza_vettori(dim1,V1,k,V2))
         {
            cout<<"\nHo trovato due diagonali!";
            cout<<"\nd1 = ";
            for(int i=0;i<h;i++)
            {
                cout<<"   "<<M1[i][dim-h+i];
            }
            cout<<"\nd2 = ";
            for(int i=0;i<k;i++)
            {
                cout<<"   "<<M2[dim-k+i][i];
            }
            exit(0);
         }
     }
     //ciclo che memorizza in V2 la diagonale di M2 che va da quella immediatamente a destra della principale all'ultima
     for(int j=dim-1;j>1;j--)
     {
         dim2=j;
         for(int i=0;i<j;i++)
         {
             V2[i]=M2[i][dim-j+i];
         }
         elem_dist(j,V2);
         if(controlla_uguaglianza_vettori(dim1,V1,j,V2))
         {
            cout<<"\nHo trovato due diagonali!";
            cout<<"\nd1 = ";
            for(int i=0;i<h;i++)
            {
                cout<<"   "<<M1[i][dim-h+i];
            }
            cout<<"\nd2 = ";
            for(int i=0;i<j;i++)
            {
                cout<<"   "<<M2[i][dim-j+i];
            }
            exit(0);
         }
     }
  }
//messaggio nel caso non viene trovato nulla
cout<<"\nNon ci sono diagonali che soddisfano le condizioni richieste";
}
Ultima modifica di selfmademan il 22/09/2017, 15:55, modificato 3 volte in totale.
selfmademan
Junior Member
Junior Member
 
Messaggio: 32 di 152
Iscritto il: 30/03/2017, 09:15

Re: [C++] esercizio diagonali matrici

Messaggioda Super Squirrel » 22/09/2017, 14:46

Non ricordo bene, eri tu quello il cui professore assegnava esercizi senza senso?
In ogni caso la traccia non è molto chiara e se proprio volessimo dargli un senso (ignorando la definizione di diagonale), diventerebbe solo un esercizio inutilmente complesso.
Dopo do un'occhiata al codice, ma nel frattempo potresti dirmi tu come hai interpretato la traccia e a grandi linee come vorresti risolvere il problema?
Chi dorme in democrazia, si sveglia in dittatura.
Super Squirrel
Senior Member
Senior Member
 
Messaggio: 149 di 1486
Iscritto il: 16/05/2013, 22:05

Re: [C++] esercizio diagonali matrici

Messaggioda selfmademan » 22/09/2017, 15:37

Sisi sono io. Come diagonale ho inteso un'opportuna sequenza formata da minimo 2 elementi, quindi ho escluso l'elemento posto all'ultima riga e alla prima colonna e l'elemento posto alla prima riga e ultima colonna. Ho anche ignorato la diagonale principale, come richiesto dall'esercizio.
Ho creato due vettori di supporto V1 e V2 in cui memorizzare rispettivamente una diagonale della matrice M1 e una della matrice M2. Considero le diagonali procedendo da sinistra a destra.

Mi metto sulla prima diagonale di M1 (quindi copio in V1 tale diagonale) e scorro le diagonali di M2 (quindi memorizzo in V2 le varie diagonali che scorro sovrascrivendo ogni volta). A ogni passo uso le funzioni elem_dist che prendono i vettori V1 e V2 e li trasformano nei vettori degli elementi distinti, poi confronto questi ultimi e la funzione controlla_uguaglianza_vettori mi ritorna se coincidono o no. Se coincidono ho trovato 2 diagonali che soddisfano le condizioni richieste ed esco dal programma.
Siccome devo ignorare la diagonale centrale, per scorrere le diagonali in M2 faccio due cicli for, il primo dalla prima diagonale a quella immediatamente a sinistra della principale e il secondo dalla diagonale immediatamente a destra della principale all'ultima. Dopo aver confrontato la prima diagonale di M1 con l'ultima di M2 considero la seconda diagonale di M1 e così via (quindi faccio un ciclo su M1, anch'esso diviso in due dovendo ignorare la diagonale principale).
Nel mio programma esco non appena trovo 2 diagonali che soddisfano le richieste ma volendo potrei anche mostrarle tutte.
La richiesta stavolta mi sembra abbastanza chiara, sarà che mi sono abituato al suo modo di formulare i problemi.
selfmademan
Junior Member
Junior Member
 
Messaggio: 33 di 152
Iscritto il: 30/03/2017, 09:15

Re: [C++] esercizio diagonali matrici

Messaggioda Super Squirrel » 23/09/2017, 12:12

Ho dato un'occhiata al codice e sembra che le idee descritte nel tuo post precedente siano messe in pratica piuttosto bene, ma una correzione completa del codice richiederebbe troppo tempo.
Dal momento che hai preso la mano con il linguaggio e a risolvere questo tipo di problemi, il passo successivo è quello di ottimizzare il codice (rendendolo più chiaro) e l'impostazione logica dell'algoritmo adottato (in modo che anche la ricerca di un eventuale errore risulti più facile).

Tra le varie cose vorrei farti notare che andare ad analizzare ogni diagonale di m2 per ogni diagonale di m1 non è proprio il massimo a livello di prestazioni. Conviene a questo punto analizzare tutte le diagonali di ciascuna matrice una sola volta e salvare le informazioni utili da qualche parte.

Se ti può essere utile ho provato a risolvere l'esercizio.

Codice:
#include <iostream>

using namespace std;

const int dim_max = 10;

void inserisci_matrice(const int &dim, int m[dim_max][dim_max])
{
    for(int i = 0; i < dim; i++)
    {
        for(int j = 0; j < dim; j++)
        {
            cout << "m[" << i << "][" << j << "] = ";
            cin >> m[i][j];
        }
    }
}

void scambia_valori(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}

void ordina_crescente(const int &dim, int *v)
{
    bool scambio;
    for(int k = 0; k < dim - 1; k++)
    {
        scambio = false;
        for(int i = 0; i < dim - 1 - k; i++)
        {
            if(v[i] > v[i + 1])
            {
                scambia_valori(v[i], v[i + 1]);
                scambio = true;
            }
        }
        if(scambio == false)
        {
            return;
        }
    }
}

struct diagonale
{
    int l;
    int w[dim_max];
    int n = 1;
    int rig;
    int col;
};

void analizza_diagonale(diagonale &d)
{
    ordina_crescente(d.l, d.w);
    int v[dim_max];
    int i;
    v[0] = d.w[0];
    for(i = 1; i < d.l; i++)
    {
        if(d.w[i] != d.w[i - 1])
        {
            v[d.n] = d.w[i];
            ++d.n;
        }
    }
    for(i = 0; i < d.n; i++)
    {
        d.w[i] = v[i];
    }
}

void preleva_diagonali(const int &dim, diagonale *d, int m[dim_max][dim_max])
{
    int p = 0;
    for(int i = 1; i < dim - 1; i++)
    {
        d[p].rig = i;
        d[p].col = 0;
        d[p].l = dim - i;
        for(int k = 0; k < d[p].l; k++)
        {
            d[p].w[k] = m[i + k][k];
        }
        analizza_diagonale(d[p]);
        ++p;
    }
    for(int j = 1; j < dim - 1; j++)
    {
        d[p].rig = 0;
        d[p].col = j;
        d[p].l = dim - j;
        for(int k = 0; k < d[p].l; k++)
        {
            d[p].w[k] = m[k][j + k];
        }
        analizza_diagonale(d[p]);
        ++p;
    }
}

bool verifica_uguaglianza(const diagonale &d1, const diagonale &d2)
{
    if(d1.n != d2.n)
    {
        return false;
    }
    for(int k = 0; k < d1.n; k++)
    {
        if(d1.w[k] != d2.w[k])
        {
            return false;
        }
    }
    return true;
}

int main()
{
    int m1[dim_max][dim_max];
    int m2[dim_max][dim_max];
    diagonale d1[dim_max * 2 - 3];
    diagonale d2[dim_max * 2 - 3];
    int dim;
    cout << "INSERIRE DIMENSIONE MATRICI: ";
    cin >> dim;
    inserisci_matrice(dim, m1);
    inserisci_matrice(dim, m2);
    preleva_diagonali(dim, d1, m1);
    preleva_diagonali(dim, d2, m2);
    for(int k = 0; k < dim * 2 - 3; k++)
    {
        for(int q = 0; q < dim * 2 - 3; q++)
        {
            if(verifica_uguaglianza(d1[k], d2[q]))
            {
                cout << endl << "M1:DIAGONALE(" << d1[k].rig << "," << d1[k].col << ") - ";
                cout <<         "M2:DIAGONALE(" << d2[q].rig << "," << d2[q].col << ")";
            }
        }
    }
}


La struct "diagonale" contiene:
- "l" che rappresenta il numero di elementi della generica diagonale;
- "rig" e "col" che rappresentano gli indici (rispetto alla matrice) del primo elemento (quello in alto a sinistra) della generica diagonale;
- "n" che è inizialmente uguale a 1 e che assumerà poi, dopo essere passata per la funzione analizza_diagonale, il numero di elementi distinti presenti nella diagonale considerata;
- "w" che è un vettore di dim_max elementi. Nella funzione preleva_diagonali tale vettore verrà riempito per i suoi primi "l" elementi con il contenuto della generica diagonale; dopo essere passato per la funzione analizza_diagonale esso conterrà invece nelle prime "n" posizioni gli elementi distinti di quella diagonale ordinati in ordine crescente.

Se hai qualche dubbio chiedi pure.
Chi dorme in democrazia, si sveglia in dittatura.
Super Squirrel
Senior Member
Senior Member
 
Messaggio: 150 di 1486
Iscritto il: 16/05/2013, 22:05

Re: [C++] esercizio diagonali matrici

Messaggioda selfmademan » 26/09/2017, 11:35

Ho letto la tua risposta e dato un'occhiata al tuo programma che sembra molto più efficiente del mio. Mi sono reso quindi conto che il mio modo di progettare gli algoritmi, sebbene funzionante, è troppo innaturale e dispendioso per il calcolatore. Ho cercato di capire la logica che porta alla scrittura dell'algoritmo risolutivo e sto riscrivendo i programmi più banali in modo diverso e credo più efficiente. Purtroppo come al solito ci fanno studiare le cose, addirittura un linguaggio di programmazione, ignorando completamente il funzionamento del calcolatore e l'informatica teorica, quindi è facile perdersi in strade poco produttive.
Ho riscritto i programmi per la verifica della crescenza o meno di un vettore e l'uguaglianza tra due vettori.
Praticamente avevo preso il "vizio" di ragionare scrivendo istruzioni per tutti i casi teoricamente possibili ma questo non mi sembra il modo naturale di programmare. Il modo naturale è procedere passo passo.

Codice:
//funzione che controlla se crescente
bool controlla_crescente(int dim,int V[])
{
    for(int i=0;i<dim-1;i++)
    {
        if(V[i]>=V[i+1])
        {
            return false;
        }
    }
    return true;
}


Codice:
//funzione che controlla uguaglianza tra 2 vettori
bool controlla_uguaglianza_vettori(int dim1,int V1[],int dim2,int V2[])
{
    if(dim1!=dim2)
        return false;
    for(int i=0;i<dim1;i++)
    {
        if(V1[i]!=V2[i])
            return false;
    }
    return true;
}
selfmademan
Junior Member
Junior Member
 
Messaggio: 35 di 152
Iscritto il: 30/03/2017, 09:15

Re: [C++] esercizio diagonali matrici

Messaggioda vict85 » 27/09/2017, 22:11

Il tuo professore ti chiede di calcolare molte cose in poco tempo. Quindi metterti a ragionare in termini di computer, tra l'altro senza davvero avere l'esperienza e la conoscenza per farlo, è piuttosto inutile e dannoso. Per esempio, cambiando la definizione di diagonale per semplicità, il problema è risolvibile così:
Codice:
#include <iostream>
#include <sstream>
#include <cstring>
#include <utility>
#include <new>
#include <vector>
#include <set>

class matriceQuadrata
{
public:
   matriceQuadrata() noexcept
      : _data(nullptr), _n(0) { }

   explicit matriceQuadrata(size_t n) noexcept
      : matriceQuadrata()
   {
      if (!n)
         return;

      int * temp = new(std::nothrow) int[n * n];
      if (!temp)
         return;
      _data = temp;
      _n = n;
   }

   matriceQuadrata(const matriceQuadrata& M) noexcept
      : matriceQuadrata(M._n)
   {
      if (!_n || !_data)
         return;
      std::memcpy(_data, M._data, _n * sizeof(int));
   }

   matriceQuadrata(matriceQuadrata&& M) noexcept
      : matriceQuadrata()
   {
      std::swap(this->_data, M._data);
      std::swap(this->_n, M._n);
   }

   matriceQuadrata& operator=(matriceQuadrata M) noexcept
   {
      std::swap(this->_data, M._data);
      std::swap(this->_n, M._n);
      return *this;
   }

   ~matriceQuadrata() noexcept
   {
      if (_data)
      {
         delete[] _data;
      }
   }

   void clear() noexcept
   {
      if (!_data || !_n)
         return;
      std::memset(_data, 0, _n * _n * sizeof(int));
   }

   int operator()(size_t i, size_t j) const noexcept
   {
      return (i < _n && j < _n) ? _data[i*_n + j] : 0;
   }

   void set(size_t i, size_t j, int value) noexcept
   {
      if (i >= _n || j >= _n)
         return;
      _data[i*_n + j] = value;
   }

   size_t size() const noexcept
   {
      return _n;
   }
private:
   int * _data;
   size_t _n;
};

const char * str1 = "5" "\n"
"1 2 3 4 5" "\n"
"5 1 2 3 4" "\n"
"4 5 1 2 3" "\n"
"3 4 5 1 2" "\n"
"2 3 4 5 1" "\n";

const char * str2 = "5" "\n"
"5 3 5 5 5" "\n"
"5 1 3 5 5" "\n"
"4 5 5 3 5" "\n"
"5 5 5 5 3" "\n"
"3 5 4 5 5" "\n";

bool inserisciElementi(matriceQuadrata& mat, std::istream& is, std::ostream * os = nullptr)
{
   {
      if (os)
         *os << "Quanto e' grande la matrice? N = ";
      size_t n;
      is >> n;
      matriceQuadrata tempM = matriceQuadrata{ n };
      if (tempM.size() == 0)
      {
         if (os)
            *os << "Dimensione della matrice non valida.\n";
         return false;
      }

      mat = tempM;
   }
   size_t const N = mat.size();
   for (size_t i = 0; i != N; i++)
   {
      for (size_t j = 0; j != N; j++)
      {
         if (os)
            *os << "mat[" << i + 1 << "][" << j + 1 << "] = ";

         int value;
         is >> value;
         mat.set(i, j, value);
      }
   }
   return true;
}

void stampaElementi(const matriceQuadrata& mat, std::ostream& os)
{
   size_t const N = mat.size();
   for (size_t i = 0; i != N; i++)
   {
      for (size_t j = 0; j != N; j++)
      {
         os << mat(i, j) << " ";
      }
      os << std::endl;
   }
}

void estraiDiagonali(const matriceQuadrata& mat, std::vector< std::set<int> >& diag)
{
   if (diag.size() != mat.size())
      return;

   size_t const N = mat.size();
   for (size_t i = 0; i != N; i++)
   {
      for (size_t j = 0; j != N; j++)
      {
         diag[(j + N - i) % N].insert(mat(i, j));
      }
   }
}

std::ostream& operator<<(std::ostream& os, const std::set<int>& set)
{
   os << "{ ";
   for (const auto& e : set)
   {
      os << e << " ";
   }
   os << "}";
   return os;
}

int main()
{
   matriceQuadrata Mat1;
   matriceQuadrata Mat2;

   if (!inserisciElementi(Mat1, std::stringstream{ str1 }))
      return EXIT_FAILURE;

   std::cout << "Matrice 1:\n";
   stampaElementi(Mat1, std::cout);
   std::cout << std::endl << std::endl;

   if (!inserisciElementi(Mat2, std::stringstream{ str2 }) || Mat1.size() != Mat2.size())
      return EXIT_FAILURE;

   std::cout << "Matrice 2:\n";
   stampaElementi(Mat2, std::cout);
   std::cout << std::endl << std::endl;

   std::vector<std::set<int>> diag1(Mat1.size());

   estraiDiagonali(Mat1, diag1);

   std::vector<std::set<int>> diag2(Mat2.size());

   estraiDiagonali(Mat2, diag2);

   for (size_t i = 0; i != diag1.size(); i++)
   {
      for (size_t j = 0; j != diag2.size(); j++)
      {
         if (diag1[i] == diag2[j])
         {
            std::cout << "(" << i + 1 << ", " << j + 1 << ") = " << diag1[i]<< std::endl;
         }
      }
   }
}


Nota che il codice non è ottimale per molte ragioni (in particolare avrei potuto ottimizzare la memoria usata dalle diagonali e aumentare le performance usando un array, ordinandolo e ridimensionandolo) e che ho voluto scrivere una funzione per caricare e stampare la matrice volutamente più generica. Inoltre avrei potuto evitare di gestire la memoria delle matrici da solo e ridurre ulteriormente la dimensione del codice.

Ho voluto presentare il codice per mostrare un modo più professionale per rispondere al problema. Non sono sicuro tu possa usare std::set nel tuo codice d'esame, ma spero non ti faccia problemi sull'usare std::swap e std::sort.
vict85
Moderatore
Moderatore
 
Messaggio: 9180 di 19253
Iscritto il: 16/01/2008, 00:13
Località: Berlin

Re: [C++] esercizio diagonali matrici

Messaggioda vict85 » 27/09/2017, 22:27

In ogni caso ti consiglio di chiedere al tuo professore se e quali librerie della libreria standard del C++ puoi usare durante l'esame. E indipendentemente dalla risposta dovresti provare a risolvere gli esercizi nel seguente modo:
1) risolvere gli esercizi usando tutte le funzioni e le classi che la libreria standard ti permette di usare.
2) partendo dalla soluzione con la libreria standard, prova ad eliminare uno alla volta le varie funzioni e di arrivare alla soluzione che non la usa per nulla (cercando di capire anche che compromessi hai fatto per poter utilizzare le librerie standard (std::swap puoi evitare di toglierla).

I benefici a mio avviso sono tre:
1) impari ad usare e conoscere la libreria standard che è una competenza utile professionalmente,
2) impari ad implementare le funzioni della libreria standard capendo quindi come funziona
3) cominci ad avere esperienza dei benefici e degli svantaggi che scegliere una funzione standard può comportare

Un beneficio ulteriore di incominciare ad implementare solo la parte che non puoi far gestire ad una funzione già fatta e testata è che la funzione è già fatta e testata e quindi sufficientemente attendibile. In pratica vuol dire che se togliendola il risultato cambia allora probabilmente hai fatto un errore implementando la nuova funzione.
vict85
Moderatore
Moderatore
 
Messaggio: 9181 di 19253
Iscritto il: 16/01/2008, 00:13
Località: Berlin


Torna a Informatica

Chi c’è in linea

Visitano il forum: Nessuno e 1 ospite