I have questions:
1) Program to get input from user till 'z' or 'Z' is inputted
the program will check for the chars, and print
(new line) small chars
(new line) big chars
(new line) numbers
[without 'z' or 'Z']
can't use variables.
only Stack.
example :
input: ASdf154sdgdf123vcvbz
Small chars: dfsdgdfvcvb
Big chars: AS
Numbers: 154123

This is code for question 1:

STA SEGMENT STACK
    DB 100H DUP (0)
STA ENDS

CODE SEGMENT
    ASSUME CS:CODE,SS:STA
MAIN:
    MOV BP, SP
    MOV BX, BP
    SUB BP, 2
    MOV CX, 0
INPUT:
    MOV AH, 01H
    INT 21H
    INC CX
    CMP AL, 'z'
    JE TOPRINT
    CMP AL, 'Z'
    JE TOPRINT
    MOV AH, 0
    PUSH AX
    MOV AX, 0
    JNE INPUT
    MOV DI, CX
TOPRINT:
    POP DX
    CMP DX, 'a'
    JL NEXT
    CMP DX, 'z'
    JG NEXT
    MOV AH, 02H
    INT 21H
    CMP DX, 'A'
    JL NEXT
    CMP DX, 'Z'
    JG NEXT
    MOV AH, 02H
    INT 21H
    CMP DX, '0'
    JL NEXT
    CMP DX, '9'
    JG NEXT
    MOV AH, 02H
    INT 21H
NEXT:
    SUB BP, 2
    DEC CX
    CMP CX, 0
    JMP TOPRINT

    MOV AX, 4C00H
    INT 21H

CODE ENDS
    END MAIN

2) Program with string size Define N, program will take input from the user, and will take only numbers from the input and put them to string with N size, the input size is N. and print message with the string (must have only numbers from input) and amount of the numbers.
example (string size 10)
input : 1adr1t23g7
string: 11237
print out:
The String of numbers are : 11237 and Tolat Numbers are : 5

Stuck with question 1, not understand the subject and cant continue to question 2.
thanks to every one who may help me

I'd like to hear your solution. While I have written very small passages in assembly on quite a few CPUs these were mostly on non-x86 processors. In assembly I don't think of variables but some memory location by name. Since all my work was IRL, my only restrictions were usually functionality first, reliability and other issues like code size which is usually the reason the work was in assembler to start with.

So if the input text was on the stack I guess we could get the input to the stack which I think you can do. But how to read down the stack without popping it would be my solution. In the x86 we have a stack pointer so you could use that plus or minus the number of characters you input then point at the first character, test the output or not, increment your pointer, test for end or loop.

In your final "Numbers" you could switch gears and pop off the stack and output or not depending on the test result.

To me this is not using a variable. Might end up definding this with the prof which I do because I've done too much IRL coding.