Un resolveur suduko avec assembleur nasm

Soyez le premier à donner votre avis sur cette source.

Vue 7 971 fois - Téléchargée 457 fois

Description

Un resolveur suduko avec assembleur NASM

il y a dans la source une fonction iteratif et une autre recursif

aussi les tests de saisie en rempliant la grille

Source / Exemple :

bits 16
org 0x0100
section .data


ph db 'Taper ENTER ou ESC pour Voir solution $'
ph1 db 'Mountassir Youssef 2IIR3 EMSI','$'
ph3 db 'msavyo1@hotmail.com','$'
ph2 db 'Pas de solution$'
section .bss

yy resb  1
cd resb  81
x resb  81
xx resb 81
sol resb 1
nbr resw 1

good resb 1





[section .text]
mov ax,3
int 10h
mov ax,1112h
mov bl,30h
int 10h
mov ah,1
mov ch,8
mov cl,12
int 10h



;****MOUNTASSIR ---YOUSSEF------2IIR3********


call cadre1
call cadre2
call cadre3
call col
call souris

;**********affichage phrase**************************
mov dl,40
mov dh,10
call gotoxy
mov bx,ph
call puts

mov dl,40
mov dh,13
call gotoxy
mov bx,ph1
call puts

mov dl,40
mov dh,15
call gotoxy
mov bx,ph3
call puts
;**********FIN affichage phrase*************************

mov cx,81

initial:

here:mov bx,cx
mov byte [(bx+cd)-1],'0'
loop here



mov dl,1
mov dh,1
call gotoxy2


click :






                  call getch

                  cmp al,13
                  jnz z1

                  mov al,27


                  z1 :cmp al,27



                  jnz z2

                  call backo

                  mov [nbr],bp
                  mov byte [xx+bp],255

                  call posa
                  call tri


                  mov bp,-1





       


                 ;call solurecursif
                 call soluiteratif
                 cmp byte [good],1
                 jz  afi
                 mov al,7
                 call putchar
                 mov bx,ph2
                   call clrscr
                 call puts
                 call getch


                 jmp outaa


                 afi
                call afff







                 outaa :



                  call outa


                  z2 :cmp al,0

                  jnz koko
                  call direc
                 jmp click
                 koko



                  cmp al,8

                  jnz too
                  mov al,0
                  call dakhal
                  mov al,0

                    call putchar
                    call gotoxy2
                    jmp click


                 too:
                 cmp al,'1'

                  jl click

                  cmp al,'9'

                  jg click

                  ;******************************test col reg lig*******************
                  call tst

                 cmp  byte [sol],0
                 jz click

                 ;**************************************
                 call dakhal




                   call putchar
                  call gotoxy2



                  jmp click








;************************VERIFICATION DU LIMITES DE CURSEUR****************
tet:
cmp dh,0
JG aca
mov dh,9
jmp ddd
aca:
cmp dh,10
jl bbb
mov dh,1
jmp ddd

bbb:
cmp dl,0
jg ccc
mov dl,9
jmp ddd

ccc:
cmp dl,10
jl ddd
mov dl,1

ddd:
call gotoxy2
ret
;*****************FONCTION AFFICHAGE PHRASE************************************
puts:
mov al,[bx]
cmp al,'$'
jz barap
call putchar
inc bx
jmp puts
barap :
ret
;********************************************************
call clrscr
mov dh,0
mov dl,0
call gotoxy
;*************AFFICHAGE MATRICE FINAL******************
afff:
mov dh,-1
mov dl,0
call gotoxy
mov cx, 9
mov bp,0
matr:
add dh,4
mov dl,3
call nl
mov bx,0
la:
mov al,[cd+bp]
call gotoxy
add dl,4
call putchar
inc bp
inc bx
cmp bx,9
jnz la
loop matr
call getch
ret
;***************************************
outa
mov     ax, $4C00
int       $21
ret
;**********************************
direc
call getch
                 cmp al,77
                   jnz aa
                   add dl,1
                   jmp dir1e
aa:
         cmp al,75
         jnz bb
         add dl,-1
         jmp dir1e
bb:
         cmp al,80
         jnz cc
         add dh,1
         jmp dir1e
cc:
         cmp al,72
         jnz dir1e
            add dh,-1

dir1e:
call tet
ret
;**********************************
testligne:
push dx

                  mov dl,1
                  ligne :
                  call adrbx
                  cmp  [cd+bx],al
                  jnz ti1
                  mov byte [sol],0
                  ti1
                  inc dl
                  cmp dl,10
                  jnz ligne
                  pop dx
                  ret
;***********************************
testcol:
 push dx

                  mov dh,1
                  colonnes :
                  call adrbx
                  cmp  [cd+bx],al
                  jnz ti2
                  mov byte [sol],0
                  ti2
                  inc dh
                  cmp dh,10
                  jnz  colonnes
                  pop dx
                  ret
;**********************************

;*******************************
testreg:


                 push dx
                 push ax
                 mov ah,0
                 mov bh,3

                 mov al,dl
                 sub al,1
                 div  bh
                 mul bh
                 mov dl,al
                 add dl,1

                 mov al,dh
                 sub al,1
                 div bh
                 mul bh
                 mov dh,al
                 add dh,1
                 pop ax
                 mov [yy],dl



                 mov  bp,3
                 reg:

                 mov dl,[yy]
                 mov cx,3
                 sreg
                 call adrbx
                 cmp  [cd+bx],al
                 jnz ti3
                  mov byte [sol],0
                  ti3

                 inc dl

                 loop sreg

                 inc dh
                 dec bp
                  jnz reg

                   pop dx
ret
;*********************************

backo:
mov bx,0
mov bp,0
lp

cmp byte [cd+bx],'0'
jnz lpi

mov byte[xx+bp],0
mov [x+bp],bl


inc bp
lpi:
inc bx
cmp bx,81
jnz lp


ret

;*******************************
posa
mov cx,[nbr]

mov bh,0
.ici
mov ax,cx
mov bp,cx
sub bp,1
mov bl,[x+bp]
call calcino

call pos
mov cx,ax

loop .ici
ret
;**************************************
pos
push ax
mov cx,9
.ici
mov al,cl
add al,48
call tst
cmp byte[ sol],0
jz .a
inc byte [xx+bp]
.a
loop .ici
pop ax
ret

;********************************
tri
.deb
mov cx,[nbr]
sub cx,1
.ici
mov bp,cx

mov al,[xx+bp-1]
mov ah,[xx+bp]
cmp al,ah
jng .a

mov [xx+bp-1],ah
mov [xx+bp],al
mov al,[x+bp-1]
mov ah,[x+bp]
mov [x+bp-1],ah
mov [x+bp],al

mov cx,[nbr]
.a

loop .ici

ret
;*****************************************
solurecursive :
inc bp
cmp bp,[nbr]
jnz .a
mov byte[good],1
ret
.a
mov bh,0
mov bl,[x+bp]

call calcino
mov al,'1'


.j


call tst

cmp byte [sol],0
jz .h

mov byte [cd+bx],al
push ax
push bx
push dx
push bp

mov byte[good],1
call solurecursive

pop bp
pop dx
pop bx
pop ax



cmp byte [good],1
jz .br

.h
inc al
cmp al,'9'+1
jnz .j

mov byte [cd+bx],'0'
mov byte [good],0

.br
ret


;********************************



calcino
push ax
push bx
mov dx,0

mov ax,bx
mov bx,9

div bl

mov  dl,ah
mov dh,al
inc dl
inc dh





pop bx
pop ax
ret



;********************************************************
tst
pusha
mov byte [sol],1
call testligne
call testcol
call testreg
popa
ret
;********************************************************

soluiteratif :
mov bp,0
.a
mov bh,0
mov bl,[x+bp]
call calcino
mov al,[cd+bx]
.b
inc al
cmp al,'9'+1
jz .br
call tst
cmp byte[sol],0
jz .b
mov [cd+bx],al
inc bp
cmp bp,[nbr]
jnz .r
mov byte [good],1
ret
.r
 jmp .a
.br
mov byte[cd+bx],'0'
dec bp
cmp bp,-1
jnz .a
mov byte [good],0
ret



;***********************************************************************

SEGMENT .text

t80x50:  mov  ax,03
         int  10h
         mov  ax,1112h
         mov  bl,30h
         int  10h
         ret

clrscr:  pusha
         mov  ax,0B800h
         mov  es,ax
         cld
         mov  di,0
         mov  cx,4000
         mov al,' '
         mov ah,0fh     ;jaune/bleu
         rep  stosw
         popa
         ret
;**********************************************
putaxd: ;affiche AX en decimal (non sign?)
         pusha
         mov  cx,0      ; compteur
         mov  bx,10     ; base 10
