Error Handling:

• we must handle some input error :
  • if no parameters are specified, the program must not display anything and give the prompt back
  • if some arguments aren’t integers,
  • if some arguments are bigger than an integer
  • if there are some duplicates
  • if we have an argument as a string with some numbers separated by space

The real work:

• After parsing our arguments and handling all the errors, and handling the cases where we have (0 .. 5) numbers, now the work begins :

  • We must create a temporary stack

  • fill it with the numbers that are in stack_a

  • sort it

  • replace the elements of stack_a with their index in the sorted stack (temporary)

  • now our work is to push everything to stack_b with some rules :

    • first of all we gotta specify a range which we will work with

      • 0 - 15 : if we’re sorting (5 .. 100) number
      • 0 - 30 : if we’re sorting (100 .. +) number

    • we check if the top of stack_a is :

      • less or equal than the start of range : pb → rb → start_of_range++ → end_of_range++
      • bigger than the start and smaller than the end : pb → start_of_range++ → end_of_range++
      • bigger than the end : ra

    • we repeat this process until we have no longer an element in stack_a

    • now we have the elements in stack_b taking a shape of a pyramid with the bigger numbers (smaller elements in stack_a (bcs of our index filling)) are in the middle

      

    • now its time to refill the stack_a :

      • first, we divide our stack into by two and we check the index of the minimum (which will be the maximum value)
      • if that index is in the second half we rrb until it reaches the top and we pa
      • else if its in the first half we rb until it reaches the top and we pa

    • now after the first push to a we will observe that the pyramid is in opposite side

    

    • now we wont consume much operations we gonna just repeat whats above bcs if the minimum in the first half we are sure that he’s near to the top so we wont do much rb and same if its in the second half we are sure that its near to the first elements of the stack so wont do much rrb

• and VOILA here’s the stack_a sorted with the minimum of operations :