Loput operaatiot sarjamuotoisesti on todella helppoa.Tärkein oletus on, että tiedot tulevat ensin MSB: ksi, jos ne ovat sarjakuvia.Tarvitset vain N tilaa jäljellä olevan moduulin N laskemiseksi. Aloita "0" -tilassa ja jos päädyt "0" -tilaan viimeisen bitin jälkeen (ei ole väliä kuinka monta bittiä on), loput ovatnolla.

^{simuloi tätä virtapiiriä - Kaavio luotu käyttämällä CircuitLab}

Ajattele, kuinka tekisit pitkän jaon, jos ainoa asia, jota tarvitsit seurata, oli loput:

  -prosessi (clk)
alkaa
  jos nouseva_reuna (clk) sitten
    jos nollaus = 1, niin
      tila < = 0;
    muu
      jos (ilmoita & din) > = N sitten
        tila < = (tila & din) - N;
      muu
        tila < = tila & din;
      loppu Jos;
    loppu Jos;
  loppu Jos;
lopeta prosessi;
 

Voit myös suunnitella tilakoneen, jos data on ensin LSB:

Tällaisen deterministisen äärellisen automaatin (DFA) olemassaolo seuraa suoraan toisesta vastauksesta, jossa kuvataan ensin MSB: n DFA. Koska DFA: n hyväksymät kielet ovat tavallisia ja säännöllisten kielten tiedetään olevan suljettuja käänteessä (esim. Katso täällä), on oltava DFA, joka hyväksyy seuraavan kielen:

\ $ L = \ {w \ sisään \ {0,1 \} ^ * | \ \ text {käänteinen} (w) _ {10} \ \ text {on jaettavissa arvolla} 5 \} \ $.

Rakentaminen

1. Kopioi MSB: n ensimmäinen DFA Dave Tweedin vastauksesta. Käytin siihen automaattityökalua JFLAP.

2. Käytä eksplisiittistä muunnosalgoritmia DFA-peruutuksiin, esim. kuten CS.SE: ssä on kuvattu: DFA: n suunnittelu ja sen kääntöpuoli.
   Näet tämän vaiheen (rajoittamattoman) tuloksen tämän vastauksen vanhassa versiossa.

3. Minimoi tuloksena oleva DFA. Valitettavasti tämä ominaisuus on hieman buginen viimeisimmässä JFLAP-versiossa, joten erosin minimoimalla sen käsin.
   Jälleen on olemassa monia algoritmeja ja lähteitä niille. Käytin niitä, jotka on kuvattu osoitteessa “DFA-minimointi” tutorialspoint.com-sivustossa.
   
   (Itse asiassa, jos silmäsi on koulutettu riittävän hyvin katsomalla DFA: ta, voit suoraan nähdä , että \ $ q_0 \ $ ja \ $ q_1 \ $ ovat samanlaisia ​​tiloja DFA: ssa kuin kohdassa 2 on saatu. Minun ei ole, kiitos huomaamastasi, mene superkissan kommenttiin!)

Tuloksena oleva automaatti antaa oikeat vastaukset:

Liite: Helppokäyttöisyydestä johtuen DFA, joka hyväksyy binääriluvut, jotka jaetaan 5: llä LSB-ensin, on \ $ A_ {rev5} = (Q, \ Sigma, \ delta, q_0, F) \ $ ja \ $ Q = \ {q_0, q_1, q_2, q_3, q_4 \} \ $, \ $ \ Sigma = \ {0,1 \} \ $, \ $ F = \ {q_0 \} \ $ ja \ $ \ delta \ $ seuraavasti:

\ $ \ delta (q_0, 0) = q_0, \ quad \ delta (q_0, 1) = q_1 \\ \ delta (q_1, 0) = q_4, \ quad \ delta (q_1, 1) = q_3 \\ \ delta (q_2, 0) = q_1, \ quad \ delta (q_2, 1) = q_2 \\ \ delta (q_3, 0) = q_2, \ quad \ delta (q_3, 1) = q_4 \\ \ delta (q_4, 0) = q_3, \ quad \ delta (q_4, 1) = q_0 \ $

Yksi tapa löytää (MSB ensin) -tilakone on seuraava:

1. Tähän mennessä vastaanotettu numero on N .Oletetaan, että tiedät loput M = N mod 5 .

2. Uusi bitti on tulossa ja uusi arvo on nyt N '= N * 2 + b .

3. Uusi loppuosa on sitten M '= (N * 2 + b) mod 5 = (M * 2 + b) mod 5 .

Tämä on tarpeeksi helppo taulukoida käsin:

Toivotaan, että haastattelukysymys koski ongelmasi ratkaisemista pikemminkin kuin VHDL: n tai Verilogin haittoja. Kielitiedot ovat suoraviivaisia, kun sinulla on algoritmi.

Jos numero välitetään ensin bitti kerrallaan MSB: n kanssa, sitten luvun moduuli 5 arvo voidaan laskea alustamalla tila \ $ S = 0 \ $ ja keräämällä sitten arvo \ $ S \ vasen nuoli (2 S + d) \ text {mod} 5 \ $. Lopussa numero on jaettavissa 5: llä iff \ $ S \ $ on nolla. Koska \ $ S, d \ $ ovat rajattuja, päivitysyhtälö voidaan kirjoittaa yksinkertaiseksi tilakoneeksi, jonka tilat ovat \ $ S = 0, \ cdots, 4 \ $.

Jos numero välitetään ensin vähitellen LSB: n kanssa, meidän on tehtävä vähän enemmän työtä. Voit yrittää alustaa tilan \ $ S = 0, k = 0 \ $ ja sitten arvon kerääminen \ $ S \ vasemmalla nuolella (S + 2 ^ k d) \ text {mod} 5, k \ vasen nuoli k + 1 \ $. Tämän ongelmana on, että \ $ k \ $ on mahdollisesti rajaton, mutta koska \ $ 2 ^ 4 = 1 \ text {mod} 5 \ $, voimme yksinkertaistaa yllä olevan \ $ S \ vasen nuoli (S + 2 ^ k d) \ text {mod} 5, k \ leftarrow (k + 1) \ text {mod} 4 \ $. Jälleen kerran, koska \ $ S, k, d \ $ on rajattu, päivitysyhtälö voidaan kirjoittaa yksinkertaiseksi tilakoneeksi, jonka tilat ovat \ $ (S, k) \ $, missä \ $ S = 0, \ cdots, 4 \ $ , \ $ k = 0, \ cdots, 3 \ $.

Riippuen siitä, mihin VHDL kirjoitetaan, kannattaa käyttää lähestymistapaa, joka kuvaa sitä suorana, yhdistelmälaskelmana. Numeron vastaanottaminen voi tarkoittaa, että koko numero on rekisterissä yhden kellojakson ajan.

Voit esimerkiksi merkitä muistiin modin 5 arvon, jota kukin bittiä edustaa, lisätä ne yhteen ja toistaa prosessia, kunnes sinulle jää alle 5. Joko toteuta tämä yhdistelmällisesti kaikille pienennusvaiheita tai käytä logiikkaa uudelleen muutamille pienille jaksoille.

Mutta jos käytät VHDL rem -operaattoria, se voi olla vain oikea vastaus. Olettaen, että yrityksellä on kunnolliset synteesityökalut, se antaisi sinulle melko tehokkaan toteutuksen - hieman enemmän aluetta kuin ehkä valtion-koneen ratkaisut, mutta täysi läpijuoksu ja siten todennäköisesti hyvä energia laskentaa kohti. Se on vaihtoehto, jonka toteuttaminen maksaisi vähiten aikaa ja siten työnantajalle todennäköisesti vähiten rahaa!

