Výpis všech 9-bitových čísel s troma jedničkama – Java – Fórum – Programujte.com

Ahoj, nevím si poradit  jak naprogramovat program v Jave (stačil by i pseudokód)
pro výpis všech 9-bitových čísel s troma jedničkama (právě 3 jedničky, ani víc, ani míň) 

napr. 111 000 000
         010 011 000 atd...

Díky.

#1 gaucan
Tak si to udělej sám ne?

Napiš si na papír pro jednoduchost třeba jen 5-ti bitový tvar a zkus si procházet možnosti s posouváním jedniček doprava počínaje poslední

11100

11010

11001

Další sada

10110

10101

Další

10011

No od začátku

01110

01101

Další

01011

Znovu od začátku zbývá jen

00111

To jsou myslím všechny ne?

No a teď to naprogramuj pokud možno obecně a místo pěti pracuj s devíti a je to...

takhle si to napsat jak ty rikas to umim taky, ale naprogramovat to obecne proste nevim

#3 gaucan
Tak začni tím, že tam budeš mít jen jednu jedničku.

100

010

001

To bys mohl zavládnout ne?

vzdyt prave ani to nejak rozumne neumim spravit...
me napada tak jedine tohle: (ale to je nepouzitelny pro vetsi pocet moznosti) 
 

int [3] pole;={1,0,0};
vypis;

int [3] pole;={0,1,0};

vypis;

int [3] pole;={0,0,1};

vypis;

#5 gaucan
Aha, takže úplný začátečník? Proč teda jdeš do tak těžké úlohy?

Koukni se na cyklus for

no pac to chteji po nas do skoly, do pondeli :| a jako nejsem uplnej zacatecnik jen na tenhle spusob sem jeste nic nedelal jinak vim jak funguje FOR a tak.. jenomze nevim jak to udelat.. ani pro ty 3 cisla a jedna jednicka...

#7 gaucan
No to se pak blbě radí - taky je divný, že po tobě chtějí něco na způsob, kterej jste ve škole nedělali...

No ale zkusím to...

Takže obecně: dejme tomu mám na pětimístném číslet pozic umístit třeba na pozici 4 jedničku ( a na zbytek nuly)

Takže začnu tím, že všude dám nuly a pak na určené místo jedničku.

pro p=1 to 5 
  pole(p)=0
další p

pole(4)=1

vypiš pole (bude tam 00010)

Ale protože tu jedničku chci mít postupně na všech pozicích, tak použiju další cyklus:

Takže:

pro kam=1 to 5

    pro p=1 to 5 
       pole(p)=0
    další p

    pole(kam)=1

    vypiš pole (postupně se vypíše 10000, 01000, 00100 ...

další kam

#8 JoDiK
Zkus to udělat v té javě...

#9 JoDiK
Jsem to nakonec nedoupravil, snad jsi to pochopil, jen pro jistotu

"na pětimístném číslet pozic"

čti jako "na pětimístném čísle"

tomu co si napsal chapu, vypise to vsechny 5-bitove cisla ktere obsahuji prave jednu jednicku a 4 nuly ale  vymyslet to pro to moje zadani je o poznani tezsi, pac tam bude  aspon 100 moznosti a ne 5 jak ve tvem prikladu , a prave na tom selhavam :(  

ak to chces riesit takto tak proste si spravis 3 indexy pre kazdu jednotku a postupne ich budes zmensovat (najpv zmensis posledne az na koniec potom posunies druhe o jednu poziciu dalej a tretie zase prejde na koniec) ... resp zvecsovat a dostanes vzostupnu postupnost ... ak to chces robit do pola pouzil by som boolean hodnoty

... neviem ci je to myslene ako chytak (neviem ako to mas presne zadane) ale cislo 000 000 111 je podla mna trojbitove ... cize by som riesil len cisla s jednotkou na zaciatku

#11 gaucan
Tak to nevzdávej tak brzo a nesnaž se hned řešit celý "velký problém" (možností bude 84)

Takovéto úlohy se právě  řeší postupně od jednoduššího ke složitějšímu...

Další krok bude zobecnění toho příkladu - naplnění nulami a posouvání jedniček jen v určeném rozmezí od - do

Dalším krokem bude zvýšení počtu jedniček.

No a to už se zobecňovat nemusí, přidá se druhá a třetí jednička a už to valí...

111000000 110100000 110010000 110001000 110000100 110000010 110000001 101100000 101010000 101001000 101000100 101000010 101000001 100110000 100101000 100100100 100100010 100100001 100011000 100010100 100010010 100010001 100001100 100001010 100001001 100000110 100000101 100000011
011100000 011010000 011001000 011000100 011000010 011000001 010110000 010101000 010100100 010100010 010100001 010011000 010010100 010010010 010010001 010001100 010001010 010001001 010000110 010000101 010000011
001110000 001101000 001100100 001100010 001100001 001011000 001010100 001010010 001010001 001001100 001001010 001001001 001000110 001000101 001000011
000111000 000110100 000110010 000110001 000101100 000101010 000101001 000100110 000100101 000100011
000011100 000011010 000011001 000010110 000010101 000010011
000001110 000001101 000001011
000000111

Flowy: 9bitove znamena  9 miestne cislo 

#12 Flowy
Heleď, jestli s tím chceš pomoct, tak makej, za chvíli jdu jíst a pak du ven...

Udělej to, co jsem ti psal v javě a dej to sem, ať se pohnem...

hmm tak to zbytecne necekej, to tak rychle nebude, sice chapu cos napsal i jak to uz resit, ale to potrva kym si to v hlave srovnam a prenesu do kodu, tak ja to tu pak dam, zatim si di klidne ven, stejne to ma cas az do nedele pulnoci

#16 gaucan
Já na nic nečekám, makám na svým domácím úkolu, to tvoje zadání jsem si zmáknul jen tak na odfrknutí a občas sem kouknu co je novýho...

0001 sa ulozi na 4 bitoch ale je to cislo 1 a ma 1 cifru

tak prozatim dik, ja to skusim nejak zbouchat a kdyz budu mit otazku tak napisu :D 

zatim tedy mam  jen 5bitove a 1 jednicka a 4 nuly :D ted du zistit jak to predelam na to 9bitove a 3 jednicky a 6 nul :O

public class vypis
{

private int pole[]= new int[5];

    public void main ()
    {
        for(int i=0;i<5;i++)
        { // vynuluje pole
            for(int j=0;j<5;j++)
            {
                pole[j]=0;
            }
            pole[i]=1; // posunie jednicku
       
            for(int j=0;j<5;j++)
            { // vypise vznikle cislo
                System.out.print(pole[j]);
            }
            System.out.println();
        }
    }
}

#20 gaucan
Takže druhý level:

Uprav to tak, že to to bude tu jedničku umisťovat jen od určité zadané pozice

Například od pozice 3:

00100

00010

00001

#21 JoDiK
Až to budeš mít, zobecni i počet míst v čísle na nějaké n. pozice začátku bude třeba z.

Další krok bude pracovat s více jedničkami - obecně s  počtem třeba s

Příklad pro n=5 a s=2 a z=2

01100

00110

00011

tady to je od te 3ti pozice 

public class vypis
{

private int pole[]= new int[5];

    public void main ()
    {
         System.out.println("\f");
        for(int i=2;i<5;i++)
        { // vynuluje pole
            for(int j=0;j<5;j++)
            {
                pole[j]=0;
            }
            pole[i]=1; // posunie jednicku
       
            for(int j=0;j<5;j++)
            { // vypise vznikle cislo
                System.out.print(pole[j]);
            }
            System.out.println();
        }
    }
}

#23 gaucan
výborně, ale teď už začni zobecňovat - počet číslic nebude 5 ale nějaké obecné n

počáteční pozice nebude 3 ale třeba z

Ověř funkčnost na několika kombinacích n a z

3,1

6,4

7,7

1,1

a podobně...

tak tady je to zobecneno  jeste treba dodelat  aby to delalo pro vic nez jednu jednotku

public class vypis
{
private int pocetBitu=9;
private int pole[]= new int[pocetBitu];
private int zacatek=3; // zacatecni pozice 

    public void main ()
    {
         System.out.println("\f");
        for(int i=zacatek-1; i<pocetBitu; i++)
        { // vynuluje pole
            for(int j=0;j<pocetBitu;j++)
            {
                pole[j]=0;
            }
            pole[i]=1; // posunie jednicku
       
            for(int j=0;j<pocetBitu;j++)
            { // vypise vznikle cislo
                System.out.print(pole[j]);
            }
            System.out.println();
        }
    }
}

ani za boha nemuzu prijit na to jak do toho zakomponovat kombinaci vsech dvou jednotek :( s jednou jednotkou v pohode ale s vic.. 

pre jednu pouzivas jeden index ktory chodi od konca po zaciatok (alebo naopak to je jedno) ... pre dalsie si spravis dalsie indexy ale ich koniec/zaciatok bude inde

#27 Flowy
absolutne netusim jak to zakomponovat do myho kodu, skus to zakomponovat ty 

public class vypis
{
private int pocetBitu=9;
private int pole[]= new int[pocetBitu];
private int zacatek=3; // zacatecni pozice 
private int index[] = { zacatek };

    public void main ()
    {
         System.out.println("\f");
        do {
        	// vynuluje pole
            for(int j=0;j<pocetBitu;j++)
            {
                pole[j]=0;
            }
            
            for (int i=index.length-1;i>=0;i--) {  //pre kazdu jednotku a zacina sa tou napravo
            pole[index[0]]=1; // zapise jednicku
            index[0]++;  //posunie jednotku
            }
      
            for(int j=0;j<pocetBitu;j++)
            { // vypise vznikle cislo
                System.out.print(pole[j]);
            }
            System.out.println();
if (index[0]<pocetBitu) continue;
else break;} while(true);    }
}

este sa zabavis pri viacerych indexoch tak aby sa posuvali v zavyslosti na sebe

mas problem v tom ze si si spravil cyklus ktory predpoklada ze vies kolko cisel budes potrebovat

musis si spravit while (resp mozes si vypocitat kolko cisel budes mat ale neni to potrebne) a pouzit podmienku ktorou zistis ci si na konci (ze si vytlacil cislo ktore ma vsetky jednotky na druhej strane) ... teraz pouzivas ako index int i ... tento musis zvysovat sam ... 

ked to budes mat skus si to napisat tak aby sa ti tie cisla vypisali viackrat (ked jednotka dorazi na koniec tak ju nastavis o jednu viac atd)

ked to budes mat tak jednoducho pridas pole indexov (pre kazdu jednotku jeden index ktory znamena jej poziciu) a ked ti pride jednotka na koniec tak si ponusunies predchadzajucu jednotku a zarovnas k nej tu prvu

#26 gaucan

Jsem se vrátil zvenku, chvilku tu ještě budu, nevím jestli ty...

Tohle
pole[i]=1; // posunie jednicku

je potřeba udělat pro dvě jedničky (obecně pro tolik, kolik se jich bude zpracovávat)

takže místo jednoho přiřazení tam bude další cyklus a měl by dělat tohle:

příklad pocetBitu=6, zacatek=2, pocetJednicek=2

011000

001100

000110

000011

Udělej to...

#30 JoDiK
staci takhle? 
public class vypis
{
private int pocetBitu=6;
private int pole[]= new int[pocetBitu];
private int zacatek=2; // zacatecni pozice 

    public void main ()
    {
         System.out.println("\f");
       
        for(int i=zacatek-1; i<pocetBitu-1; i++)
        {
            for(int j=0;j<pocetBitu;j++)
            { // vynuluje pole
                pole[j]=0;
            }
            pole[i]=1; // vypise jednicku na posunutej pozici
            pole[i+1]=1;
           
           
            for(int j=0;j<pocetBitu;j++)
            { // vypise vznikle cislo
                System.out.print(pole[j]);
            }
            System.out.println();
        }
    }
}

#31 gaucan
Nestačí, není to obecné. Musíš tam  použít další cyklus...

#32 JoDiK
Až to budeš mít, zkontroluj že to bez problémů funguje na příkladech, třeba:

pocetBitu=3, zacatek=1, pocetJednicek=1

100

010

001

pocetBitu=5, zacatek=2, pocetJednicek=3

11100

01110

00111

Musíš si správně ohlídat meze...

tak uz mam, ten cyklus si chtel pro vypis poctu jednicek? pac tak sem to pochopil 
a btw tvuj druhej vypis by mel byt jenom 

01110

00111

pac se zacatek=2...  

public class vypis
{
private int pocetBitu=6;
private int pole[]= new int[pocetBitu];
private int zacatek=2; // zacatecni pozice
private int pocetJednicek=2;

    public void main ()
    {
         System.out.println("\f");
       
        for(int i=zacatek-1; i<pocetBitu-pocetJednicek+1; i++)
        {
            for(int j=0;j<pocetBitu;j++)
            { // vynuluje pole
                pole[j]=0;
            }
           
            for(int pom=0; pom<pocetJednicek; pom++)
            pole[pom+i]=1; // vypise jednicku na posunutej pozici
           
           
           
            for(int j=0;j<pocetBitu;j++)
            { // vypise vznikle cislo
                System.out.print(pole[j]);
            }
            System.out.println();
        }
    }
}

sice to nemám v javě, tu tady nemám po ruce, ale základní logiku si z toho snad odvodíš

nemám ten cyklus úplně nejlíp optimalizovanej, to by bylo jedině přes bitový posuny, ale pro takovýhle malý čísla je to v pohodě 

// kontroluje spravny pocet bitu v binarni hodnote
bool isValidBits(const string bin, const unsigned bits)
{
    int result = 0;

    for (int i = 0; i < bin.length(); ++i)
    {
        if (bin[i] == '1') ++result;
        if (result > bits) return false;
    }
    return (result == bits);
}

// ziska pole binarnich vysledku
vector<string> getBinary(const string startBin, const string endBin, const unsigned bits)
{
    // ziska decimalni hodnoty z binarnich cisel
    // funkce "bin2dec" a "dec2bin" si snad napises sam ^.^
    const ulong decMin = bin2dec(startBin);
    const ulong decMax = bin2dec(endBin);

    // pro ulozeni vysledku binarnich kombinaci
    vector<string> result;

    // projde vsechny hodnoty do maximalniho cisla v binaru
    // pro binar "111000000" je to 448 iteraci
    for (int i = decMin; i <= decMax; ++i)
    {
        // prevede cislo na binarni tvar
        string bin = dec2bin(i);

        // prida dodatecne "0", aby delka binarnu byla konstantni
        if (bin.length() < endBin.length())
            bin = string(endBin.length() - bin.length(), '0') + bin;

        // kontroluje, jestli v binarnim cisle je spravny pocet bitu a prida ho do pole
        if (isValidBits(bin, bits))
            result.push_back(bin);
    }
    return result;
}

int main()
{
    // binarne "od" a "do" a pocet bitu, ktere se maji hledat (v zadani jsou 3)
    vector<string> result = getBinary("000000111", "111000000", 3);

    for (string bin : result)
        cout << bin << endl;

    return EXIT_SUCCESS;
}

výsledek je pak následující 

000000111
000001011
000001101
000001110
000010011
000010101
000010110
000011001
000011010
000011100
000100011
000100101
000100110
000101001
000101010
000101100
000110001
000110010
000110100
000111000
001000011
001000101
...
... a tak dale...
...
111000000

snad to trochu pomohlo =D

#34 gaucan
Jo, máš pravdu s tím druhým příkladem, ty to máš správně.

Takže zbývá poslední zobecnění.

Všechno to, co jsme doteď dělali, musí jít i od zadané pozice. Nebo-li přibyde ještě jedna proměnná, od kolikáté pozice se to má začít plnit nulami, přičemž všechny předchozí pozice musí zůstat beze změny.

Doporučuji naplnit pole pro kontrolu třeba dvojkama a přidat proměnnou třeba pocatek

pocatek=3, pocetBitu=7, zacatek=4, pocetJednicek=2

Příprava:

2222222

Program:

2201100

2200110

2200011

#36 JoDiK
Jejda, já si ten program neuložil, a teď už mi to pomaleji myslí, takže není potřeba další proměnná, jen ty nuly by měly začínat od pozice zacatek. Vše ostatní platí, takže:

pocetBitu=7, zacatek=4, pocetJednicek=2

Příprava:

2222222

Program:

2221100

2220110

2220011

#37 JoDiK
Jdu pod sprchu, takže pak už chybí jen udělat z toho co máš podprogram s těmito parametry:

zacatek, pocetJednicek

No a pak ho zavoláš postupně ve třech cyklech

Začneš cyklem pro tři jedničky

Do něj vnoříš cyklus pro dvě jedničky se začátkem o jednu dál než je pozice první jednička

a třetí pro jednu jedničku se začátkem o dvě dál oproti první jedničce

Kdybys to nedal, tak zítra se snad kouknu...

ja si to udelal i s tim pocatkem.. 

public class vypis
{
private int pocetBitu=7;
private int pole[]= new int[pocetBitu];
private int zacatek=4; // zacatecni pozice
private int pocetJednicek=2;
private int pocatek=3;

    public void main ()
    {
         System.out.println("\f");
       
        for(int i=zacatek-1; i<pocetBitu-pocetJednicek+1; i++)
        {
            for(int j=0;j<pocetBitu;j++)
            { // priprava
                pole[j]=2;
            }
           
            for(int j=pocatek-1;j<pocetBitu;j++)
            { // vynuluje pole od pocatku
                pole[j]=0;
            }
           
            for(int pom=0; pom<pocetJednicek; pom++)
            pole[pom+i]=1; // vypise jednicku na posunutej pozici
           
           
           
            for(int j=0;j<pocetBitu;j++)
            { // vypise vznikle cislo
                System.out.print(pole[j]);
            }
            System.out.println();
        }
    }
}

teda uz sem odstranil ten pocatek, ten tam zbytecne navic, takze takhle 

public class vypis
{
private int pocetBitu=7;
private int pole[]= new int[pocetBitu];
private int zacatek=4; // zacatecni pozice
private int pocetJednicek=2;

    public void main ()
    {
         System.out.println("\f");
       
        for(int i=zacatek-1; i<pocetBitu-pocetJednicek+1; i++)
        {
            for(int j=0;j<pocetBitu;j++)
            { // priprava
                pole[j]=2;
            }
           
            for(int j=zacatek-1;j<pocetBitu;j++)
            { // vynuluje pole od zacatku
                pole[j]=0;
            }
           
            for(int pom=0; pom<pocetJednicek; pom++)
            pole[pom+i]=1; // vypis jednicek
           
           
           
            for(int j=0;j<pocetBitu;j++)
            { // vypise vznikle cislo
                System.out.print(pole[j]);
            }
            System.out.println();
        }
    }
}

#35 ingiraxo
tak by to slo asi  taky , ale ted skousime s Jodikem to resit jinak, tak pak to snad skusim i tvym spusobem :D 

tak jako netusim jak si to myslel jak to udelat s tema vnorenyma cyklama... udelal sem to na metodu( funkci/podpogram)
ale jedine co umim vypsat sou te 3 jednicky pri sobe, tu je muj kod, skus napsat jaks to ty myslel 

public class vypis
{
private int pocetBitu=9;
private int pole[]= new int[pocetBitu];
//private int zacatek=4; // zacatecni pozice
//private int pocetJednicek=2;

    public void fce(int zacatek, int pocetJednicek)
    {
       
       
        for(int i=zacatek-1; i<pocetBitu-pocetJednicek+1; i++)
        {
            /*for(int j=0;j<pocetBitu;j++)
            { // priprava
                pole[j]=2;
            }*/
           
            for(int j=zacatek-1;j<pocetBitu;j++)
            { // vynuluje pole od zacatku
                pole[j]=0;
            }
           
            for(int pom=0; pom<pocetJednicek; pom++)
                pole[pom+i]=1; // vypis jednicek
         
            for(int j=0;j<pocetBitu;j++)
            { // vypise vznikle cislo
                System.out.print(pole[j]);
            }
            System.out.println();
        }
    }
 
    public void main()
    {
          System.out.println("\f");
     
          fce(1,3); // vypis vsech 3 jednicek pri sobe
        
               
    }
}

Tak jsem si to musel udělat znovu (jak jsem to včera neuložil).

Samozřejmě mě hned napadlo několik dalších možných řešení, včetně rekurzivního, ale dokončíme to, co jsme začali...

Nakonec ten třetí parametr tam bude muset být...

Takže budeme mít podprogram napln(zacatek, od, kolik)

zacatek - pozice odkud se budou plnit nuly

od - pozice, odkud se budou plnit jedničky

kolik - kolik bude těch jedniček

v hlavním programu bude tento první cyklus:

pro i=1 to pocetBitu

napln(1,od,3)

vypis(pole)

dalsi i

tohle odladit ať funguje...

pak se zařadí další vnořený cyklus, který bude pokračovat o jednu pozici dál a bude dávat o jednu jedničku méně.

pro i=1 to pocetBitu
   napln(1, od, 3)

   pro j=i+1 To pocetBitu-1
        napln(i+1, j, 2)

	vypis(pole)
   dalsi j

dalsi i

No a na závěr už ten třetí cyklus zase o jednu pozici dál a o jedničku méně.

To už určitě zvládneš sám...

Já se jdu kouknout na ta další řešení...

Takže to další řešení bude optimalizační - není třeba plnit všechny jedničky (stejně se v tom dalším vnořeném cyklu přepíšou) bude stačit dávat jen jednu.

Ale to už je na tobě, jestli pochopíš to předchozí řešení a dokážeš ho sám zoptimalizovat...

ah, ja ti nejak nerozumim ze co chces aby to jako delalo, mohl bys popsat co chces aby bylo jako vystup pro ty dalsi pripady? (3 jednotky po hromade sou jasny) 

a btw tohle musis mit spatne:  

pro i=1 to pocetBitu
   napln(1, od, 3)

pac tohle nesmi byt v cyklu pac uz jenom samotne napln(1,od,3) vypise vsech 7 kombinaci troch jednicek pri sobe, takze zbytocne bys vypisoval to same nekolikrat 

v podstate po tomhle 
111000000
011100000
001110000
000111000
000011100
000001110
000000111
absolutne netusim co dale chces po me abych vypisoval , tak mi to prosim rekni

chces abych vypsal pak tohle? 
110000000
011000000
001100000
000110000
000011000
000001100
000000110
000000011 
a jestli jo tak co pak chces s tim? abych sebral 110000000 a pridelal tam 
110100000
110010000
110001000
110000100
110000010
110000001 
?

ked sa posledna jednotka dostane na koniec tak posunies dalsiu jednotku a zaradis tu poslednu pred nu

#46 gaucan
posouvá se zprava doleva, takže na příkladu pro 5. místné číslo, kde budou 2 jedničky, bude výstup vypadat takto 

00011
00101
00110
01001
01010
01100
10001
10010
10100
11000

to o co se snažíš ty, jak si ted uvedl je nesmysl, protože vynecháváš dost čísel (kombinací chceš-li) nebo v opačným případě děláš duplicitní výsledky, takže musíš udělat alg. na přesně takovýhle "výpočet"

uz sem docela to skoro cele zmazal a hodne predelal a sem na docela dobre ceste tak to sem placnu az to dodelam :D 

#49 gaucan
To je ideální stav, když si to doděláš sám...

Chybu tam nemám, jen jsme nesjednotili to, co má dělat podprogram napln.

Jak jsem si to včera neuložil, tak jsem si to přesně nepamatoval a navedl tě trochu mimo.

Ale zdá se, že princip jsi pochopil...

Až to doděláš po svojemu, můžeš to porovnat s mým řešením:

Dim cisla
Dim pocet
Dim vystup

Sub naplnJednicku(zacatek, kam)
Dim i
For i = zacatek To pocet
    cisla(i) = 0
Next i
cisla(kam) = 1
End Sub

Function Seznam()
Dim i
Dim s
For i = 1 To pocet
  s = s & cisla(i)
Next i
Seznam = s
End Function

Sub trojicky()
Dim vypis
Dim i, j, k
cisla = Array(0, 0, 0, 0, 0, 0, 0, 0)
pocet = UBound(cisla)
vypis = Seznam
For i = 1 To pocet - 2
    Call naplnJednicku(1, i)
    For j = i + 1 To pocet - 1
        Call naplnJednicku(i + 1, j)
        For k = j + 1 To pocet
            Call naplnJednicku(j + 1, k)
            vypis = vypis & vbNewLine & Seznam
        Next k
    Next j
Next i
MsgBox vypis
End Sub

Spustitelné v jakémkoliv office, počet bitů se určuje počtem nul (-1) v deklaraci

cisla = Array(0, 0, 0, 0, 0, 0, 0, 0)

tak ja zatim postnu co mam  :D 
zatim tohle muj vypis 
111000000
110100000
110010000
110001000
110000100
110000010
110000001

011100000
011010000
011001000
011000100
011000010
011000001

001110000
001101000
001100100
001100010
001100001

000111000
000110100
000110010
000110001

000011100
000011010
000011001

000001110
000001101

000000111

a tady je kod : 

import java.util.*;

public class vypis
{
private int pocetBitu=9;
ArrayList<Integer> pole = new ArrayList<Integer>(9);

    private void napln(int zacatek,int od, int pocetJednicek)
    {

            for(int j=zacatek;j<pocetBitu;j++)
            { // nulovanie od zacatku
                pole.add(j,0); // list.add(index,object)
            }
        
            for(int pom=0; pom<pocetJednicek; pom++)
                pole.add(pom+od,1); // vypis jednicek
    }
   
    private void vypis()
    { // vypis araylistu
         for(int j=0;j<pocetBitu;j++)
            {
                System.out.print(pole.get(j));
            }
            System.out.println();
    }
       
 
    public void main()
    {
          System.out.println("\f");
       
          int nulovatOd=2;
          for(int i=0; i<pocetBitu-3+1; i++)
          {
                napln(0,i,3); // OK vypis vsech 3 jednicek pri sobe
                vypis(); // OK
               
                for(int j=1;j<pocetBitu-nulovatOd; j++)
                {
                            napln(nulovatOd,nulovatOd+j,1);
                            vypis();
                }
                nulovatOd++; // zvetsime pocet prvych nemennych cisel
                System.out.println();
               
          }
    }
}

#50 JoDiK
tak jako kdyz to napises v nevimcem a jeste neokomentovane tak fakt netusim jak to predelat do me Javy/C... sem skousel to teda nako prepsat ale je to jiste blbost tak to skus opravit 

public class pokus {

int [] cisla;
int pocet;
int vystup;

public void naplnJednicku(int zacatek, int kam)
{
    int i;
    for(i=zacatek;i<pocet;i++)
        cisla[i]=0;
       
    cisla[kam]=1;
}

public void seznam()
{
int i ;
int s;

for(i=1; i < pocet;i++)
    s= s & cisla[i];
   
    seznam = s;
}

public void trojicky()
{
    int vypis;
    int i,j,k;
    int [] cisla = {0,0,0,0,0,0,0,0};
    vypis = seznam;
   
    for(i=1;i<pocet-2;i++)
    {
        naplnJednicku(1,i);
        for(j=i+1;j<pocet-1;j++)
        {
            naplnJednicku(i+1,j);
            for(k=j+1;k<pocet;k++)
            {
                naplnJednicku(j+1,k);
                vypis = vypis & vbNewLine & Seznam;
            }
        }
    }
    vypis;
   
}
}

vkladaj tie kody ako source code ...

#52 gaucan
Nemusíš to přepisovat, stačí když dokončíš to co máš...

#54 JoDiK
V tom pseudokódu by to bylo:

pro i=1 to pocetBitu-2
   napln(1, od, 3)

   pro j=i+1 To pocetBitu-1
        napln(i+1, j, 2)

        pro k=j+1 To pocetBitu
        	napln(j+1, k, 1)
	
		vypis(pole)
	dalsi k

   dalsi j

dalsi i

Koukám, že v tom první cyklu jsem měl kopírovací chybu... prochází se do pocetbitu-2

#55 JoDiK
Pro kontrolu, co to dělá u mně:

1110000
1101000
1100100
1100010
1100001
1011000
1010100
1010010
1010001
1001100
1001010
1001001
1000110
1000101
1000011
0111000
0110100
0110010
0110001
0101100
0101010
0101001
0100110
0100101
0100011
0011100
0011010
0011001
0010110
0010101
0010011
0001110
0001101
0001011
0000111

#55 JoDiK
jn cez tohle mi to uz taky de , diky :D 

 

111000000
110100000
110010000
110001000
110000100
110000010
110000001
101100000
101010000
101001000
101000100
101000010
101000001
100110000
100101000
100100100
100100010
100100001
100011000
100010100
100010010
100010001
100001100
100001010
100001001
100000110
100000101
100000011
011100000
011010000
011001000
011000100
011000010
011000001
010110000
010101000
010100100
010100010
010100001
010011000
010010100
010010010
010010001
010001100
010001010
010001001
010000110
010000101
010000011

001110000
001101000
001100100
001100010
001100001
001011000
001010100
001010010
001010001
001001100
001001010
001001001
001000110
001000101
001000011
000111000
000110100
000110010
000110001
000101100
000101010
000101001
000100110
000100101
000100011

000011100
000011010
000011001
000010110
000010101
000010011
000001110
000001101
000001011

000000111
riadkov je84

a tady kod 

 

import java.util.*;

public class pokus2 
{
 private int pocetBitu=9;
 ArrayList<Integer> pole = new ArrayList<Integer>(9); 
 
    private void napln(int zacatek,int od, int pocetJednicek)
    { 
            zacatek--;
            od--;
            
            for(int j=zacatek;j<pocetBitu;j++)
            { // nulovanie od zacatku
                pole.add(j,0); // list.add(index,object)
            }
         
            for(int pom=0; pom<pocetJednicek; pom++)
                pole.add(pom+od,1); // vypis jednicek 
    }
    
    private void vypis()
    { // vypis araylistu
         for(int j=0;j<pocetBitu;j++)
            { 
                System.out.print(pole.get(j));
            }
            System.out.println();
    }
        
  
    public void main()
    {
          System.out.println("\f");
          int sucet=0;
          
          for(int i=1; i<pocetBitu-2+1; i++)
          { 
                napln(1,i,3); 
             
                    
                    for(int j=i+1;j<pocetBitu-1+1; j++)
                    {
                            napln(i+1,j,2);
                           
                            for(int k=j+1;k<pocetBitu+1;k++)
                            {
                                napln(j+1,k,1);
                                vypis();
                                sucet++;
                            }
                            
                    }
                    System.out.println();
          }
          System.out.println("riadkov je"+sucet);
        }
    }

#57 gaucan
přepsal jsem to do c++ (do jedný fce), páč mě zajímalo jak to bude vypadat, když to je doslova ráj cyklů =D

a musim říct - wau... 

void vypocet()
{
    int soucet = 0;

    for (int i = 1; i < pocetBitu - 2 + 1; ++i)
    { 
        for (int x = 0; x < pocetBitu; ++x)
            pole[x] = 0;

        for (int y = 0; y < 3; ++y)
            pole[y + i - 1] = 1;

        for (int j = i + 1; j < pocetBitu - 1 + 1; ++j)
        {
            for (int x = i; x < pocetBitu; ++x)
                pole[x] = 0;

            for (int y = 0; y < 2; ++y)
                pole[y + j - 1] = 1;

            for (int k = j + 1; k < pocetBitu + 1; ++k)
            {
                for (int x = j; x < pocetBitu; ++x)
                    pole[x] = 0;

                for (int y = 0; y < 1; ++y)
                    pole[y + k - 1] = 1;

                for (int z = 0; z < pocetBitu; ++z)
                    cout << pole[z];

                cout << endl;
                soucet++;
            }
        }
        cout << endl;
    }
    cout << "Radku je " << soucet << endl; // 84
}

Jinak jsem to i měřil, a vyšlo to průměrně na 105ms (dokončení  celý funkce)

#58 ingiraxo
btw mas jedno jestli delas  ++x nebo x++ pac se to deje jenom na konci iterace

#59 gaucan
v c++ to jedno neni, bezpečnější zápis je preinkrementace