[C++, Java, C, VB, etc...] risoluzione combinazioni

[misterx]

abbiamo 2 variabili che possono assumere il valore 0 oppure 1

qualcuno ci insegna che possiamo scrivere le seguenti combinazioni:

0 0
0 1
1 0
1 1

bene; sembrerebbe che rispondendo alla regola 2^2^n dove n rappresenta il numero di variabili, sia possibile ottenere 16 colonne formate dalle combinazioni di 0 e 1 possibili

esempio:

0 1 1 ... fino a 16 colonne
0 1 0 ...
0 1 0 ...
0 1 0 ...

sarebbe comodo se ci pensasse un programmetto scritto all'uopo e per la regola dell'acqua calda ci scommetto che l'avete già scritto, quindi: postate il vostro codice

[ri]

e a che ti serve?
scuola? spero di no, perchè altrimenti (da parte mia) ti scordi qualsiasi riga di codice pronta

[misterx]

Originariamente inviato da ri
e a che ti serve?
scuola? spero di no, perchè altrimenti (da parte mia) ti scordi qualsiasi riga di codice pronta

se fosse per la scuola ci penserei da me

è per mia curiosità personale

fosse una serie di numeri come ad esempio:

1 2 3 4
1 2 4 3
4 3 2 1
etc......

me la caverei con un certo numero di cicli for nidificati

ma con 0 e 1 non mi viene in mente nulla; di sicuro se cerco in rete qualcosa c'è già ma vai a capire cosa cercare

[ri]

Originariamente inviato da misterx
se fosse per la scuola ci penserei da me

brav

ora sono un po' intasato in ufficio, se posso ci penso

[VICIUS]

Non è che ti serve la formula delle combinazioni con ripetizione ?

Cr(n,k) = (n+k-1)! / (n-1)!*k!

con n=2 e k=16.

ciao

[misterx]

Originariamente inviato da VICIUS
Non è che ti serve la formula delle combinazioni con ripetizione ?

Cr(n,k) = (n+k-1)! / (n-1)!*k!

con n=2 e k=16.

ciao

meglio

2^n = numero di righe

2^2^n = numero di colonne

[anx721]

Codice PHP:

int n = 2;
        //2^n
    int n_2 = (int)Math.pow(2.0, n);
        //2^2^n
    int n_2_2 = (int)Math.pow(2.0, n_2);
    int temp = 1;

    for(int i = 0; i < n_2;  i++){
        for (int j = 0; j <  n_2_2 ; j = j + temp){
            for(int k = 0; k <  temp ; k++){
                if(((j / temp) % 2) == 0)
                    System.out.print("0");
                else
                    System.out.print("1");    
            }        
        }
        temp = temp * 2;
        System.out.println();
    } 


Se n > 2 è già difficile visualizzare il risultato...

[misterx]

lo stavo controllando e sembrerebbe che qualche problemino c'è nel tuo codice

ancora qualche test per sincerarmene

cmq, grazie 1000

[/\/\@®¢Ø]

Originariamente inviato da anx721

Codice PHP:

int n_2 = (int)Math.pow(2.0, n);
    int n_2_2 = (int)Math.pow(2.0, n_2); 


occhio che a priori non sei sicuro che non vengano effettuati arrotondamenti nella conversione tra float e interi (alcuni interi non sono rappresentabili come float)
visto che la base e' due meglio scrivere

Codice PHP:

int n_2 =  ( 1 << n )
  int n_n_2 = (  1 << n_2 ) 


tra l'altro qui si vede bene che se n e' piu' grande di 5, n_2 diventa > 32 e quindi n_n_2 sfora.

[anx721]

L'importante è che sia corretto l'algoritmo

[/\/\@®¢Ø]

Originariamente inviato da anx721
L'importante è che sia corretto l'algoritmo

Vero, ma anche il risultato vuole la sua parte

[anx721]

Si, ma i dettagli implementativi ognuno se li vede, anche in base al linguaggio scelto, comuqnue le tue osservazioni sono giuste, anche se non capito il fatto dell'arrorondamento

[/\/\@®¢Ø]

Originariamente inviato da anx721
Si, ma i dettagli implementativi ognuno se li vede, anche in base al linguaggio scelto

Figurati, volevo solo avvertirti perche' quel tipo di bug e' abbastanza insidioso.
[quote
comuqnue le tue osservazioni sono giuste, anche se non capito il fatto dell'arrorondamento [/quote]
Con un numero in virgola mobile non riesci a rappresentare tutti i numeri interi presenti in un int. Sulla mia macchina ad esempio il seguente codice ritorna false:

bool foo()
{
  int n = 16777217;
  float f = n;
  return f == n;
}

[/\/\@®¢Ø]

Originariamente inviato da misterx
abbiamo 2 variabili che possono assumere il valore 0 oppure 1

qualcuno ci insegna che possiamo scrivere le seguenti combinazioni:

0 0
0 1
1 0
1 1

Giusto una piccola curiosità:
se guardi bene quelle che stai scrivendo sono le rappresentazioni binarie dei numeri a 2 ( o in generale piu' ) bit
Una soluzionie decisamente compatta potrebbe essere la seguente:

    int bits = 31;
    for ( int i=0 ; i< INT_MAX ; ++i )
    {
        for ( int j = bits-1 ; j >= 0 ; --j )
        {
                cout << (( i & (1<<j) ) != 0) << ' ';
        }
        cout << endl;
    }

[anx721]

La conversione da int a float dà in effetti problemi in c, infatti con con

int n = 16777217;
float f = n;

stampando n ed f ottengo:

n = 16777217
f = 16777216.0000

Penso dipenda dal numero di bit utilizzati per rappresentare il numero; in java invece funziona.

In c basta usare double invece di float.

Quanto al tuo codice alternativo, non conosco bene gli operatori del c++, ma ci credo che sia giusto

[VICIUS]

Originariamente inviato da misterx
meglio

2^n = numero di righe

2^2^n = numero di colonne

Saro pignolo io ma m^n è la formula delle disposizioni con ripetizione e non delle combinazioni.

ciao

[misterx]

Originariamente inviato da VICIUS
Saro pignolo io ma m^n è la formula delle disposizioni con ripetizione e non delle combinazioni.

ciao

che avesse un nome lo so ora

beh, meglio sarebbe disposizioni senza ripetizioni....

forse non sono stato molto chiaro nella mia esposizione

[verloc]

aspetta un paro di giorni che ti do la roba fatta da me.

Il ragazzo ha ragione: quelle erano le disp.

hey Misterix
domani...toccando palle...