Ollakseni oikeudenmukainen, se ei todennäköisesti ole vastausta, jota he etsivät tällaisella kysymyksellä - mutta se on myös tilaisuus esitellä todellista suunnittelukokemusta.

Jos luku esitetään paloina, jotka ovat suurempia kuin yksi bitti, voi olla hyödyllistä käyttää joitain rinnakkaisia ​​laskutoimituksia jäännösmoodin 15 laskemiseksi edellyttäen, että laskennasta saadaan 15 tarkalleen, jos jäännös on nolla. Yksinkertainen tapa laskea mod-15-tähde on havaita, että minkä tahansa arvon N> = 1 osalta, vasemmanpuoleisimpien 4N-bittien lisääminen numeron osaan, joka ylittää arvon, antaa arvon, joka on yhdenmukainen alkuperäisen modin 15 kanssa. mahdollistaa ongelman jakamisen monin eri tavoin käytettävissä olevien resurssien mukaan.

Jos esimerkiksi arvo alkaa 32-bittisellä arvolla, sitä voidaan pitää kahdeksana 4-bittisenä arvona. Ne voidaan yhdistää pareittain, jolloin saadaan neljä 5-bittistä arvoa, jotka puolestaan ​​voidaan yhdistää kahdeksi 6-bittiseksi tai yhdeksi 7-bittiseksi arvoksi. Lisäämällä tuon 7-bittisen arvon kolme ylempää bittiä alempiin 4-bitteihin saadaan 5-bittinen arvo, joka on enintään 21. Täten voidaan määrittää, onko alkuperäinen arvo 5: n kerrannaisena tarkkailemalla onko lopullinen arvo yksi 0, 5, 10, 15 tai 20.

En muista VHDL: ääni, mutta tässä on luonnos ideasta, joka mieleeni tuli ensin:

Kahden ensimmäisen voiman viimeiset numerot (pohjassa 10) ovat 1, 2, 4, 8, 6, 2, ... ja jakso toistuu.Näin ollen kahden potenssin loput mod 5 ovat 1, 2, 4, 3, ....

Tätä käyttämällä voimme siirtyä bitteinä LSB: stä ja kerätä loput mod 5, joka vastaa sijaintia, kun 1 -bitti näkyy.Tee myös kertymismoduuli 5, ja riittää tarkistaa, onko summa lopussa nolla.

Voimme käyttää ajatusta tästä vastauksesta, että perustasta 4 voimme johtaa, että luku on jaollinen 5: llä vain, jos vaihteleva numero on. Siksi

1. ryhmittele numerot 2 2: lla
2. summa pariton ja vähennä parilliset 2-bittiset lohkot.
3. Jos tulos on muutaman bitin kahdella komplementtialueella, esimerkiksi [-4,3] (helppo tarkistaa olettaen, että käytämme kahta komplementtia), olemme valmiit ja voimme jakaa alkuperäisen luvun 5: llä vain, jos summauksen tulos on 0, joka on hyvin yksinkertainen looginen lauseke tarkistettavaksi (pohjimmiltaan vain iso eikä kaikilla tuloksena olevilla biteillä, ei?)
4. muuten toistamme uuden (paljon lyhyempi luku).

Kokeile numeroa 166 = (10) (10) (01) (10): 2,2,1,2

2-2 + 1-2 = -1

mikä on < = 3 absoluuttisessa arvossa eikä 0 miksi voimme päätellä yhdellä iteraatiolla, että 166 ei ole jaettu tasaisesti viidellä.

Voi olla, että pieni muisti voi olla halvempi / parempi nopeuden / porttien lukumäärän suhteen kuin iterointi. Voidaan tietysti laskea pahin (suurin mahdollinen tulos sallittujen syötteiden perusteella) ja suunnitella suunnittelu vastaavasti.

MSB-lähestymistapa on ehdottomasti helpompaa, mutta onnistuin tekemään LSB-tilakaavion tarvitsematta luoda MSB-ratkaisua ... se kesti vain pari tuntia. Se osoittautuu vastaavaksi @ComFreek: n osoittamaan, vain huomautettu toisin.

