variació nostrum

està a to: el negat y el afirmat tenen la mateisha estructura.


frase:
( [12+06]+[12+05]+[12+03]+[10] )=60
( [12+05]+[12+03]+[12+01]+[10] )=55
( [12+03]+[12+01]+[12]+[08] )=48
( [12+01]+[12]+[10]+[05] )=40


frase negada:
( [12+12]+[12+11]+[12+09]+[12+04] )=84
( [12+11]+[12+09]+[12+07]+[12+04] )=79
( [12+09]+[12+07]+[12+06]+[12+02] )=72
( [12+07]+[12+06]+[12+04]+[11] )=64


60=30·2=5·6·2
84=42·2=7·6·2
84+(-60) =[12]= 0


55=5·10+5
79=5·10+29
79+(-55) =[24]= 0


48=6·8=2·3·8
72=9·8=3·3·8
72+(-48) =[24]= 0


40=5·7+5
64=5·7+29
64+(-40) =[24]= 0

funció scan-tecla en assembler

int scan-tecla-positiu()
{
xor ax,ax
int 0010 0001
mov bx,y
mov [bx],ax
ret y
}


int scan-tecla-positiu()
{
sis ax,ax
int not(0010 0001)
mov bx,y
mov [bx],ax
ret y
}


def-int
{
int 0010 0001 : mov ax,[caracter] si pulses caracter
int not(0010 0001) : mov ax,[not(caracter)] si pulses caracter
}


def-int
{
{
int 0010 0001 : mov ax,[right-arrow]
int not(0010 0001) : mov ax,[left-arrow]
}
{
int 0010 0001 : mov ax,[left-arrow]
int not(0010 0001) : mov ax,[right-arrow]
}
}


def-int
{
{
int 0010 0001 : mov ax,[up-arrow]
int not(0010 0001) : mov ax,[dawn-arrow]
}
{
int 0010 0001 : mov ax,[dawn-arrow]
int not(0010 0001) : mov ax,[up-arrow]
}
}

funció hbhit en assembler

int kbhit-positiu()
{
xor ax,ax
int 0010 0000
mov bx,y
mov [bx],ax
ret y
}


int kbhit-negatiu()
{
sis ax,ax
int not(0010 0000)
mov bx,y
mov [bx],ax
ret y
}




def-int
{
int 0010 0000 : inc ax si pulses una tecla
int not(0010 0001) : dec ax si pulses una tecla
}

el dual-tetris

si kbhit-positiu()==1 ==>
{
si ( n==1 & scan-tecla-positiu()==2 ) ==>
{
matriu-x[(grafic-max-x+grafic-min-x)·(i+(-1))][(grafic-min-y+grafic-max-y)·j]=0;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·j]=0;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·(j+1)]=0;


matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·(j+1)]=1;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·j]=1;
matriu-x[(grafic-max-x+grafic-min-x)·(i+1)][(grafic-min-y+grafic-max-y)·j]=1;
n=(-1);
}
}
si kbhit-negatiu()==(-1) ==>
{
si ( n==(-1) & scan-tecla-negatiu()==(-2) ) ==>
{
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·(j+1)]=0;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·j]=0;
matriu-x[(grafic-max-x+grafic-min-x)·(i+1)][(grafic-min-y+grafic-max-y)·j]=0;


matriu-x[(grafic-max-x+grafic-min-x)·(i+1)][(grafic-min-y+grafic-max-y)·j]=1;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·j]=1;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·(j+(-1))]=1;
n=2;
}
}
si kbhit-positiu()==1 ==>
{
si ( n==2 & scan-tecla-positiu()==2 ) ==>
{
matriu-x[(grafic-max-x+grafic-min-x)·(i+1)][(grafic-min-y+grafic-max-y)·j]=0;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·j]=0;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·(j+(-1))]=0;


matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·(j+(-1))]=1;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·j]=1;
matriu-x[(grafic-max-x+grafic-min-x)·(i+(-1))][(grafic-min-y+grafic-max-y)·j]=1;
n=(-2);
}
}
si kbhit-negatiu()==(-1) ==>
{
si ( n==(-2) & scan-tecla-negatiu()==(-2) ) ==>
{
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·(j+(-1))]=0;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·j]=0;
matriu-x[(grafic-max-x+grafic-min-x)·(i+(-1))][(grafic-min-y+grafic-max-y)·j]=0;


