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 |
|---|---|---|---|---|---|---|
f1f2b09a5a7d9453ee9ca98f74d12f73e75a182a | PropeReferio/practice-exercises | /important-concepts/get_digit.py | 823 | 3.8125 | 4 | import math
class Solution:
def get_digit(self, x: int, dig: int) -> int:
'''Takes an int an a digit as input, outputs the value of said digit.'''
return x // 10 ** dig % 10
# First floor division by 10 for 10's place,
# 100 for 100's place, etc (puts 100's place digit in 1's place)
# Then get the remainder of division by 10 to get digit's value
def isPalindrome(self, x: int) -> bool:
if x < 0:
return False
elif x == 0:
return True
left_dig, right_dig = int(math.log10(x)), 0
print(left_dig)
while left_dig > right_dig:
if self.get_digit(x, left_dig) != self.get_digit(x, right_dig):
return False
left_dig -= 1
right_dig += 1
return True |
9c4378edfdb41a942286830610d4bf2c24d2535f | PropeReferio/practice-exercises | /daily-coding-problem/dcp_10.py | 266 | 3.71875 | 4 | #This problem was asked by Apple.
#Implement a job scheduler which takes in a function f and an integer n,
# and calls f after n milliseconds.
import time
def scheduler(func, n):
time.sleep(n/1000)
f()
def f():
print('Do stuff')
scheduler(f, 5000)
|
07439e13efd7e16d993733605018fd0624c65820 | PropeReferio/practice-exercises | /random_exercises/alien_colors.py | 339 | 3.828125 | 4 | # Ex 5-3 from Python Crash Course
alien_color = 'red'
points = 0
if alien_color == 'green':
points += 5
print(f"Player 1 earned {points} points.")
elif alien_color == 'yellow':
points += 10
print(f"Player 1 earned {points} points.")
elif alien_color == 'red':
points += 15
print(f"Player 1 earned {points} points.") |
796c9387dce8f55b1a2a7efd90438bdff7eee5c8 | PropeReferio/practice-exercises | /random_exercises/filter_with_lambda_enumerate.py | 514 | 3.59375 | 4 | def multiple_of_index(arr):
print(arr)
for i, x in enumerate(arr):
print(i,x)
def divisible_by_index(lst):
for i, x in enumerate(lst):
if not x % i:
return True
else:
return False
#return list(filter(divisible_by_index, arr[1:]))
#The problem is that filter wants to run my function on each item of arr[:1], but those can't be enumerated.
#use enumerate
#my_enumerate = lambda x :[(t, x[t]) for t in range(len(x))] |
89a8e2146e366ce54617134d314e68d81c6b340a | PropeReferio/practice-exercises | /random_exercises/cars.py | 282 | 3.890625 | 4 | def car_info(manu, model, **car_info):
"""Creates a dictionary with info about a car that can receive an
arbitrary number of k,v pairs"""
car = {}
car['manufacturer'] = manu
car['model'] = model
for k, v in car_info.items():
car[k] = v
return car |
93dedb445a3623c144f6b064941685eea52144d8 | PropeReferio/practice-exercises | /random_exercises/opportunity_costs.py | 5,771 | 4.125 | 4 | # A program I made to compare my lifetime earnings in my current career, and
#after having taken a bootcamp, or going to college, taking into account
#cost of bootcamp/school and the time spent not making money.
current_age = float(input("How old are you? "))
retire_age = int(input("At what age do you expect to retire? ")) #The program
#could be further refined by having different retirement ages for different
#careers.
current_career = input("What is your current career? ")
current_income = int(input("What are the yearly earnings in your current"
" career? "))
bootcamp_income = int(input("What salary would you earn after a coding"
" bootcamp? "))
bootcamp_months = float(input("How many months does the bootcamp take? "))
bootcamp_years = bootcamp_months / 12 #Converts to years
bootcamp_cost = int(input("How much does the bootcamp cost? "))
college_income = int(input("What salary would you make after earning a"
" degree? "))
college_years = int(input("How many years would you spend in college? "))
college_cost = int(input("What would tuition cost per year? "))
total_tuition = int(college_cost * college_years)
def tax_rate(salary, career): #Based on 2019 Brackets,
if salary <= 39475: #determines effective tax rate and salary, filing
bracket1 = 9700 * 0.9 #singly, ignores deductions
bracket2 = (salary - 9700) * 0.88
after_tax = bracket1 + bracket2
taxes = salary - after_tax
eff_rate = taxes / salary
print(f"Your income after taxes in {career} would be {after_tax}. "
f"Your effective tax rate would be {eff_rate}.")
return after_tax
elif salary <= 84200:
bracket1 = 9700 * 0.9
bracket2 = (39475 - 9700) * 0.88
bracket3 = (salary - 39475) * 0.78
after_tax = bracket1 + bracket2 + bracket3
taxes = salary - after_tax
eff_rate = taxes / salary
print(f"Your income after taxes in {career} would be {after_tax}. "
f"Your effective tax rate would be {eff_rate}.")
return after_tax
elif salary <= 160725:
bracket1 = 9700 * 0.9
bracket2 = (39475 - 9700) * 0.88
bracket3 = (84200 - 39475) * 0.78
bracket4 = (salary - 84200) * 0.76
after_tax = bracket1 + bracket2 + bracket3 + bracket4
taxes = salary - after_tax
eff_rate = taxes / salary
print(f"Your income after taxes in {career} would be {after_tax}. "
f"Your effective tax rate would be {eff_rate}.")
return after_tax
elif salary <= 204100:
bracket1 = 9700 * 0.9
bracket2 = (39475 - 9700) * 0.88
bracket3 = (84200 - 39475) * 0.78
bracket4 = (160725 - 84200) * 0.76
bracket5 = (salary - 160725) * 0.68
after_tax = bracket1 + bracket2 + bracket3 + bracket4 + bracket5
taxes = salary - after_tax
eff_rate = taxes / salary
print(f"Your income after taxes in {career} would be {after_tax}. "
f"Your effective tax rate would be {eff_rate}.")
return after_tax
elif salary <= 510300:
bracket1 = 9700 * 0.9
bracket2 = (39475 - 9700) * 0.88
bracket3 = (84200 - 39475) * 0.78
bracket4 = (160725 - 84200) * 0.76
bracket5 = (204100 - 160725) * 0.68
bracket6 = (salary - 204100) * 0.65
after_tax = bracket1 + bracket2 + bracket3 + bracket4 + bracket5 + bracket6
taxes = salary - after_tax
eff_rate = taxes / salary
print(f"Your income after taxes in {career} would be {after_tax}. "
f"Your effective tax rate would be {eff_rate}.")
elif salary > 510300:
bracket1 = 9700 * 0.9
bracket2 = (39475 - 9700) * 0.88
bracket3 = (84200 - 39475) * 0.78
bracket4 = (160725 - 84200) * 0.76
bracket5 = (204100 - 160725) * 0.68
bracket6 = (510300 - 204100) * 0.65
bracket7 = (salary - 510300) * 0.63
after_tax = bracket1 + bracket2 + bracket3 + bracket4 + bracket5 + bracket6 + bracket7
taxes = salary - after_tax
eff_rate = taxes / salary
print(f"Your income after taxes in {career} would be {after_tax}. "
f"Your effective tax rate would be {eff_rate}.")
return after_tax
#Determines lifetime earnings before taxes
def before_tax_lifetime(salary, career, time_spent = 0, cost = 0):
lifetime_earnings = int((retire_age - current_age - time_spent) * salary)
adjusted_for_learning = lifetime_earnings - cost
print(f"\nBefore taxes, your lifetime earnings would be "
f"{lifetime_earnings} in a career in {career}. Adjusted "
f"for learning costs, this would be {adjusted_for_learning}.")
def after_tax_lifetime(salary, career, time_spent = 0, cost = 0): #Determines
after_tax_salary = tax_rate(salary, career) #lifetime earnings after taxes
after_tax_lifetime_earnings = int((retire_age - current_age - time_spent)
* after_tax_salary)
adjusted_for_learning = after_tax_lifetime_earnings - cost
print(f"After taxes, your lifetime earnings would be "
f"{after_tax_lifetime_earnings} in a career in {career}. Adjusted "
f"for learning costs, this would be {adjusted_for_learning}.")
before_tax_lifetime(bootcamp_income, "Software Development", bootcamp_years,
bootcamp_cost)
after_tax_lifetime(bootcamp_income, "Software Development", bootcamp_years,
bootcamp_cost)
before_tax_lifetime(college_income, "a college career", college_years,
college_cost)
after_tax_lifetime(college_income, "a college career", college_years,
college_cost)
before_tax_lifetime(current_income, current_career)
after_tax_lifetime(current_income, current_career)
print("Please note that tax deductions are ignored here.")
#Add in a standard deduction |
2c4c928322977ee0f99b7bfe4a97728e09402656 | PropeReferio/practice-exercises | /random_exercises/temp_converter.py | 586 | 4.28125 | 4 | unit = input("Fahrenheit or Celsius?")
try_again = True
while try_again == True:
if unit == "Fahrenheit":
f = int(input("How many degrees Fahrenheit?"))
c = f / 9 * 5 - 32 / 9 * 5
print (f"{f} degrees Fahrenheit is {c} degrees Celsius.")
try_again = False
elif unit == "Celsius":
c = int(input("How many degrees Celsius?"))
f = c * 9 / 5 + 32
print (f"{c} degrees Celsius is {f} degrees Fahrenheit.")
try_again = False
else:
print ("What unit is that?")
unit = input("Fahrenheit or Celsius?") |
25cc7ac225f74fd71ba79e365a251a2daf83aeb7 | PropeReferio/practice-exercises | /random_exercises/rand_pass.py | 730 | 3.8125 | 4 | # Ex 16 from practicepython.org Write a password generator in Python. Be
#creative with how you generate passwords - strong passwords have a mix
# of lowercase letters, uppercase letters, numbers, and symbols. The
# passwords should be random, generating a new password every time the
# user asks for a new password. Include your run-time code in a main method.
def generate_password(s):
import random
pass_length = random.randint(8,20)
password = ""
while pass_length > 0:
new_char = s[random.randint(0, len(s) - 1)]
password += new_char
pass_length -= 1
return password
s = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*()"
print(generate_password(s)) |
7b8aa1806a0084dfd6e189720fc10131d0e0b1b1 | PropeReferio/practice-exercises | /random_exercises/fave_fruits.py | 438 | 3.96875 | 4 | # Ex 5-7 from Python Crash Course
faves = ["Mangoes", "Papayas", "Maracuya"]
if "bananas" not in faves:
print("You don't like bananas?")
if "mangoes".title() in faves:
print("Yeah... mangoes are delish!")
if "papayas".title() in faves:
print("Papayas have a nice blend of flavors.")
if "Maracuya" in faves:
print("Maracuya makes great sauce for broccoli!")
if "apples" not in faves:
print("Apples are so overrated.") |
849c615ac2f77f6356650311deea9da6c32952bf | andrearus-dev/shopping_list | /myattempt.py | 1,719 | 4.1875 | 4 | from tkinter import *
from tkinter.font import Font
window = Tk()
window.title('Shopping List')
window.geometry("400x800")
window.configure(bg="#2EAD5C")
bigFont = Font(size=20, weight="bold")
heading1 = Label(window, text=" Food Glorious Food \n Shopping List",
bg="#2EAD5C", fg="#fff", font=bigFont).pack(pady=10)
# Adding input text to the list
def add_command():
text = entry_field.get()
for item in my_list:
list_layout.insert(END, text)
# Deleting one item at a time
def delete_command():
for item in my_list:
list_layout.delete(ACTIVE)
# Deleting all items with one click of a button
def delete_all_command():
list_layout.delete(0, END)
# Variable holding empty list
my_list = [""]
# Frame and scroll bar so the user can view the whole list
my_frame = Frame(window, bg="#00570D")
scrollBar = Scrollbar(my_frame, orient=VERTICAL)
# List box - where the items will be displayed
list_layout = Listbox(my_frame, width=40, height=20,
yscrollcommand=scrollBar.set)
list_layout.pack(pady=20)
# configure scrollbar
scrollBar.config(command=list_layout.yview)
scrollBar.pack(side=RIGHT, fill=Y)
my_frame.pack(pady=20)
heading2 = Label(window, text="Add items to your list \n Happy Shopping!",
bg="#2EAD5C", fg="#fff", font=1).pack(pady=5)
# Entry Field
entry_field = Entry(window)
entry_field.pack(pady=5)
# Buttons - when clicked the function is called
Button(window, text="Add Item", command=add_command).pack(pady=5)
Button(window, text="Delete Item", command=delete_command).pack(pady=5)
Button(window, text="Delete ALL Food Items",
command=delete_all_command).pack(pady=10)
window.mainloop()
|
74f7e45ab5fc619715f5e530b6790c65c51a3767 | caiooliveirac/Jogo-da-Forca | /core.py | 554 | 3.53125 | 4 | #Modelo de criação de diferentes arquivos txt com dificuldades diferentes baseados numa lista
arquivo = open('palavras2.txt',mode='r',encoding='utf8')
arquivo2 = open('palavras3.txt',mode='r',encoding='utf8')
todas = []
nivel = []
for linha in arquivo:
linha.strip()
todas.append(linha)
for palavra in arquivo2:
palavra.strip()
nivel.append(palavra)
with open('palavras2.txt','w',encoding='utf8') as arq:
for i, k in enumerate(todas):
if i > 0 and k not in nivel:
arq.write(f"{k}")
print(todas)
print(nivel)
|
66c823e68f5362768970826ee380e58da07b57d2 | jamesspearsv/cs50 | /pset6/mario/more/mario.py | 648 | 4.03125 | 4 | from cs50 import get_int
def main():
h = 0
while h < 1 or h > 8:
h = get_int("Height: ")
printPyramid(h)
# Function definitions
def printPyramid(h):
for i in range(h, 0, -1):
# Print left half
for j in range(h):
if j < i-1:
print(" ", end="")
else:
print("#", end="")
# Print gaps
print(" ", end="")
# Print right hal
for k in range(h, 0, -1):
if k <= i-1:
print("", end="")
else:
print("#", end="")
print() # Prints new line
# Main function
main() |
026dc30173ab7427f744b000f55558ffc19099e8 | glaxur/Python.Projects | /guess_game_fun.py | 834 | 4.21875 | 4 | """ guessing game using a function """
import random
computers_number = random.randint(1,100)
PROMPT = "What is your guess?"
def do_guess_round():
"""Choose a random number,ask user for a guess
check whether the guess is true and repeat whether the user is correct"""
computers_number = random.randint(1,100)
while True:
players_guess = int(input(PROMPT))
if computers_number == int(players_guess):
print("correct!")
break
elif computers_number > int(players_guess):
print("Too low")
else:
print("Too high")
while True:
print("Starting a new round")
print("The computer's number should be "+str(computers_number))
print("Let the guessing begin!!!")
do_guess_round()
print(" ")
|
19c763e647a12c9b697005354a86de78726e08b7 | lukechn99/leetcode | /nDistinct.py | 572 | 3.828125 | 4 | # given a string, find the number of substrings that have n distinct characters
# use sliding window
def distinct(string, ptr1, ptr2):
pass
def nDistinct(string, n):
ptr1 = 0
ptr2 = n
number_distinct = 0
while ptr1 < len(string) - n:
while ptr2 < len(string):
if distinct(string, ptr1, ptr2):
number_distinct += 1
ptr2 += 1
ptr1 += 1
ptr2 = ptr1 + n
return number_distinct
# we could also maintain a table of the characters and each time we slide we add or remove accordingly
|
d1a7e7a1efd779623129ce86fa8237e490690b4b | lukechn99/leetcode | /traverse.py | 264 | 3.5625 | 4 | import os
def traverse(dir):
print(dir)
tempcwd = os.getcwd()
if os.path.isdir(os.path.join(tempcwd, dir)):
for d in os.listdir(os.path.join(tempcwd, dir)):
os.chdir(os.path.join(tempcwd, dir))
traverse(d)
os.chdir(tempcwd)
traverse(".") |
4e9a3cb0737ffd797c2231646f57d6f00a14b4e9 | lukechn99/leetcode | /pleasePassTheCodedMessages.py | 2,429 | 3.984375 | 4 | # Please Pass the Coded Messages
# ==============================
# You need to pass a message to the bunny prisoners, but to avoid detection, the code you agreed
# to use is... obscure, to say the least. The bunnies are given food on standard-issue prison
# plates that are stamped with the numbers 0-9 for easier sorting, and you need to combine sets
# of plates to create the numbers in the code. The signal that a number is part of the code is
# that it is divisible by 3. You can do smaller numbers like 15 and 45 easily, but bigger numbers
# like 144 and 414 are a little trickier. Write a program to help yourself quickly create large
# numbers for use in the code, given a limited number of plates to work with.
# You have L, a list containing some digits (0 to 9). Write a function solution(L) which finds the
# largest number that can be made from some or all of these digits and is divisible by 3. If it is
# not possible to make such a number, return 0 as the solution. L will contain anywhere from 1 to 9
# digits. The same digit may appear multiple times in the list, but each element in the list may
# only be used once.
import unittest
import itertools
def solution(l):
return helper(sorted(l, reverse = True))
def helper(l):
if l == []:
return 0
if sum(l) % 3 != 0:
potentials = []
for i in range(len(l)):
new_l = l[:i] + l[i + 1:]
potentials.append(helper(new_l))
if potentials == []:
return 0
return max(potentials)
else:
str_list = [str(n) for n in l]
cur_perm = "".join(str_list)
int_cur_perm = int(cur_perm)
return int_cur_perm
# wrong solution, we must consider subsets
# def solution(l):
# perm = list(itertools.permutations(l))
# max = 0
# for p in perm:
# # convert to int
# str_list = [str(n) for n in p]
# cur_perm = "".join(str_list)
# int_cur_perm = int(cur_perm)
# if int_cur_perm > max and int_cur_perm % 3 == 0:
# max = int_cur_perm
# print(max)
# return max
class Test(unittest.TestCase):
def test1(self):
self.assertEqual(solution([3, 1, 4, 1]), 4311)
def test2(self):
self.assertEqual(solution([3, 1, 4, 1, 5, 9]), 94311)
if __name__=="__main__":
# main()
unittest.main() |
6ff855754a5b040e7b46749ce8a68a90e15a389a | lukechn99/leetcode | /count_clicks.py | 3,129 | 3.703125 | 4 | '''
You are in charge of a display advertising program. Your ads are displayed on websites all over the internet. You have some CSV input data that counts how many times that users have clicked on an ad on each individual domain. Every line consists of a click count and a domain name, like this:
counts = [ "900,google.com",
"60,mail.yahoo.com",
"10,mobile.sports.yahoo.com",
"40,sports.yahoo.com",
"300,yahoo.com",
"10,stackoverflow.com",
"20,overflow.com",
"5,com.com",
"2,en.wikipedia.org",
"1,m.wikipedia.org",
"1,mobile.sports",
"1,google.co.uk"]
Write a function that takes this input as a parameter and returns a data structure containing the number of clicks that were recorded on each domain AND each subdomain under it. For example, a click on "mail.yahoo.com" counts toward the totals for "mail.yahoo.com", "yahoo.com", and "com". (Subdomains are added to the left of their parent domain. So "mail" and "mail.yahoo" are not valid domains. Note that "mobile.sports" appears as a separate domain near the bottom of the input.)
Sample output (in any order/format):
calculateClicksByDomain(counts) =>
com: 1345
google.com: 900
stackoverflow.com: 10
overflow.com: 20
yahoo.com: 410
mail.yahoo.com: 60
mobile.sports.yahoo.com: 10
sports.yahoo.com: 50
com.com: 5
org: 3
wikipedia.org: 3
en.wikipedia.org: 2
m.wikipedia.org: 1
mobile.sports: 1
sports: 1
uk: 1
co.uk: 1
google.co.uk: 1
n: number of domains in the input
(individual domains and subdomains have a constant upper length)
'''
counts = [
"900,google.com",
"60,mail.yahoo.com",
"10,mobile.sports.yahoo.com",
"40,sports.yahoo.com",
"300,yahoo.com",
"10,stackoverflow.com",
"20,overflow.com",
"5,com.com",
"2,en.wikipedia.org",
"1,m.wikipedia.org",
"1,mobile.sports",
"1,google.co.uk"
]
'''
key: domain
value: (count, subdomains_list)
com : (900, [{yahoo : (300, [{sports : (40, []) }...]), {stackoverflow : (10, []), ])
[]
sports.yahoo.com
'''
# def add_value(count, domain, result):
# subdomains = domain.split(".")
# for name in reversed(subdomains):
# if name in
def parse_domain_counts(counts):
result = {}
for entry in counts:
count_split = entry.split(",")
count = int(count_split[0])
domain = count_split[1].split(".")
# see if each subdomain is in result
for i in reversed(range(len(domain))):
domain_name = ""
for j in range(i, len(domain)):
domain_name += domain[j]
if j < len(domain) - 1:
domain_name += "."
# add to dict
if domain_name in result:
result[domain_name] += count
else:
result[domain_name] = count
return result
parse_domain_counts(counts) |
fc3bd6d939a85c3cee0f57229bd9bbdcd4da9be0 | lukechn99/leetcode | /removeN.py | 822 | 3.75 | 4 | def removeEven (list):
for i in list:
if i % 2 == 0:
list.remove(i)
return list
list = [1, 2, 3, 4, 5, 6, 7, 8]
print(removeEven(list))
def removeMultTwo (n):
list = []
for i in range(2, n+1):
list.append(i)
for p in list:
# p starts as 2
# multiplier = 2
# multiplier = 3
# ...
for multiplier in range(2, len(list)):
if (p * multiplier) in list:
list.remove(p * multiplier)
# remove 4, 6, 8, 10... based on multiplier
return list
print("using mult two\n")
list2 = [2, 3, 4, 5, 6, 7, 8, 9, 10]
print(removeMultTwo(120))
def removeMultTwoByCount (n):
list = []
for i in range(2, n+1):
list.append(i)
for p in list:
sum = 2 * p
while sum <= list[-1]:
if sum in list:
list.remove(sum)
sum += p
return list
print(removeMultTwoByCount(100))
|
46f70133d8fc36aa8c21c51ba8cd35efd18fcfc7 | MenggeGeng/FE595HW4 | /hw4.py | 1,520 | 4.1875 | 4 | #part 1: Assume the data in the Boston Housing data set fits a linear model.
#When fit, how much impact does each factor have on the value of a house in Boston?
#Display these results from greatest to least.
from sklearn.datasets import load_boston
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
#load boston dataset
boston = load_boston()
#print(boston)
data = pd.DataFrame(boston['data'], columns= boston['feature_names'])
print(data.head())
data['target'] = boston['target']
print(data.head())
# The correlation map
correlation = data.corr()
sns.heatmap(data = correlation, annot = True)
plt.show()
# The correlation coefficient between target and features
print(correlation['target'])
#prepare the regression objects
X = data.iloc[:, : -1]
Y = data['target']
print(X.shape)
print(Y.shape)
#build regression model
reg_model = LinearRegression()
reg_model.fit(X,Y)
print('coefficient : \n ', reg_model.coef_)
#The impact of each factor have on the value of a house in Boston
coef = pd.DataFrame(data= reg_model.coef_, index = boston['feature_names'], columns=["value"])
print(coef)
#Display these results from greatest to least.
coef_abs = abs(reg_model.coef_)
coef_1 = pd.DataFrame(data= coef_abs , index = boston['feature_names'], columns=["value"])
print("Display these coefficient from greatest to least:")
print(coef_1.sort_values("value",inplace=False, ascending=False))
|
256c69199c1891d4c678824e59db2b80b69e3aa2 | sangianpatrick/hacktiv8-python-datascience | /day_01/task5.py | 273 | 3.859375 | 4 | #pesanan
orderan = list()
order = input("Masukkan pesanan pertama: \n")
orderan.append(order)
order = input("Masukkan pesanan kedua: \n")
orderan.append(order)
order = input("Masukkan pesanan ketiga: \n")
orderan.append(order)
print("Pesanan anda: \n")
print(orderan)
|
0145516901db83e2d3f6d3e4962212eb8c2c27d8 | sangianpatrick/hacktiv8-python-datascience | /day_02/task3.py | 134 | 3.578125 | 4 | pangkat = 3
for x in range(11):
a = x**pangkat
print("Hasil dari {x} pangkat {pangkat} adalah {a}".format(x=x,pangkat=pangkat,a=a))
|
546e3058dab3aec1e7aeac1c12d7a96ae404b1bd | ahilgenkamp/Pi_projects | /Boggle_AI/word_distribution.py | 741 | 3.65625 | 4 | #word distribution graph
import string
import matplotlib
from nltk.corpus import words
#load dictionary
word_list = words.words()
print('Total Words: '+str(len(word_list)))
low = string.ascii_lowercase
'''
for i in range(len(low)):
num_letters = sum(a.lower() == low[i] for a, *_ in word_list) #for notes on *_ --> https://www.python.org/dev/peps/pep-3132/
print(low[i].upper()+': '+str(num_letters))
'''
two_letters = []
for i in low:
for j in low:
two_letters.append(i+j)
for i in range(len(two_letters[0:35])):
num_letters = sum(a[0:2].lower() == two_letters[i] for a in word_list) #for notes on *_ --> https://www.python.org/dev/peps/pep-3132/
print(two_letters[i].upper()+': '+str(num_letters))
|
a7a25c301bdd9cf4cfea71458868d1aa7d20b548 | hannes1903/Homework-and-Exercises | /count.py | 409 | 3.6875 | 4 | import collections
words = ['a', 'b', 'a', 'c', 'b', 'k']
c = collections.Counter(words)
print (c)
print (c.most_common(2))
print (c['i'])
def count_1 (a):
a = collections.Counter(words).most_common(2)
return (a)
print (count_1 (words))
##
d={}
for word in words:
if word in ('a', 'b', 'h'):
if word in d:
d [word] += 1
else:
d[word] = 1
print(d)
|
61a6ef3a2803175b7082beb408ba794a4980c9b4 | hannes1903/Homework-and-Exercises | /even the last.py | 309 | 3.5625 | 4 | import math
import statistics
b = [1,2,4,5,6,7,8,9,6,6,4,5,]
print(len(b))
list2=b[0::2]
print (list2)
list3=sum(list2)*b[-1]
print (list3)
def checkio(V):
a=len(V)
if a==0:
return (0)
else:
list2=V[0::2]
list3=sum(list2)*V[-1]
return (list3)
print (checkio(b)) |
3b75c81b02d0b18839a1ed43429119fc0a3d05af | J-man21/Python_Basics | /107_for_loops.py | 595 | 3.84375 | 4 | # For Loops
# syntax
# for item in iterable:
# block of code
import time
cool_cars = ['Ferrari', 'Fiat', 'Skoda','Mk7','VW', 'focus']
#for car in cool_cars:
# print(car)
# time.sleep(1)
count = 1
for car in cool_cars:
print(count, '-', car)
count += 1
time.sleep(1)
# For loop for dictionaries
boris_dict = {
'name': 'boris',
'l_name': 'johnson',
'phone': '07939527648',
'address': 'Aymz',
}
for key in boris_dict:
print(key)
print(boris_dict['phone'])
for key in boris_dict:
print(boris_dict['phone'])
print(boris_dict['name'])
|
94d019ad93368584495f832b72ccc2c0230526c8 | kyleo83/EscapeTheKonigsberg | /bridge.py | 3,923 | 3.75 | 4 | from scene import Scene
from textwrap import dedent
from stats_inventory import Person, Inventory
import numpy as np
class Bridge(Scene):
def enter(self):
print(dedent("""
You find yourself on bridge #7 and you are not alone.
The captain of the ship 'Dicey Roll' is blocking
your path to the podbay, your only hope of escape.
Do you 'flee' or 'fight'?
"""))
choice = input('> ')
if 'flee' in choice:
print(dedent("""Looking around the bridge you see four
doors to the 'port', 'forward', 'starboard' and
'aft'. As the 'forward' door is block you choose
another."""))
choice = input("> ")
while choice.lower() != "quit":
choice = choice.lower()
if "port" in choice or choice == 'p':
return 'communication'
elif "starboard" in choice or choice == 's':
return 'armory'
elif "aft" in choice or choice == 'a':
return 'engineroom'
else:
print(dedent("""You stand frozen in place trying to
decide which door to open. You can go 'port',
'startboard' or 'aft'. This is a ship afterall."""))
choice = input("> ")
else:
print("Get ready to fight!")
capHealth = 10
bonusDamage = 0
choice = input("If you have a weapon now would be good time to 'use' it > ")
if "use" in choice and ("stick" in choice or "buzz" in choice):
myRoot = Inventory.item.insertKey("Lincoln Head Penny 1909 VBS")
foundNode = Inventory.item.searchBST("Buzz Stick", myRoot)
if foundNode is not None:
bonusDamage = 3
else:
print("You were unable to pull it out in time if you actually have one.")
print(dedent("""At first you attempt to throw him off-guard with
vast knowledge discrete mathmatics"""))
if Person.earthling.euler < 8:
print(dedent("""(The captain is not amused by anecdotes on
'Finite State Machines and gets in the first hit."""))
Person.earthling.health -= np.random.randint(1,3)
else:
print(dedent("""Your knowledge of graphs and set theory stuns him, allowing
you the first strike."""))
while capHealth > 0:
damage = np.random.randint(1,5) + bonusDamage + (Person.earthling.strength - 8)
capHealth -= damage
if bonusDamage != 0:
print("You swing at him with your Buzz Stick and hit him hard!\n")
else:
print("You swing at him with your fist and make contact.\n")
if capHealth > 0:
print("The captain swings at you\n")
Person.earthling.health -= np.random.randint(1,4)
if Person.earthling.health <= 0:
return 'disaster'
print(dedent("""You have defeated the captain! You find a small manual labeled 'Launch codes for the escape pod Joj. You add this to your inventory. You can go 'port', 'aft', 'starboard' or 'forward' to the podbay."""))
myRoot = Inventory.item.insertKey("Launch Codes for Joj")
print("\nCurrent Inventory: ")
Inventory.item.inOrder(myRoot)
choice = input("> ")
while choice.lower() != "quit":
choice = choice.lower()
if "port" in choice or choice == 'p':
return 'communication'
elif "starboard" in choice or choice == 's':
return 'armory'
elif "aft" in choice or choice == 'a':
return 'engineroom'
elif "forward" in choice or choice == 'f':
return 'podbay'
elif "inventory" in choice or choice == 'i':
myRoot = Inventory.item.insertKey("Lincoln Head Penny 1909 VBS")
print("Your inventory:")
Inventory.item.inOrder(myRoot)
print(dedent("""\nYou stand frozen in place trying to
decide which door to open. You can go 'port',
'startboard' or 'aft'. This is a ship afterall."""))
choice = input("> ") |
4766351a150037e894e98ccb190c9386af39a5a0 | slackbot115/calculadora_lei_de_ohm | /lei de ohm.py | 1,253 | 3.859375 | 4 | op = input("Digite qual lei de ohm voce deseja efetuar as contas: \n1 - Primeira Lei de Ohm (digite 1)\n2 - Segunda Lei de Ohm (digite 2)\n\n")
if op == "1":
conta = input("Digite o valor que voce deseja encontrar: \nR - Resistencia\nV - Tensao\nI - Intensidade Corrente\nDigite a respectiva letra que voce deseja efetuar a conta: ")
if conta.lower() == "r":
v = int(input("Digite a tensao (volts): "))
i = int(input("Digite a intensidade (amperes): "))
r1 = v / i
print("A resistencia ficou: ", int(r1))
elif conta.lower() == "v":
i = int(input("Digite a intensidade (amperes): "))
r = int(input("Digite a resistencia (ohm): "))
v = r * i
print("A tensao calculada ficou: ", int(v))
elif conta.lower() == "i":
v = int(input("Digite a tensao (volts): "))
r = int(input("Digite a resistencia (ohm): "))
i = v / r
print("A intensidade calculada ficou: ", int(i))
'''
l: m
p: ohm por m
a: mm2
'''
if op == "2":
l = int(input("Digite o comprimento do fio: "))
a = int(input("Digite a area transversal: "))
p = int(input("Digite a resistividade do material: "))
r2 = (p * l) / a
print("A resistencia final ficou: ", int(r2))
|
cf716a695460503ee0dbc131e3569d60f2669393 | jsrawan-mobo/samples | /python/ce/tictactoe.py | 1,567 | 3.703125 | 4 | # To go faster m = 1000
# So avoid going through 1M squares. We would need to do 4 types. So could be 4 * 1000
# This is pretty fast, so i don't think it be a problem
# We know the sum of any board is M
class TicTacToe(object):
def __init__(self, m):
self.the_board = [[False for x in xrange(m)] for y in xrange(m)]
def is_game_over(self, x, y):
m = len(self.the_board)
is_done = all([self.the_board[xi][y] for xi in xrange(m)])
if is_done:
return True
is_done = all([self.the_board[x][yi] for yi in xrange(m)])
if is_done:
return True
if x / y == 1:
is_done = all([self.the_board[pos][pos] for pos in xrange(m)])
if ((x - 1 - m) / y) == 1:
is_done = all([self.the_board[pos - 1 - m][pos] for pos in xrange(m)])
if is_done:
return True
return False
def make_move(self, x, y):
if not self.the_board[x][y]:
self.the_board[x][y] = True
else:
raise Exception("Already taken")
return True
if __name__ == '__main__':
ttt = TicTacToe(3)
ttt.make_move(0, 0)
ttt.make_move(1, 1)
ttt.make_move(2, 2)
if ttt.is_game_over(2, 2):
print "Finished game"
ttt = TicTacToe(3)
ttt.make_move(0, 0)
ttt.make_move(1, 1)
ttt.make_move(1, 2)
if not ttt.is_game_over(1, 2):
print "Not Done"
ttt.make_move(0, 2)
ttt.make_move(2, 2)
if ttt.is_game_over(2, 2):
print "Finished game"
|
c88ca226b26c7b77b58a6181dc36031c6d31d7fd | jsrawan-mobo/samples | /python/ce/baybridges2.py | 11,010 | 3.734375 | 4 | from copy import copy
from itertools import permutations, chain
from sys import argv
#
# Two sequences where the greatest subsequence, which is NON continguous
# assume only one unique
# Create a recursive sequence, that basically takes the left, and walks through all possibilities
# Its recursive
# This below will two strings and find the maximal possible sequence
# Starting at first leter
import re
import itertools
def slope(cc):
return (cc['yr'] - cc['yl']) / (cc['xr'] - cc['xl'])
def is_overlapping_box(c1, c2):
"""
The simple approximatation will turn the lines into 2D boxes, that we can
easily computer overlap. This is for set assignment
:param c1: dict of xl,yl,xr,yr
:param c2: dict of xl,yl,xr,yr
:return: the overlapping box or None
"""
# figure out the slope and reverse the logic if slopes are not the same sign
m1 = slope(c1)
m2 = slope(c2)
reverse = False
if m1 * m2 < 0:
reverse = True
if (c1['xl'] <= c2['xr'] and c2['xl'] <= c1['xr']):
if ((not reverse and (c1['yl'] <= c2['yr'] and c2['yl'] <= c1['yr']))
or (reverse and (c1['yl'] >= c2['yr'] and c2['yl'] >= c1['yr']))):
return {
'xl': min(c1['xl'], c2['xl']),
'xr': max(c2['xr'], c2['xr']),
'yl': max(c1['yl'], c2['yl']),
'yr': min(c1['yr'], c2['yr'])
}
return None
def is_colliding_line(c1, c2):
"""
Using line to line intersection described here:
http://en.wikipedia.org/wiki/Line%E2%80%93line_intersection
x = (b2.- b1) / (m1 - m2)
y = (b2*m1 - b1*m2) (m1 - m2)
Take l1, and make that intercept = 0
Take l2 and find its y intercept = 0
then we can find point of instersection using equations
:return : None if no overlap or the coordinate of the x,y point (its a line as a point)
"""
y_f = lambda m, x, b: m * x + b
x_f = lambda m, y, b: (y - b) / m
def swap_if(c):
if c['xr'] < c['xl']:
return {'xl': c['xr'],
'yl': c['yr'],
'xr': c['xl'],
'yr': c['yl']}
else:
return c
# This works only if the first point is on the left, we swap the points if required
c1 = swap_if(c1)
c2 = swap_if(c2)
# Setup the m and b for the linear equation. The number represent the number degrees of y
# over x.
# to get the number of degree slop of line
# >> math.degrees(math.atan(c1m)
c1m = slope(c1)
c2m = slope(c2)
# Now we set up the b valuea to represent the at x=x0 (like x=0). We pick
x0 = c1['xl']
c1b = c1['yl']
c2b = y_f(c2m, x0 - c2['xl'], c2['yl'])
# Now find the x,y point that overlaps. If m are equal (parallel lines)
# then we get infinite answer
try:
x_i = (c2b - c1b) / (c1m - c2m) + x0
y_i = (c2b * c1m - c1b * c2m) / (c1m - c2m)
except Exception:
return None
# Now the easy part, make sure the xi,yi is in the bounding box for both lines
eps = 1e-6
c_i = {'yl': y_i - eps, 'xl': x_i - eps, 'yr': y_i + eps, 'xr': x_i + eps}
if is_overlapping_box(c1, c_i) and is_overlapping_box(c2, c_i):
return {'yl': y_i, 'xl': x_i}
return None
# Second do
def group_by_overlapping_2(groups):
"""
# Another option is just to find a random overlap, and remove
# The one that has less overlaps.
# Prune operation can be recursive
:param groups:
:return:
"""
if len(groups) <= 1:
return groups
# 1. initialize empty list of conflicting nodes
groups_o = [(x[0], x[1], set()) for x in groups]
# 2. For each coordinate, check all others for overlap
for (idl, coordl, tl), (idr, coordr, tr) in itertools.product(groups_o, repeat=2):
if idl == idr:
continue
if is_colliding_line(coordl, coordr):
tl.add(idr)
# 3. sort by number of overlaps
# 4. while overlaps are not empty
while True:
groups_o = sorted(groups_o, key=lambda x: len(x[2]), reverse=True)
clen = len(groups_o[0][2])
all_index = [groups_o[0][0]]
for id, coord, t in groups_o[1:]:
if len(t) == clen:
all_index.append(id)
else:
break
# 5. Remove all k overlaps, and check if we are free
#group_copy = copy(groups_o)
for ki in all_index:
for id, coord, t in groups_o[1:]:
t.discard(ki)
del groups_o[0:len(all_index)]
sumc = sum([len(t) for id, coord, t in groups_o])
if sumc == 0:
#groups_o = group_copy
break
# 6. Optimize the lines to remove. assume k may not be optimal
# we have to remove k-1 overlaps, and check if we are free. If so do k-2
final_id = set([id for id, coord, t in groups_o])
groups_final = [x for x in groups if x[0] in final_id]
return groups_final
def group_by_overlapping(groups):
"""
Simply keep adding to a group if anything matches
:param groups:
:return: a list of of list of groups that overlap
"""
def is_group_colliding(coord, groups):
for id, coordg in groups:
if is_colliding_line(coord, coordg):
return True
return False
# This is n^2 to find interesection
sub_groups = []
for id, coord in groups:
found_groups = []
found_group_index = []
for k, sgroups in enumerate(sub_groups):
if is_group_colliding(coord, sgroups):
found_groups += sgroups
found_group_index.append(k)
if len(found_groups) > 0:
for k, ind in enumerate(found_group_index):
del sub_groups[ind - k]
found_groups.append((id, coord))
sub_groups.append(found_groups)
else:
sub_groups.append([(id, coord)])
return sub_groups
def gcdf(groups):
"""
Take the permutations at the top level, then for
each permutation, do a recursion to find the gc subgroup
:param groups_list:
:return: a list of of list of groups that overlap
"""
def is_group_colliding(coord, groups):
for id, coordg in groups:
if is_colliding_line(coord, coordg):
return True
return False
def gcfd_recurse(groups):
"""
Left tree is the group, right tree
:param groups:
:return:
"""
n = len(groups)
gcfd_ret = []
for id, coord in groups:
if not is_group_colliding(coord, gcfd_ret):
gcfd_ret.append((id, coord))
return gcfd_ret
all_perms = permutations(groups, len(groups))
longest = []
for perm in all_perms:
gcfd_group = gcfd_recurse(perm)
if len(gcfd_group) > len(longest):
longest = gcfd_group
if len(longest) >= len(groups) - 1:
return gcfd_group
return longest
def hsv_to_rgb(h, s, v):
if s == 0.0:
v *= 255
return [v, v, v]
# XXX assume int() truncates!
h = h / 60
i = int(h)
f = h - i
v *= 255
p = int(v * (1. - s))
q = int(v * (1. - s * f))
t = int(v * (1. - s * (1. - f)))
i %= 6
if i == 0:
return [v, t, p]
if i == 1:
return [q, v, p]
if i == 2:
return [p, v, t]
if i == 3:
return [p, q, v]
if i == 4:
return [t, p, v]
if i == 5:
return [v, p, q]
if __name__ == "__main__":
file_name = argv[1]
debug = False
input = file(file_name)
flist = [tuple([y for y in x.replace("\n", '').split(':')]) for x in input.readlines() if
len(x.strip()) > 0 and x[0] != '#']
coords = dict()
floatre = re.compile(
'([\-\+]?\d+\.\d+)[\s,\]\[]*([\-\+]?\d+\.\d+)[\s,\]\[]*([\-\+]?\d+\.\d+)[\s,'
'\]\[]*([\-\+]?\d+\.\d+)')
for id, val in flist:
res = floatre.search(val)
if not res:
raise Exception("Invalid input line {}".format(val))
coords[id] = {'yl': float(res.group(1).strip()), 'xl': float(res.group(2).strip()),
'yr': float(res.group(3).strip()), 'xr': float(res.group(4).strip())}
# for id1, coord1 in coord.iteritems():
# for id2, coord2 in coord.iteritems():
#
# box = is_overlapping_box(coord1, coord2)
# line = is_colliding_line(coord1, coord2)
#
# print "{}-{}-{}-{}".format(id1, id2, box, line)
# groups_list = group_by_bounding_box(coords)
# groups_only = [idb_groups['groups'] for idb_groups in groups_list]
# tHIS OVERLAPS ALL OF THEM
groups_only = [[(id, coord) for id, coord in coords.iteritems()]]
intersect_groups = []
for groups in groups_only:
intersect_groups += group_by_overlapping(groups)
if debug:
import matplotlib.pyplot as pyplot
for k, groups in enumerate(intersect_groups):
for id, coord in groups:
h, s, v = (int(k) * 60, 1, 1)
r, g, b = hsv_to_rgb(h, s, v)
color = '#{:02x}{:02x}{:02x}'.format(r, g, b)
pyplot.plot([coord['xl'], coord['xr']], [coord['yl'], coord['yr']], color=color,
linestyle='-', linewidth=2, label=id)
pyplot.text(coord['xl'], coord['yl'], '{}[{}]'.format(k, id), size=9, rotation=12,
color=color,
ha="center", va="center", bbox=dict(ec='1', fc='1'))
pyplot.legend()
pyplot.title("Groups")
pyplot.show()
final_groups = []
for groups in intersect_groups:
final_groups += group_by_overlapping_2(groups)
coord_dict = dict([(int(groups[0]), groups[1]) for groups in chain(final_groups)])
for key in sorted(coord_dict.keys()):
print key
if debug:
import matplotlib.pyplot as pyplot
for id, coord in coords.iteritems():
h, s, v = (int(id) * 50, 1, 1) if int(id) in coord_dict else (360, 0, 0)
r, g, b = hsv_to_rgb(h, s, v)
color = '#{:02x}{:02x}{:02x}'.format(r, g, b)
pyplot.plot([coord['xl'], coord['xr']], [coord['yl'], coord['yr']], color=color,
linestyle='-', linewidth=2, label=id)
rotation = 0
pyplot.text(coord['xl'], coord['yl'], '{}-{}\n{}'.format(id, coord['xl'], coord['yl']),
size=6, rotation=rotation, color=color,
ha="center", va="center", bbox=dict(ec='1', fc='1'))
pyplot.text(coord['xr'], coord['yr'], '{}-{}\n{}'.format(id, coord['xr'], coord['yr']),
size=6, rotation=rotation, color=color,
ha="center", va="center", bbox=dict(ec='1', fc='1'))
pyplot.legend()
pyplot.title("Non-Intersecting lines")
pyplot.show()
|
a6622d0573a5ead8200ba2ffb9eb5d736d0b7cb3 | easontm/Cinemagraphs | /scripts/note_refresh.py | 726 | 3.515625 | 4 | import urllib.request
import fileinput
from os import system
localNotePath = "/home/pi/Cinemagraphs/notes/Notes.txt"
remoteNotePath = "https://www.dropbox.com/s/nh8o4gou047td5m/Notes.txt?dl=1"
# Download the notes from remoteNotePath and save it locally under localNotePath:
with urllib.request.urlopen(remoteNotePath) as response, open(localNotePath, 'wb') as out_file:
data = response.read() # a `bytes` object
out_file.write(data)
# fixing line end chars
with fileinput.FileInput(localNotePath, inplace=True, backup='.bak') as file:
for line in file:
print(line, end='')
fileinput.close()
# backs up and updates html files
system("python3 /home/pi/Cinemagraphs/scripts/update_html.py")
|
9d723b583cec6a1c2ec2aea6497eec0d6dd6d27f | ageinpee/DaMi-Course | /1/Solutions/Solution-DAMI1-Part3.py | 2,024 | 4.15625 | 4 | ''' Solution to Part III - Python functions. Comment out the parts you do not wish to execute or copy
a specific function into a new py-file'''
#Sum of squares, where you can simply use the square function you were given
def sum_of_squares(x, y):
return square(x) + square(y)
print sum_of_squares(3, 5) # Try out yourself
#Increment by 1
x = 0
y = 0
def incr(x):
y = x + 1
return y
print incr(5) # Try out yourself
# Increment by any n; quite straightforward, right?
x = 0
y = 0
def incr_by_n(x, n):
y = x + n
return y
print incr_by_n(4,2) # Try out yourself
#Factorial of a number
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
n=int(input("The number you want to compute the factorial of: ")) # User input
print "Result:", factorial(4) # Try out yourself
#Display numbers between 1 and 10 using 'for' ...
for a in range(1, 11):
print a
#... and 'while'
a=1
while a<=10:
print a
a+=1
#Test if a number is between 1 and 10 (can be of any range though)
def number_in_range(n):
if n in range(1,10):
print( " %s is in the range"%str(n))
else :
print "The number is outside the given range."
test_range(8) # Try out yourself
'''Multiple if-conditionals
Note, that no keyword 'end' is needed! Instead, program blocks are controlled via indentation.
For beginners, indentation errors are most likely to occur, so playing around and extending smaller
code snippets to bigger program code can better help understanding the underlying
Python interpretation process'''
def chain_conditions(x,y):
if x < y:
print x, "is less than", y
elif x > y:
print x, "is greater than", y
else:
print x, "and", y, "are equal"
chain_conditions(50, 10) # Try out yourself
#Prime number
def test_prime(n):
if (n==1):
return False
elif (n==2):
return True;
else:
for x in range(2,n):
if(n % x==0):
return False
return True
print(test_prime(7)) # Try out yourself
|
3abbabd95a1f0b3d2cc6f91659af0231d9d9b112 | sejinwls/2018-19-PNE-practices | /session-17/client2.py | 1,771 | 3.921875 | 4 | # -- Example of a client that uses the HTTP.client library
# -- for requesting a JSON object and printing their
# -- contents
import http.client
import json
import termcolor
PORT = 8001
SERVER = 'localhost'
print("\nConnecting to server: {}:{}\n".format(SERVER, PORT))
# Connect with the server
conn = http.client.HTTPConnection(SERVER, PORT)
# -- Send the request message, using the GET method. We are
# -- requesting the main page (/)
conn.request("GET", "/listusers")
# -- Read the response message from the server
r1 = conn.getresponse()
# -- Print the status line
print("Response received!: {} {}\n".format(r1.status, r1.reason))
# -- Read the response's body
data1 = r1.read().decode("utf-8")
# -- Create a variable with the data,
# -- form the JSON received
person = json.loads(data1)
print("CONTENT: ")
# Print the information in the object
print()
print("Total people in the database: {}".format(len(person["people"])))
for i, num in enumerate(person["people"]):
termcolor.cprint("Name: ", 'green', end="")
print(person["people"][i]['Firstname'], person["people"][i]['Lastname'])
termcolor.cprint("Age: ", 'green', end="")
print(person["people"][i]['age'])
# Get the phoneNumber list
phoneNumbers = person["people"][i]['phoneNumber']
# Print the number of elements int the list
termcolor.cprint("Phone numbers: ", 'green', end='')
print(len(phoneNumbers))
# Print all the numbers
for i, num in enumerate(phoneNumbers):
termcolor.cprint(" Phone {}:".format(i), 'blue')
# The element num contains 2 fields: number and type
termcolor.cprint(" Type: ", 'red', end='')
print(num['type'])
termcolor.cprint(" Number: ", 'red', end='')
print(num['number']) |
6f4e6fe5a6989ddd065712fe1e9d917d31648b6b | sejinwls/2018-19-PNE-practices | /Session-7/client.py | 426 | 3.546875 | 4 | # Programming our first client
import socket
# Create a socket for communicating with the server
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print("Socket created")
PORT = 8080
IP = "212.128.253.108"
# Connect to the server
s.connect((IP, PORT))
# Send a message
s.send(str.encode("HELLO FROM MY CLIENT"))
msg = s.recv(2048).decode("utf-8")
print("Mesaage from server: ")
print(msg)
s.close()
print("The end")
|
45fc9452f03b169869eb753bf3ffc017540dd052 | sejinwls/2018-19-PNE-practices | /session-5/ex-1.py | 620 | 4.1875 | 4 | def count_a(seq):
""""THis function is for counting the number of A's in the sequence"""
# Counter for the As
result = 0
for b in seq:
if b == "A":
result += 1
# Return the result
return result
# Main program
s = input("Please enter the sequence: ")
na = count_a(s)
print("The number of As is : {}".format(na))
# Calculate the total sequence lenght
tl = len(s)
# Calculate the percentage of As in the sequence
if tl > 0:
perc = round(100.0 * na/tl, 1)
else:
perc = 0
print("The total lenght is: {}".format(tl))
print("The percentage of As is {}%".format(perc))
|
3e282477d9c87ed3371cec434b14c76908e72b91 | ElonRM/DataScienceBuch | /Kapitel_5_Statistik/Lagemaße.py | 1,223 | 3.609375 | 4 | from typing import Counter, List
import numpy
num_friends = numpy.random.binomial(100, 0.06, 206)
def mean(xs: List[float]) -> float:
return sum(xs)/len(xs)
# Die Unterstriche zeigen, dass dies "private" Funktionen sind, da sie nur
# von unserer median Funktion, nicht aber von anderen Nutzern unserer Statistik
# Bibliotek verwendet werden sollen
def _meadian_even(xs: List[float]) -> float:
"""Liefert den Mittelwert die zwei mittleren Einträge"""
return (sorted(xs)[len(xs)//2-1] + sorted(xs)[len(xs)//2])/2
def _median_odd(xs: List[float]) -> float:
"""Liefert den Median"""
return sorted(xs)[len(xs)//2]
def median(v: List[float]) -> float:
"""Lifert den Median abhängig von gerade/ungeraden Anzahlen"""
return _median_odd(v) if len(v) % 2 == 1 else _meadian_even(v)
def quantile(xs: List[float], p: float) -> float:
"""Liefert den Wert des p-ten Perzentils"""
return sorted(xs)[int(len(xs)*p)]
def mode(xs: List[float]) -> List[float]:
"""Liefert eine Liste, denn es kann mehr als einen Modus geben"""
counts = Counter(xs)
max_count = max(counts.values())
return [x_i
for x_i, count in counts.items()
if count == max_count]
|
4e8419fba8837646ac89192407d2f4fcf9c74fa0 | ElonRM/DataScienceBuch | /Kapitel_5_Statistik/Einen_einzelnen_Datensatz_beschreiben.py | 790 | 3.625 | 4 | import numpy as np
from collections import Counter
from matplotlib import pyplot as plt
import math
num_friends = np.random.binomial(100, 0.08, 204)
friends_counter = Counter(num_friends)
plt.bar(friends_counter.keys(), friends_counter.values(), edgecolor=(0, 0, 0))
#plt.xticks([20*i for i in range(6)])
#plt.yticks([i*5 for i in range(math.ceil(max(friends_counter.values())//5+2))])
plt.axis([0, 101, 0, max(friends_counter.values())+1])
plt.xlabel("# of friends")
plt.ylabel("# of people")
plt.title("Histogram of friends count")
plt.show()
num_points = len(num_friends)
largest_value = max(num_friends)
smallest_value = min(num_friends)
sorted_values = sorted(num_friends)
smallest_value = sorted_values[0]
largest_value = sorted_values[-1]
second_largest_number = sorted_values[-2]
|
e152129339f29660b810322076c088030a59ff0d | ElonRM/DataScienceBuch | /kapitel_3_Daten_Visualisierung/Balkendiagramme.py | 2,264 | 3.8125 | 4 | from matplotlib import pyplot as plt
from collections import Counter
plots = ["movies", "grades", "mentions"]
# Funktioniert nicht wirklich...
selected_plot = plots[2]
#grades = [83, 95, 91, 87, 70, 0, 85, 82, 100, 67, 73, 77, 0]
x_values = {
"movies": ["Annie Hall", "Ben-Hur", "Casablanca", "Gandhi", "West Side Story"],
"grades": [x + 5 for x in Counter(min((grade) // 10 * 10, 90) for grade in [83, 95, 91, 87, 70, 0, 85, 82, 100, 67, 73, 77, 0]).keys()],
"mentions": [2017, 2018],
}
y_values = {
"movies": [5, 11, 3, 8, 10],
"grades": Counter(min((grade) // 10 * 10, 90) for grade in [83, 95, 91, 87, 70, 0, 85, 82, 100, 67, 73, 77, 0]).values(),
"mentions": [500, 505],
}
x_labels = {
"movies": None,
"grades": "Decile",
"mentions": None,
}
y_labels = {
"movies": "# of Academy Awards",
"grades": "# of students",
"mentions": "# of times I heard someone say 'data science'",
}
axis_ranges = {
"movies": None,
"grades": [-5, 105, 0, max(y_values["grades"])+1],
"mentions": [min(x_values["mentions"])-0.5, max(x_values["mentions"])+0.5, 0, max(y_values["mentions"])+50],
}
x_ticks = {
"movies": [range(len(x_values["movies"])), x_values["movies"]],
"grades": [10 * i for i in range(11)],
"mentions": x_values["mentions"],
}
y_ticks = {
"movies": None,
"grades": None,
"mentions": [100 * i for i in range((max(y_values["mentions"])//100)+1)],
}
bar_width = {
"movies": [False],
"grades": [True, 10],
"mentions": [False],
}
edge_color = {
"movies": None,
"grades": (0, 0, 0),
"mentions": None,
}
titles = {
"movies": "My Favorite Movies",
"grades": "Distribution of Exam 1 grades",
"mentions": "Not so huge anymore",
}
plt.bar(x_values[selected_plot],
# gibt jedem Balken die korrekte Höhe (Anzahö, wie oft die Note vorkam)
y_values[selected_plot],
# bar_width[selected_plot][1] if bar_width[selected_plot][0] == True else pass,
edgecolor=edge_color[selected_plot]
)
plt.xticks(x_ticks[selected_plot])
plt.yticks(y_ticks[selected_plot])
plt.axis(axis_ranges[selected_plot])
plt.xlabel(x_labels[selected_plot])
plt.ylabel(y_labels[selected_plot])
plt.title(titles[selected_plot])
plt.show()
|
468fc754315c516757a5e679e03e13d97d69f3f5 | Sergey-Shulnyaev/my_python | /graphics/moodle/1/15.py | 3,969 | 3.828125 | 4 | from math import sqrt
import math
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return "(%.2f, %.2f)" % (self.x, self.y)
def distanceTo(self, point):
return math.sqrt((self.x - point.x) ** 2 + (self.y - point.y) ** 2)
def __sub__(self, other):
return Point(math.floor((self.x - other.x) * 10000) / 10000, math.floor((self.y - other.y) * 10000) / 10000)
class Line:
def __init__(self, a, b, c):
if abs(a) < 0.0001:
self.a = 0
else:
self.a = a
if abs(b) < 0.0001:
self.b = 0
else:
self.b = b
if abs(c) < 0.0001:
self.c = 0
else:
self.c = c
def __str__(self):
if self.a < 0:
a = "-%.2fx" % (-self.a)
else:
a = "%.2fx" % (self.a)
if self.b < 0:
b = " - %.2fy" % (-self.b)
else:
b = " + %.2fy" % (self.b)
if self.c < 0:
c = " - %.2f" % (-self.c)
else:
c = " + %.2f" % (self.c)
return a + b + c + " = 0"
@staticmethod
def fromCoord(x1, y1, x2, y2):
return Line(y1 - y2, x2 - x1, x1 * y2 - x2 * y1)
def distanceToZero(self):
return abs(self.c) / sqrt(self.a ** 2 + self.b ** 2)
def distanceToPoint(self, point):
return abs(self.a * point.x + self.b * point.y + self.c) / sqrt(self.a ** 2 + self.b ** 2)
def isParallel(self, line):
if abs(self.b * line.a - self.a * line.b) < 0.001:
return True
else:
return False
def intersection(self, line):
if self.isParallel(line):
return None
else:
x = (line.c * self.b - self.c * line.b)/(line.b * self.a - self.b * line.a)
y = (line.c * self.a - self.c * line.a)/(self.b * line.a - self.a * line.b)
if abs(x) < 0.001:
x = 0
if abs(y) < 0.001:
y =0
p = Point(x, y)
return p
def nearPoint(self, point):
oLine = Line(self.b, -self.a, self.a * point.y - self.b * point.x)
return self.intersection(oLine)
def oneSide(self, p1, p2):
nearP1 = self.nearPoint(p1)
nearP2 = self.nearPoint(p2)
v1 = nearP1 - p1
v2 = nearP2 - p2
if v1.x * v2.x >= 0:
return True
else:
return False
def normalize(self):
if self.c !=0:
self.a = self.a/self.c
self.b = self.b/self.c
self.c = 1
elif self.a != 0:
self.b = self.b/self.a
self.a = 1
elif self.b != 0:
self.b = 1
return 0
def perpendicularLine(self, point):
return Line(self.b, -self.a, self.a * point.y - self.b * point.x)
def parallelLine(self, point):
return Line(self.a, self.b, -self.a * point.x - self.b * point.y)
def projectionLength(self, p1, p2):
nearP1 = self.nearPoint(p1)
nearP2 = self.nearPoint(p2)
return sqrt((nearP1.x - nearP2.x)**2 + (nearP1.y - nearP2.y)**2)
def middlePoint(self, p1):
nearP1 = self.nearPoint(p1)
v1 = nearP1 - p1
return Point(p1.x + v1.x/2, p1.y + v1.y/2)
def symmetricPoint(self, p1):
nearP1 = self.nearPoint(p1)
v1 = nearP1 - p1
return Point(p1.x + v1.x*2, p1.y + v1.y*2)
def insideTreug(self, p1):
nearP1 = self.nearPoint(p1)
v1 = nearP1 - p1
if (v1.x * nearP1.x >= 0 and v1.y * nearP1.y >= 0) and(p1.x * nearP1.x >= 0 and p1.y * nearP1.y >= 0):
return True
else:
return False
p2 = Point(0,1)
p1 = Point(7.62, 1.11)
x = Line.fromCoord(0, 1, 1, 0)
y = Line.fromCoord(1, 0, 0, 1)
z = Line.fromCoord(0, 6, 0, -7.25)
print(y)
print(y.nearPoint(p2))
print(y.nearPoint(p2)- p2)
print(y.insideTreug(p2))
|
29f58b769d226b4790169e5730c7a9075b8b0451 | Sergey-Shulnyaev/my_python | /HomeWork_10.09.19/Third.py | 2,353 | 3.640625 | 4 |
import tkinter
class GaloConverter:
def __init__(self):
# Создать главное окно.
self.main_window = tkinter.Tk()
# Создать три рамки, чтобы сгруппировать элементы интерфейса.
self.top_frame = tkinter.Frame()
self.mid1_frame = tkinter.Frame()
self.mid2_frame = tkinter.Frame()
self.bottom_frame = tkinter.Frame()
self.galo_label = tkinter.Label(self.top_frame,
text='Введите количество галлонов:')
self.galo_entry = tkinter.Entry(self.top_frame,
width=10)
self.galo_label.pack(side='left')
self.galo_entry.pack(side='left')
self.mile_label = tkinter.Label(self.mid1_frame,
text='Введите количество миль:')
self.mile_entry = tkinter.Entry(self.mid1_frame,
width=20)
self.mile_label.pack(side='left')
self.mile_entry.pack(side='left')
self.descr_label = tkinter.Label(self.mid2_frame,
text='Мили на галлон (MPG):')
self.value = tkinter.StringVar()
self.mpg_label = tkinter.Label(self.mid2_frame,
textvariable=self.value)
self.descr_label.pack(side='left')
self.mpg_label.pack(side='left')
self.calc_button = tkinter.Button(self.bottom_frame,
text='Преобразовать',
command=self.convert)
self.quit_button = tkinter.Button(self.bottom_frame,
text='Выйти',
command=self.main_window.destroy)
self.calc_button.pack(side='left')
self.quit_button.pack(side='left')
self.mid1_frame.pack()
self.top_frame.pack()
self.mid2_frame.pack()
self.bottom_frame.pack()
tkinter.mainloop()
def convert(self):
galo = float(self.galo_entry.get())
miles = float(self.mile_entry.get())
MPG = miles / galo
self.value.set(MPG)
# Создать экземпляр класса KiloConverterGUI.
Galo = GaloConverter() |
4d7589abe594f6a22e9d308214666b90054a23c4 | Sergey-Shulnyaev/my_python | /graphics/moodle/1/4.py | 818 | 4.0625 | 4 | from math import sqrt
class Line:
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
def __str__(self):
if self.a < 0:
a = " - %.2fx" % (-self.a)
else:
a = "%.2fx" % (self.a)
if self.b < 0:
b = " - %.2fx" % (-self.b)
else:
b = " + %.2fx" % (self.b)
if self.c < 0:
c = " - %.2fx" % (-self.c)
else:
c = " + %.2fx" % (self.c)
return a + b + c + " = 0"
@staticmethod
def fromCoord(x1, y1, x2, y2):
return Line(y1 - y2, x2 - x1, x1 * y2 - x2 * y1)
def distanceToZero(self):
return abs(self.c) / sqrt(self.a ** 2 + self.b ** 2)
s = Line(3,4,5)
x = Line.fromCoord(1, 0, 0, 1)
print(s)
print(x.distanceToZero())
|
18fc474590f1def29690c55bd15232b983edba25 | Sergey-Shulnyaev/my_python | /HomeWork_1/cinema_price.py | 1,448 | 3.5 | 4 | # -*- coding: utf-8 -*-
"""
Created on Tue Feb 19 14:37:06 2019
"""
def vibor_film(film,time):
if film == 'Пятница':
if time == 12:
return 250
elif time == 16:
return 350
elif time == 20:
return 450
elif film == 'Чемпионы':
if time == 10:
return 250
elif time == 13:
return 350
elif time == 16:
return 350
elif film == 'Пернатая банда':
if time == 10:
return 350
elif time == 14:
return 450
elif time == 18:
return 450
else:
return 0
def skidka(data,numbil):
a = 1
if data == 'Завтра' or data == 'завтра':
a -= 0.05
elif data != 'сегодня' or data != 'Сегодня':
return 0
if numbil >= 20:
a -= 0.2
return a
film = input('Сейчас в кино фильмы:"Пятница", "Чемпионы", "Пернатая банда"\nВыберите фильм:\t')
data = input('Введите дату сеанса:\t')
time = int(input('Введите время сеанса:\t'))
numbil = int(input('Укажите количество билетов:\t'))
a = vibor_film(film,time)
b = skidka(data,numbil) * numbil
if a * b == 0:
print('Ошибка ввода')
else:
print('Стоимость булетов будет:',a*b)
|
38285d586d40592a3a00bace74aa4166960e6b03 | moreira-matheus/math-fun | /exp_pow.py | 513 | 3.765625 | 4 | # -*- coding: utf-8 -*-
"""
Created on Thu Oct 4 13:58:42 2018
@author: USP
"""
import random
import matplotlib.pyplot as plt
def exp_pow_num(x):
return x**x
def exp_pow_den(x):
return x**(1./x)
N = 20000
x_low, x_high = 10**(-6), 2
x = sorted([random.uniform(x_low, x_high) for _ in range(N)])
y_num = [exp_pow_num(i) for i in x]
y_den = [exp_pow_den(i) for i in x]
plt.figure(1)
plt.plot(x,y_num, label='$ f(x) = x^{x} $')
plt.plot(x,y_den, label='$ f(x) = x^{1/x} $')
plt.legend()
plt.show()
|
7b5046099a1e06aa79d090d9f2d3fee33da48946 | aratik711/100-python-programs | /my_exception_2.py | 456 | 3.859375 | 4 | """
Define a custom exception class which takes a string message as attribute.
Hints:
To define a custom exception, we need to define a class inherited from Exception.
"""
class myError(Exception):
"""My own exception class
Attributes:
msg -- explanation of the error
"""
def __init__(self, msg):
self.msg = msg
try:
raise myError("Something went wrong")
except myError as err:
print(err.msg)
|
dbe164b35c75b08ccfca88cf63db48220b7ffafc | aratik711/100-python-programs | /number_add.py | 386 | 4.09375 | 4 | """
Write a program that computes the value of a+aa+aaa+aaaa with a given digit as the value of a.
Suppose the following input is supplied to the program:
9
Then, the output should be:
11106
"""
num = int(input())
num1 = int("%s" % num)
num2 = int("%s%s" % (num, num))
num3 = int("%s%s%s" % (num, num, num))
num4 = int("%s%s%s%s" % (num, num, num, num))
print(num1+num2+num3+num4)
|
30ee27670b91ef7aa6bfc727131e6d2271c00f6c | aratik711/100-python-programs | /frequency.py | 692 | 4.09375 | 4 | """
Question:
Write a program to compute the frequency of the words from the input. The output should output after sorting the key alphanumerically.
Suppose the following input is supplied to the program:
New to Python or choosing between Python 2 and Python 3? Read Python 2 or Python 3.
Then, the output should be:
2:2
3.:1
3?:1
New:1
Python:5
Read:1
and:1
between:1
choosing:1
or:2
to:1
Hints
In case of input data being supplied to the question, it should be assumed to be a console input.
"""
sentence = input()
freq = {}
for word in sentence.split():
freq[word] = freq.get(word, 0) + 1
words = sorted(freq.keys())
for word in words:
print(word + ":" + str(freq[word]))
|
e14736ccc657561a7db0a6653d64f05953b85d30 | aratik711/100-python-programs | /eval_example.py | 320 | 4.28125 | 4 | """
Please write a program which accepts basic mathematic expression from console and print the evaluation result.
Example:
If the following string is given as input to the program:
35+3
Then, the output of the program should be:
38
Hints:
Use eval() to evaluate an expression.
"""
exp = input()
print(eval(exp)) |
0e38a128a6b075c53e090d701674e4ff4b32026d | aratik711/100-python-programs | /isogram.py | 516 | 3.859375 | 4 | """
Determine if a word or phrase is an isogram.
An isogram (also known as a "nonpattern word") is a word or phrase without a repeating letter, however spaces and hyphens are allowed to appear multiple times.
Examples of isograms:
lumberjacks
background
downstream
six-year-old
The word isograms, however, is not an isogram, because the s repeats.
"""
def is_isogram(string):
string = list(filter(str.isalpha, string.lower()))
return len(set(string)) == len(string)
print(is_isogram("lumberjacks"))
|
d33e36b0734802ce63caaa7310a21ecb2b6081d6 | aratik711/100-python-programs | /subclass_example.py | 382 | 4.125 | 4 | """
Question:
Define a class named American and its subclass NewYorker.
Hints:
Use class Subclass(ParentClass) to define a subclass.
"""
class American:
def printnationality(self):
print("America")
class NewYorker:
def printcity(self):
American.printnationality(self)
print("New York")
citizen = NewYorker()
citizen.printcity()
|
f3744e80c43703b02eab678c8b9e4b5d9569f3fb | ValeriiaGW/IntroPython_Bakanova_Valeriia | /HW4/hw_test.py | 1,361 | 3.890625 | 4 | values = [1, 2, 3, 4, 5]
print(type(values))
values = (1, 2, 3, 4, 5)
print(type(values))
values = (1, 2, 3, 4, 5)
values = list(values)
print(type(values))
values = [1, 2, 3, 4, 5]
values = tuple(values)
print(type(values))
values = [1, 2, 3, 4, 5]
result = []
for value in values:
result.append(value)
print(result)
values = [1, 2, 3, 4, 5]
result = []
for value in values[::-1]:
result.append(value)
print(result)
values = [1, 2, 3, 4, 5]
print(len(values))
values = [1, 2, 3, 4, 5]
new_value = values + values[::-1]
print(new_value)
values = [1, 2, 3, 4, 5]
new_value = values
new_value.append(6)
print(values)
values = [1, 2, 3, 4, 5]
new_value = values.copy()
new_value.append(6)
print(values)
values = [0] * 6
values[0] = 1
print(values)
value = 0
values = [value] * 6
value = 1
print(values)
my_list = [0]
values = [my_list] * 3
print(values)
my_list = [0]
values = [my_list] * 3
my_list.append(1)
print(values)
my_list = [0]
values = [my_list.copy()] * 3
my_list.append(1)
print(values)
my_list = ["a", "b", "c", "d", "e", "f"]
my_str = " ".join(my_list)
print(my_str)
my_list = ["a", "b", "c", "d", "e", "f"]
my_str = "_".join(my_list)
print(my_str)
my_list = ["a", "b", "c", "d", "e", "f"]
my_str = "_".join(my_list[::-1])
print(my_str)
my_list = ["a", "b", "c", "d", "e", "f"]
my_str = "".join(my_list[::2])
print(my_str)
|
86977ffec84ee264f4dbf4c17e374611ca7ef533 | ValeriiaGW/IntroPython_Bakanova_Valeriia | /HW_8/hw_8.py | 2,845 | 3.640625 | 4 | # 1) Дан список словарей persons в формате [{"name": "John", "age": 15}, ... ,{"name": "Jack", "age": 45}]
# а) Напечатать имя самого молодого человека. Если возраст совпадает - напечатать все имена самых молодых.
# б) Напечатать самое длинное имя. Если длина имени совпадает - напечатать все имена.
# в) Посчитать среднее количество лет всех людей из списка.
#
persons = [
{"name": "Jon", "age": 15},
{"name": "Mike", "age": 35},
{"name": "Anna", "age": 15},
{"name": "Samanta", "age": 75},
{"name": "Jack", "age": 45},
]
age_list = []
names_length = []
for person in persons:
age = person.get("age")
age_list.append(age)
long_name = len(person.get("name"))
names_length.append(long_name)
min_age = min(age_list)
for person in persons:
if person.get("age") == min_age:
print(person.get("name"))
max_name_length = max(names_length)
for person in persons:
if len(person.get("name")) == max_name_length:
print(person.get("name"))
avg_age = sum(age_list) / len(age_list)
print(avg_age)
# 2) Даны два словаря my_dict_1 и my_dict_2.
# а) Создать список из ключей, которые есть в обоих словарях.
# б) Создать список из ключей, которые есть в первом, но нет во втором словаре.
# в) Создать новый словарь из пар {ключ:значение}, для ключей, которые есть в первом, но нет во втором словаре.
# г) Объединить эти два словаря в новый словарь по правилу:
# если ключ есть только в одном из двух словарей - поместить пару ключ:значение,
# если ключ есть в двух словарях - поместить пару {ключ: [значение_из_первого_словаря, значение_из_второго_словаря]},
#
# {1:1, 2:2}, {11:11, 2:22} ---> {1:1, 11:11, 2:[2, 22]}
my_dict1 = {"key1": 1, "key2": 2, "key5": 5}
my_dict2 = {"key1": 1, "key3": 3, "key4": 4}
keys_1 = set(my_dict1.keys())
keys_2 = set(my_dict2.keys())
my_list_a = list(keys_1.intersection(keys_2))
my_list_b = list(keys_1.difference(keys_2))
new_dict_c = {}
for key, value in my_dict1.items():
if key in my_list_b:
new_dict_c[key] = value
new_dict_g = my_dict1.copy()
for key, value in my_dict2.items():
if key in new_dict_g:
new_dict_g[key] = [new_dict_g[key], value]
else:
new_dict_g[key] = value
|
b02b74b30fa5db9a2c53d84dae858543ef2e3e00 | S-Cardenas/Chess_Python_FP | /Pawn.py | 3,416 | 3.546875 | 4 | #location has to be the index of the list board
def Pawn(piece, location, board, active_indx):
if piece > 0:
if location >= 9 and location <= 16:
a = location + 1 * 9
b = location + 2 * 9
c = location + (1 * 9) + 1
d = location + (1 * 9) - 1
new_indxs = [a, b, c, d]
#Check if new location is an active index
i = 0
for item in new_indxs:
if item not in active_indx:
new_indxs[i] = 'null'
i += 1
#Define which piece ID is in the new_indxs
piece_ID = []
for indx in new_indxs:
if indx == 'null':
piece_ID.append('null')
else:
piece_ID.append(board[indx])
this = []
if piece_ID[0] == 0 and piece_ID[1] == 0:
this.extend(new_indxs[0:2])
elif piece_ID[0] == 0 and piece_ID[1] != 0:
this.append(new_indxs[0])
if piece_ID[2] < 0 and piece_ID[2] != 'null':
this.append(new_indxs[2])
if piece_ID[3] < 0 and piece_ID[3] != 'null':
this.append(new_indxs[3])
return this
elif location >= 18 and location <= 61:
a = location + 1 * 9
c = location + (1 * 9) + 1
d = location + (1 * 9) - 1
new_indxs = [a, c, d]
#Check if new location is an active index
i = 0
for item in new_indxs:
if item not in active_indx:
new_indxs[i] = 'null'
i += 1
#Define which piece ID is in the new_indxs
piece_ID = []
for indx in new_indxs:
if indx == 'null':
piece_ID.append('null')
else:
piece_ID.append(board[indx])
this = []
if piece_ID[0] == 0:
this.append(new_indxs[0])
if piece_ID[1] != 'null' and piece_ID[1] < 0:
this.append(new_indxs[1])
if piece_ID[2] != 'null' and piece_ID[2] < 0:
this.append(new_indxs[2])
return this
else:
this = []
return this
elif piece < 0:
if location >= 54 and location <= 61:
a = location - 1 * 9
b = location - 2 * 9
c = location - (1 * 9) + 1
d = location - (1 * 9) - 1
new_indxs = [a, b, c, d]
#Check if new location is an active index
i = 0
for item in new_indxs:
if item not in active_indx:
new_indxs[i] = 'null'
i += 1
#Define which piece ID is in the new_indxs
piece_ID = []
for indx in new_indxs:
if indx == 'null':
piece_ID.append('null')
else:
piece_ID.append(board[indx])
this = []
if piece_ID[0] == 0 and piece_ID[1] == 0:
this.extend(new_indxs[0:2])
elif piece_ID[0] == 0 and piece_ID[1] != 0:
this.append(new_indxs[0])
if piece_ID[2] < 0 and piece_ID[2] != 'null':
this.append(new_indxs[2])
if piece_ID[3] < 0 and piece_ID[3] != 'null':
this.append(new_indxs[3])
return this
elif location >= 9 and location <= 52:
a = location - 1 * 9
c = location - (1 * 9) + 1
d = location - (1 * 9) - 1
new_indxs = [a, c, d]
#Check if new location is an active index
i = 0
for item in new_indxs:
if item not in active_indx:
new_indxs[i] = 'null'
i += 1
#Define which piece ID is in the new_indxs
piece_ID = []
for indx in new_indxs:
if indx == 'null':
piece_ID.append('null')
else:
piece_ID.append(board[indx])
this = []
if piece_ID[0] == 0:
this.append(new_indxs[0])
if piece_ID[1] != 'null' and piece_ID[1] < 0:
this.append(new_indxs[1])
if piece_ID[2] != 'null' and piece_ID[2] < 0:
this.append(new_indxs[2])
return this
else:
this = []
return this
|
e4d60aa8dc63871a3076ef785a7aabab78806d79 | SudeepNadgambe/cv | /Guess_game.py | 812 | 3.96875 | 4 | import random
print("Welcome to the Number Guessing Game\nI am thinking of a number between 1 and 100")
guessed_number=random.randint(1,100)
print(guessed_number)
level=input("Type 'e' for easy level\nType 'h' for hard level\n")
if level == 'e':
chances = 10
elif level == 'h':
chances = 5
else:
print("Invalid input")
end = False
while not end:
print(f"You have {chances} live left")
user_guess=int(input("Make a guess"))
if user_guess==guessed_number:
print("You won")
end = True
else:
chances-=1
if user_guess > guessed_number:
print("Too high")
elif user_guess < guessed_number:
print("Too low")
if chances==0:
print("Your lives ended \nYou lose")
end = True
|
a3863e7f034ce25c3b0803c0230e732508e90d98 | jordwhit3288/PTO-App | /PTO_Calculator_v4.0.py | 10,363 | 3.859375 | 4 | from datetime import date
import datetime
from datetime import datetime
import time
import pandas as pd
import numpy as np
def hours_current_balance(nurse_or_not):
if nurse_or_not == 'yes':
nurse_hours_num = accruing_pto_hours()
nurse_hours_pto = input('Are you going to use PTO?')
if nurse_hours_pto == 'yes':
num_of_hours = input('How many hours?')
num_of_hours_num = float(num_of_hours)
hours_remaining = nurse_hours_num - num_of_hours_num
days_remaining = float(hours_remaining / 12)
days_remaining = float(round(days_remaining, 2))
print('You have ' , hours_remaining , 'hours', ', that is ' , days_remaining ,' days')
if nurse_hours_pto == 'no':
no_pto_days = round(float(nurse_hours_num) / 12,2)
print('You have ' , nurse_hours_num , 'hours' ', that is' , no_pto_days , ' days')
if nurse_or_not == 'no':
hours_balance_num = accruing_pto_hours()
norm_shift_pto = input('Are you going to use PTO?')
if norm_shift_pto == 'yes':
num_of_hours = input('How many hours of PTO?')
pto_hours = float(num_of_hours)
hours_remaining = hours_balance_num - pto_hours
days_remaining = hours_remaining / 8
days_remaining = float(round(days_remaining,2))
print('You have ' , hours_remaining , 'hours' , ', that is ', days_remaining, ' days')
if norm_shift_pto == 'no':
no_pto_days = round(float(hours_balance) / 8,2)
print('You have ' , hours_balance , 'hours' , ', that is ', no_pto_days, ' days')
def hours_total_pto(nurse_or_not):
if nurse_or_not == 'yes':
hours_balance = input('How many hours do you have?')
hours_balance_num = float(hours_balance)
norm_shift_pto = input('Are you going to use PTO?')
if norm_shift_pto == 'yes':
num_of_hours = input('How many hours of PTO?')
pto_hours = float(num_of_hours)
hours_remaining = hours_balance_num - pto_hours
days_remaining = hours_remaining / 12
days_remaining = float(round(days_remaining,2))
print('You have ' , hours_remaining , 'hours' , ', that is ', days_remaining, ' days')
if norm_shift_pto == 'no':
no_pto_days = round(float(hours_balance) / 12,2)
print('You have ' , hours_balance , 'hours' , ', that is ', no_pto_days, ' days')
if nurse_or_not == 'no':
hours_balance = input('How many hours do you have?')
hours_balance_num = float(hours_balance)
norm_shift_pto = input('Are you going to use PTO?')
if norm_shift_pto == 'yes':
num_of_hours = input('How many hours of PTO?')
pto_hours = float(num_of_hours)
hours_remaining = hours_balance_num - pto_hours
days_remaining = hours_remaining / 8
days_remaining = float(round(days_remaining,2))
print('You have ' , hours_remaining , 'hours' , ', that is ', days_remaining, ' days')
if norm_shift_pto == 'no':
no_pto_days = round(float(hours_balance) / 8,2)
print('You have ' , hours_balance , 'hours' , ', that is ', no_pto_days, ' days')
def days_current_balance(nurse_or_not):
if nurse_or_not == 'yes':
nurse_days_num = accruing_pto_days()
nurse_days_pto = input('Are you going to use PTO?')
if nurse_days_pto == 'yes':
num_of_days = input('How many days?')
num_of_days_num = float(num_of_days)
days_remaining = nurse_days_num - num_of_days_num
days_remaining = float(days_remaining)
hours_remaining = float(days_remaining * 12)
hours_remaining = float(round(hours_remaining, 2))
print('You have ' , days_remaining , 'days', ', that is ' , hours_remaining ,' hours')
if nurse_days_pto == 'no':
no_pto_hours = 0
no_pto_hours = float(nurse_days) * 12
print('You have ' , nurse_days_num, ',that is' , no_pto_hours ,' hours')
if nurse_or_not == 'no':
days_balance_num = accruing_pto_days()
norm_shift_pto = input('Are you going to use any PTO?')
if norm_shift_pto == 'yes':
num_of_days = input('How many days?')
pto_days = float(num_of_days)
days_remaining = days_balance_num - pto_days
hours_remaining = days_remaining * 8
hours_remaining = float(round(hours_remaining,2))
print('You have ' , days_remaining , 'days' , ', that is ', hours_remaining, ' hours')
if norm_shift_pto == 'no':
no_pto_hours = float(days_balance) * 8
print('You have ' , days_balance , 'days' , ', that is ', no_pto_hours, ' hours')
def days_total_pto(nurse_or_not):
if nurse_or_not == 'yes':
nurse_days = input('How many days do you have?')
nurse_days_num = float(nurse_days)
nurse_days_pto = input('Are you going to use PTO?')
if nurse_days_pto == 'yes':
num_of_days = input('How many days?')
num_of_days_num = float(num_of_days)
days_remaining = nurse_days_num - num_of_days_num
days_remaining = float(days_remaining)
hours_remaining = float(days_remaining * 12)
hours_remaining = float(round(hours_remaining, 2))
print('You have ' , days_remaining , 'days', ', that is ' , hours_remaining ,' hours')
if nurse_days_pto == 'no':
no_pto_hours = 0
no_pto_hours = float(nurse_days) * 12
print('You have ' , nurse_days_num, ',that is' , no_pto_hours ,' hours')
if nurse_or_not == 'no':
days_balance = input('How many days do you have?')
days_balance_num = float(days_balance)
norm_shift_pto = input('Are you going to use any PTO?')
if norm_shift_pto == 'yes':
num_of_days = input('How many days?')
pto_days = float(num_of_days)
days_remaining = days_balance_num - pto_days
hours_remaining = days_remaining * 8
hours_remaining = float(round(hours_remaining,2))
print('You have ' , days_remaining , 'days' , ', that is ', hours_remaining, ' hours')
if norm_shift_pto == 'no':
no_pto_hours = float(days_balance) * 8
print('You have ' , days_balance , 'days' , ', that is ', no_pto_hours, ' hours')
def accruing_pto_hours():
current_balance = input('How many hours do you currently have?')
current_balance = float(current_balance)
hours_per_check = input('How many hours do you accrue per check?')
hours_per_check = float(hours_per_check)
end_of_year = date(2020, 12, 31)
current_date = date.today()
date_diff = (end_of_year - current_date)
date_diff = date_diff.days
weeks_left = float(round(date_diff / 7))
checks_left = (weeks_left / 2)
remaining_pto_accrual = (checks_left * hours_per_check)
total_remaining_pto = remaining_pto_accrual + current_balance
total_remaining_pto = round(total_remaining_pto,2)
print('Remaining pto hours for the year ' , total_remaining_pto)
return total_remaining_pto
def accruing_pto_days():
current_balance = input('How many days do you currently have?')
current_balance = float(current_balance)
current_balance_to_hours = (current_balance * 8)
hours_per_check = input('How many hours do you accrue per check?')
hours_per_check = float(hours_per_check)
end_of_year = date(2020, 12, 31)
current_date = date.today()
date_diff = (end_of_year - current_date)
date_diff = date_diff.days
weeks_left = float(round(date_diff / 7))
checks_left = (weeks_left / 2)
remaining_pto_accrual = (checks_left * hours_per_check)
remaining_pto_to_days = (remaining_pto_accrual / 8)
total_remaining_pto = remaining_pto_to_days + current_balance
total_remaining_pto = round(total_remaining_pto,2)
print('Remaining pto days for the year ' , total_remaining_pto)
return total_remaining_pto;
##MAIN METHOD##
def main():
hours_or_days_list = ['hours', 'days']
hours_or_days_list = [element.lower() for element in hours_or_days_list]
hours_or_days = input('Do you have your PTO in hours or days?')
while hours_or_days not in hours_or_days_list:
print('---Enter hours or days---')
hours_or_days = input('Do you have your PTO in hours or days?')
know_total_or_balance_list = ['Total PTO', 'Current Balance']
know_total_or_balance_list = [element.lower() for element in know_total_or_balance_list]
know_total_or_balance = input('Do you know your total PTO for the year, or just current balance?')
while know_total_or_balance not in know_total_or_balance_list:
print('---Enter Total PTO or Current Balance---')
know_total_or_balance = input('Do you know your total PTO for the year, or just current balance?')
if know_total_or_balance == know_total_or_balance_list[0]: #total pto
if hours_or_days == hours_or_days_list[0]: #hours
nurse_or_not = input('Do you work 12 hour shifts?')
hours_total_pto(nurse_or_not)
if hours_or_days == hours_or_days_list[1]: #days
nurse_or_not = input('Do you work 12 hour shifts?')
days_total_pto(nurse_or_not)
if know_total_or_balance == know_total_or_balance_list[1]: #current balance
if hours_or_days == hours_or_days_list[0]: #hours
nurse_or_not = input('Do you work 12 hour shifts?')
hours_current_balance(nurse_or_not)
if hours_or_days == hours_or_days_list[1]: #days
nurse_or_not = input('Do you work 12 hour shifts?')
days_current_balance(nurse_or_not)
print()
input('Press X to Exit or Hit Enter for Another Simulation')
print()
print()
print('Another PTO Simulation Will Begin Now..')
print()
return;
#Calling main method
while True:
main()
|
4e86f5a5a42e92bae21d418e4e7e29718ca47ec9 | ncrafa/infosatc-lp-avaliativo-03 | /exercicio 3.py | 327 | 3.921875 | 4 | numero=int(input("Insira um numero de 1 a 12: "))-1
meses=["janeiro","fevereiro","março","abril","maio","junho","julho","agosto","setembro","outubro","novembro","dezembro"]
for x in range(1,12):
if x==numero:
print(" mês de: ",meses[numero])
if x != numero :
print(" mês não encontrado") |
58694ea2088a17fc1bff58cc191519bb5277daf3 | ryan-ghosh/Python-Projects | /ESC180_Labs/LAB!.py | 866 | 3.625 | 4 | def find_euclidean_distance(x1, y1, x2, y2):
"""
(float,float,float,float) -> float
"""
def is_cow_within_bounds(cow_position, boundary_points):
"""
Your docstring here
"""
def find_cow_distance_to_boundary(cow_position, boundary_point):
"""
Your docstring here
"""
def find_time_to_escape(cow_speed, cow_distance):
"""
Your docstring here
"""
def report_cow_status(cow_position1, cow_position2, delta_t, boundary_points):
"""
Your docstring here
"""
if __name__ == '__main__':
# Test your code by running your functions here, and printing the
# results to the terminal.
# This code will not be marked
print('Testing functions...')
# test_distance = find_euclidian_distance(3.0, 3.0, 2.0, 5.0)
# print(test_distance)
# test_distance should be 2.24
|
eb63a6c9cc749b10b0d18785e756048bee6b0dde | ryan-ghosh/Python-Projects | /scheduler.py | 1,465 | 3.6875 | 4 |
class Node:
def __init__(self, date:int, schedule:dict):
self.date = date
self.schedule = schedule
def add_task(self, time:int, task:str):
self.schedule[time] = task
def print_task(self, time:int):
print(self.schedule[time])
def print_schedule(self):
for i in self.schedule:
print("{}:".format(i), self.schedule[i])
class Queue:
def __init__(self, list: list, capacity: int):
self.list = list
self.capacity = capacity
def isEmpty(self):
if self.list == []:
return True
return False
def isFull(self):
length = len(self.list)
if length == self.capacity:
return True
else:
return False
def enqueue(self, data):
if self.isFull():
print("Max capacity reached")
else:
self.list.append(data)
def dequeue(self):
if self.isEmpty():
print("Empty")
else:
self.list.pop(0)
def print_Nodes(self):
for i in self.list:
i.print_schedule()
## initializing schedule
sunday = Node(26, {})
sunday.add_task(9, "wake up")
sunday.add_task(9.30, "eat breakfast")
sunday.add_task(10.30, "exercise")
sunday.add_task(13, "scholarships, Corona funding, Wealthsimple")
sunday.print_schedule()
## initialize Queue
days = []
|
944dbd5c7aa1cb0f5543c61e7a44dd2507eb8274 | Macro1989/cp1404practicals | /prac_02/randoms.py | 652 | 3.953125 | 4 | import random
print(random.randint(5, 20)) # line 1
print(random.randrange(3, 10, 2)) # line 2
print(random.uniform(2.5, 5.5)) # line 3
#What did you see on line 1? 13
#What was the smallest number you could have seen, what was the largest? 5 and 20
#What did you see on line 2? 3
#What was the smallest number you could have seen, what was the largest? 3 and 9
#Could line 2 have produced a 4? no
#What did you see on line 3? 4.582393345338769
#What was the smallest number you could have seen, what was the largest? 2.5 and 5.5
#Write code, not a comment, to produce a random number between 1 and 100 inclusive.
print(random.randint(1, 100)) |
26b320e3ef9c264c91eceb6661117ec9356d117a | JoCGM09/AlgorithmsAndDataStructuresPython | /Algorithms/Search/binary_Search.py | 1,484 | 4.03125 | 4 | """
- Search algorithm who search a value in a given list by looking for the middle of it. If we get a match return the index, else if we do not get a match check whether the element is less or greater than the middle element. If is greater pick the elements on the right and start again, if is less pick the left.
- Is applied on sorted lists with a lot of elements.
- It has a time comlexity of O(logn).
- It is very simple to implementate.
"""
# min and max -> Pointers at the beginning and the end of the list zone to check
# step -> Number of steps to catch the target
# middle -> Middle index at the list
def binary_search(list, target):
min = 0
max = len(list) - 1
step = 0
while min <= max:
middle = (min + max) // 2
if list[middle] == target:
step+=1
return middle, step
elif list[middle] < target:
step+=1
min = middle + 1
else:
step+=1
max = middle - 1
return -1, 0
def validate(index, step):
if index != -1:
print(f'Target found at index {index}, number of steps for search: {step}')
else:
print('Target not found')
############ Test ############
numbers = [2,4,6,7,8,13,16]
numbers2 = [3,4,6,7,8,11]
result1, index1 = binary_search(numbers,7)
result2, index2 = binary_search(numbers, 4)
result3, index3 = binary_search(numbers2, 8)
result4, index4 = binary_search(numbers2, 5)
validate(result1, index1)
validate(result2, index2)
validate(result3, index3)
validate(result4, index4) |
5e0fc9b783390cb732bee5f5cba05f87a75591eb | julianandrews/adventofcode | /2019/python/utils/pq.py | 1,325 | 3.796875 | 4 | import heapq
class UpdateableQueue:
def __init__(self):
self.count = 0
self.values = []
self.entries = {}
def push(self, value, priority):
"""Add a new value or update the priority of an existing value."""
if value in self.entries:
self.remove(value)
entry = self.QueueEntry(value, priority, self.count)
self.entries[value] = entry
self.count += 1
heapq.heappush(self.values, entry)
def remove(self, value):
"""Remove a value from the queue."""
entry = self.entries.pop(value)
entry.removed = True
def pop(self):
"""Remove and return the lowest priority value."""
while self.values:
entry = heapq.heappop(self.values)
if not entry.removed:
del self.entries[entry.value]
return entry.value
raise KeyError("Pop from empty queue")
def __len__(self):
return len(self.entries)
class QueueEntry:
def __init__(self, value, priority, counter):
self.value = value
self.priority = priority
self.counter = counter
self.removed = False
def __lt__(self, other):
return (self.priority, self.counter) < (other.priority, other.counter)
|
d21fe1c61458bf07a2f42d8236972c5073bc4286 | julianandrews/adventofcode | /2015/python/day13.py | 1,050 | 3.5 | 4 | import collections
import fileinput
import itertools
def happy_sum(people, happy_map):
neighbors = itertools.cycle(people)
next(neighbors)
return sum(
happy_map[a][b] + happy_map[b][a]
for a, b in zip(people, neighbors)
)
def part1(happy_map):
return max(
happy_sum(people, happy_map)
for people in itertools.permutations(happy_map.keys())
)
def part2(happy_map):
happy_map["Me"] = {}
for person in happy_map.keys():
happy_map["Me"][person] = 0
happy_map[person]["Me"] = 0
return max(
happy_sum(people, happy_map)
for people in itertools.permutations(happy_map.keys())
)
if __name__ == "__main__":
lines = [line.strip() for line in fileinput.input()]
happy_map = collections.defaultdict(dict)
for line in lines:
words = line[:-1].split()
happy_map[words[0]][words[-1]] = (1 if words[2] == "gain" else -1) * int(words[3])
print("Part 1: %s" % part1(happy_map))
print("Part 2: %s" % part2(happy_map))
|
190b8e36d82e4d4e8b6f90f3f31b44981f1906f2 | imudiand/recipes | /Python/decorators/decorators.py | 2,107 | 3.9375 | 4 | from functools import wraps
# Why use functools.wraps ??
# When you print get_text.__name__ doesnt return get_text
# without using wraps; you'l see that the name is overridden
# to the wrapper functions name - func_wrapper.
# Hence, use this @wraps decorator on the wrapper_function
# and pass the func as an argument to this decorator so that
# it sets these attributes correctly. It helps a lot in debugging
# when you want to know what the name of the function is.
# With using @wraps; the name is correctly set to "get_text"
# Simple decorator example
def tags_decor(func):
@wraps(func)
def wrapper(name):
# wrapper func can do verifications on arguments before calling func(name)
return "<p>%s</p>" % (func(name))
# wrapper func can do verifications/operations on the result after calling func(name)
return wrapper
@tags_decor
def get_text(name):
return "Hello %s" % (name)
# Multiple Decorators example
def p_tags_decor(func):
@wraps(func)
def wrapper(name):
return "<p>%s</p>" % (func(name))
return wrapper
def div_tags_decor(func):
@wraps(func)
def wrapper(name):
return "<div>%s</div>" % (func(name))
return wrapper
def h1_tags_decor(func):
@wraps(func)
def wrapper(name):
return "<h1>%s</h1>" % (func(name))
return wrapper
@p_tags_decor
@div_tags_decor
@h1_tags_decor
def get_text2(name):
return "Hello %s" % (name)
# Passing Arguments to Decorators
def tags(tagname):
def tags_decor(func):
@wraps(func)
def wrapper(name):
# wrapper func can do verifications on arguments before calling func(name)
return "<{0}>{1}</{0}>".format(tagname, func(name))
# wrapper func can do verifications/operations on the result after calling func(name)
return wrapper
return tags_decor
@tags("p")
@tags("div")
@tags("h1")
def get_text3(name):
return "Hello %s" % (name)
# testing code here
def main():
#import pdb; pdb.set_trace()
# print get_text.__name__ return get_text if functools.wraps is used else returns wrapper
print get_text("Harshit")
print get_text2("Hemant")
print get_text3("Hemant")
if __name__ == "__main__":
main()
|
6e137cdf18daa271370c51ee89fb3f3d05e1cbda | imudiand/recipes | /Python/generators/non-generator_prime_nums.py | 666 | 3.96875 | 4 | import math
# Non-Generator Implementation - Get prime Numbers
def get_primes(input_list):
prime_numbers_list = []
for item in input_list:
if is_prime(item):
prime_numbers_list.append(item)
return prime_numbers_list
def get_primes2(input_list):
return [ item for item in input_list if is_prime(item) ]
def is_prime(number):
if number > 1:
if number == 2:
return True
if number % 2 == 0:
return False
for current in range(3, int(math.sqrt(number) + 1), 2):
if number % current == 0:
return False
return True
return False
def main():
print get_primes(range(100))
print get_primes2(range(100))
if __name__ == "__main__":
main() |
a8f29d0c4f9adb25af4ff18d596b2f5301801bdc | imudiand/recipes | /Python/tuts/recursion/recursive_sum.py | 312 | 3.8125 | 4 |
def r_sum(num_list):
sum = 0
for item in num_list:
if type(item) == type([]):
sum += r_sum(item)
else:
sum += item
return sum
def main():
list1 = [3, 5, 9, 20, 100]
print r_sum(list1)
list2 = [3, [4, 2, 4], 2, [3, 4, [5, 3], 12], 2, 9]
print r_sum(list2)
if __name__ == "__main__":
main()
|
52c361e776fc68c64270961259066b5e6eac6364 | rootwiz/colorful_hexagon | /Hexagon.py | 1,683 | 3.625 | 4 | # screen size
S_HIGHT = 500
S_WIDTH = 500
# 正六角形クラス
class Hexagon:
'''
----
/ \
\ /
----
'''
size = 40
def __init__(self, x, y, color, wall):
self.width = Hexagon.size
self.height = Hexagon.size * 3 // 4
pos_x = self.size // 3
pos_y = S_HIGHT * 2 // 3
tmp_x = pos_x + self.width * 2 // 3 * x
tmp_y = pos_y - self.height * y + self.height // 2 * x
vertexes_offset = [[0, 0], [self.width//3, 0], [self.width*2//3, -self.height//2], [self.width//3, -self.height], [0, -self.height], [-self.width//3, -self.height//2]]
self.vertexes = [None]*6
for i in range(6):
self.vertexes[i] = [tmp_x+vertexes_offset[i][0], tmp_y+vertexes_offset[i][1]]
self.x = x
self.y = y
self.color = color
self.wall = wall
self.active = True
self.point = 1
def find_coordinates(self, c_x, c_y, v1, v2):
# y = ax + b ; x = (y - b) / a
a = (v1[1] - v2[1]) / (v1[0] - v2[0])
b = v1[1] - (a * v1[0])
return [(c_y - b) / a, c_y]
def is_in_area(self, c_x, c_y):
d_y = self.vertexes[0][1] # yの最大値（下）
u_y = self.vertexes[3][1] # yの最小値（上）
l_x = self.vertexes[5][0] # xの最小値（左）
r_x = self.vertexes[2][0] # xの最大値（右）
#print(d_y, u_y, l_x, r_x)
if c_y > d_y or c_y < u_y:
return False
elif c_x > r_x or c_x < l_x:
return False
else:
pass
# 正六角形内かを判定する処理を記述予定
return True
|
ab158012359b50275f2adabb082830fb37bfd103 | joeycarter/atlas-plot-utils | /examples/random_hist.py | 1,151 | 3.5 | 4 | #!/usr/bin/env python
"""
Random Histogram
================
This module plots a random histogram using the ATLAS Style.
.. literalinclude:: ../examples/random_hist.py
:lines: 12-
"""
from __future__ import absolute_import, division, print_function
import ROOT as root
from atlasplots import atlas_style as astyle
def main():
# Set the ATLAS Style
astyle.SetAtlasStyle()
# Construct the canvas
c1 = root.TCanvas("c1", "The FillRandom example", 0, 0, 800, 600)
# Define a distribution
form1 = root.TFormula("form1", "abs(sin(x)/x)")
sqroot = root.TF1("sqroot", "x*gaus(0) + [3]*form1", 0, 10)
sqroot.SetParameters(10, 4, 1, 20)
# Randomly fill the histrogram according to the above distribution
hist = root.TH1F("hist", "Test random numbers", 100, 0, 10)
hist.FillRandom("sqroot", 10000)
hist.Draw()
# Set axis titles
hist.GetXaxis().SetTitle("x axis")
hist.GetYaxis().SetTitle("y axis")
# Add the ATLAS Label
astyle.ATLASLabel(0.2, 0.87, "Internal")
# Save the plot as a PDF
c1.Update()
c1.Print("random_hist.pdf")
if __name__ == '__main__':
main()
|
544d131948f0580166fee32c23c6c936795fb419 | Kelsey2018/Algorithm_2020HIT | /algorithm/quickSort/main.py | 3,207 | 3.640625 | 4 | # -*- coding: utf-8 -*-
# @Author: Xiang xi
# @Date: 2020-05-05 10:32:35
import random
import copy
import random
import time
import math
def quickSort(A,p,r):
if p < r:
q = rand_partition(A,p,r)
quickSort(A,p,q-1)
quickSort(A,q+1,r)
return A
def swap(A,i,j):
temp = A[i]
A[i] = A[j]
A[j] = temp
return A[i],A[j]
def rand_partition(A,p,r):
# key = A[p] #基准元素
# while p < r:
# while p<r and A[r]>=key:
# r = r - 1
# A[p] = A[r]
# while p<r and A[p]<=key:
# p = p +1
# A[r] = A[p]
# A[p] = key
# return p
i = random.randint(p,r)
A[i], A[r] = A[r], A[i]
key = A[r]
i = p - 1
for j in range(p,r):
if A[j] <= key:
i = i + 1
A[i], A[j] = A[j], A[i]
A[i+1], A[r] = A[r], A[i+1]
return i+1
def generateA(length):
random_list = []
for i in range(length):
random_list.append(random.randint(1,100))
return random_list
def generateNewA(length,i):
dup_num = int(length * 10 * i * 0.01) #第i个数据集重复元素的个数
random_dup_list = []
if dup_num > 0:
dup_number = random.randint(1,math.pow(10,6))
print("重复元素为：",dup_number)
print("重复次数：",dup_num)
for i in range(dup_num):
random_dup_list.append(dup_number)
while len(random_dup_list) <= length:
random_dup_list.append(random.randint(1, math.pow(10,6)))
# random.shuffle(random_dup_list[1:])
print(random_dup_list)
return random_dup_list
else:
while len(random_dup_list) <= length:
random_dup_list.append(random.randint(1, math.pow(10,6)))
return random_dup_list
def three_partition(A,p,r):
if (p >= r):
return
pivot = A[p]
gt = r
lt = p
i = p + 1
while i <= gt:
if A[i] > pivot:
A[i],A[gt] = swap(A,i,gt)
gt = gt - 1
elif A[i] < pivot:
# A[i], A[lt] = A[lt], A[i]
A[i], A[lt] = swap(A,i,lt)
lt = lt + 1
i = i + 1
else:
i = i + 1
three_partition(A,p,lt-1)
three_partition(A,gt+1,r)
return A
if __name__ == '__main__':
start = time.time()
#=================单个数据集===================
# A = generateA(length = 20)
# print("排序前：",A)
# p = 0
# r = len(A) - 1
# print("排序后：",quickSort(A,p,r))
# =================单个数据集===================
# =================11个数据集===================
length = math.pow(10,6)
# length = 5000
for i in range(7,11):
start = time.time()
A = generateNewA(length,i)
# print("第{}个数据集------排序前：".format(i), A)
p = 0
r = len(A) - 1
print("第{}个数据集------排序后：".format(i), three_partition(A,p,r))
end = time.time()
print("Running Time(ms):{:.4f}".format((end - start) * 1000))
# =================11个数据集===================
# end = time.time()
# print("Running Time(ms):{:.4f}".format((end - start) * 1000))
|
025ec86f422233e500aeaf2b9c6f6432db4585b4 | ssanusi/Data-Structure | /Stack/Python/Stack.py | 574 | 3.90625 | 4 |
class Stack(object):
def __init__(self):
self.data = []
self.count = 0
def push(self, item):
self.data.append(item)
self.count += 1
def pop(self):
if self.count == 0:
return "Stack is Empty"
data = self.data[-1]
del self.data[-1]
self.count -= 1
return data
def peek(self):
if self.count == 0:
return "Stack is Empty"
return self.data[-1]
def isEmpty(self):
return self.count == 0
def size(self):
return self.count
|
933e0974e486a9710bb592955f206300485b798f | CodeupClassroom/bayes-python-exercises | /pandas_exercises.py | 5,254 | 3.75 | 4 | import numpy as np
import pandas as pd
from pydataset import data
## Exercise 1
# On average, which manufacturer has the best miles per gallon?
# How many different manufacturers are there?
# How many different models are there?
# Do automatic or manual cars have better miles per gallon?
mpg = data('mpg')
mpg["mpg"] = (mpg.hwy + mpg.cty) / 2
automatic = mpg[mpg.trans.str.contains("auto")]
manual = mpg[mpg.trans.str.contains("manual")]
auto_avg = automatic.mpg.mean()
manual_avg = manual.mpg.mean()
print("automatic", auto_avg)
print("manual:", manual_avg)
# On average, which manufacturer has the best miles per gallon?
city_and_hwy = mpg.groupby("manufacturer").hwy.agg("mean") + mpg.groupby("manufacturer").cty.agg("mean")
average_mpg = city_and_hwy / 2
best_mpg_manufacturer = average_mpg.idxmax()
best_mpg_manufacturer
# How many different manufacturers are there?
number_of_different_manufacturers = len(mpg.manufacturer.unique())
number_of_different_manufacturers
# How many di fferent models are there?
number_of_different_models = mpg.model.nunique()
number_of_different_models
# Do automatic or manual cars have better miles per gallon?
mpg.head()
mpg["transmission"] = mpg.trans.str.partition("(")[0]
mpg = mpg.drop(columns = ["trans"])
mpg["average_mpg"] = (mpg.cty + mpg.hwy) / 2
mpg_and_transmission_type = mpg[["average_mpg", "transmission"]]
mpg_and_transmission_type.head()
mpg_and_transmission_type.groupby("transmission").mean()
best_mpg_transmission_type = mpg_and_transmission_type.groupby("transmission").mean().idxmax()
best_mpg_transmission_type
# another approach to the above problem without grouping by
# mpg["mpg"] = (mpg.hwy + mpg.cty) / 2
# automatic = mpg[mpg.trans.str.contains("auto")]
# manual = mpg[mpg.trans.str.contains("manual")]
# auto_avg = automatic.mpg.mean()
# manual_avg = manual.mpg.mean()
## Exercise 2
# Copy the users and roles dataframes from the examples above.
# What do you think a right join would look like?
# An outer join?
# What happens if you drop the foreign keys from the dataframes and try to merge them?
users = pd.DataFrame({
'id': [1, 2, 3, 4, 5, 6],
'name': ['bob', 'joe', 'sally', 'adam', 'jane', 'mike'],
'role_id': [1, 2, 3, 3, np.nan, np.nan]
})
roles = pd.DataFrame({
'id': [1, 2, 3, 4],
'name': ['admin', 'author', 'reviewer', 'commenter']
})
right_join = pd.merge(users, roles, left_on="role_id", right_on="id", how="right")
right_join
outer_join = pd.merge(users, roles, left_on="role_id", right_on="id", how="outer")
outer_join
## Exercise 3
# Create a function named get_db_url. It should accept a username, hostname, password, and database name and return a url formatted like in the examples in this lesson.
def get_db_url(user, host, password, database_name):
url = f'mysql+pymysql://{user}:{password}@{host}/{database_name}'
return url
# Use your function to obtain a connection to the employees database.
from env import host, user, password
employees_db_url = get_db_url(user, host, password, "employees")
employees_db_url
query = "select * from employees limit 10"
pd.read_sql(query, employees_db_url)
# Once you have successfully run a query:
# Intentionally make a typo in the database url. What kind of error message do you see?
# Intentionally make an error in your SQL query. What does the error message look like?
# Read the employees and titles tables into two separate dataframes
query = "SELECT * from employees"
employees = pd.read_sql(query, employees_db_url)
query = "SELECT * FROM titles"
titles = pd.read_sql(query, employees_db_url)
# Visualize the number of employees with each title.
unique_titles = titles.groupby("title").count()
unique_titles.rename(columns={"emp_no": "number_with_title"}, inplace=True)
unique_titles = unique_titles.drop(columns=["from_date", "to_date"])
unique_titles = unique_titles.reset_index()
unique_titles.plot(x ='title', y='number_with_title', kind = 'bar')
# Join the employees and titles dataframes together.
employee_titles = pd.merge(employees, titles, how="inner", left_on="emp_no", right_on="emp_no")
employee_titles.head()
# Visualize how frequently employees change titles.
df = employee_titles.groupby("emp_no").count()
df.head()
df = df.reset_index()
df = df.rename(columns={"title":"number_of_titles"})
df = df[["number_of_titles", "emp_no"]]
df.head()
df = df.rename(columns={"emp_no":"number_of_employees"})
title_counts = df.groupby("number_of_titles").count()
title_counts = title_counts.reset_index()
title_counts
df.plot(x ='number_of_titles', y='number_of_employees', kind = 'bar')
# For each title, find the hire date of the employee that was hired most recently with that title.
employee_titles.groupby("title").hire_date.max()
# create a cross tabulation of the number of titles by department.
# (Hint: this will involve a combination of SQL and python/pandas code)
query = """
select *
from departments
join dept_emp using(dept_no)
join titles using(emp_no)
where titles.to_date > now()
and dept_emp.to_date > now()
"""
df = pd.read_sql(query, employees_db_url)
df.head()
# number of titles per department
number_of_titles_per_dept = pd.crosstab(df.title, df.dept_name)
number_of_titles_per_dept |
0fbfa0dc00e79f42281e3829b339f181bc801cd1 | jmcq89/code | /ProjectEuler/Project Euler 12.py | 506 | 3.796875 | 4 | from math import sqrt
def factors(n):
fact=[1,n]
check=2
rootn=sqrt(n)
while check<rootn:
if n%check==0:
fact.append(check)
fact.append(n/check)
check+=1
if rootn==check:
fact.append(check)
fact.sort()
return fact
def triangleFactors(max):
n=6
triangle=21
while len(factors(triangle))<max+1:
triangle=(n*(n+1))/2
n+=1
if len(factors(triangle))>max:
print triangle
triangleFactors(500)
|
799e4ea0240a9b0a49f66d7cd959dc1b4132a221 | jmcq89/code | /ProjectEuler/Project Euler 67.py | 607 | 3.5 | 4 | def _reduce_triangle(to_reduce):
last_row=to_reduce[-1]
for index in xrange(len(to_reduce)-1):
to_reduce[-2][index]+=max(last_row[index:index+2])
del to_reduce[-1]
def find_max_sum(triangle):
while len(triangle)>1:
_reduce_triangle(triangle)
return triangle[0][0]
def _parse_triangle_from_file(data_file):
triangle=[]
with open(data_file,'r')as triangle_file:
for line in triangle_file:
triangle.append([int(x) for x in line.split()])
return triangle
triangle=_parse_triangle_from_file('triangle_67.txt')
print find_max_sum(triangle)
|
448e960d5310146600fcd81d8210ba68c5071fa1 | dknitk/programs | /python/projects/KWPythonSample/KWHelloWord.py | 404 | 3.890625 | 4 | num1 = input("Enter the first Number:")
num2 = input("Enter the first Number:")
result1 = int(num1) + int(num2)
result2 = float(num1) + float(num2)
print(result1)
print(result2)
cordinates = (4, 5)
print(cordinates[0])
print(cordinates[1])
def sayHi():
print("Hello")
sayHi()
# Function and class declaration
def addition(a, b):
return a + b
result = addition(10, 30)
print(result)
|
dc8cd70b3df76eec86889021b5d8ca1bf329b79f | webclinic017/machinelearning | /Artificial_Intelligence_with_Python/legacy/chap_6.py | 564 | 3.53125 | 4 | import sys
def logic_programming(option=1):
if option == 1:
''' Matching mathematical expressions '''
print("Example: I say Hello world")
pass
elif option == 2:
''' Validating primes '''
pass
elif option == 3:
''' Parsing a family tree '''
pass
elif option == 4:
''' Analyzing geography '''
pass
elif option == 5:
''' Building a puzzle solver '''
pass
pass
def main():
logic_programming(int(sys.argv[1]))
if __name__ == "__main__":
main() |
1b2f0f743c907d65b09cebaa80561cb3fb920ef3 | pinruic/CSC361 | /lab3/smtpclient.py | 1,939 | 3.609375 | 4 | from socket import *
msg = "\r\n I love computer networks!"
endmsg = "\r\n.\r\n"
# Choose a mail server (e.g. Google mail server) and call it mailserver
mailserver = "smtp.uvic.ca"
portnumber = 25
# Create socket called clientSocket and establish a TCP connection with mailserver
clientSocket = socket(AF_INET, SOCK_STREAM)
clientSocket.connect((mailserver, portnumber))
recv = clientSocket.recv(1024).decode()
print(recv)
if recv[:3] != '220':
print('220 reply not received from server.')
# Send HELO command and print server response.
heloCommand = 'HELO Alice\r\n'
clientSocket.send(heloCommand.encode())
recv1 = clientSocket.recv(1024).decode()
print(recv1)
if recv1[:3] != '250':
print('250 reply not received from server.')
# Send MAIL FROM command and print server response.
command1 = "MAIL FROM: <pinruic@uvic.ca>\r\n"
clientSocket.send(command1.encode())
recv2 = clientSocket.recv(1024).decode()
print(recv2)
if recv2[:3] != "250":
print("250 reply not received from server.")
# Send RCPT TO command and print server response.
command2 = "RCPT TO: <chenpinruay@gmail.com>\r\n"
clientSocket.send(command2.encode())
recv3 = clientSocket.recv(1024).decode()
print(recv3)
if recv3[:3] != "250":
print("250 reply not received from server.")
# Send DATA command and print server response.
command3 = "DATA\r\n"
clientSocket.send(command3.encode())
recv4 = clientSocket.recv(1024).decode()
print(recv4)
if recv4[:3] != "354":
print("354 reply not received from server.")
# Send message data.
clientSocket.send(msg)
# Message ends with a single period.
clientSocket.send(endmsg)
recv5 = clientSocket.recv(1024)
print(recv5)
if recv5[:3] != "250":
print("250 reply not received from server.")
# Send QUIT command and get server response.
command4 = "QUIT\r\n"
clientSocket.send(command4.encode())
recv6 = clientSocket.recv(1024).decode()
print(recv6)
if recv6[:3] != '221':
print('221 reply not received from server.')
|
840b38a9c037abbe972948fe8facd628b05c1617 | nishthabhatia/bmi210_final_project | /app.py | 7,019 | 3.6875 | 4 | from owlready2 import *
#Load the ontology and present the introduction.
def setup():
#Load the existing ontology
onto = get_ontology('ProjectOntology.owl')
onto.load()
convo_running = True
#TO DO --> ADD COLOR!
header = """
███████╗██╗████████╗███╗ ██╗███████╗███████╗███████╗
██╔════╝██║╚══██╔══╝████╗ ██║██╔════╝██╔════╝██╔════╝
█████╗ ██║ ██║ ██╔██╗ ██║█████╗ ███████╗███████╗
██╔══╝ ██║ ██║ ██║╚██╗██║██╔══╝ ╚════██║╚════██║
██║ ██║ ██║ ██║ ╚████║███████╗███████║███████║
╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═══╝╚══════╝╚══════╝╚══════╝
█████╗ ██████╗ ██╗ ██╗██╗███████╗ ██████╗ ██████╗
██╔══██╗██╔══██╗██║ ██║██║██╔════╝██╔═══██╗██╔══██╗
███████║██║ ██║██║ ██║██║███████╗██║ ██║██████╔╝
██╔══██║██║ ██║╚██╗ ██╔╝██║╚════██║██║ ██║██╔══██╗
██║ ██║██████╔╝ ╚████╔╝ ██║███████║╚██████╔╝██║ ██║
╚═╝ ╚═╝╚═════╝ ╚═══╝ ╚═╝╚══════╝ ╚═════╝ ╚═╝ ╚═╝
"""
print(header)
print ("Welcome! We are so excited to have you here. Today, we will discuss your goals and health, and use them to determine a set of physical fitness activities that may be good for you.\n")
start_convo(onto)
#return the individual, based on user input
def returnGoalFromNumber(number):
number = int(number)
if (number == 1):
return "toImproveHeart"
elif (number == 2):
return "toGetStronger"
elif (number == 3):
return "toImproveFlexibility"
elif (number == 4):
return "toBuildEndurance"
elif (number == 5):
return "toLoseWeight"
elif (number == 6):
return "toStrengthenMuscles"
else: return ""
#return a list of health data information, based on user input
def returnHealthDataFromNums(nums):
health_data = []
for num in nums:
num = int(num)
if (num == 1):
health_data.append("pregnant")
elif (num == 2):
health_data.append("soreMuscles")
elif (num == 3):
health_data.append("asthma")
elif (num == 4):
health_data.append("backPain")
elif (num == 5):
health_data.append("overFifty")
elif (num == 6):
health_data.append("injuredLimbs")
elif(num == 7):
health_data.append('heartDisease')
return health_data
# def iterateThroughProperties(individual):
# for prop in individual.get_properties():
# for value in prop[individual]:
# print (".%s == %s" % (prop.python_name, value))
# def printInstancesOfClass(class_name):
# print ('Instances of ' + class_name +':')
# for i in ontology.class_name.instances():
# print(i)
#find the exercises a user should not do, based on their health data
def findNonRecommendedExercises(ontology, health_data):
nonRecExercises = []
exercisesOfInterest = ontology.search(hasHarmfulHealthData="*")
for ex in exercisesOfInterest:
if len(set(ex.hasHarmfulHealthData).intersection(set(health_data))) > 0:
nonRecExercises.append(ex.name)
return nonRecExercises
def findRecommendedExercises(ontology, goal, nr_ex):
recExercises = []
exercisesOfInterest = ontology.search(hasEffectOfExercise="*")
for ex in exercisesOfInterest:
sameIndividuals = ex.hasEffectOfExercise[0].equivalent_to
if sameIndividuals[0] == goal[0]:
if ex.name not in nr_ex:
recExercises.append(ex.name)
return recExercises
def start_convo(ontology):
convo_running = True
# for thing in ontology.individuals():
# print (thing)
while (convo_running):
#1. Create a new Person instance
name = input("First things, first. What is your name? \n")
new_person = ontology.Person(name)
print ("\n")
#2. Determine the Goal instance that applies to them -->
#you can create a new goal.
#and then it must be set equivalent to an existing effect of exercise.
goal_num = input("Awesome! Hi " + name + """! Which of the following goals do you align with most?
1: Improve Heart
2: Get Stronger
3: Improve Flexibility
4: Build Endurance
5: Lose Weight
6: Strengthen Muscles \n
Please type the number corresponding to your selected goal: \n""")
print("\n")
goal = returnGoalFromNumber(goal_num)
#3. Use hasGoal property to link Person to Goal
new_person.hasGoal = [ontology.Goal(goal)]
# print('HAS GOAL')
# print(new_person.hasGoal)
#4. Ask for health data. This is important for linking to exercise health data.
health_data_nums = input("""Great! Just a few more questions. Do any of the following health conditions apply to you?
1: Pregnant
2: Sore Muscles
3: Asthma
4: Back Pain
5: Over 50 Years Old
6: Injured Limbs
7: Heart Disease \n
Please type a list of numbers corresponding to conditions that apply to you, separated by a single space. If none apply, please type 0: \n""")
health_data_nums = health_data_nums.split()
health_data_list = returnHealthDataFromNums(health_data_nums)
i = 0
hasHealthDataArr = []
for i in range(len(health_data_list)):
# print (i)
health_data = health_data_list[i]
hasHealthDataArr.append(ontology.HealthData(health_data))
new_person.hasHealthData = hasHealthDataArr
nr_exercises = findNonRecommendedExercises(ontology, hasHealthDataArr)
r_exercises = findRecommendedExercises(ontology, new_person.hasGoal, nr_exercises)
print ('\n')
if (len(r_exercises)>0):
print ("Thank you! These are the exercises that we recommend for you:")
else: print("Currently, we do not have any recommended exercises for you!")
for ex in r_exercises:
ex = ''.join(' ' + char if char.isupper() else char.strip() for char in ex).strip()
print (ex.lower())
print('\n')
if (len(nr_exercises)>0):
print ("...and these are the exercises that we don't recommend for you:")
for ex in nr_exercises:
ex = ''.join(' ' + char if char.isupper() else char.strip() for char in ex).strip()
print (ex.lower())
else: print ("Currently, we do not have any non-recommended exercises for you!")
print('\n')
print('Thanks for using the Fitness Advisor! Good luck with your health journey. \n')
convo_running = False
setup()
|
7ffcf00691eee8175109679f13106cc2f9e72497 | rafajob/Python-beginner | /ordenada.py | 324 | 3.671875 | 4 | def ordenada(lista):
fim = len(lista)
for i in range(fim):
pos = i
if len(lista) != 1:
for j in range(i + 1, fim):
if lista[j] < lista[pos]:
return False
else:
return True
else:
return True
|
5409cb2ddb690e2bdc967850ca25651155358714 | rafajob/Python-beginner | /contanumero.py | 173 | 3.875 | 4 | numero = int(input("Digite o valor de n: "))
soma = 0
while (numero != 0) :
resto = numero % 10
soma = soma + resto
numero = numero // 10
print(soma)
|
8be521fba75c13d82fe0e3715c432ea3d0402293 | rafajob/Python-beginner | /adjacente.py | 282 | 4.09375 | 4 | numero = float(input("Digite um numero: "))
teste = 1
teste2 = 0
while (teste != teste2) and (numero != 0) :
teste = numero % 10
numero = numero // 10
teste2 = numero % 10
if teste == teste2:
print("Adjacente")
else:
print("Não Adjacente") |
255e13684231f6258958b6da62ff4a8548a13ac0 | Olumuyiwa19/aws_restart | /Moisture_Estimator_Script.py | 1,665 | 3.78125 | 4 | #This code estimate the
Yes = True
while Yes:
Grain_Type = str(input("Enter the type of your grain: "))
Wg = float(input("What is the weight of your grain? "))
MC_Wg = int(input("what is the moisture content of your wet grain? "))
MC_Dg = int(input("what is your desired final moisture content for the grain? "))
#Determine the standard measuring system in Bushel
Initial_Bu = Wg / 56
print(f"The weight of your grain in Bushel is: {Initial_Bu:1.2f}")
MC_Shrinkage_Dict = {16.0:1.190, 15.5:1.183, 15.0:1.176, 14.5:1.170, 14.0:1.163, 13.5:1.156, 13.0:1.149, 12.5:1.143, 12.0:1.136}
#Determine mositure points which is same as moisture difference
moisture_pt = MC_Wg - MC_Dg
#Determine the percentage shrinkage and amount of shrinkage
shrinkage_percent = moisture_pt * MC_Shrinkage_Dict[13.0]
print(str(shrinkage_percent) + "%")
shrinkage_decimal = shrinkage_percent / 100
#Determine the amount of shrinkages in the grain after drying
shrinkage_Amt = Initial_Bu * shrinkage_decimal
print("The amount of shrinkages in Bushel is: " + str(f"{shrinkage_Amt: 1.2f}"))
#Determine the final weight of grain after drying
Final_Bu = Initial_Bu - shrinkage_Amt
print("The weight of your grain in Bushel after drying to 13% moisture content is: " + str(f"{Final_Bu: 1.2f}"))
#Determine the final price of grain at $3.50/Bushel
Final_Price = Final_Bu * 3.5
print("The price for your grain is: " + "$" + str(f"{Final_Price:1.2f}"))
Yes = input("Do you want to carryout another grain moisture estimate? yes or no: ").lower()
if Yes != "yes":
print("Goodbye for now")
quit
|
776209f54c8a436bcde8099db7e82855cc7a6adf | sureshpodeti/Algorithms | /dp/slow/no_of_subsets_to_sum.py | 972 | 3.703125 | 4 | '''
Given a weight array 'A'. we need to figureout
no.of subsets of elements in 'A' will sum up to weight't'
psudo code:
brute-force algorithm:
1. Let f(A, m, t) (where m =|A|) denote no_of solutions
2. we can pick any element from the A and check if
how many solutions it forms, or how many solutions
include this element in solution subset
eg: A =[3,4,7,2,1], t = 7
possible solutions are:
1. {3,4}
2. {7}
3. {2,1,4}
so, we can write:
total_no_of solutions = solutions where '4' included +
solutions where '4' do not include
time complexicity: O(2^n)
'''
def no_of_subsets(A, m,t):
if t ==0:
return 1
if m ==0:
return 0
if A[m-1] > t:
return no_of_subsets(A, m-1, t)
return no_of_subsets(A, m-1, t-A[m-1]) + no_of_subsets(A, m-1, t)
A = [3,4,7,2,1]
t = 7
print "no_of_subsets:{}".format(no_of_subsets(A, len(A), t))
|
12f63228c0b4b788891c84edb85d49ef248090c8 | sureshpodeti/Algorithms | /dp/efficient/maximum_sum_path_divisibilty_condition.py | 708 | 3.6875 | 4 | '''
Maximum path sum for each position with jumps under divisibility condition:
Given an array of n positive integers. Initially we are at first position. We can jump position y to position x if y divides x and y < x. The task is to print maximum sum path ending with every position x where 1 <= x <= n.
Here position is index plus one assuming indexes begin with 0.
dynamic programming solution:
time complexicity: O(n^2)
space complexicity: O(n)
'''
def max_sum_path(A, m):
s = [0]*(m+1)
s[1] = A[0]
for j in range(2, m+1):
for i in range(1, j):
if j%i == 0:
s[j] = max(s[j], s[i]+ A[j-1])
return s[1:]
A = [2,3,1,4,6,5]
print "max_sum_path:{}".format(max_sum_path(A, len(A)))
|
0306359920877c74481047b9a0c113f04392e5ce | sureshpodeti/Algorithms | /dp/efficient/min_edits.py | 3,043 | 3.625 | 4 | '''
Given string s1, and s2 . we have following operations each of same cost:
1. insert
2. remove
3. replace
we can perform above three operations on string s1 to make it string s2.
eg:
s1 = Geek , s2= Gesek
Here, we should insert s into s1 to make it s2. so we need 1 operation.
hence, answer: 1.
brute force solution:
Let us say, f(s1, s2, m,n) denote the min #of operations perform to get s2.
where m = |s1| , n = |s2|
f(s1, s2, m-1, n-1) if s1[m-1] == s2[n-1]
f(s1, s2, m, n) =
1 + min{ f(s1, s2, m, n-1), # insert otherwise
f(s1, s2, m-1, n), # remove
f(s1, s2, m-1, n-1), # replaced
}
# if the characters are not same, it means we have found one operation need, and
which could have been resulted from either insert, remove , or replacement.
base case: if m == 0 then return n
if n == 0 then reuturn m
time complexicity: O(3^n)
Dynamic programing technique:
better understanding demonstration:
---------
|G|e|e|k|
---------
i
---------
|G|e|s|k|
---------
j
we come from the last index, we check if last character in both are same if yes means
no edit was made to s1 in making last character.
now, the problem looks:
-------
|G|e|e|
-------
i
-------
|G|e|s|
-------
j
Now, last characters are different, question: what operation could have resulted in different
characters??
it means we must have done any of the operation:
we could have done : insertion 's' into s1
-----
|G|e|
-----
i
-------
|G|e|s|
-------
j
we could have done: replacement
------
|G|e|e
------
i
-------
|G|e|s|
-------
j
we could have done: remove
--------
|G|e|s|x
--------
i
-------
|G|e|s|
-------
j
any of these operation must have taken place, thats why we are getting different last characters as mentioned.
hence, if last characters are differnent
f(s1,s2,m,n) = 1 + min{f(s1,s2,m-1,n), f(s1,s2,m,n-1), f(s1,s2,m-1,n-1)} , for insertion, remove,and replacement
'''
def min_operations(s1, s2, m,n):
s = [[0 for i in range(n+1)] for x in range(m+1)]
for i in range(m+1):
for j in range(n+1):
if i == 0:
s[i][j] = j
elif j == 0:
s[i][j] = i
elif s1[i-1] == s2[j-1]:
s[i][j] = s[i-1][j-1]
else:
s[i][j] = 1 + min(s[i][j-1], s[i-1][j-1], s[i-1][j])
return s[m][n]
s1, s2 = raw_input().split(' ')
print "min_operations:{}".format(min_operations(s1,s2, len(s1), len(s2)))
|
f3953a4b15af2cef12066243c8c760dfe7b5ae61 | sureshpodeti/Algorithms | /dp/efficient/longest_increasing_subsequence.py | 609 | 3.953125 | 4 | '''
Given an array, we need to return the length of longest increasing subsequence in that.
eg: A = [50, 3, 10, 7, 4, 0,80]
The idea is, if we know the longest increasing subsequence which at index i.
can we found LIS which ends at i+1 ????
Yes, we need to follow the below algorithm to do that.
time complexicity : O(n^2
space complexicity: O(n)
'''
def lis(A):
s = [1]*len(A)
for j in range(1, len(A)):
for i in range(0, j):
if A[i] < A[j] and s[i]>=s[j]:
s[j] += 1
return s[len(s) -1]
A = raw_input().split(',')
A = map(int, A)
print "LIS:({}):{}".format(A, lis(A))
|
2f133b9e5687578ca73e329c24c3197512b7d790 | sureshpodeti/Algorithms | /dp/slow/min_steps_to_minimize_num.py | 740 | 4.15625 | 4 | '''
Minimum steps to minimize n as per given condition
Given a number n, count minimum steps to minimize it to 1 according to the following criteria:
If n is divisible by 2 then we may reduce n to n/2.
If n is divisible by 3 then you may reduce n to n/3.
Decrement n by 1.
brute-force solution:
time complexicity: O(3^n)
'''
def min_steps(n):
if n == 0 or n==1:
return n
if n == 2 or n == 3:
return 1
if n%3 ==0 and n%2 ==0:
return 1+min(min_steps(n/3), min_steps(n/2), min_steps(n-1))
elif n%3 == 0:
return 1 + min(min_steps(n/3), min_steps(n-1))
elif n%2 == 0:
return 1+min(min_steps(n/2), min_steps(n-1))
return 1+min_steps(n-1)
n = int(raw_input())
print "no.of steps:{}".format(min_steps(n))
|
b451c8b81268bfa225e669f9532971a2a6ebf3d9 | sureshpodeti/Algorithms | /dp/slow/longest_sum_contiguous_subarray.py | 719 | 3.71875 | 4 | '''
Longest sum contigous subarray:
Given an one-dimensional array. we need to find the logest contigous subarray which gives the maximum sum
eg: A = [a,b,c]
brute-force algorithm: Generate and test
a1= [a]
a2= [a, b]
a3= [a,b,c]
b1 = [b]
b2 = [b,c]
c1 = [c]
so, we need to return the max(a1,a2,a3,b1,b2,c1)
time complexicity of the brute-force algorithm is O(n^2)
'''
from sys import maxint
def longest_sum(A):
max_value = - maxint
for i in range(0, len(A)):
sum = A[i]
for j in range(i+1, len(A)):
sum += A[j]
max_value = max(max_value, sum)
return max_value
A =raw_input().split(' ')
A = map(int, A)
print "longes_sum({}):{}".format(A, longest_sum(A))
|
f7b05c070eb88efe3ea889c2d77647a6e9cf6b4d | sureshpodeti/Algorithms | /dp/slow/min_cost_path.py | 1,157 | 4.125 | 4 | '''
Min cost path:
Given a matrix where each cell has some interger value which represent the cost incurred
if we visit that cell.
Task is found min cost path to reach (m,n) position in the matrix from (0,0) position
possible moves: one step to its right, one step down, and one step diagonally
brute-force : generate and test
Let f(i,j) denote the min cost path needed to reach (i,j) position from (0,0) position
Suppose, if we have f(i-1,j), f(i-1, j-1), and f(i, j-1) ,
Is it possible to find f(i,j) from know values ???
answer: yes, we can as shown below
f(i,j) = A[i][j]+min{f(i-1, j-1), f(i-1,j), f(i, j-1)}
base condition : if i<0 or j<0 then return 0
if i ==j and i==0 then return A[i][j]
'''
from sys import maxint
def min_cost_path(A, m,n):
if m<0 or n<0:
return maxint
if m==n and m==0:
return A[m][n]
return A[m][n]+ min(min_cost_path(A, m-1, n), min_cost_path(A, m-1, n-1), min_cost_path(A, m, n-1))
A = [ [1, 2, 3], [4, 8, 2], [1, 5, 3] ]
inp = raw_input().split(' ')
m,n = map(int, inp)
print "min_cost_path({}):{}".format(A, min_cost_path(A, m, n))
|
70d8adee68755bbc2b792c471c2ce8bd0aa04205 | oway13/project-presentation | /WebScraper PYTHON3/hearthpwn_scraper.py | 4,806 | 3.5 | 4 | from requests import get
from requests.exceptions import RequestException
from contextlib import closing
from bs4 import BeautifulSoup
import re
import json
def simple_get(url):
"""
Attempts to get the content at `url` by making an HTTP GET request.
If the content-type of response is some kind of HTML/XML, return the
text content, otherwise return None.
"""
try:
with closing(get(url, stream=True)) as resp:
if is_good_response(resp):
return resp.content
else:
return None
except RequestException as e:
log('error: Error during requests to {0} : {1}'.format(url, str(e)))
return None
def is_good_response(resp):
"""
Returns True if the response seems to be HTML, False otherwise.
"""
content_type = resp.headers['Content-Type'].lower()
return (resp.status_code == 200
and content_type is not None
and content_type.find('html') > -1)
def log(e):
"""
Simple logging function. Currently Prints to Console.
"""
print(e)
def top_user_decks(pages):
"""
Gets the hearthpwn.com urls for pages worth of top-rated user-created decks
Returns a list of urls
"""
top_decks = []
main_url = "https://www.hearthpwn.com/"
search_url = "decks?filter-deck-tag=1&filter-show-constructed-only=y&filter-show-standard=1&page="
deck_link_re = re.compile('^\/decks\/[0-9].*')
for i in range(pages):
raw_html = simple_get(main_url+search_url+str(i))
if raw_html is not None:
html = BeautifulSoup(raw_html, 'html.parser')
top_decks = get_links(html, deck_link_re, top_decks)
else:
log("error: top_user_decks simple_get returned None")
log("Found {0} user decks over {1} pages".format(len(top_decks), pages))
return top_decks
def top_general_decks(pages):
"""
Gets the hearthpwn.com urls for pages worth of top-rated generalized meta decks
Returns a list of urls
"""
top_decks = []
main_url = "https://www.hearthpwn.com/"
page_1_url = "top-decks?page=1&sort=-rating"
page_2_url = "top-decks?page=2&sort=-rating"
deck_link_re = re.compile('^\/top-decks\/[0-9].*')
for i in range (1, pages+1):
page_url = "top-decks?page={0}&sort=-rating".format(i)
raw_html = simple_get(main_url+page_url)
if raw_html is not None:
html = BeautifulSoup(raw_html, 'html.parser')
top_decks = get_links(html, deck_link_re, top_decks)
else:
log("error: top_general_decks simple get returned None on page {0}.".format(i))
log("Found {0} general decks over {1} pages".format(len(top_decks), pages))
return top_decks
def get_links(html, regex, deck_list):
"""
Parses html, finding all matches of regex for all anchor elements
appends the hearthpwn.com urls it finds to the deck_list, and returns deck_list
"""
for link in html.find_all('a'):
href = str(link.get('href'))
if regex.match(href):
deck_list.append(href)
return deck_list
def card_list(search_url):
"""
Given a hearthpwn.com deck url, gets the url of each card in the deck
If two of the same card are in the deck, a duplicate url will be appended to the list
Returns the list of these urls.
"""
card_list = []
card_link_re = re.compile('^\/cards\/[0-9].*')
main_url = "https://www.hearthpwn.com"
raw_html = simple_get(main_url+search_url)
if raw_html is not None:
html = BeautifulSoup(raw_html, 'html.parser')
for link in html.aside.find_all('a'):
href = str(link.get('href'))
if card_link_re.match(href):
try:
count = int(link['data-count'])
if count == 2:
card_list.append(href)
except:
log("data-count error. Likely extraneous card. Skipping...")
continue
card_list.append(href)
#log(href)
else:
log("error: card_list simple_get returned None")
log("Found {0} cards in deck.".format(len(card_list)))
return card_list
def test_full_card_list():
deck_list = top_user_decks(2)
deck_list.extend(top_general_decks(2))
full_card_list = []
for url in deck_list:
log(url)
full_card_list.extend(card_list(url))
#log(full_card_list)
with open("cards.json", 'w') as cards:
json.dump(full_card_list, cards)
#card_list("/decks/1140105-up-mill-warlock-top-100-by-illness")
#card_list("/decks/1142643-the-light-wills-it")
test_full_card_list()
#log(str(card_list("/decks/1267668-tokens-will-get-shreked"))) |
b1173a7eeb9e3fffefa507594125fea06e7a5a74 | zhangli1229/gy-1906A | /demo/day-03/tupel.py | 209 | 3.6875 | 4 | #列表和元组的区别
#1.元组中只有一个数据的时候，后边必须带一个逗号,列表就不需要
a = [1]
b = (1,)
print(a)
print(b)
#2.元组中的数据不可修改
# a[0] = 2
# print(a)
|
25bd2d75157436ba58f2a472ee71080438a28c25 | hiyamgh/Forecasting-Demand-Primary-Health-Care | /initial_input/helper_codes/data_subset.py | 5,111 | 3.625 | 4 | from pandas import DataFrame
import pandas as pd
import numpy as np
import os.path
import sys
sys.path.append('..')
from initial_input.helper_codes.data_set import DataSet
class DataSubset:
def __init__(self, df):
self.original_df = df
def copy_df(self):
return self.original_df.copy(deep=True)
def agg_count(self, group_elements):
"""
This method aggregates a dataframe by the count of all other rows
:param group_elements: array of labels to group by
:return:
"""
df = self.copy_df()
return DataFrame({'count': df.groupby(group_elements).size()}).reset_index()
def agg_mean(self, group_elements):
"""
This method aggregates a dataframe by the mean of a row
:param group_elements: array of labels to group by
:return:
"""
df = self.copy_df()
return df.groupby(group_elements).agg('mean')
def categorize_demand(self, groupby=['date'], mohafaza='north', service='General Medicine'):
"""
1- will aggregate the initial dataframe by the count of the date
2- get the 1s1,2nd,3rd, and 4th quartile put into an array
3- categorize the demand column ('here called: count') according to the count value
:return: df with the categorization column added, called: 'demand_class'
"""
df = self.agg_count(groupby)
df = data_set.DataSet.add_external_data(df)
if len(mohafaza):
df = self.filter(df, 'mohafaza', [mohafaza])
if len(service):
df = self.filter(df, 'service_name', [service])
desc = df.describe()
min = desc.loc['min', 'count']
fq = desc.loc['25%', 'count']
sq = desc.loc['50%', 'count']
tq = desc.loc['75%', 'count']
max = desc.loc['max', 'count']
nums = [min, fq, sq, tq, max]
print(nums)
classf = []
for (i, row) in df.iterrows():
dmnd = row['count']
if dmnd <= fq:
classf.append(0)
elif dmnd >= tq:
classf.append(2)
else:
classf.append(1)
df['demand_class'] = classf
return df
def split_groups(self, df, group):
"""
This method splits an aggregated dataframe into multiple dataframes
:param df: dataframe
:param group: array of labels to groupby
:return:
"""
groupped_df = df.groupby(group)
return [groupped_df.get_group(group) for group in groupped_df.groups]
def partition(self, df, column, num_partions):
"""
Split a dataframe into partitions based on the number of unique values in a column
:param df: dataframe
:param column: the column to partition on
:param num_partions: the number of partitions to split the dataframe into
:return: list of partitions
"""
column_partition = np.array_split(df[column].unique(), num_partions)
return [self.filter(df, column, values) for values in column_partition]
@staticmethod
def filter(df, column, values):
"""
Returns a dataframe who's entries in a given column are only in a list of values
:param df: dataframe
:param column: column to apply filtering to
:param values: list of values to include
:return: dataframe who's entries in a given column are only in a list of values
"""
return df[df[column].isin(values)]
def generate_subsets(self, subset):
"""
subsets dataframe
:param subset: dict from column to list of values to use, put None instead of a list to use all values
"""
df = self.copy_df()
for column, values in subset.items():
if values is not None:
df = self.filter(df, column, values)
return self.split_groups(df, list(subset.keys()))
def save_subsets(self, subset, dir=""):
"""
subsets dataframe and writes them to file as csv
:param subset: dict from column to list of values to use, put None instead of a list to use all values
"""
subset_list = self.generate_subsets(subset)
for data_subset in subset_list:
name = "ministry_of_health_subset_"
subset_values = [data_subset[column].iloc[0] for column in subset.keys()]
name += '_'.join(subset_values) + ".csv"
name = name.replace(" ", "_")
data_subset.to_csv(os.path.join(dir, name))
if __name__ == "__main__":
data_set_holder = DataSet()
# full_df = data_set_holder.copy_df()
full_df = pd.read_csv('input/FaourProcessed.csv')
full_df = data_set_holder.clean(full_df, sex=True, age=True, nationality=True, average_age=True)
data_subsetter = DataSubset(full_df)
data_subsetter.save_subsets({"nationality" : ["Lebanon", "Syria"],
"mohafaza": ["north", "south", "beirut"],
"service_name": ["General Medicine", "Pharmacy", "Pediatrics"]}) |
48f13070c13aa87c81d705e51481278336cf1c19 | hossainlab/statsandpy | /book/_build/jupyter_execute/descriptive/m3-demo-01-ReadingFromAndWritingToFilesUsingPandas.py | 2,348 | 3.515625 | 4 | #!/usr/bin/env python
# coding: utf-8
# In[1]:
get_ipython().system('python --version')
# #### Installation of pandas
# In[2]:
get_ipython().system('pip install pandas')
# In[3]:
get_ipython().system('pip install numpy')
# #### Installation of matplotlib
# In[4]:
get_ipython().system('pip install matplotlib')
# In[5]:
get_ipython().system('pip install seaborn')
# #### Pandas version
# In[6]:
import pandas as pd
pd.__version__
# #### Matplotlib version
# In[7]:
import matplotlib
matplotlib.__version__
# #### Numpy version
# In[8]:
import numpy as np
np.__version__
# ### Seaborn Version
# In[9]:
import seaborn
seaborn.__version__
# <b>Dataset</b> https://www.kaggle.com/vjchoudhary7/customer-segmentation-tutorial-in-python
# * Gender - Gender of the customer
# * Age - Age of the customer
# * Annual Income (k$) - Annual Income of the customee
# * Spending Score (1-100) - Score assigned by the mall based on customer behavior and spending nature
# #### Reading data using pandas python
# In[10]:
## TODO: While recording please show the file structure first
# In[11]:
mall_data = pd.read_json('datasets/Mall_Customers.json')
mall_data.head(5)
# In[12]:
average_income = mall_data['annual_income'].mean()
average_income
# In[13]:
mall_data['above_average_income'] = (mall_data['annual_income'] - average_income) > 0
mall_data.sample(5)
# * We can save it in any forms like normal text file, csv or json. It will save it in the location where you prefer as well
# In[14]:
mall_data.to_csv('datasets/mall_data_processed.csv', index=False)
# In[15]:
get_ipython().system('ls datasets/')
# #### Read the csv file for the clarification
# In[16]:
mall_data_updated = pd.read_csv('datasets/mall_data_processed.csv', index_col=0)
mall_data_updated.head(5)
# In[17]:
## TODO: While recording please show the files after each save
# In[18]:
mall_data.to_json('datasets/mall_data_column_oriented.json', orient='columns')
# In[19]:
mall_data.to_json('datasets/mall_data_records_oriented.json', orient='records')
# In[20]:
mall_data.to_json('datasets/mall_data_index_oriented.json', orient='index')
# In[21]:
mall_data.to_json('datasets/mall_data_values_oriented.json', orient='values')
# In[22]:
get_ipython().system('ls datasets/')
# In[ ]:
|
72b8750a3c41dca8a93cea4edc0cb704fb79b175 | ertugrul-dmr/automate-the-boring-stuff-projects | /comma-code/comma-alt.py | 366 | 3.71875 | 4 |
# Another variation to automate the Boring Stuff With Python Ch. 4 Project
spam = ['apples', 'bananas', 'tofu', 'cats', 'coconuts']
def comma(items): # Combines list into a string of the form item1, item2, item 3 and item 4
if len(items) == 1:
print(items[0])
print('{} and {}'.format(', '.join(items[:-1]), items[-1]))
comma(spam)
|
8f83e4e958303fca9387b8697e8a9f83c38356e3 | ertugrul-dmr/automate-the-boring-stuff-projects | /spreadsheet-cell-inverter/inverter.py | 538 | 3.90625 | 4 | # A program to invert the row and column of the cells in the spreadsheet.
import openpyxl
inputwb = openpyxl.load_workbook('produceSales.xlsx', data_only=True)
inputSheet = inputwb.active
maxRow = inputSheet.max_row
maxColumn = inputSheet.max_column
outputwb = openpyxl.Workbook()
outputSheet = outputwb.active
for r in range(1, maxRow + 1):
for c in range(1, maxColumn + 1):
outputSheet.cell(row=c, column=r).value = inputSheet.cell(
row=r, column=c).value
outputwb.save('inverted.xlsx')
|
c6e2d36b530c166448f12701ef4017d89b1667b4 | ertugrul-dmr/automate-the-boring-stuff-projects | /rockpaperscissors/rockpaperscissors.py | 2,665 | 4 | 4 | # This is a game tries to simulate rock, paper, scissors game.
import random
import sys
def maingame(): # Start's the game if player chooses to play.
wins = 0
losses = 0
draws = 0
while True: # Main loop
print(f'Wins: {wins}, Losses: {losses}, Draws: {draws}')
if wins == 5:
print(f'You beat the ai!')
break
if losses == 5:
print(f'Ai has beaten you!')
break
if draws == 5:
print(f'It\'s a draw between you and ai!')
break
playerMove = str(
input('Plese make your move. r(ock),p(aper),s(scissors): '))
aiMove = random.randint(1, 3) # 1 rock, 2 paper, 3 scissor
if playerMove == 'r':
if aiMove == 1:
print('Ai move is: Rock.' + f' Your move was: {playerMove}.')
print('Draw')
draws += 1
elif aiMove == 2:
print('Ai move is: Paper.' + f' Your move was: {playerMove}.')
print('Lose')
losses += 1
else:
print('Ai move is: Scissor.' +
f' Your move was: {playerMove}.')
print('Win')
wins += 1
if playerMove == 'p':
if aiMove == 2:
print('Ai move is: Paper.' + f' Your move was: {playerMove}.')
print('Draw')
draws += 1
elif aiMove == 3:
print('Ai move is: Scissor.' +
f' Your move was: {playerMove}.')
print('Lose')
losses += 1
else:
print('Ai move is: Rock.' + f' Your move was: {playerMove}.')
print('Win')
wins += 1
if playerMove == 's':
if aiMove == 3:
print('Ai move is: Scissor.' +
f' Your move was: {playerMove}.')
print('Draw')
draws += 1
elif aiMove == 1:
print('Ai move is: Rock.' + f' Your move was: {playerMove}.')
print('Lose')
losses += 1
else:
print('Ai move is: Paper.' + f' Your move was: {playerMove}.')
print('Win')
wins += 1
k = input(f'Enter R to restart and press Q to quit\nR/Q? ')
k.lower()
if k == 'r':
maingame()
else:
sys.exit
k = input(f'Enter S to restart and press Q to quit\nS/Q? ')
k.lower()
if k == 's':
maingame()
else:
sys.exit
|
ffd91a476007794992ffedccc592bbc3685c864a | themaddoctor/BritishNationalCipherChallenge | /2020 special edition/forum/gantun/encrypt.py | 987 | 3.609375 | 4 | #!/usr/bin/env python
# based on Gantun from https://susec.tf/tasks/gantun_229621efd1dcc01ef8851254affd1326887ec58e.txz
#from random import randint
randint = []
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
def encrypt(p):
global randint
numbers = []
for char in p.upper():
numbers.append(alphabet.index(char)+26)
while len(numbers) > 1:
n = randint[0]; randint = randint[1:] # randint(0,len(numbers)-2)
x = numbers[n]
y = numbers[n+1]
if x > y:
z = x*x + x + y
else:
z = y*y + x
numbers = numbers[:n] + [z] + numbers[n+2:]
return numbers[0]
p = open("plaintext.txt","r").read().upper().replace(" ","").replace("\n","").replace("\r","")
# the random choices made in encryption have been stored in random.txt, so that you can reproduce the ciphertext
random = open("random.txt","r").read().replace("\n","").replace("\r","").split(",")
randint = [int(x) for x in random]
print encrypt(p)
|
c6c138a068df67112091256c4491e3ea2b539a39 | blairg23/files-in-folder | /files_in_folder.py | 15,406 | 3.78125 | 4 | #-*- coding: utf-8 -*-
'''
Description: Checks existence of files from one given folder in the other given folder.
- If the left folder is larger than the right folder, it will return the filenames and hashes of the remaining files.
- If the right folder is larger than the left folder, it will return a True if all files from the left folder
exist in the right folder and a False with the filenames and hashes of the non-existence files.
'''
import os # Operating System functions
import sys # System Functions
import shutil # File copy operations
import hashlib # Hashing functions
import json # JSON stuff
from time import localtime as clock # Time a function
# Filenames we don't want to check:
PROTECTED_FILENAMES = ['contents.csv', 'missing.txt']
class FilesInFolder:
def __init__(
self,
left_folder=None,
right_folder=None,
write_mode=None,
hash_algorithm='md5',
hash_type='contents',
contents_filename='contents.json',
missing_files_filename='missing.txt',
fix_missing_files=False,
verbose=False
):
self.verbose = verbose
self.action_counter = 0
self.write_mode = write_mode
self.hash_algorithm = hash_algorithm
self.hash_type = hash_type
self.left_folder = left_folder
self.right_folder = right_folder
self.contents_filename = contents_filename
self.missing_files_filename = missing_files_filename
self.fix_missing_files = fix_missing_files
try:
# If valid directories have not been provided:
if self.left_folder == None or self.right_folder == None or not os.path.exists(self.left_folder) or not os.path.exists(self.right_folder):
raise IOError('[ERROR] Please provide valid right and left directories.')
else:
print('[{action_counter}] Left Directory: {left_folder}'.format(action_counter=self.action_counter, left_folder=self.left_folder))
print('[{action_counter}] Right Directory: {right_folder}'.format(action_counter=self.action_counter, right_folder=self.right_folder))
print('\n')
except Exception as e:
print(e)
def find_filenames(self, directory=None):
'''
Finds all the filenames in a given directory.
'''
filenames = []
try:
if directory == None or not os.path.exists(directory):
raise IOError('[ERROR] Please provide a valid directory to search.')
else:
if self.verbose:
print('[{action_counter}] Finding files in {directory}.\n'.format(action_counter=self.action_counter, directory=directory))
filenames = [f for f in os.listdir(directory) if os.path.isfile(os.path.join(directory,f))]
self.action_counter += 1
except Exception as e:
print(e)
return filenames
def hash_file_contents(self, filepath=None, hash_algorithm='md5'):
'''
Uses given hashing algorithm to hash the binary file, given a full filepath.
'''
BLOCKSIZE = 65536 # In case any file is bigger than 65536 bytes
hash_value = 0x666
try:
if self.verbose:
print('[{action_counter}] Hashing file contents of {filepath}.\n'.format(action_counter=self.action_counter, filepath=filepath))
if filepath == None or not os.path.exists(filepath):
raise IOError('[ERROR] Please provide a valid filepath to hash.')
with open(filepath, 'rb+') as inFile:
h = hashlib.new(hash_algorithm)
buf = inFile.read(BLOCKSIZE)
while len(buf) > 0:
h.update(buf)
buf = inFile.read(BLOCKSIZE)
hash_value = h.hexdigest()
except Exception as e:
print(e)
return hash_value
def hash_filename(self, filename=None, hash_algorithm='md5'):
'''
Uses given hashing algorithm to hash the given filename.
'''
hash_value = 0x666
try:
if self.verbose:
print('[{action_counter}] Hashing filename {filename}.\n'.format(action_counter=self.action_counter, filename=filename))
if filename == None:
raise IOError('[ERROR] Please provide a filename to hash.')
else:
h = hashlib.new(hash_algorithm)
h.update(filename)
hash_value = h.hexdigest()
except Exception as e:
print(e)
return hash_value
def get_hashes(self, directory=None, hash_algorithm='md5', hash_type='contents'):
'''
Populate a dictionary with filename:hash_value pairs, given a directory and list of filenames.
'''
hashlist = {}
hashlist['headers'] = ['hash_value', 'filepath']
try:
if directory == None or not os.path.exists(directory):
raise IOError('[ERROR] Please provide a valid directory to hash.')
else:
filenames = self.find_filenames(directory=directory)
for filename in filenames:
if filename not in PROTECTED_FILENAMES:
filepath = os.path.join(directory, filename)
if hash_type == 'contents':
hash_value = self.hash_file_contents(filepath=filepath, hash_algorithm=hash_algorithm)
elif hash_type == 'filenames':
hash_value = self.hash_filename(filename=filename, hash_algorithm=hash_algorithm)
hashlist[str(hash_value)] = str(filepath)
self.action_counter += 1
except Exception as e:
print(e)
return hashlist
def write_dictionary_contents(self, dictionary_contents={}, write_mode=None, contents_filepath=None):
'''
Writes contents of a given dictionary, using the specified write mode (JSON or CSV).
'''
valid_write_modes = ['json', 'csv']
try:
if dictionary_contents == {}:
raise Exception('[ERROR] Need to provide a valid dictionary with contents.')
elif write_mode == None or not write_mode.lower() in valid_write_modes:
raise Exception('[ERROR] Need to provide a write mode from: {valid_write_modes}'.format(valid_write_modes=valid_write_modes))
elif contents_filepath == None:
raise Exception('[ERROR] Need to provide a valid file to write contents.')
else:
with open(contents_filepath, 'a+') as outfile:
if write_mode.lower() == 'json':
json.dump(dictionary_contents, outfile)
elif write_mode.lower() == 'csv':
headers = ','.join(dictionary_contents['headers'])
outfile.write(headers + '\n')
for key,value in dictionary_contents.items():
if key != 'headers':
output_line = key + ',' + value + '\n'
outfile.write(output_line)
else:
raise Exception('[ERROR] Need to provide a write mode from: {valid_write_modes}'.format(valid_write_modes=valid_write_modes))
except Exception as e:
print(e)
def compare_hash_lists(self, left_hash_dict=None, right_hash_dict=None):
'''
Given two hash lists, will compare them to ensure all hashes
from left list exist in right list, then will return the list of
all hashes that are missing.
'''
missing_hash_value_filepaths = []
for hash_value, filepath in left_hash_dict.items():
if not hash_value in right_hash_dict.keys():
missing_hash_value_filepaths.append(filepath)
return missing_hash_value_filepaths
def write_list_contents(self, list_contents=[], missing_files_filepath=None):
'''
Writes contents of a given list to a file.
'''
try:
if list_contents == []:
raise Exception('[ERROR] Need to provide a valid list with contents.')
else:
with open(missing_files_filepath, 'a+') as outfile:
for value in list_contents:
outfile.write(value + '\n')
except Exception as e:
print(e)
def write_missing_files(self, missing_filepaths=[], destination_directory=None):
'''
Writes missing files to the destination filepath.
'''
try:
if missing_filepaths == []:
raise Exception('[ERROR] Need to provide a valid list of missing files.')
else:
for missing_filepath in missing_filepaths:
missing_filename = os.path.basename(missing_filepath)
# Use copy2 to retain metadata such as creation and modification times of the file
destination_filepath = os.path.join(destination_directory, missing_filename)
shutil.copy2(missing_filepath, destination_filepath)
except Exception as e:
print(e)
def cleanup(self):
'''
Cleans up metadata files like contents.csv and missing.txt
'''
self.action_counter += 1
for filename in PROTECTED_FILENAMES:
left_file_to_delete = os.path.join(self.left_folder, filename)
right_file_to_delete = os.path.join(self.right_folder, filename)
if os.path.exists(left_file_to_delete):
if self.verbose:
print(f'[{self.action_counter}] Deleting {left_file_to_delete}.\n')
os.remove(left_file_to_delete)
self.action_counter += 1
if os.path.exists(right_file_to_delete):
if self.verbose:
print(f'[{self.action_counter}] Deleting {right_file_to_delete}.\n')
os.remove(right_file_to_delete)
self.action_counter += 1
def run(self):
'''
Runs all the required functions to check whether two folders have identical content.
'''
left_hash_dict = self.get_hashes(directory=self.left_folder, hash_algorithm=self.hash_algorithm, hash_type=self.hash_type)
right_hash_dict = self.get_hashes(directory=self.right_folder, hash_algorithm=self.hash_algorithm, hash_type=self.hash_type)
missing_hash_value_filepaths = self.compare_hash_lists(left_hash_dict=left_hash_dict, right_hash_dict=right_hash_dict)
if self.write_mode != None:
# Missing files:
if len(missing_hash_value_filepaths) == 0:
print('All files from left folder exist in right folder.')
print('Left Folder:' ,self.left_folder)
print('Right Folder:', self.right_folder)
print('\n')
# Left side:
left_outfilepath = os.path.join(self.left_folder, self.contents_filename)
self.write_dictionary_contents(dictionary_contents=left_hash_dict, write_mode=self.write_mode, contents_filepath=left_outfilepath)
if self.verbose:
print('[{action_counter}] Writing contents to {contents_filepath}.\n'.format(action_counter=self.action_counter, contents_filepath=left_outfilepath))
self.action_counter += 1
# Right side:
right_outfilepath = os.path.join(self.right_folder, self.contents_filename)
self.write_dictionary_contents(dictionary_contents=right_hash_dict, write_mode=self.write_mode, contents_filepath=right_outfilepath)
if self.verbose:
print('[{action_counter}] Writing contents to {contents_filepath}.\n'.format(action_counter=self.action_counter, contents_filepath=right_outfilepath))
self.action_counter += 1
else:
missing_files_filepath = os.path.join(self.left_folder, missing_files_filename)
if self.verbose:
print('[{action_counter}] Writing missing file info to {missing_files_filepath}.\n'.format(action_counter=self.action_counter, missing_files_filepath=missing_files_filepath))
self.write_list_contents(list_contents=missing_hash_value_filepaths, missing_files_filepath=missing_files_filepath)
self.action_counter += 1
if self.fix_missing_files:
if self.verbose:
print(f'[{self.action_counter}] Writing missing files to {self.right_folder}.\n')
self.write_missing_files(missing_filepaths=missing_hash_value_filepaths, destination_directory=self.right_folder)
self.action_counter += 1
if self.verbose:
print(f'[{self.action_counter}] Cleaning up metadata files.\n')
self.cleanup()
if self.verbose:
print(f'[{self.action_counter}] Rerunning file checker.\n')
self.action_counter += 1
self.run()
else:
print('Files missing from left folder that exist in right folder:')
print(missing_hash_value_filepaths)
if __name__ == '__main__':
# Until I use arg parse:
left_folder = ''
right_folder = ''
hash_algorithm = 'md5'
hash_type = 'contents' # Other option is "filenames"
write_mode = 'csv'
contents_filename = 'contents.csv'
missing_files_filename = 'missing.txt'
fix_missing_files = True
file_checker = FilesInFolder(
left_folder=left_folder,
right_folder=right_folder,
write_mode=write_mode,
hash_algorithm=hash_algorithm,
hash_type=hash_type,
contents_filename=contents_filename,
missing_files_filename=missing_files_filename,
fix_missing_files=fix_missing_files,
verbose=True
)
# Some calls you can use to test (until I write good unit tests):
# filenames = file_checker.find_filenames(directory=left_folder)
#hashlist = file_checker.get_hashes(directory=left_folder, hash_algorithm=hash_algorithm, hash_type=hash_type)
#contents_filepath = os.path.join(left_folder, contents_filename)
#file_checker.write_dictionary_contents(dictionary_contents=hashlist, write_mode=write_mode, contents_filepath=contents_filepath)
file_checker.run() |
99226eef5a94c5a5394dc4d6cb645b7334d271a0 | cs-summercrew/Summer19-SeedSystems | /OpenCV-Examples/Image Detection/cam.py | 4,474 | 3.546875 | 4 | # Authors: CS-World Domination Summer19 - CB
'''
Simply display the contents of the webcam with optional mirroring using OpenCV
via the new Pythonic cv2 interface. Press <esc> to quit.
NOTE: Key bindings:
g: BGR->RGB
f: vertical flip
d: horizontal flip
esc: quit
'''
import cv2
import numpy as np
cascPath = "haarcascade_frontalface_default.xml"
faceCascade = cv2.CascadeClassifier(cascPath)
def demo1():
"""
just run it to see the video from the built-in webcam
if CAPTURE_NUM = 0 doesn't work, try -1, 1, 2, 3
(if none of those work, the webcam's not supported!)
"""
CAPTURE_NUM = 0
cam = cv2.VideoCapture(CAPTURE_NUM)
mirror=False
VERTICAL_FLIP=False
BGR=False
while True:
ret_val, orig = cam.read()
#shrink image to half size (.5)
#"None" argument refers to the size in pixels, which we don't care about since we're scaling
img=cv2.resize(orig, None, fx=.5, fy=.5)
#NOTE: if the image is original size, it will be very slow and laggy, and will miss some keypresses.
#adjust size as desired if your machine is powerful enough
""" key-press handling """
k = cv2.waitKey(20) & 0xFF
k_char = chr(k)
if k_char == 'g':
BGR = not BGR # fun!
if k_char == 'f':
VERTICAL_FLIP = not VERTICAL_FLIP # fun!
if k_char == 'd':
mirror = not mirror # fun!
if mirror:
img = cv2.flip(img, 1)
if VERTICAL_FLIP:
img = cv2.flip(img, 0)
if BGR:
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
if k == 27:
break # esc to quit
#facial recognition handling
faces = faceCascade.detectMultiScale(
img,
scaleFactor=1.1,
minNeighbors=5,
minSize=(30, 30),
flags = cv2.CASCADE_SCALE_IMAGE
)
#print("Found {0} faces!".format(len(faces)))
# Draw a rectangle around the faces
for (x, y, w, h) in faces:
cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)
cv2.imshow('my webcam', img)
cv2.destroyAllWindows()
def demo3():
"""
to demo: click to bring focus to the messi image
move mouse around and hit 'r' (lowercase r)
a cyan rectangle should appear at your mouse
hit spacebar to clear
drawing reference:
http://docs.opencv.org/2.4/modules/core/doc/drawing_functions.html
"""
# Create a black image, a window and bind the function to window
# this is from here:
FILE_NAME = "messi5.jpg"
image_orig = cv2.imread(FILE_NAME, cv2.IMREAD_COLOR)
#image_orig = cv2.cvtColor(image_orig, cv2.COLOR_BGR2RGB)
image = image_orig.copy()
current_mouse_pos = [0,0] # not true yet...
def mouse_handler(event,x,y,flags,param):
""" a function that gets called on mouse events
reference:
"""
current_mouse_pos[0] = x
current_mouse_pos[1] = y
#print("The mouse is currently at", current_mouse_pos)
if event == cv2.EVENT_LBUTTONDOWN: print("Left button clicked!")
if event == cv2.EVENT_RBUTTONDOWN: print("Right button clicked!")
cv2.namedWindow('image')
cv2.setMouseCallback('image',mouse_handler)
while True:
cv2.imshow('image',image)
""" key-press handling """
k = cv2.waitKey(20) & 0xFF
k_char = chr(k)
if k_char == 'm': print('mmmm!') # fun!
if k_char == 'r':
x, y = current_mouse_pos # adjusted by the mouse_handler!
DELTA = 42
UL = (x-DELTA,y-DELTA) # Upper Left
LR = (x+DELTA,y+DELTA) # Lower Right
CLR = (255,255,0) # color
WIDTH = 1 # rectangle width
cv2.rectangle( image, UL, LR, CLR, WIDTH ) # draw a rectangle
if k_char == ' ': image = image_orig.copy() # clear by re-copying!
if k == 27: # escape key has value 27 (no string represetation...)
print("Quitting!")
break
""" end of key-press handling """
# outside of the while True loop...
cv2.destroyAllWindows()
def main():
#demo3()
#demo2()
demo1()
if __name__ == '__main__':
main() |
cb2cab044509d2dc344c4a3faa162ef432233bdc | brendon977/programas_Python | /imc_comstatus.py | 1,335 | 4 | 4 | #Desenvolva uma lógica que leia o peso e altura
# de uma pessoa, calcule seu IMC e mostre seu status
#de acordo com a tabela abaixo:
#-Abaixo de 18.5: Abaixo do peso
# Entre 18.5 e 25: Peso ideal
#25 ate 30: Sobrepeso
#30 ate 40: Obesidade mórbida
#Validação de dados inclusa
valid_peso= False
while valid_peso == False:
peso= input("Digite seu peso: ")
try:
peso = float(peso)
if peso <0:
print('Insira apenas numeros maiores que 0')
else:
valid_peso = True
except:
print('Insira apenas números!')
valid_peso = False
valid_altura = False
while valid_altura == False:
altura = input("Digite sua altura: ")
try:
altura = float(altura)
if altura == str:
print("Insira apenas números e separando apenas usando ponto(.)")
else:
valid_altura= True
except:
print("Insira apenas números e separando apenas usando ponto'(.)'")
valid_altura= False
iMC= peso/(altura*altura)
if iMC<18.5:
print("Seu imc {:.2f}. Abaixo do peso!".format(iMC))
elif iMC>=18.5 and iMC<=25:
print("Seu imc {:.2f}. Peso ideal!".format(iMC))
elif iMC>25 and iMC<=30:
print("Seu imc {:.2f}. Sobrepeso!".format(iMC))
elif iMC>30 and iMC<=40:
print("Seu imc {:.2f}. Obesidade mórbida!".format(iMC))
|
037f40f144c471fe6ac96b6ac387d2ff2d6eb242 | brendon977/programas_Python | /jogo_jokenpo.py | 1,599 | 3.921875 | 4 | #Crie um programa que faça o computador
#jogar jokenpo com voce.
from random import randint
from time import sleep # para colocar timer no programa
valid_jogador = False
itens = ('Pedra', 'Papel','Tesoura')
computador = randint(0,2)
print('''Suas opções:
[0] PEDRA
[1] PAPEL
[2] TESOURA''')
while valid_jogador == False:
jogador= input('Qual sua jogada? ')
try:
jogador = int(jogador)
if jogador <0 or jogador >2:
print("Escolha entre as opções de 0 a 2")
else:
valid_jogador = True
except:
print('Insira apenas números')
valid_jogador = False
print('JO')
sleep(1) # sleep de 1 segundo
print('KEN')
sleep(1)
print('PO')
sleep(1)
print("-="*11)
print('O computador escolheu{}'.format(itens[computador])) #com itens[computador] ele passa a escrever o nome dos itens que cair em vez dos numeros.
print('O jogador jogou{}'.format(itens[jogador]))
print("-="*11)
if computador == 0:
if jogador ==0:
print("Empate")
elif jogador ==1:
print("Jogador venceu")
elif jogador ==2:
print("Computador venceu")
else:
print("Jogada inválida")
elif computador ==1:
if jogador ==0:
print("Computador venceu")
elif jogador ==1:
print("Empate")
elif jogador ==2:
print("Jogador venceu")
else:
print("Jogada inválida")
elif computador ==2:
if jogador ==0:
print("Jogador venceu")
elif jogador ==1:
print("Computador venceu")
elif jogador ==2:
print("Empate")
else:
print("Jogada inválida")
|
c41b853bc0869c6cbda8438edbbed46954673d47 | Ping-ChenTsai417/Astroid-impact-armageddon-itokawa-acse4 | /armageddon/Optimisation.py | 4,854 | 3.671875 | 4 | import scipy.interpolate as intpl
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
'''
Optimization problem
'''
def meteor_data(file):
""" The given results of the meteor event.
Parameter
-----------
file: file path
"""
data_csv = pd.read_csv(file)
df=pd.DataFrame(data=data_csv)
altitude_ = np.array(df.iloc[1:,0])
energy = np.array(df.iloc[1:,1]) #* 4.184 * 1e12 # convert to joules
return altitude_, energy
def RMSE(energy_guess, energy_target):
""" Calculate the root mean square error of the optimized energy and target energy
Parameter
------------
energy_guess: array
energy_arget: array
"""
return np.sqrt(np.mean((energy_guess-energy_target)**2))
# loop through each possible r and Y
def get_opt_radius_Y(earth, rad, Y, height_ori, energy_ori, target_func):
'''Optimize r and Y by looping guessed parameters within possible range.
Possible range can be tuned manually.
Parameters
----------
earth: object of class
Planet in solver.py
rad: array
Guessed radian
Y: array
Guessed strength
height_ori: array
Given heights of the event
energy_ori: array
Given energy of the event
target_func: function
Interpolated function of the event data
Returns
-------
outcome :
'radius_opt', 'strength_opt','rmse','height_guess_s' and 'energy_guess_s' are
the optimized radius, optimized strength, rmse between optimised energy and target energy, array of
optimized height, array of optimized strength.
'''
rmse_all = []
tol = 5
for r in rad:
for s in Y:
result = earth.solve_atmospheric_entry(radius = r, angle=18.3, strength = s, velocity=1.92e4, density=3300)
outcome = earth.calculate_energy(result)
energy_guess = outcome.dedz
height_guess = outcome.altitude/1000
# Slice optimized function to the same range as target one
lower_bound = np.where(height_guess <= height_ori[0])[0][0]
upper_bound = np.where(height_guess >= height_ori[-1])[0][-1]
height_guess_s = height_guess[lower_bound:upper_bound]
energy_guess_s = energy_guess[lower_bound:upper_bound]
# Calculate optimal energy
energy_ori_s = target_func(height_guess_s)
# Output energy rmse difference, put error into an array
rmse = RMSE(energy_guess_s, energy_ori_s)
rmse_all.append(rmse)
if rmse < np.amin(rmse_all[:]) or np.allclose(rmse, np.amin(rmse_all[:])):
radius_opt = r
strength_opt = s
elif rmse<tol:
radius_opt = r
strength_opt = s
break
return radius_opt, strength_opt,rmse, height_guess_s, energy_guess_s
def plot_Optimisation_radius_strength(filepath_, earth):
'''
Plot the optimized function vs. the target function of the event
Parameter
------------
filepath_: file path
earth: object of the class Planet() in solver
'''
height_ori, energy_ori = meteor_data(filepath_) # insert filename
target_func = intpl.interp1d(height_ori, energy_ori)
fig = plt.figure(figsize=(18, 6))
ax = fig.add_subplot(121)
# Interpolate function
target_func = intpl.interp1d(height_ori, energy_ori)
# Plot target function
ax.plot(height_ori, target_func(height_ori),'r',label = 'Target func')
#Guess energy and height
result = earth.solve_atmospheric_entry(radius=8.21, angle=18.3, strength=5e6, velocity=1.92e4, density=3300)
outcome = earth.calculate_energy(result)
energy_guess = outcome.dedz
height_guess = outcome.altitude/1000
# Plot guess function
ax.plot(height_guess, energy_guess,label = 'Guess func')
ax.legend()
ax.grid(True)
ax.set_ylabel('Energy Loss per Unit Height (kt TNT)')
ax.set_xlabel('Altitude (km)')
# Change guessed range for radius and strength
radius_ = np.linspace(8.1, 8.3, 3)
strength_ = np.linspace(4.9e6,5.3e6, 3)
radius_opt, strength_opt, rmse_opt, height_guess_s, energy_guess_s = get_opt_radius_Y(earth, radius_, strength_ ,height_ori, energy_ori, target_func)
ax1 = plt.subplot(122)
ax1.plot(height_guess_s, energy_guess_s, label = 'Guess func')
ax1.plot(height_ori, target_func(height_ori),'r', label = 'Target func')
ax1.grid(True)
ax1.legend()
ax1.set_ylabel('Energy Loss per Unit Height (kt TNT)')
ax1.set_xlabel('Altitude (km)')
print('radius_opt:')
print(radius_opt)
print('strength_opt: ')
print(strength_opt)
return
|
7afbbb718239098a4f64aacab5efd56b45c27370 | u-ever/JavaScript_Guanabara | /aula14ex/ex017/testetabuada.py | 109 | 3.703125 | 4 | mult = int(input('Digite um número: '))
for c in range (1,11):
print(f'{mult} x {c} = {mult * c}')
c += 1 |
e8019a0d7da90f1633bd139a32ca191887b08c10 | naroladhar/MCA_101_Python | /mulTable.py | 1,074 | 4.125 | 4 | import pdb
pdb.set_trace()
def mulTable(num,uIndexLimit):
'''
Objective : To create a multiplication table of numbers
Input Variables :
num : A number
uIndexLimit: The size of the multiplication table
Output Variables:
res : The result of the product
return value:none
'''
for i in range(0,uIndexLimit+1):
res=num*i
print("%d X %d = %d" %(num,i,res))
def main():
'''
Objective : To create a multiplication table of numbers
Input Variables :
num : A number
uIndexLimit: The size of the multiplication table
Output Variables:
res : The result of the product
return value:none
'''
start=int(input(" Enter a start: "))
finish = int(input(" Enter a finish: "))
uIndexLimit = int(input(" Enter size of the table: "))
for start in range(start,finish+1):
print("*******Time Table for ",start,"*********")
mulTable(start,uIndexLimit)
if __name__=='__main__':
main()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.