Lunedì quiz - risposte

Risposta alla puntata numero 6

1: public  bool  MoveNext()
2: {
3:     if  (eof)
4:     {
5:         return  false ;
6:     }
7: 
8:     while  (true )
9:     {
10:         if  (!innerEnum.MoveNext())
11:         {
12:             eof = true ;
13:             return  false ;
14:         }
15: 
16:         if  (innerEnum.Current == 0)
17:         {
18:             eof = true ;
19:             currentValue = 0;
20:             return  false ;
21:         }
22: 
23:         if  (innerEnum.Current != currentValue)
24:         {
25:             return  true ;
26:         }
27:     }
28: }
29: 

Risposta alla puntata numero 5

Risposta alla puntata numero 4

 

Risposta al terzo appuntamento

1:     class  Node 
2:     {
3:         int  X;
4:         int  Y;
5:         Node  Left;
6:         Node  Right;
7: 
8: 
9:         public  static  void  Find(Node  root,
10:                                   Node  reference)
11:         {
12:             if  (root == null )
13:             {
14:                 return ;
15:             }
16: 
17:             if  (root.X > reference.X)
18:             {
19:                 Find(root.Left, reference);
20:                 if  (root.Y > reference.Y)
21:                 {
22:                     Console .WriteLine("node found" );
23:                 }
24:             }
25: 
26:             Find(root.Right, reference);
27:         }
28:     }
29: 

Risposta al lunedì quiz – 2

Molto meno elaborata della precedente.

1:     class  foo 
2:     {
3:         int  finddupe(int [] values)
4:         {
5:             while  (true )
6:             {
7:                 int  newIndex = values[0];
8:                 if  (values[newIndex] == newIndex)
9:                 {
10:                     return  newIndex;
11:                 }
12:                 values[0] = values[newIndex];
13:                 values[newIndex] = newIndex;
14:             }
15:         }
16:     }

Risposta al lunedì quiz – 1

In allegato - clicca qui!

-quack

Potrebbero interessarti anche:
Commenti (7):
1. Giuseppe
martedì 19 ottobre 2010 alle 10:00 PM - IE 9.0 Windows 7
   

Chapeaux. (se si scrive così )

   
2. Blackstorm
martedì 19 ottobre 2010 alle 10:13 PM - firefox 3.6.10 Windows 7
   

Figo! Credo di aver capito come funge... mi piace.

   
3. Gabriele
mercoledì 20 ottobre 2010 alle 12:40 AM - firefox 3.6.12 Ubuntu 10.10
   
Papero, la soluzione che hai proposto è davvero molto elegante.
Che ne pensi di questa?  class  foo
  {
      int  finddupe(int [] values)
      {
          int index1=0;
          int index2=0;
          while (true)
          {
              if  (values[index1] == 0)
              {
                  return index1;
              }
              index2 = values[index1];
              values[index1] = 0;
              if (value[index2] == 0)
              {
                  return index2;
              }
              index1 = values[index2];
              values[index2] = 0;
          }
      }
  }È certamente assai meno elegante e distrugge i valori dell'array però per ogni controllo fa due sole assegnazioni e non tre.Se non ho fatto male i conti (e può darsi) se la tua soluzione trova l'indice al confronto k-simo, fa 3(k-1)+1 = 3k-2 assegnazioni.Questa invece nello stesso caso fa k+1 confronti e 2k+2 assegnazioni, ossia meglio per N (e quindi k) grandi.(Io ho fatto una prova con values[] = {5,4,2,3,1,1})
   
4. wac
mercoledì 20 ottobre 2010 alle 9:43 AM - firefox 3.6.10 Windows 7
   

cavolo questo me lo sono perso

grande papero non c'è che dire

aspetto il prossimo lunedì, cercherò di farmi trovare pronto

   
5. Paperino
mercoledì 20 ottobre 2010 alle 7:01 PM - chrome 6.0.472.63 Windows 7
   

@gabriele: interessante variazione! 

   
6. il nonno
giovedì 21 ottobre 2010 alle 8:53 AM - chrome 7.0.517.24 Windows 7
   

L'algoritmo di Gabriele non e' poi cosi' diverso da quello di Paperino, la prima differenza e' che in quello di Gabriele il loop e' srotolato di un fattore 2, puo' essere riscritto senza srotolamento cosi':

  1.         int index1 = values[0];
  2. int index2 = 0;            
  3. while (true)             
  4. {                 
  5. if (values[index1] == 0)                
  6. {                     
  7. return index1;                
  8. }                 
  9. index2 = values[index1]; 
  10. values[index1] = 0;   
  11. index1 = index2;         
  12. }         

che come si puo' vedere e' di fatto equivalente a quello di Paperino; quando lo si srotola, non serve piu' fare l'assegnazione index1 = index2 semplicemente perche' se ne scambia l'uso, quella che e' la variabile temporanea diventa l'indice di riferimento e viceversa.

L'algoritmo di Paperino puo' essere srotolato cosi':

  1.         int newIndex = values[0];
  2. while (true)            
  3. {                
  4. if (values[newIndex] == newIndex)                
  5. {                    
  6. return newIndex;                
  7. }                
  8. values[0] = values[newIndex];                
  9. values[newIndex] = newIndex;
  10.                 if (values[values[0]] == values[0])                
  11. {                    
  12. return values[0];                
  13. }                
  14. newIndex = values[values[0]];                
  15. values[values[0]] = values[0];            

a questo punto e' evidente che i due algoritmo sono assolutamente identici, con la variante che Paperino usa values[0] come index2 e che usa il valore corrente al posto di zero per il confronto, ma l'unica vera differenza tra i due resta appunto lo srolotamento, che a volte viene fatto automaticamente dal compilatore (di certo per i cicli con indice esplicito, ma non sarei troppo stupito se riuscisse a farlo anche in questo caso)

   
7. il nonno
giovedì 21 ottobre 2010 alle 8:56 AM - chrome 7.0.517.24 Windows 7
   

azz... pessima impaginazione... riprovo....

Gabriele non srotolato:

  1. int index1 = values[0];
  2. int index2 = 0;            
  3.     while (true)             
  4.     {                 
  5.         if (values[index1] == 0)                
  6.         {                     
  7.             return index1;                
  8.         }                 
  9.         index2 = values[index1]; 
  10.         values[index1] = 0;   
  11.         index1 = index2;         
  12.     }  

 

Paperino srotolato:

  1. int newIndex = values[0];
  2. while (true)            
  3. {                
  4.     if (values[newIndex] == newIndex)                
  5.     {                    
  6.         return newIndex;                
  7.     }                
  8.     values[0] = values[newIndex];                
  9.     values[newIndex] = newIndex;
  10.     if (values[values[0]] == values[0])                
  11.     {                    
  12.         return values[0];                
  13.     }                
  14.     newIndex = values[values[0]];                
  15.     values[values[0]] = values[0];            

 

   
Lascia un commento:
Commento: (clicca su questo link per gli smiley supportati; regole di ingaggio per i commenti)
(opzionale, per il Gravatar)