Zjednodušení algoritmu – .NET – Fórum – Programujte.com

Zdravím,

už druhý den si lámu hlavu s tímto kodem, spíše s jeho zjednodušením, protože bych ho do budoucna chtěl rozšířit o další čísla, ale už takhle "jenom" při 3 číslech je to neskutečně zdlouhavý.

Zjednodušeně, jedná se o brutoforce attack s tím, že zkouší kombinace "pro tří číselný zámek" 0 0 0 -> 0 0 1 -> 0 0 2 -> ... 0 0 9 -> zvýší nadřezený (0 1 9) -> sníží podřízený postupně od 9 do 0 (0 1 0) a takhle jede dál... Jde o to, že bych to nechtěl vynulovat (proměnnou) na 0 a jet od znova ale ten postup na snížení se musí dodržet. Chtěl bych to udělat nějak elegantně, ale nedokážu si představit tohle psát třeba pro 20čísel.

Enum Send označuje že teprve tam se provede "ODESLANI" kodu (na server). Kód funguje přesně jak potřebuju a jak to má fugnovat (postup musí zustat), jen bych ho rád nějak zjednodušil a vůbec mě nenapadá jak.

Kod není úplně totožný s originálem (je to jen pro testování ve VS a bylo zkompilovatelný) proměnný
lFirstNum, lSecondNum, lThirdNumber tam ve skutečnosti nejsou je to demonstrace dat co přijdou ze serveru (ale to je asi irelevantní)
 

static void Main(string[] args)
        {
            Switch FHatratTruhlaSwitch = Switch.RaiseThird;
 
            int lFirstNum = 0;
            int lSecondNum = 0;
            int lThirdNumber = 0;
 
            while (true)
            {    
                switch (FHatratTruhlaSwitch)
                {
                    case Switch.RaiseThird:
                        if (lThirdNumber == 9)
                            FHatratTruhlaSwitch = Switch.RaiseSecond;
                        else
                        {
                            lThirdNumber += 1;
                            FHatratTruhlaSwitch = Switch.Send;
                        }
                        break;
 
                    case Switch.DownThird:
                        if (lThirdNumber != 0)
                        {
                            Console.WriteLine("Down " + lFirstNum.ToString() + "-" + lSecondNum.ToString() + "-" + lThirdNumber.ToString());
                            lThirdNumber -= 1;
                            FHatratTruhlaSwitch = Switch.DownThird;
                        }
                        else
                            FHatratTruhlaSwitch = Switch.Send;
                        break;
 
                    case Switch.RaiseSecond:
                        if (lSecondNum == 9)
                            FHatratTruhlaSwitch = Switch.RaiseFirst;
                        else
                        {
                            lSecondNum += 1;
                            FHatratTruhlaSwitch = Switch.DownThird;
                        }
 
                        break;
 
                    case Switch.DownSecond:
                        if (lSecondNum != 0)
                        {
                            Console.WriteLine("Down " + lFirstNum.ToString() + "-" + lSecondNum.ToString() + "-" + lThirdNumber.ToString());
                            lSecondNum -= 1;
                            FHatratTruhlaSwitch = Switch.DownSecond;
                        }
                        else
                            FHatratTruhlaSwitch = Switch.DownThird;
                        break;
 
                    case Switch.RaiseFirst:
                        if (lFirstNum == 9)
                        {
                            FHatratTruhlaSwitch = Switch.End;
                        }
                        else
                            FHatratTruhlaSwitch = Switch.DownSecond;
                        lFirstNum += 1;
                        break;
 
                    case Switch.Send:
                        Console.WriteLine(lFirstNum.ToString() + "-" + lSecondNum.ToString() + "-" + lThirdNumber.ToString());
                        Thread.Sleep(25);
                        FHatratTruhlaSwitch = Switch.RaiseThird;
                        break;
 
                    case Switch.End:
                        Console.WriteLine("Konec");
                        Console.ReadKey();
                        break;
                }
            }
        }
    

enum Switch: byte
    {
        RaiseFirst,
        RaiseSecond,
        RaiseThird,
        DownFirst,
        DownSecond,
        DownThird,
        Send,
        End
    }

Díky

