[java] array vullen met 6 complement getallen

[KnEuTeR]

ik moet dus een string array vullen met 6 complement getallen, tot 4 characters

hiervoor heb ik het volgende stukje code:

Java:

        for(int i=0;i<1296;i++){
            for(int j=0;j<6;j++){
                for(int k=0;k<6;k++){
                    for(int l=0;l<6;l++){
                        for(int m=0;m<6;m++){
                            cbg[i] = String.valueOf(j) + String.valueOf(k) + String.valueOf(l) + String.valueOf(m);
                        }
                    }
                }
            }
        }

begrijpelijk komt hieruit dus een array helemaal gevult met 5555

maar ik snap fff helemaal niet meer hoe ik hem gewoon kan laten oplopen


edit:

betere uitleg:

hij moet dus oplopen van 0000 tot 5555 met per "letter" maximaal tot 5. (dat is dus in 6 complement notatie)

ongeveer zo:

0000
0001
0002
0003
0004
0005
0010
0011
0012
0013
0014
0015
0020
0021
0022

etc

[ Voor 27% gewijzigd door KnEuTeR op 01-12-2003 21:02 ]

[Robtimus]

Je array waarden worden elke keer overschreven, totdat alle vars vanaf j 5 zijn. Dan stoppen al die innerloops en wordt i verhoogd. De waarde in het array is dan idd 5555.

Ik weet nog steeds niet precies wat je wilt, maar een nieuw ontwerp lijkt me niet onverstandig.

[py.mosjuh]

het zou inderdaad handig zijn om ook te posten wat je er nou mee wil..

[KnEuTeR]

ik heb het even beter uitgelegd

[Verwijderd]

NOTE: het is mij duidelijk geworden dat ik een klein redenatie foutje gemaakt heb zie de berichten hieronder waarom

er van uitgaande dat ik je begrijp lijkt me dat de volgende code zou moeten werken, hoewel ik het niet getest heb.

code:

            for(int j=0;j<6;j++){
                for(int k=0;k<6;k++){
                    for(int l=0;l<6;l++){
                        for(int m=0;m<6;m++){
                            cbg[(j + k + l + m)] = String.valueOf(j) + String.valueOf(k) + String.valueOf(l) + String.valueOf(m);
                        }
                    }
                }
            }

[ Voor 13% gewijzigd door Verwijderd op 01-12-2003 21:35 ]

[RayNbow]

KnEuTeR schreef op 01 december 2003 @ 20:37:
...

Java:

        for(int i=0;i<1296;i++){
            for(int j=0;j<6;j++){
                for(int k=0;k<6;k++){
                    for(int l=0;l<6;l++){
                        for(int m=0;m<6;m++){
                            cbg[i] = String.valueOf(j) + String.valueOf(k) + String.valueOf(l) + String.valueOf(m);
                        }
                    }
                }
            }
        }

...

Je maakt waarschijnlijk een denkfout. Je code produceert in plaats van 1296 getallen (0000 tot 5555) 1296*1296 getallen (0000-5555 1296 keer).

Dit moet de code zijn:

Java:

// DEZE FOR WEG: for(int i=0;i<1296;i++){
    for(int j=0;j<6;j++){
        for(int k=0;k<6;k++){
            for(int l=0;l<6;l++){ 
                for(int m=0;m<6;m++){ 
                    cbg[m+l*6+k*6*6+j*6*6*6] = String.valueOf(j) + String.valueOf(k) + String.valueOf(l) + String.valueOf(m); 
                } 
            } 
        } 
    } 
// DEZE FOR WEG: }

[Verwijderd]

bla bla bla Foutje


(eventueel zou je cbg[m + l*10 + k*100 + j*1000] kunnen doen voor een leukere indexxing )

[ Voor 90% gewijzigd door Verwijderd op 01-12-2003 21:36 ]

[RayNbow]

Verwijderd schreef op 01 december 2003 @ 21:19:
[...]


hmm zal aan mij liggen maar volgens mij krijg je zo enorme gaten in je array (cbg[m+l*6+k*6*6+j*6*6*6]) en zo ver ik topic starter snap is dit niet de bedoeling. 6 * 6 * 6 * 6 is precies 1296 ( het aantal nummers dat hij voor ogen had te maken (for i < 1296)). Nu gooi alleen maar grote gaten tussen deze getallen...

Niet echt...

1te run... m=l=k=j=0, dus in array element 0 wordt 0000 opgeslagen
2de run... m=1, l=k=j=0, dus in array element 1 wordt 0001 opgeslagen
...
6de run... m=5, l=k=j=0, dus in array element 5 wordt 0005 opgeslagen
7de run... m=0, l=1, k=j=0, dus in array element 6 (= 0 + 1*6 + 0*6*6 + 0*6*6*6) wordt 0010 opgeslagen.
...
1296de run... m=l=k=j=5, dus in array element 1295 (= 5 + 5*6 + 5*6*6 + 5*6*6*6) wordt 5555 opgeslagen

