Un resolveur suduko avec assembleur nasm
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
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
retConclusion :
juste une autre resolveur mais cette fois avec langage machineCodes Sources
A voir également
- Un resolveur suduko avec assembleur nasm
- Resolveur motus - Forum IRC
- Jeu motus - Forum C
- Motus en C - Forum C
- JEU DE MOTUS - Forum C
- Resolveur de lettres ✓ - Forum C / C++ / C++.NET
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.