Jen sem zapomněl dodat, že cyklus while je irelevantní (cyklus emuluje eventu co přijde ze serveru) kde po každé změně čísla příjde právě ona eventa. Takže zjednodušeně co 1 akce (zvýšení čísla/snížení čísla/odeslání kombinace) to přijde event (proto tam mám ten globální přepínač, který si drží v jaké fázi aktuálně je) kde po odeslání kombinace mi to napíše otevřeno nebo špatná kombinace (a tam se znova udrží stav pro zvýšení čísla až znova přijde event)

https://pastebin.com/ckWPWDtr

Tady jsem vytvořil přesnou kopii jak to funguje v praxi. Eventa simuluje přijem/odeslaní na server. Takže já sem závyslej jen na tom co se děje v eventě, nijak neovlivním data co mi dorazí.

#3 Mutagen
je ti jasné, že v okamžiku kdy dojdeš k 9 a měníš směr se ti to vyhodnotí až v dalším průchodu cyklu?

jinak 1/2 větví týkající se směrů by šla vyhodit, stačí si směr pro každou pozici uložit jako např. firstSmer +1 nebo -1, změna směru pak ..smer = -..smer  , a pak ještě odpovídajícím způsobem rozšířit podmínku.

Jak bych to resil ja, snad tam neni moc chyb, momentálně nemam jak vyzkouset. Jinak podle mě ten tvůj kod posílal až od 0 0 1 a  0 0 0 bylo přeskočeno bo jsi do cyklu vstupoval s nastavenim pro zmenu na 3. pozici a to samé v sendu nemohl ti fungovat smer dolů když v Sendu pokaždé nastavuješ RaiseThird.

enum Switch: byte
    {
        Dalsi,
        Send,
        End
    }

static void Main(string[] args)
        {
	    Switch FHatratTruhlaSwitch = Switch.Send; 
  
            int PocetPozic=3;
 
            int[] Pozice = new int[PocetPozic] {0,0,0};
            int[] Smer = new int[PocetPozic] {1,1,1};
            int Index = PocetPozic-1;
   
            while (true)
            {    
                switch (FHatratTruhlaSwitch)
                {
                    case Switch.Dalsi:
                        if (Index < 0)
			{
			    FHatratTruhlaSwitch = Switch.End;
			    break;
			}
                        if ((Pozice[Index] == 9) || (Pozice[Index] == 0))
			{
			    Smer[Index] -= Smer[Index];
                            Index -=1;
			}
                        else
                        {
                            Pozice[Index] += Smer[index];
                            FHatratTruhlaSwitch = Switch.Send;
                            Index = PocetPozic-1;
                        }
                        break;
			
 
                    case Switch.Send:
//Nutno UPRAVIT převést pole na string
//                        Console.WriteLine(lFirstNum.ToString() + "-" + lSecondNum.ToString() + "-" + lThirdNumber.ToString());
                        Thread.Sleep(25);
                        FHatratTruhlaSwitch = Switch.Dalsi;
                        break;
 
                    case Switch.End:
                        Console.WriteLine("Konec");
                        Console.ReadKey();
                        break;
                }
            }
        }


		

ještě jednodušší mít ty čísla zámku a směr v poli a v řízení jít přes index pak ti na jakýkoliv počet stačí jen zvětšit daná pole.

#4 MilanL
To je přesně ten důvod proč jsem napsal i ty další příspěvky a v tom posledním napsal přesnou simulaci jak to funguje.

Kdyby se to dalo řešit hned v jednom spuštění tak bych to dokázal taky napsat. Tady jde o to jak jsme psal v posledním příspěvku, že co akce (snížení/zvýšení/odeslání) to přijde nová eventa a je to na tom pastebinu kompletně funkční jak to funguje v praxi. To z čeho jsi vycházel byl pouze pseudokod na testování cyklu nikoli praktické použití proto jsem pak napsal i ty další příspěvky protože sem se v tom prvním nevjádřil až tak moc dobře.

Při začáteční inicializaci jsou všechno 0 (přijde ze serveru) a co akce to proběhne komunikace se serverem viz pastebin volání eventy (OnServerEvent(e);) simuluje akci co client pošle na server (v tomhle případě zvýšení/snížení/odeslání)... Pořád je to jen kod kterej má daleko k praxi protože v praxi (třeba) e.ThirdNumber += 1; je už právě to odeslání (je to jenom ukázka pro prostředí aby to demonstrovalo serverová data co se posílaj) takže si pod e.ThirdNumber += 1; představ akci co client odešle serveru.