matriu-x[(grafic-max-x+grafic-min-x)·(i+(-1))][(grafic-min-y+grafic-max-y)·j]=1;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·j]=1;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·(j+1)]=1;
n=1;
}
}

funció put-pixel duals en assembler

put-pixel-x( int color, int x , int y )
{
mov bx,color
mov ax,[bx]
not ax
not ax


mov bx,x
mov cx,[bx]
not cx
not cx


mov bx,y
mov dx,[bx]
not dx
not dx


int 0001 0000
}


put-pixel-y( int color, int x , int y )
{
mov bx,color
mov ax,[bx]
not ax


mov bx,x
mov cx,[bx]
not cx


mov bx,y
mov dx,[bx]
not dx


int not(0001 0000)
}


def-int
{
int 0001 0000 : posa el color ax afirmat en la tarjeta de grafica en cx,dx.
int not(0001 0000) : posa el color not(ax) negat en la tarjeta grafica en not(cx),not(dx).
}

funció put-grafic-dual-dos-d

max-x=n
min-x=(-n)
max-y=m
min-y=(-m)


estructura grafic {
int max-x;
int min-x;
int max-y;
int min-y;
int **grafic-x[i][j];
int **grafic-y[i][j];
};


put-grafic-dual-dos-d( estructura grafic *nom , int x-grafic , int y-grafic )
{
put-pixel-x( nom->grafic-x[0][0] , 0+x-grafic , 0+y-grafic );
put-pixel-x( nom->grafic-x[not(0)][not(0)] , 0+x-grafic , 0+y-grafic );


put-pixel-y( nom->grafic-y[not(0)][not(0)] , 0+x-grafic , 0+y-grafic );
put-pixel-y( nom->grafic-y[0][0] , 0+x-grafic , 0+y-grafic );


for( i=1 ; i [< nom->max-x ; i++ )
{
put-pixel-x( nom->grafic-x[i][0] , i+x-grafic , 0+y-grafic );
put-pixel-x( nom->grafic-x[i][not(0)] , i+x-grafic , 0+y-grafic );
}


for( i=(-1) ; i >] nom->min-x ; i-- )
{
put-pixel-y( nom->grafic-y[i][not(0)] , i+x-grafic , 0+y-grafic );
put-pixel-y( nom->grafic-y[i][0] , i+x-grafic , 0+y-grafic );
}


for( j=1 ; j [< nom->max-y ; j++ )
{
put-pixel-x( nom->grafic-x[0][j], 0+x-grafic , j+y-grafic );
put-pixel-x( nom->grafic-x[not(0)][j] , 0+x-grafic , j+y-grafic );
}


for( j=(-1) ; j >] nom->min-x ; j-- )
{
put-pixel-y( nom->grafic-y[not(0)][j] , 0+x-grafic , j+y-grafic );
put-pixel-y( nom->grafic-y[0][j] , 0+x-grafic , j+y-grafic );
}


for( i=1 ; i [< nom->max-x ; i++ )
{
for( j=1 ; j [< nom->max-y ; j++ )
{
put-pixel-x( nom->grafic-x[i][j] , i+x-grafic , j+y-grafic );
}
for( j=(-1) ; j >] nom->min-y ; j-- )
{
put-pixel-x( nom->grafic-x[i][j] , i+x-grafic , j+y-grafic );
}
}


for( i=(-1) ; i >] nom->min-x ; i-- )
{
for( j=(-1) ; j >] nom->min-y ; j-- )
{
put-pixel-y( nom->grafic-y[i][j] , i+x-grafic , j+y-grafic );
}
for( j=1 ; j [< nom->max-y ; j++ )
{
put-pixel-y( nom->grafic-y[i][j] , i+x-grafic , j+y-grafic );
}
}


}

funció increment y decrement

inc(<0,0>) = <0,0>[<==]<0,1> = <0,1>
dec(<(-1),(-1)>) = <0,1>[==>]<(-1),(-1)> = <(-1),0>


inc(<0,1>)= <0,1>[<==]<0,1> = <1,0>
dec(<0,1>)= <0,(-1)>[==>]<0,1> = <0,0>


inc(<(-1),0>)= <(-1),0>[<==]<0,(-1)> = <(-1),(-1)>
dec(<(-1),0>)= <0,1>[==>]<(-1),0> = <0,(-1)>