CONTINUAL INTEGRATION

Problem scenario
You need to write a Python program to see if a list of unique integers is in order. You can copy the list and sort it to compare the ideal state to the list provided. The program must print out a relevant message if a swap of two numbers can place those two numbers in the correct order. The program must print out if a given number is already in order.

Here are the requirements of the Python program:

• generate a list of numbers (either by random or hard-code a list)
• sort the list
• find if incorrectly placed numbers share a spot with another number that if swapped, both would be in order

Solution

import random

def diff_finder(array):
  unsorted_list = array[:]
  array.sort()
  counter = 0
  for i in range(len(array)):
    if array[i] != unsorted_list[i]:
      if unsorted_list[array.index(unsorted_list[i])] == array[i]:   
      # if the integer in this position (the array.index(unsorted_list[i]) returns the position of the value of the wrong integer),
      # is the value of the correctly-ordered integer in the sorted array
        print("ONE SWAP WOULD CORRECTLY PLACE TWO NUMBERS!")
      else:
        print("It will take more than one swap with this number to get the list in order: " + str(unsorted_list[i]) )
    else:
      print(str(array[i]) + " is in correct order")

a_list = []

for i in range(10):
  a_list.append(random.randint(1,10))

print("This list we are dealing with is " + str(a_list))
diff_finder(a_list)

Problem scenario
You see Python code with this "-> str" syntax. What does it do?

Answer
It is purely for readability. To help your coworkers we recommend using the "-> str" syntax if a function returns a string. Otherwise the way to find out is to read the code or temporarily change the code and use type(variable_returned) to show the data type of that which is/was returned.

Here is a program that illustrates how we know the "-> str" is just for information and has no affect on the code:

def documentation_proof() -> str:
  var1 = "unmistakeably a string"
  #have either the above or below var1 definition uncommented. have only one.  it proves the "-> str" syntax is for information only.
  #var1 = 55
  return var1

check_output = documentation_proof()
print(check_output)

Some functions will be configured as "-> None" if the function returns nothing. (If the function actually does return something, the "-> None" will have no effect other than misleading people when they read the function itself.

Similarly, the parameters in a function's definition can display intended data types like this:

def nifty_function(a: int, b: str):

But those parameter data type definitions do nothing special beyond enhancing readability. If you passed a non-integer for "a" or a non-string for "b", the function would proceed as if there was no ": int" or ": str" in the function parameters. Some programmers do not use this explicit convention as it is arguably more prolix and makes the code busy to read.