l'angolo dell'informatico

[Lovercraft]

Tutto giusto, tutto sensato...una sola cosa non mi quadra...chi to ffa fa?

[djcarmine]

Tutto giusto, tutto sensato...una sola cosa non mi quadra...chi to ffa fa?

me lo sono chiesto quando era troppo tardi 

Puoi usare un albero di espressione e ti passa la paura. Vedi qui ad esempio com'è implementato, è in Python ma è talmente facile da capire che forse ti verrà  voglia di farlo in Python e non in C++! :P

PS: vedi il paragrafo 20.5 se vuoi andare al dunque

PPS: puoi decidere di usare l'attraversamento inorder invece di postorder...

 

[falceEmarcello]

queste 


From:   Bancoposta@poste.it To: bianchi.m@poste.it
Sent: Wednesday, September 14, 2005 10:38 PM
Subject: Misure di sicurezza di cliente di BancoPosta ID 42501

Caro bianchi.m@poste.it, Recentemente abbiamo notato uno o più tentativi di entrare al vostro conto di
BancoPostaonline da un IP indirizzo differente.
Se recentemente accedeste al vostro conto mentre viaggiavate, i tentativi insoliti
di accedere a vostro Conto BancoPosta possono essere iniziati da voi.
Tuttavia, visiti prego appena possibile BancoPostaonline per controllare le vostre
informazioni di conto:

https://bancopostaonline.poste.it/bpol/bancoposta/formslogin.asp

Ringraziamenti per vostra pazienza.
BancoPostaon.

 


p.s tradotto con google rumeno - italiano .... e non sai a quanti di loro si sono fatti

[falceEmarcello]

Java the Javatar

[kurz]

Java the Javatar

[peppe9]

Java the Javatar

Il cuoricino sul petto, i love Java

[Lovercraft]

Java the Javatar

oddio

[SpamMattia]

ma già  avete una sezione sana tutta dedicata NERDONI DEL CAZZO

[mk89]

ma già  avete una sezione sana tutta dedicata NERDONI DEL CAZZO

una non basta!!! 

[ciccio-s]

una non basta!!! 

linguaggi, hardware & software, analisi 

[djcarmine]

Spoiler

num eval (expression* token , int nodeopen , int nodeclose )
{
   
   
   //variabili per ricerca parentesi
   int ex_node = 0;

   
   //variabili per priorità  operatori
   num pri_type = 14;
   int pri_loc = nodeopen;

   //PASSO 1: RICONOSCIMENTO DEL NODO MINIMO
   //nodo minimo: formato dal solo operando, cardinalità  1...basta ritornare
   //l'operando!!!!!!!
   
   if (nodeopen == nodeclose && token[nodeopen].is_opd)
   {
                return token[nodeopen].val;
   }
   
   
   //PASSO 2: RICONOSCIMENTO DELL'OPERATORE DI MINIMA PRIORITA'
   //scansione del vettore-token, trova l'operatore del nodo-radice e lo
   //esegue al passo 3!
   //tabella delle priorità  (versione 1): () -> / e * -> + e -
   
   for (int i = nodeopen ; i <= nodeclose ; i++)
   {
       
       //-----------------algoritmo di ricerca parentesi------------------------
       if (token.val == nodeop && !token.is_opd)
       {
                        ex_node++;
       }
       
       if (token.val == nodecl && !token.is_opd)
       {
                        ex_node--;
       }
       
       
       //--------------------valutazione dell'operatore-------------------------
       
       //se il token è operatore E se non ci sono priorità  minori o simili
       //assegna al token-operando la minima priorità  e salva la locazione
       
       //priorità  '+' e '-'
       if ( !token.is_opd &&
             token.val < pri_type &&
             token.val < nodeop &&
             ex_node == 0 )
       {
                        pri_type = token.val;
                        pri_loc = i;
       }
       //-----------------------------------------------------------------------
   }
   
   //PASSO 3: COSTRUZIONE DELL'ALBERO OPERATIVO
   //esegue l'operazione prioritaria: se l'operando prioritario è (), chiama
   //ricorsviamente eval per valutare l'interno di ()
   //se è un operatore binario chiama ricorsivamente eval per valutare separatamente
   //le sottoespressioni ai lati
   //
   //ESEMPIO:
   //                 eval ((3+2)*5)
   //        eval (3+2)     *     eval (5)
   //     eval (3) + eval (2)      5
   //
   //       3          2
   
   if (token [nodeopen].val == nodeop && !token[nodeopen].is_opd &&
       token[nodeclose].val == nodecl && !token[nodeclose].is_opd)
   {
         return eval (token , nodeopen + 1 , nodeclose - 1 );
   }
    //sottonodi-operatori binari
   switch ((int) pri_type)
   {
          case pridiv:
          {
                return eval (token , nodeopen , pri_loc-1) / eval (token , pri_loc + 1 , nodeclose);
          }

          case primul:
          {
                return eval (token , nodeopen , pri_loc-1) * eval (token , pri_loc + 1 , nodeclose);
          }
           
          case prisub:
          {
               return eval (token , nodeopen , pri_loc-1) - eval (token , pri_loc + 1 , nodeclose);
          }
         
          case priadd:
          {
               return eval (token , nodeopen , pri_loc-1) + eval (token , pri_loc + 1 , nodeclose);
          }
   }
   
}