Seuraamme kahta numeroa. Ensin aiomme seurata juoksevaa summaa, modulo 5 ("SUM"). Toiseksi seuraamme seuraavan siirrettävän 2 tehon, modulo 5: n ("SEURAAVA") arvoa. Esitän jokaisen tilan, jonka yläosassa on summan mahdolliset arvot ja niiden alapuolella vastaavat NEXT-arvot.

Aloitetaan tapauksesta, jossa "SUM" modulo 5 on 0:

Huomaa, että tila näyttää tältä:
3,2,4,1
1,4,3,2

vastaa:
1,3,4,2
2,1,3,4

Koska molemmat osavaltiot edustavat sitä:
SUM = 1 ja SEURAAVA = 4 TAI
SUM = 2 ja SEURAAVA = 3 TAI
SUM = 3 ja SEURAAVA = 2 TAI
SUM = 4 ja SEURAAVA = 1.

Okei, joten meidän on nyt kehitettävä ylimääräisiä tiloja, koska useimpiin haastattelijoihin ei tule vaikuttamaan tilakaavio, jossa on vain yksi tila. Olemme valmiit, kun jokaisella valtiolla on kaksi siirtymää.

Aina kun siirryt uuteen tilaan, jokainen NEXT-numero kaksinkertaistuu ja sitten modulo'd 5. Noudata SUM-arvoa varten näitä sääntöjä:

• Jos siirtyit pitkin 0, ylärivi säilyttää arvonsa.
• Jos olet siirtynyt pitkin 1, kukin sarake on vanhan tilan "SUM" + "NEXT" moduuli 5.

Aloitetaan siis täyttämällä siirtymät, kun saapuva bitti on 1.

No, nyt täytämme nollat. Siihen on lisätty vain yksi tila, joten jatkamme myös sen siirtymiä.

Ja voila! Meillä on tilakone, joka hyväksyy ensin LSB: n tarvitsematta luoda MSB-ratkaisua.

Kaikki yllä olevat vaikuttavat niin monimutkaisilta! On helppo matemaattinen tapa havaita, onko binaarinen kokonaisluku jaettavissa viidellä. Ensinnäkin, muistatko, kuinka "yhdeksän heittäminen" tapahtuu tavallisessa desimaalilaskutoimituksessa? Desimaalisen kokonaisluvun jäännösmoduuli 9 on sama kuin jäännösmodulo 9 sen numeroiden summasta. Tämä toimii, koska 9 on yksi pienempi kuin numeropohja.

Vastaava prosessi on "yksitoista karkottaminen", jossa vaihtoehtoisten numeroiden merkit asetetaan negatiivisiksi. Tämä toimii, koska yksitoista on yksi suurempi kuin numeropohja.

Joten jos haluamme "heittää pois viisi", saatamme edustaa kokonaislukua numeropohjassa neljä. Aloitetaan sitten alimmasta numeroparista alkuperäisenä summana ja vähennetään se seuraavasta numeroparista saadaksesi seuraavan summan. Kun olemme käyneet läpi ehdokaslukumme tällä tavalla, lopullinen summa on nolla tai jaollinen 5: llä, jos alkuperäinen kokonaislukumme on jaettavissa 5: llä.

Esimerkki 70: 01 00 01 10 -> 01 00-1 -> 01 01 -> 00, jaettavissa 5: llä Esimerkki 49: 11 00 01 -> 11-1 -> 1 00 -> 1, EI jaettavissa 5: llä

Huomaa, että sinulla on oltava ylimääräiset bitit kertyneen eron merkkinä ja tapauksissa, joissa on kantoa.

Toinen tapa edetä on yksinkertaisesti lisätä heksadesimaalit, jotta saadaan jäännösmoduuli 15. Tietysti tarvitset viimeisen logiikkavaiheen kolmen hyväksyttävän tuloksen nollan, viiden ja kymmenen tunnistamiseksi.