[SilencerNL]

wat dacht je van:

code:

    int i = 0;
    for(int j=0;j<6;j++){ 
        for(int k=0;k<6;k++){ 
            for(int l=0;l<6;l++){  
                for(int m=0;m<6;m++){  
                    cbg[i] = String.valueOf(j) + String.valueOf(k) + String.valueOf(l) + String.valueOf(m);  
                    i++;
                }  
            }  
        }  
    }

[RayNbow]

Silencer_NL schreef op 01 december 2003 @ 21:29:
wat dacht je van:
[hier stond wat code]

Dat kan natuurlijk ook, scheelt een flink aantal vermenigvuldigingen

[Verwijderd]

RayNbow schreef op 01 december 2003 @ 21:29:
[...]


Niet echt...

1te run... m=l=k=j=0, dus in array element 0 wordt 0000 opgeslagen
2de run... m=1, l=k=j=0, dus in array element 1 wordt 0001 opgeslagen
...
6de run... m=5, l=k=j=0, dus in array element 5 wordt 0005 opgeslagen
7de run... m=0, l=1, k=j=0, dus in array element 6 (= 0 + 1*6 + 0*6*6 + 0*6*6*6) wordt 0010 opgeslagen.
...
1296de run... m=l=k=j=5, dus in array element 1295 (= 5 + 5*6 + 5*6*6 + 5*6*6*6) wordt 5555 opgeslagen

My bad i bow 2 your wisdom

was weer eens te snel in mijn redeneren

[.oisyn]

RayNbow schreef op 01 december 2003 @ 21:32:
[...]


Dat kan natuurlijk ook, scheelt een flink aantal vermenigvuldigingen

dat kan ook door de a*x³ + b*x² + c*x + d te vervangen door:
(((a * x + b) * x + c) * x + d

(Horner's rule)

Maar gewoon een countertje is natuurlijk nog efficienter

[RayNbow]

.oisyn schreef op 01 december 2003 @ 21:38:
[...]


dat kan ook door de a*x³ + b*x² + c*x + d te vervangen door:
(((a * x + b) * x + c) * x + d

(Horner's rule)

[...]

Hmm, maar als we uitgaan dat de Java compiler de factoren 6*6 en 6*6*6 vervangt met 36 en 216... Dan moet je bij beide berekeningen 3 keer vermenigvuldigen en 3 keer optellen, dus maakt het dan wat uit of je (((a * x + b) * x + c) * x + d doet of a*x³ + b*x² + c*x + d?

* RayNbow denkt eens diep na...

[KnEuTeR]

aha, het komt er dus eigenlijk op neer het allerbuitenste tellertje helemaal naar binnen te halen. tja, ik was er zolang mee aan het klooien dat ik ineens geen oplossing meer zag

erg bedankt allemaal

[.oisyn]

RayNbow schreef op 01 december 2003 @ 21:48:
[...]


Hmm, maar als we uitgaan dat de Java compiler de factoren 6*6 en 6*6*6 vervangt met 36 en 216... Dan moet je bij beide berekeningen 3 keer vermenigvuldigen en 3 keer optellen, dus maakt het dan wat uit of je (((a * x + b) * x + c) * x + d doet of a*x³ + b*x² + c*x + d?

* RayNbow denkt eens diep na...

klopt, daar heb je helemaal gelijk in. De x in deze is natuurlijk gewoon een constante

[Verwijderd]

misschien is het verstandiger om die formule te gebruiken... die is veel gemakkelijker te onderhouden. en daarnaast ook nog een stuk beter lees baar... ik hou niet van dat soort for lus constructies

[DaCoTa]

Wat een moeilijkdoenerij:

Java:

int radix = 6;
int maxlen = 4;

StringBuffer pad = new StringBuffer();
while(pad.length() < maxlen) {
    pad.append("0");
}

String s;

int max = Integer.parseInt("1"+pad, radix);
for(int i = 0; i < max; i++) {
    s = Integer.toString(i, radix);
    System.out.println(pad.substring(s.length())+s);   
}

Of begrijp ik het probleem verkeerd?

[Confusion]

In navolging van Marik2000's opmerking: ik zou het volgende overzichtelijker vinden:

Java:

for (i = 0; i < 1296; i++) {
   a = i / 216;
   b = (i % 216) / 36;
   c = (i % 36) / 6;
   d = (i % 6);
   bg[i] = String.valueOf(1000*a + 100*b + 10*c + d);
}

(hmmm, zo krijg je natuurlijk geen goede strings; moeten vier digits zijn, maar ik geloof ook dat de post hierboven een veel betere oplossing heeft)

[ Voor 23% gewijzigd door Confusion op 02-12-2003 11:27 . Reden: Een sluitende } is wel netjes ]

[kenneth]

lama ik zag de radix over het hoofd

[ Voor 92% gewijzigd door kenneth op 02-12-2003 11:43 ]