funziona, ma per espressioni del tipo ad es. (a+b)+(a+c) calcola solo il risultato della prima parentesi 

[mk89]

usa un albero di espressione!

[djcarmine]

usa un albero di espressione!

l'ho fatto, ho letto l'articolo che hai postato   

il problema è questo:

la mia funzione lavora così

scandisce il vettore in ingresso, trova l'operatore meno prioritario e lo esegue, se ad esempio l'operatore è + farà 

"tutto quello che sta a sinistra del piu" + "tuttoquello che sta a destra del piu"

e quindi vita ricorsivamente fino a sudividere l'espressione in tante sotto-espressioni formate dal solo operando. quando l'espressione è formata solo dall'operando, ritorna semplicemente tale operando

resta ovviamente da definidre l'operatore "()" che ha il ruolo di modificare la priorità  degli altri operatori

mi sono dato una definizione ricorsiva

-se l'espressione contiene parentesi, valuta solo gli operatori al di fuori delle parentesi (ovvero quando il numero di parentesi aperte trovate lungo la scansione eguaglia il numero di prarentesi chiuse)

-  se la sottoespressione ricavata è racchiusa tra parentesi, allora parsa il contenuto delle parentesi

nel caso (a+b)+(c+d), ad esempio, si verificano entrambe le condizioni, allora il parser dividerà  così l'espressione

