Néhány ZH Feladat Leírása És Megoldása




Könnyebb feladatok:

  1. Adott természetes számoknak egy -1-gyel végződő sorozata. (Feltehető, hogy a -1-nek megfelelő 0FFFFh érték nem fordul elő a sorozatban.) Keressük meg a sorozatban az első M-mel osztható számot!

    Input: VEKTOR előjeltelen szavak -1-gyel terminált sorozatát tartalmazó változó; M egy pozitív, szó méretű konstans.

    Output: Ha van a sorozatban ilyen érték, akkor hívjuk meg a TALALAT eljárást, különben menjünk a @vege címkére.

    
                     mov         bx,M
                     lea         si,[VEKTOR]
         @cikl:
                     mov         ax,[si]
                     add         si,2
                     cmp         ax,-1
                     je          @vege
                     xor         dx,dx
                     div         bx
                     or          dx,dx
                     jnz         @cikl
                     call        TALALAT
         @vege:
         
  2. Egy N elemű vektor maximális elemének megkeresése és eltárolása.

    Input: VEKTOR előjeles szavak N elemű sorozatát, továbbá MAX előjeles szót tartalmazó változók. N pozitív, szó méretű konstans.

    Output: A maximális elemet tegyük a MAX változóba.

    
                     lea         si,[VEKTOR]
                     mov         ax,[si]
                     add         si,2
                     mov         [MAX],ax
                     mov         cx,N-1
                     jcxz        @vege
         @cikl:
                     mov         ax,[si]
                     add         si,2
                     cmp         ax,[MAX]
                     jle         @kisebb
                     mov         [MAX],ax
         @kisebb:
                     loop        @cikl
         @vege:
         
  3. Adott természetes számoknak egy -1-gyel végződő sorozata. (Feltehető, hogy a -1-nek megfelelő 0FFFFh érték nem fordul elő a sorozatban.) Számítsuk ki a sorozat számtani közepét!

    Input: VEKTOR előjeltelen szavak -1-gyel terminált sorozatát, továbbá KOZEP előjeltelen szót tartalmazó változók.

    Output: A számtani közepet tároljuk el a KOZEP változóban.

    
                     lea         si,[VEKTOR]
                     xor         cx,cx
                     mov         ax,cx
                     cwd
         @cikl:
                     add         ax,[si]
                     adc         dx,0
                     inc         cx
                     add         si,2
                     cmp         word ptr [si],-1
                     jne         @cikl
                     div         cx
                     mov         [KOZEP],ax
         

Nehezebb feladatok:

  1. Egy N elemű oszlopvektor és egy szintén N elemszámú sorvektor diadikus (külső) szorzatának meghatározása és eltárolása. (A diadikus szorzat definíciója a Numerikus Matematika jegyzetben található.)

    Input: OSZLOPVEKT, SORVEKT előjeles szavak vektorát, EMATRIX pedig előjeles duplaszavak mátrixát tartalmazó memóriaváltozók. N pozitív, szó méretű konstans.

    Output: A diadikus szorzatot tároljuk el az N sort és ugyanannyi oszlopot tartalmazó EMATRIX változóban. Feltehetjük, hogy EMATRIX elemei sorfolytonosan tárolódnak a memóriában.

    
                     lea         bp,[MATRIX]
                     lea         si,[OSZLOPVEKT]
                     mov         cx,N
         @kciklus:
                     lea         di,[SORVEKT]
                     mov         bx,N
         @bciklus:
                     mov         ax,[si]
                     imul        word ptr [di]
                     mov         ds:[bp],ax
                     add         bp,2
                     mov         ds:[bp],dx
                     add         bp,2
                     add         di,2
                     dec         bx
                     jnz         @bciklus
                     add         si,2
                     loop        @kciklus
         
  2. Egy N elemű vektor forgatása adott célvektorba L elemmel (nem pedig bittel!) jobbra úgy, hogy a jobbról kiforgó elemek balról ismét belépnek. (Ez gyakorlatilag az elemek permutációját jelenti.) A lépésszám a vektor hosszánál nagyobb is lehet!

    Input: VEKTOR és EVEKTOR előjeles duplaszavak vektorát tartalmazó változók. N pozitív, L nemnegatív, szó méretű konstansok.

    Output: VEKTOR L elemmel jobbra forgatott példányát tároljuk el az EVEKTOR változóban.

    
                     mov         ax,L
                     mov         bx,N
                     xor         dx,dx
                     div         bx
                     mov         di,dx
                     shl         di,2
                     add         di,offset EVEKTOR
                     lea         si,[VEKTOR]
                     mov         cx,bx
                     sub         cx,dx
         @ciklus1:
                     mov         ax,[si]
                     mov         [di],ax
                     mov         ax,[si+2]
                     mov         [di+2],ax
                     add         si,4
                     add         di,4
                     loop        @ciklus1
                     mov         cx,dx
                     lea         di,[EVEKTOR]
                     jcxz        @vege
         @ciklus2:
                     mov         ax,[si]
                     mov         [di],ax
                     mov         ax,[si+2]
                     mov         [di+2],ax
                     add         si,4
                     add         di,4
                     loop        @ciklus2
         @vege:
         
  3. Egy N sort és ugyanennyi oszlopot tartalmazó mátrix kétszeresének transzponálása egy azonos típusú célmátrixba. A művelet elvégzése közben figyelni kell a túlcsordulásra. (Túlcsordulás esetén a HIBA eljárást kell meghívni!)

    Input: MATRIX és EMATRIX előjeles duplaszavak mátrixát tartalmazó változók. N pozitív, szó méretű konstans. Feltehető, hogy MATRIX elemei sorfolytonosan helyezkednek el a memóriában.

    Output: MATRIX kétszeresének transzponáltját tároljuk el az EMATRIX változóban. Tegyük fel, hogy EMATRIX is sorfolytonosan tárolódik.

    
                     lea         si,[MATRIX]
                     lea         di,[EMATRIX]
                     mov         cx,N
         @kciklus:
                     push        di
                     mov         bx,N
         @bciklus:
                     mov         ax,[si]
                     mov         dx,[si+2]
                     add         ax,ax
                     adc         dx,dx
                     jno         @nhiba
                     call        HIBA
         @nhiba:
                     mov         [di],ax
                     mov         [di+2],dx
                     add         si,4
                     add         di,N*4
                     dec         bx
                     jnz         @bciklus
                     pop         di
                     add         di,4
                     loop        @kciklus
         

Módosítva: 2003. október 22.