#5 Mutagen
nj ale tak jak to máš postaveny to nezoptimalizuješpro každou další pozici si musíš udělat 2 extra větve pro raise a down

#6 MilanL
No právě proto sem žádal o pomoc tady, že já si nevím rady jak ybch to mohl zoptimalizovatz aniž bych musel přidávat další větve. Kdybych věděl jak to udělat tak se neptám zde :)

Samosebou to co jsi napsal jako první reakci tak ano to by takhle bylo možné, ale to tu proceduru neopustíš, tady právě jde o to, že co akce to komunikace se serverem viz pastebin

#7 Mutagen
asi už se dostávám do obrazu, napiš mi pak jestli jsem to pochopil správně:

1) ze serveru obdržíš číselnou řadu 3 a více čísel

2) client by měl zpracovat a poslat a ted co? novou číselnou řadu nebo příkaz?

Pokud by měl klient vychazet z čísel, která dostane ze serveru, tak je to jednoduché, test na směr se dá řešit z parity předchozího (sudý nahoru lichý dolů) a vždy se mění jen 1 číslo takže pokud jsi na konci testuješ předchozí úroven dokud nejsi na začátku

Následující postup ber jako inspiraci..

vstup : čísla ze serveru (pole nebo string)

naparsování čísel pro klienta nejlépe do pole

index podle délky pole

cyklus index >= 0

nastavení parity pro index 0 (jde jen 1 smerem nahoru) napevno parita = 0 pro ostatní parita = číslo[index-1] modulo 2

podmínka ((parita == 0 && číslo[index] == 9) || (parita == 1 && číslo[index] == 0))

splněno tak index - 1 cyklus se bude poakovat pro změnu na další pozici

else
{
podle toho co se posílá zpátky na server nastavit příkaz směru, nebo podle parity číslo[index] +-1 , podmínku na paritu lze obejít číslo[index] += 2*parita - 1;
break z cyklu
}

