blob_id stringlengths 40 40 | repo_name stringlengths 5 127 | path stringlengths 2 523 | length_bytes int64 22 545k | score float64 3.5 5.34 | int_score int64 4 5 | text stringlengths 22 545k |
|---|---|---|---|---|---|---|
9f13a29c757c6cc2ef8f0d7dfe29b37ddec47df0 | Dannikk/dfs_bfs_animation_-using-networkx- | /src/graph_reader.py | 567 | 3.921875 | 4 | import os
DELIMITER = ':'
NODES_DELIMITER = ','
def read_graph(file_path: str):
"""
Function that reads a graph from a text file
Parameters
----------
file_path : str
directory to file to read graph
Returns
-------
generator :
yielding node (any hashable object), list of neighbors
"""
with open(file_path, 'r') as file:
for line in file:
node, _, neighbors = line.partition(DELIMITER)
assert neighbors
yield node, neighbors.replace(NODES_DELIMITER, '').split()
|
39bbe7fce725a7fb6fbc91def71fd88e6373b7e6 | endfirst/python | /first_class_function/first_class_function00.py | 511 | 3.515625 | 4 | # -*- coding: utf-8 -*-
# 퍼스트클래스 함수란 프로그래밍 언어가 함수 (function) 를 first-class citizen으로 취급하는 것을 뜻합니다.
# 쉽게 설명하자면 함수 자체를 인자 (argument) 로써 다른 함수에 전달하거나 다른 함수의 결과값으로 리턴 할수도 있고,
# 함수를 변수에 할당하거나 데이터 구조안에 저장할 수 있는 함수를 뜻합니다.
def square(x):
return x * x
print square(5)
f = square
print square
print f |
938501b49e1f9678ac3f64094b2cf4eed46c35f6 | JasmineBharadiya/pythonBasics | /task_8_guessNo.py | 161 | 3.609375 | 4 | import random
a=int(raw_input("guess a no. between 1-10: "))
rA=random.randint(1,10)
if(rA==a):
print "well guessed"
else :
print "try again"
|
91d55cba2c6badcd157aae309c518f6fafcbf9c1 | mildzf/zantext | /zantext/zantext.py | 671 | 3.65625 | 4 | # -*- coding: utf-8 -*-
"""
File: zantext.py
Author: Mild Z Ferdinand
This program generates random text.
"""
import random
POOL = "abcdefghijklmnopqrstuvwxyz"
def word(length=0):
if not length or length > 26:
length = random.randint(3, 10)
else:
length = abs(length)
word = [random.choice(POOL) for i in range(length)]
return ''.join(word)
def sentence(words=0, chars=0):
words = abs(words)
if not words:
words = random.randint(3, 10)
return " ".join([word() for i in range(words)]) + "."
def paragraph(sentences=0, words=0):
if not sentences and not words:
return " ".join([sentence() for i in range(5)])
|
4bdde3d9684f505ae85c0446465aa211a012a02d | luizfirmino/python-labs | /Python I/Assigments/Module 5/Ex-2.py | 415 | 4.3125 | 4 | #
# Luiz Filho
# 3/14/2021
# Module 5 Assignment
# 2. In mathematics, the factorial of a number n is defined as n! = 1 ⋅ 2 ⋅ ... ⋅ n (as the product of all integer numbers from 1 to n).
# For example, 4! = 1 ⋅ 2 ⋅ 3 ⋅ 4 = 24. Write a recursive function for calculating n!
def calculateN(num):
if num == 1:
return num
else:
return num * calculateN(num-1)
print(calculateN(4))
|
7372b7c995d2302f29b8443656b50cae298a566b | luizfirmino/python-labs | /Python I/Assigments/Module 6/Ex-4.py | 742 | 4.40625 | 4 | #
# Luiz Filho
# 3/23/2021
# Module 6 Assignment
# 4. Write a Python function to create the HTML string with tags around the word(s). Sample function and result are shown below:
#
#add_html_tags('h1', 'My First Page')
#<h1>My First Page</h1>
#
#add_html_tags('p', 'This is my first page.')
#<p>This is my first page.</p>
#
#add_html_tags('h2', 'A secondary header.')
#<h2>A secondary header.</h2>
#
#add_html_tags('p', 'Some more text.')
#<p>Some more text.</p>
def add_html_tags(tag, value):
return "<" + tag + ">" + value + "</" + tag + ">"
print(add_html_tags('h1', 'My First Page'))
print(add_html_tags('p', 'This is my first page.'))
print(add_html_tags('h2', 'A secondary header.'))
print(add_html_tags('p', 'Some more text.'))
|
7207ee818fe1cd157874667ae152ee4e8072de3d | luizfirmino/python-labs | /Python Databases/Assigments/Assignment 1/filho_assignment1.py | 655 | 4 | 4 | #!/usr/bin/env python3
# Assignment 1 - Artist List
# Author: Luiz Firmino
#imports at top of file
import sqlite3
def main():
con = sqlite3.connect('chinook.db')
cur = con.cursor()
#query to select all the elements from the movie table
query = '''SELECT * FROM artists'''
#run the query
cur.execute(query)
#save the results in movies
artists = cur.fetchall()
print("List of Artists: \n")
#loop through and print all the movies
for artist in artists:
print(artist[0] , " " , artist[1])
print("\nDone - See you next time! \n")
if con:
con.close()
if __name__ == "__main__":
main() |
c13619368c38c41c0dbf8649a3ca88d7f2788ee8 | luizfirmino/python-labs | /Python Networking/Assignment 2/Assignment2.py | 564 | 4.21875 | 4 | #!/usr/bin/env python3
# Assignment: 2 - Lists
# Author: Luiz Firmino
list = [1,2,4,'p','Hello'] #create a list
print(list) #print a list
list.append(999) #add to end of list
print(list)
print(list[-1]) #print the last element
list.pop() #remove last element
print(list)
print(list[0]) #print first element
list.remove(1) #remove element
print(list)
del list[3] #remove an element by index
print(list)
list.insert(0,'Baby') #insert an element at index
print(list) |
51d1e3a48b954c1de3362ea295d4270a884fea98 | luizfirmino/python-labs | /Python I/Assigments/Module 7/Ex-3.py | 1,042 | 4.3125 | 4 | #
# Luiz Filho
# 4/7/2021
# Module 7 Assignment
# 3. Gases consist of atoms or molecules that move at different speeds in random directions.
# The root mean square velocity (RMS velocity) is a way to find a single velocity value for the particles.
# The average velocity of gas particles is found using the root mean square velocity formula:
#
# μrms = (3RT/M)½ root mean square velocity in m/sec
#
# R = ideal gas constant = 8.3145 (kg·m2/sec2)/K·mol
#
# T = absolute temperature in Kelvin
#
# M = mass of a mole of the gas in kilograms. molar mass of O2 = 3.2 x 10-2 kg/mol
#
# T = °C + 273
#
# a. By using the decimal module, create a decimal object and apply the sqrt and quantize method (match pattern “1.000”)
# and provide the answer to the question:
# What is the average velocity or root mean square velocity of a molecule in a sample of oxygen at 25 degrees Celsius?
number = 3237945.76
print("{:25,.9f}".format(number))
print("{:.2f}".format(number))
print("{:,.2f}".format(number))
print("{:,.4f}".format(number))
|
47d783748c562dd3c3f8b7644dda166f37b5f11e | luizfirmino/python-labs | /Python I/Assigments/Module 5/Ex-6.py | 238 | 4.5 | 4 | #
# Luiz Filho
# 3/14/2021
# Module 5 Assignment
# 6. Write a simple function (area_circle) that returns the area of a circle of a given radius.
#
def area_circle(radius):
return 3.1415926535898 * radius * radius
print(area_circle(40)) |
6ca6fbf8e7578b72164ab17030f1c01013604b04 | luizfirmino/python-labs | /Python I/Assigments/Module 5/Ex-4.py | 549 | 4.28125 | 4 | #
# Luiz Filho
# 3/14/2021
# Module 5 Assignment
# 4. Explain what happens when the following recursive functions is called with the value “alucard” and 0 as arguments:
#
print("This recursive function is invalid, the function won't execute due an extra ')' character at line 12 column 29")
print("Regardless any value on its parameters this function will not execute or compile.")
def semordnilap(aString,index):
if index < len(aString):
print(aString[index]), end="")
semordnilap(aString, index+1)
semordnilap("alucard", 0) |
796c8bb615635d769a16ae12d9f27f2cfce4631c | luizfirmino/python-labs | /Python I/Assigments/Module 2/Ex-2.py | 880 | 4.53125 | 5 | #
# Luiz Filho
# 2/16/2021
# Module 2 Assignment
# Assume that we execute the following assignment statements
#
# length = 10.0 , width = 7
#
# For each of the following expressions, write the value of the expression and the type (of the value of the expression).
#
# width//2
# length/2.0
# length/2
# 1 + 4 * 5
#
length = 10.0
width = 7
print("-- DEFAULTS --------------")
print("Variable width value = " + str(width))
print("Variable length value = " + str(length))
print("--------------------------")
print("Result of width//2: " + str(width//2) + " output type:" + str(type(width//2)))
print("Result of length/2.0: " + str(length/2.0) + " output type:" + str(type(length/2.0)))
print("Result of length/2: " + str(length/2) + " output type:" + str(type(length/2)))
print("Result of 1 + 4 * 5: " + str((1 + 4 * 5)) + " output type:" + str(type((1 + 4 * 5))))
|
6c41276669d4b83b5b79074f60302f370c4eaa80 | wuga214/PlanningThroughTensorFlow | /utils/argument.py | 388 | 3.609375 | 4 | import argparse
def check_int_positive(value):
ivalue = int(value)
if ivalue <= 0:
raise argparse.ArgumentTypeError("%s is an invalid positive int value" % value)
return ivalue
def check_float_positive(value):
ivalue = float(value)
if ivalue < 0:
raise argparse.ArgumentTypeError("%s is an invalid positive float value" % value)
return ivalue |
910a369c1dc5ad07e8e4c1916ef31c0c044f7430 | Litao439420999/LeetCodeAlgorithm | /Python/integerBreak.py | 701 | 3.59375 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: integerBreak.py
@Function: 整数拆分 动态规划
@Link: https://leetcode-cn.com/problems/integer-break/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-07-16
"""
class Solution:
def integerBreak(self, n: int) -> int:
if n < 4:
return n - 1
dp = [0] * (n + 1)
dp[2] = 1
for i in range(3, n + 1):
dp[i] = max(2 * (i - 2), 2 * dp[i - 2], 3 * (i - 3), 3 * dp[i - 3])
return dp[n]
# -------------------------
if __name__ == "__main__":
n = 2
solution = Solution()
max_mul = solution.integerBreak(n)
print(f"The solution of this problem is {max_mul}")
|
78098f3c8900ab45f703158bfefd790be0cfe74b | Litao439420999/LeetCodeAlgorithm | /Python/maxProfitChance.py | 799 | 4 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: maxProfitChance.py
@Function: 买卖股票的最佳时机 动态规划
@Link: https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-07-16
"""
from typing import List
class Solution:
def maxProfit(self, prices: List[int]) -> int:
inf = int(1e9)
minprice = inf
maxprofit = 0
for price in prices:
maxprofit = max(price - minprice, maxprofit)
minprice = min(price, minprice)
return maxprofit
# ---------------------------
if __name__ == "__main__":
prices = [7, 1, 5, 3, 6, 4]
solution = Solution()
max_profit = solution.maxProfit(prices)
print(f"The solution of this problem is {max_profit}")
|
a5dfcb4f79865d734ddfd7d9cf0c9061fcc6d187 | Litao439420999/LeetCodeAlgorithm | /Python/missingNumber.py | 611 | 3.828125 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: missingNumber.py
@Function: 丢失的数字
@Link: https://leetcode-cn.com/problems/missing-number/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-07-22
"""
class Solution:
def missingNumber(self, nums):
missing = len(nums)
for i, num in enumerate(nums):
missing ^= i ^ num
return missing
# ------------------------
if __name__ == "__main__":
nums = [1, 2, 3, 4]
solution = Solution()
missing_number = solution.missingNumber(nums)
print(f"The solution of this problem is {missing_number}")
|
ead8d1adb57d0b887ccd55638e88586230fe2d47 | Litao439420999/LeetCodeAlgorithm | /Python/maxArea.py | 868 | 4.03125 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: maxArea.py
@Function: 盛最多水的容器
@Link: https://leetcode-cn.com/problems/container-with-most-water/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-08-08
"""
from typing import List
class Solution:
def maxArea(self, height: List[int]) -> int:
left, right = 0, len(height) - 1
maxArea = 0
while left < right:
area = min(height[left], height[right]) * (right - left)
maxArea = max(maxArea, area)
if height[left] <= height[right]:
left += 1
else:
right -= 1
return maxArea
# -------------------------
if __name__ == "__main__":
height = [4,3,2,1,4]
solution = Solution()
max_area = solution.maxArea(height)
print(f"The solution of this problem is : {max_area}")
|
f0df420f1b26891e1e1483da86615aa651a99815 | Litao439420999/LeetCodeAlgorithm | /Python/combinationSum2.py | 1,456 | 3.734375 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: combinationSum2.py
@Function: 给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合
@Link: https://leetcode-cn.com/problems/combination-sum-ii/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-07-12
"""
import collections
from typing import List
class Solution:
def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
def dfs(pos: int, rest: int):
nonlocal sequence
if rest == 0:
ans.append(sequence[:])
return
if pos == len(freq) or rest < freq[pos][0]:
return
dfs(pos + 1, rest)
most = min(rest // freq[pos][0], freq[pos][1])
for i in range(1, most + 1):
sequence.append(freq[pos][0])
dfs(pos + 1, rest - i * freq[pos][0])
sequence = sequence[:-most]
freq = sorted(collections.Counter(candidates).items())
ans = list()
sequence = list()
dfs(0, target)
return ans
# ------------------------
if __name__ == "__main__":
# candidates = [10, 1, 2, 7, 6, 1, 5]
# target = 8
candidates = [2,5,2,1,2]
target = 5
solution = Solution()
list_combine = solution.combinationSum2(candidates, target)
print(f"The solutio of this problem is : {list_combine}")
|
4cf065dceacbfb09de77b2dba2d1f6879e080362 | Litao439420999/LeetCodeAlgorithm | /Python/removeNthFromEnd.py | 884 | 3.9375 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: removeNthFromEnd.py
@Function: 删除链表的倒数第 N 个结点
@Link: https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-07-30
"""
# Definition for singly-linked list.
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
class Solution:
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
dummy = ListNode(0, head)
first = head
second = dummy
for i in range(n):
first = first.next
while first:
first = first.next
second = second.next
second.next = second.next.next
return dummy.next
# --------------------------
if __name__ == "__main__":
# test on LeetCode online.
pass
|
f5e0250259414bd762064edd430b574d691f7051 | Litao439420999/LeetCodeAlgorithm | /Python/isPowerOfThree.py | 825 | 4.09375 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: isPowerOfThree.py
@Function: 3的幂 数学问题
@Link: https://leetcode-cn.com/problems/power-of-three/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-07-19
"""
import math
class Solution:
def isPowerOfThree(self, n: int) -> bool:
if n <= 0:
return False
res = round(math.log(n, 3), 9)
# python 需要精确到小数点 9 位，才能精确判断小数和它转换后的整数是否相等
return res - round(res) == 0 # round不加第二个参数，默认保留为整数
# ----------------------------------
if __name__ == "__main__":
# num = 21
num = 27
solution = Solution()
bool_power_three = solution.isPowerOfThree(num)
print(f"The solution of this problem is {bool_power_three}") |
8146a0a68782bf0745c250965e9440689dd3d957 | Litao439420999/LeetCodeAlgorithm | /Python/candy.py | 3,342 | 3.640625 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: candy.py
@Function: 分发糖果 贪心策略
@Link: https://leetcode-cn.com/problems/candy/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-07-04
"""
# --------------------------------------------------------------
class Solution2:
"""0、只需要简单的两次遍历即可：把所有孩子的糖果数初始化为 1；
1、先从左往右遍历一遍，如果右边孩子的评分比左边的高，
则右边孩子的糖果数更新为左边孩子的糖果数加 1；
2、再从右往左遍历一遍，如果左边孩子的评分比右边的高，且左边孩子当前的糖果数不大于右边孩子的糖果数，
则左边孩子的糖果数更新为右边孩子的糖果数加 1。
3、通过这两次遍历，分配的糖果就可以满足题目要求了。
这里的贪心策略即为，在每次遍历中，只考虑并更新相邻一侧的大小关系。
"""
def candy(self, ratings):
# 若只有一个人，则最少需要一个糖果
if len(ratings) < 2:
return len(ratings)
# 初始化每个人一个糖果
left = [1 for _ in range(len(ratings))]
right = left[:]
# 第一次遍历，从左往右
for i in range(1, len(ratings)):
if ratings[i] > ratings[i - 1]:
# 如果右边的评分高于左边，则其糖果数量等于其左边的糖果数量 + 1
left[i] = left[i - 1] + 1
# 计算需要的最小糖果数量
# 因为后面累加计算时索引不到最后一个
count = left[-1]
# 第二次遍历，从右往左
for i in range(len(ratings) - 2, -1, -1):
# 如果左边的评分高于右边，则左边孩子的糖果数更新为右边孩子的糖果数 + 1
if ratings[i] > ratings[i + 1]:
right[i] = right[i + 1] + 1
# 不断累加需要的最小糖果数量
# 每次具体位置的值，取从左往右遍历 和 从右往左遍历 的最大值
count += max(left[i], right[i])
return count
# --------------------------------------------------------------
class Solution:
def candy(self, ratings):
# 初始化每个人一个糖果
nums = [1] * len(ratings)
# 第一次遍历，从左往右
for i in range(0, len(ratings)-1):
# 如果右边的评分高于左边，则其糖果数量等于其左边的糖果数量 + 1
if ratings[i] < ratings[i+1]:
nums[i+1] = nums[i] + 1
# 第二次遍历，从右往左
for i in range(len(ratings)-1, 0, -1):
# 如果左边的评分高于右边，
if ratings[i] < ratings[i-1]:
# 且左边孩子当前的糖果数不大于右边孩子的糖果数
if nums[i] > nums[i-1] or nums[i] == nums[i-1]:
# 左边孩子的糖果数更新为右边孩子的糖果数 + 1
nums[i-1] = nums[i] + 1
return sum(nums)
if __name__ == "__main__":
ratings = [1, 0, 2]
# ratings = [1, 2, 2]
solution = Solution()
num_candy = solution.candy(ratings)
print(f"The solution of this problem is : {num_candy}") |
268b790641e7a522cc7d2431dcdb28b9a30126c8 | Litao439420999/LeetCodeAlgorithm | /Python/MinStack.py | 754 | 3.65625 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: MinStack.py
@Function: 最小栈
@Link: https://leetcode-cn.com/problems/min-stack/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-07-25
"""
import math
class MinStack:
def __init__(self):
self.stack = []
self.min_stack = [math.inf]
def push(self, x: int) -> None:
self.stack.append(x)
self.min_stack.append(min(x, self.min_stack[-1]))
def pop(self) -> None:
self.stack.pop()
self.min_stack.pop()
def top(self) -> int:
return self.stack[-1]
def getMin(self) -> int:
return self.min_stack[-1]
# --------------------------------------
if __name__ == "__main__":
# Test on LeetCode online.
pass
|
03a7ff048927334379e9758f3d2e7b43d2ceee43 | Litao439420999/LeetCodeAlgorithm | /Python/hammingDistance.py | 636 | 3.78125 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: hammingDistance.py
@Function: 两个整数之间的 汉明距离 指的是这两个数字对应二进制位不同的位置的数目
@Link: https://leetcode-cn.com/problems/hamming-distance/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-07-21
"""
class Solution:
def hammingDistance(self, x, y):
return bin(x ^ y).count('1')
# -------------------------
if __name__ == "__main__":
x, y = 1, 4
# x, y = 3, 1
solution = Solution()
hamming_distance = solution.hammingDistance(x, y)
print(f"The solution of this problem is {hamming_distance}")
|
f04df87810d13395100540e524f48db20db18d52 | Litao439420999/LeetCodeAlgorithm | /Python/calculate.py | 1,149 | 3.875 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: calculate.py
@Function: 基本计算器 II
@Link: https://leetcode-cn.com/problems/basic-calculator-ii/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-07-28
"""
class Solution:
def calculate(self, s: str) -> int:
n = len(s)
stack = []
preSign = '+'
num = 0
for i in range(n):
if s[i] != ' ' and s[i].isdigit():
num = num * 10 + ord(s[i]) - ord('0')
if i == n - 1 or s[i] in '+-*/':
if preSign == '+':
stack.append(num)
elif preSign == '-':
stack.append(-num)
elif preSign == '*':
stack.append(stack.pop() * num)
else:
stack.append(int(stack.pop() / num))
preSign = s[i]
num = 0
return sum(stack)
# ----------------------------------
if __name__ == "__main__":
str = " 3/2 "
solution = Solution()
calculate_value = solution.calculate(str)
print(f"The solution of this problem is : {calculate_value}")
|
a39d90db4f8ca2489ce1c157bc075f59aba7c24d | Litao439420999/LeetCodeAlgorithm | /Python/reconstructQueue.py | 1,015 | 3.859375 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: reconstructQueue.py
@Function: 根据身高重建队列 贪心策略
@Link: https://leetcode-cn.com/problems/queue-reconstruction-by-height/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-07-06
"""
# ---------------------------
class Solution:
def reconstructQueue(self, people):
people.sort(key=lambda x: (x[0], -x[1]))
n = len(people)
ans = [[] for _ in range(n)]
for person in people:
spaces = person[1] + 1
for i in range(n):
if not ans[i]:
spaces -= 1
if spaces == 0:
ans[i] = person
break
return ans
# -------------------------
if __name__ == "__main__":
# people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]
people = [[6,0],[5,0],[4,0],[3,2],[2,2],[1,4]]
solution = Solution()
reconstruct_queue = solution.reconstructQueue(people)
print(reconstruct_queue) |
0334614a346b0a1dcddf4da9b585a997ab561dad | Litao439420999/LeetCodeAlgorithm | /Python/matrixReshape.py | 850 | 4.0625 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: matrixReshape.py
@Function: 重塑矩阵
@Link: https://leetcode-cn.com/problems/reshape-the-matrix/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-07-26
"""
from typing import List
class Solution:
def matrixReshape(self, nums: List[List[int]], r: int, c: int) -> List[List[int]]:
m, n = len(nums), len(nums[0])
if m * n != r * c:
return nums
ans = [[0] * c for _ in range(r)]
for x in range(m * n):
ans[x // c][x % c] = nums[x // n][x % n]
return ans
# -------------------------
if __name__ == "__main__":
nums = [[1, 2], [3, 4]]
# r, c = 1, 4
r, c = 2, 4
solution = Solution()
reshape_matrix = solution.matrixReshape(nums, r, c)
print(f"The solutino of this problem is {reshape_matrix}")
|
7b22af2549e23620e764bfe31cf5fbddf2a6b6bd | Litao439420999/LeetCodeAlgorithm | /Python/dailyTemperatures.py | 956 | 3.96875 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: dailyTemperatures.py
@Function: 每日温度
@Link: https://leetcode-cn.com/problems/daily-temperatures/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-07-25
"""
from typing import List
class Solution:
def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
length = len(temperatures)
ans = [0] * length
stack = []
for i in range(length):
temperature = temperatures[i]
while stack and temperature > temperatures[stack[-1]]:
prev_index = stack.pop()
ans[prev_index] = i - prev_index
stack.append(i)
return ans
# --------------------------------------
if __name__ == "__main__":
temperatures = [30,40,50,60]
solution = Solution()
daily_temperature = solution.dailyTemperatures(temperatures)
print(f"The solution of this problem is {daily_temperature}")
|
2c3bdd46d4cd3975dfb4cadb5f4f29af6bbd7872 | Litao439420999/LeetCodeAlgorithm | /Python/wiggleMaxLength.py | 1,074 | 3.71875 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: wiggleMaxLength.py
@Function: 摆动序列 动态规划
@Link:https://leetcode-cn.com/problems/wiggle-subsequence/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-07-16
"""
class Solution:
def wiggleMaxLength(self, nums) -> int:
n = len(nums)
if n < 2:
return n
up = [1] + [0] * (n - 1)
down = [1] + [0] * (n - 1)
for i in range(1, n):
if nums[i] > nums[i - 1]:
up[i] = max(up[i - 1], down[i - 1] + 1)
down[i] = down[i - 1]
elif nums[i] < nums[i - 1]:
up[i] = up[i - 1]
down[i] = max(up[i - 1] + 1, down[i - 1])
else:
up[i] = up[i - 1]
down[i] = down[i - 1]
return max(up[n - 1], down[n - 1])
# -------------------------
if __name__ == "__main__":
nums = [1, 7, 4, 9, 2, 5]
solution = Solution()
max_length = solution.wiggleMaxLength(nums)
print(f"The solution of this problem is {max_length}")
|
adb7c6349316892da5414d10a589f891e97bb1e5 | Litao439420999/LeetCodeAlgorithm | /Python/constructFromPrePost.py | 1,101 | 3.875 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: constructFromPrePost.py
@Function: 根据前序和后序遍历构造二叉树
@Link : https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-postorder-traversal/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-08-02
"""
# Definition for a binary tree node.
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
class Solution(object):
def constructFromPrePost(self, pre, post):
def make(i0, i1, N):
if N == 0:
return None
root = TreeNode(pre[i0])
if N == 1:
return root
for L in range(N):
if post[i1 + L - 1] == pre[i0 + 1]:
break
root.left = make(i0 + 1, i1, L)
root.right = make(i0 + L + 1, i1 + L, N - 1 - L)
return root
return make(0, 0, len(pre))
# ------------------------------
if __name__ == "__main__":
# test on LeetCode online.
pass |
97427f841b2215fda35a0110c3323725acace837 | Litao439420999/LeetCodeAlgorithm | /Python/findKthLargest.py | 1,315 | 3.953125 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: findKthLargest.py
@Function: 数组中的第K个最大元素 快速选择
@Link: https: // leetcode-cn.com/problems/kth-largest-element-in-an-array/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-07-10
"""
import random
class Solution:
def findKthLargest(self, nums, k):
def findTopKth(low, high):
pivot = random.randint(low, high)
nums[low], nums[pivot] = nums[pivot], nums[low]
base = nums[low]
i = low
j = low + 1
while j <= high:
if nums[j] > base:
nums[i + 1], nums[j] = nums[j], nums[i + 1]
i += 1
j += 1
nums[low], nums[i] = nums[i], nums[low]
if i == k - 1:
return nums[i]
elif i > k - 1:
return findTopKth(low, i - 1)
else:
return findTopKth(i + 1, high)
return findTopKth(0, len(nums) - 1)
# -------------------------
if __name__ == "__main__":
# nums = [3, 2, 1, 5, 6, 4]
# k = 2
nums = [3, 2, 3, 1, 2, 4, 5, 5, 6]
k = 4
solution = Solution()
kth_largest = solution.findKthLargest(nums, k)
print(f"The solution of this problem is : {kth_largest}")
|
b944a375a96ced5824239689a7e7b5f26dc854c4 | Litao439420999/LeetCodeAlgorithm | /Python/binaryTreePaths.py | 2,102 | 3.96875 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: binaryTreePaths.py
@Function: 二叉树的所有路径
@Link: https://leetcode-cn.com/problems/binary-tree-paths/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-07-12
"""
import collections
from typing import List
import string
# Definition for a binary tree node.
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
# 方法一：深度优先搜索
class Solution:
def binaryTreePaths(self, root):
"""
:type root: TreeNode
:rtype: List[str]
"""
def construct_paths(root, path):
if root:
path += str(root.val)
if not root.left and not root.right: # 当前节点是叶子节点
paths.append(path) # 把路径加入到答案中
else:
path += '->' # 当前节点不是叶子节点，继续递归遍历
construct_paths(root.left, path)
construct_paths(root.right, path)
paths = []
construct_paths(root, '')
return paths
# 方法二：广度优先搜索
class Solution:
def binaryTreePaths(self, root: TreeNode) -> List[str]:
paths = list()
if not root:
return paths
node_queue = collections.deque([root])
path_queue = collections.deque([str(root.val)])
while node_queue:
node = node_queue.popleft()
path = path_queue.popleft()
if not node.left and not node.right:
paths.append(path)
else:
if node.left:
node_queue.append(node.left)
path_queue.append(path + '->' + str(node.left.val))
if node.right:
node_queue.append(node.right)
path_queue.append(path + '->' + str(node.right.val))
return paths
# ------------------------
if __name__ == "__main__":
# test on LeetCode online.
pass
|
6bc5f504ef16bea225cae8f52e818fb96687b002 | Litao439420999/LeetCodeAlgorithm | /Python/sumOfLeftLeaves.py | 1,006 | 3.78125 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: sumOfLeftLeaves.py
@Function: 左叶子之和
@Link: https://leetcode-cn.com/problems/sum-of-left-leaves/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-08-01
"""
# Definition for a binary tree node.
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
class Solution:
def sumOfLeftLeaves(self, root: TreeNode) -> int:
def isLeafNode(node): return not node.left and not node.right
def dfs(node: TreeNode) -> int:
ans = 0
if node.left:
ans += node.left.val if isLeafNode(
node.left) else dfs(node.left)
if node.right and not isLeafNode(node.right):
ans += dfs(node.right)
return ans
return dfs(root) if root else 0
# ----------------------------------
if __name__ == "__main__":
# test on LeetCode online.
pass
|
8b39bba2440821071ad46e65071a642da9ce5434 | Litao439420999/LeetCodeAlgorithm | /Python/lowestCommonAncestor2.py | 962 | 3.65625 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: lowestCommonAncestor2.py
@Function: 二叉树的最近公共祖先
@Link : https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-08-02
"""
# Definition for a binary tree node.
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
class Solution:
def lowestCommonAncestor(self, root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:
if not root or root == p or root == q:
return root
left = self.lowestCommonAncestor(root.left, p, q)
right = self.lowestCommonAncestor(root.right, p, q)
if not left:
return right
if not right:
return left
return root
# ------------------------------
if __name__ == "__main__":
# test on LeetCode online.
pass
|
fbc71fc9cb47523ce6a7b1aed3f1c24b3723846b | Litao439420999/LeetCodeAlgorithm | /Python/numSquares.py | 1,301 | 3.671875 | 4 | #!/usr/bin/env python3
# encoding: utf-8
"""
@Filename: numSquares.py
@Function: 完全平方数 动态规划
@Link: https://leetcode-cn.com/problems/perfect-squares/
@Python Version: 3.8
@Author: Wei Li
@Date：2021-07-14
"""
class Solution:
def numSquares(self, n: int) -> int:
'''版本一'''
# 初始化
nums = [i**2 for i in range(1, n + 1) if i**2 <= n]
dp = [10**4]*(n + 1)
dp[0] = 0
# 遍历背包
for j in range(1, n + 1):
# 遍历物品
for num in nums:
if j >= num:
dp[j] = min(dp[j], dp[j - num] + 1)
return dp[n]
def numSquares1(self, n: int) -> int:
'''版本二'''
# 初始化
nums = [i**2 for i in range(1, n + 1) if i**2 <= n]
dp = [10**4]*(n + 1)
dp[0] = 0
# 遍历物品
for num in nums:
# 遍历背包
for j in range(num, n + 1):
dp[j] = min(dp[j], dp[j - num] + 1)
return dp[n]
# -------------------------
if __name__ == "__main__":
# n = 12
n = 13
solution = Solution()
# num_sequares = solution.numSquares(n)
num_sequares = solution.numSquares1(n)
print(f"The solution of this problem is : {num_sequares}")
|
3bb8a813d915675a1aec37019e157674a162dfef | renatovvjr/candidatosDoacaoPython | /main.py | 1,269 | 3.796875 | 4 | #O programa receberá informações de 10 candidatos à doação de sangue. O programa deverá ler a idade e informar a seguinte condição:
#- Se menor de 16 ou acima de 69 anos, não poderá doar;
#- Se tiver entre 16 e 17 anos, somente poderá doar se estiver acompanhado dos pais ou responsáveis (neste caso criar uma condição: "Está acompanhado de pais ou responsável: 1-sim ou 2-não);
#- Se tiver entre 18 e 69 anos, poderá doar.
#Ao final o programa deverá mostrar quantos candidatos poderão doar sangue.
idade=0
doadorMenorIdoso=0
doadorAdolescente=0
doadorAdulto=0
simNao=0
podeDoar=0
naoPodeDoar=0
adolescente=0
for i in range(0, 10):
idade = int(input('Informe a idade do candidato à doação: '))
if idade <16 or idade > 69:
doadorMenorIdoso+=1
elif 16<=idade<=17:
simNao = int(input('Está acompanhado de pais ou responsável? Digite [1 - SIM] ou [2 - NÃO]'))
if simNao == 1:
doadorAdolescente+=1
else :
adolescente+=1
else :
doadorAdulto+=1
naoPodeDoar = doadorMenorIdoso + adolescente
podeDoar = doadorAdolescente + doadorAdulto
print(naoPodeDoar, ' candidatos não atenderam aos critérios para doação de sangue.')
print(podeDoar, ' candidatos atenderam aos critérios para doação de sangue e poderão doar.') |
ef1db11ab060501a5f23c772da2e3467889b3fb3 | Zetinator/just_code | /python/leetcode/jumping_clouds.py | 655 | 3.84375 | 4 | """
Emma is playing a new mobile game that starts with consecutively numbered clouds. Some of the clouds are thunderheads and others are cumulus. She can jump on any cumulus cloud having a number that is equal to the number of the current cloud plus 1 or 2. She must avoid the thunderheads.
"""
def deep(x, jumps):
if not x or len(x) == 1: return jumps
print(f'STATUS: x: {x}, jumps: {jumps}')
if x[0] == 1: return float('inf')
return min(deep(x[1:], jumps+1), deep(x[2:], jumps+1))
def play(x):
return deep(x, 0)
# test
# test = [0, 0, 1, 0, 0, 1, 0]
test = [0,0,0,1,0,0]
print(f'testing with: {test}')
print(f'ans: {play(test)}')
|
dd146b10d8b6c0900a77754d93b0c9231e2737a8 | Zetinator/just_code | /python/leetcode/sorting_bubble_sort.py | 1,012 | 4.09375 | 4 | """https://www.hackerrank.com/challenges/ctci-bubble-sort/problem?h_l=interview&playlist_slugs%5B%5D%5B%5D=interview-preparation-kit&playlist_slugs%5B%5D%5B%5D=sorting
Given an array of integers, sort the array in ascending order using the Bubble Sort algorithm above. Once sorted, print the following three lines:
Array is sorted in numSwaps swaps., where is the number of swaps that took place.
First Element: firstElement, where is the first element in the sorted array.
Last Element: lastElement, where is the last element in the sorted array.
"""
def countSwaps(x):
swaps = 0
for i in x:
for j in range(len(x)-1):
if x[j] > x[j+1]:
x[j], x[j+1] = x[j+1], x[j]
swaps += 1
print(f'Array is sorted in {swaps} swaps.')
print(f'First Element: {x[0]}')
print(f'Last Element: {x[-1]}')
# test
test = [33, 66, 1, 65, 5, 7, 41, 74, 11, 45, 14, 60, 48, 84, 85, 31, 93, 63]
print(f'testing with: {test}')
print(f'ans: {countSwaps(test)}')
|
2dcdbed4df8b0608780c4d3a226c4f25d0de2b38 | Zetinator/just_code | /python/leetcode/binary_distance.py | 872 | 4.1875 | 4 | """
The distance between 2 binary strings is the sum of their lengths after removing the common prefix. For example: the common prefix of 1011000 and 1011110 is 1011 so the distance is len("000") + len("110") = 3 + 3 = 6.
Given a list of binary strings, pick a pair that gives you maximum distance among all possible pair and return that distance.
"""
def binary_distance(x: 'binary string', y: 'binary string') -> 'distance':
def find_prefix(x, y, n):
if not x or not y: return n
# print(f'STATUS: x:{x}, y:{y}, n:{n}')
if x[0] == y[0]:
return find_prefix(x[1:], y[1:], n+1)
else:
return n
prefix_len = find_prefix(x, y, 0)
x, y = x[prefix_len:], y[prefix_len:]
return len(x) + len(y)
# test
x = '1011000'
y = '1011110'
print(f'testing with: x:{x}, y:{y}')
print(f'ANS: {binary_distance(x, y)}')
|
2b9f81e6106ebe23353158a2b4b3f12d034003e7 | Zetinator/just_code | /python/leetcode/simple_text_editor.py | 1,697 | 4 | 4 | """https://www.hackerrank.com/challenges/simple-text-editor/problem
In this challenge, you must implement a simple text editor. Initially, your editor contains an empty string, . You must perform operations of the following types:
append - Append string to the end of .
delete - Delete the last characters of .
print - Print the character of .
undo - Undo the last (not previously undone) operation of type or , reverting to the state it was in prior to that operation.
"""
class TE():
def __init__(self):
self.stack = ['']
def append(self, x):
"""append new string to the past string
"""
if not x: return
self.stack.append(self.stack[-1] + x)
def delete(self, k):
"""delete the last k elements
"""
self.stack.append(self.stack[-1][:-k])
def print(self, k):
"""print the last k element
"""
k -= 1
print(self.stack[-1][k])
def undo(self):
"""undo the last operation
"""
self.stack.pop()
def execute_query(te, q):
"""simple interface to process the queries
"""
if q[0] == '1':
return te.append(q[1])
if q[0] == '2':
return te.delete(int(q[1]))
if q[0] == '3':
return te.print(int(q[1]))
else: return te.undo()
# read from stdin
te = TE()
for _ in range(int(input())):
q = [e for e in input().split()]
execute_query(te, q)
# local test...
test = """1 abc
3 3
2 3
1 xy
3 2
4
4
3 1"""
_t = []
for line in test.split('\n'):
tmp = []
for e in line.split():
tmp.append(e)
_t.append(tmp)
test = _t
print(f'test with: {test}')
te = TE()
for q in test:
execute_query(te, q)
|
18b95ddca9704d64627cde69375e30a880efaa95 | Zetinator/just_code | /python/leetcode/poisonous_plants.py | 3,076 | 3.921875 | 4 | """https://www.hackerrank.com/challenges/poisonous-plants/problem?h_l=interview&playlist_slugs%5B%5D=interview-preparation-kit&playlist_slugs%5B%5D=stacks-queues
There are a number of plants in a garden. Each of these plants has been treated with some amount of pesticide. After each day, if any plant has more pesticide than the plant on its left, being weaker than the left one, it dies.
You are given the initial values of the pesticide in each of the plants. Print the number of days after which no plant dies, i.e. the time after which there are no plants with more pesticide content than the plant to their left.
"""
import sys
sys.setrecursionlimit(100000)
def poisonousPlants(p):
"""naive solution, recursive
almost there, failing because of recursion depth
"""
def r(x, ans=0):
tmp = [x[0]]
for i in range(len(x)-1):
if x[i] >= x[i+1]: tmp.append(x[i+1])
if tmp == x: return ans
return r(tmp, ans+1)
return r(p)
def poisonousPlants(p):
"""naive solution, iterative
not fast enought...
"""
for days in range(len(p)):
tmp = p[:1]
for i in range(len(p)-1):
if p[i] >= p[i+1]: tmp.append(p[i+1])
if p == tmp: return days
p = tmp
from collections import deque
def poisonousPlants(p):
"""stack solution...
the solution is a list of stacks
working... almost
"""
# create list of stacks in descendent order
stacks = []
tmp = deque(p[:1])
for i in range(len(p)-1):
if p[i] < p[i+1]:
stacks.append(tmp)
tmp = deque([p[i+1]])
else:
tmp.append(p[i+1])
# push the remaining
stacks.append(tmp)
if len(stacks[0]) == len(p): return 0
print(f'stacks: {stacks}')
for days in range(1, len(p)):
current_min = stacks[0][-1]
pop_flag = False
for stack in stacks[1:]:
if not stack: continue
print(f'day: {days}, stack: {stack}, current_min: {current_min}')
while stack and stack[0] > current_min:
print(f'deque: {stack[0]}')
stack.popleft()
pop_flag = True
current_min = stack[-1] if stack else current_min
if not pop_flag: return days
from collections import deque
def poisonousPlants(p):
"""optimized solution
"""
# create list of stacks
stacks, days = [deque(p[:1])], 0
for i, v in enumerate(p[1:], 1):
if p[i-1] < v: stacks += [deque([v])]
else: stacks[-1] += [v]
# consecutive pops according to the days
while len(stacks) > 1:
i = 1
while i < len(stacks):
stacks[i].popleft()
if not stacks[i]: stacks.pop(i)
elif stacks[i-1][-1] >= stacks[i][0]:
stacks[i-1] += stacks[i]
stacks.pop(i)
else: i += 1
days += 1
return days
# test
test = [6,5,8,4,7,10,9]
test = [4, 3, 7, 5, 6, 4, 2,]
# test = [3,2,5,4]
print(f'testing with {test}')
print(f'ans: {poisonousPlants(test)}')
|
246928be6fa574268809d7291343ff2e7d099234 | Zetinator/just_code | /python/classics/max_change.py | 654 | 3.8125 | 4 | """
Coin Change problem: Given a list of coin values in a1, what is the minimum number of coins needed to get the value v?
"""
from functools import lru_cache
@lru_cache(maxsize=1000)
def r(x, coins, coins_used):
"""recursive implementation
"""
if x <=0: return coins_used
return min(r(x-coin, coins, coins_used+1) for coin in coins)
def max_change(money: int, coins: tuple) -> int:
"""finds the minimum combination of 'coins' to reach the 'money' quantity
"""
return r(money, coins, 0)
# test
money = 24
coins = (1,3,4,5)
print(f'test with: money: {money}, coins: {coins}')
print(f'min coins: {max_change(money, coins)}')
|
319781d2b8b2a6bb1fdbb3070ac71057b4e949a0 | Zetinator/just_code | /python/data_structures/radix_trie.py | 5,142 | 3.53125 | 4 | """custom implementation of a radix trie with the purpose of practice
the ADT contains the following methods:
- insert
- search
- delete
"""
class RTrie():
class Node():
"""Node basic chainable storage unit
"""
def __init__(self, x=None):
self.data = x
self.children = {}
def __init__(self, keys=None):
self.root = self.Node()
if keys:
for key in keys:
self.insert(key)
def __repr__(self):
nodes = []
def r(node, level):
if node.data != None:
nodes.append('\t'*(level-1) + f'({node.data})\n')
for k,child in node.children.items():
nodes.append('\t'*level + f'--<{k}>--\n')
r(child, level+1)
r(self.root, 0)
return ''.join(nodes)
def insert(self, key):
"""insert a new key... recursive attempt
"""
data = key
def lcp(key_1, key_2):
"""largest common prefix
"""
for i in range(min(len(key_1),len(key_2))):
if key_1[i] != key_2[i]: return i
return i+1
def r(current_node, key):
"""recursive branching...
no children -> new branch
common root + remainings -> split and extend
common root + no remainings -> extend
no comomon root -> create new branch
"""
# base case... no children
if not current_node.children:
current_node.children.setdefault(key, self.Node()).data = data
return
# look for similar roots in the children...
for k, child in current_node.children.items():
i = lcp(k, key)
prefix, suffix, key = k[:i], k[i:], key[i:]
if prefix and suffix:
# common root found... branching
current_node.children[prefix] = self.Node()
del(current_node.children[k])
# append suffixs to common root
current_node.children[prefix].children[suffix] = self.Node()
current_node.children[prefix].children[suffix].data = child.data
current_node.children[prefix].children[suffix].children = child.children
# recurse on the shared root
return r(current_node.children[prefix], key)
elif prefix and not suffix:
# common root found... extending
return r(child, key)
# no common root... create new child branch
current_node.children.setdefault(key, self.Node()).data = data
return r(self.root, key)
def predict(self, key=None):
"""predict all branches of the lowest common ancestor
"""
if not self.root.children: raise ValueError(f'{key} not found')
def lcp(key_1, key_2):
"""largest common prefix
"""
i = 0
while i < min(len(key_1),len(key_2)):
if key_1[i] != key_2[i]: return i
i += 1
return i
nodes = []
def dig(node):
"""explore all the leafs from the current_node
"""
if node.data != None: nodes.append(f'{node.data}')
for k,child in node.children.items(): dig(child)
def r(current_node, key):
"""search recursively the given key
"""
# base case... no children
if not key:
return dig(current_node)
# look for similar roots in the children...
for k, child in current_node.children.items():
i = lcp(k, key)
prefix, suffix, key = k[:i], k[i:], key[i:]
if prefix in current_node.children:
# recurse on the shared root
return r(current_node.children[prefix], key)
return dig(current_node)
r(self.root, key)
return nodes
def search(self, key):
"""search for a given key in the trie
"""
if not self.root.children: raise ValueError(f'{key} not found')
def lcp(key_1, key_2):
"""largest common prefix
"""
i = 0
while i < min(len(key_1),len(key_2)):
if key_1[i] != key_2[i]: return i
i += 1
return i
_key = key[:]
def r(current_node, key):
"""search recursively
"""
# base case... no children
if not key:
return current_node
# look for similar roots in the children...
for k, child in current_node.children.items():
i = lcp(k, key)
prefix, suffix, key = k[:i], k[i:], key[i:]
if prefix:
# recurse on the shared root
return r(current_node.children[prefix], key)
raise ValueError(f'{_key} not found')
return r(self.root, key)
|
27db300075e7661296ee4d494f378aac89b21c83 | Zetinator/just_code | /python/algorithms/dinic.py | 2,041 | 4 | 4 | """implementation of the dinic's algorithm
computes the max flow possible within a given network gaph
https://visualgo.net/en/maxflow
https://en.wikipedia.org/wiki/Dinic%27s_algorithm
"""
from data_structures import network_graph
def dinic(graph: network_graph.NGraph) -> int:
"""computes the maximum flow value of the network
"""
# set-up
residual_network = network_graph.NGraph(graph.inner, graph.source, graph.sink)
dinic.max_flow = 0
dinic.parents = {}
# retrieve bottle neck function
def blocking_flow(node, minimum=float('inf')):
"""returns the value of the bottleneck once the sink is been reached
"""
if not node: return minimum
minimum = min(minimum, residual_network.capacity(dinic.parents[node], node))
# recursively find minimum to return
minimum = blocking_flow(dinic.parents[node], minimum)
# update residual graph
residual_network.capacities[dinic.parents[node], node] -= minimum
return minimum
# standard bfs
def bfs(start, end):
"""standard bfs, with implicit queue
modified to stop once the sink is been reached and increase the max flow
"""
dinic.parents = {graph.source:None}
frontier = [graph.source]
while frontier:
_next = []
for current_node in frontier:
for node in graph.neighbors(current_node):
if node not in dinic.parents\
and residual_network.capacity(current_node, node)>0:
dinic.parents[node] = current_node
# sink within reach, increase max-flow
if node == graph.sink:
dinic.max_flow += blocking_flow(graph.sink)
return True
_next.append(node)
frontier = _next
# repeat until there are no more augmenting paths... s -> t
while(bfs(graph.source, graph.sink)): pass
return dinic.max_flow
|
6fc20cea6cd490bd44af17299584ee0be51356e4 | Zetinator/just_code | /python/leetcode/min_swaps_2.py | 1,795 | 3.796875 | 4 | """https://www.hackerrank.com/challenges/minimum-swaps-2/problem?h_l=interview&playlist_slugs%5B%5D%5B%5D=interview-preparation-kit&playlist_slugs%5B%5D%5B%5D=arrays
You are given an unordered array consisting of consecutive integers [1, 2, 3, ..., n] without any duplicates. You are allowed to swap any two elements. You need to find the minimum number of swaps required to sort the array in ascending order.
"""
# the above was too slow for hackerrank...
def minimumSwaps(x):
current_pos = {e: i for i, e in enumerate(x)}
swaps = 0
for i in range(len(x)):
# skip if item is already where it should
if x[i] == i+1: continue
# standard swap
x[i], x[current_pos[i+1]] = i+1, x[i]
# update the current position of the swaped item
current_pos[x[current_pos[i+1]]] = current_pos[i+1]
swaps += 1
return swaps
def minimumSwaps(x):
sorted_x = sorted(x)
right_pos = {e: i for i, e in enumerate(sorted_x)}
def entropy(x, right_pos):
return [i-right_pos[e] for i,e in enumerate(x)]
swaps = 0
while sorted_x != x:
swaps += 1
minima = min([i for i in range(len(x))], key=lambda i: i-right_pos[x[i]])
maxima = max([i for i in range(minima, len(x))], key=lambda i: i-right_pos[x[i]])
print(f'entropy current state: x: {x}, entropy: {entropy(x, right_pos)}')
print(f'min: {minima}, maxima: {maxima}')
x[minima], x[maxima] = x[maxima], x[minima]
print(x)
return swaps
test = [7, 1, 3, 2, 4, 5, 6]
test = [2, 1, 3, 1, 2]
# test = [2, 1, 3, 7, 4, 5, 6]
# test = [1, 2, 3, 7, 4, 5, 6]
# test = [1, 2, 3, 4, 7, 5, 6]
# test = [1, 2, 3, 4, 5, 7, 6]
# test = [1, 2, 3, 4, 5, 6, 7]
print(f'testing with: {test}')
print(f'ans: {minimumSwaps(test)}')
|
c1d4def8281d064203472299ab75b786a9261ae2 | Zetinator/just_code | /python/leetcode/find_maximum_index_product.py | 1,328 | 3.9375 | 4 | """https://www.hackerrank.com/challenges/find-maximum-index-product/problem
You are given a list of numbers . For each element at position (), we define and as:
Sample Input
5
5 4 3 4 5
Sample Output
8
Explanation
We can compute the following:
The largest of these is 8, so it is the answer.
"""
def solve(arr):
"""we keep a stack to access the next biggest in O(1)
"""
stack_left, stack_right = [], []
left, right = [], []
# left -> right
for i,e in enumerate(arr):
while stack_left and e >= stack_left[-1][0]:
stack_left.pop()
left.append(stack_left[-1][1] if stack_left else 0)
stack_left.append((e, i+1))
# right -> left
for i in reversed(range(len(arr))):
while stack_right and arr[i] >= stack_right[-1][0]:
stack_right.pop()
right.append(stack_right[-1][1] if stack_right else 0)
stack_right.append((arr[i], i+1))
# multiply and we are done...
res = -float('inf')
for i,e in enumerate(left):
res = max(res, (left[i])*(right[len(right)-1 -i]))
return res
test = """5 4 3 4 5"""
test = [int(e) for e in test.split()]
with open('./test_data.txt', 'r') as f:
for line in f:
test = [int(n) for n in line.split()]
print(f'testing with: {test[:10]}...')
print(f'ans: {solve(test)}')
|
308f485babf73eec8c433821951390b8c2414750 | Zetinator/just_code | /python/leetcode/pairs.py | 966 | 4.1875 | 4 | """https://www.hackerrank.com/challenges/pairs/problem?h_l=interview&playlist_slugs%5B%5D%5B%5D=interview-preparation-kit&playlist_slugs%5B%5D%5B%5D=search
You will be given an array of integers and a target value. Determine the number of pairs of array elements that have a difference equal to a target value.
Complete the pairs function below. It must return an integer representing the number of element pairs having the required difference.
pairs has the following parameter(s):
k: an integer, the target difference
arr: an array of integers.
"""
from collections import Counter
def pairs(k, arr):
counter = Counter()
n_pairs = 0
for e in arr:
# print(f'e: {e}, counter: {counter}, n_pairs: {n_pairs}')
if e in counter:
n_pairs += counter[e]
counter[e+k] += 1
counter[e-k] += 1
return n_pairs
# test
k = 2
arr = [1,3,5,8,6,4,2]
print(f'testing with: {arr}')
print(f'ans: {pairs(k, arr)}')
|
671ea3e72e4ff94b20aed867eb3c4075b2be4d92 | Zetinator/just_code | /python/classics/longest_common_substring.py | 828 | 3.9375 | 4 | """In computer science, the longest common substring problem is to find the longest string (or strings) that is a substring (or are substrings) of two or more strings.
https://en.wikipedia.org/wiki/Longest_common_substring_problem
"""
from functools import lru_cache
@lru_cache(maxsize=1000)
def r(x, y, record=0):
"""recursive implementation
"""
if not x or not y: return record
print(f'STATUs: x: {x}, y: {y}, record: {record}')
if x[0] == y[0]:
return max(record, r(x[1:], y[1:], record+1))
return max(record, r(x, y[1:], 0), r(x[1:], y, 0))
def lcs(x, y):
"""returns the longest common substring in O(N*M)
"""
if not x or not y: return 0
return r(x, y)
# test
e = 'kim es super bonita'
m = 'erick es lo maximo'
print(f'testing with: {e}, {m}')
print(f'ans: {lcs(e, m)}')
|
d7927eb47f552113d335a0e1b04f608e852a8c3a | Zetinator/just_code | /python/leetcode/string_comparator.py | 910 | 4.0625 | 4 | """https://www.hackerrank.com/challenges/ctci-comparator-sorting/problem?h_l=interview&playlist_slugs%5B%5D%5B%5D=interview-preparation-kit&playlist_slugs%5B%5D%5B%5D=sorting&h_r=next-challenge&h_v=zen&h_r=next-challenge&h_v=zen
Comparators are used to compare two objects. In this challenge, you'll create a comparator and use it to sort an array. The Player class is provided in the editor below. It has two fields:
"""
from collections import namedtuple
Player = namedtuple('Player', ['name', 'score'])
def sort_data(players):
players = [Player(*e) for e in players]
players = sorted(players, key=lambda x: (x.score, [-ord(e) for e in x.name]))
players.reverse()
return players
# test
players = [('amy', 100),
('david', 100),
('heraldo', 50),
('aakansha', 75),
('aleksa', 150)]
print(f'testing with: test: {players}')
print(f'ans: {sort_data(players)}')
|
e823b273ed44482d8c05499f66bf76e78b06d842 | Zetinator/just_code | /python/leetcode/special_string_again.py | 2,477 | 4.21875 | 4 | """https://www.hackerrank.com/challenges/special-palindrome-again/problem?h_l=interview&playlist_slugs%5B%5D%5B%5D=interview-preparation-kit&playlist_slugs%5B%5D%5B%5D=strings
A string is said to be a special string if either of two conditions is met:
All of the characters are the same, e.g. aaa.
All characters except the middle one are the same, e.g. aadaa.
A special substring is any substring of a string which meets one of those criteria. Given a string, determine how many special substrings can be formed from it.
"""
def is_special(s):
"""checks if the substring is "special"
"""
# special case:
if len(s) == 1: return True
# general case
match = s[0]
for i in range(len(s)//2):
if s[i] != match or s[i] != s[-(1+i)]: return False
return True
def substrCount(n, s):
"""counts how many substrings are "special"
somehow not fast enought... maybe because of the function call
"""
n_specials = 0
for i in range(len(s)):
for j in range(i, len(s)):
n_specials += 1 if is_special(s[i:j+1]) else 0
return n_specials
def substrCount(n, s):
res = 0
count_sequence = 0
prev = ''
for i,v in enumerate(s):
# first increase counter for all seperate characters
count_sequence += 1
if i and (prev != v):
# if this is not the first char in the string
# and it is not same as previous char,
# we should check for sequence x.x, xx.xx, xxx.xxx etc
# and we know it cant be longer on the right side than
# the sequence we already found on the left side.
j = 1
while ((i-j) >= 0) and ((i+j) < len(s)) and j <= count_sequence:
# make sure the chars to the right and left are equal
# to the char in the previous found squence
if s[i-j] == prev == s[i+j]:
# if so increase total score and step one step further out
res += 1
j += 1
else:
# no need to loop any further if this loop did
# not find an x.x pattern
break
#if the current char is different from previous, reset counter to 1
count_sequence = 1
res += count_sequence
prev = v
return res
# test
# s = 'asasd'
s = 'abcbaba'
n = 5
print(f'testing with: {s}')
print(f'ans: {substrCount(n, s)}')
|
768f200cbdbbbd4808c4eea18004f7e4ff7c912c | Zetinator/just_code | /python/data_structures/double_linked_list.py | 3,017 | 3.96875 | 4 | """custom implementation of a double linked list with the purpose of practice
the ADT contains the following methods:
- append
- insert
- search
- delete
- traverse
"""
class DoubleLinkedList():
class Node():
"""Node basic chainable storage unit
"""
def __init__(self, x=None, prev=None):
self.value = x
self.prev = prev
self.next = None
def __init__(self, x=[]):
self.head = None
for e in x:
self.append(e)
def append(self, x):
"""append a new node to the tail
"""
if not self.head:
self.head = self.Node(x)
return
current_node = self.head
while current_node.next:
current_node = current_node.next
current_node.next = self.Node(x, prev=current_node)
return
def search(self, x):
"""search for a node with the given 'x' value
"""
current_node = self.head
while current_node:
if current_node.value == x: return current_node
current_node = current_node.next
raise ValueError(f'{x} not found')
def insert(self, x, index):
"""inserts a new node with value 'x' at the 'index' position
"""
# special case: empty list
if not self.head:
self.append(x)
return
# special case: replace head
if index == 0:
tmp = self.head
self.head = self.Node(x)
self.head.next = tmp
return
# general case
current_node = self.head
while current_node.next and (index-1):
current_node = current_node.next
index -= 1
tmp = current_node.next
current_node.next = self.Node(x, prev=current_node)
current_node.next.next = tmp
def delete(self, x):
"""deletes the node with value 'x'
"""
# special case: empty list
if not self.head: raise ValueError(f'{x} not in the list')
# special case: delete head
if self.head.value == x:
self.head = self.head.next
return
# general case
current_node = self.head
while current_node.next:
if current_node.next.value == x:
current_node.next = current_node.next.next
return
current_node = current_node.next
raise ValueError(f'{x} not in the list')
def traverse(self):
"""print all the nodes in the link
"""
current_node = self.head
while current_node:
print(f'{current_node.value}', end=' -> ')
current_node = current_node.next
print('null')
def __repr__(self):
current_node = self.head
ans = []
while current_node:
ans.append(f'{current_node.value} -> ')
current_node = current_node.next
ans.append('null')
return ''.join(ans)
|
51e43263d84055e470d62d41a870972357ab30f2 | Zetinator/just_code | /python/leetcode/give_change.py | 472 | 3.671875 | 4 | def give_change(quantity):
coins = [25, 10, 5, 1]
def go_deep(quantity, coins, change):
print('STATUS: quantity: {}, coins:{}, change:{}'.format(quantity, coins, change))
if quantity <= 0: return change
n = quantity // coins[0]
change[coins[0]] = n
quantity -= n*coins[0]
return go_deep(quantity, coins[1:], change)
return go_deep(quantity, coins, {})
# test
print('testing with 2350')
print(give_change(2399))
|
6ee354648d87ca74e3a5c3776c70741bed442799 | Zetinator/just_code | /python/leetcode/candies.py | 3,186 | 3.984375 | 4 | """https://www.hackerrank.com/challenges/candies/problem?h_l=interview&playlist_slugs%5B%5D%5B%5D=interview-preparation-kit&playlist_slugs%5B%5D%5B%5D=dynamic-programming
Alice is a kindergarten teacher. She wants to give some candies to the children in her class. All the children sit in a line and each of them has a rating score according to his or her performance in the class. Alice wants to give at least 1 candy to each child. If two children sit next to each other, then the one with the higher rating must get more candies. Alice wants to minimize the total number of candies she must buy.
For example, assume her students' ratings are [4, 6, 4, 5, 6, 2]. She gives the students candy in the following minimal amounts: [1, 2, 1, 2, 3, 1]. She must buy a minimum of 10 candies.
"""
import time
def candies(n, arr):
"""dev version
returns score with traceback
"""
def r(arr, prev, acc, ans=None):
# remember...
time.sleep(.1)
p_grade, p_candie = prev
if not arr: return (acc, (p_grade,p_candie))
c_candie = 1
while True:
print(f'arr: {arr}, c: {arr[0]}, p_candie: {p_candie}')
# depending on the past state decide
if arr[0] <= p_grade:
if p_candie - 1 <= 0: print('geht nicht...'); return
ans = r(arr[1:], (arr[0], c_candie), acc + c_candie)
if arr[0] > p_grade:
ans = r(arr[1:], (arr[0], p_candie+1), acc + p_candie+1)
# if failure... change current_state
if ans:
return ans + ((p_grade,p_candie),)
else:
c_candie += 1
retry = 1
while True:
ans = r(arr[1:], (arr[0], retry), retry)
if ans:
score, *traceback = ans
traceback.reverse()
print(f'traceback: {traceback}')
return score
retry += 1
from functools import lru_cache
import sys
sys.setrecursionlimit(100000)
def candies(n, arr):
"""prod version
some good old backtracking...
"""
candies = [1] * len(arr)
def r(i):
# accept
if i == len(arr): return True
if i < len(arr)-1 and arr[i] < arr[i+1]:
candies[i+1] = candies[i] + 1
return r(i+1)
# reject
if arr[i-1] > arr[i] and candies[i-1] - 1 == 0:
return
# change state
while True:
if r(i+1): return True
candies[i] += 1
# init
while True:
if r(0):
return sum(candies)
else:
candies[0] += 1
def candies(n, arr):
"""naive approach
"""
candies = [1] * len(arr)
# left -> right
for i in range(len(arr)-1):
if arr[i] < arr[i+1]:
candies[i+1] = max(candies[i+1], candies[i] + 1)
# right -> left
for i in reversed(range(1, len(arr))):
if arr[i] < arr[i-1]:
candies[i-1] = max(candies[i-1], candies[i] + 1)
return sum(candies)
test = [4, 6, 4, 5, 6, 2]
test = [1,2,2]
# test = [2,4,2,6,1,7,8,9,2,1]
# test = [2,4,3,5,2,6,4,5]
n = len(test)
print(f'testing with: {test}')
print(f'ans: {candies(n, test)}')
|
7353020b0f9f4e876ad39334bad7953aa1096b44 | Zetinator/just_code | /python/leetcode/max_min.py | 965 | 3.953125 | 4 | """https://www.hackerrank.com/challenges/angry-children/problem?h_l=interview&playlist_slugs%5B%5D%5B%5D=interview-preparation-kit&playlist_slugs%5B%5D%5B%5D=greedy-algorithms
Complete the maxMin function in the editor below. It must return an integer that denotes the minimum possible value of unfairness.
maxMin has the following parameter(s):
k: an integer, the number of elements in the array to create
arr: an array of integers .
"""
def maxMin(k, arr):
s_arr = sorted(arr)
minima = float('inf')
for i in range(len(s_arr)-(k-1)):
# the begining is inclusive and the end is exclusive
print(f'max: {s_arr[i+(k-1)]}, min: {s_arr[i]}')
delta = s_arr[i+(k-1)] - s_arr[i]
if delta < minima: minima = delta
return minima
# test
k = 4
arr = [1,
2,
3,
4,
10,
20,
30,
40,
100,
200]
print(f'testing with: {arr}')
print(f'ans: {maxMin(k, arr)}')
|
44b2c2a5ef7e890d3f38b6ccb1e990ed668930d2 | Zetinator/just_code | /python/data_structures/max_heap.py | 3,645 | 3.875 | 4 | """custom implementation of a max heap tree with the purpose of practice
the ADT contains the following methods:
- push
- peek
- pop
"""
class Heap():
def __init__(self, x=[]):
self.v = []
for e in x:
self.push(e)
def __len__(self):
return len(self.v)
def __repr__(self):
return str(self.v)
def push(self, x):
"""push a new element into the heap
can also push tuples with the priority as the first element :)
"""
# special case: push None element
if not x: return
# auxiliar function to compute the parent index
parent = lambda i: max((i-1)//2, 0)
v = self.v # alias because i am lazy to write
# special case: empty heap
if not v: v.append(x); return
# general case
i = len(v)
v.append(x)
# bubble up...
while v[parent(i)] < v[i]:
v[parent(i)], v[i] = v[i], v[parent(i)]
i = parent(i)
def peek(self):
"""peek the maximum
"""
# special case: empty heap
if not self.v: return
return self.v[0]
def pop(self):
"""pop the maximum
"""
v = self.v # alias again
# special case: empty heap
if not v: return
# swap max <-> last
v[0], v[-1] = v[-1], v[0]
minimum = v.pop()
# bubble down
i = 0
left = lambda: i*2 + 1 if i*2 + 1 < len(v) else False
right = lambda: i*2 + 2 if i*2 + 2 < len(v) else False
while left() and v[left()] > v[i] or right() and v[right()] > v[i]:
max_child = left()
if right() and v[right()] > v[left()]:
max_child = right()
v[i], v[max_child] = v[max_child], v[i] # swap
i = max_child
return minimum
class Heap():
def __init__(self, x=[]):
self._ = []
for e in x:
self.push(e)
def push(self, x):
"""push a new element into the heap
can also push tuples with the priority as the first element :)
"""
# special case: push None element
if not x: return
# auxiliar function to compute the parent index
parent = lambda i: max((i-1)//2, 0)
_ = self._ # alias because i am lazy to write
# special case: empty heap
if not _: _.append(x); return
# general case
i = len(_)
_.append(x)
while _[parent(i)] < _[i]: # heapify-up
# print(f'index: {i}, parent: {_[parent(i)]}, current: {_[i]}')
_[parent(i)], _[i] = _[i], _[parent(i)]
i = parent(i)
def peek(self):
"""peek the maximum
"""
# special case: empty heap
if not self._: return
return self._[0]
def pop(self):
"""pop the maximum
"""
_ = self._ # alias again
# special case: empty heap
if not _: return
# swap max <-> last
_[0], _[-1] = _[-1], _[0]
maximum = _.pop()
# sift down
i = 0
i_left = lambda: i*2 + 1
i_right = lambda: i*2 + 2
while (i_left() < len(_) and _[i_left()] > _[i]) or \
(i_right() < len(_) and _[i_right()] > _[i]):
max_child = i_left()
if i_right() < len(_) and _[i_right()] > _[i_left()]:
max_child = i_right()
_[i], _[max_child] = _[max_child], _[i] # swap
i = max_child
return maximum
def __len__(self):
return len(self._)
def __repr__(self):
return str(self._)
|
e2b8fe6ba7d4d000b5ef8578aae3caf1847efc9d | Zetinator/just_code | /python/leetcode/unique_email.py | 1,391 | 4.375 | 4 | """
Every email consists of a local name and a domain name, separated by the @ sign.
For example, in alice@leetcode.com, alice is the local name, and leetcode.com is the domain name.
Besides lowercase letters, these emails may contain '.'s or '+'s.
If you add periods ('.') between some characters in the local name part of an email address, mail sent there will be forwarded to the same address without dots in the local name. For example, "alice.z@leetcode.com" and "alicez@leetcode.com" forward to the same email address. (Note that this rule does not apply for domain names.)
If you add a plus ('+') in the local name, everything after the first plus sign will be ignored. This allows certain emails to be filtered, for example m.y+name@email.com will be forwarded to my@email.com. (Again, this rule does not apply for domain names.)
It is possible to use both of these rules at the same time.
Given a list of emails, we send one email to each address in the list. How many different addresses actually receive mails?
"""
def unique_email(x: 'array with emails')-> 'array with unique emails':
ans = set()
for e in x:
name, domain = e.split('@')
name = e.replace('.','').split('+')[0]
ans.add(f'{name}@{domain}')
return list(ans)
# test
test = ["test.email+alex@leetcode.com",
"test.e.mail+bob.cathy@leetcode.com",
"testemail+david@lee.tcode.com"]
print(f'testing with: {test}')
print(f'ANS: {unique_email(test)}')
|
c80ef444ca25f5a4a263ef68b3dfdab39aa85c89 | santiagoahc/coderbyte-solutions | /medium/swapII.py | 513 | 3.5 | 4 | def SwapII(str):
new_str = []
last_digit = (None, -1)
for i, s in enumerate(str):
if s.isalpha():
s = s.lower() if s.isupper() else s.upper()
elif s.isdigit():
if last_digit[0]:
new_str[last_digit[1]] = s
s = last_digit[0]
last_digit = (None, -1)
elif i+1 < len(str) and str[i+1].isalpha():
last_digit = s, i
else:
last_digit = (None, -1)
new_str.append(s)
return ''.join(new_str)
print SwapII("123gg))((")
print SwapII("yolO11") |
b1310efca71f5bf0d3daa2d0ae9135a0edc70382 | santiagoahc/coderbyte-solutions | /medium/bracket_matcher.py | 711 | 3.96875 | 4 | def BracketMatcher(str):
round_brackets = 0
square_brackets = 0
total_pairs = 0
for s in str:
if s == '(':
round_brackets += 1
total_pairs += 1
elif s == ')':
if round_brackets < 1:
return 0
round_brackets -= 1
elif s == '[':
square_brackets += 1
total_pairs += 1
if s == ']':
if square_brackets < 1:
return 0
square_brackets -= 1
if square_brackets != 0 or round_brackets != 0:
return 0
if total_pairs == 0:
return 1
return "1 %d" % total_pairs
# code goes here
text = "Code must be properly"
more = " indented in Python!"
return text + more |
a8b5da625783c4dc555005d83ebb04dbea1b4e50 | santiagoahc/coderbyte-solutions | /medium/most_free_time.py | 1,603 | 4.09375 | 4 | """
Using the Python language, have the function MostFreeTime(strArr) read the strArr parameter being passed which will represent a full day and will be filled with events that span from time X to time Y in the day. The format of each event will be hh:mmAM/PM-hh:mmAM/PM. For example, strArr may be ["10:00AM-12:30PM","02:00PM-02:45PM","09:10AM-09:50AM"]. Your program will have to output the longest amount of free time available between the start of your first event and the end of your last event in the format: hh:mm. The start event should be the earliest event in the day and the latest event should be the latest event in the day. The output for the previous input would therefore be 01:30 (with the earliest event in the day starting at 09:10AM and the latest event ending at 02:45PM). The input will contain at least 3 events and the events may be out of order.
"12:15PM-02:00PM","09:00AM-10:00AM","10:30AM-12:00PM"
"""
def MostFreeTime(strArr):
def to_minutes(t):
h, m = map(int, t[:-2].split(':'))
h = h % 12 + (12 if t[-2] == 'P' else 0)
return h * 60 + m
events = sorted([[to_minutes(a) for a in p.split('-')] for p in strArr], key=lambda x:x[0])
breaks = [(b[0] - b[1]) for b in zip([e[0] for e in events[1:]], [e[1] for e in events[:-1]])]
return '%02d:%02d' % divmod(max(breaks), 60)
assert MostFreeTime(["12:15PM-02:00PM","09:00AM-10:00AM","10:30AM-12:00PM"]) == '00:30'
# print MostFreeTime(["12:15PM-02:00PM","09:00AM-12:11PM","02:02PM-04:00PM"])
assert MostFreeTime(["12:15PM-02:00PM", "09:00AM-12:11PM", "02:02PM-04:00PM"]) == '00:04'
|
91f2f7d0ab659ac5454438737642142c3c18af15 | santiagoahc/coderbyte-solutions | /hard/bitch.py | 2,860 | 3.625 | 4 | def gcd(a, b):
while a % b:
a, b = b, a % b
return b
def frac_reduce(num, den):
g = gcd(num, den)
return (num/g, den/g)
class Fraction:
def __init__(self, num, den=1):
self.num, self.den = frac_reduce(num, den)
def __neg__(self):
return Fraction(-self.num, self.den)
def __add__(self, other):
if type(other) == type(0):
return self + Fraction(other)
elif type(other) != type(self):
raise TypeError
return Fraction(self.num * other.den + other.num * self.den, self.den * other.den)
def __sub__(self, other):
if type(other) == type(0):
return self - Fraction(other)
elif type(other) != type(self):
raise TypeError
return self + -other
def __mul__(self, other):
if type(other) == type(0):
return self * Fraction(other)
elif type(self) != type(other):
raise TypeError
return Fraction(self.num * other.num, self.den * other.den)
def __div__(self, other):
if type(other) == type(0):
return self / Fraction(other)
elif type(other) != type(self):
raise TypeError
return Fraction(self.num * other.den, self.den * other.num)
def __eq__(self, other):
if other == None:
return False
elif type(other) == type(0):
return self == Fraction(other)
elif type(other) != type(self):
raise TypeError
return self.num == other.num and self.den == other.den
def __str__(self):
return str(self.num) if self.den == 1 else '%d/%d' % (self.num, self.den)
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
class Line:
def __init__(self, p1, p2):
self.p1 = p1
self.p2 = p2
if p1.x == p2.x:
self.m = None
else:
self.m = (p2.y - p1.y) / (p2.x - p1.x)
self.b = p1.y - self.m * p1.x
def intersection(self, other):
if self.m == other.m:
return None
elif self.m == None or other.m == None:
if self.m == None:
return other.intersection(self)
return (other.p1.x, self.m * other.p1.x + self.b)
x = (other.b - self.b) / (self.m - other.m)
#mm = sorted([self.p1.x, self.p2.x])
#if x < mm[0] or x > mm[1]:
# return None
return (x, self.m * x + self.b)
def IntersectingLines(strArr):
points = [Point(a[0], a[1]) for a in [map(Fraction, map(int, s[1:-1].split(','))) for s in strArr]]
l1 = Line(points[0], points[1])
l2 = Line(points[2], points[3])
i = l1.intersection(l2)
return '(%s,%s)' % (str(i[0]), str(i[1])) if i else 'no intersection'
print (IntersectingLines(["(100,5)","(6,2)","(2,6)","(5,100)"]))
|
70d7c7e63e2c431192dafc2df18f86ef0551541d | santiagoahc/coderbyte-solutions | /members/kaprekars.py | 1,338 | 3.671875 | 4 | """
Using the Python language,
have the function KaprekarsConstant(num) take the num parameter being passed which will be a 4-digit number with at least two distinct digits.
Your program should perform the following routine on the number:
Arrange the digits in descending order and in ascending order (adding zeroes to fit it to a 4-digit number),
and subtract the smaller number from the bigger number.
Then repeat the previous step.
Performing this routine will always cause you to reach a fixed number: 6174.
Then performing the routine on 6174 will always give you 6174 (7641 - 1467 = 6174).
Your program should return the number of times this routine must be performed until 6174 is reached.
For example:
if num is 3524 your program should return 3 because of the following steps:
(1) 5432 - 2345 = 3087, (2) 8730 - 0378 = 8352, (3) 8532 - 2358 = 6174.
"""
def KaprekarsConstant(num):
def calc(a_num, num_calc):
if a_num == 6174:
return num_calc
num_str = str(a_num)
if len(num_str) < 4:
a_num *= 10**(4-len(num_str))
num_str = str(a_num)
max_num = int("".join(sorted(num_str, reverse=True)))
min_num = int("".join(sorted(num_str)))
new_num = max_num - min_num
return calc(new_num, num_calc+1)
return calc(num, 0)
|
c685e5a1b88a50e5206e108c18453cd8206aa855 | santiagoahc/coderbyte-solutions | /medium/polish notation.py | 633 | 3.984375 | 4 | """
"+ + 1 2 3"
expr is a polish notation list
"""
def solve(expr):
"""Solve the polish notation expression in the list `expr` using a stack.
"""
operands = []
# Scan the given prefix expression from right to left
for op in reversed(expr):
if op == "+":
operands.append(operands.pop() + operands.pop())
elif op == "-":
operands.append(operands.pop() - operands.pop())
else:
operands.append(float(op))
return operands.pop()
assert solve("+ + 1 2 3".split()) == 6
assert solve("+ 10 5".split()) == 15
assert solve("- 15 - 7 + 1 1".split()) == 10
|
0bca43812f3d8fcf893ca985c8f5f7db76335a25 | santiagoahc/coderbyte-solutions | /medium/arith_geo.py | 810 | 3.609375 | 4 | __author__ = 'osharabi'
def ArithGeoII(arr):
if len(arr) <= 1:
return -1
diff = arr[1] - arr[0]
mult = arr[1] / arr[0]
i = 1
while (i+1) < len(arr) and not (diff is None and mult is None):
cur_diff = arr[i+1] - arr[i]
curr_mult = arr[i+1] / arr[i]
if cur_diff != diff:
diff = None
if curr_mult != mult:
mult = None
i += 1
if diff != None:
return 'Arithmetic'
if mult != None:
return 'Geometric'
return -1
assert ArithGeoII([1,2,3,100]) == -1
assert ArithGeoII([-2, -6, -18, -54]) == 'Geometric'
assert ArithGeoII([2, 6, 18, 54]) == 'Geometric'
assert ArithGeoII([5, 10, 15]) == "Arithmetic"
assert ArithGeoII([2, 4, 6]) == "Arithmetic"
assert ArithGeoII([-4, 4, 12]) == "Arithmetic"
|
292d7fcf6be00f2e22950fc9af2abc9f6493bf0d | santiagoahc/coderbyte-solutions | /medium/three_five_mult.py | 130 | 3.875 | 4 | def ThreeFiveMultiples(num):
return sum([n for n in range(3, num) if (n % 3 == 0 or n % 5 == 0)])
print ThreeFiveMultiples(16)
|
2a2acbc1e8bf446dd7b8ac5582d9faa5f4f7f51b | nbonfils/fixed-probe | /sensor-server.py | 6,956 | 3.5625 | 4 | #! /usr/bin/python3
# -*- coding: utf-8 -*-
"""Server that reads values from differents sensors.
This script is a server that is supposed to run on a RPi with the
adequate sensors hooked to it via GPIO.
It reads the value of the sensors then store them on disk or on
the usb drive if one is plugged, it also always export local data on
the usb drive if there are local data.
The measurements are stored in csv format in the file called :
"sensors_data.csv"
either locally in "/srv/sensors/" or directly at the root of the usb.
The sensors are:
BMP180 from adafruit : ambient temperature and barometric pressure
DS18B : water temperature
Turbidity Sensor (dishwasher) : turbidity of water
It also records the time and date of the measure.
"""
import os
import sys
from csv import DictWriter, DictReader
from time import sleep
from datetime import datetime
from w1thermsensor import W1ThermSensor
from Adafruit_BMP.BMP085 import BMP085
from turbsensor import TurbiditySensor
# Constants
DATA_FILENAME = 'sensors_data.csv'
PATH_TO_MEDIA = '/media/root'
MEASURE_INTERVAL = 60
# Global variables
need_to_export = None
data_file_exists = None
turbidity_sensor = None
def init():
"""Initialization for the server to run properly."""
global need_to_export
global data_file_exists
global turbidity_sensor
# Don't know if data file exists yet
data_file_exists = False
# Init working directory
os.chdir('/srv/sensors')
# Check if a local file is to be exported
dirents = os.listdir()
need_to_export = False
for ent in dirents:
if ent == DATA_FILENAME:
need_to_export = True
break
# Create and start the Turbidity Sensor thread on analog pin 0
pin = 0
mes_per_interval = 20
sleep = MEASURE_INTERVAL / mes_per_interval
turbidity_sensor = TurbiditySensor(pin, sleep)
turbidity_sensor.start()
def find_dev(path):
"""Find usb device absolute path.
Note:
Also check if data already exists on device and update
global variable data_file_exists.
Args:
path (str): The path to the dir where the device might be.
Returns:
str: Full path to the correct usb device.
"""
global data_file_exists
data_file_exists = False
dev = ''
# Get full path of all devices connected
dirents = [os.path.join(path, e) for e in os.listdir(path)]
# Pick first one by default if data don't exists on others
if dirents:
dev = dirents[0]
# Try to find if data file already exists on one device
for ent in dirents:
found = False
for subent in os.listdir(ent):
if subent == DATA_FILENAME:
dev = ent
data_file_exists = True
found = True
break
if found:
break
return dev
def write_data(data):
"""Write data in the file and eventually export the local file.
Note:
Change 2 global variables to know where to write next time.
Args:
data (dict): The dict containing the data for each parameter.
"""
global need_to_export
global data_file_exists
path = find_dev(PATH_TO_MEDIA)
fieldnames = [
'time',
'date',
'air_temp',
'air_pressure',
'water_temp',
'turb'
]
if path == '':
# If there is no storage device, write on disk (sd card)
with open(DATA_FILENAME, 'a', newline='') as f:
writer = DictWriter(f, fieldnames)
if not need_to_export:
# If data file will be created, add headers
writer.writeheader()
writer.writerow(data)
# As written on disk data will need to be exported now
need_to_export = True
else:
# If storage device available, check if need to export
# Create the full path to the file on the device
path = os.path.join(path, DATA_FILENAME)
if need_to_export:
# Open the 2 files and transfer the data
with open(DATA_FILENAME, 'r', newline='') as e, \
open(path, 'a+', newline='') as f:
reader = DictReader(e)
writer = DictWriter(f, fieldnames)
if not data_file_exists:
# New data file will be created on device
writer.writeheader()
data_file_exists = True
# Write data on device
for row in reader:
writer.writerow(row)
writer.writerow(data)
# Once exported remove the local data file
os.remove(DATA_FILENAME)
# No more local file to be exported
need_to_export = False
else:
# No need to export
with open(path, 'a', newline='') as f:
writer = DictWriter(f, fieldnames)
if data_file_exists:
writer.writerow(data)
else:
writer.writeheader()
writer.writerow(data)
# Data file created on disk
data_file_exists = True
def get_data():
"""Get the data from the sensors, also get the date and time.
Data recorded:
time (str): the time of the record in HH:MM:SS format.
date (str): the date of the record in DD-MM-YYYY format.
air_temp (float): the ambient temperature in Celsius.
air_pressure (float): the barometric pressure in Pascal.
water_temp (float): the temperature of the water in Celsius.
turb (int): the analog value of the turbidity (from 0 to 1024).
Returns:
dict: The data in the order of the fieldnames.
"""
global turbidity_sensor
# Date (DD-MM-YYY) and time (HH:MM:SS)
d = datetime.now()
time = '{:%H:%M:%S}'.format(d)
date = '{:%d-%m-%Y}'.format(d)
# (DS18B) Water temperature
try:
w = W1ThermSensor()
water_temp = str(w.get_temperature())
except:
water_temp = '0'
# (BMP180) Air temperature + pressure
try:
b = BMP085()
air_temp = str(b.read_temperature())
air_pressure = str(b.read_pressure())
except:
air_temp = '0'
air_pressure = '0'
# Turbidity of the water
turb = turbidity_sensor.read_turbidity()
if turb > 1023:
turb = 0
return {
'time' : time,
'date' : date,
'air_temp' : air_temp,
'air_pressure' : air_pressure,
'water_temp' : water_temp,
'turb' : turb
}
def main():
"""The main function of the program."""
init()
while True:
data = get_data()
write_data(data)
sleep(MEASURE_INTERVAL)
return 0
if __name__ == "__main__":
sys.exit(main())
|
ca54ebba62347e2c3a4107872889e4746c51a922 | malbt/PythonFundamentals.Exercises.Part5 | /anagram.py | 497 | 4.375 | 4 | def is_anagram(first_string: str, second_string: str) -> bool:
"""
Given two strings, this functions determines if they are an anagram of one another.
"""
pass # remove pass statement and implement me
first_string = sorted(first_string)
second_string = sorted(second_string)
if first_string == second_string:
print("anagram")
else:
print("not anagram")
first_string = "dormitory"
second_string = "dirtyroom"
is_anagram(first_string, second_string) |
c093ea69bbcc1a304b3d9d65580f3930ac9aeefc | jpages/twopy | /tests/quick_sort.py | 987 | 3.96875 | 4 | import random
# Very inefficient bubble sort
def bubble_sort(array):
for i in range(len(array)):
for j in range(i, len(array)):
if array[i] > array[j]:
# Swap these elements
temp = array[i]
array[i] = array[j]
array[j] = temp
return array
# More efficient quick sort (with a pivot)
def quick_sort(array):
less = []
equal = []
greater = []
if len(array) > 1:
# Chose a pivot
pivot = array[0]
for x in array:
if x < pivot:
less.append(x)
if x == pivot:
equal.append(x)
if x > pivot:
greater.append(x)
return quick_sort(less) + equal + quick_sort(greater)
else:
return array
random.seed()
array = [12, 4, 5, 6, 7, 3, 1, 15]
for i in range(10000):
array.append(int(random.random()*100000))
print(quick_sort(array))
print(bubble_sort(array))
|
e7e5c25404dcbd2c211d1ac67d59909bc48c81f7 | jpages/twopy | /tests/sum35.py | 917 | 3.75 | 4 | def sum35a(n):
'Direct count'
# note: ranges go to n-1
return sum(x for x in range(n) if x%3==0 or x%5==0)
def sum35b(n):
"Count all the 3's; all the 5's; minus double-counted 3*5's"
# note: ranges go to n-1
return sum(range(3, n, 3)) + sum(range(5, n, 5)) - sum(range(15, n, 15))
def sum35c(n):
'Sum the arithmetic progressions: sum3 + sum5 - sum15'
consts = (3, 5, 15)
# Note: stop at n-1
divs = [(n-1) // c for c in consts]
sums = [d*c*(1+d)/2 for d,c in zip(divs, consts)]
return sums[0] + sums[1] - sums[2]
#test
for n in range(1001):
sa, sb, sc = sum35a(n), sum35b(n), sum35c(n)
assert sa == sb == sc # python tests aren't like those of c.
print('For n = %7i -> %i\n' % (n, sc))
# Pretty patterns
for p in range(7):
print('For n = %7i -> %i' % (10**p, sum35c(10**p)))
# Scalability
p = 20
print('\nFor n = %20i -> %i' % (10**p, sum35c(10**p)))
|
7530cd3094d1a69ac8a8ec7f8aff2555875167ba | Fashgubben/TicTacToe | /test_program.py | 12,276 | 3.578125 | 4 | import unittest
import check_input
import check_for_winner
import game_functions
from class_statistics import Statistics, Player
from random import randint
class TestCases(unittest.TestCase):
"""Test "check_input" functions"""
def test_strip_spaces(self):
test_value1 = '1 1 '
test_value2 = ' 1 1'
test_value3 = ' 1 1 '
expected_value = '1 1'
function_value = check_input.strip_spaces(test_value1)
self.assertEqual(expected_value, function_value)
function_value = check_input.strip_spaces(test_value2)
self.assertEqual(expected_value, function_value)
function_value = check_input.strip_spaces(test_value3)
self.assertEqual(expected_value, function_value)
def test_splits_on_space(self):
test_value = '1 2'
expected_result = ['1', '2']
function_value = check_input.splits_on_space(test_value)
self.assertEqual(expected_result, function_value)
def test_convert_to_int(self):
test_value1 = ['1', '2']
test_value2 = ['1', 'a']
expected_result = [1, 2]
function_value = check_input.convert_to_int(test_value1)
self.assertEqual(expected_result, function_value)
with self.assertRaises(ValueError):
check_input.convert_to_int(test_value2)
def test_check_coordinates_count(self):
test_value1 = [randint(0, 10), randint(0, 10)]
test_value2 = [1, 2, 3]
test_value3 = [1]
expected_result = 2
function_value = check_input.check_coordinates_count(test_value1)
self.assertEqual(expected_result, len(function_value))
with self.assertRaises(ValueError):
check_input.check_coordinates_count(test_value2)
with self.assertRaises(ValueError):
check_input.check_coordinates_count(test_value3)
def test_check_coordinates_range(self):
grid_size = 4
test_value1 = [randint(0, 3), randint(0, 3)]
test_value2 = [8, 9]
function_value = check_input.check_coordinates_range(test_value1, grid_size)
self.assertIn(function_value[0] and function_value[1], range(grid_size))
with self.assertRaises(ValueError):
check_input.check_coordinates_range(test_value2, grid_size)
def test_is_coordinates_occupied(self):
test_coordinates = [0, 1]
name1 = 'Name'
name2 = 'Skynet'
game_board1 = [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
game_board2 = [['_', '_', '_'], ['X', '_', '_'], ['_', '_', '_']]
expected_value1 = [0, 1]
function_value = check_input.is_coordinates_occupied(test_coordinates, game_board1, name1)
self.assertEqual(expected_value1, function_value)
function_value = check_input.is_coordinates_occupied(test_coordinates, game_board2, name2)
self.assertFalse(function_value)
with self.assertRaises(ValueError):
check_input.is_coordinates_occupied(test_coordinates, game_board2, name1)
def test_get_valid_coordinates(self):
game_board = [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
grid_size = 3
user_input = "0 0"
name = 'Name'
expected_result = [0, 0]
function_value = check_input.get_valid_coordinates(game_board, grid_size, user_input, name)
self.assertEqual(expected_result, function_value)
def test_check_x(self):
game_board1 = [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
game_board2 = [['_', '_', '_'], ['X', 'X', 'X'], ['_', '_', '_']]
grid_size = 3
symbol = 'X'
function_value = check_for_winner.check_x(game_board1, grid_size, symbol)
self.assertNotEqual(function_value, True)
function_value = check_for_winner.check_x(game_board2, grid_size, symbol)
self.assertTrue(function_value)
def test_check_y(self):
game_board1 = [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
game_board2 = [['_', '_', 'X'], ['_', '_', 'X'], ['_', '_', 'X']]
grid_size = 3
symbol = 'X'
function_value = check_for_winner.check_y(game_board1, grid_size, symbol)
self.assertNotEqual(function_value, True)
function_value = check_for_winner.check_y(game_board2, grid_size, symbol)
self.assertTrue(function_value)
def test_check_diagonal_1(self):
game_board1 = [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
game_board2 = [['X', '_', '_'], ['_', 'X', '_'], ['_', '_', 'X']]
grid_size = 3
symbol = 'X'
function_value = check_for_winner.check_diagonal_1(game_board1, grid_size, symbol)
self.assertNotEqual(function_value, True)
function_value = check_for_winner.check_diagonal_1(game_board2, grid_size, symbol)
self.assertTrue(function_value)
def test_check_diagonal_2(self):
game_board1 = [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
game_board2 = [['_', '_', 'X'], ['_', 'X', '_'], ['X', '_', '_']]
grid_size = 3
symbol = 'X'
function_value = check_for_winner.check_diagonal_2(game_board1, grid_size, symbol)
self.assertNotEqual(function_value, True)
function_value = check_for_winner.check_diagonal_2(game_board2, grid_size, symbol)
self.assertTrue(function_value)
"""Test "class_statistics" functions"""
def test_add_win(self):
test_value = test_player.wins
test_player.add_win()
self.assertEqual(test_player.wins, test_value + 1)
def test_add_total_move(self):
test_value = test_player.total_moves
test_player.add_total_move()
self.assertEqual(test_player.total_moves, test_value + 1)
def test_add_last_game_moves(self):
test_value = test_player.last_game_moves
test_player.add_last_game_moves()
self.assertEqual(test_player.last_game_moves, test_value + 1)
def test_calculate_total_average_moves(self):
test_player.total_moves = 3
test_player.games = 1
test_player.calculate_total_average_moves()
self.assertEqual(test_player.total_average_moves, round(test_player.total_moves / test_player.games, 2))
test_player.total_moves = 0
test_player.games = 0
test_player.calculate_total_average_moves()
self.assertEqual(test_player.total_average_moves, 0.0)
def test_calculate_average_win_moves(self):
test_player.total_moves_winning_games = 3
test_player.wins = 1
test_player.calculate_average_win_moves()
self.assertEqual(test_player.average_win_moves,
round(test_player.total_moves_winning_games / test_player.wins, 2))
test_player.total_moves_winning_games = 0
test_player.wins = 0
test_player.calculate_average_win_moves()
self.assertEqual(test_player.total_moves_winning_games, 0.0)
def test_update_player_moves(self):
test_player.total_moves = 3
test_player.last_game_moves = 3
expected_result = test_player.total_moves + test_player.last_game_moves
test_player.update_player_moves()
self.assertEqual(expected_result, test_player.total_moves)
def test_update_percent(self):
test_player.games = 2
test_player.wins = 1
test_player.ties = 1
expected_result = '50.0%'
function_value = test_player.update_percent(test_player.wins, test_player.games)
self.assertEqual(expected_result, function_value)
function_value = test_player.update_percent(test_player.ties, test_player.games)
self.assertEqual(expected_result, function_value)
test_player.games = 0
test_player.wins = 0
expected_result = '0.0%'
function_value = test_player.update_percent(test_player.wins, test_player.games)
self.assertEqual(expected_result, function_value)
def test_update_scoreboard(self):
test_player.games = 2
test_player.wins = 1
test_player.ties = 1
expected_result = '50.0%'
test_player.update_scoreboard()
self.assertEqual(expected_result, test_player.win_percent)
self.assertEqual(expected_result, test_player.tie_percent)
def test_get_total_win(self):
test_player.wins = randint(0, 10)
test_player2.wins = randint(0, 10)
expected_result = test_player.wins + test_player2.wins
total.get_total_win(test_player.wins, test_player2.wins)
self.assertEqual(expected_result, total.wins)
def test_get_total_last_moves(self):
test_player.last_game_moves = randint(0, 10)
test_player2.last_game_moves = randint(0, 10)
expected_result = test_player.last_game_moves + test_player2.last_game_moves
total.get_total_last_moves(test_player.last_game_moves, test_player2.last_game_moves)
self.assertEqual(expected_result, total.last_game_moves)
def test_get_total_moves(self):
test_player.total_moves = randint(0, 10)
test_player2.total_moves = randint(0, 10)
expected_result = test_player.total_moves + test_player2.total_moves
total.get_total_moves(test_player.total_moves, test_player2.total_moves)
self.assertEqual(expected_result, total.total_moves)
def test_get_total_winning_moves(self):
test_player.total_moves_winning_games = randint(0, 10)
test_player2.total_moves_winning_games = randint(0, 10)
expected_result = test_player.total_moves_winning_games + test_player2.total_moves_winning_games
total.get_total_winning_moves(test_player.total_moves_winning_games, test_player2.total_moves_winning_games)
self.assertEqual(expected_result, total.total_moves_winning_games)
"""Test "game_turn" functions"""
def test_create_board(self):
test_value1 = 3
test_value2 = 1
expected_result1 = [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
expected_result2 = [['_']]
function_value = game_functions.create_board(test_value1)
self.assertEqual(expected_result1, function_value)
function_value = game_functions.create_board(test_value2)
self.assertEqual(expected_result2, function_value)
def test_reset_move_count(self):
test_player.last_game_moves = 5
test_player2.last_game_moves = 4
total.last_game_moves = 3
game_functions.reset_move_count(test_player, test_player2, total)
self.assertEqual(test_player.last_game_moves, 0)
self.assertEqual(test_player2.last_game_moves, 0)
self.assertEqual(total.last_game_moves, 0)
def test_get_random_numbers(self):
grid_size = 3
expected_list = game_functions.get_random_numbers(grid_size)
self.assertIn(expected_list[0], range(0, grid_size))
self.assertIn(expected_list[1], range(0, grid_size))
def test_check_for_available_moves(self):
grid_size = 3
game_board1 = [['X', 'X', 'X'], ['X', 'X', 'X'], ['X', 'X', 'X']]
function_value1 = game_functions.check_for_available_moves(game_board1, grid_size)
game_board2 = [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
function_value2 = game_functions.check_for_available_moves(game_board2, grid_size)
self.assertFalse(function_value1)
self.assertTrue(function_value2)
def test_place_mark(self):
game_board = [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
coordinates = [0, 0]
symbol = 'X'
expected_result = [['X', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
game_functions.place_mark(game_board, coordinates, symbol)
self.assertEqual(expected_result, game_board)
test_player = Player('Test', 'T')
test_player2 = Player('Test2', 'T2')
total = Statistics()
unittest.main()
|
a3ee45b658838526491e85141bc219b4e8a8d31e | Vipulhere/Python-practice-Code | /Module 10/3.1 insertinto.py | 322 | 3.796875 | 4 | import sqlite3
conn=sqlite3.connect("database.db")
query="INSERT into STD(name,age,dept)values ('bob',20,'CS');"
try:
cursor=conn.cursor()
cursor.execute(query)
conn.commit()
print("Our record is inserted into database")
except:
print("Error in database insert record")
conn.rollback()
conn.close() |
cc779c69d84dc9ea2afc1249646caef9f589c15e | Vipulhere/Python-practice-Code | /Module 3/12.1 loops with else block of code.py | 254 | 4.0625 | 4 | for a in range(5):
print(a)
else:
print("The loop has completed execution")
print("_______________________")
t=0
n=10
while (n<=10):
t=t+n
n=n+1
print("Value of total while loop is",t)
else:
print("You have value is equal to 10") |
e777115b8048caa29617b9b0e99d6fbac3beef99 | Vipulhere/Python-practice-Code | /Module 8/11.1 inheritance.py | 643 | 4.3125 | 4 | #parent class
class parent:
parentname=""
childname=""
def show_parent(self):
print(self.parentname)
#this is child class which is inherites from parent
class Child(parent):
def show_child(self):
print(self.childname)
#this object of child class
c=Child()
c.parentname="BOB"
c.childname="David"
c.show_parent()
c.show_child()
print("___________________")
class car:
def __init__(self,name="ford",model=2015):
self.name=name
self.model=model
def sport(self):
print("this is sport car")
class sportcar(car):
pass
c=sportcar("sportcar")
print(c.name)
print(c.model)
c.sport()
|
3db13f56cd5cac39e2e32ba3a5aa460d3cd957c4 | Vipulhere/Python-practice-Code | /Module 8/7.1 object method.py | 237 | 3.84375 | 4 | class car:
def __init__(self,name,color):
self.name=name
self.color=color
def car_detail(self):
print("Name of car",self.name)
print("Color of car",self.color)
c=car("ford","white")
c.car_detail() |
e549aca0a2c1b27dcde960f56b65da2eb6632fbd | Vipulhere/Python-practice-Code | /Module 6/6.1 tuple.py | 169 | 3.75 | 4 | tuple=()
tuple2=(1,2,3,4,5,6)
tuple3=("python","java","php")
tuple4=(10,20,"java","php")
print(tuple)
print(tuple2)
print(tuple3)
del tuple3
print(tuple3)
print(tuple4)
|
bcabbb2b0ed927d608c3bd8a832aded14e53738f | Vipulhere/Python-practice-Code | /Module 7/2.1 exception handling.py | 209 | 3.796875 | 4 | try:
text=input("Enter a value or something you like")
except EOFError:
print("EOF Error")
except KeyboardInterrupt:
print("You cancelled the operation")
else:
print("you enterd".format(text))
|
5e9af0fd6c370d21c0ce17a5d6ccffad245abaf2 | Vipulhere/Python-practice-Code | /Module 8/16.1 encapsulation.py | 609 | 3.890625 | 4 | class encapsulation:
__name=None
def __init__(self,name):
self.__name=name
def getname(self):
return self.__name
e=encapsulation("Encapsulation")
print(e.getname())
print("________________")
class car(object):
def __init__(self,name="BMw",year=2020,mileage="250",color="white"):
self.__name=name
self.__year=year
self.__mileage=mileage
self.__color=color
def cardetail(self,speed):
print("your car spreed is %s" %(self.__name,speed))
def speeds(self,speed):
print("meter speed is %s"%speed)
c=car()
print(car.__name)
|
f37f6cfbbe1ca3542992c7a6673284d9b59666a1 | Vipulhere/Python-practice-Code | /Module 6/17.1 sort a dict.py | 172 | 3.921875 | 4 | dict={
"BMW":"2020",
"Ford":"2019",
"Toyota":"2018",
"BMW": "2012",
"Honda": "2015"
}
for key1 in sorted(dict,key=dict.get):
print(key1,dict[key1]) |
391625ce1ccb63a4471ba41a184c346114168c46 | Vipulhere/Python-practice-Code | /Module 2/5.1 Short Hand of operator.py | 83 | 3.71875 | 4 | var=2
var+=10
print(var)
var*=10
print(var)
var/=10
print(var)
var-=10
print(var) |
7b49801dcfbc7feeadb92bf9a9c8de86a7a90d48 | Vipulhere/Python-practice-Code | /Module 3/5.1 nested if else.py | 137 | 3.6875 | 4 | var=-10
if var>0:
print("Postive Number")
else:
print("Negative Number")
if -10<=var:
print("Two Digit are Negative") |
3c2b47f35531074d47b6e3022ae94d8c30d5e99d | Vipulhere/Python-practice-Code | /Module 8/2.1 Classes and Object.py | 170 | 3.921875 | 4 | class car:
model=2020
name="ford"
c=car()
print(c.model,c.name)
class animal:
age=20
name="dog"
color="Black"
a=animal()
print(a.name,a.age,a.color) |
3e49fd765e0672df380c18249f1b1cada092b1d9 | pivacik/leetcode-algorithms | /plan_calc.py | 272 | 3.71875 | 4 | import sys
def calculate_plan(a, b, c, d):
if d > b:
return a + c * (d - b)
else:
return a
string = ''
for line in sys.stdin:
string += line
lst = list(string.split())
a, b, c, d = lst
print(a, b, c, d)
print(calculate_plan(a, b, c, d))
|
aae533ba404018f1c31e8fb949d44741fc54c792 | frigusgulo/F4_Architecture | /VM_Control_Only.py | 1,540 | 3.71875 | 4 |
def Main():
pass
# VM Control
def goto(labelname):
return "@" + str(labelname) + "\n0;JMP\n"
def if_goto(labelname):
return pop_D() + "D=D+1\n@" + str(labelname) + "\nD;JGT\n"
# my understanding is if-goto jumps if top of stack is -1 (true) i.e. pop_D() + D=D+1 + D;JEQ
def label(labelname):
return "(" + str(labelname) + ")\n"
RETURN_ADDRESSES = []
callnum = -1
def callFunction(FunctionName, nArgs):
callnum += 1
RETURN_ADDRESS = str(FunctionName) + str(callnum)
RETURN_ADDRESSES.append(RETURN_ADDRESS)
str = "@" + RETURN_ADDRESS + "\nD=A\n" + push_D()
str += saveFrame(LCL) + saveFrame(ARG) + saveFrame(THIS) + saveFrame(THAT)
str += "@SP\nD=M\n@" + (5 + int(nArgs)) + "\nD=D-A\n@ARG\nM=D\n"
str += "@SP\nD=M\n@LCL\nM=D\n"
str += goto(str(FunctionName))
str += "(" + RETURN_ADDRESS + ")\n"
return str
# Helper function for callFunction
def saveFrame(name):
return "@" + str(name) + "\nD=M\n" + push_D()
def makeFunction(FunctionName, nVars):
str = label(str(FunctionName))
for i in range(nVars):
str += "D=0\n" + push_D()
return str
def return_control():
str = "@LCL\nD=M\n@endFrame\nM=D\n"
str += "@5\nD=A\n@endFrame\nD=M-D\n@returnAddress\nM=D\n"
str += pop_D() + "@ARG\nM=D\n"
str += "@SP\nM=D+1\n"
str += "@endFrame\nD=M\n" + "@THAT\nDM=D-1\n" + "@THIS\nDM=D-1\n" + "@ARG\nDM=D-1\n" + "@LCL\nM=D-1\n"
str += goto(RETURN_ADDRESSES[-1])
RETURN_ADDRESSES.pop()
return str
if __name__ == '__main__':
main()
|
78f055ae60f4eaa45424f8f9dea223ff1d5c667c | yukimiii/competitive-programming | /typical90/solved/75.py | 378 | 3.703125 | 4 | def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
n = int(input())
a=prime_factorize(n)
b=len(a)
count=0;
while(b>1):
b=-(-b//2)
count+=1
print(count) |
b8585391d0425578a059c18ccd8399eaa4db1581 | Bullsquid/gitTask-1 | /halves.py | 693 | 3.8125 | 4 | import numpy as np
import matplotlib.pyplot as plt
def min_halves(f, a, b, eps):
if b < a:
tmp = a
a = b
b = tmp
t = np.arange(a-1.0, b+1.0, 0.02)
right = []
left = []
plt.plot(t, f(t))
while b-a >= eps:
center = (a + b) / 2.0
delta = (b-a) / 4.0
x1 = center - delta
x2 = center + delta
if f(x1) < f(x2):
b = x2
right.append(x2)
else:
a = x1
left.append(x1)
plt.plot(right, map(f, right), 'rs')
plt.plot(left, map(f, left), 'bs')
plt.show()
x_min = (a+b) / 2.0
return {"x": x_min,
"f": f(x_min)
} |
b0032fa5aa5281354ec4cd92162dc9ac2e1e2e78 | lohe987/ECE366Group4Project3 | /simulator_z.py | 5,921 | 3.640625 | 4 | import sys
import collections
# Class CPU will hold the information of the CPU
class CPU:
PC = 0 # Program Counter
DIC = 0 # Insturction Counter
R = [0] * 4 # Register Values
instructions = [] # instructions in array
memory = [] # memory in array
def check_parity_bit(machine_line):
# Count the number of zeros and ones
one_zero_dict = collections.Counter(machine_line)
# Make sure an even number of ones exist in the instructions
if one_zero_dict["1"] % 2 == 0:
return True
return False
def convert_imm_value(number):
if number < 0:
number = 0xFFFF + number + 1
return format(int(number), "016b")
def xor(a, b):
result = ""
for c,d in zip(a,b):
if c == d:
result = result + "0"
else:
result = result + "1"
return result
def load_program(cpu, instr_file_name, memory_file_name):
instr_file = open(instr_file_name, "r")
memory_file = open(memory_file_name, "r")
for line in instr_file:
line = line.strip()
if len(line) < 1 or line.startswith("#") or line.startswith("U"):
continue
line = line.split(" ")
cpu.instructions.append(line[0])
for line in memory_file:
line = line.strip()
if len(line) < 1 or line.startswith("#"):
continue
number = int(line,2)
if line.startswith("1"):
number = (0xFFFF - int(line,2) + 1) * -1
cpu.memory.append(number)
for i in range(128-len(cpu.memory)):
cpu.memory.append(0)
instr_file.close()
memory_file.close()
return cpu
def run_program(cpu):
finished = False
while(not finished):
instr = cpu.instructions[cpu.PC]
if not check_parity_bit(instr):
print(instr)
print("ERROR: Parity Bit Error")
sys.exit()
if instr[1:8] == "1110111":
'''
cpu.R[3] = cpu.R[3] ^ cpu.R[2]
cnt = str(bin(cpu.R[3])).count("1")
cpu.R[3] = 16 - cnt # 16 bit integers
'''
a = convert_imm_value(cpu.R[3])
b = convert_imm_value(cpu.R[2])
result = collections.Counter(xor(a,b))
cpu.R[3] = result["0"]
cpu.PC = cpu.PC + 1
cpu.DIC = cpu.DIC + 1
elif instr[1:8] == "1110000":
# Halt Command
finished = True
cpu.PC = cpu.PC + 1
cpu.DIC = cpu.DIC + 1
elif instr[1:6] == "01100":
# AddR instruction
Rx = registers[instr[6:8]]
cpu.R[2] = cpu.R[Rx] + cpu.R[Rx]
cpu.PC = cpu.PC + 1
cpu.DIC = cpu.DIC + 1
elif instr[1:6] == "01111":
# AddR3 instruction
Rx = registers[instr[6:8]]
cpu.R[3] = cpu.R[Rx] + cpu.R[Rx]
cpu.PC = cpu.PC + 1
cpu.DIC = cpu.DIC + 1
elif instr[1:6] == "01110":
# AddR2 instruction
Rx = registers[instr[6:8]]
cpu.R[2] = cpu.R[2] + cpu.R[Rx]
cpu.PC = cpu.PC + 1
cpu.DIC = cpu.DIC + 1
elif instr[1:6] == "01101":
# Sub R3 instruction
Rx = registers[instr[6:8]]
cpu.R[3] = cpu.R[3] - cpu.R[Rx] # R3 = R3 - RX
cpu.PC = cpu.PC + 1
cpu.DIC = cpu.DIC + 1
elif instr[1:4] == "001":
# Load instruction
Rx = registers[instr[4:6]]
Ry = registers[instr[6:8]]
cpu.R[Rx] = cpu.memory[cpu.R[Ry]]
cpu.PC = cpu.PC + 1
cpu.DIC = cpu.DIC + 1
elif instr[1:4] == "010":
# Store instruction
Rx = registers[instr[4:6]]
Ry = registers[instr[6:8]]
cpu.memory[cpu.R[Ry]] = cpu.R[Rx]
cpu.PC = cpu.PC + 1
cpu.DIC = cpu.DIC + 1
elif instr[1:4] == "000":
# Init instruction
Rx = registers[instr[3:5]] # Bit 4 picks whether or not this should be
cpu.R[Rx] = int(instr[5:8], 2) # Cast the imm value into base ten
cpu.PC = cpu.PC + 1
cpu.DIC = cpu.DIC + 1
elif instr[1:3] == "11":
# Branch Equal R0
Rx = registers[instr[3:5]]
imm = imm_mux[instr[5:8]]
if cpu.R[Rx] == cpu.R[0]:
cpu.PC = cpu.PC + imm
else:
cpu.PC = cpu.PC + 1
cpu.DIC = cpu.DIC + 1
elif instr[1:4] == "100":
# Add immediate
Rx = registers[instr[4:6]]
imm = registers[instr[6:8]] # imm value is [0,3] in this case encoded the same way as the registers
cpu.R[Rx] = cpu.R[Rx] + imm
cpu.PC = cpu.PC + 1
cpu.DIC = cpu.DIC + 1
elif instr[1:4] == "101":
# Set less than, if so R0 = 1
Rx = registers[instr[4:6]]
Ry = registers[instr[6:8]]
if cpu.R[Rx] < cpu.R[Ry]:
cpu.R[0] = 1
else:
cpu.R[0] = 0
cpu.PC = cpu.PC + 1
cpu.DIC = cpu.DIC + 1
else:
print("Error Unknown command")
sys.exit()
#print(cpu.R)
#print(cpu.memory[0:10])
return cpu
registers = {"00" : 0,
"01" : 1,
"10" : 2,
"11" : 3}
imm_mux = {"000": -22, #P1 JMP
"001": -9, #P2 JMP
"010": -5, #P1 JMP
"011": -6, #P2 JMP (X2)
"100": 3, #P1 JMP
"101": -17, #P2 JMP
"110": 16, #P2 JMP (X3)
"111": 21} #P1 JMP
if __name__ == "__main__":
cpu1 = CPU()
cpu1 = load_program(cpu1, "prog1_group_4_p2_bin.txt", "patternA.txt")
print(cpu1.memory[0:10])
print(cpu1.R)
print(cpu1.instructions)
cpu1 = run_program(cpu1)
print("Registers: " + str(cpu1.R))
print("DIC: " + str(cpu1.DIC))
print(cpu1.memory[0:10])
|
1dd2bc4d81e2f09a5dec71127ac5eade13be3dd8 | mayanksingh2233/ML-algo | /ML Algorithms/linear regression.py | 899 | 3.546875 | 4 | #!/usr/bin/env python
# coding: utf-8
# # linear regression
# In[17]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# In[115]:
df=pd.read_csv('E:\\python\\datasets\\cars.csv',delimiter=';',skiprows=[1])
df.head()
# In[118]:
x=df[['Displacement']]
x
# In[120]:
y=df[['Acceleration']]
y
# In[121]:
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
# In[122]:
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.3)
# In[123]:
lr=LinearRegression()
# In[124]:
lr.fit(x_train,y_train)
# In[125]:
y_pred=lr.predict(x_test)
# In[126]:
y_pred
# In[127]:
y_test
# In[110]:
from sklearn.metrics import mean_squared_error
# In[128]:
mean_squared_error(y_pred,y_test)
# In[130]:
plt.scatter(x_test,y_test)
plt.plot(x_test,y_pred,color='r')
plt.show()
# In[ ]:
|
b59bb752bfdc1b3fdd2c2f2c961b79b27dcc9188 | 935375572/python_study | /1基础/13成员运算符in_notin.py | 146 | 3.65625 | 4 | # in 判断数据是否在序列之中
# not in 判断数据是否不再序列中
numbers = ["A", "B", "C"]
if "B" in numbers:
print("对的") |
3a40e487e84bdd009f31a2606a1261bf8d81ebaf | 935375572/python_study | /1基础/4在字符串上使用乘法.py | 563 | 3.78125 | 4 | info = "msg" * 5 # 重复5遍
print(info)
"""使用与逻辑运算符 and"""
name = "张三"
age = 13
result = name == "张三" and age == 13
print(result)
"""使用或逻辑运算符 or"""
name = "张三"
age = 13
result = name == "张三" or age == 13
print(result)
"""使用非逻辑运算符 and"""
name = "张三"
age = 13
result = not age == 13
print(result)
"""身份运算符：通过一个id()函数以获取数据对应的内存地址"""
nub = 2
print("nub的内存地址是：%s" % id(nub))
nub = 100
print("nub的内存地址是：%s" % id(nub)) |
883c2914bec7eb100a9d1eb5be239b04793af6d9 | 935375572/python_study | /1基础/3定义布尔型变量.py | 610 | 3.828125 | 4 | flag = True
print(type(flag)) # 获取变量的类型
if flag:
print("你好啊老哥") # 条件满足时执行
"""字符串的连接操作"""
info = "hello"
info = info + "world"
info += "python"
info = "优拓软件学院\"www.yootk.com\"\n\t极限IT程序员：\'www.jixianit.com\'"
print(info)
"""input()函数 获取键盘输入的数据"""
msg = input("请输入你的内容：")
wc = int(msg) # 将字符串转为int类型
if wc > 12:
print("可以了")
print(msg) # 打印输入的内容
"""格式化输出"""
name = "abc"
age = 13
print("姓名是：%s 年龄有：%d" % (name, age))
|
13398c4ff7dad957ac14f32791f942f9c9ed4b58 | AlSakharoB/easy_list_v1 | /ft_even_index_list.py | 265 | 3.640625 | 4 | def ft_len_mass(mass):
count = 0
for i in mass:
count += 1
return count
def ft_even_index_list(mass):
mass1 = []
for i in range(ft_len_mass(mass)):
if i % 2 == 0:
mass1.append(mass[i])
return mass1
|
13e0b3ecf515c7e7f35e947e6ae523eb40320e5e | sraghus/Python_examples | /triangle.py | 440 | 3.625 | 4 | #!usr/bin/env python
#import modules used here - sys is a very standard one
import sys
def area(base, height):
return (base * height) / 2
if __name__ == '__main__':
print('Area :', area(12,23))
def perimeter(side1, side2, side3):
return (side1 + side2 + side3)
if __name__ == '__main__':
print ('Perimeter :', perimeter(12,83,95))
#def name():
# input("What is your name? ")
#if __name__ == '__main__':
# print name() |
979fb7ce2ecbf9672d9674f8da264b6e3d870e50 | chelseasenter/custom-dice-roller | /dice.py | 6,846 | 3.515625 | 4 | import random
run='y'
while run == 'y':
## introduction for user --------------------------------------------------------------------------------------------
# print(".")
# print(".")
# print(".")
# print(".")
# print(".")
# print(".")
# print(".-------------------------------------------------------------------------------------------------------*")
# print("| Welcome to the Dice Roller 5000! There are several different ways to roll dice. See below for details.|")
# print("*-------------------------------------------------------------------------------------------------------.")
# print(" ")
# print("_._._._._._._._._._._._._._._._._._._._._._")
# print(" ")
# print("5e Rolls")
# print(" ")
# print("To roll a pre-created D20 dice roll (initiative, saving throws, attack rolls, skill checks):")
# print("1. decide the type of roll you want: i = _I_nitiative, c = skill _C_heck, t = saving _T_hrow, or a = _A_ttack roll")
# print("2. followed by a = advantage, d = disadvantage, n = none")
# print("3. add any modifiers at the end with a + or - followed by the value of your modifier.")
# print("**check out these examples:**")
# print(" id+3 means rolling initiative at disadvantage adding a +3 modifier")
# print(" tn-1 means rolling a normal saving throw with a -1 modifier")
# print(" ")
# print("_._._._._._._._._._._._._._._._._._._._._._")
# print(" ")
# print("Custom Dice")
# print(" ")
# print("To roll a custom dice:")
# print("1. Input your dice type (D4, D6, D8, D10, D12, D20, or custom)")
# print("2. Input the number of dice you'd like to roll (ie. 1, 3, infinity and beyond")
# print("3. Indicate what kind of modifier (if any) you are using and if you'd like it ")
# print(" added to each dice roll or just once at the end of the calculation.")
# print(".")
# print(".")
# print(".")
# print(".")
# print(".")
# print(".")
## dice type --------------------------------------------------------------------------------------------
dice_type = input("Which would you like to use? Type e for 5e Rolls, c for Custom Dice, a number to roll a basic dice or n to end this script: ")
dice_type = dice_type.lower()
## 5e Roller logic --------------------------------------------------------------------------------------------
if dice_type == "e":
# print("_._._._._._._._._._._._._._._._._._._._._._")
# print("5e Roller")
# print(' ')
# print("Type out your preferences using the following instructions:")
# print("1. decide the type of roll you want: ")
# print(" i = _I_nitiative, c = skill _C_heck, t = saving _T_hrow, or a = _A_ttack roll")
# print("2. followed by a = advantage, d = disadvantage, or n = none")
# print("3. add any modifiers at the end with a + or - followed by the value of your modifier.")
# print("**check out these examples:**")
# print(" id+3 means rolling initiative at disadvantage adding a +3 modifier")
# print(" tn-1 means rolling a normal saving throw with a -1 modifier")
try:
formula = input("Enter your preferences here: ")
print(' ')
formula = formula.lower().strip()
print(formula)
output = list(formula)
number1 = random.randint(1,20)
onewithmod = number1 + int(output[3])
number2 = random.randint(1,20)
twowithmod = number2 + int(output[3])
roll_types = {'i': 'initiative', 'c': 'skill check', 't': 'saving throw', 'a': 'attack roll'}
adv_dis_num = {'a': max([onewithmod, twowithmod]), 'd': min([onewithmod, twowithmod])}
adv_dis = {'a' : 'advantage', 'd' : 'disadvantage'}
if output[1] == 'a' or output[1] == 'd':
print(' ')
print(f"{number1} {output[2]} {output[3]} = {onewithmod}")
print(f"{number2} {output[2]} {output[3]} = {twowithmod}")
print(' ')
# new advantage/disadvantage logic
print(f"Final results ({roll_types.get(output[0])}, {adv_dis.get(output[1])}): {adv_dis_num.get(output[1])}")
print(' ')
# old advantage/disadvantage logic
# if output[1] == 'a':
# print(' ')
# print(f"Final results ({roll_types.get(output[0])}, advantage): {max([onewithmod, twowithmod])}")
# print(' ')
# elif output[1] == 'd':
# print(' ')
# print(f"Final results ({roll_types.get(output[0])}, disadvantage): {min([onewithmod, twowithmod])}")
# print(' ')
else:
print(' ')
print(f"Your roll result for {roll_types.get(output[0])}: {number1} {output[2]} {output[3]} = {onewithmod}")
finally:
run='n'
## FUTURE: Custom Dice --------------------------------------------------------------------------------------------
elif dice_type == "c":
# print("_._._._._._._._._._._._._._._._._._._._._._")
# print("Custom Dice")
# print(" ")
# print("To roll a custom dice:")
# print("1. If more than one dice: Start with the number of dice you'd like to roll (1, 5, 100) followed by an 'x'")
# print("2. Type the dice type you'd like to use (ie. 20 for D20, 10 for D10, 100 for D100)")
# print("3. Include the modifier you are using (ie. +1, 0, -2). If you'd like it used just once at the end,")
# print(" include a space between the dice type number and modifier number.")
# print(' ')
formula = input("Enter your custom roll here: ")
print(' ')
formula = formula.lower().strip()
print(formula)
output = list(formula)
find_x = formula.find('x') #
find_mod_type = formula.find(' ')
find_mod_plus = formula.find('+')
find_mod_minus = formula.find('-')
## stopped here: need to figure out way to pull dice face number from ALL inputs
# dice_faces =
mod_dict = {'+': output[find_mod_plus], '-': output[find_mod_minus]}
#find function note: .find(value, start, end) if value doesn't exist in string, comes back -1
if '+' in formula or '-' in formula:
print("this string contains a modifier")
else:
print("this string doesn't contain a modifier")
run='n'
elif dice_type == "n":
run='n'
elif dice_type.isdigit():
print(" ")
print(f"Roll results: {random.randint(1,int(dice_type))}")
print(" ")
else:
print("input not recognized")
run='n' |
854bb5826a378627b9041b230607e51da2905cd8 | tberhanu/green_book | /ch2_LinkedLists/check_llist_palindrome.py | 772 | 3.984375 | 4 | # from LinkedList import LinkedList
def check_llist_palindrome(llist):
curr = llist
runner = llist
stack = [] #In python we use 'lists' as 'stacks'
while runner and runner.next:
stack.append(curr.data)
curr = curr.next
runner = runner.next.next
if runner:
curr = curr.next
while curr:
top = stack.pop()
if top != curr.data:
return False
curr = curr.next
return True
class Node():
def __init__(self, data, next=None):
self.data = data
self.next = next
ll1 = Node(1, Node(2, Node(3, Node(2, Node(1, None)))))
print(check_llist_palindrome(ll1))
ll2 = Node(1, Node(2, Node(3, Node(3, Node(2, Node(1, None))))))
print(check_llist_palindrome(ll2))
ll3 = Node(1, Node(2, Node(3, Node(2, Node(2, Node(1, None))))))
print(check_llist_palindrome(ll3)) |
b1858530c96c0ff053d78237695ac3764ccc5362 | tberhanu/green_book | /ch1_Arrays&Strings/check_permutation3_counter.py | 690 | 3.859375 | 4 | from collections import Counter
def check_permutation3_counter(str1, str2):
if len(str1) != len(str2):
return False
cntr1 = Counter(str1) #gives a dictionary of each CHAR:FREQUENCY
cntr2 = Counter(str2)
for key1 in cntr1:
for key2 in cntr2:
if key1 == key2 and cntr1[key1] != cntr2[key2]:
return False
elif key1 == key2 and cntr1[key1] == cntr2[key2]:
break
return True
print(cntr1)
print(cntr2)
print(check_permutation3_counter("hello", "ohhhh"))
print(check_permutation3_counter("strr", "rrst"))
print(check_permutation3_counter("strra", "rarst"))
print(check_permutation3_counter("strcra", "raxrst"))
print(check_permutation3_counter("astrcra", "raxrste")) |
4380cb3cb4bbdace75f27ff7059a0505e17687b7 | ToxaRyd/WebCase-Python-course- | /7.py | 1,757 | 4.3125 | 4 | """
Данный класс создан для хранения персональной (смею предположить, корпоративной) информации.
Ниже приведены doc тесты/примеры работы с классом.
>>> Employee = Person('James', 'Holt', '19.09.1989', 'surgeon', '3', '5000', 'Germany', 'Berlin', 'male')
>>> Employee.name
James Holt
>>> Employee.age
29 years old
>>> Employee.work
He is a surgeon
>>> Employee.money
180 000
>>> Employee.home
Lives in Berlin, Germany
"""
class Person:
def __init__(self, first_name, last_name, birth_date, job, working_years, salary, country, city, gender='uknown'):
self.__first_name = first_name
self.__last_name = last_name
self.__birth_date = birth_date
self.__job = job
self.__working_years = working_years
self.__salary = salary
self.__country = country
self.__city = city
self.__gender = gender
@property
def name(self):
print(f'{self.__first_name} {self.__last_name}')
@property
def age(self):
a = list(self.__birth_date.split('.'))
b = 2018 - int(a[2])
print(f'{b} years old')
@property
def work(self):
ci = {'male': 'He', 'female': 'She', 'uknown': 'He/She'}
print('{0} is a {1}'.format(ci[self.__gender], self.__job))
@property
def money(self):
m = int(self.__working_years) * int(self.__salary) * 12
print('{0:,}'.format(m).replace(',', ' '))
@property
def home(self):
print(f'Lives in {self.__city}, {self.__country}')
if __name__ == '__main__':
import doctest
doctest.testmod()
|
eb44d31501175cf09d4eac5bfc3ab2e8784168f9 | jasonfhill/cronwatch | /app/utils.py | 1,391 | 3.953125 | 4 | import os
import re
import sys
_filename_ascii_strip_re = re.compile(r'[^A-Za-z0-9_.-]')
PY2 = sys.version_info[0] == 2
if PY2:
text_type = unicode
else:
text_type = str
def secure_filename(filename):
r"""Pass it a filename and it will return a secure version of it. This
filename can then safely be stored on a regular file system and passed
to :func:`os.path.join`. The filename returned is an ASCII only string
for maximum portability.
>>> secure_filename("My cool movie.mov")
'My_cool_movie.mov'
>>> secure_filename("../../../etc/passwd")
'etc_passwd'
>>> secure_filename(u'i contain cool \xfcml\xe4uts.txt')
'i_contain_cool_umlauts.txt'
The function might return an empty filename. It's your responsibility
to ensure that the filename is unique and that you generate random
filename if the function returned an empty one.
:param filename: the filename to secure
"""
if isinstance(filename, text_type):
from unicodedata import normalize
filename = normalize('NFKD', filename).encode('ascii', 'ignore')
filename = filename.decode('ascii')
for sep in os.path.sep, os.path.altsep:
if sep:
filename = filename.replace(sep, ' ')
filename = str(_filename_ascii_strip_re.sub('', '_'.join(
filename.split()))).strip('._')
return filename |
d5532a8bf440890fd844ee1f0cdd02f06ea4dc55 | ckfChao/My-First-git-Repository | /main.py | 451 | 3.953125 | 4 | from op import op
#input
a = int(input("Enter value of a:"))
input_op = input("Enter operater:")
b = int(input("Enter value of b:"))
calc = op(a, b)
if (input_op == "+"):
print("%d + %d = %d"%(a, b, calc.add()))
elif (input_op == "-"):
print("%d - %d = %d"%(a, b, calc.sub()))
elif (input_op == "*"):
print("%d * %d = %d"%(a, b, calc.mult()))
elif (input_op == "/"):
print("%d / %d = %d"%(a, b, calc.div()))
else:
print("Error") |
9efdeb16d054511cf515531db3eb805fc690f4a5 | logchi/scrach_zone | /python/data_structure_algorithms/breath_first_serach.py | 1,055 | 3.78125 | 4 | from collections import deque
def search_queue(graph, dq, right, searched=[]):
def addnextlevel(dq, node):
next_level = graph.get(node)
if next_level:
dq += next_level
if dq:
node = dq.popleft()
if node in searched:
return search_queue(graph, dq, right, searched)
else:
if right(node):
print("This is the appropriate node:", node)
return True
else:
searched.append(node)
addnextlevel(dq, node)
return search_queue(graph, dq, right, searched)
else:
print("We can't find the appropriate node")
return False
def breath_first_search_demo():
def right(node):
return node[-1] == 'm'
graph = {}
graph["you"] = ["alice", "bob", "claire"]
graph["bob"] = ["anuj", "peggy"]
graph["alice"] = ["peggy"]
graph["claire"] = ["thom", "jonny"]
dq = deque(['you'])
print(search_queue(graph, dq, right))
breath_first_search_demo()
|
0147ba4f123a05170e4ed99fea9f2741974301e4 | akashzcoder/coding_discipline | /CoderPro/day3/solution.py | 413 | 3.53125 | 4 | class Solution:
def permute(self, nums: List[int]) -> List[List[int]]:
return self._permute_helper(nums, [])
def _permute_helper(self, nums: list, values: list = []) -> list:
if len(nums) == 0:
return [values]
result = []
for i in range(len(nums)):
result += self._permute_helper(nums[:i] + nums[i + 1:], values + [nums[i]])
return result
|
4fe543b01436500dd6ca7b3d2ff27746fc2508a5 | Wibbo/voting | /main.py | 240 | 3.515625 | 4 | from election import election
choices = ['Salad', 'Burger', 'Pizza', 'Curry', 'Pasta', 'BLT']
campaign = election(300, choices)
print('NEW ELECTION')
print(f'Number of voters is {campaign.voter_count}')
print(campaign.vote_counts)
|
9ae6c4d2f37119e7f90db29b3db050b40d5dff8b | nnicexplsz/python | /Work/test4.py | 606 | 3.578125 | 4 | a = input('enter number 1 \n')
b = input('enter number 2 \n')
c = input('enter number 3 \n')
d = input('enter number 4 \n')
c = input('enter number 5 \n')
a1 = float(a)
a2 = complex(a)
a3 = float(b)
a4 = complex(b)
a5 = float(c)
a6 = complex(c)
a7 = float(d)
a8 = complex(d)
a9 = float(c)
a10 = complex(c)
print('float of 1 = %.1f'%a1)
print('complex of 1 = %s'%a2)
print('float of 2 = %.1f'%a3)
print('complex of 2 = %s'%a4)
print('float of 3 = %.1f'%a5)
print('complex of 3 = %s'%a6)
print('float of 4 = %.1f'%a7)
print('complex of 4 = %s'%a8)
print('float of 5 = %.1f'%a9)
print('complex of 5 = %s'%a10) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.