Thus, starting today, This Repository will be available as a Public Archive only.
Basic python CLI programs as examples.
All the examples are useful examples.
These examples are of beginner level.
Note: In 2.x versions input isn't useful. Similarly, in 3.x versions raw_input isn't useful. Also, xrange() and other methods are discontinued or changed in 3.x versions of Python. Change the keywords accordingly.
Update: I wrote these programs when I was just starting out with programming, now I realize that many of them seem quite amateur in their rendering so I've decided to audit through all of them and update them according to my current capabilities.
Files outside particular directories have not been checked yet
Files inside, directories offer better code and explanation
Also see this : Beginners-Python-Examples/CONTRIBUTING.md
================================================ FILE: Turtle_Drawing.py ================================================ import turtle ninja = turtle.Turtle() ninja.speed(10) for i in range(180): ninja.forward(100) ninja.right(30) ninja.forward(20) ninja.left(60) ninja.forward(50) ninja.right(30) ninja.penup() ninja.setposition(0, 0) ninja.pendown() ninja.right(2) turtle.done() ================================================ FILE: _config.yml ================================================ theme: jekyll-theme-minimal ================================================ FILE: algorithms/README.md ================================================
'algorithms' Sub-directory contains all algorithms further separated in different particular sub directoriesThe programs have been re-checked and re-mastered by me!
Although i've tried to keep it as orignal as possible.
Keep Patience It'll take time to go through every program!!
Thanks ================================================ FILE: algorithms/analysis/README.md ================================================
'analysis' Sub-directory contains all analysis related algorithms. Thanks================================================ FILE: algorithms/analysis/bigo_notation.py ================================================ from math import log import numpy as np import matplotlib.pyplot as plt %matplotlib inline plt.style.use('bmh') # Set up runtime comparisons n = np.linspace(1,10,1000) labels = ['Constant','Logarithmic','Linear','Log Linear','Quadratic','Cubic','Exponential'] big_o = [np.ones(n.shape),np.log(n),n,n*np.log(n),n**2,n**3,2**n] # Plot setup plt.figure(figsize=(12,10)) plt.ylim(0,50) for i in range(len(big_o)): plt.plot(n,big_o[i],label = labels[i]) plt.legend(loc=0) plt.ylabel('Relative Runtime') plt.xlabel('n') ================================================ FILE: algorithms/analysis/count.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # Simple algorithm to count # number of occurrences of (n) in (ar) # Sudo: Algorithm # each time (n) is found in (ar) # (count) varible in incremented (by 1) # I've put spaces to separate different # stages of algorithms for easy understanding # however isn't a good practise def count(ar, n): count = 0 for element in ar: # More complex condition could be # => (not element != n) if element == n: count += 1 return count # Testing # add your test cases in list below test_cases = [([1, 1, 2, 3, 5, 8, 13, 21, 1], 1), ("Captain America", "a")] for test_case in test_cases: print("TestCase: {}, {}".format(test_case[0], test_case[1])) print("Results: {}\n".format(count(test_case[0], test_case[1]))) # You can add condition to check weather output is correct # or not ================================================ FILE: algorithms/analysis/enum.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # Enum function # yields a tuple of element and it's index def enum(ar): for index in range(len(ar)): yield((index, ar[index])) # Test case_1 = [19, 17, 20, 23, 27, 15] for tup in list(enum(case_1)): print(tup) # Enum function is a generator does not # return any value, instead generates # tuple as it encounters element of array # Tuples can be appended to list # and can be returned after iteration # However, # Generator is a good option ================================================ FILE: algorithms/analysis/length.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- import math # Length of array(number of elements in array) # is simple algorithm # Iterates through array # at each iteration (count) variable # is incremented # # This solution is ideal for small array # But not that good for bigger array's # There are many ways to do same thing # but always go with solution that is # simple, and has least instructions # for computer to execute, making # process faster # is_ap parameter indicates weather array # is an arithmetic progression or not # # Similarly, # is_gp indicates weather array is an geometric progression or not # If array is either ap or gp then it's length can be # found by derivation of it's general term formula # e.g. ap's general term, # tn = a + (n - 1)d # thus, n = (tn - a) / d + 1 def length(ar, is_ap = False, is_gp = False, big_data = False, data_outline = []): # Length of data if it is an arithmetic progression # using derived formula, n = (tn - a) / d + 1 if is_ap: return ((ar[-1] - ar[0]) / (ar[1] - ar[0])) + 1 # Length of data if it is an geometric progression # using derived formula, n = ((log base 10 an / a1) / log 10 r) + 1 elif is_gp: # length is never a float return int(math.log10((ar[-1] / ar[0])) / math.log10((ar[1] / ar[0])) + 1) # Length of big data using data outline # data outline is selective elements to be counted from entire # data elif big_data: count = 0 for element in data_outline: count += ar.count(element) return count # Sequential counting # of elements in array else: res = 0 for item in ar: res += 1 return res # Test # Geometric progression Test if length([1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096], None, is_gp = True) == 13: print("\nLength of geometric progression: " + str(13)) print("--> geometric progression counting works!\n") else: print("Something's wrong with gp feature") # Arithmetic progression test if length([1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43], is_ap = True) == 15: print("Length of arithmetic progression: " + str(15)) print("--> arithmetic progression counting works!\n") else: print("Something's wrong with ap feature") # Big data test # Passing only useful numbers in outline array if length([1, 1, 4, 5, 7, 1, 9, 5, 2, 4, 3, 5, 9], None, None, True, [1, 4, 5, 7, 9]) == 11: print("Length of arithmetic progression: " + str(11)) print("--> big data counting works!\n") else: print("Something's wrong with ap feature") # Small data print("Length: " + str(length([1, 1, 2, 3, 5, 8, 13, 21, 34, 55]))) print("Everything Works!\n") ================================================ FILE: algorithms/analysis/max.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # Finds the maximum number # in un-sorted data # Sudo Algo: # Iterate through data # each time a number(say k) greater than, previous # consideration(say p) is found, replace previous # consideration(p) with that greater number(k) # By this way, # At last we get the maximum number from data def max_(seq): max_n = seq[0] for item in seq[1:]: if item > max_n: max_n = item return max_n # Test # Add your tests too! tests = [[9017289, 782367, 736812903, 9367821, 71256716278, 676215, 2398, 0, 1], [19208, 9239, 4376, 738, 78, 51, 5, 6, 12, 78, 123, 65765, 1999999999], [1, 2, 4, 7, 9]] # checking our functions results # with python's built-in max() function for test_i in range(len(tests)): m = max_(tests[test_i]) if m == max(tests[test_i]): print("Max number in array({}) -> ".format(test_i + 1) + str(m)) else: print("Oops! Someting went wrong!") ================================================ FILE: algorithms/analysis/mean.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # f(x) = s(x) / l(x) ______(e1) # Functions below same principle as (e1) # # Here, # Mean value can be float # 'er is need to declare float values # Function to get mean of given args def mean_(*args): sum_ = 0.0 length_ = 0.0 for arg in args: sum_ += arg length_ += 1.0 return sum_ / length_ # Function to get mean of array def mean_ar(ar): return float(sum(ar))/float(len(ar)) # Another feature can be start index # and end index of array # Test # First function if mean_(12, 445, 76, 23, 7, 9, 17, 19, 100) == 78.66666666666667: print("First Function Works!") # Second function if mean_ar([12, 445, 76, 23, 7, 9, 17, 19, 10]) == 68.66666666666667: print("Second Function Works!") ================================================ FILE: algorithms/analysis/median.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # Median # Median is the middle value of data # Data of odd length has a mid value # but, data of even length has 2 mid values # so their median is mean of these 2 values # ranked parameter is to tell function # weather data is ranked(sorted) or not # def median(ar, ranked = False): if not ranked: data = sorted(ar[:]) else: # Don't need an else block still # but to map program properly # i've added it data = ar[:] # Data with odd length if len(data) % 2 != 0: # f(x) = (l(x) + 1) / 2 th term is the median of data # but since computer starts counting from 0 # and not from 1, there is no need to add 1 # to length of data, otherwise results are # not accurate return data[len(data) / 2] # Data with even length # f(x) = [l(x) / 2 th term + (l(x) + 2) / 2th term] / 2 # 2.0 is to declare that median can be a float # in case of even length data return (data[len(data) / 2 - 1] + data[(len(data) + 1) / 2]) / 2.0 # Test odd = [123, 456, 789, 101112, 131415, 161718, 192021, 222324, 252627] even = [8, 7, 5, 2, 1, 3, 4, 6] if median(odd, ranked = True) == 131415 and median(even) == 4.5: # Print statements on separate lines look better print("Median of odd data: " + str(131415)) print("Median of even data: " + str(4.5)) print("Yeah, it works!") else: # If algo didn't work print("There's something wrong!") # This median is for un-distributed/un-grouped data # i.e. no frequencies # plain numbers in an array ================================================ FILE: algorithms/analysis/min.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # Finds the minium number # in un-sorted data # Sudo Algo: # Iterate through data # each time a number(say k) is less than previous # consideration(say p), replace previous # consideration(p) with that smaller number(k) # By this way, # At last we get the smallest(minium) number from data def min_(seq): min_n = seq[0] for item in seq[1:]: if item < min_n: min_n = item return min_n # Test # Add your tests too! tests = [[9017289, 782367, 736812903, 9367821, 71256716278, 676215, 2398, 0, 1], [19208, 9239, 4376, 738, 78, 51, 5, 6, 12, 78, 123, 65765, 1999999999], [1, 2, 4, 7, 9]] # checking our functions results # with python's built-in min() function for test_i in range(len(tests)): m = min_(tests[test_i]) if m == min(tests[test_i]): print("Min number in array({}) -> ".format(test_i + 1) + str(m)) else: print("Oops! Someting went wrong!") ================================================ FILE: algorithms/analysis/mode.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # Mode # mode or modal value, is the number in data # that has highest frequency, or occurs in data/array # maximum number of times # This function produces an outline of data # each element occurs only once in outline # that means no repeats of same numbers def reduce_data(data): # Simplest way to do this, just 1 line of code: # return list(set(data)) # since set data structure does not have repeats # But below code is much more # illustrative and easier to understand data_outline = [] for item in data: if item not in data_outline: data_outline.append(item) return data_outline # To find mode, we apply same principle, that works # behind finding the maximum or minimum number(see max.py, min.py) def mode(data): mode_ = data[0] max_frequency = data.count(data[0]) # Insted of iterating through every repeat of # same number, then counting multiple repeats # of number multiple times, iterating through outline # of data is convinient, less time consuming. for value in reduce_data(data[1:]): if data.count(value) > max_frequency: mode_ = value max_frequency = data.count(value) # instead of just mode, it's freq # can also be helpful return (mode_, max_frequency) # Test # Add your test cases tests = [ [19, 17, 25, 34, 57, 17, 25, 52, 47, 42, 25, 17, 3, 0, 3, 41, 17], [1917, 2534, 5717, 1725, 5247, 1917, 4117, 5717, 17303, 1917], ] # Function does work, # Check yourself for test in tests: modal_v = mode(test) print("\nData outline: {}".format(reduce_data(test))) print("Mode: {}\nFrequency: {}".format(modal_v[0], modal_v[1])) print("") # Mode for un-grouped data ================================================ FILE: algorithms/analysis/sort.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # Bubble Sort # Ideal sorting algorithm for # small data/array # temporary parameter tells # function to sort a copy of # orignal array, and not the array itself # reverse parameter tells func # to sort array in reverse/decending # order def sort_(arr, temporary = False, reverse = False): # Making copy of array if temporary is true if temporary: ar = arr[:] else: ar = arr # To blend every element # in correct position # length of total array is required length = len(ar) # After each iteration right-most # element is completed sorted while length > 0: # So every next time we iterate only # through un-sorted elements for i in range(0, length - 1): if reverse: # Swapping greater elements to left # and smaller to right # decending order if ar[i] < ar[i+1]: tmp = ar[i] ar[i] = ar[i + 1] ar[i + 1] = tmp else: # Swapping greater elements to right # and smaller to left # accending order if ar[i] > ar[i+1]: tmp = ar[i] ar[i] = ar[i + 1] ar[i + 1] = tmp # making sure loop breaks length = length - 1 # if temporary, then returning # copied arr's sorted form # cuz if not returned, then function # is literally of no use if temporary: return ar # See proper explaination # at: https://www.geeksforgeeks.org/bubble-sort/ # a good site! # Testing tests = [[7, 8, 9, 6, 4, 5, 3, 2, 1, 15], [1, 90, 1110, 1312, 1110, 98, 76, 54, 32, 10], ] # Add your test cases for test in tests: accend, decend = sort_(test, True), sort_(test, True, True) if accend == sorted(test) and decend == sorted(test, reverse = True): print("Orignal: {}".format(test)) print("Sorted: {}".format(accend)) print("Sorted(reverse): {}\n".format(decend)) else: print("Something went wrong!\n") # Seems our bubble sort works # however for small data/array! ================================================ FILE: algorithms/analysis/sum.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # Sudo ALgorithm: # both functions work on same principle # Iterate through array/arguments # add each element to variable(res) # return sum def sum_(*args): res = 0.0 for arg in args: res += arg return res def sum_ar(ar, end_i): # end_i is the last index of array # till which function should add # array's elements if end_i > 0 and end_i <= len(ar): if end_i == len(ar): end_i = end_i - 1 else: end_i = len(ar) - 1 res = 0.0 for elem in ar[:end_i + 1]: res += elem return res # Simple Algorithm # Testing # First Function if sum_(1, 2, 3, 4, 5, 6, 7, 8, 9) == 45: print("First Function Works!") # Second Function if sum_ar([1, 2, 3, 4, 5, 6, 7, 8, 9], -1) == 45: print("Second Function Partially Works!") if sum_ar([1, 2, 3, 4, 5, 6, 7, 8, 9], 6) == 28: print("Second Function Completely Works!") ================================================ FILE: algorithms/analysis/useful_function_mapping.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- def squared(n): return n * n def cubed(n): return n * n * n def raise_power(n, power): for t in range(power): n *= n return n def is_divisible(n, t): return n % t == 0 def is_even(n): return n % 2 == 0 def is_odd(n): return n % 2 != 0 # These all functions are extremely # helpful when used with map method of python # map(func, list) basically applies given function # to every element of list and appends results to a new # list # e.g. print(map(squared, [1, 3, 5, 7, 9, 11, 13, 15])) # for functions with multiple args # see: https://www.quora.com/How-do-I-put-multiple-arguments-into-a-map-function-in-Python ================================================ FILE: algorithms/numbers/README.md ================================================
'numbers' Sub-directory contains all numbers/math/sequences(arrays) related algorithms. Thanks================================================ FILE: algorithms/numbers/binary_to_decimal_converter.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- import sys # Binary to decimal conversion # See explaination: https://i.imgur.com/heAT0PB.gif , # https://www.electronics-tutorials.ws/binary/bin_2.html # Pesudo code: # Iterate through binary num # if 0 then pass # else result = result + bit(1) * 2 ** index of bit(1) def binary_to_decimal_conv(binary_string): res = 0 binary_l = list(binary_string) for bit_i in range(len(binary_l)): res += int(binary_l[bit_i]) * (2 ** bit_i) return res # Test # Testing interface i = 0 while True: if raw_input("\n[{}] Exit(press e) or Continue(press c): ".format(i)).strip().lower() == "c": print("Decimal form: " + str(binary_to_decimal_conv(raw_input("\nBinary?: ")))) else: print("\nHope you enjoyed!") sys.exit() i += 1 ================================================ FILE: algorithms/numbers/collatz_sequence.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- import sys # Collatz conjecture # is a series of numbers # where the orignal number is manipulated, until # one is obtained # if n is even n // 2 is the next number # else n * 3 # No matter what the value of n we'll, # always reach 1. # See: https://en.wikipedia.org/wiki/Collatz_conjecture # Collatz series generator def collatz_conjecture(n): if n < 1: raise Exception("\n Expected a value greater than 1") while n != 1: if n % 2 == 0: n = n // 2 else: n = 3*n + 1 yield n # If n will be negative then # sequence will be infinite # Interface # Test/Play i = 0 while True: if raw_input("\n[%i] Continue[Y/n]?: " % i).strip().lower() == "y": for v in collatz_conjecture(int(raw_input("N?: "))): print(" > " + str(v)) i += 1 else: print("\nSee you soon!") sys.exit(0) ================================================ FILE: algorithms/numbers/compare_array_elements.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # Compares elements at same # index in 2 different arrays # and so called generates tuple of # that value, index, array number # however if both numbers are equal # returns zero simply # Prime condition for correct results # length(arr1) == length(arr2) def compare_array_elements(arr1, arr2): for l in range(len(arr1)): if arr1[l] > arr2[l]: yield (arr1[l], l, 1) elif arr1[l] < arr2[l]: yield (arr2[l], l, 2) else: yield(0) # Tests tests = [ [ [21, 3454, 12, 77, 21, 90, 235], [123, 54, 21, 7, 23, 987, 21312] ], [ [1223, 8273, 17732, 7127], [12989, 2131223, 129, 10] ] ] # Does not test last condition of function for test in tests: for n, index, array_n in compare_array_elements(test[0], test[1]): print(" [ %i ] is biggest value at index(%i) from array(%i)" %(n, index, array_n)) ================================================ FILE: algorithms/numbers/factorial.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # Factorial # is a mathematical function which # determines number of all possibilities # you can arrange 'n' number of objects! # # If there are 5 options in total # At first: there are 5 to choose from # 5 X # then, after choosing 1 from those 5 we'd have # 4 remaining, 5 x 4 x # then 3 remaining, 5 x 4 x 3 # then 2, 5 x 4 x 3 x 2 # then 1, 5 x 4 x 3 x 2 x 1 = 120 # n is total number of objects def factorial(n): if n <= 1: return 1 else: n = n * factorial(n - 1) return n # Recursion is the easiest way to # solve this problem # but, to make sure recursion's depth ends, above # condition is necessary, otherwise # errors occur # Another way to solve problem def factorial_(n): if n <= 1: return 1 else: m = 1 # range function produces inclusive range for integer in range(1, n + 1): m *= integer return m # This solution is bigger # and looks much more complex # than the recursion one # Both work the same however # Test if factorial(5) == factorial_(5) == 120: print("(" + str(5) + ")! == " + str(120)) print("Both functions work!\n-Try it yourself-") x = int(raw_input("\nNumber: ")) print("(" + str(x) + ")! == " + str(factorial(x))) else: print("Someting went wrong!") ================================================ FILE: algorithms/searching/binary_search.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- import sys # I'm too lazy to explain how it works, # instead check below sites out: # https://en.wikipedia.org/wiki/Binary_search_algorithm # https://www.geeksforgeeks.org/binary-search/ # Make sure you know concept of Recursion # Function explaination: # ar is the array # f is starting index for divided search array # l is ending index for divided search array # v is the query to search in array data space # sorted_ar tells the func, if array is sorted or not # as binary search won't work on an un-sorted array def binary_search(arr, f, l, v, sorted_ar = False): # need an ordered/sorted array for search, # else search won't produce desirable results if not sorted_ar: arr.sort() # If input is invalid if l - f < 0: return -1 else: # Index of mid-term of array[f:l+1] mid_element_i = (f + l) // 2 # If mid-term matches the query if arr[mid_element_i] == v: return mid_element_i # If query is bigger than that mid-term # then we'll look at next_half of array elif v > arr[mid_element_i]: return binary_search(arr, mid_element_i+1, l, v, True) # else query is smaller than mid-term # so we'll look at lesser half of array else: return binary_search(arr, f, mid_element_i-1, v, True) # Tests # Add your tests # Arrays below are not sorted or are un-ordered # Index returned by function is for sorted array # thus index might differ for same element, array below and in sorted array! tests = [ [10, 29, 38, 47, 56, 19, 28, 37, 46, 50], [1, 92, 83, 74, 65, 29, 84, 75], [1, 21, 32, 43, 54, 65, 79], [7, 7], ] # Play as long as you can # Searches query in all of arrays in tests i = 0 while True: if raw_input("\n[%i] Exit(press e) or Continue(press c): " % i) == "e": sys.exit() q = int(raw_input("\nSearch?: ")) print("Results:") for test in tests: find_i = binary_search(test, 0, len(test) - 1, q, False) if test[find_i] == q: print(" Found [{}] at index({}) in array({})".format(q, find_i, tests.index(test) + 1)) else: # else is executed means, # something is wrong with the algorithm print(" No results for [{}] in array({}). Try another search!".format(q, tests.index(test) + 1)) i += 1 ================================================ FILE: algorithms/sorting/README.md ================================================
'sorting' Sub-directory contains all sorting algorithms. Thanks================================================ FILE: algorithms/sorting/bubble_sort.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # Bubble Sort # Ideal sorting algorithm for # small data/array # temporary parameter tells # function to sort a copy of # orignal array, and not the array itself # reverse parameter tells func # to sort array in reverse/decending # order def sort_(arr, temporary = False, reverse = False): # Making copy of array if temporary is true if temporary: ar = arr[:] else: ar = arr # To blend every element # in correct position # length of total array is required length = len(ar) # After each iteration right-most # element is completed sorted while length > 0: # So every next time we iterate only # through un-sorted elements for i in range(0, length - 1): if reverse: # Swapping greater elements to left # and smaller to right # decending order if ar[i] < ar[i+1]: tmp = ar[i] ar[i] = ar[i + 1] ar[i + 1] = tmp else: # Swapping greater elements to right # and smaller to left # accending order if ar[i] > ar[i+1]: tmp = ar[i] ar[i] = ar[i + 1] ar[i + 1] = tmp # making sure loop breaks length = length - 1 # if temporary, then returning # copied arr's sorted form # cuz if not returned, then function # is literally of no use if temporary: return ar # See proper explaination # at: https://www.geeksforgeeks.org/bubble-sort/ # a good site! #can add flag to reduce time complexity # Testing tests = [[7, 8, 9, 6, 4, 5, 3, 2, 1, 15], [1, 90, 1110, 1312, 1110, 98, 76, 54, 32, 10], ] # Add your test cases for test in tests: accend, decend = sort_(test, True), sort_(test, True, True) if accend == sorted(test) and decend == sorted(test, reverse = True): print("Orignal: {}".format(test)) print("Sorted: {}".format(accend)) print("Sorted(reverse): {}\n".format(decend)) else: print("Something went wrong!\n") # Seems our bubble sort works # however for small data/array! ================================================ FILE: algorithms/sorting/insertion_sort.py ================================================ # -*- coding: utf-8 -*- # Insertion Sort # Ideal sorting algorithm for # small/small-medium data/array # temporary parameter tells # function to sort a copy of # orignal array, and not the array itself # reverse parameter tells func # to sort array in reverse/decending # order def sort_(arr,temporary=False,reverse=False): # Making copy of array if temporary is true if temporary: ar = arr[:] else: ar = arr # To blend every element # in correct position # length of total array is required length = len(ar) # After each iteration left-most # sub-array is completed sorted for i in range(1,length): # In each iteration we place # the current element to its # proper position in left sorted # sub array tmp = ar[i] j = i-1 if reverse: while j>=0 and tmp>ar[j]: ar[j+1]=ar[j] j-=1 ar[j+1]=tmp else: while j>=0 and tmp
'string' Sub-directory contains all string related algorithms Thanks================================================ FILE: algorithms/string/caesars_cipher_encryption.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- import string, sys # Caesar's cipher is type of shift cipher, # an encryption technique # First used by roman rular Julius Caesar # To see how it works refer: # web-page/article: https://en.wikipedia.org/wiki/Caesar_cipher OR # https://www.khanacademy.org/computing/computer-science/cryptography/crypt/v/caesar-cipher def caesars_cipher_encoding(s, k, lowercase = True, uppercase = False): # To encrypt plain text in either # uppercase letters or lowercase letters if lowercase: alphas = list(string.lowercase) elif uppercase: alphas = list(string.uppercase) encrypted = "" # List characters in orignal string char_s = list(s) # Shifting of each single # character in orignal string # using given key for char in char_s: # avoid encryption of spaces if char == " ": encrypted += " " else: # n_index or new index is # the index of encrypted character n_index = k + alphas.index(char) # if encrypted character is greater than # length of english alphabets if n_index > 25: # Read explaination on line 59 while not n_index <= 25: n_index = n_index - 26 encrypted += alphas[n_index] # simple shift else: encrypted += alphas[n_index] return encrypted # Explaination of key bigger than 26: # say we have key 54, # we add index of char(say 'a') to key, i.e. key = 54 + 1 = 55 # so after first iteration over array of length(26), # i.e. 55(total iterations to perform) - 26(iterations completed) = 29(iterations left) # but, 29 is still a big index i.e. 29 > length of array(26) # so we continue to subtract more 26(iterations), # i.e. 29(iterations to perform) - (26 iterations done) = 3(remaining) # so 3 is smaller than length of array and can be used as key, # i.e. 3 < 26(length of array) # thus, we reached at index of 3 after 54 iterations over an array of length 26 # bit complicated but read it twice, you'll master it! # Test, Playing UI i = 0 while True: if raw_input("[{}] Exit(press e), To continue(press c): ".format(i)).lower() == "c": # Number of times i += 1 # Input for String and key for char shift S, K = raw_input("\nString: "), int(raw_input("Key: ")) # Results print("\nOrignal string: " + S + " , Key: " + str(K)) print("Encrypted text: " + caesars_cipher_encoding(S, K, True, False) + "\n") else: sys.exit() ================================================ FILE: algorithms/string/check_anagram.py ================================================ '''An anagram is a word or phrase created by rearranging the letters of another word or phrase. For example, the word "heart" can be rearranged to form the word "earth". So, "heart" and "earth" are anagrams of each other.''' def check_anagram(str1,str2): # Remove all spaces from both the strings # and convert them to lowercase str1 = str1.replace(" ","").lower() str2 =str2.replace(" ","").lower() # if the length of both strings are not equal then return false if len(str1) != len(str2): return False count1 = {} count2 = {} for i in range(len(str1)): count1[str1[i]] = 1+count1.get(str1[i],0) count2[str2[i]] = 1+count2.get(str2[i],0) for c in count1: if count1[c] != count2.get(c,0): return False str1 = input() str2 = input() if check_anagram(str1,str2): print(f"{str1} and {str2} are anagrams") else: print(f"{str1} and {str2} are anagrams") ================================================ FILE: algorithms/string/is_palindrome.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # Palindrome is a special string, is same if reversed # e.g. noon, racecar, et cetera # Notice in above strings, there is no difference between # string and it's reversed form # Function checks if given string is a palindrome or not # string[::-1] is a clever way to reverse string # string from start index to end index # whose difference is -1(reverse) # found on stack overflow, very pythonic def is_palindrome(s) : if s[::-1] == s: return True return False # Test S = raw_input("String: ") if is_palindrome(S): print("Results:\n " +S + " is a palindrome string.") else: print("Results:\n " + S + " is not a palindrome string.") # add a loop to play many times(maybe infinite) ================================================ FILE: algorithms/string/is_palindrome_two_liner.py ================================================ import string def is_palindrome(s): # String Clenasing s = "".join([char for char in list(s.lower()) if char in list(string.ascii_lowercase)]) # (index+1) * -1 gives negative index of corresponding counterpart # for e.g. s = "noon" s[0] = s[-1] = "n" and so on # all() and list comprehensions make task so easy!! return all([s[index]==s[(index+1)*-1] for index in range(0, len(s))]) # Tests print(is_palindrome("racecar")) print(is_palindrome("ra cec, a?r ")) // True print(is_palindrome("noooonnn")) print(is_palindrome("cool..eh") ================================================ FILE: algorithms/string/vowel_count.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- import sys # The function # counts number of occurrences of vowels # in given string # Principle: # Loop through list of vowels # count occurrences of each vowel in given string # yield/generate the occurrences of that vowel def vowel_count(S): vowels = ['a', 'e', 'i', 'o', 'u'] for vowel in vowels: counter = 0 for char in S: if char == vowel: counter += 1 yield(vowel, counter) # CLI # Testing or Playing Interface while True: usr_input = raw_input("\nPress (e) to Exit\nor Enter string: ").strip().lower() if not usr_input == "e": print("> Results: ") for vow, counter in vowel_count(usr_input): print(" " + vow + " > occurred " + str(counter) + " times.") else: print("\nHope you enjoyed!") sys.exit() ================================================ FILE: ansi-colors.py ================================================ """ ansi-colors.py Print 256 ANSI(8bit) color chart Reference : https://en.wikipedia.org/wiki/ANSI_escape_code *** Warning! In some terminal/OS environments, this code may display different colors or color may not be displayed properly """ START_ESCAPE_8BIT = "\033[38;5;" END_ESCAPE = "\033[0;0m" SQUARE_CHAR = '\u25A0' def print_square_8bit(color): print(START_ESCAPE_8BIT + str(color) + 'm' + SQUARE_CHAR + END_ESCAPE, end="") print("System standard colors: ", end="") for i in range(8): print_square_8bit(i) print() print("System high intensity colors: ", end="") for i in range(8, 16): print_square_8bit(i) print() step = 0 print("216 Colors: ") for i in range(16, 232): print_square_8bit(i) step += 1 if step % 24 == 0: # Make newline every 24 colors print() print() print("Grayscale colors: ", end="") for i in range(232, 256): print_square_8bit(i) print() ================================================ FILE: armstrong_number.py ================================================ # Python program to check if the number is an Armstrong number with the index of 3 or not # for input try numbers 153, 370, 371, 407 # take input from the user num = int(input("Enter a number: ")) # initialize sum sum = 0 # finding the length of num n = len(str(num)) # find the sum of the cube of each digit temp = num while temp > 0: digit = temp % 10 sum += digit ** n # power of n temp //= 10 # display the result if num == sum: print(num, "is an Armstrong number.") else: print(num, "is not an Armstrong number.") # Originally contribution by denz647 ================================================ FILE: bell_number.py ================================================ # Contribution by https://github.com/nightwarriorftw #Python program to print bell number #Bell Number:-Let S(n, k) be total number of partitions of n elements into k sets. The value of n’th Bell Number is sum of S(n, k) for k = 1 to n. Value of S(n, k) can be defined recursively as, S(n+1, k) = k*S(n, k) + S(n, k-1) A sample Bell triangle is as follows: 1 1 3 3 8 13 13 23 33 43 #The code to print the bell triangle is as follows- #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- n=int(input("enter the number of bell")) #taking value from the user bell=0 #initialising bell to 'zero' k=0 #initialising k to 'zero' for i in range(0,n): #loop for changing rows from 0 to n for j in range(0,i+1): #printing columns if j==0 and i>0: #repeating the last number of previous row in new row print(bell,'',end='') #printing first number of each line else: k=(i**2)+1+bell #to generate other numbers of line print(k,'',end='') #printing other number in lines bell=k #updating value of bell print('\n') #for moving into next lines print("last number of bell is",bell) ================================================ FILE: bigo_notation.py ================================================ # Contribution from https://github.com/Alok070899 from math import log import numpy as np import matplotlib.pyplot as plt %matplotlib inline plt.style.use('bmh') # Set up runtime comparisons n = np.linspace(1,10,1000) labels = ['Constant','Logarithmic','Linear','Log Linear','Quadratic','Cubic','Exponential'] big_o = [np.ones(n.shape),np.log(n),n,n*np.log(n),n**2,n**3,2**n] # Plot setup plt.figure(figsize=(12,10)) plt.ylim(0,50) for i in range(len(big_o)): plt.plot(n,big_o[i],label = labels[i]) plt.legend(loc=0) plt.ylabel('Relative Runtime') plt.xlabel('n') ================================================ FILE: bubble sort.py ================================================ '''Bubble Sort Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in wrong order. Example: First Pass: ( 5 1 4 2 8 ) –> ( 1 5 4 2 8 ), Here, algorithm compares the first two elements, and swaps since 5 > 1. ( 1 5 4 2 8 ) –> ( 1 4 5 2 8 ), Swap since 5 > 4 ( 1 4 5 2 8 ) –> ( 1 4 2 5 8 ), Swap since 5 > 2 ( 1 4 2 5 8 ) –> ( 1 4 2 5 8 ), Now, since these elements are already in order (8 > 5), algorithm does not swap them. Second Pass: ( 1 4 2 5 8 ) –> ( 1 4 2 5 8 ) ( 1 4 2 5 8 ) –> ( 1 2 4 5 8 ), Swap since 4 > 2 ( 1 2 4 5 8 ) –> ( 1 2 4 5 8 ) ( 1 2 4 5 8 ) –> ( 1 2 4 5 8 ) Now, the array is already sorted, but our algorithm does not know if it is completed. The algorithm needs one whole pass without any swap to know it is sorted. Third Pass: ( 1 2 4 5 8 ) –> ( 1 2 4 5 8 ) ( 1 2 4 5 8 ) –> ( 1 2 4 5 8 ) ( 1 2 4 5 8 ) –> ( 1 2 4 5 8 ) ( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )''' # Python program for implementation of Bubble Sort def bubbleSort(arr): n = len(arr) # Traverse through all array elements for i in range(n): # Last i elements are already in place for j in range(0, n-i-1): # traverse the array from 0 to n-i-1 # Swap if the element found is greater # than the next element if arr[j] > arr[j+1] : arr[j], arr[j+1] = arr[j+1], arr[j] # Driver code to test above arr = [64, 34, 25, 12, 22, 11, 90] bubbleSort(arr) print ("Sorted array is:") for i in range(len(arr)): print ("%d" %arr[i]), ================================================ FILE: cartesian_plane_quadrant.py ================================================ # quadrant determiner # I(+,+) II(-,+) III(-,-) IV(+,-) def determine_quadrant(x, y): try: if x > 0 and y > 0: return 'I(+,+)' elif x < 0 and y > 0: return 'II(-,+)' elif x < 0 and y < 0 : return 'III(-,-)' elif x > 0 and y < 0 : return 'IV(+,-)' else : return 'Invalid parameters were provided' except TypeError: return "X and Y co-ords must be integers and not X {}, Y{}".format(type(x), type(y)) # Test result = determine_quadrant(float(input('X co-ordinate: ')), float(input('Y co-ordinate: '))) print("Quadrant is " + result) ================================================ FILE: client_file.py ================================================ import socket server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM) host = socket.gethostbyname(socket.gethostname()) port = 12345 x = input("Enter file name : ") server_socket.connect((host,port)) name = server_socket.recv(1024).decode() name = name.split('.')[-1] name = x+'.'+name f = open(name,'wb') while True : c_msg = server_socket.recv(1024) if c_msg == 'EOF'.encode() : f.close() server_socket.close() break f.write(c_msg) ================================================ FILE: conways.py ================================================ ''' -conway's game of life -made by Tzara Northcut @Mecknavorz -requires pygame ''' #import the stuff we need import pygame, sys, time #----------------------------------------- #initalize some variables and other things #----------------------------------------- width = 6 #cell size width height = 6 #cell size height space = 2 #thickness of world lines #create the 2d array where we actually store vairables of cells world = [[0 for x in range(100)] for y in range(100)] #initialzie pygame pygame.init() size = [100*(width+space)+space, 100*(height+space)+space] #window size screen = pygame.display.set_mode(size) #make the window the right size #set spme colors BLACK = ( 0, 0, 0) #background color WHITE = (255, 255, 255) #color of world GREEN = ( 0, 0, 0) #color of cells that are alive and well RED = (255, 0, 0) #colors of the cells about to die #speed stuff clock = pygame.time.Clock() #clock used to manage game speed pause = True #used to control the steps, might not need this laststep = time.time() #used to keep runing until the game is closed done = False #------------------------------------- #some functions to be used in the game #------------------------------------- #determine #of cells nearby def getclose(x, y): nearby = 0 #avoid out of bounds error and make the grid a torroid if(x+1) > 99: x = 0 if(y+1) > 99: y = 0 #swcan nearby squares and if there's something there add 1 to the count if world[x-1][y-1]: nearby += 1 if world[x][y-1]: nearby += 1 if world[x+1][y-1]: nearby += 1 if world[x-1][y]: nearby += 1 if world[x+1][y]: nearby += 1 if world[x-1][y+1]: nearby += 1 if world[x][y+1]: nearby += 1 if world[x+1][y+1]: nearby += 1 return nearby #calculate next step def nextStep(): for x in range(len(world)): for y in range(len(world[0])): near = getclose(x, y) if near < 2: #if there are less than two neighbors then kill the cell world[x][y] = 0 if near > 3: #if there are more than three neighbors then kill the cell world[x][y] = 0 if (world[x][y] == 0) and (near == 3): #if there are 3 neighbors near a dead cell, revive it world[x][y] = 1 #clear the board def clear(): for x in range(len(world)): for y in range(len(world[0])): world[x][y] = 0 #--------------------- #the initale game loop #--------------------- while not done: #to make sure the game quits when we need it to for event in pygame.event.get(): if event.type == pygame.QUIT: done = True elif event.type == pygame.MOUSEBUTTONDOWN: #if we get a click pos = pygame.mouse.get_pos() #find where the click was #change the pixel coords into game coords x = pos[1] // (height+space) y = pos[0] // (width+space) #add or remove the cell that's there if world[x][y] == 0: #if the tile is empty add a cell world[x][y] = 1 #print("nearby: ", getclose(x, y)) #used for debugging else: #else if there's something there, remove the cell world[x][y] = 0 #print("click: ", pos, "grid coord: ", x, y) #debug stuff elif event.type == pygame.KEYDOWN: #pause the game when space is pressed if event.key == pygame.K_SPACE: #print('space pressed') if pause: pause = False elif not pause: pause = True elif event.key == pygame.K_RIGHT: #if we presws the right key go forward a step nextStep() #calculate the next elif event.key == pygame.K_ESCAPE: clear() #draw the world screen.fill(BLACK) #maybe move this to a seprate function to help with effeciency? for x in range(len(world)): for y in range(len(world[0])): color = WHITE if world[x][y] == 1: color = GREEN pygame.draw.rect(screen, color, [(space+width)*y+space, (space+height)*x+space, width, height]) #set frame rate clock.tick(60) if (not pause) and ((time.time() - laststep) > .1): laststep = time.time() #print(laststep) nextStep() #update screen pygame.display.flip() #if we;ve gotten this far (eg out of the while loop) we know it's time to quit pygame.quit() ================================================ FILE: count_algorithm_execution_time.py ================================================ from datetime import datetime # Don't confuse this is "Main" algorithm # Time calculated is near accurate because of some extra instructions # before actually executing the algorithm def count_cpu_microtime(func_name, *args): tmp = [i for i in args] t1 = datetime.now().microsecond func_name(*tmp) time_took = datetime.now().microsecond - t1 return round(time_took, 5) # Testing # "Test" algorithm def binary_search(array, n): arr = sorted(array) to_return = False first_elem = 0 last_elem = len(arr) - 1 while (first_elem <= last_elem): mid = (first_elem + last_elem) // 2 if (arr[mid] == n): to_return = True break else: if (n > arr[mid]): first_elem = mid + 1 else: last_elem = mid - 1 return to_return result = count_cpu_microtime(binary_search, [12,324,23,213,3,2,1], 1) print(str(result) + " microsecs") ================================================ FILE: days_you_lived.py ================================================ # We assume that given dates are correct # and # solved for problem set in cs course on udacity.com from calendar import isleap def daysBetweenDates(year1, month1, day1, year2, month2, day2): dom = [ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] domleap = [ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] if (isleap(year1) and isleap(year2)): e1 = sum(domleap) + sum(domleap[:month1 - 1]) + day1 e2 = sum(domleap) + sum(domleap[:month2 - 1]) + day2 return e2 - e1 days = 0 if isleap(year1): days += (sum(domleap[month1 - 1:]) - day1) + sum(dom[:month2 - 1]) + day2 elif isleap(year2): days += (sum(dom[month1 - 1:]) - day1) + sum(domleap[:month2 - 1]) + day2 else: days += (sum(dom[month1 - 1:]) - day1) + sum(dom[:month2 - 1]) + day2 for year in range(year1 + 1, year2): if isleap(year): days += sum(domleap) else: days += sum(dom) return days date1=input("Enter a first date in YYYY-MM-DD format") year1,month1,day1=map(int,date1.split('-')) date2=input("Enter a second date in YYYY-MM-DD format") year2,month2,day2=map(int,date2.split('-')) days=daysBetweenDates(year1, month1, day1, year2, month2, day2) print("Number of days between {} and {} is \n {}".format(date1,date2,abs(days))) ================================================ FILE: deMorgans_law.py ================================================ # Morgans Formula In Algebra Set operations # number(set A) + number(set B) - number(set A interaction B) # n(a)+ n(b) - n(anb) # you can add sets or increase the number elements of sets The formula still works a = { 1 , 23 , 55 , 76 , 13 , 90 , 34 , 78 } b = { 12 , 345 , 8 , 4 , 0 , 7 , 4 , 3 , 53 , 4 , 6 , 3 } abInteraction = a & b # & operator interacts two sets abUnion = a | b # | operator makes union of two sets eqn = len(a) + len(b) - len(abInteraction) print(str(eqn) + ' = ' + str(len(abUnion))) ================================================ FILE: decimal_to_binary_converter.py ================================================ # For concatenation def concat(S): res = "" for i in S: if not isinstance(i, str): res += str(i) else: res += i return res # Simple Base 10 number(Decimal) number converter to Base 2 number(binary) number # Function returns answer in str datatype # For understanding steps: http://www.electronics-tutorials.ws/binary/bin_2.html def decimal_to_binary(n): res = [] while n != 0: res.append(n % 2) n = n // 2 final = concat(res) + "0" return final[::-1] # Test cases = [123, 23455, 253552, 87985, 3479434, 76, 246572, 231, 69, 2, 7, 2, 543] for case in cases: built_in = str(bin(case))[2:] my_func = decimal_to_binary(case)[1:] # For test purposes if built_in == my_func: print("Decimal: " + str(case)) print("Binary: " + my_func + "\nTest Passed!\n") else: print("Test Failed! Badly!!\n") ================================================ FILE: decrypting_caesars_cipher.py ================================================ import string # Note: this decryption function is designed to decrypt messages encrypted by encryption function i wrote(avaliable in this repo) def concat_elements(n): res = "" for i in n: res += i return res def decrypt(message, key): string_chars = list(string.ascii_uppercase) + list(string.ascii_lowercase) + list(string.digits) + list(string.punctuation) + [" "] try: splitted_message = list(message) except TypeError: return "Expected an string for text!" for char in splitted_message: try: tmp = string_chars[string_chars.index(char) - key] except IndexError: tmp_key = (string_chars.index(char) + key) + len(string_chars) tmp = string_chars[tmp_key] splitted_message[splitted_message.index(char)] = tmp final = concat_elements(splitted_message) return final def decrypt_generator(message, n): # range(0, 96) because len(string_chars) == 95 for i in range(0, n + 1): case = decrypt(message, i) yield case # Test test_case = "lq01Ir1I2xyI1ncrn2*" result = decrypt(test_case, 9) print("Decrypted Text: " + result, "\n") _result = list(decrypt_generator(test_case, 95)) for res in _result: print("Possible text: " + res) # Look at ninth result ================================================ FILE: dictionary.py ================================================ global dictionary dictionary = {} class Dict: def __init__(self, word, meaning): self.word = word self.meaning = meaning def add_new(self): dictionary[self.word] = self.meaning print("Word Successfully Added") def delete_word(self): try: del dictionary[self.word] print("Word Successfully Deleted") except KeyError: print("The Word Does Not Exist in Dictionary. Try Again!") def edit_word(self): try: dictionary[self.word] = self.meaning print("Word Was Successfully Edited") except KeyError: print("The Word You Trying To Edit Does Not Exist in Dictionary!") def view_word(self): try: print(dictionary[self.word]) except KeyError: print("The Word is not in Dictionary.") def view_all(self): for i in dictionary.keys(): print(f"{i} : {dictionary[i]}") def start(): get_op = input("Add, Delete, Edit, View, View all : ") if get_op in ["add", "Add"]: get_word = input("Word to add : ") get_meaning = input("Meaning : ") new = Dict(get_word, get_meaning) new.add_new() elif get_op in ["delete", "Delete"]: get_word_to_del = input("Word to delete : ") delete = Dict(get_word_to_del, None) delete.delete_word() elif get_op in ["edit", "Edit"]: get_word_to_edit = input("Word to edit : ") get_new_meaning = input("New meaning : ") mean = Dict(get_word_to_edit, get_new_meaning) mean.edit_word() elif get_op in ["view", "View"]: get_word_to_view = input("Word to view : ") view = Dict(get_word_to_view, None) view.view_word() elif get_op in ["view all", "View All", "View all"]: nothing = Dict(None, None) nothing.view_all() else: print("Invalid Input. Try again!") def end(): quit() def main(): while True: s_or_e = input("Start or End : ") if s_or_e.lower() == "start": start() print(" ") continue else: end() if __name__ == "__main__": main() ================================================ FILE: difference_testing.py ================================================ # We assume that the input always be find_difference_matching(list, list, integer) def find_difference_matching(x , y , diff = 0): res = [] for i in range(len(x)): if abs(x[i] - y[i]) == diff: res.append((x[i], y[i])) return res # Test a = [12, 10, 123, 76, 9990] b = [2, 0, 45,66, 10000] result = find_difference_matching(a, b, 10) print("Matches:") for i in result: print(" " + str(i)) ================================================ FILE: discount.py ================================================ def percToDiscount(percent , mp): discount = percent / 100 * mp return('Discount is : ' + str(discount)) print('Hello\n') print('Press Enter to exit') while(True): # I've put counting discount in a loop cause if you want to count on multiple items more = str(input('Count or End : ')) if more == 'Count': disCountPerc = float(input('Discount Percent : ')) marketPrice = float(input('Market Price : ')) print(percToDiscount(disCountPerc , marketPrice)) continue else: quit() ================================================ FILE: discountPercent.py ================================================ def iLoveDiscount(discount , mp): # mp is market price discountPerc = discount / mp * 100 return('Discount is ' + str(discountPerc) + '%') print('Hello\n') print('Press Enter to exit') while(True): # I've put counting discount in a loop cause if you want to count on multiple items more = str(input('Count or End : ')) if more == 'Count': disCount = float(input('Discount : ')) marketPrice = float(input('Market Price : ')) print(iLoveDiscount(disCount , marketPrice)) continue else: quit() ================================================ FILE: distance_on_number_line.py ================================================ # this is a simple geometric distance formula # d(x,y) = |x-y| = distance # where x and y are co-ordinates on a number line def distance(x,y): return abs(x-y) flag = True while flag: usr = str(input("start [Y/n]: ")).strip().lower() if usr == "y": print(distance(float(input("Value of X co-ordinate: ")), float(input("Value of Y co-ordinate: ")) ), "\n") else: flag = False ================================================ FILE: euclids_algorithm.py ================================================ # Recursive implementation of Euclidean algorithm def gcd(m, n): """ Calculates the greatest common divisor (GCD) of two positive integers using the Euclidean algorithm. Args: m (int): First positive integer. n (int): Second positive integer. Returns: int: The GCD of m and n. """ (a, b) = (max(m, n), min(m, n)) while b != 0: a, b = b, a % b return a ================================================ FILE: factorial.py ================================================ def factorial(n): if n == 0: return 1 else: return n * factorial(n-1) n=int(input("Input a number to compute the factiorial : ")) print(factorial(n)) ================================================ FILE: figure determiner.py ================================================ while(2==2): print("_________________________________________________") print("""Program can determine till 6 angles only. and remember if you have angles less than 6 simply enter 0""") print("_________________________________________________") get = int(input("Enter first angle:")) print("_________________________________________________") get_again = int(input("Enter second angle:")) print("_________________________________________________") get_again_again = int(input("Enter third angle:")) print("_________________________________________________") get_it = int(input("Enter fourth angle:")) print("_________________________________________________") get_it_it = int(input("Enter fifth angle:")) print("_________________________________________________") getting = int(input("Enter sixth angle:")) print("_________________________________________________") if get + get_again + get_again_again + get_it + get_it_it + getting == 180: print("The figure is Triangle or linear pair of angles") print("_________________________________________________") elif get + get_again + get_again_again + get_it + get_it_it + getting == 360: print("The figure is Quadrilateral ") elif get + get_again + get_again_again + get_it + get_it_it + getting == 540: print("The figure is Pentagon") elif get + get_again + get_again_again + get_it + get_it_it + getting == 720: print("The figure is Hexagon") feature = raw_input("Start again or End:") if feature == "Start again": print("Starting again...") print("Started again") continue elif feature == "End": print("Program Ended...") print("_________________________________________________") print(" ") break ================================================ FILE: findLcm.py ================================================ # function to find lcm of two numbers def findLcm(i,v): if i > v: x = i else: x = v while True: if (x % i == 0) and (x % v == 0): lcm = x return(x) break x = x + 1 # Main code while(True): startOrEnd = str(input('Count lcm or End : ')) if startOrEnd == 'Count lcm': getFirst = float(input('First num : ')) getSecond = float(input('Second num : ')) print(findLcm(getFirst , getSecond)) else: quit() ================================================ FILE: find_cube_root.py ================================================ # This method is called exhaustive numeration! # I am checking every possible value # that can be root of given x systematically # Kinda brute forcing def find_cube_root(x): if type(x) == str: return "Expected an integer! Cannot find cube root of an string!" for i in range(0, x): if i ** 3 == x: return i return "{} is not a perfect cube".format(x) # Test x = 27 result = find_cube_root(x) print("Cube root of {} is {}".format(x, result)) ================================================ FILE: find_roots.py ================================================ """ How it works: Thing is simple first we determine the variable in equation; Then we iterate through given range by user or default range; For each iteration we replace the variables in equation to the number; At last we return the roots found; """ from string import ascii_letters def find_variable(string): splitted = string.split() for i in splitted: if (i in ascii_letters): return i else: continue return None # Input format for function: # "z ** 2 + 97 * z + (-4)" def find_roots(S, rng = [-10000, 10000]): res = [] for v in range(rng[0], rng[1]): try: test_case = S.replace(find_variable(S), str(v)) except Exception as e: print(e) return "" if (eval(test_case) == 0): res.append(v) else: continue if (len(res) == 0): return None return res #testing """ test_str = "x ** 2 + 5 * x - 6" result = find_roots(test_str, [-10, -2]) for i in result: print("Root of the equation is {}".format(i)) """ ================================================ FILE: find_square_root.py ================================================ # This method is called exhaustive numeration! # I am checking every possible value # that can be root of given x systematically # Kinda brute forcing def find_square_root(x): if type(x) == str: return "Expected an integer! Cannot find square root of an string!" for i in range(0, (x/2 )+2): if i ** 2 == x: return i return "{} is not a perfect square".format(x) # Test x = 2 result = find_square_root(x) print("Square root of {} is {}".format(x, result)) ================================================ FILE: find_square_root_of_imperfect_square.py ================================================ # Here I've implemented a method of finding square root of imperfect square # Steps (Pseudocode): visit http://burningmath.blogspot.in/2013/12/finding-square-roots-of-numbers-that.html # Read the steps carefully or you'll not understand the program! # To check is number is a perfect square or not def is_perfect_square(n): if isinstance(n, float): return (False, None) for i in range(n + 1): if i * i == n: return (True, i) return (False, None) # Average def average(*args): hold = list(args) return sum(hold) / len(hold) # Method # Just implementation of steps on above webpage def sqrt_of_imperfect_square(a, certainty = 6): is_square = is_perfect_square(a) if is_square[0]: return "{} is a perfect square .It's root is {}.".format(a, is_square[1]) else: a = int(a) tmp = None s1 = max([float(x * x) for x in range(0,a)]) while True: s2 = a / s1 tmp = average(s1, s2) if not(round(tmp * tmp, certainty) == float(a)): s1 = tmp continue else: return tmp return -1 # This condition will normally never occur # Test case = 2613 res = sqrt_of_imperfect_square(case, 9) print("Test case: " + str(case)) print("Root: " + str(res)) print("Root Squared: " + str(res * res)) ================================================ FILE: geometric_progression_builder.py ================================================ """ Simply it just builds a geometric progression on given conditions. Iterates through t1 till n multiplies last values in list to constant append it back to list COOL! """ def build_geo_sequence(start, end, constant): temp = [start] try: for i in range(start, end): temp.append(temp[-1] * constant) except TypeError as te: print(te) except Exception as e: print(e) else: return temp # Test res = build_geo_sequence(1, 10, 3) print("Geo Sequence:") for i in res: print(" " + str(i)) # Expected -> 1, 3, 9, 27, 81, .... # Here a = 1, d = 3 ================================================ FILE: healthScore.py ================================================ # Health Calculator # func to show health score of user def healthScore(): print(' ') numberOfFruits = int(input('Number Of Fruits You Eat in Week : ')) numberOftimesFastFood = int(input('Number of Times You Eat FastFood in a Week : ')) cigars = int(input('Cigars You Smoke In A Week : ')) workoutTime = int(input('How Much minutes You Workout EveryDay : ')) bodyMassIndex = int(input('Whats Your BodyMassIndex(BMI) : ')) if 18 < bodyMassIndex < 26 : print(' ') healthScore = (numberOfFruits + workoutTime + bodyMassIndex ) - (cigars + numberOftimesFastFood) print(healthScore) else : print(' ') healthScore = (numberOfFruits + workoutTime) - (cigars + numberOftimesFastFood + bodyMassIndex ) print(healthScore) # main code while True: startOrEnd = str(input('Start or End : ')) if startOrEnd == 'Start': print(healthScore()) continue else : quit() ================================================ FILE: hello_world.py ================================================ # printing hello world is a tradition in beginners # it is normally used to if check everything is okay import sys #type 1 sys.stdout.write() sys.stdout.write("Hello, ") sys.stdout.write("World!") sys.stdout.write("\n") #type 2 print() print("Hello, World!") #type 3 - format() word1 = "Hello" word2 = "World" print("{} {}".format(word1, word2)) #type 4 - f-strings word1 = "Hello" word2 = "World" print(f"{word1} {word2} ") #type 5 - join characters = ['H','e','l','l','o',' ','W','o','r','l','d'] message = "".join(characters) print(message) #type 6 - Dict words = {"Eng_greeting": "Hello", "Eng_world": "World"} message = " ".join(words.values()) print(message) ================================================ FILE: html_source.py ================================================ # Tested in python2.7 # Getting Html text and saving it to a file. import urllib def get_html(url , fname): try: responsive = urllib.urlopen(url) save_file = open(fname + '.html' , 'w') save_file.write(responsive.read()) save_file.close() except IOError: return "Make sure url entered is correct and valid!" except Exception as e: return "An Error occured, make sure information enerted is correct!" else: return "Html Successfully received and saved in file {}.html".format(fname) # if you want to read the file uncomment this code # emp = open(name + ".html", 'r').read() # openFile.close() # return emp print('Hello,') while(True): start_or_end = str(raw_input('start or end: ')).strip().lower() if start_or_end == 'start': print(get_html(raw_input('URL: ').strip() , raw_input('file name: ').strip()), "\n") continue quit() ================================================ FILE: identity_matrix_recognizer.py ================================================ # from cs 101 course of udacity.com (problem set solved solution) # Given a list of lists representing a n * n matrix as input, # define a procedure that returns True if the input is an identity matrix # and False otherwise. # An IDENTITY matrix is a square matrix in which all the elements # on the principal/main diagonal are 1 and all the elements outside # the principal diagonal are 0. # (A square matrix is a matrix in which the number of rows # is equal to the number of columns) def is_identity_matrix(matrix): total_elems = 0 last_pos = 0 for row in matrix: total_elems += len(row) if row[last_pos] == 1 and row.count(0) == len(row) - 1: last_pos += 1 else: return False if total_elems == len(matrix[0]) * len(matrix[0]): return True else: return False # Test Cases: matrix1 = [[1,0,0,0], [0,1,0,0], [0,0,1,0], [0,0,0,1]] print is_identity_matrix(matrix1) #>>>True matrix2 = [[1,0,0], [0,1,0], [0,0,0]] print is_identity_matrix(matrix2) #>>>False matrix3 = [[2,0,0], [0,2,0], [0,0,2]] print is_identity_matrix(matrix3) #>>>False matrix4 = [[1,0,0,0], [0,1,1,0], [0,0,0,1]] print is_identity_matrix(matrix4) #>>>False matrix5 = [[1,0,0,0,0,0,0,0,0]] print is_identity_matrix(matrix5) #>>>False matrix6 = [[1,0,0,0], [0,1,0,1], [0,0,1,0], [0,0,0,1]] print is_identity_matrix(matrix6) #>>>False matrix7 = [[1, -1, 1], [0, 1, 0], [0, 0, 1]] print is_identity_matrix(matrix7) #>>>False ================================================ FILE: image_downloader.py ================================================ import random import urllib.request get = str(input("Enter url of image to download : ")) def download_image(url): name = random.randrange(1, 1000) full_name = str(name) + ".jpg" urllib.request.urlretrieve(url, full_name) print(download_image(get)) ================================================ FILE: in_the_something.py ================================================ import random # "The something in something" program noun_lib = ["cat","dog","lizard","bald","insane guy","CEO","monkey","teacher","ballerina","old man","nerd","lion","alien","elephant"] place_lib = ["in Hungary","in the toilet","in a car","in a zoo","in a lions cave","in a park","in Norway","in Rio","on Mars","on a tree","on the roof of Burj-Khalifa"] flag = True while flag: inp = str(input("\nDo you want more? [Y/n] ")) if inp.strip().lower() == "y": print("-> The" + " " + random.choice(noun_lib) + " " + random.choice(place_lib) + ".") else: flag = False ================================================ FILE: item_index.py ================================================ """Algorithm for finding index of element in an array""" def index(array, item): index = 0 found = False while (not found): if (array[index] == item): found = True else: index = index + 1 return index print index([12, 34], 34) ================================================ FILE: kay_sort.py ================================================ """ This sort is same as reverse sort by me. Except minor changes in first for loop, and comparison sign on line 11 And function is called kay_sort because kay is my nickname """ def kay_sort(array): print "Orignal List : {}".format(array) for i in range(len(array)): for n in range(len(array) - 1): a = array[n] if (a > array[i]): tem = array[i] array[i] = a array[n] = tem return "Sorted List : {}".format(array) print kay_sort([123, 4, 123, 4]) ================================================ FILE: lessThanMoreThan.py ================================================ nums = [12,34,65,43,21,97,13,57,10,32] finalNums = [] moreFinalNums = [] def compareMore(a): for x in nums: if x > a : c = finalNums.append(x) def compareLess(d): for x in nums: if x < d : c = moreFinalNums.append(x) get = int(input('To Compare More Than : ')) getAgain = int(input('To Compare Less Than : ')) print('\nMore Than Values : ') print(compareMore(get)) print(finalNums , '\n') print('\nLess Than Values : ') print(compareLess(getAgain)) print(moreFinalNums,'\n') ================================================ FILE: linear_search.py ================================================ # Linear Search or Sequential Search Algorithm def linear_search(array, to_find): pos = 0 # Starting position or index to_return = (False, 0) while (pos < len(array)): # while index is less than length of array if (array[pos] == to_find): # if array with index of var pos is equal to find to_return = (True, pos) # no need to break loop cuz return appends func return to_return else: pos = pos + 1 # if elem not found continue to next pos return to_return nums = [12, 34, 54, 88, 21] print linear_search(nums, 88) ================================================ FILE: listOperations.py ================================================ # list operations # You can create a list by putting elements inside square brackets[] # lists are capable of containing any type of data # a list can contain datas of different datatypes numsAndAlphas = ['a',1,'hello',3.14159265359,'are you okay',True,'good',False] # this is going to work print(numsAndAlphas) # list accessing # You can access single items from the list similar to string indexing # if you dont know string indexing look for my program called stringOperations.py print(numsAndAlphas[0]) print(numsAndAlphas[1:5]) print(numsAndAlphas[0:]) print(numsAndAlphas[:6]) print(numsAndAlphas[:]) print(numsAndAlphas[2:7:2]) print(numsAndAlphas[::3]) # you can add lists too... list2 = [2,9,16,25,36,49,64,81,100,144] newList = numsAndAlphas + list2 ================================================ FILE: listOperationsMethods.py ================================================ # list operations part 2 siliconValley = ['Google','Apple','Dropbox','Facebook','Cisco','Adobe','Oracle','Samsung'] print(siliconValley) # hmm seems like i forgot to add Electronic Arts in the list siliconValley # This will add the element at the end of the list siliconValley.append('Electronic Arts') print(siliconValley) # thats cool but I want my element at specific position siliconValley.insert(5, 'AMD') # 5 is the position and whatever you add after comma is element # Okay enough I want to pop out an element from list and I want to use it in a string # you have to provide the index of elementyou want to pop out poppedElement = siliconValley.pop(4) print('Popped element is ' + poppedElement) # Oops I Samsung isnt in silicon valley, I have to remove Samsung from list # How am I gonna do thats # You have to enter the element in parenthesis and not it's index siliconValley.remove('Samsung') print(siliconValley) # I want to sort the list in alphabetical order # How to do thats # simple siliconValley.sort() # or sorted(siliconValley) print(siliconValley) # I wanted list in reverse alphabetical order # simple siliconValley.sort(reverse = True) # or sorted(siliconValley , reverse = True) # seperate the reverse with comma print(siliconValley) # Okay what if i dont know about the index of an element but i want to print only that element googleIndex = siliconValley.index('Google') print(siliconValley[googleIndex]) # I am tired of watching those elements again and again # How I am going to do thats # easy del siliconValley print(siliconValley) # this should probably give you an NameError ================================================ FILE: listReverse.py ================================================ getLi = [12,43,7,43,87,89,56,9809,9878,56,78,98,True,56,76] reverseList = getLi[::-1] # [::-1] tells to step from end without difference print(reverseList) ================================================ FILE: list_comprehensions.py ================================================ list_of_even_squares = [num ** 2 for num in range(0,101,2)] print(list_of_even_squares , "\n") list_of_odd_squares = [num ** 2 for num in range(1,102,2)] print(list_of_odd_squares , "\n") list_of_even_cubes = [num ** 3 for num in range(0,101,2)] print(list_of_even_cubes , "\n") list_of_odd_cubes = [num ** 3 for num in range(1,102,2)] print(list_of_odd_cubes , "\n") ================================================ FILE: logarithm_integer.py ================================================ # Exhaustive numeration (iteration) # Simple implementation of logarithmic function # I love math! # log(b, x) <=> b ** y = x # So we have to find y! # Don't use it for decimal numbers # log(1000) or log(e, x) is not automatically avaliable def logarithm_integer(b, x): if (b > 0 and b != 1) and x > 0: for i in range(x): if b ** i == x: return i return -1 else: return "Invalid input for logarithm" # Test print("log(6, 216) -> " + str(logarithm_integer(6, 216))) print("log(5, 625) -> " + str(logarithm_integer(5, 25))) print("log(4, 16) -> " + str(logarithm_integer(4, 16))) print("log(2, 8) -> " + str(logarithm_integer(2, 8))) print("log(3, 6) -> " + str(logarithm_integer(3, 6))) print("log(0, 16) -> " + str(logarithm_integer(0, 16))) ================================================ FILE: madLibs.py ================================================ # my code may not work with python 3.5 cause it is made for 2.7 version libs =["Dragon Freak","Excuses"] # precode def dragonFreak(): colorDrag = raw_input("Color : ") superLatDrag = raw_input("Superlative (ending in est) : ") adj1Drag = raw_input("Adjective : ") bodyDragPlu = raw_input("Body Part Plural : ") bodyDrag = raw_input("Body Part : ") nounDrag = raw_input("Noun : ") animalDrag = raw_input("Animal(Plural) : ") adj2Drag = raw_input("Adjective : ") adj3Drag = raw_input("Adjective : ") adj4Drag = raw_input("Adjective : ") # creating madlib fMadLib = ''' The %s Dragon is the %s Dragon of all. It has %s %s, and a %s shaped like a %s. It loves to eat %s, although it will feast on nearly anything. It is %s and %s. You must be %s around it, or you may end up as it`s meal! '''%(colorDrag , superLatDrag , adj1Drag , bodyDragPlu , bodyDrag , nounDrag , animalDrag , adj2Drag , adj3Drag , adj4Drag) print(fMadLib) def excuses(): place = raw_input("Place : ") adjExcuse = raw_input("Adjective : ") bodyPart = raw_input("Bodypart : ") fMadLib = ''' I cannot come to %s , because there is %s %s flu ''' %(place , adjExcuse , bodyPart) print(fMadLib) # main code for user interaction while True: startOrEnd = raw_input("Start or End : ") if startOrEnd.strip() == "Start": print(libs) whichLib = raw_input("Which one :") if whichLib.strip() == "Dragon Freak": print(dragonFreak()) continue elif whichLib.strip() == "Excuse": print(excuses()) continue else : print("Not avaliable") continue elif startOrEnd.strip() == "End": print("Progarm Ended...") break ================================================ FILE: magicball_8.py ================================================ import random def magic(): input("Ask me a question . Try me: ") return random.choice([ "It is certain" , "Outlook good" , "You may rely on it" , "Ask again later" , "Concentrate and ask again" , "Reply hazy, try again" , "My reply is no" , "My sources say no" ]) # main Sector print("Hello,") while True: if input("start or end: ").strip().lower() == "start": print(magic(), "\n") continue else: quit() ================================================ FILE: map_example.py ================================================ # Contribution by https://github.com/tyadav4268 #This is to demonstrate the use of map function in python #Problem Statement: Using the function Map, count the number of words that start with ‘S’ in input_list. #Sample Input: ['Santa Cruz','Santa fe','Mumbai','Delhi'] #Sample Output: 2 #Solution: input_list = ['Santa Cruz','Santa fe','Mumbai','Delhi'] count = sum(map(lambda x: x[0] == 'S', input_list)) print(count) # Output: 2 ================================================ FILE: math/Binary_to_decimal ================================================ # binary_to_decimal.py # # Description: A program to evaluate binary to decimal. # # Author: Chaitanya Mittal # Date: 2023-11-17 10:14:20.288913 """Idea: - def a function to decode 1 byte: - get the list - get value by multiplying each element with 2** its index from reverse (pattern observation) .... (instead of this we can multiply index to list reversed)...... - return the sum of value - get input - split it to get rid of spaces (assume user is well behaved and will enter 1-space separated string only) - convert each byte and compile result in a list - print the converted bytes separated by space """ def byte_decode(binary): # Convert binary string to list lst = list(binary)[::-1] # Initialize variables length = len(binary) sum = 0 # Loop through each character in the binary string for i in range(length): # Calculate value of each bit value = int(lst[i]) * (2 ** i) # Add value to the sum sum += value # Return the final sum return sum # ____ Main Program ____ # # Get input of the required binary string binary = input("Binary: ").split(" ") """ TESTING PURPOSES string = ("01010101 01101110 01100100 01100101 0110010 00100000 01011001 01101111 01110101 01110010 00100000 01010011 01100101 01100001 01110100").split() binary = list(string)""" # Initialize an empty list to store 'evaluated' bytes bytes_translated = list() #translate the byte and append it to the list for byte in binary: bytes_translated.append(byte_decode(byte)) # Print the output print(f'Evaluated: ', end = "") for byte in bytes_translated: print(byte, end = " ") print() ================================================ FILE: math/FreefallCalculator ================================================ # Gravity Simulation import math import numpy as np # Welcome print("Welcome to a 1D Free Fall Simulation. Please enter only in metric integers. ") print("You will enter the amount of time you want to simulate, it includes information about impact, \n" "even if the simulation stops before impact.") # Constants g = 9.81 # Variables height = int(input("Drop Height: ")) timeElapsed = 1 runTime = int(input("How long do you want to record data from the fall? ")) location = 0 mass = int((input("Mass: "))) timeToImpact = 0 # Simulation print("Second by second info of free fall in given time.") while timeElapsed <= runTime and timeToImpact >= 0 and location >= 0: # Equations distanceTraveled = (g * timeElapsed ** 2) / 2 velocity = distanceTraveled / timeElapsed location = height - distanceTraveled momentum = mass * velocity timeToImpact = math.sqrt((2 * height) / g) # Print Stats print("\nTime to simulation end: " + str(runTime - timeElapsed)) print('Y Location: ' + str(location) + 'M') print('Velocity: ' + str(velocity) + 'M/S') print('Distance Traveled: ' + str(distanceTraveled) + 'M') print('Momentum: ' + str(momentum) + 'N') print('Time Elapsed: ' + str(timeElapsed)) print('Rough time to impact: ' + str(timeToImpact - timeElapsed)) print() # Add to time elapsed timeElapsed = timeElapsed + 1 # Print impact results print("\n The Simulation is done. \n") print("*This is printed even if the object fell past the ground, or never hit it.* \n Info on impact: ") print('Y Location: 0M') print('Velocity: ' + str(height / runTime) + 'M/S') print('Distance Traveled: ' + str(height) + 'M') print('Momentum: ' + str(mass * (height / runTime)) + 'N') print('Time Spent in free fall: ' + str(timeToImpact)) print() ================================================ FILE: math/README.md ================================================
'math' Sub-directory contains all the math related scripts This dir does not contain mathematical algorithms, only math related scriptsThe programs have been re-checked and re-mastered by me!
Although i've tried to keep it as orignal as possible.
Keep Patience It'll take time to go through every program!!
Thanks ================================================ FILE: math/aircraft_thrust.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- import math # Calculating thrust of Aircraft Propeller def thrust_props(diameter , velocity , velocity1 , density): # According to formula return math.pi / 4 * diameter ** 2 * (velocity + velocity1/2) * density * velocity1 print('Hello Aircraft Lovers,\n') while(True): # Loop for continous calculation start_or_end = str(raw_input('start or end : ')).strip().lower() # Main interface if start_or_end == 'start': res = thrust_props(float(input('\nDiameter of propeller: ')) , float(input('Velocity of air flow: ')) , float(input('Additional propeller acceleration, velocity: ')) , float(input('Fluid density: '))) print("\nThrust of propeller: {}".format(res)) else: quit() print("") # found formula on nasa's website ================================================ FILE: math/area_volume_calculator.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- import math import sys # Perimeter # or sum of span of all sides of figure # perimeter of square f(s) = 4 * s # where s is the side of square peri_of_square = lambda s: 4 * s # perimeter of rectangle, f(L, W) = 2 * (L + W) or 2L + 2W # where L is length, and W is width(breadth) of rectangle peri_of_rectangle = lambda l, w: 2 * (l + w) # perimeter of triangle, f(s1, s2, s3) = s1 + s2 + s3 # where s1, s2, s3, are the sides of a regular triangle peri_of_triangle = lambda s1, s2, s3: s1 + s2 + s3 # peri of right angled triangle, f(a, b) = a + b + square_root(a ** 2 + b ** 2) # since, by pythagoras theoram, # a ** 2 + b ** 2 = c ** 2 or a squared + b squared = c squared peri_of_rt_triangle = lambda a, b: a + b + math.sqrt(a ** 2 + b ** 2) # perimeter of circle(or circumference), f(r) = 2 * r * pi # or f(d) = d * pi, where r is radius, pi is pi ratio(3.14159......), # d is diameter peri_of_circle = lambda r: 2 * r * math.pi peri_of_circle1 = lambda d: d * math.pi # Areas # or surface area of figure # how many lengths into widths and vice versa # area of square, f(s) = s * s or (s)squared or s ** 2 # where s is the side of square, s is same as both # length and width of square area_of_square = lambda s: s ** 2 # area of rectangle, f(L, W) = L * W # or length multiplied by width(breadth) area_of_rectangle = lambda l, w: l * w # area of triangle, f(b, h) = b * h / 2 # where, b is base, and h is the height of triangle # see: explaination of area of triangle # here: area_of_triangle = lambda b, h: (b * h) / 2 # Heron's formula # see for more info: https://en.wikipedia.org/wiki/Heron%27s_formula area_of_triangle1 = lambda a, b, c: math.sqrt((a+b+c)/2 * ((a+b+c)/2 - a) ((a+b+c)/2 - b) ((a+b+c)/2 - c)) # area of parallelogram, f(b, h) = b * h # where b is base, h is height of parallelogram area_of_parallelogram = lambda b, h: b * h # area of trapezoid(trapezium), f(b1, b2, h) (b1 + b2) / 2 * h # where, b1 is base 1, b2 is base 2, and h is height area_of_trapezoid = lambda b1, b2, h: (b1 + b2) / 2 * h # area of circle, f(r) = pi * r ** 2 # where r is radius, pi is math constant of pi(C/D) # see explaination of formula: # http://pythagoreanmath.com/complete-explanation-for-area-of-a-circle-formula/ area_of_circle = lambda r: math.pi * r ** 2 # Terminal UI i = 0 while True: if raw_input("\n[{}] Exit(press e), Continue(press c): ".format(i)).lower() == "c": which_fig = raw_input("\nSquare(s), Rectangle(r), Triangle(t), right(|_)led triangle(rt), Parallelogram(pa), Cricle(ci), Trapezoid(tr): ").lower() if which_fig == "s": if raw_input("\nArea(press a) or Perimeter(press p): ").lower() == "a": print("\tArea of square: " + str(area_of_square(float(raw_input("Side of square: "))))) else: print("\tPerimeter of square: " + str(peri_of_square(float(raw_input("Side: "))))) elif which_fig == "r": if raw_input("\nArea(press a) or Perimeter(press p): ").lower() == "a": print("\tArea of rectangle: " + str(area_of_rectangle(float(raw_input("Length: ")), float(raw_input("Width: "))))) else: print("\tPerimeter of rectangle: " + str(peri_of_rectangle(float(raw_input("Length: ")), float(raw_input("Width: "))))) elif which_fig == "t": if raw_input("\nArea(press a) or Perimeter(press p): ").lower() == "a": if raw_input("\nBy Heron's Formula[y/n]: ").lower() == "y": print("\tArea of triangle(Heron's Formula): " + str(area_of_triangle1(float(raw_input("A: ")), float(raw_input("B: ")), float(raw_input("C: "))))) else: print("\tArea of triangle: " + str(area_of_triangle(float(raw_input("Base: ")), float(raw_input("Height: "))))) else: print("\tPerimeter of triangle: " + str(peri_of_triangle(float(raw_input("A: ")), float(raw_input("B: ")), float(raw_input("C: "))))) elif which_fig == "rt": if raw_input("\nArea(press a) or Perimeter(press p): ").lower() == "a": print("\tArea of triangle: " + str(area_of_triangle(float(raw_input("Base: ")), float(raw_input("Height: "))))) else: print("\tPerimeter or right angled triangle: " + str(peri_of_rt_triangle(float(raw_input("A: ")), float(raw_input("B: "))))) elif which_fig == "pa": if raw_input("\nArea(press a) or Perimeter(press p): ").lower() == "a": print("\tArea of parallelogram: " + str(area_of_parallelogram(float(raw_input("Base: ")), float(raw_input("Height: "))))) else: print("\tPerimeter of parallelogram: " + str(peri_of_rectangle(float(raw_input("Length: ")), float(raw_input("Width: "))))) elif which_fig == "tr": if raw_input("\nArea(press a) or Perimeter(press p): ").lower() == "a": print("\tArea of trapezoid: " + str(area_of_trapezoid(float(raw_input("Base 1: ")), float(raw_input("Base 2: ")), float(raw_input("Height: "))))) else: print("\tPerimeter of trapezoid: " + str(peri_of_triangle(float(raw_input("Side1: ")), float(raw_input("Side4: ")), float(raw_input("Side3: "))) + float(raw_input("Side1: ")))) elif which_fig == "c": if raw_input("\nArea(press a) or Perimeter(press p): ").lower() == "a": print("\tArea of circle: " + str(area_of_circle(float(raw_input("Radius: "))))) else: if raw_input("\nUsing Radius(r) or Diameter(d): ").lower() == "r": print("\tCircumference of circle: " + str(peri_of_circle(float(raw_input("Radius: "))))) else: print("\tCircumference of circle: " + str(peri_of_circle1(float(raw_input("Diameter: "))))) i += 1 else: sys.exit() ================================================ FILE: math/arithmetic_progression_builder.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # Arithmetic progressions # are special types of sets(more of a series) # where the difference between every consecutive # numbers of series is constant or common # for more refer: https://en.wikipedia.org/wiki/Arithmetic_progression # formula for general term of arithmetic prog. # tn = a + (n - 1) * d # where, # tn -> is the n(th) term, # a -> if the first term, # d -> is the common difference # Third param 'n_last' refers to limit or length or index of last term def arithmetic_p_sequence_builder(a, d, n_last): # To generate an A.P. length should be # greater than or equal to 1 if n_last < 1: return -1 seq = [] # Every item is obtained by # applying the general term formula for n in range(1, n_last + 1): seq.append(a + (n - 1) * d) return seq # Test print("Arithmetic progression: {}".format(arithmetic_p_sequence_builder(int(raw_input("A(a, first term): ")), int(raw_input("D(d, common difference): ")), int(raw_input("N(n, length): "))))) # Although big line, but works just fine! ================================================ FILE: math/calculator.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- import sys # Functions to apply basic arithmetic # operations on 2 numbers # Each func, takes 2 numbers as input add = lambda a, b: a + b subtract = lambda a, b: a - b multiply = lambda a, b: a * b divide = lambda a, b: a / b modulus = lambda a, b: a % b # CLI # Testing/Playing Interface i = 0 while True: if raw_input("\n\n[{}] Exit(press e) or Calculate(press c): ".format(i)) == "c": op = raw_input("\nAdd(press a), Subtract(press s), Multiply(press m),\nDivide(press d), Modulus(press mo): ").strip().lower() if op == "a": print(" Sum: " + str(add(float(raw_input("\nN1: ")), float(raw_input("N2: "))))) elif op == "s": print(" Subtracted: " + str(subtract(float(raw_input("\nN1: ")), float(raw_input("N2: "))))) elif op == "m": print(" Multiplied: " + str(multiply(float(raw_input("\nN1: ")), float(raw_input("N2: "))))) elif op == "d": print(" Divided: " + str(divide(float(raw_input("\nN1: ")), float(raw_input("N2: "))))) else: print(" Modulus: " + str(modulus(float(raw_input("\nN1: ")), float(raw_input("N2: "))))) i += 1 else: print("\nHope you enjoyed!") sys.exit() ================================================ FILE: math/decimal_to_binary_converter.py ================================================ """ I came up with this algorithm to convert decimal(natural numbers only xd) to binary completely from scratch and therefore it might not be the best most efficient implementation. Optimizations are welcome. """ def dec_to_bin(n): quo = n binary = 0 while (quo>0): tmp = quo pows = 0 while (quo > 1): quo = quo // 2 pows = pows + 1 quo = tmp-pow(2,pows) binary = binary+pow(10,pows) return binary for i in range(0,101): print("Natural Number:"+str(i)+" Binary:"+str(dec_to_bin(i))) ================================================ FILE: math/eulers_python.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # By formula derived by Euler(A great mathematician) print("Euler's Formula: F(faces) + V(vertices) = E(Edges)+2\n") # Further derivation print("Derivation 1: E(Edges) = F(faces)+V(vertices) - 2") print("Derivation 2: V(vertices) = E(edges)+2 - F(Faces)") print("Derivation 3: F(faces) = E(edges)+2 - V(vertices)") # By order of operations, parenthesis can be added # for ensuring, but not needed def E(f, v): return f+v - 2 def V(e, f): return e+2 - f def F(e, v): return e+2 - v # function to evaluate # By default datatype of raw_input() is string user = raw_input("\nE, V or F: ").upper() print(" ") # evaluating function asked by user if user == "E": print("\nEdges: " + str(E(input("Faces: "), input("Vertices: ")))) elif user == "V": print("\nVertices: " + str(V(input("Edges: "), input("Faces: ")))) elif user == "F": print("\nFaces: " + str(F(input("Edges: "), input("Vertices: ")))) else: print("Invalid Input, Try again!") # A while loop can be added # to perform multiple calculations ================================================ FILE: math/geoMean.py ================================================ # Add path, encoding import math # Geometric Mean: # Calculates the geometric mean of # two numbers # formula: f(x, y) = square_root(x*y) geoMean = lambda x, y: math.sqrt(x*y) while True: if input("Start [Y/n]? ").strip().lower() == "y": print(" [Res] = " + str(geoMean(float(input("\nX? ")), float(input("Y? ")))) + "\n\n") else: print("\n\nGoodBye!") break ================================================ FILE: math/number_lesser_greater.py ================================================ import sys # Use of # Conditionals in python # Determines weather the number is positive negative or zero def pos_neg_zero(x): if x < 0: return "Negative" elif x > 0: return "Positive" return "Zero" while True: if str(raw_input(" Start [Y/n]? ")).strip().lower()== "y": print(" [Num] = " + pos_neg_zero(float(raw_input(" Number: "))) + "\n") else: print("Bye!") sys.exit(0) ================================================ FILE: mathoperators.py ================================================ # maths sucks make it cool with python # math operators # INTEGERS # integers are whole numbers positive or negative # + operator adds numbers add = 24 + 1004 # - operator subtracts second number from First subtract = 546 - 132 # * multiplies numbers multiply = 90 * 4 # / divides numbers divide = 36/6 # returns the remainder of the division modulo = 17 % 3 # FLOAT # floats are decimal point numbers positive or negative addFloat = 24.5 + 1004.005 subtractFloat = 546.90 - 132.56 multiplyFloat = 90.0 * 4.2 divideFloat = 36.6 / 6.6 moduloFloat = 17.0 % 3.0 # all operators work same on both floats or integers ================================================ FILE: max_by_alphabetical_order.py ================================================ import string def lower_(arr): """ For conversion of every element in list to lower """ for i in range(len(arr)): arr[i] = arr[i].lower() def max_alphabetical_order(s): """ Useful on lists containing strings that start from alphabets, because the algorithm is written for it in the first place! """ copy = s[:] useful = list(string.ascii_lowercase) lower_(s) res = s[0] for word in s[1:]: tmp = word[0] if useful.index(tmp) > useful.index(res[0]): res = word return copy[s.index(res)] # Test case1 = ["Alpha", "Beta", "Gist", "exotic", "hells kitchen", "word", "Ultra", "zip"] call = max_alphabetical_order(case1) print("Max element in list by alphabet order:\n" + call) ================================================ FILE: max_int_in_list.py ================================================ def compare(li): res = 0 for i in range(len(li) - 1): a = li[i] b = li[i + 1] if (a > b): if (a > res): res = a else: if (b > res): res = b return res def convert(): get_input = raw_input("Enter Space Seperated Numbers : ") raw = get_input.split() nums = [] for i in raw: nums.append(float(i)) return nums if __name__ == "__main__": print compare(convert()) ================================================ FILE: min_by_alphabetical_order.py ================================================ import string def lower_(arr): """ For conversion of every element in list to lower """ for i in range(len(arr)): arr[i] = arr[i].lower() def min_alphabetical_order(s): """ Useful on lists containing strings that start from alphabets, because the algorithm is written for it in the first place! """ copy = s[:] useful = list(string.ascii_lowercase) lower_(s) res = s[0] for word in s[1:]: tmp = word[0] if useful.index(tmp) < useful.index(res[0]): res = word return copy[s.index(res)] # Test case1 = ["Alpha", "Beta", "Gist", "exotic", "hells kitchen", "word", "Ultra", "zip"] call = min_alphabetical_order(case1) print("Max element in list by alphabet order:\n" + call) ================================================ FILE: min_int_in_list.py ================================================ def compare(li): if (len(li) == 1): return "Single Value To Compare {} in List".format(li[0]) res = 0 for i in range(len(li) - 1): a = li[i] b = li[i + 1] if (a < b): if (i != 0): if (a < res): res = a else: res = a else: if (i != 0): if (b < res): res = b else: res = b return res def convert(): get_input = raw_input("Enter Space Seperated Numbers : ") raw = get_input.split() nums = [] for i in raw: nums.append(float(i)) return nums if __name__ == "__main__": print compare(convert()) ================================================ FILE: mod_example.py ================================================ import random import urllib.request def downloadImage(url): filename = str(random.randrange(1,1000)) download = urllib.request.urlretrieve(url, filename) downloadImage() ================================================ FILE: modified_selection_sort.py ================================================ """ My Modified Solution to Selection Sort Algorithm, instead of swapping elem it is appended to another temporary array. This makes algotrihm less complicated. """ def selection_sort(array): temp_num = len(array) temp_arr = [] while (len(temp_arr) != temp_num): a = min(array) temp_arr.append(a) del array[array.index(a)] return temp_arr # Test test_case = [100, 99, 98, 97, 96, 95, 94, 93, 92, 91, 90] print("By Builtin method: {}".format(sorted(test_case))) print("By SelectionSort method: {}".format(selection_sort(test_case))) ================================================ FILE: morse_code_decoder.py ================================================ def decodeMorse(morseCode): # ToDo: Accept dots, dashes and spaces, return human-readable message morse_code = {".-" : "A", "-..." : "B", "-.-." : "C", "-.." : "D", "." : "E", "..-." : "F", "--." : "G", "...." : "H", ".." : "I", ".---" : "J", "-.-" : "K", ".-.." : "L", "--" : "M", "-." : "N", "---" : "O", ".--." : "P", "--.-" : "Q", ".-." : "R", "..." : "S", "-" : "T", "..-" : "U", "...-" : "V", ".--" : "W", "-..-" : "V", "-.--" : "Y", "--.." : "Z", ".----" : "1", "..---" : "2", "...--" : "3", "....-" : "4", "....." : "5", "-...." : "6", "--..." : "7", "---.." : "8", "----." : "9", "-----" : "0", "SPACE" : " "} morseCode.strip() new = morseCode.replace(" ", " SPACE ") prep = new.split() res = "" li = list(morse_code.keys()) for n in prep: elif n in li: res = res + morse_code[n] else: pass return res.strip() ================================================ FILE: multiplicationTables.py ================================================ # Multiplication Table viewer while True: startOrEnd = str(input('Start or End : ')) if startOrEnd == 'Start': whichTable = int(input('Which Table : ')) for x in range(1, 13): table = whichTable * x print(table) continue else : print('Program Ended...') break ================================================ FILE: my_name.py ================================================ # Example of accessing elements in list inside = list("abcdefghijklmnopqrs tuvwyxyz") print (inside[10] + inside[0] + inside[11] + inside[15] + inside[0] + inside[10] + inside[19] + inside[20] + inside[0] + inside[10] + inside[4]) ================================================ FILE: nearest_square_and_its_root.py ================================================ # Find the nearest root and its square def nearest_square(n): i = 0 found = False while (not found): if i ** 2 <= n < ((i + 1) ** 2): found = True else: i += 1 return (i, i ** 2) # Test case = 40 res = nearest_square(case) print("Nearest square to {}: \n{}".format(case, res[1])) ================================================ FILE: network/are_you_connected_to_world.py ================================================ import os import sys import webbrowser from time import sleep as sleep_sheep # Executing ping with input host # using systems functionality (only linux) def ping(host): instr = "ping -c 1 %s" %(host) response = os.system(instr) return response == 0 # Finite state loop if # computer re-connects to network # else will run till re-conn def you_cant_be_dead(host): if (not ping(host)): # Status update print(" [.] Status -> Not connected to network") print(" / CONSTANTLY Re-CHECKING CONNECTIVITY... /") while (True): if not ping(host): continue else: break # Connectivity is checked # every 7 secs sleep_sheep(7) return True def exit_(status): if (status == 0 or status == 1): print("\n ~ See you soon!") sys.exit(status) else: return None # User # Shell Interface while True: if raw_input("\nStart [Y/n]? ").strip().lower() == "y": inp = raw_input("URI (alive) HOST: ").strip() print("\n > CHECKING CONNECTION...\n > Host -> %s\n" % inp) if you_cant_be_dead(inp): # When connected to internet # Status update, and proof of connection print("\n [.] Status -> CONNECTED to network") webbrowser.open("https://www.youtube.com/watch?v=JbjIH5pvT5A") exit_(0) else: exit_(0) ================================================ FILE: newOnContacts.py ================================================ # pre code # main list of contacts contacts = {} # funcs of pre code # func to add new contact def newContact(): while True: newContact = raw_input("Name for new Contact : ") numForNewContact = raw_input("Number for Contact : ") add = raw_input("Add or Try again :") if add.strip() == "Add": contacts[newContact] = numForNewContact print("Contact Successfully added.") break elif add.strip() == "Try again": continue else : print("Invalid Input.try again") continue startAgain = raw_input("Add more or continue : ") if startAgain.strip() == "Add more": print(" ") continue elif startAgain.strip() == "continue": print(" ") break # func to search for a contact def searchContact(): while True: search = raw_input("Search for contact : ") toShow = str(search) + contacts[search] print(toShow) startAgain = raw_input("Search more or continue : ") if startAgain.strip() == "Search more": print(" ") continue elif startAgain.strip() == "continue": print(" ") break # func to edit a contact def editContact(): while True: whichToEdit = raw_input("Name of Contact of which Number to Edit : ") contacts[whichToEdit] = raw_input("Number to add : ") startAgain = raw_input("Edit more or continue : ") if startAgain.strip() == "Edit more": print(" ") continue elif startAgain.strip() == "continue": print(" ") break # main code to interact while True: print("hello,".title()) # part of main code to start or end startOrEnd = raw_input("Start or End : ") if startOrEnd.strip() == "Start": # part of main code to control functions addSearchEdit = raw_input("Add or Search or Edit : ") if addSearchEdit.strip() == "Add": print(newContact()) elif addSearchEdit.strip() == "Search": print(searchContact()) elif addSearchEdit.strip() == "Edit": print(editContact()) else : print("Invalid Input . Try Again") continue elif startOrEnd.strip() == "End": print("Ending...") break else : print("Invalid Input . Try Again") continue # part of main code to start again or end startAgain = raw_input("Start again or End : ") if startAgain.strip() == "Start again": print("Starting again...") continue elif startAgain.strip() == "End": print("Ending program...") break else : break ================================================ FILE: non_multiples.py ================================================ number_to_check = int(input("Number : ")) till_where = int(input("Till where to check : ")) list_of_non_multiples = [] for num in range(0, till_where + 1): if num % number_to_check != 0: list_of_non_multiples.append(num) print(list_of_non_multiples) # or you can do # this print(" ") for element in list_of_non_multiples: print(element) ================================================ FILE: ordered_binary_search.py ================================================ def binary_search(array, n): arr = sorted(array) to_return = False first_elem = 0 last_elem = len(arr) - 1 while (first_elem <= last_elem): mid = (first_elem + last_elem) // 2 if (arr[mid] == n): to_return = True break else: if (n > arr[mid]): first_elem = mid + 1 else: last_elem = mid - 1 return to_return def Ordered_binary_search(arra, elem): if (len(arra) == 0): return False middle = len(arra) // 2 if (arra[middle] == elem): return True else: if (elem > arra[middle]): return binary_search(arra[middle:], elem) else: return binary_search(arra[:middle], elem) nums = [0,23,54,5,32,78] print Ordered_binary_search(nums, 32) print Ordered_binary_search(nums, 5) ================================================ FILE: otherAngle.py ================================================ def complementary(): while(True): complementary = float(input('Complementary of : ')) if complementary <= 90: complement = 90 - complementary return(complement) break else: print('Number greater than 90 degree. Try again') continue def supplementary(): while(True): supplementary = float(input('Supplementary of : ')) if supplementary <= 180: supplement = 180 - supplementary return(supplement) break else: print('Number greater than 180 degree. Try again') continue while(True): countOrEnd = str(input('Count or End : ')) if countOrEnd.strip() == 'Count': print('\nSupp for supplementary\nComp for complementary') getSuppOrCom = str(input('Supp or Comp : ')) if getSuppOrCom.strip() == 'Supp': print(supplementary()) continue elif getSuppOrCom.strip() == 'Comp': print(complementary()) continue else: break else: quit() ================================================ FILE: password_creator.py ================================================ """ Why to create strong password? Because it makes the chances of hackers bruteforcing your password to almost 0% Simply to not get hacked! """ import random import string # Password level is Strong! # Creates a alphanumeric password of `n` chars def create_password(n): allChars = list(string.ascii_letters) + list(string.digits) + list(string.punctuation) passphrase = [] for i in range(n): tmp = random.choice(allChars) passphrase.append(tmp) res = "".join(passphrase) return res # Test 1 test1 = create_password(16) print(test1) # Test 2 test2 = create_password(32) print(test2) ================================================ FILE: percentageCalc.py ================================================ # Percentage Calculator def percentToOrig(): whatPercent = float(input('What Percent : ')) ofWhat = float(input('Of What Percent : ')) orignal = whatPercent / 100 * ofWhat print(orignal) print(percentToOrig()) ================================================ FILE: percentage_increase_decrease.py ================================================ # Percantage Increase , Percentage Decrease def increasePercent(increase , origValue): return(str(increase / origValue * 100) + '%') def decreasePercent(decrease , origValue): return(str(decrease / origValue * 100) + '%') print('Hello,\nPress Enter To Exit') incOrDec = str(input('increase or decrease: ')).strip().lower() if incOrDec == 'increase': print(increasePercent(float(input('Increased Value : ')) , float(input('Orignal Value : ')))) elif incOrDec == 'decrease': print(increasePercent(float(input('Increased Value : ')), float(input('Orignal Value : ')))) else: quit() ================================================ FILE: physics.py ================================================ # physics calcy operations = [ "Preassure" , "Force" , "Speed" , "Velocity" , "Accelaration" , "Momentum" ] #pre code sector I # preassure function to calculate preassure def preassure(): print(" ") force = int(raw_input("Enter force : ")) print(" ") area = int(raw_input("Enter area : ")) preassure = force / area print(" ") print("Preassure is " + str(preassure) + "pascal") # force function to calculate force def force(): print(" ") mass = int(raw_input("Enter mass : ")) print(" ") accelaration = int(raw_input("Enter accelaration : ")) force = mass * accelaration print(" ") print("Force is " + str(force) + "newton") # speed func to calculate speed of object def speed(): print(" ") distance = int(raw_input("Enter distance : ")) print(" ") time = int(raw_input("Enter time taken : ")) speed = distance / time print(" ") print("Speed of object is " + str(speed)) # velocity func to calculate velocity of object def velocity(): print(" ") displacement = int(raw_input("Enter displacement : ")) print(" ") time = int(raw_input("Enter time taken : ")) velocity = displacement / time print(" ") print("Velocity of object is " + str(velocity)) # accelaration func to calculate accelaration def accelaration(): print(" ") initialV = int(raw_input("Enter initial velocity : ")) print(" ") finalV = int(raw_input("Enter final velocity : ")) print(" ") time = int(raw_input("Enter time taken : ")) acce = (finalV - initialV) / time print(" ") print("Accelaration is " + str(acce) + "m/s sq.") # monentum func to calculate momentum def moment(): print(" ") mass = int(raw_input("Enter mass : ")) print(" ") velocity = int(raw_input("Enter velocity : ")) print(" ") momentum = mass * velocity print(" ") print("Momentum is " + str(momentum)) # CLI code sector II while True: print(" ") print("Hello") print(" ") startOrEnd = raw_input("Start or End : ") print(" ") if startOrEnd.strip() == "Start" : for op in operations: print(op) print(" ") main = raw_input("Which operation : ") if main.strip() == "Preassure": print(preassure()) continue elif main.strip() == "Force": print(force()) continue elif main.strip() == "Speed": print(speed()) continue elif main.strip() == "Velocity": print(velocity()) continue elif main.strip() == "Accelaration": print(accelaration()) continue elif main.strip() == "Momentum": print(moment()) continue else : print("Invalid operation") continue elif startOrEnd.strip() == "End": print("...Progarm Ended...") break ================================================ FILE: pigLatin.py ================================================ # Pig Latin Word Altering Game # function to convert word in pig latin form def alterWords(): wordToAlter = str(input('Word To Translate : ')) alteredWord = wordToAlter[1:] + wordToAlter[0:2] + 'y' # translating word to pig latin if len(wordToAlter) < 46 : print(alteredWord) else : print('Too Big . Biggest Word in English Contains 45 characters.') # main interaction code while True: startOrEnd = str(input('Start or End : ')) if startOrEnd == 'Start': print(' ') print(alterWords()) continue else : quit() ================================================ FILE: piggyBank.py ================================================ # piggy bank # pre code money = 0 # function to add money to current amount def addMoney(): print(" ") userAdd = float(raw_input("Add money : ")) print(" ") money = money + userAdd print("After adding current Money you have is " + str(money) + " rupees") # function to withdraw money from current amount def withdrawMoney(): print(" ") userWithdraw = float(raw_input("Add money : ")) print(" ") money = money + userWithdraw print("After adding current Money you have is " + str(money) + " rupees") # function to display current amount def currentMoney(): print(" ") current = "Current money you have is " + str(money) + " rupees" # main code print(" ") print("--------------------Start-------------------") while True: print(" ") user = raw_input("Start or End : ") if user.strip() == "Start": controlPiggy = raw_input("Add Withdraw or Check : ") if controlPiggy.strip() == "Add": print(addMoney()) continue elif controlPiggy.strip() == "Withdraw": print(withdrawMoney()) continue elif controlPiggy.strip() == "Check": print(currentMoney()) continue else : print(" ") print("Invalid Input.Try again") continue elif user.strip() == "End" : print(" ") print("------------Program Ended-----------") print(" ") break else : print(" ") print("Invalid Input. Try again") continue ================================================ FILE: ping_host.py ================================================ import os import platform as plt def ping_host(host_name): ping_str = "-c 1" if plt.system().lower() == "Windows": ping_str = "-n 1" ping = "ping " + ping_str + " " + host_name resp = os.system(ping) return resp == 0 # Test test_host = "www.google.co.in" result = ping_host(test_host) if result: print("\nStatus ({}): Is Alive".format(test_host)) else: print("\nStatus ({}): Is Dead".format(test_host)) ================================================ FILE: primeNumbers.py ================================================ # Prime number Determiner # replace input() with raw_input() in Python version 2.7 input() works with version 3 import math as Math POSITIVE_MESSAGE = " is a prime number" NEGATIVE_MESSAGE = " is not a prime number" def is_number_prime(number): """ Function which checks whether the number is a prime number or not :param number: integer - to be checked for prime-ness :return: boolean - true if prime, else false """ """ This is the main logic behind reducing the numbers to check for as factors if N = a * b; where a<=b and a,b C (1, N) then, a * b >= a*a; which leads to => a*a <= N => a <= sqrt(N) Hence checking only till the square root of N """ upper_lim = Math.floor(Math.sqrt(number)) + 1 is_prime = True if number != 1 else False for i in range(2, upper_lim): if number % i == 0: is_prime = False break # The moment there is a divisor of 'number', break the iteration, as the number is not prime return is_prime while True: startOrEnd = str(input('Start or End : ')) if startOrEnd == 'Start': number = int(input('Number to Check : ')) result = str(number) prime_status = is_number_prime(number) if prime_status: result += POSITIVE_MESSAGE else: result += NEGATIVE_MESSAGE print(result) else: print('Program Ended...') break ================================================ FILE: profitLoss.py ================================================ # Profit Loss Calculator def profit(sellP , costP): profit = sellP - costP return(profit) # Function for calculating profit def loss(costP , sellP): loss = costP - sellP return(loss) # Function for calculating loss def profitPercent(prof , costP): profitPerc = prof / costP * 100 return(str(profitPerc) + '%') # func to calculate profit percent def lossPercent(loss , costP): lossPerc = loss / costP * 100 return(str(lossPerc) + '%') # Func to calculate loss percent print('Hello\n') print('Press Enter To Exit') while(True): google = str(input('Profit or Loss : ')) if google.strip() == 'Profit': # condition for profit sellPrice = float(input('Selling Price : ')) # getting selling price costPrice = float(input('Cost Price : ')) # getting costprice if sellPrice > costPrice: # if selling price is greater than cp print('Profit : ' + str(profit(sellPrice , costPrice))) print('Profit Percent : ' + str(profitPercent(profit(sellPrice , costPrice) , costPrice))) continue else: # else if sp is less than cp so it is loss print('Cost Price is Greater Than Selling Price') print('Try calculating loss\n') continue elif google.strip() == 'Loss': costPrice = float(input('Cost Price : ')) sellPrice = float(input('Selling Price : ')) if costPrice > sellPrice: print('Loss : ' + str(loss(costPrice , sellPrice))) print('Loss Percent : ' + str(lossPercent(loss(costPrice , sellPrice) , costPrice))) continue else: print('Selling Price is Greater Than Cost Price') print('Try calculating profit\n') continue else: quit() ================================================ FILE: pyKeywords.py ================================================ # Checking is some keyword is a python keyword or not import keyword pythonKeywords = keyword.kwlist getToCheck = str(input('Keyword to check : ')) check = keyword.iskeyword(getToCheck) if check == True: print(getToCheck + ' is a python keyword.') else: print(getToCheck + ' is not a python keyword.') print('\nShowing all keywords in python : \n') print(pythonKeywords) # remember to test the code ================================================ FILE: pythagoras.py ================================================ # Pythagoras Formula import math # a.sq + b.sq = c.sq a = float(input('Value for A : ')) b = float(input('Value for B : ')) c = math.sqrt(a ** 2 + b ** 2) # here's the answer print(c) ================================================ FILE: python_files_compiler.py ================================================ from cx_Freeze import setup, Executable # file must be saved in same directory as the file you want to Compile # Download cx_Freeze from source forge or run easy_install in power shell nameOfExec = input("Name for Executable: ") versionNumber = input("Version: ") auth = input("Name of Author: ") auth_email = input("Email of Author: ") descript = input("Description: ") filename = input("File to Compile(Add .py to file): ") # run this file in cmd "python CompileFiles.py build" or "python CompileFiles.py build_exe" # This setup in minimialistic setup( name = nameOfExec, version = versionNumber, description = descript, author = auth, author_email = auth_email, executables = [Executable(filename)] ) ================================================ FILE: randomModule.py ================================================ import random inside = random.randint(1,37890) # choses a random integer between given range print(inside) outside = random.randrange(1,1000) # choses a random number number in given range print(outside) colors = ['green','black','blue','yellow','white'] print(random.choice(colors)) # choses random element from list ================================================ FILE: readFiles.py ================================================ # Reading files # Enter file name which is in same directory as that of the program fileName = str(input('File name : ')) fileToRead = open(fileName, 'r') # 'r' reads the file print(fileToRead.read()) # reading file fileToRead.close() # closing the file ================================================ FILE: reverse_sort.py ================================================ """ This sort is designed by me. First self designed sorting Algorithm. Kalpak Take """ def reverse_sort(array): for i in range(len(array) - 1): for n in range(len(array) - 1): a = array[n] if (a < array[i]): tem = array[i] array[i] = a array[n] = tem return array print reverse_sort([123, 3455, 6577, 546, 345, 22, 56, 7]) ================================================ FILE: rock,paper,scissor.py ================================================ import random while 2 == 2: print('--------------------------------------------------------------') get_again = raw_input('Enter rock paper or scissor : ') make_use = random.choice(['rock','paper','scissor']) print('--------------------------------------------------------------') print(make_use) print('--------------------------------------------------------------') if get_again == 'rock' and make_use == 'paper': print('computer wins! You "LOSE" ') print('--------------------------------------------------------------') continue elif get_again == 'rock' and make_use == 'scissor': print('computer loses You win!') print('--------------------------------------------------------------') break elif get_again == 'rock' and make_use == 'rock': print('It\'s a tie ! try again !') print('--------------------------------------------------------------') continue elif get_again == 'paper' and make_use == 'paper': print('It\'s a tie ! try again !') print('--------------------------------------------------------------') continue elif get_again == 'scissor' and make_use == 'scissor': print('It\'s a tie ! try again !') print('--------------------------------------------------------------') continue elif get_again == 'paper' and make_use == 'scissor': print('computer wins! You "LOSE" ') print('--------------------------------------------------------------') continue elif get_again == 'scissor' and make_use == 'paper': print('computer loses You win!') print('--------------------------------------------------------------') break elif get_again == 'paper' and make_use == 'rock': print('computer wins! You "LOSE" ') print('--------------------------------------------------------------') continue elif get_again == 'scissor' and make_use == 'rock': print('computer wins You "LOSE" ') print('--------------------------------------------------------------') continue else : print('Invalid input: Try again') continue ================================================ FILE: selection_sort.py ================================================ #Selection Sort def selection_sort(l): # Scan slices l[0:len(l)], l[1:len(l)], … for start in range(len(l)): # Find minimum value in slice . . . minpos = start for i in range(start,len(l)): if l[i] < l[minpos]: minpos = i # . . . and move it to start of slice (l[start],l[minpos]) = (l[minpos],l[start]) return(l) # Test result = selection_sort([9,8,7,6,5,4,3,2,1]) print("Builtin Method Result: {}".format(sorted([9,8,7,6,5,4,3,2,1]))) print("Selection Sort Method Result: {}".format(result)) ================================================ FILE: sendingEmailsInPython.py ================================================ import smtplib # REMEMBER : dont send mails through public computers or servers # connecting to googles serevrs serverToLogin = smtplib.SMTP('smtp.gmail.com' , 587) # Username userName = str(input('Username for Gmail : ')) # password password = str(input('Password Of Account : ')) # Logging in serverToLogin.login(userName , password) def sendMail(): yourEmail = str(input('Your Email Address : ')) # senders email address toSendEmail = str(input('Receivers Email Address')) # receivers email address messageHead = str(input('Message Head : ')) # Message head messageBody = str(input('Message : ')) # main message fullMessage = messageHead + '\n' + messageBody # full message serverToLogin.sendmail(yourEmail , toSendEmail , fullMessage) # sending email address through server while True: toSendOrNot = str(input('Send or End : ')) if toSendOrNot == 'Send': print('\n') print(sendMail()) else : quit() ================================================ FILE: server_file.py ================================================ import socket server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM) host = socket.gethostbyname(socket.gethostname()) port = 12345 server_socket.bind((host,port)) print("Server socket sucessfully Created on IP : {} at port {} ".format(host,port)) server_socket.listen() print("Server is waiting for clients to connect .... \n\n") client_socket,client_addr = server_socket.accept() print("Client is connected") print("Client's IP {}:{}\n\n".format(*client_addr)) f = open(input("Enter path to your file "),'rb') name =f.name client_socket.send(name.encode()) for line in f: client_socket.send(line) else : client_socket.send("EOF".encode()) client_socket.close() server_socket.close() ================================================ FILE: shell_games/README.md ================================================
'shell_games' Sub-directory contains all the games(programs) written for terminal/shell/command line. More games like sudoku, chess, battleship, et cetera are on their way!The programs have been re-checked and re-mastered by me!
Although i've tried to keep it as orignal as possible.
Keep Patience It'll take time to go through every program!!
Thanks ================================================ FILE: shell_games/battleship.py ================================================ # Add Encoding and path to exec from random import randint import sys class BattleShip: def __init__(self, rows_grid, columns_grid, co_ord_symbol): # Initializes battleship board of n * m size self.board = self.create_board(rows_grid, columns_grid, co_ord_symbol) # Placing ship randomly on board x refers to # array, y refers to index in array self.ship_x = randint(0, rows_grid) self.ship_y = randint(0, columns_grid) def create_board(self, x_length, y_length, co_ord_symbol="o "): # creates a multi-dimensional array of # n * m length return [[co_ord_symbol]*x_length for col in range(y_length)] def view(self): # For graphical representation of board for row in self.board: print(" ".join(row)) def is_ship_there(self, x_cord_guess, y_cord_guess): # Check if ship exists at given co-ordinates if self.ship_x == x_cord_guess and self.ship_y == y_cord_guess: return True return False def no_place_for_old_guess(self, row, col): # Replaces the co-ordinate at wrong guessed # ship position for convinience with X self.board[row][col] = "X " def get(self, row, col): # For UI purpose see ln 72 return self.board[row][col] def battleshipUI(): # Maximum n turns for player to guess the position of ship max_turns = 5 turns = 0 # Board of rows * columns for playing rows = int(input("How many rows? ")) cols = int(input("How many columns? ")) lets_battle = BattleShip(rows, cols, "o ") # Execute until user runs out of chances while turns < max_turns: # View the board at each new chance print("\n\nOcean:") lets_battle.view() # User to guess position of ship row_guess = int(input("\nGuess row? ")) col_guess = int(input("Guess column? ")) # Conditions if user guessed correctly, # or missed it or guessed extremely wrong # co-ordinates if lets_battle.is_ship_there(row_guess, col_guess): print("\n > Damn! You sunk my SHIP!") print(" > You Won the Game!\n\nSee You Soon!") sys.exit(0) elif (row_guess >= rows or row_guess < 0 or col_guess >= cols or col_guess < 0): print("\n - Ship isn't even in Ocean!") else: if lets_battle.get(row_guess, row_guess) == "X ": print("\n - Really you tried that already!") else: print("\n - Wrong Guess! Use your sailor's instincts!") # Replace symbol o with X to tell user # He/She already tried those co-ordinates lets_battle.no_place_for_old_guess(row_guess, col_guess) turns += 1 print("\n~~~GAMEOVER~~~") battleshipUI() ================================================ FILE: shell_games/battleship_info.txt ================================================ Battleship: Computer places a ship on the board User/Player has to guess the position os ship Rows and columns are numbered from 0 to n-1 and not 1 to n Structure of code can be understood by giving a careful look! You'll notice the game is highly customizable! Enjoy the game! ================================================ FILE: shell_games/dice_rolling_simulator.py ================================================ # Add encoding and path to executable import sys import time import random class DiceRollSim: def __init__(self, no_of_players, no_of_dies): self.players = self.assign_names(no_of_players) self.die_n = no_of_dies def assign_names(self, n): # Assigns names to 'n' players playing dict_players = {} # All members are indentified by name # and not number for i in range(n): dict_players[i + 1] = str( input("Name for player({}): ".format(i + 1))) return dict_players def roll_die(self): # Roll die n number of times # In case playing with multiple dies return [random.randint(1, 6) for roll in range(self.die_n)] def play(self): # Main rounds = 0 while True: # Continue playing until desired if str(input("\n\n[+]Continue [Y/n]? ")).strip().lower() == "y": print("\nRound-> %d" % rounds) # Print rolled die upper face number/s # for each player playing, along with sum for quick moves for player_num in self.players.keys(): rolled = self.roll_die() print(" > Chance of player %s: %s total: %d" % (self.players[player_num], rolled, sum(rolled))) # Delay for better user experience time.sleep(5) # Update rounds played rounds += 1 continue else: # Finished playing print("\n > Rounds played: %d" % rounds) break def main_interface(): # Indroductions print(" " * 7 + "| Dice Rolling Simulator | \n\n") # Initializations/Declarations players_n = abs(int(input("> How many players? "))) die_n = abs(int(input("> Number of dies? "))) print("\n\n") die_rolling_simulator = DiceRollSim(players_n, die_n) print("\nNumber of players playing -> %d\nWith %d dies." % (players_n, die_n)) # And the game begins die_rolling_simulator.play() print("\n\nSee you at another game!") sys.exit(0) main_interface() ================================================ FILE: shell_games/dice_rolling_simulator_info.txt ================================================ DiceRollingSimulator: Basically simulates rolling of die for 'n' players Playing with given number of dies Each player is identified by name During each dice rolling session, session is called as round After each round user can either continue playing another round Or simply exit Simulator is helpful in playing all board games played with dies ================================================ FILE: shell_games/number_guessing_game.py ================================================ #!/usr/bin/python3 from random import randint MAX_ = 500 # Specify biggest possible value from random number generation # Asks user for a guess and returns this when successful def get_guess(): while True: # Run forever, until broken try: # Try the following, if fails, run the except statment user_input = int(input("Guess a number: ")) # Get user input and covert it to an int (number) break # If the input can be converted, break the loop except ValueError: # This runs if the input could not be converted - text was entered print("Enter a number!\n") # Tell them to enter a number, then run loop again return user_input # Return value when loop broken num_to_guess = randint(0, MAX_) # Generates a random number between 0 and value of MAX_ print("Welcome to my random number guessing game!\nGuess a number between 0 and ", MAX_, "\n") while True: guess = get_guess() if guess >= 0 and guess <= MAX_: # Check if guess between 0 and max # Correct number! if guess == num_to_guess: print("That's a correct guess!\nYou got it!\n") break # Incorrect - give hint elif guess < num_to_guess: print("Try a bigger num!") # Number to small else: print("Try a smaller num!") # Number to big # Number is not in range else: print("Enter a number in between 0 and ", MAX_) print("") ''' *Challenge* 1) Can you give the user the option to Play Again? - if yes, the game will reset - including the random number 2) Try count the number of guesses and give a score to the user when they guess the number - the lower the guesses, the higher the score ''' ================================================ FILE: simple_scripts/ListExample.py ================================================ my_list = ['p','y','t','h','o','n'] # Output: p print(my_list[0]) # Output: t print(my_list[2]) # Output: o print(my_list[4]) # Error! Only integer can be used for indexing # my_list[4.0] # Nested List n_list = ["Happy", [2,0,1,5]] # Nested indexing # Output: a print(n_list[0][1]) # Output: 5 print(n_list[1][3]) ================================================ FILE: simple_scripts/README.md ================================================
'simple_scripts' Sub-directory contains all simplest programs, these programs are simple to read/write.The programs have been re-checked and improved a bit
Although i've tried to keep it as orignal as possible.
Thanks ================================================ FILE: simple_scripts/args_example.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # *args is used when we don't know the exact number of # arguments are going that will be passed, so this placeholder # is used commonly def add_numbers(*args): res = 0 for i in args: res += i return res # Quick Test t1 = add_numbers(123,435,876,12,54,76,78954,89,87,56,78,98,56,32,87) if t1 == sum([123,435,876,12,54,76,78954,89,87,56,78,98,56,32,87]): print("Sum: " + str(t1)) else: print("Something went wrong!") ================================================ FILE: simple_scripts/args_example_1.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # *params is just a placeholder(try putting other name) # for n number of arguments # so that n can be any number, instead of params # any name can be used, but the * asterisk is important # Below function, is a generator # generates a tuple containing arg, and a boolean value # every time it encounters argument def squared(*params): for arg in params: yield((arg, arg % 2 == 0)) # Quick Test print("Divisibility Test(by 2): ") for n, bool_ in squared(12, 13, 34, 4576, 234536, 2341): if bool_: print(" [" + str(n) + "] -> is divisible by 2!") else: print(" [" + str(n) + "] -> is NOT divisible by 2!") ================================================ FILE: simple_scripts/class_animal_attributes_examples.py ================================================ class Animal: def __init__(self, species, name, legs, color, voices): self.species = species self.name = name self.legs = legs self.color = color self.voices = voices cat = Animal("Cat" , "Pussy-Cat" , 4 , "white" , "meow") dog = Animal("Dog" , "Cloudy", 4 , "brownie" , "bark") print("Species of animal : ",dog.species) print("name of animal : ",dog.name) print("no. of legs : ",dog.legs) print("color of animal : ",dog.color) print("voice of animal : ",dog.voices) print(" ") print("Species of animal : ",cat.species) print("name of animal : ",cat.name) print("no. of legs : ",cat.legs) print("color of animal : ",cat.color) print("voice of animal : ",cat.voices) ================================================ FILE: simple_scripts/class_example_movies.py ================================================ class movie(): def __init__(self, name, rating, director, budget, description): self.name = name self.rating = rating self.director = director self.budget = budget self.description = description def good_movie(self): if self.rating >= 4: return("It's a good movie.") toy_story = movie("ToyStory2" , 4 , "John Lasseter , Lee Unkrich , Ash Brannon" , "90 millon USD" , """When Woody is toy-napped by a greedy toy collector and is nowhere to be found, Buzz and his friends set out to rescue him.But Woody too is tempted by the idea of becoming immortal in a museum. """) print("Title : " + str(toy_story.name)) print("Rating : " + str(toy_story.rating)) print("Director : " + str(toy_story.director)) print("Budget : " + str(toy_story.budget) + "\n") print("Description : " + str(toy_story.description)) print(toy_story.good_movie()) ================================================ FILE: simple_scripts/class_movies.py ================================================ class Movie: def __init__(self, name, rating, director, budget, description): self.name = name self.rating = rating self.director = director self.budget = budget self.description = description def good_movie(self): if self.rating >= 4: return"Good Movie" else: return "Average Movie" toy_story = Movie("ToyStory2" , 4 , "John Lasseter , Lee Unkrich , Ash Brannon" , "90 millon USD" , "When Woody is toy-napped by a greedy toy collector and is nowhere to be found, \nBuzz and his friends set out to rescue him.\nBut Woody too is tempted by the idea of becoming immortal in a museum.") print("Title : " + toy_story.name) print("Rating : " + str(toy_story.rating)) print("Director : " + toy_story.director) print("Budget : " + str(toy_story.budget)) print("Description : " + toy_story.description) print("Comment: " + toy_story.good_movie()) ================================================ FILE: simple_scripts/conditionals_examples.py ================================================ # THIS SCRIPT IS TO UNDERSTAND # THAN TO EXECUTE! # Conditionals Examples # if , elif , else # Condition Testing operators # == checks equality # != not equal to # > greater than # < less than # <= smaller than equal to # >= greater than equal to # Let's start with if # Let's say we have a robot and we want it to move forward by 20 steps robotMoving = True if robotMoving == True: print('Move 20 steps') # Okay what about if robot is not moving # This is where else : statement comes in robotMoving = False else : print('You are not moving') # elif # What if there are multiple things to check like if # We need more if statements but each if will run # Thus we need elif(else if) statement # Only else : statements dont contain values to check start = str(input('Enter a or b or c : ')) # we need to check if entered value is equal to a or b or c if start == 'a': print('You entered ' + start) elif start == 'b': print('You entered ' + start) elif start == 'c': print('You entered ' + start) else: print('Invalid Input') # Another Example numsA = input('Enter a : ') numsB = input('Enter b : ') if numsA > numsB: print(str(numsA) + ' is greater than ' + str(numsB)) elif numsA < numsB: print(str(numsB) + ' is greater than ' + str(numsA)) else : print('Numbers are equal') # nested if else # You can nest conditionals inside other conditionals startProgram = True numsA = input('Enter a : ') numsB = input('Enter b : ') if startProgram == True: if numsA > numsB: print(str(numsA) + ' is greater than ' + str(numsB)) elif numsA < numsB: print(str(numsB) + ' is greater than ' + str(numsA)) else : print('Numbers are equal') else: print('Can\'t access program') # and or not are helpful # and returns True if both conditions are true # or returns True if one of both condition is true # not returns True if condition is false and False if condition is True # Think you have bike and you want to go out on a ride but you have to check if you have enough fuel # remember not evaluates first then and then or # and youHaveBike = True fuel = 30 if youHaveBike == True and fuel > 65: print('You are good to go') else: print('You need to refill fuel') # or extraFuel = True if extraFuel = True or fuel > 65: print('You are good to go') else: print('You need to refill fuel') # not number = 12 if not(number != 11): print('True') else: print('False') ================================================ FILE: simple_scripts/for_loop_fibonnaci ================================================ #printing fibonnaci series till nth element def print_fibonacci(n): current_no = 1 prev_no = 0 for i in range(n): print(current_no, end = " ") prev_no,current_no = current_no, current_no + prev_no print_fibonacci(10) ================================================ FILE: simple_scripts/for_loop_mountain.py ================================================ # Accept User Input, consider (4) n = int(raw_input("How big? ")) # Building block of our mountain of money s = '$' # Process for constructing mountain # Since n = 4, # range (1, n+1) would be all the integers from 1 to 4 including 1 and 4 # Mountain formed would be: # $ i = 1, ' ' * n-i = 4-1 = 3 is empty space taken 3 times, s*i is '$' taken once(i times) # $$ i = 2, ' ' * n-i = 4-2 = 2 , s*i is '$' taken twice(i times) # $$$ and so on # $$$$ # Again, notice how i and n change for each iteration for i in range( 1 , n+1): print (' ' *(n-i) + s*i) print("\n") # Other variant s = '$$' for i in range( 1 , n+1): print (' ' *(n-i) + s*i) ================================================ FILE: simple_scripts/personality_teller.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # Personality Teller import random # Chooses personality randomly # Just for fun! # Don't be serious! personalities = ['Arrogant and Rude','Funny and Polite','Insane and Crazy' ,'Lover and Cute','Nerd and Boring','Cool and Rude','Cute but arrogant','Intelligent and Geek' ,'Cool and Funny','Idiot and Crazy','Awesome and Crazy','Good and Smart','Cool and Smart', 'Smart and Geek','Cool and Smart'] while True: if raw_input("\nPress(e) to Exit,\nName?: ").strip() == "e": print("\nHope you enjoyed!") exit(0) else: print(" > You are %s" % random.choice(personalities)) ================================================ FILE: simple_scripts/unicode.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # returns UNICODE value of a character def get_ascii(S): # even if string has only 1 character # it yields same for all if len(S) > 0: for char_ in list(S): yield((char_, ord(char_))) # ord returns unicode value of given string of length 1 # we only increased it's capacity # simple ..eh # test test_characters = ['A', 'x', 'Y', 'Z', 'm', 'K', "STack"] for test_case in test_characters: print("Test Case: " + test_case) codes = list(get_ascii(test_case)) for code in codes: print(" character: {}, unicode_val: {}".format(code[0], code[1])) print(" ") ================================================ FILE: simple_scripts/website_opener.py ================================================ #!/usr/bin/python # -*- coding: utf-8 -*- # Just Exploring webbrowser lib from webbrowser import open as web_open # Simple function to open given link in webbrowser def open_website(link): try: print("Opening link: " + link) web_open(link) except Exception as e: print("Error Occurred:\n {}".format(e)) # Just for test get_link = raw_input("Link to open: ") open_website(get_link) ================================================ FILE: sleepWellAlarm.py ================================================ # Alarm in Python # Playing Sound on youtube to wake the person up # I havent really battle tested the program so it might contain bugs # If you come accross the bugs inform me from time import sleep,ctime import datetime import webbrowser import random now = datetime.datetime.now() linksToSounds = ['https://www.youtube.com/watch?v=6pR5cyH63mA','https://www.youtube.com/watch?v=e12KryuLcbs','https://www.youtube.com/watch?v=nbjwmC8K4K4','https://www.youtube.com/watch?v=UqSww10eeKw','https://www.youtube.com/watch?v=9f06QZCVUHg','https://www.youtube.com/watch?v=kffacxfA7G4'] # remember to add links and test the code def alarm(h,m,s): timeToSleep = h * 3600 + m * 60 + s sleepingTime = sleep(timeToSleep) playSound = webbrowser.open_new(random.choice(linksToSounds)) # Main code print(ctime(),'\n') startOrEnd = str(input('Set alarm or End : ')) if startOrEnd.strip() == 'Set alarm': hours = int(input('Hours : ')) minutes = int(input('Minutes : ')) seconds = int(input('Seconds : ')) print('Alarm started at %s : %s'%(now.hour,now.minute)) print(alarm(hours,minutes,seconds)) wakedUp = False while wakedUp == False: get = str(input('Have you waked up : ')) if get == 'Yes': print('Good') wakedUp = True else: sleepMoreTime = sleep(300) # playing sound again in 5 minutes playSoundAgain = webbrowser.open_new(random.choice(linksToSounds)) continue else : quit() ================================================ FILE: snake game/.idea/.gitignore ================================================ # Default ignored files /shelf/ /workspace.xml ================================================ FILE: snake game/.idea/inspectionProfiles/profiles_settings.xml ================================================