konec cyklu a podle indexu odeslání na server (pokud je index <0 jsi na konci testování

Ten generátor přece není problém izolovat a rozkrokovat.

class Generator
{
    public int[] code;
    public int[] smer;

    public Generator(int size)
    {
        code = Enumerable.Repeat(0, size).ToArray();
        smer = Enumerable.Repeat(1, size).ToArray();
    }

    public int[] Next()
    {
        for (int i = code.Length - 1; i >= 0; i--)
        {
            int val = code[i] + smer[i];
            if (val > 9 || val < 0)
            {
                smer[i] *= -1;
            }
            else
            {
                code[i] = val;
                break;
            }
        }
        
        return code;
    }
}

#10 gna
ano takhle jsem to myslel ja, neříkám že píšu optimalni kody,

jen ta zmena smeru, kdy se maji menit znaménka by mela byt Smer[i] = -Smer[i];

Ale on to myslel trošku jinak, já to pochopil tak, že potřebuje odpověd klienta pro server na základě dat přišlých ze serveru.

#11 MilanL

Já si myslím, že mu prostě ze serveru chodí aktuální kombinace, takže by mohl kontrolovat, jestli odpovídá tomu co zadal, ale jinak ta hodnota není podstatná.

Poznámku s měněním znaménka nechápu.

#9 MilanL
To je přesně to co asi nechápeš, ale o je v pohodě protože ono to asi nedokážu vysvětlit pořádně, ale fakt si představ že co +1 tak je odeslání na server ... tzv i kdybych chtěl tak nemůžu v cyklu přičíst třeba 10x a to samý když jdu dolů též -1 je akce co se přepošle tzv navýšení = komunikace client -> server -> do clienta se vrátí výsledek otevřeno neotevřeno a pokud neotevřeno provedu přičítáni znova ... Prostě to není klasický že bych to vše udělal v cklu a podle toho kontroloval na serveru. Jak jsem napsal to na pastebinu je to přesná simulace prostě co +1/-1 to komunikace přes server

#13 Mutagen

no ja nevidim rozdil mezi tim, jestli je to v cyklu, který po odeslání počká na odpověd ze serveru, nebo zda se obsah cyklu dá do procedury-eventu, který se zavolá při negativní odpovědi ze serveru, důležitý je mít správně nadefinované ty proměnné,

Každopádně v cyklu by mělo být to přičítání, aby se obsloužily ty situace kdy poslední číslice dojde na 0 nebo 9, tak aby se udělal přírůstek na dalším místě. Po každém přírůstku,pak opuštění cyklu a bud odeslání nebo konec.

#12 gna
EDIT: sakra jsem slepejš, ted jsem si všiml, že ten směr máš jinak, že násobíš -1, o je pak OK.

#14 MilanL
Je tam násobení zápornou jedničkou!

#15 gna
jj nevím kde jsem viděl ten smer -= smer, možná u sebe v tom prvním kodu, omlouvám se.

#15 gna
drobnost jak tvuj kod da vedet nadřízenému, že došel na konec? Jako chápu, že prakticky by tam dojít neměl, jedna z kombinací musí být platná.

Jinak v podstatě je to tak, jak jsem to v podstatě myslel já, jen elegantně  zabalené do třídy.

#17 MilanL
Mně šlo jen o to, jak Mutagen neviděl, že ten tvůj algortimus nemusí běžet na jeden zátah. Tak ja to je, by šlo testovat protočení tak, že to dvakrát vrátí stejnou hodnotu, ale to si může pořešit jakkoliv jinak.

#14 MilanL
Ten cyklus nemůže počkat, chápeš, že v cyklu to být nemůže už jenom kvuli tomu, že ty čekáš až ti přijde eventa? Pořád to řikám, jakmile přičteš jedničku je to akce u který to má skončit protože ti v tu chvíli příjde od serveru další eventa kde zpracováváš další příčtení?

Prostě to nejde udělat, že v 1 cyklu zkontroluju všechny kombinace, kdyby to šlo tak už to co tu píšete dávno mám tak přepsaný. Prostě si musím při přičtení čísla pamatovat stav kde jsem skončil abych mohl v následujcím kroku (v proceduře od znova) odtamtud pokračovat. Určitě by to šlo nějak udělat líp, ale né přesně jak tu radíte. Ale určitě nad tím pořád přemýšlím, tak snad to nějak vymyslím.

#19 Mutagen
Přesně o tom je tady řeč ty brzdo.

Generator gen = new Generator(3);

public bool podelanej_event()
{
    int[] prev = (int[]) gen.code.Clone();
    int[] next = gen.Next();
    
    Console.Write("{0} -> {1} = ", String.Join("", prev), String.Join("", next));
    for (int i = 0; i < next.Length; i++)
        Console.Write("-.+"[1 + next[i] - prev[i]]);
    Console.WriteLine("");
}

#19 Mutagen

hele já v podstatě v NETu nedělám, ale na tohle stačí obecné znalosti. Ten můj první příspěvek byl v podstatě reakcí na.ten tvuj kod.

GNA je zkušenej ví o čem píše, když navrhne nějaký kod na 99,9999% to funguje podle toho co lidi potřebují.

Podstatná je jediná věc objekt Gerenátoru musí být pro klienta definován globálně, aby se zachovával stav, v eventě pak voláš na generatoru metodu Next která generuje přírůstek na jedné z pozic podle tvých podmínek, cyklus je tam od toho, aby v případě, že na poslední případně další pozici je budoucí číslo (pomocná proměnná val) mimo rozsah 0-9, to otočilo směr počítání a udělalo změnu na další pozici. Změna je vždy jen 1 po ní se cyklus ukončí "Break" ..em.

Navíc je to otevřené ohledně počtu pozic, při vytváření objektu mu posíláš v argumentu velikost, tzn počet pozic je omezen pouze na limit velikosti pole v NET.

#20 gna
Ajo máš pravdu, promin, ten princip funguje přesně jak potřebuju, jenže to je jen ten princip, (pro vývoj. studio) pořád tu je ta věc, že akce +1 simuluje tlačítko co automaticky pošle data na server takže ve výsledku musím ještě tohle doladit, ale s tím si musím poradit už sám.

PS. opravdu díky, ten kod je fakt parádní, snad se mi povede to přepsat přímo pro ten učel co potřebuju.

n - cisel (kod delka)
m - znaku, znaky = string "1234' (kod pocet znaku)

 Pseudokod by mohl vypadat nejak takto:

kod = []
cyklus (i = 0 az n delka)
	{
	next = 1;
	cyklus (j = 0 az n delka) // zkotroluj vsechny znaky
		{
		next = vyhodnot(j, next) // x = kod[j]; x++; if (x<m) {kod[j] = x; return 0;}; kod[j] = 0; return 1;
		if (next==0) break;
		}
        // vypis kod...
	}