Algorithm design option one - flow diagram

Algorithm design option two - pseudocode

{set error flag to True to enable loop}
Set error = True

{iterate until a valid password is entered}
while error == True

    {set all variables to default values }
    set error = False
    set lower case = 0
    set upper case = 0
    set number = 0

    {input the password}
    Output "Type in a password of at least 5
    characters including 1 l/c letters, 1 u/c, 1 number: "
    input password

    {check password length - error if not at least 5 characters}
    if len(password)< 5 then
        error = True
     end if

    {if the password is the right length then}
    {inspect each character in the password}
    {add 1 to the number of upper case for each upper case character}
    {add 1 to the number of lower case for each lower case character}
    {add 1 to the number of numbers for each number}
    if error = False then
        for position (0 to len(password))
            {loop between 0 and length of password}
                    if password[position] >="A" AND password[position]
            < ="Z" then
                    upper case = upper case + 1
                    
            else if password[position] >="a" AND
            password[position]< ="z" then
                lower case = lower case 1
            else if password[position] >="0" AND
            password[position]< ="9" then
                number = number + 1
     next position
   end if

   {if character requirements are not met, an error has occured}
   if upper case < 1 OR lower case < 1 OR number < 1 then
       error = True
   output "Password not accepted"
Else
{output acceptance}
output "Password accepted: "< password
    end if
END

Output table

With the inputs stated below the outputs would be:

Example:

Type in a password of at least 5 characters including 1 l/c letters, 1 u/c, 1 number: Pass1234

Password accepted: Pass1234

Testing table

Tests will be required to test that the final program runs correctly.

The problem has now been fully decomposed and an algorithm has been designed.