Esimerkki 70: 4 6 -> A, joten 70 on jaollinen 5: llä (mutta ei 15: llä) Esimerkki 49: 3 1 -> 4, joten 70 EI ole jaettavissa 5: llä.

Huomaa, että voit käyttää erilaisia ​​numeropohjia rakentaaksesi paljon jakokokeita, vaikka tietokonelogiikassa 2 +/- 1 -voimakkuudet ovat helpoimmin toteutettavissa.

Desimaaliaritmeettisesti yksi suosikeistani on testini jäännökselle mod 7. Huomaa, että 100 on kaksi suurempi kuin 7: n moninkertainen, joten ryhmitä numerot pareiksi (toimi numeropohjassa 100) ja lisää sadat KAKSI yksiköt. Täällä työskentelemme vasemmalta oikealle ...

Esimerkki: 98 76 -> 2 72 -> 76, joten 9876 ei ole jaollinen 7: llä. Se on 6 mod 7. Esimerkki: 03 45 67 -> 51 67 -> 1 69 -> 71, joten se on 1 mod 7.

Ota tietysti binäärisenä vain oktaalinumeroiden summa (3 bitin ryhmät).

Anteeksi, toivon, että olisin Verilog-guru, mutta aritmeettinen on kaikki mitä voin tarjota tässä elämänvaiheessa.Katso Ron Doerflerin "Dead Reckoning" monista tällaisista temppuista.

VHDL-haastattelukysymyksen pitäisi johtaa VHDL-koodiin.

Minulla oli tilaisuus löytää ghdl llvm -taustavirhe Dave Tweedin tilasiirtotaulukon toteutuksella, jossa ghdlin kirjoittaja tislasi toteutuksen funktiossa 17 riviin:

  -tyyppi on (r0, r1, r2, r3, r4); - loput arvot

    funktio mod5 (osinko: bit_vektori) palauttaa loogisen arvon
        type stay_array on matriisin (NBITS alas 0) jäännöksiä;
        tyypin haara on jäännösten taulukko (jäännökset, bitti);
        vakio br_table: haara: = (r0 = > ('0' = > r0, '1' = > r1),
                                        r1 = > ('0' = > r2, '1' = > r3),
                                        r2 = > ('0' = > r4, '1' = > r0),
                                        r3 = > ('0' = > r1, '1' = > r2),
                                        r4 = > ('0' = > r3, '1' = > r4)
                                      );
        muuttujan loppuosa: jäljellä: = r0;
        muuttuja tbit: bit_vector (NBITS - 1 alas 0): = osinko;
    alkaa
        i: lle osingon pituudessa - 1 alaspäin 0 silmukkaan
            jäännös: = br_table (loppu, tbit (i));
        loppusilmukka;
        paluu jäännös = r0;
lopputoiminto;
 

Liittyvä testitapaus on melko pieni, mikä helpottaa virheenkorjausta ja käyttää VHDL: n kanssa yhteensopivia tilanimiä luetelluissa tyypeissä:

(luotu Dia: llä)

Ajatuksena on, että toiminto (tai jopa esimerkki 27 rivin VHDL-ohjelmasta) on riittävän lyhyt VHDL-vastauksen kirjoittamiseksi haastattelun aikana. Ei tarvitse huolehtia haastattelukysymyksen pilaamisesta, joka vaatii sekä tiedon että taitojen osoittamista, haastateltavan odotetaan puolustavan toteutusta, kun hänet kysytään.

(Llvm-taustavirhe on korjattu aiemmin 1f5df6e -sovelluksessa.)

Yksi huomioitavista asioista on tilansiirtotaulukko, joka kertoo meille myös, missä osamääräbitti olisi '1', joka näkyy siirtymällä tilaan, jolla on pienempi jäännösarvo (tai molemmat siirtymät ryhmälle r4), kun vähennetään 5 osinko. Se voidaan koodata erilliseen taulukkoon (tai tietuetyyppiseen taulukkoon, joka näyttää hankalalta). Teemme tämän historiallisesti grafiikkalaitteissa, jotka käsittelevät 5 pikselin kerrannaisia ​​vaakanäyttöresoluutioita