A= a+b)
B= (c+d

return A + B

che ovviamente non ha senso   

[raistlin980]

ci sta il mitico esempio di celentano per spiegare che a volte e' necessario approssimare un numero reale ad intero ... GIUVINO' SI CHIST INVEC E ESSER NUMMARIELL ERAN SACCHET E GEMENT VUJE DIC NO QUANTI SACCHETT AVITA ACCATTA ????

Il Maestro

[djcarmine]

l'ho fatto 

Spoiler

#include <cstdlib>
#include <iostream>
#include <string>

#define c_opts 4                //10 cifre + 4 operatori + 2 parentesi
#define add 0                   //+
#define sub 1                   //-
#define mul 2                   //*
#define div 3                   ///

using namespace std;
typedef float num;

struct expression
{
       num val;
       bool is_opd;
};

num eval (expression* token , int nodeopen , int nodeclose )
{
   
   

   
   //variabili per priorità  operatori
   num pri_type = 0xFFFF;
   int pri_loc ;


   //PASSO 1: RICONOSCIMENTO DEL NODO MINIMO
   //nodo minimo: formato dal solo operando, cardinalità  1...basta ritornare
   //l'operando!!!!!!!
   
   if (nodeopen == nodeclose && token[nodeopen].is_opd)
   {
                return token[nodeopen].val;
   }
   
   //PASSO 2: RICONOSCIMENTO DELL'OPERATORE DI MINIMA PRIORITA'
   //scansione del vettore-token, trova l'operatore del nodo-radice e lo
   //esegue al passo 3!
   //tabella delle priorità  (versione 1): () -> / e * -> + e -
   
   for (int i = nodeopen ; i <= nodeclose ; i++)
   {
       if (!token.is_opd)
       {
         
                         //----------------valutazione dell'operatore-----------
                         //se il token è operatore E se non ci sono priorità  minori o simili
                         //assegna al token-operando la minima priorità  e salva la locazione
                         if(token.val <= pri_type)
                         {
                                         pri_type = token.val;
                                         pri_loc = i;
                                         break;
                         }
                         //-----------------------------------------------------
          }
   }
   
   //PASSO 3: COSTRUZIONE DELL'ALBERO OPERATIVO
   //esegue l'operazione prioritaria: se l'operando prioritario è (), chiama
   //ricorsviamente eval per valutare l'interno di ()
   //se è un operatore binario chiama ricorsivamente eval per valutare separatamente
   //le sottoespressioni ai lati
   //
   //ESEMPIO:
   //                 eval ((3+2)*5)
   //        eval (3+2)     *     eval (5)
   //     eval (3) + eval (2)      5
   //
   //       3          2
   
 
    //sottonodi-operatori binari
   
    int opt = (int)  pri_type % c_opts;
   
   switch (opt)
   {
          case div:
          {
                return eval (token , nodeopen , pri_loc-1) / eval (token , pri_loc + 1 , nodeclose);
          }

          case mul:
          {
                return eval (token , nodeopen , pri_loc-1) * eval (token , pri_loc + 1 , nodeclose);
          }
           
          case sub:
          {
               return eval (token , nodeopen , pri_loc-1) - eval (token , pri_loc + 1 , nodeclose);
          }
         
          case add:
          {
               return eval (token , nodeopen , pri_loc-1) + eval (token , pri_loc + 1 , nodeclose);
          }
}       
}

int main(int argc, char *argv[])
{
    string func;                  //stringa da parsare
    getline (cin , func);


int riemp = 0;
     int k = 0;
     int nodelevel = 0;
     char alphopd[11] = "0123456789";     //stringa-alfabeto
     char alphopt[5] = "+-*/";
     
     for (int i = 0 ; i < func.length () ; i++)
     {
         if ( func != '('  && func != ')' && func != ' ')
         {
              riemp++;
         }
     }
     
    expression* token = new expression[riemp];
   
    //SCANSIONE DELLA STRINGA
     for (int i = 0 ; i < func.length () ; i++)
     {
         switch (func)
         {
                case '(':
                     {
                         nodelevel++;
                         break;
                     }
               
                case ')':
                     {
                         nodelevel--;
                         break;
                     }
                     
                default:
                {
                        for (int j = 0 ; j <= 10 ; j++)
                        {
                            if (func == alphopd[j])                      //associa numero a carattere di str
                            {
                               token[k].val = j;
                               token[k].is_opd = true;
                               k++;
                            }
                        }
         
                        //VALUTAZIONE OPERATORI
                        for (int j = 0 ; j <= c_opts ; j++)
                        {
                            if (func == alphopt[j])                      //associa numero a carattere di str
                            {
                               token[k].val = j + (nodelevel*4);
                               token[k].is_opd = false;
                               k++;
                            }
                        }
         }
                       
         }
     }
                     
     
     for (int i = 0 ; i < riemp ; i++)
     {
         if (token.is_opd == true && token[i+1].is_opd == true)
         {
                             token.val = ((token[i+1].val/10) + token.val)*10;
                             shift_l (token , i , riemp , 1);
                             i--;
         }
     }

[ciccio-s]

stu megaupload e merd va solo a 400k oggi ma che caxx a passat? 

[djcarmine]

ho comprato (  ) il libro di charles petzold sulla programmazione gui......prima che inizi la prima di 1344 pagine rigorosamente in english , mi dite che è il caso di levare mano e buttarmi su qualcosa di piu semplice?

[mk89]

dj senti non conosco l'autore in questione però puoi dare un'occhiata, come minimo se usi il c++, alle qt e in particolare al libro ufficiale di mark summerfield :-)
Per il tuo libro  prova a dare un'occhiata alle recensioni su amazon.

[marcojak]

Java the Javatar

E' fantasticoo 

Il bello è che io ci lavoro pure in .NET 

[djcarmine]

dj senti non conosco l'autore in questione però puoi dare un'occhiata, come minimo se usi il c++, alle qt e in particolare al libro ufficiale di mark summerfield :-)
Per il tuo libro  prova a dare un'occhiata alle recensioni su amazon.

che sono le qt??? ma io poi non ho capito uina cosa........so che esistono delle librerie (alcune fornite direttamente dal linguaggio come le java.awt di java) di classi che in pratica creano un livello di astrazione tra programmatore e api, ma i programmatori seri usano questi o gestiscono direttamente le chiamate alle api??