Advertisement
Guest User

Untitled

a guest
Nov 27th, 2018
172
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. INCLUDE IO.ASM
  2.  
  3. ST1 SEGMENT
  4.     DB 128 DUP(?)
  5. ST1 ENDS
  6.  
  7. DATA SEGMENT
  8.     n dw 0
  9.     n2 dw 0
  10.     i   dw 1
  11.     k   dw  0
  12.     j   dw  1
  13.     two dw  2
  14.     a   dw  100 DUP(1)
  15.     mess db "Enter n = $"
  16.     mess1 db "Enter matrix $"
  17. DATA ENDS
  18.  
  19. CODE SEGMENT
  20. ASSUME CS:CODE, DS:DATA, SS:ST1
  21. MAIN PROC
  22.     mov ax,Data
  23.     mov ds,ax
  24. ;==============
  25.     mov dx,0
  26.     LEA DX,mess
  27.         outstr
  28.     inint n
  29.     mov dx,0
  30.     mov ax,n
  31.     add n2,ax
  32.     add n2,ax
  33.     mov cx,n
  34. l1:
  35.     push cx
  36.     mov j,1
  37.     mov cx,n
  38. cj:
  39.     mov ax,i
  40.     cmp ax,j
  41.     jle l2
  42.     mov dx,0
  43.     dec ax                  ;;ниже главной j>i
  44.     mul n
  45.     add ax,j
  46.     mov dx,0
  47.     mul two
  48.     mov bx,ax
  49.     sub bx,2
  50.     mov a[bx],0
  51. l2:
  52.     inc j
  53.     loop cj
  54.     inc i
  55.     pop cx
  56.     loop l1
  57.     mov cx,n
  58.     mov bx,0
  59. output:
  60.     push cx
  61.     mov cx,n
  62.     mov si,0
  63. ots:
  64.     outint a[bx][si]
  65.     outch ' '
  66.     add si,2
  67.     loop ots
  68.     newline
  69.     add bx,n2
  70.     pop cx
  71.     loop output
  72.     mov dx,0
  73. ;==============
  74. exit:   mov ah,4ch
  75.         int 21h
  76. MAIN ENDP
  77. CODE ENDS
  78. END MAIN
  79.  
  80. ====
  81.  
  82. INCLUDE IO.ASM
  83.  
  84. ST1 SEGMENT
  85.     DB 128 DUP(?)
  86. ST1 ENDS
  87.  
  88. DATA SEGMENT
  89.     n dw 0
  90.     n2 dw 0
  91.     i   dw 1
  92.     k   dw  0
  93.     j   dw  1
  94.     two dw  2
  95.     a   dw  100 DUP(1)
  96.     mess db "Enter n = $"
  97.     mess1 db "Enter matrix $"
  98. DATA ENDS
  99.  
  100. CODE SEGMENT
  101. ASSUME CS:CODE, DS:DATA, SS:ST1
  102. MAIN PROC
  103.     mov ax,Data
  104.     mov ds,ax
  105. ;==============
  106.     mov dx,0
  107.     LEA DX,mess
  108.         outstr
  109.     inint n
  110.     mov dx,0
  111.     mov ax,n
  112.     add n2,ax
  113.     add n2,ax
  114.     mov cx,n
  115. l1:
  116.     push cx
  117.     mov j,1
  118.     mov cx,n
  119. cj:
  120.     mov ax,i
  121.     cmp ax,j
  122.     jge l2
  123.     mov dx,0
  124.     dec ax
  125.     mul n           ;;выше главной i<j
  126.     add ax,j
  127.     mov dx,0
  128.     mul two
  129.     mov bx,ax
  130.     sub bx,2
  131.     mov a[bx],0
  132. l2:
  133.     inc j
  134.     loop cj
  135.     inc i
  136.     pop cx
  137.     loop l1
  138.     mov cx,n
  139.     mov bx,0
  140. output:
  141.     push cx
  142.     mov cx,n
  143.     mov si,0
  144. ots:
  145.     outint a[bx][si]
  146.     outch ' '
  147.     add si,2
  148.     loop ots
  149.     newline
  150.     add bx,n2
  151.     pop cx
  152.     loop output
  153.     mov dx,0
  154. ;==============
  155. exit:   mov ah,4ch
  156.         int 21h
  157. MAIN ENDP
  158. CODE ENDS
  159. END MAIN
  160.  
  161.  
  162.  
  163. INCLUDE IO.ASM
  164.  
  165. ST1 SEGMENT
  166.     DB 128 DUP(?)
  167. ST1 ENDS
  168.  
  169. DATA SEGMENT
  170.     n dw 0
  171.     n2 dw 0
  172.     i   dw 1
  173.     k   dw  0
  174.     j   dw  1
  175.     two dw  2
  176.     a   dw  100 DUP(1)
  177.     mess db "Enter n = $"
  178.     mess1 db "Enter matrix $"
  179. DATA ENDS
  180.  
  181. CODE SEGMENT
  182. ASSUME CS:CODE, DS:DATA, SS:ST1
  183. MAIN PROC
  184.     mov ax,Data
  185.     mov ds,ax
  186. ;==============
  187.     mov dx,0
  188.     LEA DX,mess
  189.         outstr
  190.     inint n
  191.     mov dx,0
  192.     mov ax,n
  193.     add n2,ax
  194.     add n2,ax
  195.     mov cx,n
  196. l1:
  197.     push cx
  198.     mov j,1
  199.     mov cx,n
  200. cj:
  201.     mov ax,n
  202.     sub ax,j
  203.     inc ax
  204.     mov di,ax
  205.     mov ax,i
  206.     cmp ax,di
  207.     jle l2          ;;ниже побочной i>n-j+1
  208.     mov dx,0
  209.     dec ax
  210.     mul n
  211.     add ax,j
  212.     mov dx,0
  213.     mul two
  214.     mov bx,ax
  215.     sub bx,2
  216.     mov a[bx],0
  217. l2:
  218.     inc j
  219.     loop cj
  220.     inc i
  221.     pop cx
  222.     loop l1
  223.     mov cx,n
  224.     mov bx,0
  225. output:
  226.     push cx
  227.     mov cx,n
  228.     mov si,0
  229. ots:
  230.     outint a[bx][si]
  231.     outch ' '
  232.     add si,2
  233.     loop ots
  234.     newline
  235.     add bx,n2
  236.     pop cx
  237.     loop output
  238.     mov dx,0
  239. ;==============
  240. exit:   mov ah,4ch
  241.         int 21h
  242. MAIN ENDP
  243. CODE ENDS
  244. END MAIN
  245.  
  246. ===
  247.  
  248. INCLUDE IO.ASM
  249.  
  250. ST1 SEGMENT
  251.     DB 128 DUP(?)
  252. ST1 ENDS
  253.  
  254. DATA SEGMENT
  255.     n dw 0
  256.     n2 dw 0
  257.     i   dw 1
  258.     k   dw  0
  259.     j   dw  1
  260.     two dw  2
  261.     a   dw  100 DUP(1)
  262.     mess db "Enter n = $"
  263.     mess1 db "Enter matrix $"
  264. DATA ENDS
  265.  
  266. CODE SEGMENT
  267. ASSUME CS:CODE, DS:DATA, SS:ST1
  268. MAIN PROC
  269.     mov ax,Data
  270.     mov ds,ax
  271. ;==============
  272.     mov dx,0
  273.     LEA DX,mess
  274.         outstr
  275.     inint n
  276.     mov dx,0
  277.     mov ax,n
  278.     add n2,ax
  279.     add n2,ax
  280.     mov cx,n
  281. l1:
  282.     push cx
  283.     mov j,1
  284.     mov cx,n
  285. cj:
  286.     mov ax,n
  287.     sub ax,j
  288.     inc ax
  289.     mov di,ax
  290.     mov ax,i
  291.     cmp ax,di                   ;;выше побочной i<n-j+1
  292.     jge l2
  293.     mov dx,0
  294.     dec ax
  295.     mul n
  296.     add ax,j
  297.     mov dx,0
  298.     mul two
  299.     mov bx,ax
  300.     sub bx,2            ;;т.к. k элемент это k+1 в памяти, -1 для байт
  301.     mov a[bx],0
  302. l2:
  303.     inc j
  304.     loop cj
  305.     inc i
  306.     pop cx
  307.     loop l1
  308.     mov cx,n
  309.     mov bx,0
  310. output:
  311.     push cx
  312.     mov cx,n
  313.     mov si,0
  314. ots:
  315.     outint a[bx][si]
  316.     outch ' '
  317.     add si,2
  318.     loop ots
  319.     newline
  320.     add bx,n2
  321.     pop cx
  322.     loop output
  323.     mov dx,0
  324. ;==============
  325. exit:   mov ah,4ch
  326.         int 21h
  327. MAIN ENDP
  328. CODE ENDS
  329. END MAIN
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement