编写计算 N !的程序，数值 N 由键盘键入，结果在屏幕上显示。N 的范围为 0---65535。即刚好能被一个 16 位寄存器容纳。

以下是使用C语言编写的计算N!的程序：

#include <stdio.h>

int main() {
    int n, i;
    unsigned long long factorial = 1;

    printf("请输入一个正整数n：");
    scanf("%d", &n);

    if (n < 0 || n > 65535) {
        printf("输入的数值超出范围！\n");
        return 1;
    }

    for (i = 1; i <= n; i++) {
        factorial *= i;
    }

    printf("%d! = %llu\n", n, factorial);

    return 0;
}

该程序使用了一个循环结构来计算N的阶乘，同时使用了一个`unsigned long long`类型的变量来存储阶乘结果，以确保能够存储16位寄存器所能容纳的最大值。在输入的数值超出范围时，程序会输出一条错误信息。

相关问题

汇编语言编写计算 N !的程序，数值 N 由键盘键入，结果在屏幕上显示。N 的范围为 0---65535。

以下是使用汇编语言编写计算 N! 的程序：

.model small
.stack 100h

.data
msg1 db 'Enter a number:', '$'
msg2 db 'Factorial of ', 13, 10, ' is ', 13, 10, '$'
n dw ?
fact dw ?

.code
main proc
    mov ax, @data
    mov ds, ax

    ; 输出提示信息
    mov ah, 9
    lea dx, msg1
    int 21h

    ; 读取用户输入的数字
    mov ah, 1
    int 21h
    sub al, '0'
    mov bh, 10
    mov bl, al
    mov cx, 1

read_loop:
    mov ah, 1
    int 21h
    cmp al, 0dh ; 检查回车键
    je calc_fact
    sub al, '0'
    mul bx
    mov bl, al
    inc cx
    jmp read_loop

calc_fact:
    ; 计算阶乘
    mov n, cx
    mov fact, 1
fact_loop:
    cmp cx, 0
    je print_result
    mul fact
    dec cx
    jmp fact_loop

print_result:
    ; 输出结果
    mov ah, 9
    lea dx, msg2
    int 21h

    mov dl, n
    add dl, '0'
    mov ah, 2
    int 21h

    mov dl, ' '
    mov ah, 2
    int 21h

    mov ax, fact
    mov bx, 10
    call print_num

    mov ah, 4ch
    int 21h

print_num proc
    ; 将 AX 中的数字转换为字符串并输出
    push ax
    push bx
    push cx

    mov cx, 0
    mov bx, 10

num_loop:
    xor dx, dx
    div bx
    push dx
    inc cx
    test ax, ax
    jnz num_loop

print_loop:
    pop dx
    add dl, '0'
    mov ah, 2
    int 21h
    loop print_loop

    pop cx
    pop bx
    pop ax

    ret
print_num endp

main endp
end main

程序流程：

1. 输出提示信息，要求用户输入一个数字。
2. 读取用户输入的数字，并将其转换为十进制数保存在 BX 寄存器中。
3. 循环读取用户输入的数字，将它们相乘，保存在 BL 寄存器中。
4. 当用户输入回车键时，计算 BL 的阶乘，保存在 AX 寄存器中。
5. 将结果输出到屏幕上。

该程序使用了基本的输入输出函数，以及乘法和循环指令。值得注意的是，由于阶乘的结果可能非常大，这个程序使用了十进制数转换函数 `print_num` 将结果转换为字符串并输出。

编写计算 N !的程序，数值 N 由键盘键入，结果在屏幕上显示。N 的范围为 0---65535。要求使用汇编语言8086

以下是使用汇编语言8086计算N!的程序：

DATA SEGMENT
    NUM DW 1 ; 存储 N 的值
    FACT DW 1 ; 存储 N! 的值
DATA ENDS

CODE SEGMENT
ASSUME CS:CODE, DS:DATA

START:
MOV AX, DATA ; 初始化数据段寄存器
MOV DS, AX 

MOV AH, 01H ; 获取 N 的值
INT 21H 
SUB AL, 30H ; 将 ASCII 码转换为数字
MOV BL, AL 

CALL FACTORIAL ; 计算 N! 的值

MOV AH, 02H ; 将结果输出到屏幕
MOV DL, FACT
ADD DL, 30H ; 将数字转换为 ASCII 码
INT 21H 

MOV AH, 4CH ; 程序结束
INT 21H 

FACTORIAL PROC
    MOV AX, 1 ; 初始化 AX 为 1
    MOV CX, NUM ; 将 N 的值保存在 CX 中

    LOOP_START:
    MUL CX ; AX = AX * CX
    DEC CX ; CX = CX - 1
    JNZ LOOP_START ; 如果 CX 不等于 0，继续循环

    MOV FACT, AX ; 将 AX 中的值保存到 FACT 中
    RET 
FACTORIAL ENDP

CODE ENDS
END START

解释：

该程序使用了一个变量 `NUM` 来存储输入的值 N，使用了另一个变量 `FACT` 来存储计算出的 N! 的值。

程序通过调用 `FACTORIAL` 过程来计算 N! 的值。该过程使用了寄存器 AX 和 CX，其中 AX 用来保存 N! 的值，CX 用来保存 N 的值。

在 `LOOP_START` 标签处，程序使用 `MUL` 指令将 AX 的值乘以 CX 的值，然后使用 `DEC` 指令将 CX 的值减 1。程序然后使用 `JNZ` 指令来测试 CX 是否为 0，如果不是，则跳转回 `LOOP_START` 标签处继续循环，直到 CX 等于 0。

最后，程序将计算出的 N! 的值输出到屏幕上。