Initial Commit

Priyansi · Priyansi · commit aa343818d0a9 · 2020-04-07T17:02:10.000+05:30
diff --git a/aliquotSum.py b/aliquotSum.py
@@ -0,0 +1,20 @@
+import sys
+
+classificationList = ['Alpha', 'Gamma', 'Beta']
+
+
+def calculateIndex(diff):
+    if diff == 0:
+        return 0
+    return diff//abs(diff)
+
+
+def aliquotSum(n):
+    return sum([x for x in range(1, n//2 + 1) if n % x == 0])
+
+
+def classify(n):
+    return classificationList[calculateIndex(int(n) - aliquotSum(int(n))) + 1]
+
+
+print(classify(sys.argv[1]))
diff --git a/allDigitsEvenPerfectSquare.py b/allDigitsEvenPerfectSquare.py
@@ -0,0 +1,20 @@
+import sys
+import math
+
+START, LIMIT = 1000, 10000
+
+
+def allDigitsEven(num: int) -> bool:
+    return not 1 in [int(x) & 1 for x in str(num)]
+
+
+def perfectSquare(num: int) -> bool:
+    squareRoot = math.sqrt(num)
+    return math.ceil(squareRoot) == math.floor(squareRoot)
+
+
+def numberList() -> list:
+    return [num for num in range(START, LIMIT) if allDigitsEven(num) and perfectSquare(num)]
+
+
+print(numberList())
diff --git a/armstrong.py b/armstrong.py
@@ -0,0 +1,21 @@
+import sys
+START, LIMIT = int(sys.argv[1]), int(sys.argv[2])
+
+
+def make_armstrong(a: int, b: int) -> [int]:
+    return [x for x in range(a, b) if is_armstrong(x)]
+
+
+def is_armstrong(n: int) -> bool:
+    return n == sum(cubes(digits(n)))
+
+
+def cubes(ds: int) -> int:
+    return [d**len(ds) for d in ds]
+
+
+def digits(n: int) -> [int]:
+    return [int(ch) for ch in str(n)]
+
+
+print(make_armstrong(START, LIMIT))
diff --git a/armstrongNumbersRange.py b/armstrongNumbersRange.py
@@ -0,0 +1,17 @@
+import sys
+
+
+def countDigits(num: int) -> int:
+    return len(str(num))
+
+
+def calculate(num: int) -> int:
+    lenNum = countDigits(num)
+    return sum([int(i)**lenNum for i in str(num)])
+
+
+def armstrong(start: int, stop: int) -> list:
+    return [x for x in range(start, stop+1) if calculate(x) == x]
+
+
+print(armstrong(int(sys.argv[1]), int(sys.argv[2])))
diff --git a/collatz.py b/collatz.py
@@ -0,0 +1,19 @@
+import sys
+
+
+def odd(n: int) -> bool:
+    return n % 2 == 1
+
+
+def nextTerm(p: int) -> int:
+    return 3*p+1 if odd(p) else p//2
+
+
+def series(start: int) -> [int]:
+    if start == 4:
+        return [4, 2, 1]
+    else:
+        return [start]+series(nextTerm(start))
+
+
+print(series(int(sys.argv[1])))
diff --git a/digitalRoot.py b/digitalRoot.py
@@ -0,0 +1,8 @@
+import sys
+
+
+def digitalRoot(num):
+    return num % 9 if num % 9 else 9
+
+
+print(digitalRoot(int(sys.argv[1])))
diff --git a/encryptString.py b/encryptString.py
@@ -0,0 +1,18 @@
+import sys
+
+dictionary = {'a': 0, 'e': 1, 'o': 2, 'u': 3}
+
+
+def changeCharacter(ch):
+    return str(dictionary[ch]) if ch in dictionary else ch
+
+
+def newString(string):
+    return ''.join(changeCharacter(x) for x in string)
+
+
+def encrypt(string):
+    return newString(string[::-1])+'aca'
+
+
+print(encrypt(sys.argv[1]))
diff --git a/factorialTrailingZeros.py b/factorialTrailingZeros.py
@@ -0,0 +1,13 @@
+import sys
+
+
+def factorialTrailingZeros(num: int) -> int:
+    count = 0
+    i = 5
+    while num//i:
+        count += num//i
+        i *= 5
+    return count
+
+
+print(factorialTrailingZeros(int(sys.argv[1])))
diff --git a/fairRations.py b/fairRations.py
@@ -0,0 +1,35 @@
+ODD = 'O'
+EVEN = 'E'
+
+
+def checkOdd(array: int) -> bool:
+    return array & 1
+
+
+def is_solvable(loavesInHand: [int]) -> bool:
+    return not checkOdd(sum(loavesInHand))
+
+
+def numberToEO(num: int) -> str:
+    return ODD if checkOdd(num) else EVEN
+
+
+def convert(loaves: [int]) -> str:
+    return ''.join([numberToEO(x) for x in loaves])
+
+
+def rsolve(oeloaves: str) -> int:
+    if oeloaves.count(ODD) == 0:
+        return 0
+    if oeloaves[0] == EVEN:
+        return rsolve(oeloaves[1:])
+    if oeloaves[0] == ODD and oeloaves[1] == ODD:
+        return 2 + rsolve(oeloaves[2:])
+    if oeloaves[0] == ODD and oeloaves[1] == EVEN:
+        return 2 + rsolve(ODD + oeloaves[2:])
+
+
+def solve(oeloaves: str) -> int:
+    Es = oeloaves.split(ODD)
+    relevantEs = Es[1::2]
+    return sum([2*len(x)+2 for x in relevantEs])
diff --git a/groupAnagrams.py b/groupAnagrams.py
@@ -0,0 +1,28 @@
+import sys
+
+
+def generateKey(word):
+    return ''.join(sorted(word.lower()))
+
+
+def makeDictionary(array):
+    dictionary = {}
+
+    for word in array:
+        key = generateKey(word)
+        if key in dictionary.keys():
+            dictionary[key].append(word.lower())
+        else:
+            dictionary[key] = []
+            dictionary[key].append(word.lower())
+
+    return dictionary
+
+
+def groupAnagrams(words):
+    anagramDictionary = makeDictionary(words)
+
+    return [anagramDictionary[key] for key in anagramDictionary]
+
+
+print(groupAnagrams(sys.argv[1:]))
diff --git a/holeNumber.py b/holeNumber.py
@@ -0,0 +1,9 @@
+dictionary = {0: 1, 1: 0, 2: 0, 3: 0, 4: 1, 5: 0, 6: 1, 7: 0, 8: 2, 9: 1}
+
+
+def calculateKey(i):
+    return sum([dictionary[int(ch)] for ch in str(i)])
+
+
+def sum_of_holes(limit):
+    return sum([calculateKey(i+1) for i in range(limit)])
diff --git a/isvowel.py b/isvowel.py
@@ -0,0 +1 @@
+def isvowel(letter):
diff --git a/kaprekar.py b/kaprekar.py
@@ -0,0 +1,27 @@
+import sys
+
+
+def num2digits(n: int) -> [int]:
+    return [int(ch) for ch in str(n)]
+
+
+def digits2num(ds: [int]) -> int:
+    return int(''.join([str(i) for i in ds]))
+
+
+def next(n: int) -> int:
+    ds = num2digits(n)
+    maxi = digits2num(sorted(ds, reverse=True))
+    mini = digits2num(sorted(ds))
+    return n, maxi, mini, maxi-mini
+
+
+def kap_seq(n: int) -> [int]:
+    nn = next(n)
+    if nn[-1] == n:
+        return [nn]
+    return [nn]+kap_seq(nn[-1])
+
+
+for k in kap_seq(int(sys.argv[1])):
+    print(k)
diff --git a/matchingCharacters.py b/matchingCharacters.py
@@ -0,0 +1,8 @@
+import sys
+
+
+def matches(str1, str2):
+    return sum((a == b) for a, b in zip(str1, str2))
+
+
+print(matches(sys.argv[1], sys.argv[2]))
diff --git a/nestingDepth.py b/nestingDepth.py
diff --git a/nextHigherPalindromeBetterApproach.py b/nextHigherPalindromeBetterApproach.py
@@ -0,0 +1,35 @@
+# function that tests again cases, manipulates and finds the next palindrome
+def nextPalindrome(number):
+    length = len(str(number))
+    leftHalf = getLeftHalf(number)
+    middle = getMiddle(number)
+    if number & 1:
+        increment = pow(10, length//2)
+        newNumber = int(leftHalf+middle+leftHalf[::-1])
+    else:
+        increment = int(1.1*pow(10, length//2))
+        newNumber = int(leftHalf+leftHalf[::-1])
+    if newNumber > number:
+        return newNumber
+    if middle != '9':
+        return newNumber+increment
+    else:
+        return nextPalindrome(roundUp(number))
+
+
+def getLeftHalf(number):
+    return str(number)[:len(str(number))//2]
+
+
+def getMiddle(number):
+    return str(number)[(len(str(number))-1)//2]
+
+
+def roundUp(number):
+    length = len(str(number))
+    increment = int(pow(10, ((length//2)+1)))
+    return int(((number//increment)+1)*increment)
+
+
+number = int(input())
+print(nextPalindrome(number))
diff --git a/nextHigherPalindromeNaiveApproach.py b/nextHigherPalindromeNaiveApproach.py
@@ -0,0 +1,11 @@
+# function that incremets and checks palindrome
+def palindrome(number: int) -> int:
+    while True:
+        if str(number) == str(number)[::-1]:
+            return number
+        else:
+            number += 1
+
+
+number = int(input())
+print(palindrome(number))
diff --git a/primoral.py b/primoral.py
@@ -0,0 +1,29 @@
+import sys
+import math
+import numpy
+
+
+def checkPrime(n) -> bool:
+    for i in range(2, int(math.sqrt(n))+1):
+        if n % i == 0:
+            return False
+    return True
+
+
+def firstN(number):
+    START = 2
+    listPrimes = []
+    for i in range(1, number+1):
+        while not checkPrime(START):
+            START += 1
+        listPrimes.append(START)
+        START += 1
+
+    return listPrimes
+
+
+def getPrimoral(number):
+    return numpy.prod(firstN(number))
+
+
+print(getPrimoral(3))
diff --git a/russianMultiplication.py b/russianMultiplication.py
@@ -0,0 +1,24 @@
+import sys
+
+equalTos = '==========='
+
+
+def table(a, b):
+    return ''.join(str(a)+' '+str(b))+''.join(' +\n' if a & 1 else '\n')
+
+
+def russianMultiplication(a, b):
+    outputString = ''
+    total = 0
+    indent = len(str(a))+1
+    while a > 0:
+        outputString += table(a, b)
+        if outputString.endswith('+\n'):
+            total += b
+        a = a//2
+        b = 2*b
+
+    return outputString+equalTos+'\n'+''.rjust(indent, ' ')+str(total)+'\n'+equalTos
+
+
+print(russianMultiplication(int(sys.argv[1]), int(sys.argv[2])))
diff --git a/smarterWayAbsoluteFunction.py b/smarterWayAbsoluteFunction.py
@@ -0,0 +1,7 @@
+def absoluteFunction(number):
+    number -= (number < 0)*2*number
+    return number
+
+
+number = int(input())
+print(absoluteFunction(number))
diff --git a/smarterWayIdentityMatrix.py b/smarterWayIdentityMatrix.py
@@ -0,0 +1,10 @@
+def identityMatrix(rows, columns):
+
+    for i in range(1, rows+1):
+        for j in range(1, columns+1):
+            identityMatrix[i-1][j-1] = (i/j)*(j/i)
+    return identityMatrix
+
+
+rows, columns = input().split(' ')
+print(identityMatrix(rows, columns))
diff --git a/specialNumber.py b/specialNumber.py
diff --git a/stringTransformation.py b/stringTransformation.py
diff --git a/sumUniqueNumbersArray.py b/sumUniqueNumbersArray.py
diff --git a/transformThreeWords.py b/transformThreeWords.py
diff --git a/vestigium.py b/vestigium.py