Näin saat div / mod5: n, joka tuottaa osamäärän ja loput:

  kirjasto ieee;
käytä ieee.std_logic_1164.all;

kokonaisuus divmod5 on
    yleinen (
        Huom: luonnollinen: = 13
    );
    satama (
        clk: in std_logic;
        osinko: std_logic_vectorissa (NBITS - 1 alas 0);
        kuormitus: in std_logic;
        osamäärä: out std_logic_vector (NBITS - 3 alas 0);
        loppuosa: out std_logic_vector (2 alas 0);
        remzero: out std_logic
    );
loppuyksikkö;

divmod5-arkkitehtuurin foo on
    tyypin jäännökset ovat (r0, r1, r2, r3, r4); - loput arvot
    type stay_array on matriisin (NBITS alas 0) jäännöksiä;
    signaalin jäännös: pysy_kuvaaja: = (muut = > r0);
    signaalin dividendreg: std_logic_vector (NBITS - 1 alas 0);
    signaalin lainausmerkki: std_logic_vector (NBITS - 3 alas 0);
alkaa

rinnakkain:
    i: lle NBITS: ssä - 1 alas 0: n generointiin
        tyypin haara on jäännösten taulukko (jäännökset, bitti);
        - Dave Tweedsin tilan siirtymätaulukko:
        vakio br_table: haara: = (r0 = > ('0' = > r0, '1' = > r1),
                                        r1 = > ('0' = > r2, '1' = > r3),
                                        r2 = > ('0' = > r4, '1' = > r0),
                                        r3 = > ('0' = > r1, '1' = > r2),
                                        r4 = > ('0' = > r3, '1' = > r4)
                                      );
tyyppi qt on taulukon (jäännökset, bitti) std_ulogic;
    - Luo osamääräbittejä Dave Tweedsin tilakoneesta q_taulukon avulla.
    - '1', kun loppuosa menee alempaan jäännökseen tai molemmille haaroille
    - r4: stä. "0" kaikille muille haaroille.

        vakio q_taulukko: qt: = (r0 = > (muut = > '0'),
                                        r1 = > (muut = > '0'),
                                        r2 = > ('0' = > '0', '1' = > '1'),
                                        r3 = > (muut = > '1'),
                                        r4 = > (muut = > '1')
                                      );
        signaalin tbit: bitti;
    alkaa
        tbit < = to_bit (dividendreg (i));
        remaindr (i) < = br_taulukko (remaindr (i + 1), tbit);
do_quotient:
        jos minä < quot'pituuden generoida
            quot (i) < = q_taulukko (loppuindr (i + 1), tbit);
        loppu generoida;
    loppu generoida;

dividend_reg:
    prosessi (clk)
    alkaa
        jos nouseva_reuna (clk) sitten
            jos kuorma = '1' sitten
                dividendreg < = osinko;
            loppu Jos;
        loppu Jos;
    lopeta prosessi;

quotient_reg:
    prosessi (clk)
    alkaa
        jos nouseva_reuna (clk) sitten
            osamäärä < = quot;
        loppu Jos;
    lopeta prosessi;

loput:
    prosessi (clk)
    alkaa
        jos nouseva_reuna (clk) sitten
            remzero < = '0';
            tapaus jäännös (0) on
                kun r0 = >
                    loppuosa < = "000";
                    remzero < = '1';
                kun r1 = >
                    loppuosa < = "001";
                kun r2 = >
                    loppuosa < = "010";
                kun r3 = >
                    loppuosa < = "011";
                kun r4 = >
loppuosa < = "100";
            lopputapaus;
        loppu Jos;
    lopeta prosessi;

loppuarkkitehtuuri;