divech:  mov  dx,0      ; pour la division
         div  bx        ; division en echelle par 10
         push dx        ; empiler le reste
         inc  cx        ; compter les chiffres
         cmp  ax,0      ; si pas fini, recommencer
         jne  divech
affich:  pop  ax        ; le chiffre a afficher se trouve dans AL
         add  ah,0Eh    ; AH=0E pour affichage, AL = code ascii de AL
         add  al,48
         int  10h       ; affichage
         loop affich    ; recommencer jusqu'a la fin
         popa
         ret

;***********************************

         



;***************************************************************
putchar:  ; affiche le caract?re contenu dans AL
         push ax
     
   
         mov  ah,0eh
         int  10h

         pop  ax
         ret




;*********************************************************

;AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
getch:

mov  ah,07 

int  21h

ret
;AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
gotoxy :
	push ax
	push bx
	mov ah,02h
	mov bh,00
	int 10h
	pop bx
	pop ax
	ret
;AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
gotoxy2 :
	push ax
	push bx
        push dx
        mov al,4
        mul dh
        mov dh,al
        sub dh,1

        mov al,4
        mul dl
        mov dl,al
        sub dl,1

	mov ah,02h
	mov bh,00
	int 10h
        pop dx 
	pop bx
	pop ax
	ret
;************************************************************

;******************************************************************
adrbx:
push ax
                  mov bl,dh
                  mov bh,0
                  mov al,9
                  mov ah,0
                  sub bl,1
                  
                  mul bl
                  mov bl,al
                  
                  
                  
                  mov al,dl
                  sub al,1
                  
                 
                  add bl,al
                  
                  
                  pop ax

                  

               
ret

;******************************************************************
souris:
mov ax,0
int 0x33
mov ax,1
int 0x33
ret
;*********************************************************** 
cadre2:
mov al,179
mov dl,1
bi:
add dl,4
mov cx,35
mov dh,1
ba:
inc dh
call gotoxy
call putchar
loop ba
cmp dl,32
jb bi
ret
;*****************************************************************
cadre3:
mov al,196
mov dh,1
bii:
add dh,4
mov cx,35
mov dl,1
baa:
inc dl
call gotoxy
call putchar
loop baa
cmp dh,32
jb bii
ret
;********************************************************************
col:
mov dh,13
mov dl,2
call gotoxy
mov cx,35
mov bh,0
mov al,196
mov ah,09
mov bl,5
int 10h
add dh,12
call gotoxy
int 10h

mov dl,13

mov cx,1
mov al,179
g
mov dh,2
call gotoxy
g1:
int 10h
inc dh
call gotoxy
cmp dh,37
jnz g1
add dl,12
cmp dl,26
jl g




ret
;********************************************************************
dakhal:
  push ax
  
  sub dh,1
  sub dl,1
                  mov bl,dh
                  mov bh,0

                  mov al,9
                  mov ah,0
                  
                  
                  mul bl
                  mov bl,al
                  
                  
                  
                  mov al,dl
                  
                  
                 
                  add bl,al
                  add dh,1
                  add dl,1
                  
                  pop ax

                  cmp al,0
                  jnz fino
                  mov al,'0'

                fino: mov byte [cd+bx],al
ret

;******************************************************************
cadre1 :
mov dh,1
mov dl,1
call gotoxy
mov al,201
call putchar
;//////////////////////////////////////////////////////
mov cx,35
mov al,186
b:
inc dh
call gotoxy
call putchar
loop b
;//////////////////////////////////////////////////////
inc dh
call gotoxy
mov al,200
call putchar
;////////////////////////////////////////////
mov al,205
mov cx,35
d:
call putchar
loop d


;////////////////////////////////////////////

mov cx,35
mov dh,1
mov dl,2
call gotoxy
a:
call putchar
loop a

mov al,187
call putchar
;////////////////////////////////////////////
mov dh,1
mov dl,37
mov cx,35
mov al,186
c:inc dh
call gotoxy
call putchar
loop c
inc dh
mov al,188
call gotoxy
call putchar

ret

;**************************************************************
nl:       ; retour ? la ligne
         push ax
	 mov ax,0E0Ah  ; retour a la ligne
         int 10h
         mov al,13
         int 10h
	 pop ax
         ret

Conclusion :

juste une autre resolveur mais cette fois avec langage machine

Codes Sources

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.