[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]

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

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

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 :D ;)

[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. :p

hey Misterix
domani...toccando palle...