kirjasto ieee;
käytä ieee.std_logic_1164.all;
käytä ieee.numeric_std.all;

kokonaisuus divmod5_tb on
loppuyksikkö;

divmod5_tb-arkkitehtuurin foo on
    vakio NBITS: kokonaislukualue 0-13: = 8;
    signaali clk: std_logic: = '0';
    signaaliosinko: std_logic_vector (NBITS - 1 alas 0);
    signaalin kuormitus: std_logic: = '0';

    signaalin osamäärä: std_logic_vector (NBITS - 3 alas 0);
    signaalin loppuosa: std_logic_vector (2 alas 0);
    signaalin remzero: std_logic;
    signaaliesimerkki: std_ulogic;
    signaalinäyte: std_ulogic;
    signaali tehty: looginen;
alkaa
DUT:
    kokonaisuus work.divmod5
        yleinen kartta (NBITS)
        satamakartta (
            clk = > clk,
            osinko = > osinko,
            kuorma = > kuorma,
            osamäärä = >-osamäärä,
            jäännös = > jäännös,
            remzero = > remzero
        );
KELLO:
    käsitellä asiaa
    alkaa
        odota 5 ns;
        clk < = ei clk;
        jos valmis, viivästynyt (30 ns) sitten
            odota;
        loppu Jos;
    lopeta prosessi;
ÄLKÖ:
    käsitellä asiaa
    alkaa
        i: lle 0 - 2 ** NBITS - 1 silmukka
            odota 10 ns;
            osinko < = std_logic_vector (allekirjoittamaton (i, NBITS));
            odota 10 ns;
            kuormitus < = '1';
            odota 10 ns;
            kuorma < = '0';
        loppusilmukka;
        odota 15 ns;
        tehty < = tosi;
        odota;
    lopeta prosessi;

NÄYTTEENOTTO:
    prosessi (clk)
    alkaa
        jos nouseva_reuna (clk) sitten
            psample < = kuorma;
            näyte < = psample 4 ns jälkeen;
        loppu Jos;
    lopeta prosessi;

MONITORI:
    prosessi (näyte)
        muuttuja i: kokonaisluku;
        muuttuja div5: kokonaisluku;
        muuttuja rem5: kokonaisluku;
    alkaa
        jos nouseva_reuna (näyte) sitten
            i: = kokonaisluku (allekirjoittamaton (osinko));
div5: = i / 5;
            väitä div5 = allekirjoittamaton (osamäärä)
                raportti LF & HT &
                    "i =" & kokonaisluku "kuva (i) &
                    "div 5 odotettavissa" & kokonaisluku -kuva (div5) &
                    "got" & kokonaislukukuva (to_integer (allekirjoittamaton (osamäärä)))
                VAKAVUUSVIRHE;
            rem5: = i mod 5;
            väitä rem5 = allekirjoittamaton (loppu)
                raportti LF & HT &
                    "i =" & kokonaisluku "kuva (i) &
                    "Rem 5 odotettu" & kokonaisluku'kuva (rem5) &
                    "got" & kokonaislukukuva (to_integer (allekirjoittamaton (loppuosa)))
                VAKAVUUSVIRHE;
        loppu Jos;
    lopeta prosessi;

loppuarkkitehtuuri;
 

Toteutettu tässä generointilausekkeella, sisäinen generointilauseke, joka tuottaa osioibittejä. Remaindr-taulukko tarjoaa tilansiirtojäljen:

Kaikki ilman aritmeettista operaatiota.

On myös mahdollista toteuttaa menettelyssä ilman, että kaikki rekisterit hyödyntävät parametreja tilassa mode out. Se lähestyisi haastattelun vähimmäismäärää.

Kellotettu peräkkäinen toteutus vaatii bittilaskurin ja virtauksen ohjauksen (JK-kiikku ja pari porttia).

Aika / monimutkaisuus vaihtelee osinkojen koosta riippuen, mitä sinun todennäköisesti myös puolustetaan haastattelussa.