blob_id string | repo_name string | path string | length_bytes int64 | score float64 | int_score int64 | text string | is_english bool |
|---|---|---|---|---|---|---|---|
80b595700516c71fce8cb9a27d205d18e4a793d1 | Vanzcoder/HackerRankChallenges-Python- | /List_Comprehensions.py | 1,655 | 4.375 | 4 | """
Let's learn about list comprehensions!
You are given three integers X,Y and Z representing the dimensions of a cuboid along with an integer N.
You have to print a list of all possible coordinates given by (i,j,k) on a 3D grid
where the sum of i + j + k is not equal to N.
Here, 0 <= i <= X; 0 <= j <= Y, 0 <= k <= Z
Input Format:
Four integers X,Y,Z and N each on four separate lines, respectively.
Constraints:
Print the list in lexicographic increasing order.
Sample input:
1 (1 is max value, so 1st item will be 0 <= x <= 1 in every sublist)
2 (so 2nd item will be 0 <= y <= 2 in every sublist)
3 (so 3rd item will be 0 <= z <= 3 in every sublist)
4 (the total x + y + z != 4)
Sample output (this is an example but it is not in the correct order):
[([0,0,0], [0,0,1], [0,1,0], [1,0,0],) ([0,0,2], [0,1,1], [0,2,0], [1,0,1], [1,1,0],) [0,0,3],[0,1,2],
[0,2,1],[1,0,2], [1,1,1], [1,2,0], [0, 2, 3], [1,1,3],[1,2,2],[1,2,3]]
Concept
You have already used lists in previous hacks. List comprehensions are an elegant way to
build a list without having to use different for loops to append values one by one.
This example might help.
Example: You are given two integers x and y .
You need to find out the ordered pairs ( i , j ) , such that ( i + j ) is not equal to
n and print them in lexicographic order.( 0 <= i <= x ) and ( 0 <= j <= y) This is the
code if we dont use list comprehensions in Python.
Solution:
"""
if __name__ == '__main__':
x = int(input())
y = int(input())
z = int(input())
n = int(input())
print([[ i, j, k] for i in range(x+1) for j in range(y+1) for k in range(z+1) if k+j+i != n])
| true |
1b34b710d70edbb88e6c677e35ac5fff7c795232 | lkr92/Learning-Projects | /Simple Calculator.py | 722 | 4.34375 | 4 | run = True
#Simple Calculator that will run on loop upon user request
while run:
num1 = float(input("Please type a number: "))
operator = input("Please input an operator character: ")
num2 = float(input("Please input a second number: "))
if operator == "+":
print(num1 + num2)
elif operator == "-":
print(num1 - num2)
elif operator == "/":
print(num1 / num2)
elif operator == "*":
print(num1 * num2)
else:
print("Invalid Operator!!")
if input('Type "yes" for a new request or type anything else to close: ') == "yes" or "Yes" or "YES":
run = True
else:
run = False
print("End of program.")
| true |
692f27d609c9961bf5feed66b17f29066020467f | yamaton/codeeval | /easy/prime_palindrome.py | 1,211 | 4.125 | 4 | """
prime_palindrome.py
Created by Yamato Matsuoka on 2012-07-16.
Description
-----------
Write a program to determine the biggest prime palindrome under 1000.
Input: None
Output: Prints the largest palindrome on stdout under 1000.
"""
import math
def integerdigits(n):
"""Construct list of decimal digits from the integer n."""
x = []
quotient = n
while quotient > 0:
x.append(quotient % 10)
quotient /= 10
x.reverse()
return x
def fromdigits(x):
"""Constructs an integer from the list x of decimal digits."""
return reduce(lambda i,j: 10*i + j, x)
def is_palindrome(n):
"""Return True if integer n is palindrome."""
x = integerdigits(n)
return n == fromdigits(reversed(x))
def is_prime(n):
"""Return True if integer n is prime number."""
if n == 2:
return True
elif n % 2 == 0:
return False
else:
max_p = int(math.sqrt(n))
return all(n % p != 0 for p in range(3, max_p+1, 2))
def find_prime_palindrome(upperbound):
for n in reversed(range(upperbound)):
if is_palindrome(n) and is_prime(n):
return n
upperbound = 1000
print find_prime_palindrome(upperbound)
| true |
886eb287181be88f20433007a08dc93bb7fdd82f | yamaton/codeeval | /hard/grid_walk.py | 2,029 | 4.53125 | 5 | #!/usr/bin/env python
# encoding: utf-8
"""
grid_walk.py
Created by Yamato Matsuoka on 2012-07-19.
Description:
There is a monkey which can walk around on a planar grid. The monkey can move one space at a time left, right, up or down. That is, from (x, y) the monkey can go to (x+1, y), (x-1, y), (x, y+1), and (x, y-1). Points where the sum of the digits of the absolute value of the x coordinate plus the sum of the digits of the absolute value of the y coordinate are lesser than or equal to 19 are accessible to the monkey. For example, the point (59, 79) is inaccessible because 5 + 9 + 7 + 9 = 30, which is greater than 19. Another example: the point (-5, -7) is accessible because abs(-5) + abs(-7) = 5 + 7 = 12, which is less than 19. How many points can the monkey access if it starts at (0, 0), including (0, 0) itself?
Input sample:
There is no input for this program.
Output sample:
Print the number of points the monkey can access. It should be printed as an integer — for example, if the number of points is 10, print "10", not "10.0" or "10.00", etc.
"""
def digits_sum(n):
x = 0
quotient = abs(n)
while quotient > 0:
x += quotient % 10
quotient /= 10
return x
def scan_grid():
ini = (0, 0)
queue = [ini]
visited = set([ini])
delta = [(0, 1), (1, 0)]
while queue:
p = queue.pop()
for direction in delta:
x = p[0] + direction[0]
y = p[1] + direction[1]
if is_accessible(x, y) and (x, y) not in visited:
queue.append((x, y))
visited.add((x, y))
return visited
def count(points):
edge_num = len([1 for (x, y) in points if x == y or y == 0]) - 1
inner_num = len(points) - edge_num - 1
return 8 * inner_num + 4 * edge_num + 1
def is_accessible(x, y):
return (0 <= x and 0 <= y and x >= y and
digits_sum(x) + digits_sum(y) <= 19)
def count_grid_walk():
return count(scan_grid())
if __name__ == '__main__':
print count_grid_walk()
| true |
aa4b8ced0ff163c86e0ddcd53608609a0253c138 | yamaton/codeeval | /moderate/jolly_jumpers.py | 1,892 | 4.1875 | 4 | #!/usr/bin/env python
# encoding: utf-8
"""
jolly_jumpers.py
Created by Yamato Matsuoka on 2012-07-17.
Description:
Credits: Programming Challenges by Steven S. Skiena and Miguel A. Revilla
A sequence of n > 0 integers is called a jolly jumper if the absolute values of the differences between successive elements take on all possible values 1 through n - 1. eg.
1 4 2 3
is a jolly jumper, because the absolute differences are 3, 2, and 1, respectively. The definition implies that any sequence of a single integer is a jolly jumper. Write a program to determine whether each of a number of sequences is a jolly jumper.
Input sample:
Your program should accept as its first argument a path to a filename. Each line in this file is one test case. Each test case will contain an integer n < 3000 followed by n integers representing the sequence. The integers are space delimited.
4 1 4 2 3
5 1 4 2 -1 6
Output sample:
For each line of input generate a line of output saying 'Jolly' or 'Not jolly'.
Jolly
Not jolly
"""
import sys
def is_jolly_jumber(seq):
n = len(seq)
if n == 1:
return True
else:
return range(1,n) == sorted(abs(seq[i+1]-seq[i]) for i in range(n-1))
## previous version
#
# def is_jolly_jumber(seq):
# x = len(seq)
# if x == 1:
# return True
# elif x < 1:
# return False
# else:
# if set(abs(seq[i+1]-seq[i]) for i in range(x-1)) == set(range(1,x)):
# return True
# else:
# return False
def jolly_message(tf):
if tf:
return "Jolly"
else:
return "Not jolly"
if __name__ == '__main__':
with open(sys.argv[1], "r") as f:
data = [[int(x) for x in line.rstrip().split()] for line in f if line.rstrip()]
data = [series[1:] for series in data]
out = (is_jolly_jumber(seq) for seq in data)
print "\n".join(jolly_message(x) for x in out)
| true |
6095a278b6d0625b6c4df3738cdac5805657a1d8 | yamaton/codeeval | /moderate/point_in_circle.py2 | 1,346 | 4.28125 | 4 | #!/usr/bin/env python
# encoding: utf-8
"""
point_in_circle.py2
Challenge Description
=====================
Having coordinates of the center of a circle, it's radius and coordinates
of a point you need to define whether this point is located inside of this circle.
## Input sample
Your program should accept as its first argument a path to a filename.
Input example is the following
```
Center: (2.12, -3.48); Radius: 17.22; Point: (16.21, -5)
Center: (5.05, -11); Radius: 21.2; Point: (-31, -45)
Center: (-9.86, 1.95); Radius: 47.28; Point: (6.03, -6.42)
```
All numbers in input are between -100 and 100
## Output sample
Print results in the following way.
```
true
false
true
```
"""
import sys
import re
pattern = r"Center: +\((-?[.0-9]+), +(-?[.0-9]+)\); +Radius: +(-?[.0-9]+); +Point: +\((-?[.0-9]+), (-?[.0-9]+)\)"
regex = re.compile(pattern)
def reader(s):
result = regex.search(s)
(x, y, r, px, py) = map(float, result.groups())
return (x, y, r, px, py)
def is_point_in_circle(x, y, r, px, py):
dist_squared = (x - px)**2 + (y - py)**2
return "true" if dist_squared < r*r else "false"
if __name__ == '__main__':
with open(sys.argv[1], "r") as f:
data = [reader(s) for s in f]
out = [is_point_in_circle(x, y, r, px, py) for (x, y, r, px, py) in data]
for x in out:
print x
| true |
bef391ae6989b5acc9db9e65fa702c8db2e7dd5f | yamaton/codeeval | /easy/capitalize_words.py2 | 710 | 4.625 | 5 | #!/usr/bin/env python
# encoding: utf-8
"""
Challenge Description:
Write a program which capitalizes words in a sentence.
## Input sample
Your program should accept as its first argument a path to a filename. Input example is the following
```
Hello world
javaScript language
a letter
```
## Output sample:
Print capitalized words in the following way.
```
Hello World
JavaScript Language
A Letter
```
"""
import sys
def capitalize_words(words):
return [w[0].upper() + w[1:] for w in words]
if __name__ == '__main__':
with open(sys.argv[1], 'r') as f:
data = [s.split() for s in f]
out = [capitalize_words(words) for words in data]
for line in out:
print(" ".join(line)) | true |
9fe52d300f8ec8941b028519e78f8ac9a4387da2 | yamaton/codeeval | /moderate/cycle_detection.py | 2,596 | 4.125 | 4 | #!/usr/bin/env python
# encoding: utf-8
"""
cycle_detection.py
Created by Yamato Matsuoka on 2012-07-16.
Description:
Given a sequence, write a program to detect cycles within it.
Input sample:
A file containing a sequence of numbers (space delimited). The file can have multiple such lines. e.g
2 0 6 3 1 6 3 1 6 3 1
Ensure to account for numbers that have more than one digit eg. 12. If there is no sequence, ignore that line.
Output sample:
Print to stdout the first sequence you find in each line. Ensure that there are no trailing empty spaces on each line you print. e.g.
6 3 1
"""
import sys
#
# def cycle_detection(seq):
# """
# Detect cycle in seq using Floyd's algorithm.
# http://en.wikipedia.org/wiki/Cycle_detection
#
# This algorithm works given that sequence is as long as you want.
# """
# totoise = 1 # index for totoise
# hare = 2 # index for hare
#
# while seq[totoise] != seq[hare]:
# totoise += 1
# hare += 2
#
# # Find the position of the first repetition of length mu
# mu = 0
# totoise = 0
# while seq[totoise] != seq[hare]:
# totoise += 1
# hare += 1
# mu += 1
#
# # Find the length lam of the shortest cycle starting from seq[mu]
# lam = 1
# hare = totoise + 1
# while seq[totoise] != seq[hare]:
# hare += 1
# lam += 1
#
# return seq[mu:mu+lam]
def detect_cycle(seq):
"""
Crude algorithm to find a cycle such that
- Select the subsequence seq[n:] such that n is the minimum.
- Return 1 cycle orbit of the subsequence.
"""
for n in range(len(seq)):
x = seq[n:]
period = periodicity_len(x)
if period > 0:
return x[:period]
else:
return False
def periodicity_len(seq):
"""
Return length of periodic orbit. seq must NOT contain transient.
0 is returned if seq is aperiodic.
"""
N = len(seq)
head = seq[0]
for i in range(1, N/2):
try:
periodicity = i + seq[i:].index(head)
except ValueError:
continue
if periodicity <= N/2:
if all( seq[k+periodicity] == seq[k] for k in range(N-periodicity) ):
return periodicity
else:
return 0
if __name__ == '__main__':
with open(sys.argv[1], "r") as f:
data = [[int(x) for x in line.rstrip().split()] for line in f if line.rstrip()]
out = (detect_cycle(x) for x in data if detect_cycle(x))
print "\n".join(" ".join(str(i) for i in x) for x in out)
| true |
d4da83831df94855162f5133e602a82621467666 | yamaton/codeeval | /moderate/string_rotation.py | 835 | 4.4375 | 4 | #!/usr/bin/env python
# encoding: utf-8
"""
String Rotation Share on LinkedIn
Description:
You are given two strings. Determine if the second string is a rotation of the first string.
Input sample:
Your program should accept as its first argument a path to a filename. Each line in this file contains two comma separated strings. e.g.
Hello,lloHe
Basefont,tBasefon
Output sample:
Print out True/False if the second string is a rotation of the first. e.g.
True
True
"""
import sys
def if_string_rotation(s, t):
if not len(s) == len(t):
return False
rotated = [s[i:] + s[:i] for i in range(len(s))]
return t in rotated
if __name__ == '__main__':
with open(sys.argv[1], 'r') as f:
data = [line.rstrip().split(',') for line in f]
for (s, t) in data:
print if_string_rotation(s, t)
| true |
8d4ed3c4af0a627a1600f7fea201975bfdbca67e | yamaton/codeeval | /hard/string_list.py | 1,689 | 4.125 | 4 | #!/usr/bin/env python
# encoding: utf-8
"""
string_list.py
Created by Yamato Matsuoka on 2012-07-18.
Description:
Credits: Challenge contributed by Max Demian.
You are given a number N and a string S. Print all of the possible ways to write a string of length N from the characters in string S, comma delimited in alphabetical order.
Input sample:
The first argument will be the path to the input filename containing the test data. Each line in this file is a separate test case. Each line is in the format: N,S i.e. a positive integer, followed by a string (comma separated) eg.
1,aa
2,ab
3,pop
Output sample:
Print all of the possible ways to write a string of length N from the characters in string S comma delimited in alphabetical order, with no duplicates. eg.
a
aa,ab,ba,bb
ooo,oop,opo,opp,poo,pop,ppo,ppp
"""
import sys
import itertools
def deleteduplicates(iterable):
"""Return iterator by remove duplicates"""
seen = []
for x in iterable:
if x not in seen:
yield x
seen.append(x)
def tuples(lis,n):
lis = "".join(deleteduplicates(lis))
out = []
for i in range(n):
out.append(lis)
return sorted("".join(x) for x in itertools.product(*out))
def combinations(s, n):
"""Find all permutations of substring with length n from stirng s"""
return ("".join(x) for x in tuples(s,n))
def read(entry):
(N, string) = entry.rstrip().split(",")
N = int(N)
return (N, string)
if __name__ == '__main__':
with open(sys.argv[1], "r") as f:
data = [read(x) for x in f if x.rstrip()]
out = (combinations(string, N) for (N, string) in data)
print "\n".join(",".join(x) for x in out)
| true |
903201ab083f1fed72d932aa7ae7f1eec9cc8e82 | folkol/tutorials | /python3/4.6.functions.py | 658 | 4.3125 | 4 | def fib(n):
"""Print a Fibonacci series of to n."""
a, b = 0, 1
while a < n:
print(a, end=' ')
a, b = b, a + b
print()
fib(100)
print(fib.__doc__)
def fib_list(n):
"""Returns a list containing the Fibonacci numbers up to n."""
result = []
a, b = 0, 1
while a < n:
result.append(a)
a, b = b, a + b
return result
print(fib_list(100))
def fib(n):
"""Fibonacci generator."""
a, b = 0, 1
while a < n:
yield a
a, b = b, a + b
def fib_list(n):
"""Returns a list containing the Fibonacci numbers up to n."""
return list(fib(n))
print(fib_list(100))
| true |
615fc99fe5103f7a0f9f76ebd0b42272f7804beb | ye-susan/projectEuler | /problem001.py | 603 | 4.28125 | 4 | '''
Problem 1:
If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.
Find the sum of all the multiples of 3 or 5 below 1000.
'''
sum = 0
for num in range(0, 1000):
#if num is divisible by 3 and 5 - add num to sum, else, check that it's divisible by 5 OR 3, or else - ignore it
if (num % 5 == 0) and (num % 3 == 0):
sum += num
else:
# if num is div by 5 OR 3, add to sum
if (num % 5 == 0) or (num % 3 == 0):
sum += num
print(sum)
#This code ouputted solution in 0.125 seconds | true |
221cb87c96becce61f3dad6a7fbde4fff4b070eb | BXGrzesiek/Python_Projects | /scripts/fib.py | 934 | 4.3125 | 4 | # script generating a list with fibonacci sequence elements
# the user is asked for the number of elements
# to reduce the load of computing power,
# the list is displayed after all X elements have been generated
from time import sleep
def fib(n):
try:
if n == 0:
return 0
elif n == 1:
return 1
else:
return fib(n - 2)+fib(n - 1)
except ValueError:
print('Only positive integer!')
choice = 'y'
while choice == 'y' or choice == 'Y':
print('Series of Fibonacci numbers')
print('\n'*5)
n = int(input('How deep you want to go? : '))
print(type(n))
elements = []
for i in range(n):
elements.append(fib(i))
print(elements)
choice = input('You want to try again? [Y/n] ')
if choice == 'y' or choice == 'Y':
print('Clearing the screen')
sleep(3)
print('\n'*30)
else:
break | true |
721e2ff5de164b072bab578c5696097ea5b75453 | NielRoman/BSIT302_activity1 | /Enployee.py | 1,553 | 4.3125 | 4 | Employee = []
class employ:
def __init__(self, name, department, position, rate):
self.name = name
self.department = department
self.position = position
self.rate = rate
list = True
while list:
print("""
************************************
Choose Your Option:
[1] Add New Employee's Name
[2] Enter Hourly Rate Of New Employee
[3] Show Employee's Information
[4] Exit
""")
list = input ("Enter An Option: ")
if list == "1":
name = str(input("Enter New Employee's Name: "))
department = str(input("Enter New Employee's Department: "))
position = str(input("Enter New Employee's Position: "))
rate = int(input("Enter New Employee's Rate: "))
Employee.append(name)
Employee.append(department)
Employee.append(position)
Employee.append(rate)
print("The given information are saved!")
elif list == "2":
num1 = int(input("Enter Employee's Number: "))
hour = int(input("Enter Employee's Hours: "))
num2 = rate
finResult = hour * num2
print("The employee's salary for {} hours, with a rate of ${} per hour, will be ${}".format(hour, num2, finResult))
print("The given information are saved!")
elif list == "3":
print ("""************************************
Employee's Number: {}
Employee's Name: {}
Employee's Department: {}
Employee's Position: {}
Employee's Hourly Rate: {}
Employee's Working Hours: {}""".format(num1, name, department, position, rate, hour))
elif list == "4":
print("End Of Your Session.")
else:
print("The user has entered an invalid syntax.") | true |
031f6125cfcc9048ef8ef7826828a3a2fc671d70 | spettigrew/cs2-codesignal-mod-quizzes | /problem_solving/postive_sum.py | 979 | 4.25 | 4 | """
Given an array of integers, return the sum of all the positive integers in the array.
Examples:
csSumOfPositive([1, 2, 3, -4, 5]) -> 1 + 2 + 3 + 5 = 11
csSumOfPositive([-3, -2, -1, 0, 1]) -> 1
csSumOfPositive([-3, -2]) -> 0
Notes:
If the input_arr does not contain any positive integers, the default sum should be 0.
[execution time limit] 4 seconds (py3)
[input] array.integer input_arr
[output] integer
"""
def csSumOfPositive(input_arr):
# U - return all postive numbers
# set numbers to 0
numbers = 0
# make sure sum does not include negative numbers. nums > 0
return sum(numbers for numbers in input_arr if numbers > 0)
# def csSumOfPositive(input_arr):
# # create the variable we will return
# positive_sum = 0
# # loop over the array, check if each number is positive, if it is, add to positive_sum
# for num in input_arr:
# if num > 0:
# positive_sum += num
#
#
# return positive_sum
| true |
f10ab0281a1c0cd70ab11f07d79e37e062f1b0d9 | spettigrew/cs2-codesignal-mod-quizzes | /computer_memory_basics/raindrops.py | 1,586 | 4.5625 | 5 | """
Given a number, write a function that converts that number into a string that contains "raindrop sounds" corresponding to certain potential factors. A factor is a number that evenly divides into another number, leaving no remainder. The simplest way to test if one number is a factor of another is to use the modulo operator.
Here are the rules for csRaindrop. If the input number:
has 3 as a factor, add "Pling" to the result.
has 5 as a factor, add "Plang" to the result.
has 7 as a factor, add "Plong" to the result.
does not have any of 3, 5, or 7 as a factor, the result should be the digits of the input number.
Examples:
csRaindrops(28) -> "Plong"
28 has 7 as a factor, but not 3 or 5.
csRaindrops(30) -> "PlingPlang"
30 has both 3 and 5 as factors, but not 7.
csRaindrops(34) -> "34"
34 is not factored by 3, 5, or 7.
[execution time limit] 4 seconds (py3)
[input] integer number
[output] string
"""
def csRaindrops(number):
# U - 105 is divisible by 3, 5 and 7. or 28% 7 = 0 is the remainder
answer_string = ""
# if number is divisible by 3
# add Pling
if number % 3 == 0:
answer_string += "Pling"
# if number is divisible by 5
# add Plang
if number % 5 == 0:
answer_string += "Plang"
# if number is divisible by 7
# add Plong
if number % 7 == 0:
answer_string += "Plong"
# if not divisible by any of those
# return the number as a string
if answer_string == "":
# str converts number to a string
answer_string = str(number)
return answer_string | true |
1bf90ec0db09546d69f3b08820a6f395b60c3716 | spettigrew/cs2-codesignal-mod-quizzes | /problem_solving/remove_vowels.py | 1,237 | 4.21875 | 4 | """Given a string, return a new string with all the vowels removed.
Examples:
csRemoveTheVowels("Lambda School is awesome!") -> "Lmbd Schl s wsm!"
Notes:
For this challenge, "y" is not considered a vowel.
[execution time limit] 4 seconds (py3)
[input] string input_str
[output] string
"""
def csRemoveTheVowels(input_str):
# U -remove vowels in the string.
# set vowels (upper and lower) to have removed
vowels = "AaEeIiOoUu"
# iterate through the string get all vowels
for vowel in vowels:
if vowel in input_str:
# if there is a vowel,replace it with empty ''
input_str = input_str.replace(vowel, '')
# return input_str
return input_str
# def csRemoveTheVowels(input_str):
# # create a set of all vowels to use when we are checking if a character is a vowel
# vowel_set = ('a', 'e','i', 'o', 'u')
# # we will build a new string that has no vowels
# result_str = ''
# # loop over each character, and check if its a vowel
# # if its a vowel, DO NOT add it to result_str, otherwise, add to result
# for i in input_str:
# if i.lower() not in vowel_set:
# result_str += i
# return result_str | true |
ca75c458d27e49fd0f540b9869f75b5831b2d956 | cs-fullstack-2019-fall/python-basics2f-cw-LilPrice-Code | /index.py | 2,293 | 4.375 | 4 | import random
# Problem 1:
#
# Write some Python code that has three variables called greeting, my_name, and my_age.
# Intialize each of the 3 variables with an appropriate value,
# then rint out the example below using the 3 variables and two different approaches for formatting Strings.
#
# Using concatenation and the + and 2) Using an f-string. Sample output:
# YOUR_GREETING_VARIABLE YOUR_NAME_VARIABLE!!! I hear that you are YOUR_MY_AGE_VARIABLE today!
greeting = ("Heyo")
myName = ("Shoshard")
myAgge = ("22")
print(f'{greeting} {myName}!!! I hear that you are {myAgge} today!')
# you did not include a version using concatenation
# Problem 2:
#
# Write some Python code that asks the user for a secret password.
# Create a loop that quits with the user's quit word. If the user doesn't enter that word, ask them to guess again.
#
secr = ("red")
# the secret password should be defined by the user not hard coded
user = ""
while user != secr:
user = input("Enter the password\n")
# Problem 3:
#
# Write some Python code using f-strings that prints 0 to 50 three times in a row (vertically).
#
# 1 1 1
# 2 2 2
# 3 3 3
# 4 4 4
# 5 5 5
# .
# .
# .
num1 = 1
while num1 <= 50:
print(f'{num1} {num1} {num1}')
num1 += 1
# Problem 4:
#
# Write some Python code that create a random number and stores it in a variable.
# Ask the user to guess the random number. Keep letting the user guess until they get it right, then quit.
#
ran = random.randint(1,10)
user = 0
while user != ran:
user = int(input("Guess the random between 1 and 10\n"))
# Challenge
#
# Write some Python code to ask the user to create a number for the computer to guess between 1 - 10000.
# Write the code so that the computer guesses random numbers between 1 - 10000 and
# will keep guessing until the computer guesses the number correctly. Once the computer guesses the random number,
# alert the user with an alert box that displays how many guesses it took to guess the random number.
user = int(input("Enter a number between 1 and 10,000\n"))
tryies = 0
while user > 0 and user < 10001:
ran = random.randint(1,10000)
if ran == user:
print("It took the computer " + str(tryies) + " tries to guess your number.")
break
else:
tryies +=1 | true |
90f8097c9451b5b17d5ee2035206eb7e9dbea17a | SaCut/data_collections | /lists&tuples.py | 794 | 4.1875 | 4 | # creating a list
# shopping_list = ["bread", "chocolate", "avocados", "milk"]
# # 0 1 2 3
# print(shopping_list)
# print(type(shopping_list))
# list indexing
# print(shopping_list[0])
# # change a value in the list
# shopping_list[0] = "orange"
# print(shopping_list)
# # add a value to a list
# shopping_list.append("ice-cream")
# print(shopping_list)
# # remove an item from a list
# shopping_list.remove(shopping_list[0])
# print(shopping_list)
# # can we mix data types in a list? yes
# open_minded_list = [1, 2, 3, "one", "two", "three"]
# tuples
essentials = ("paracetamol", "tooth paste", "tea bags")
print(essentials)
print(type(essentials))
# essentials[0] = "cereal" gives back an error, because tuples don't support variable reassignment
print(essentials[0]) | true |
c99cb40b55ea8c0f8da481e3c76bcc730d882581 | lincrampton/pythonHackerRankLeetCode | /swapCase.py | 504 | 4.375 | 4 | '''return a string that has upperCase->lowerCase and lowerCase->upperCase
e.g., 'I am Sam I am!" would become "i AM sAM iAM!"
def swap_case(s):
return_string = ""
for i in range(len(s)):
if s[i].islower():
return_string += s[i].upper()
elif s[i].isupper():
return_string += s[i].lower()
else:
return_string += s[i]
return return_string
if __name__ == '__main__':
s = input()
result = swap_case(s)
print(result)
| true |
54482b0ebb8235fb66db096fc1dbe569061751ae | lincrampton/pythonHackerRankLeetCode | /string2npArray.py | 284 | 4.4375 | 4 | '''You are given a space separated list of numbers.
Your task is to print a reversed NumPy array with the element type float.'''''
linzStr = " 2 3 4 5"
linzLst = list(map(int,linzStr.split()))
linzLst = linzLst[::-1]
import numpy as np
linzNp = np.array(linzLst, float)
print(linzNp)
| true |
4616f70fc68c11cfa89707aadd60446df02fd481 | luroto/lpthw | /ex6.py | 691 | 4.4375 | 4 | # Setting a first variable
types_of_people = 10
# Creating a string using this variable
x = f"There are {types_of_people} types of people."
#Setting two more variables
binary = "binary"
do_not = "don't"
# Another string using variables and f option
y = f"Those who know {binary} and those who {do_not}."
# setting variables
print(x)
print(y)
# printing strings
print(f"I said: {x}")
print(f"I also said: '{y}'")
hilarious = False
joke_evaluation = "Isn't that joke so funny?! {}"
# using the format option for the first time on this course
print(joke_evaluation.format(hilarious))
w = "This is the left side of ..."
e = "a string with a right side."
# adding two strings
print(w + e)
| true |
f27ec99e5fa2e7136bc85e98bc0ff208b21e14b2 | MDGSF/PythonPractice | /commonfunction/buildin/any.py | 555 | 4.125 | 4 | #!/usr/bin/env python
# -*- coding: UTF-8 -*-
# any(iterable)
# Return True if any element of the iterable is true. If the iterable is empty, return False.
def main():
a_list = []
print(any(a_list)) # False
b_list = [True, True]
print(any(b_list)) # True
c_list = [True, True, False]
print(any(c_list)) # True
d_list = ['a', 'b', 'c', '']
print(any(d_list)) # True
e_list = ['a', 'b', 'c']
print(any(e_list)) # True
f_list = ['']
print(any(f_list)) # False
if __name__ == "__main__":
main() | true |
c98c71fc4004811f052f309a22077b557e24aa85 | pranithsrujanroy/cpl-dwm | /test/knn_10p_missing.py | 2,648 | 4.21875 | 4 | # -*- coding: utf-8 -*-
"""
Created on Tue Sep 11 13:29:39 2018
@author: Student
Assignment 5
1. Find a suitable value of k for a given dataset " CAR EVALUATION DATASET". Use the obtained K-value for developing KNN Classifier.
Report the classification accuracy.
"""
import csv #for importing csv data file
import helper_functions
#Read the CSV file into the python environment
data_list = []
with open('../test/data.txt', 'rt') as csvfile:
read_obj = csv.reader(csvfile, delimiter = ',')
for row in read_obj:
data_list.append(row)
#field_headings = data_list[0]
#data_list.remove(data_list[0])
#print("Attribute headings are : ",field_headings)
complete_data = data_list
#PREPROCESSING DATA AND SHUFFLING
clean_data = pre_process_data(data_list)
#clean_data = data_list
import random
clean_data_shuffled = clean_data
random.shuffle(clean_data_shuffled)
print(clean_data[2])
TOTAL_RECORDS = len(clean_data)
TRAINING_SIZE = int(0.05 * TOTAL_RECORDS)
TESTING_SIZE = TOTAL_RECORDS - TRAINING_SIZE
print("TRAINING SIZE: ",TRAINING_SIZE, " TESTING SIZE : ",TESTING_SIZE)
#TESTING AND TRAINING DATA
training_data_list = clean_data_shuffled[0:TRAINING_SIZE]
testing_data_list = clean_data_shuffled[TRAINING_SIZE:TOTAL_RECORDS]
training_data = []
training_data_labels = []
for record in training_data_list:
training_data.append(record[0:4])
training_data_labels.append(record[4])
testing_data = []
testing_data_labels = []
for record in testing_data_list:
testing_data.append(record[0:4])
testing_data_labels.append(record[4])
#CALCULATING k
error_matrix = []
for k in range(1,2):
k = 5 #found
correct_classified = 0
incorrect_classified = 0
error = 0
for record,label in zip(testing_data,testing_data_labels):
nearest_neighbours,labels = k_nearest_neighbours(record,k,training_data,training_data_labels)
pred_label = predict(record,nearest_neighbours,labels)
if(pred_label == label):
correct_classified = correct_classified + 1
#print("S")
else:
incorrect_classified = incorrect_classified + 1
#print("F")
#print(pred_label,label)
error = incorrect_classified / (correct_classified + incorrect_classified)
error_matrix.append(error)
print(k,error)
#print("k:",k," Correct:",correct_classified," Incorrect:",incorrect_classified," Error:",error," Accuracy:",1-error)
#print(error_matrix)
#import matplotlib.pylot as plt
#plt.xlabel("k")
#plt.ylabel("error")
#plt.plot(error_matrix)
| true |
4efe0803924322c8fce38b16d4ece218a8aa8ad3 | peefer66/100doc | /day 22_30/Day 30 Error handling & JSON/Start/main.py | 625 | 4.21875 | 4 | # Error catching
try:
file = open('my_text_file.txt')
a_dict = {'key':'value'}
print(a_dict['key'])
except FileNotFoundError:
file = open('my_text_file.txt','w')
file.write('Somthing')
except KeyError as error_message:
print(f'The key {error_message} does not exist')
else:
content = file.read()
print(content)
finally:
file.close()
print('File was closed')
#### Raise your own exception
height = float(input('Enter height(m): '))
weight = int(input('Enter weight(kg): '))
if height > 3:
raise ValueError('Human height should not be above 3m')
bmi = weight/height**2
print(bmi) | true |
0e58e2d7390beb447817ff85d0ac87bb0d942a46 | surge55/hello-world | /02-MIT6x/2 Core Elements/for.py | 1,165 | 4.375 | 4 | ################################################################################
## Course: MITx 6.001x - Intro to CS and Programming Using Python
## Student: surge55
## Date: June 16, 2022
## Exercise: for
## In this problem you'll be given a chance to practice writing some for loops.
################################################################################
# 1. Convert the following code into code that uses a for loop
# prints 2
# prints 4
# prints 6
# prints 8
# prints 10
# prints Goodbye!
print("EXERCISE 1:")
for i in range(2, 12, 2):
print(i)
print('Goodbye!')
# 2. Convert the following code into code that uses a for loop
# prints Hello!
# prints 10
# prints 8
# prints 6
# prints 4
# prints 2
print("EXERCISE 2:")
print('Hello!')
for i in range(10, 0, -2):
print(i)
# 3. Write a for loop that sums the values 1 through `end`, inclusive. `end` is a variable that we define for you.
# So, for example, if we define `end` to be 6, your code should print the result (21). Which is 1 + 2 + 3 + 4 + 5 + 6
# DO NOT USE a variable called `sum`
print("EXERCISE 3:")
end = 6
total = 0
for n in range(end+1):
total += n
print(total) | true |
be422176cf425a3cd2d7206f42891b40fb1e35c6 | surge55/hello-world | /01-PY4E/01-why_program/wordfind.py | 979 | 4.28125 | 4 | ###############################################################
## File Name: wordfind.py
## File Type: Python File
## Author: surge55
## Course: Python 4 Everybody
## Chapter: Chapter 1 - Why Would you Learn Programming
## Excercise: n/a
## Description: Code walkthrough from book
## Other References: http://www.py4e.com/code3/words.py
###############################################################
# 1.8 - What is a program?
name = input('Enter file:')
handle = open(name, 'r')
counts = dict()
for line in handle:
words = line.split()
for word in words:
counts[word] = counts.get(word,0) + 1
bigcount = None
bigword = None
for word, count in list(counts.items()):
if bigcount is None or count > bigcount:
bigword = word
bigcount = count
print(bigword, bigcount)
# You will need to get through Chapter 10 to fully understand
# the awesome Python techniques that were used to make this program.
| true |
ef39a27ed5643fcec06397894d54eb3965e38863 | clairejrlin/stanCode_projects | /stanCode_Projects/boggle_game_solver/anagram.py | 2,828 | 4.1875 | 4 | """
File: anagram.py
Name: Claire Lin
----------------------------------
This program recursively finds all the anagram(s)
for the word input by user and terminates when the
input string matches the EXIT constant defined
at line 19
If you correctly implement this program, you should see the
number of anagrams for each word listed below:
* arm -> 3 anagrams
* contains -> 5 anagrams
* stop -> 6 anagrams
* tesla -> 10 anagrams
* spear -> 12 anagrams
"""
# Constants
FILE = 'dictionary.txt' # This is the filename of an English dictionary
EXIT = '-1' # Controls when to stop the loop
# Global variables
dictionary = []
def main():
print('Welcome to stanCode \"Anagram Generator\" (or -1 to quit)')
while True:
word = input('Find anagram for: ')
word = word.lower()
if word == EXIT:
break
else:
find_anagrams(word)
def read_dictionary():
global dictionary
with open(FILE, 'r') as f:
for line in f:
word_dict = line.strip()
dictionary.append(word_dict)
# print(dictionary)
def find_anagrams(s):
"""
:param s: str, the input which will be arranged.
:return: str, the total arranged words.
"""
find_lst, s_lst, result = [], [], []
read_dictionary()
for ele in s:
s_lst.append(ele)
find_anagrams_helper(s, find_lst, result, s_lst)
print(str(len(result)) + ' anagram: ' + str(result))
def find_anagrams_helper(s, find_lst, result, s_lst):
"""
:param s: str, the input which will be arranged.
:param find_lst: lst, the arranged alpha-word will be store here temporarily.
:param result: lst, the final arranged word store in this list, and will be printed.
:param s_lst: lst, for dealing with the repeated alpha-word.
:return: lst, the arranged words.
"""
global dictionary
n = ''
for word in find_lst:
n += word
if len(n) == len(s):
if n in dictionary and n not in result: # base case
print('Found: ' + str(n))
print('Searching...')
result.append(n)
else:
for i in range(len(s)): # Thanks to Willie for helping me debug.
if s[i] not in find_lst or s[i] in s_lst:
find_lst.append(s[i])
s_lst.remove(s[i])
if has_prefix(n):
find_anagrams_helper(s, find_lst, result, s_lst)
find_lst.pop()
s_lst.append(s[i])
def has_prefix(sub_s):
"""
:param sub_s: str, the first few words in s.
:return: bool, True or False.
"""
global dictionary
for i in dictionary:
if i.startswith(sub_s):
if sub_s in i:
return True
return False
if __name__ == '__main__':
main()
| true |
78dd1d37cdc8033f5f4f1280cd003b5a2fef579a | JagadeeshLTTS/Python_assignment_Genesis2021_99004951 | /Ass_Qn-9.py | 1,258 | 4.15625 | 4 | def actualDate(date, month, year):
while(month>12 or date>31 or (month==2 and date>29 and year%400==0) or (month==2 and date>28 and year%400!=0)):
year=year+(month//12)
month=month%12
if(month==1 or month==3 or month==5 or month==7 or month==8 or month==10 or month==12):
if(date>31):
month=month+(date//31)
date=date%31
if (month == 4 or month == 6 or month == 9 or month == 11):
if (date > 30):
month = month + (date // 30)
date = date % 30
if(month==2 and (year%400==0)):
if(date>29):
month = month + (date // 29)
date = date % 29
else:
if(date>28):
month = month + (date // 28)
date = date % 28
date=[date,month,year]
return date
if __name__ == '__main__':
date=int(input("Enter date: "))
month=int(input("Enter month "))
year = int(input("Enter year: "))
correct_date=[]
correct_date=actualDate(date,month,year)
print("Entered date is:", end=" ")
print(date, ":", month, ":", year)
print("Actual date is:",end=" ")
print(correct_date[0],":",correct_date[1],":",correct_date[2]) | true |
e5737aa69e81287528899376a67fc6e096c9a08f | DmitriiTitkov/python_practice_learning | /ex2/main.py | 673 | 4.28125 | 4 | def divide_numbers(num1, num2):
"""This function checks if one number can be divided to other without remnant"""
if isinstance(num1, int) and isinstance(num2, int):
result = num1 % num2
if result == 0:
if num2 != 4:
print("Number {} can be divided to number {} without remnant".format(num1, num2))
else:
print("Can be divided to 4")
else:
print("Remnant is: " + str(result))
else:
raise Exception("Wrong arguments passed to function")
check = int(input("please type first number: "))
num = int(input("please type second number: "))
divide_numbers(check, num)
| true |
49b3857ebdaac0c5a7c86f4fd92debfcec5f66ff | vibhore-vg/Learning-Python | /advancedExamples/dict_3.py | 544 | 4.25 | 4 | #Python that counts letter frequencies
# The first three letters are repeated.
letters = "abcabcdefghi"
frequencies = {}
for c in letters:
# If no key exists, get returns the value 0.
# ... We then add one to increase the frequency.
# ... So we start at 1 and progress to 2 and then 3.
frequencies[c] = frequencies.get(c, 0) + 1
for f in frequencies.items():
# Print the tuple pair.
print(f)
"""
Output
('a', 2)
('c', 2)
('b', 2)
('e', 1)
('d', 1)
('g', 1)
('f', 1)
('i', 1)
('h', 1)
""" | true |
827d16eafdd4f252eae58dd02931234d72ec2d52 | JarredStanford/Intro-Python-I | /src/14_cal.py | 1,249 | 4.46875 | 4 | """
The Python standard library's 'calendar' module allows you to
render a calendar to your terminal.
https://docs.python.org/3.6/library/calendar.html
Write a program that accepts user input of the form
`14_cal.py month [year]`
and does the following:
- If the user doesn't specify any input, your program should
print the calendar for the current month. The 'datetime'
module may be helpful for this.
- If the user specifies one argument, assume they passed in a
month and render the calendar for that month of the current year.
- If the user specifies two arguments, assume they passed in
both the month and the year. Render the calendar for that
month and year.
- Otherwise, print a usage statement to the terminal indicating
the format that your program expects arguments to be given.
Then exit the program.
"""
import sys
import calendar
from datetime import date
if sys.argv[2] is None:
print("lol")
today = date.today()
try:
month = int(sys.argv[1])
except:
month = today.month
try:
year = int(sys.argv[2][1:-1])
except:
year = today.year
if len(sys.argv) > 3:
print('Please enter no more than 2 variables: a month and a [year].')
else:
print(calendar.monthcalendar(year, month))
| true |
567496a8ee5849b1c0d80312f57067b4342d7050 | Roberick313/Workshop | /project_4.py | 504 | 4.21875 | 4 | ###### Fibonacci number
def fibonacci(number):
'''This function will calculate the fibonacci of the\n
\rEntery parameter'''
b = 0
result = ''
c = 1
for _ in range(1,number+1):
while b < number:
result += str(b) + ","
b = b+c
if c < number:
result += str(c)+ ','
c = b+c
if result.endswith(','):
result = result.removesuffix(',')
return result
| true |
c6ead19db12ad137036599239bcfd0d2c61fdb2e | oryband/code-playground | /sliding-window/medium-truncate-str-by-k.py | 2,173 | 4.15625 | 4 | #/usr/bin/env python
"""
Given a string constructed from ascii chars and spaces, and a non-negative integer k,
truncate the message to size k or less, while also stripping spaces such that the result
must end with a word. also, words must not be truncated in the middle. either include
whole words or non at all. examples:
'The quick brown fox jumps over the lazy dog', 39 --> 'The quick brown fox jumps over the lazy'
'Codility We test coders', 14 --> 'Codility We'
"""
def trunc_str_by_k(msg, k):
# print('DEBUG "{}"'.format(msg[:k]))
# edge case for truncating everything
# or if k surpasses message length
if k == 0 or k >= len(msg):
return msg[:k].rstrip()
# if the last char in truncated message is the last char of its word,
# return the string as it is.
#
# otherwise (the char isn't the last char of its word),
# remove the entire word containing this char.
i = k-1
if msg[k-1] != ' ' and msg[k] != ' ': # NOTE k < len(message)
while i >= 0 and msg[i] != ' ':
i -= 1
# strip remaining spaces from the right
return msg[:i+1].rstrip()
if __name__ == '__main__':
print('"{}"'.format(trunc_str_by_k('Codility We test coders', 14)))
print('"{}"'.format(trunc_str_by_k('The quick brown fox jumps over the lazy dog', 38)))
print('"{}"'.format(trunc_str_by_k('The quick brown fox jumps over the lazy dog', 39)))
print('"{}"'.format(trunc_str_by_k('The quick brown fox jumps over the lazy dog', 40)))
print('"{}"'.format(trunc_str_by_k('The quick brown fox jumps over the lazy dog', 41)))
print('"{}"'.format(trunc_str_by_k('The quick brown fox jumps over the lazy dog', 42)))
print('"{}"'.format(trunc_str_by_k('The quick brown fox jumps over the lazy dog', 43)))
print('"{}"'.format(trunc_str_by_k('The quick brown fox jumps over the lazy dog', 44)))
print('"{}"'.format(trunc_str_by_k('The quick brown fox jumps over the lazy dog', 45)))
print('"{}"'.format(trunc_str_by_k('aaa aaa', 0)))
print('"{}"'.format(trunc_str_by_k('a', 1)))
print('"{}"'.format(trunc_str_by_k('', 2)))
print('"{}"'.format(trunc_str_by_k(' ', 2)))
| true |
2c7bb1d9e25306149e166a3d3eb5f35971d35f30 | kkundann/Algorithm | /BasicPython.py | 677 | 4.375 | 4 | # developed by van Rossum in 1991
# difference between Python 2 and python 3
# python 2:- print statement is not print_function
# python 3: has function and invoked with parantheses
# print ("Hello, World.")
#
# print(type('default string '))
# print(type(b'string with b '))
#
# for i in range(0,5):
# print(i)
#python function decorator
# In Python, we can define a function inside another function.
# In Python, a function can be passed as parameter to another function (a function can also return another function
def abc(str):
def xyz():
return "Welcome to "
return xyz()+str
def site(site_name):
return site_name
print abc(site("GreeksforGeeks")) | true |
a6586ccae2d752536921d497d08d681e72ce182c | H4rliquinn/Intro-Python-I | /src/14_cal.py | 1,842 | 4.53125 | 5 | """
The Python standard library's 'calendar' module allows you to
render a calendar to your terminal.
https://docs.python.org/3.6/library/calendar.html
Write a program that accepts user input of the form
`14_cal.py month [year]`
and does the following:
- If the user doesn't specify any input, your program should
print the calendar for the current month. The 'datetime'
module may be helpful for this.
- If the user specifies one argument, assume they passed in a
month and render the calendar for that month of the current year.
- If the user specifies two arguments, assume they passed in
both the month and the year. Render the calendar for that
month and year.
- Otherwise, print a usage statement to the terminal indicating
the format that your program expects arguments to be given.
Then exit the program.
"""
import sys
import calendar
from datetime import datetime
def rules():
print('Include a month to see that calendar\nInclude a month and year for years other than 2020\n')
def show_calendar(args):
now = datetime.now()
if len(args) > 2:
if test_month(args[1]) and test_year(args[2]):
month = int(args[1])
year = int(args[2])
else:
return False
elif len(args) == 2:
if test_month(args[1]):
month = int(args[1])
year = now.year
else:
return False
else:
month = now.month
year = now.year
cal = calendar.TextCalendar(firstweekday=0)
print(cal.formatmonth(year, month, w=0, l=0))
return True
def test_month(month):
if not month.isdigit() or int(month) > 12:
return False
return True
def test_year(year):
if not year.isdigit():
return False
return True
# main program
if not show_calendar(sys.argv):
rules()
| true |
d3857af92ea1df200f76ed3b09235129a11660b5 | alhung/gameoflife | /src/main.py | 2,472 | 4.4375 | 4 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Game of Life
This program is an implementation of Conway's game of life.
The purpose of the game is to calculate the next state/generation
of a multidimensional grid given an initial state/generation of the grid
This implementation resembles a forecasting/prediction model
Assumptions for Implementation:
- Dealing with 2D grids
- Calculating only its next generation?
- No live cell off the edges (does this mean edge cells are blank?)
"""
import numpy as np
#import pickle as pk
# get # rows
def rows():
numRow = input("Type number of rows (in digits): ")
numRow_int = int(numRow)
return numRow_int
# get # columns
def columns():
numCol = input("Type number of columns (in digits): ")
numCol_int = int(numCol)
return numCol_int
# create initial random grid sized by user
def random_grid(x,y):
randomgrid = np.random.randint(2, size=(x,y))
print ("You elected to create a {} x {} grid".format(x, y))
print (randomgrid)
return randomgrid
# create random first generation seed file with initial state
#def seed(grid,x,y):
# filename = "seeding"
# with open(filename, "w") as f:
# f.write(grid)
# np.save(f, grid)
# pk.dump(grid,f)
# print ("\n2) Grid file was created, please open it and update any desired 0 to 1")
# input ("\nPress enter after the Grid File has been updated and saved")
# print("\nBelow is your initial state")
# with open(filename, "r") as f:
# values = f.read()
# print(values)
# return values
# ID Moore location - identify corner, noncorner edge, or central
def mooresq(first):
# x = 0
# y = 0
# c = np.array(x,y)
# for r in first:
# for c in first:
# setup cartesian
# x = np.linspace(-1,1,3)
# y = np.linspace(-1,1,3)
# xx,yy = np.meshgrid(x,y)
# print (xx)
# print (yy)
# count num datapoints as neighbors available
# x = np.array([-1, 0, 1]);
# y = np.array([-1, 0, 1]);
# coordinates = np.array(x, y)
# print (coordinates)
# for i in np.nditer(first):
# num = first.index(i)
def main():
print ("\nWelcome to Conway's Game of Life\n")
print ("\nPlease follow below instructions to create your desired initial state\n")
print ("Select Random Grid Size:")
x = rows()
y = columns()
first = random_grid(x,y)
next = mooresq(first)
#if __name__ =='__main__':
#main(sys.argv)
main()
| true |
0c957382dea60d860597e4702ecebc35bfab6861 | kannan-c1609/Accenture | /38_Upper_and_Lower_case.py | 891 | 4.125 | 4 | """
Single File Programming Question
Write a Python program that accepts a string and calculate the number of upper case letters and lower case letters.
Input Format:
A string in the first line
Output Format:
Print the original string in the first line.
Number of upper case characters in the second line
Number of lower case characters in the third line
Refer to the sample output for the exact format
Sample testcases
Input 1:
The quick Brown Fox
Output 1:
The quick Brown Fox
Upper case characters : 3
Lower case characters : 13
"""
def fun(n):
lower = 0
upper = 0
for i in n:
if(i.isupper()):
upper = upper + 1
if(i.islower()):
lower = lower + 1
return upper, lower
n = input()
a , b = fun(n)
print(n)
print("Upper case characters : %d"%a)
print("Lower case characters : %d"%b)
| true |
22e44b6fbe19de104ad494f2c2bd15532455acf7 | kannan-c1609/Accenture | /13_SumOfDivisors.py | 579 | 4.125 | 4 | """
Sum of Divisors
Given an integer ‘n’ (1 <= n <= 109), find the sum of its unique divisors.
Input Specification:
Input 1: the integer ‘n’
Output Specification:
Return the sum of divisors of ‘n’.
Example 1:
Input 1: 6
Output: 12
Explanation:
Divisors of 6 are 1, 2, 3 and 6. Sum od number (i.e 1 + 2 + 3 + 6) is 12
Example 2:
Input1: 36
Output: 91
"""
def sumOfDivisors(n):
sum = 0
for i in range(1, n+1):
if(n % i == 0):
sum = sum + i
return sum
n = int(input())
print(sumOfDivisors(n))
| true |
c4e26bd35da92d65d95db31784699242b0cbefee | kannan-c1609/Accenture | /28_Greeting.py | 288 | 4.125 | 4 | """
Create a program that take a name as input and returns a greeting.
Examples Input:
Gerald
Example Output:
Hello Gerald!
Examples Input:
Tiffany
Example Output:
Hello Tiffany!
"""
def Greeting(n):
return 'Hello ' + n + '!'
n = input()
print(Greeting(n))
| true |
8cd48dd8c97dc1a53ada6678bd4cf3d3c1063325 | kannan-c1609/Accenture | /33_Maxima_or_minima.py | 1,083 | 4.15625 | 4 | """
Implement the following function:
int MaximaOrMinima(int a, int b, int c);
Quadratic equation: A quadratic equation is any equation having the form, ax2 + bx + c, where ‘a’ cannot be zero.
The function accepts coefficients of a quadratic equation, ‘a’, ‘b’ and ‘c’ as its argument. Implement the function to find the maximum or minimum value of quadratic equation by substituting integer values x, where – 100 <= x <= 100. Return the values as follows:
• if a > 0, return the minimum value of the equation.
• if a < 0, return the maximum value of the equation.
Assumption: a is not equal to zero.
Note: Computer value lies within integer range
Example:
Input:
a: 1
b: 2
c: 1
Output:
0
Explanation:
Since, (a > 0) output is the minimum value which is at x = – 1, output = 1 * (– 1)2 + 2 * (– 1) + 1 = 0.
Sample Input:
a: – 2
b: – 8
c: 10
Sample Output:
18
"""
def fun(a, b, c):
return (a * (-1*-1)) + (b * -1) + c
a = int(input())
b = int(input())
c = int(input())
print(fun(a, b, c))
| true |
8d8afbe05d6b642fbfcf39aebe148abbb9afc2c7 | AmanKishore/CodingChallenges | /Cracking the Coding Interview/Sorting and Searching/GroupAnagrams.py | 784 | 4.34375 | 4 | '''
Group Anagrams:
Write a method to sort an array of strings so that all of the anagrams are next to each other.
'''
def GroupAnagrams(strings):
anagrams = {}
for i in range(len(strings)):
key = "".join(sorted(strings[i].lower())) # get the key by sorting the string
if key not in anagrams: # Check if dictionary has the key
anagrams[key] = [] # Add the key with a list
anagrams[key].append(strings[i]) # Add the string to the list
keys = anagrams.keys()
index = 0
for i in range(len(keys)): # Build the sorted list
values = anagrams.get(keys[i])
for j in range(len(values)): # Looping through every value in the key list
strings[index] = values[j]
index += 1
return strings | true |
6a1ae5ee59a0f726995e79ef161e79cf4a5c16de | vardhan-duvvuri/Challange | /ch23.py | 230 | 4.125 | 4 | def reverseLookup(dictionary, value):
output = []
for key,val in dictionary.iteritems():
if val == value:
output.append(key)
return sorted(output)
if __name__ == "__main__":
print reverseLookup({'a':1, 'b':2, 'c':2}, 2)
| true |
1d6bc423fc32cec33981e5c4a10b61d59959ddf7 | jb4503/PHYS4100_JBermeo | /Problem2.py | 1,648 | 4.40625 | 4 | import math
import argparse
import sys
# A spaceship travels from Earth in a straight line at relativistic speed v to another planet x light years away.
# Write a program to ask the user for the value of x and the speed v as a fraction of the speed of light c,
# then print out the time in years that the spaceship takes to reach its destination (a) in the rest frame of
# an observer on Earth and (b) as perceived by a passenger on board the ship.
# Use your program to calculate the answers for a planet 10 light years away with v = 0.99c.
# Let's ask for velocity first
def main():
parser1 = argparse.ArgumentParser(description= "Parses the values for this problem")
parser1.add_argument('x', type=float, help="Distance traveled in light years: ")
parser1.add_argument('v', type=float, help="Speed of the spaceship as a fraction of the speed of light, c: ")
args = parser1.parse_args()
v = args.v
while v >= 1 or v <= 0:
print("That's not a valid value for the velocity!")
v = float(input("Enter the velocity as a fraction of the speed of light, c: "))
x = args.x
while x <= 0:
print("That's not a valid value for the distance!")
x = float(input("Enter the distance in light years: "))
# Equation for dilation
gamma = 1 / (math.sqrt(1 - v ** 2))
# Distance
x_c = x / gamma
# Time
time_earth = round((x / v), 2)
time_spaceship = round((x_c / v), 2)
print("The time in Earth's frame is {} years".format(str(time_earth)))
print("The time in spaceship's frame is {} years".format(str(time_spaceship)))
if __name__ == '__main__':
main()
| true |
cd260a299fd88a32a46742e90355b1a9db4657d5 | jb4503/PHYS4100_JBermeo | /PHYS4100_HW1.py | 930 | 4.3125 | 4 | import math
import argparse
# A ball is dropped from a tower of height h with initial velocity zero.
# Write a program that asks the user to enter the height in meters of the tower
# and then calculates and prints the time the ball takes until it hits the ground,
# ignoring air resistance. Use your program to calculate the time for a ball dropped from a 100 m high tower.
# Initial Velocity
v_0 = 0;
# Ask user for tower height:
h = int(input("Enter the tower's height in meters : "))
while h <= 0:
print("Height can't be negative!")
h = int(input("Enter the tower's height in meters : "))
deltaY= - h
# Don't fprget about little g
g = 9.8;
# acceleration
a = -g
# Now let's calculate the time it takes to hit the ground
# We can use deltaY = V_0*t + 1/2 a t^2
# Since V_0 is 0, deltaY becomes 1/2 a*t^2
t = str(round(math.sqrt( (2*deltaY)/a), 2))
print ('It would take the ball '+t+' seconds to hit the ground')
| true |
a2e1faf19f6a4f1bafdeddeb05cd070b95900bd2 | Duk4/Microsoft-Python-for-beginners | /nums.py | 645 | 4.21875 | 4 | # pi = 3.14159
# print(pi)
# first_number = 6
# second_number = 2
# print(first_number + second_number)
# print(first_number ** second_number)
# first_number = input('Enter first number: ')
# second_number = input('Enter second number: ')
# print(first_number + second_number) you get a string
# print(first_number ** second_number) strings can't have exponents
# print(int(first_number) + int(second_number))
# print(float(first_number) + float(second_number))
days_in_feb = 28
# print('There are ' + days_in_feb + ' days in February') won't work, because (string + int + string)
print('There are ' + str(days_in_feb) + ' days in February')
| true |
5840505b583e8a27ad247cac1e3dc56447c3ed46 | jrcolas/Learning-Python | /100DaysBootcamp/Day12/numberGuessing.py | 1,450 | 4.15625 | 4 | from art import logo
from random import randint
import os
EASY_GUESS = 10
HARD_GUESS = 5
randomNumber = randint(1,100)
os.system('cls')
print(logo)
print("Welcome to the Number Guessing Game!")
print("I'm thinking of a number between 1 and 100.")
difficulty = input("Choose a difficulty. Type 'easy' or 'hard': ").lower()
attempts = 0
def guess_game(atpt):
'''Takes in the number of attempts left for the user to use'''
print(f"You have {atpt} attempts remaining to guess the number.")
user_guess = int(input("Take a guess: "))
while user_guess != randomNumber and atpt != 1:
if user_guess < randomNumber:
atpt -= 1
print("Too low.")
print(f"You have {atpt} attempts remaining to guess the number.")
user_guess = int(input("Take a guess: "))
else:
atpt -= 1
print("Too high.")
print(f"You have {atpt} attempts remaining to guess the number.")
user_guess = int(input("Take a guess: "))
if user_guess == randomNumber:
print("Congratulations! You guessed it right!")
if user_guess != randomNumber:
print(f"You've used up all of your attempts. The number was {randomNumber}.")
if difficulty == "easy":
attempts_left = EASY_GUESS - attempts
elif difficulty == "hard":
attempts_left = HARD_GUESS - attempts
else:
print("You done messed up!")
guess_game(attempts_left)
| true |
2846974b37536874fc1b2fe56ea204171fcd66b1 | surajsomani/Basic_Python | /Python Basics/22_Reading_CSV.py | 1,244 | 4.46875 | 4 | import csv
#library to handle csv files
with open('example.csv') as csvfile: #naming the file as csvfile
readCSV = csv.reader(csvfile, delimiter=',') #reading the file
for row in readCSV: #reading each row
print(row) #print all columns in 1st row
print(row[0]) #print 1st column Here also index starts with 0
print(row[0],row[1],row[2],) #print 1st, 2nd and 3rd column
with open('example.csv') as csvfile:
readCSV = csv.reader(csvfile, delimiter=',')
dates = []
colors = []
for row in readCSV:
color = row[3]
date = row[0]
dates.append(date)
colors.append(color)
print(dates)
print(colors)
with open('example.csv') as csvfile:
readCSV = csv.reader(csvfile, delimiter=',')
dates = []
colors = []
for row in readCSV:
color = row[3]
date = row[0]
dates.append(date)
colors.append(color)
print(dates)
print(colors)
# now, remember our lists?
whatColor = input('What color do you wish to know the date of?:')
coldex = colors.index(whatColor)
theDate = dates[coldex]
print('The date of',whatColor,'is:',theDate)
#if you enter something that doesn't exist, you will get an ugly error.
| true |
0b798c3c17c0b3302603edc792beb7c7ef9701cb | ferasmis/Repeated-Number-Finder-In-A-List | /RepeatedNumberList.py | 241 | 4.15625 | 4 | ## Author: Feras
## Description: A program that finds repeated values in a list
def repeated(myList):
for i in myList:
if myList.count(i) > 1:
return i
print("The repeated number is: ", repeated([1,2, 45, 67, 45]))
| true |
ffc6e2fda607020f9c8f320cb42a607e79d7f44b | shawl6201/CTI110 | /P3T1_AreasOfRectangles_LeslieShaw.py | 748 | 4.5 | 4 | #CTI-110
#P3T1- Areas of Rectangles
#Leslie Shaw
#October 6, 2018
#This program is to determine which rectangle has the greater area
#Get the length and width of rectangle 1
length1=int(input('Enter the length of rectangle 1:'))
width1=int(input('Enter the width of rectangle 1:'))
#Get the length and width of rectangle 2
length2=int(input('Enter the length of rectangle 2:'))
width2=int(input('Enter the width of rectangle 2:'))
#Calculate the areas of the rectangles
area1=length1*width1
area2=length2*width2
#Determine which has the greater area
if area1>area2:
print('Rectangle 1 has the greater area.')
elif area2>area1:
print('Rectangle 2 has the greater area.')
else:
print('Both have the same area.')
| true |
cc909d85ba280a5dc383da83f73abdec347a00aa | 77kHlbG/Python | /CeaserCypher.py | 1,123 | 4.21875 | 4 | #!/usr/bin/python -tt
import sys
# Define a main() function
def main():
rotation=1
# Get cyphertext from user
cyphertext = input('Enter cyphertext: ')
plaintext = cyphertext
cyphertext = cyphertext.upper()
print('\n')
print('Performing Rotation Cypher...')
# Repeats for all 25 possible rotations
for rotation in range ( 1 , 26 ):
# Rotates each character in cyphertext string
for i in range( len( cyphertext ) ):
# Use to skip non-alphabetic characters
if ord( cyphertext[i] ) + rotation >= 91:
# Add 6 to skip non-alphabetic characters between Upper and Lower case
plaintext = plaintext[:i] + chr( ord( cyphertext[i] ) + rotation + 6 ).upper()
# Increment character by rotation value
else:
plaintext = plaintext[:i] + chr( ord( cyphertext[i] )+ rotation ).upper()
# Print plaintext from each rotation
print( 'ROT-' + str( rotation ) + ":" , plaintext )
rotation = rotation + 1
# This is the standard boilerplate that calls the main() function.
if __name__ == '__main__':
main()
| true |
0f05e0f4891bf5964df0b986d46e195c8571825f | BrianHarringtonUTSC/CMS-URG | /VideoStyleDifferences/Lecture_4/functions.py | 1,332 | 4.34375 | 4 | ''' You are building a login system for your new app.
In order to protect the users, you require their password to have
certain propoerties, they are listed below:
1. Must be at least 8 characters long
2. Must have at least 1 uppercase letter
3. Must have at least 1 lowercase letter
4. Must have at least 1 numeric digit
5. Does NOT contain spaces
Write a program that takes in a password as a string,
and returns True if the password satisfies all 5 criterias. If it doesn't,
return False.
If the entered password is "ilovelasagna4", your function
should return False, as the password does not contain an uppercase letter.
Don't forget to check your code by running a few examples, including the one
given above. '''
def validate_password(password):
''' PLEASE WRITE BELOW THIS COMMENT '''
length_FLAG = (length(password) >= 8)
uppercase_FLAG = False
lowercase_FLAG = False
digit_FLAG = False
no_space_FLAG = (' ' not in password)
for letter in password:
if (not uppercase_FLAG):
uppercase_FLAG = isupper(letter)
if (not lowercase_FLAG):
lowercase_FLAG = islower(letter)
if (not digit_FLAG):
digit_FLAG = isdigit(letter)
return (length_FLAG and uppercase_FLAG and lowercase_FLAG and digit_FLAG and no_space_FLAG)
| true |
a81fc2dd8f67097c6d8b3e4ac6c35e2961665bac | lichader/leetcode-challenge | /problems/median_of_two_sorted_arrays.py | 1,832 | 4.125 | 4 | """
There are two sorted arrays nums1 and nums2 of size m and n respectively.
Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).
You may assume nums1 and nums2 cannot be both empty.
Example 1:
nums1 = [1, 3]
nums2 = [2]
The median is 2.0
Example 2:
nums1 = [1, 2]
nums2 = [3, 4]
The median is (2 + 3)/2 = 2.5
"""
from typing import List
"""
We actually only need to iterate half elements of m+n
because we only need to know the value of elements in the middle
"""
class Solution:
def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
merged = []
len1 = len(nums1)
len2 = len(nums2)
total_size = len1 + len2
left = 0
right = 0
import math
if total_size % 2 == 0:
right = int(total_size / 2)
left = right - 1
else:
right = math.floor(total_size / 2)
left = right
p1 = 0
p2 = 0
while len(merged) < (right + 1) :
i1 = None
i2 = None
if p1 < len1:
i1 = nums1[p1]
if p2 < len2:
i2 = nums2[p2]
if i1 != None and i2 != None:
if i1 < i2:
merged.append(i1)
p1 += 1
elif i1 > i2:
merged.append(i2)
p2 += 1
else:
merged.append(i1)
merged.append(i1)
p1 += 1
p2 += 1
elif i1 != None:
merged.append(i1)
p1 += 1
elif i2 != None:
merged.append(i2)
p2 += 1
return (merged[left] + merged[right]) / 2
| true |
4c0e01485636e314bc7356fda4bf0c77e8f71757 | SergioO21/holbertonschool-higher_level_programming | /0x07-python-test_driven_development/2-matrix_divided.py | 1,591 | 4.3125 | 4 | #!/usr/bin/python3
""" matrix_divided function """
def matrix_divided(matrix, div):
"""
# Divides all elements of a matrix.
Args:
matrix (list) = The matrix
div (int) = Matrix divisor
- ``matrix`` must be a list of lists of integers or floats,
otherwise raise a ``TypeError`` exception.
- Each ``row of the matrix`` must be of the same size,
otherwise raise a ``TypeError`` exception.
- ``div`` must be a number (integer or float),
otherwise raise a ``TypeError`` exception.
- ``div`` can’t be equal to (0),
otherwise raise a ``ZeroDivisionError`` exception.
- All elements of the ``matrix`` should be divided by ``div``,
rounded to 2 decimal places.
Return: A new matrix.
"""
different_size = "Each row of the matrix must have the same size"
no_number = "matrix must be a matrix (list of lists) of integers/floats"
rows_size = []
new_matrix = []
index_matrix = 0
if type(div) != int and type(div) != float:
raise TypeError("div must be a number")
elif div == 0:
raise ZeroDivisionError("division by zero")
for row in matrix:
rows_size.append(len(row))
new_matrix.append([])
for index in row:
if type(index) != int and type(index) != float:
raise TypeError(no_number)
new_matrix[index_matrix].append(round((index / div), 2))
index_matrix += 1
for x in rows_size:
if rows_size[0] != x:
raise TypeError(different_size)
return new_matrix
| true |
808811951c539c67504735063f407442135aa7d9 | meighanv/05-Python-Programming | /LABS/Threading/multithreading.py | 1,309 | 4.21875 | 4 | """
Running things concurrently is known as multithreading
Running things in parallel is known as multiprocessing
I/O bound tasks - Waiting for input and output to be completed,
reading and writing from file system,
network operations
These all benefit more from threading
You get the illusion of running code at the same time,
however other code starts running while other code is waiting
cpu bound tasks - Good for number crunching
using CPU
data crunching
These benefit more from multiprocessing and running in parallel
Using multiprocessing might be slower if you have overhead from creating and
destroying files
"""
import threading
import time
start = time.perf_counter()
def do_something():
print('Sleeping 1 second...')
time.sleep(1)
print('Done Sleeping...')
# create 2 threads
t1 = threading.Thread(target=do_something)
t2 = threading.Thread(target=do_something)
# start the thread
t1.start()
t2.start()
# make sure the threads complete before moving on to calculate finish time
t1.join()
t2.join()
finish = time.perf_counter()
print(f'Finished in {finish-start} second(s)') | true |
4a23b8eca75e3ab4d85135818bf5c496292894d4 | meighanv/05-Python-Programming | /LABS/Labs-3-4/lab3-4-9-shipCharge.py | 1,160 | 4.21875 | 4 | #Setting up main function
def main():
#Calling Charge function passing result of the getWeight function as an argument
calcCharge(float(getWeight()))
#Defining function to capture and validate the user's input of the number of packages purchased
def getWeight():
#Getting initial input
packageWeight = input('What is the weight of your package:\n')
#Validating input to be numeric and greater than 0.00
while float(packageWeight) < 0 or packageWeight.replace('.','').isnumeric() == False:
packageWeight = input('Invalid input. What is the weight of your package:\n')
#Returning result to main
return packageWeight
#Function to determine shipping charge
def calcCharge(num):
#Charge for less than 2 pounds
if num <= 2.00:
print('The shipping charge is $1.10')
#Charge for over 2 pounds upt0 6
elif num > 2 and num <= 6:
print('The shipping charge is $2.20')
#Charge for over 6 pounds upto 10
elif num > 6 and num <= 10:
print('The shipping charge is $3.70')
#Charge for more than 10 pounds
elif num > 10:
print('The shipping charge is $3.80')
main() | true |
37c5c209079b920c816c6a06442630b6ee933fe2 | meighanv/05-Python-Programming | /LABS/Classes/cellphone.py | 2,698 | 4.5 | 4 | """
Wireless Solutions, Inc. is a business that sells cell phones and wireless service.
You are a programmer in the company’s IT department, and your team is designing a program to manage
all of the cell phones that are in inventory. You have been asked to design a class that represents
a cell phone. The data that should be kept as attributes in the class are as follows:
• The name of the phone’s manufacturer will be assigned to the __manufact attribute.
• The phone’s model number will be assigned to the __model attribute.
• The phone’s retail price will be assigned to the __retail_price attribute.
The class will also have the following methods:
• An __init__ method that accepts arguments for the manufacturer, model number,
and retail price.
• A set_manufact method that accepts an argument for the manufacturer. This
method will allow us to change the value of the __manufact attribute after the object has been created, if necessary.
• A set_model method that accepts an argument for the model. This method will allow
us to change the value of the __model attribute after the object has been created, if
necessary.
• A set_retail_price method that accepts an argument for the retail price. This
method will allow us to change the value of the __retail_price attribute after the
object has been created, if necessary.
• A get_manufact method that returns the phone’s manufacturer.
• A get_model method that returns the phone’s model number.
• A get_retail_price method that returns the phone’s retail price.
"""
# The CellPhone class pulls data about the cell phone
class CellPhone:
# The __init__ method initializes the attributes
def __init__(self,manufact, model, price):
self.__manufact = manufact
self.__model = model
self.__retail_price = price
#The set_manufact method accepts an argument for the phone's manufacturer
def set_manufact(self, manufact):
self.__manufact = manufact
# The set_model method accepts an argument for the phone's model number
def set_model(self, model):
self.__model = model
# The set_retail_price method accepts and arguement for retail price
def set_retail_price(self, price):
self.__retail_price = price
# The get_manufact method returns the phones manufacturer
def get_manufact(self):
return self.__manufact
# The get_model method returns the phones model number
def get_model(self):
return self.__model
# The get_price method returns the phones price
def get_retail_price(self):
return self.__retail_price | true |
3e52bda4af910dccd9710c8d2bfd86388fe4fe07 | meighanv/05-Python-Programming | /LABS/recursion/rec-lines.py | 442 | 4.53125 | 5 | """
3. Recursive Lines
Write a recursive function that accepts an integer argument, n. The function should display
n lines of asterisks on the screen, with the first line showing 1 asterisk, the second line
showing 2 asterisks, up to the nth line which shows n asterisks.
"""
def main():
recLines(7)
def recLines(n):
if n == 0:
return 0
else:
print('*' + recLines(n-1)*'*')
return n
main()
| true |
6963e9b7069b8bcd986331c1fe8a244eca289398 | meighanv/05-Python-Programming | /LABS/DICTIONARIES-SETS/dict-set-wordcount.py | 1,981 | 4.4375 | 4 | #This program is to grab all the unique words in a file.
def main():
#this is the dictionary to store a word count for each unique word
wordcount = {}
#Stores the lines of the file specified by the user
source = readFile()
#This calls the function to extract all the words from a file
words = getWords(source)
#This stores the return of the function which casts the words list as a set, making all words unique.
unique = getUnique(words)
countWords(wordcount,words,unique)
print('Here is the count for each word in the file:')
for i in wordcount:
print('{}: {}'.format(i, wordcount[i]))
#this simple takes an array and casts/returns it as a set
def getWords(original):
#Iterate through each line
newlist = []
for i in original:
#Split the lines by spaces (a typical delimeter in English between words)
line = i.split(' ')
#Add the words in the line to the list.
newlist += line
#Clean up each word in the list, getting rid of . \n "" and ?
cleanlist = []
for i in newlist:
i = i.replace('\n','').replace('.','').replace('!','').replace('?','').replace('"','')
#ensures than all words are lower case to ensure set is properly unique
i = i.lower()
cleanlist.append(i)
return cleanlist
#Casts any list to a set and returns result to main
def getUnique(array):
uniqueItems = set(array)
return uniqueItems
def readFile():
#Getting filename from input for filename
filename = input('Provide the new file name:\n')
#Reads the file of filename
f = open(filename, 'r')
#Recording file contents in array
contents = f.readlines()
f.close()
return contents
def countWords(wordCount,words,unique):
for uni in unique:
count = 0
for word in words:
if uni.lower() == word.lower():
count += 1
wordCount.update({uni: int(count)})
main() | true |
9274734c6e50e164d86eb699a38088f1c6259aa1 | meighanv/05-Python-Programming | /LABS/Labs-3-4/lab3-4-8-Discount.py | 1,400 | 4.21875 | 4 | #Setting up main function
def main():
#Calling Discount function passing result of the numPurchase function as an argument
calcDiscount(int(numPurchase()))
#Defining function to capture and validate the user's input of the number of packages purchased
def numPurchase():
#Getting initial input
packages = input('How many packages did you buy:\n')
#Validating input to be numeric and greater than 0
while int(packages) < 0 or packages.isnumeric() == False:
packages = input('Invalid input. How many packages did you buy:\n')
#Returning result to main
return packages
#Function to determine the level of discount
def calcDiscount(num):
#No discount if less than 10 packages purchased
if num < 10:
print('There is no discount for {} purchases'.format(num))
#20 percent discount 10-19 packages purchased
elif num >= 10 and num <= 19:
print('There is a 20 percent discount for {} purchases'.format(num))
#30 percent discount 20-49 packages purchased
elif num >= 20 and num <= 49:
print('There is a 30 percent discount for {} purchases'.format(num))
#40 percent discount 50-99 packages purchased
elif num >= 50 and num <= 99:
print('There is a 40 percent discount for {} purchases'.format(num))
elif num >= 100:
print('There is a 50 percent discount for {} purchases'.format(num))
main() | true |
11fbcfd7fa221cccbb29bb6c115b4a4abee7903d | meighanv/05-Python-Programming | /LABS/Classes/cashregister.py | 2,056 | 4.46875 | 4 | """
7. Cash Register
This exercise assumes that you have created the RetailItem class for Programming
Exercise 5. Create a CashRegister class that can be used with the RetailItem class. The
CashRegister class should be able to internally keep a list of RetailItem objects. The
class should have the following methods:
• A method named purchase_item that accepts a RetailItem object as an argument.
Each time the purchase_item method is called, the RetailItem object that is passed as
an argument should be added to the list.
• A method named get_total that returns the total price of all the RetailItem objects
stored in the CashRegister object’s internal list.
• A method named show_items that displays data about the RetailItem objects stored
in the CashRegister object’s internal list.
• A method named clear that should clear the CashRegister object’s internal list.
Demonstrate the CashRegister class in a program that allows the user to select several
items for purchase. When the user is ready to check out, the program should display a list
of all the items he or she has selected for purchase, as well as the total price.
"""
from functools import reduce
class CashRegister:
def __init__ (self):
self.__purchase = []
self.__total = 0.0
def set_total(self):
# This code below was replaced by the uncommented lambda function
# total = 0
# for i in self.__purchase:
# total += float(i.get_price()) * float(i.get_unitCount())
receipt = (item.get_price()*item.get_unitCount() for item in self.__purchase)
self.__total = reduce((lambda x,y: x + y), receipt)
def purchase_item(self,item):
self.__purchase.append(item)
def get_total(self):
return self.__total
def show_items(self):
for i in self.__purchase:
print(i.get_desc())
def clear_register(self):
self.__purchase = []
self.__total = 0.0 | true |
041e263bf20440e54deb57f50d18db2dc7586953 | yohn-dezmon/python-projs | /mad_lib_git.py | 734 | 4.53125 | 5 | # Prompt user for their name
name = input("What is your name? ")
# Greeting with users name
print(f'''Hey {name}! Welcome to Mad Libs the program!
Please provide us with...''')
# Prompt user for a noun, adjective, and verb(ING)
noun = input("A noun: ")
adj = input("An adjective: ")
verb = input("A verb ending in ing: ")
# Print space between the prompts and the story
print('''
''')
# Print the story using the inputs from the user. The title is in capitals and is cenetered.
print(f'''Voila! Here is your story:
\t\tTHE LOST BURRITO
One day a burrito lost its {noun}. The burrito was so sad!
He looked everywhere for this very {adj} {noun}.
It was so dear to him, that he lost himself {verb} for the {noun}!
Poor burrito!''')
| true |
f97b49d71868b3e45bfb79f831aecf16dc1f5d6a | aishsharma/Karan-Projects | /Solutions/Numbers/Prime_Factorization.py | 1,272 | 4.3125 | 4 | """
Author: Aishwarya Sharma
Question: Prime Factorization - Have the user enter a number and find all Prime Factors (if there are any) and display
them.
"""
from math import sqrt
from typing import List
# Tests if a number is prime or not. Uses simple formula for test.
def is_prime(n: int)->bool:
if n <= 1:
return False
elif n <= 3:
return True
elif (n % 2 == 0) or (n % 3 == 0):
return False
i = 5
while i**2 <= n:
if (n % i == 0) or (n % (i + 2) == 0):
return False
i += 6
return True
def get_prime_factors(n: int)->List:
if n < 2:
print("Input should be at least 2.")
return []
elif is_prime(n):
print("Input is a prime number")
return []
prime_factors = []
for i in range(2, round(sqrt(n)) + 1):
if n % i == 0 and is_prime(i):
prime_factors.append(i)
return prime_factors
def app():
try:
n = int(input("Enter a number and I will give you its prime factors: "))
except ValueError:
print("Input must be a number > 1")
prime_factors = get_prime_factors(n)
print("The prime factors of {0} are: ".format(n))
print(prime_factors)
if __name__ == '__main__':
app()
| true |
bad3f3bc881470c895cf0ea118bd2192a29b381a | jeff87b/Python-module-1 | /Day 1-5/007 The area of a square with if and else.py | 405 | 4.28125 | 4 | print ("This program calculates the area of a square.")
side1 = float(input("Enter side number one: "))
side2 = float(input("Enter side number two:"))
print("The area is:", side1*side2)
if side1<0:
print("You have entered a negative first number")
else:
print("The first number is ok")
if side2<0:
print("You have entered a negative second number")
else:
print("The second number is ok")
| true |
0bd2d83a82395c518a0860e6d490dfad023e8b3d | katharinameislitzer/smartninjacourse | /Class3_Python3/example_01210_read_analyse_exercise_solution.py | 422 | 4.15625 | 4 | # open the file "height.txt"
# it contains the height of each person in the class
# separated by a come ","
# write a program which reads the file
# saves the different heights in a list
# and calculates the average height
with open("height.txt") as file:
a = file.read().split(",")
height_avg=0
number_of_people=len(a)
for i in a:
height_avg += int(i)
height_avg=height_avg/number_of_people
print(height_avg) | true |
7ead56c5eff91f2c77a07160363211d7c124d579 | katharinameislitzer/smartninjacourse | /Class1_Python3/example_0500_calculator_excercise_2.py | 899 | 4.375 | 4 | # print welcome to user
name = input("Please enter your name: ")
print(f"Welcome {name}")
# read user input for operation
operation = input("Please enter a mathematical sign (+, -, *, /): ")
print(f"You entered {operation}")
# read user input for first value
first_value = int(input("Please enter number one: "))
print(f"You entered {first_value}")
# read user input for second value
second_value = int(input("Please enter number two: "))
print(f"You entered {second_value}")
# calculate depending on operators
result = None
if operation is "+":
print(f"The result is {first_value + second_value}")
elif operation is "-":
print(f"The result is {first_value - second_value}")
elif operation is "*":
print(f"The result is {first_value * second_value}")
elif operation is "/":
print(f"The result is {first_value / second_value}")
else:
print("nope, try again")
# and print result
| true |
550dd8ab9ba9d4ad3527ed8461efa4623fc6497a | pransil/skLearnMnistViz | /plot_mnist_filters.py | 2,337 | 4.28125 | 4 | """
=====================================
Visualization of MLP weights on MNIST
=====================================
Sometimes looking at the learned coefficients of a neural network can provide
insight into the learning behavior. For example if weights look unstructured,
maybe some were not used at all, or if very large coefficients exist, maybe
regularization was too low or the learning rate too high.
This example shows how to plot some of the first layer weights in a
MLPClassifier trained on the MNIST dataset.
The input data consists of 28x28 pixel handwritten digits, leading to 784
features in the dataset. Therefore the first layer weight matrix have the shape
(784, hidden_layer_sizes[0]). We can therefore visualize a single column of
the weight matrix as a 28x28 pixel image.
To make the example run faster, we use very few hidden units, and train only
for a very short time. Training longer would result in weights with a much
smoother spatial appearance.
"""
print(__doc__)
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_mldata
from sklearn.neural_network import MLPClassifier
def main():
mnist = fetch_mldata("MNIST original")
# rescale the data, use the traditional train/test split
X, y = mnist.data / 255., mnist.target
X_train, X_test = X[:60000], X[60000:]
y_train, y_test = y[:60000], y[60000:]
# mlp = MLPClassifier(hidden_layer_sizes=(100, 100), max_iter=400, alpha=1e-4,
# solver='sgd', verbose=10, tol=1e-4, random_state=1)
mlp = MLPClassifier(hidden_layer_sizes=(40,60,40), max_iter=10, alpha=3e-2,
solver='adam', verbose=10, tol=1e-4, random_state=1,
learning_rate_init=.0001)
mlp.fit(X_train, y_train)
print("Training set score: %f" % mlp.score(X_train, y_train))
print("Test set score: %f" % mlp.score(X_test, y_test))
fig, axes = plt.subplots(4, 4)
# use global min / max to ensure all weights are shown on the same scale
vmin, vmax = mlp.coefs_[0].min(), mlp.coefs_[0].max()
for coef, ax in zip(mlp.coefs_[0].T, axes.ravel()):
ax.matshow(coef.reshape(28, 28), cmap=plt.cm.gray, vmin=.5 * vmin,
vmax=.5 * vmax)
ax.set_xticks(())
ax.set_yticks(())
plt.show()
if __name__ == '__main__':
main() | true |
3bc4c4a6489d517288488c4bc1c33802177a65cc | Mpreyzner/python_algorithms | /n_queens.py | 2,564 | 4.3125 | 4 | # The N Queen is the problem of placing N chess queens on an N×N chessboard
# so that no two queens attack each other.
# 1) Start in the leftmost column
# 2) If all queens are placed
# return true
# 3) Try all rows in the current column. Do following for every tried row.
# a) If the queen can be placed safely in this row then mark this [row,
# column] as part of the solution and recursively check if placing
# queen here leads to a solution.
# b) If placing queen in [row, column] leads to a solution then return
# true.
# c) If placing queen doesn't lead to a solution then umark this [row,
# column] (Backtrack) and go to step (a) to try other rows.
# 3) If all rows have been tried and nothing worked, return false to trigger
# backtracking.
n = 4
def print_solution(board):
for i in range(n):
for j in range(n):
print(board[i][j]),
print("")
# A utility function to check if a queen can
# be placed on board[row][col]. Note that this
# function is called when "col" queens are
# already placed in columns from 0 to col -1.
# So we need to check only left side for
# attacking queens
def is_safe(board, row, col):
# Check this row on left side
for i in range(col):
if board[row][i] == 1:
return False
# Check upper diagonal on left side
for i, j in zip(range(row, -1, -1), range(col, -1, -1)):
if board[i][j] == 1:
return False
# Check lower diagonal on left side
for i, j in zip(range(row, n, 1), range(col, -1, -1)):
if board[i][j] == 1:
return False
return True
def solve_util(board, column):
# base case: If all queens are placed
# then return true
if column >= n:
return True
# Consider this column and try placing
# this queen in all rows one by one
for i in range(n):
if is_safe(board, i, column):
# Place this queen in board[i][col]
board[i][column] = 1
# recur to place rest of the queens
if solve_util(board, column + 1):
return True
# backtrack
board[i][column] = 0
# if queen can not be place in any row in
return False
def solve_n_queens():
board = [[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]
]
if solve_util(board, 0):
print_solution(board)
return True
print("Solution does not exist")
return False
solve_n_queens()
| true |
a4061d17e097fc2a7753ce54998eac01619272b1 | simransidhu8/C98---Functions | /countWordsFromFile.py | 299 | 4.28125 | 4 | def countWordsFromFile() :
fileName = input("Enter file name: ")
numberOfWords = 0
f = open(fileName)
for line in f :
words = line.split()
numberOfWords = numberOfWords + len(words)
print("Number of words: ")
print(numberOfWords)
countWordsFromFile() | true |
862fbb1580e0dd290a61dae003c552128fe97c64 | HunterLaugh/codewars_kata_python | /kata_4_Validate_Sudoku_with_size_N_N.py | 2,053 | 4.125 | 4 | '''
4 kyu Validate Sudoku with size `NxN`
Given a Sudoku data structure with size NxN, N > 0 and √N == integer, write a method to validate if it has been filled out correctly.
The data structure is a multi-dimensional Array(in Rust: Vec<Vec<u32>>) , ie:
[
[7,8,4, 1,5,9, 3,2,6],
[5,3,9, 6,7,2, 8,4,1],
[6,1,2, 4,3,8, 7,5,9],
[9,2,8, 7,1,5, 4,6,3],
[3,5,7, 8,4,6, 1,9,2],
[4,6,1, 9,2,3, 5,8,7],
[8,7,6, 3,9,4, 2,1,5],
[2,4,3, 5,6,1, 9,7,8],
[1,9,5, 2,8,7, 6,3,4]
]
Rules for validation
Data structure dimension: NxN where N > 0 and √N == integer
Rows may only contain integers: 1..N (N included)
Columns may only contain integers: 1..N (N included)
'Little squares' (3x3 in example above) may also only contain integers: 1..N (N included)
'''
# ---- row ||| column +++ palace
class Sudoku(object):
def __init__(self,value):
self.L=value
def getN(self):
return len(self.L)
def get_listN(self):
return list(range(1,N+1))
def is_N_N(self):
for i in range(N):
if len(self.L[i])!=n:
return False
return True
def is_row(self):
for each in self.L:
each.sort()
if each!=listN:
return False
return True
def is_column(self):
j=0 # column
while j<N:
i=0 # row
temp=[]
while i<N:
temp.append(self.L[i][j])
i+=1
temp.sort()
if temp!=listN:
return False
j+=1
return True
def is_palace(self):
pass
N=self.getN()
listN=self.get_listN()
def is_valid(self):
if self.is_N_N():
if self.is_row():
if self.is_column():
return True
return False
testValue=[
[7,8,4, 1,5,9, 3,2,6],
[5,3,9, 6,7,2, 8,4,1],
[6,1,2, 4,3,8, 7,5,9],
[9,2,8, 7,1,5, 4,6,3],
[3,5,7, 8,4,6, 1,9,2],
[4,6,1, 9,2,3, 5,8,7],
[8,7,6, 3,9,4, 2,1,5],
[2,4,3, 5,6,1, 9,7,8],
[1,9,5, 2,8,7, 6,3,4]
]
testSudoku=Sudoku(testValue)
print(testSudoku.is_valid()) | true |
d720678c5d305947059da4ea89fa966aeecd0b51 | HunterLaugh/codewars_kata_python | /kata_6_Format_words_into_a_sentence.py | 1,028 | 4.21875 | 4 | '''
Format words into a sentence
Complete the method so that it formats the words into a single comma separated value. The last word should be separated by the word 'and' instead of a comma. The method takes in an array of strings and returns a single formatted string. Empty string values should be ignored. Empty arrays or null/nil values being passed into the method should result in an empty string being returned.
formatWords(['ninja', 'samurai', 'ronin']) // should return "ninja, samurai and ronin"
formatWords(['ninja', '', 'ronin']) // should return "ninja and ronin"
formatWords([]) // should return ""
'''
def format_words(words):
if not words:
return ""
L=[]
for each in words:
if each:
L.append(each)
if not L:
return ""
n=len(L)
if n==1:
return L[0]
elif n==2:
return L[0]+' and '+L[1]
else:
i=0
while i<n-2:
L[i]=L[i]+','
i+=1
L.insert(n-1,'and')
return ' '.join(L)
l=['one','two', 'three','four']
print(format_words(l))
| true |
e782a8a494d70e5f2d4b0000b1f1d2658513b2ee | HunterLaugh/codewars_kata_python | /kata_5_Regex_for_Gregorian_date_validation.py | 1,115 | 4.15625 | 4 | '''
Regex for Gregorian date validation
Your task is to write regular expression that validates gregorian date in format "DD.MM.YYYY"
Correct date examples:
"23.12.2008"
"01.08.1994"
Incorrect examples:
"12.23.2008"
"01-Aug-1994"
" 01.08.1994"
Notes:
maximum length of validator is 400 characters to avoid hardcoding. (shortest solution to date is 170 characters)
validator should process leap days (February, 29) correctly.
the date is Gregorian, it's important to determine if year is leap: https://en.wikipedia.org/wiki/Gregorian_calendar
'''
date_validator = r'([01][0-9]|2[0-9]|3[01]).([0][13578]|1[12])'
# TEST CASE
import re
test.assert_equals(bool(re.match(date_validator,'01.01.2009')),
True, 'Basic correct date: 01.01.2009')
test.assert_equals(bool(re.match(date_validator,'01-Jan-2009')),
False, 'Incorrect mask: 01-Jan-2009')
test.assert_equals(bool(re.match(date_validator,'05.15.2009')),
False, 'Incorrect month: 15.15.2009')
| true |
3936d910807507e628b4a0ef156a3a8f9eac24eb | HunterLaugh/codewars_kata_python | /kata_8_Who_ate_the_cookie.py | 879 | 4.5625 | 5 | '''
8 kyu
Who ate the cookie
For this problem you must create a program that says who ate the last cookie.
If the input is a string then "Zach" ate the cookie.
If the input is a float or an int then "Monica" ate the cookie.
If the input is anything else "the dog" ate the cookie.
The way to return the statement is: "Who ate the last cookie? It was (name)!"
Ex: Input = "It was Monica" --> Output = "Who ate the last cookie? It was Zach! (The reason you return Zach is because the input is a string)
Note: Make sure you return the correct message with correct spaces and punctuation.
'''
def cookie(x):
x_type=type(x)
res=''
if x_type==str :
res="Who ate the last cookie? It was Zach!"
elif x_type==int or x_type==float:
res="Who ate the last cookie? It was Monica!"
else:
res="Who ate the last cookie? It was the dog!"
return res | true |
91ce21140d3ef1fc0a0aa0771979746d4fb330b9 | Wallkon/Ejercicios-de-The-Python-Workbook | /Exercise_12_Distance_Between_Two_Points_on_Earth.py | 1,929 | 4.5625 | 5 | """
The surface of the Earth is curved, and the distance between degrees of longitude
varies with latitude. As a result, finding the distance between two points on the surface
of the Earth is more complicated than simply using the Pythagorean theorem.
Let (t1, g1) and (t2, g2) be the latitude and longitude of two points on the Earth’s
surface. The distance between these points, following the surface of the Earth, in
kilometers is:
distance = 6371.01 × arccos(sin(t1) × sin(t2) + cos(t1) × cos(t2) × cos(g1 − g2))
The value 6371.01 in the previous equation wasn’t selected at random. It is
the average radius of the Earth in kilometers.
Create a program that allows the user to enter the latitude and longitude of two
points on the Earth in degrees. Your program should display the distance between
the points, following the surface of the earth, in kilometers.
Hint: Python’s trigonometric functions operate in radians. As a result, you will
need to convert the user’s input from degrees to radians before computing the
distance with the formula discussed previously. The math module contains a
function named radians which converts from degrees to radians.
Esta página puede servir, pero no da el mismo resultado:
http://keisan.casio.com/exec/system/1224587128
"""
import math
AVG_RADIUS_HEARTH_KILOMETERS = 6371.01
t1_grades = float(input("ingrese t1: "))
g1_grades = float(input("ingrese g1: "))
t2_grades = float(input("ingrese t2: "))
g2_grades = float(input("ingrese g2: "))
t1_rads = math.radians(t1_grades)
g1_rads = math.radians(g1_grades)
t2_rads = math.radians(t2_grades)
g2_rads = math.radians(g2_grades)
#distance = 6371.01 × arccos(sin(t1) × sin(t2) + cos(t1) × cos(t2) × cos(g1 − g2))
distancia = AVG_RADIUS_HEARTH_KILOMETERS * math.acos(math.sin(t1_rads) * math.sin(t2_rads) * math.cos(t2_rads) * math.cos(g1_rads - g2_rads) )
print("La distancia es de {} km".format(distancia))
| true |
b98068b9164c4daa471c65ea6ec25082dd26db0f | EDalSanto/ThinkPythonExercises | /cartalk1_triple_double.py | 594 | 4.375 | 4 | fin = open("ThinkPython/words.txt")
def triple_double(word):
"""Tests if a word contains three consecutive double letters"""
i = 0
doubles = 0
while i < len(word)-1:
if word[i] == word[i+1]:
doubles += 1
if doubles == 3:
return True
i += 2
else:
doubles = 0
i += 1
return False
def find_triple_double():
"""Reads a word list and prints words with triple double letters"""
for line in fin:
word = line.strip()
if triple_double(word):
print word
| true |
9bd1d9c2a6a087a028eed2119926ea5bc3f94811 | Hammad-Ishaque/pydata-practise | /DesignPatterns/FactoryPattern.py | 868 | 4.125 | 4 | from abc import ABCMeta, abstractmethod
# What particular instance to create
class IPerson(metaclass=ABCMeta):
@abstractmethod
def person_method(self):
"""
:return:
"""
class Student(IPerson):
def __init__(self):
self.name = "I am Student"
def person_method(self):
print("This is Student!")
class Teacher(IPerson):
def __init__(self):
self.name = "I am Teacher"
def person_method(self):
print("This is Teacher!")
class PersonFactory:
@staticmethod
def build_person(person_type):
if person_type == "Student":
return Student()
if person_type == "Teacher":
return Teacher()
return -1
choice = input("What type of person do you want to create?\n")
person = PersonFactory.build_person(choice)
person.person_method()
| true |
53fe220d2fcb589571740e9f1998c8977385b350 | KazZBodnar/pythoncalc | /main.py | 1,793 | 4.3125 | 4 | import math
#help = input("PythonCalc V 1.0; Say 'help' for more info, and 'ready' to start the calculator.")
#if help== "help" or "Help":
# print("Signs: '+', '-', '*', '/', '^2', 'sqrt', '^3', '!', 'power'.")
#else:
print("PythonCalc V 1.0 type help for a list of commands")
sign = input("What sign should I use?")
if sign== "+":
num1 = int(input("What is the first number? "))
num2 = int(input("What is the second number? "))
print(num1+num2)
elif sign== "-":
num1 = int(input("What is the first number? "))
num2 = int(input("What is the second number? "))
print (num1-num2)
elif sign== "*":
num1 = int(input("What is the first number? "))
num2 = int(input("What is the second number? "))
print (num1*num2)
elif sign== "/":
num1 = int(input("What is the first number? "))
num2 = int(input("What is the second number? "))
print (num1/num2)
elif sign== "^2":
num1 = int(input("What is the number you wish to be squared? "))
print (num1**2)
elif sign== "^3":
num1 = int(input("What is the first number? "))
num2 = int(input("What is the second number? "))
print (num1**3)
elif sign== "power":
num1 = int(input("What is the first number? "))
num2 = int(input("What is the second number? "))
print (num1**num2)
elif sign== "sqrt":
num1 = int(input("What is the number you seek the squae root of? "))
print (math.sqrt(num1))
elif sign== "!":
num1 = int(input("What is the number you seek the factorial of? "))
print (factorial(num1))
elif sign== "help":
print("you can add, subtract, multiply, divide, square, cube, do exponents, find square root, and find factorial.")
else:
print("I am sorry, but I am unable to process your request.")
| true |
eb39c96d98e1e0813a65215471616a5fe75c71ad | hermineavagyan/OOP | /userClass.py | 2,077 | 4.125 | 4 | class User:
#defining a class attriute
bank_name = "First Dational Dojo"
#creating the class constructor
def __init__(self, name, email_address):
self.name = name
self.email = email_address
self.account_balance = 0
# increases the user's balance by the amount specified
def make_deposit(self, amount):
self.account_balance += amount
#decreases the user's balance by the amount specified
def make_withdrawal(self, amount):
self.account_balance -= amount
#prints the user's name and account balance to the terminal
def display_user_balance(self):
print(self.name, self.account_balance)
#decrease the user's balance by the amount and
# add that amount to other other_user's balance
def transfer_money(self, other_user, amount):
self.account_balance -= amount
other_user.account_balance += amount
#prints greeting message togteher with the user name
def greeting(self):
print("Hello my name is", self.name)
print("my email is ", self.email)
#creating 3 users
user1 = User("Adrien", "adrien@yahoo.com")
user2 = User("Hermine", "hermine@codingdojo.com")
user3 = User("Bob", "bob@codingdojo.com")
#first user makes 3 deposits and 1 withdrawals
user1.make_deposit(400)
user1.make_deposit(400)
user1.make_deposit(600)
user1.make_withdrawal(200)
#second user makes 2 deposits and 2 withdrawals
user2.make_deposit(500)
user2.make_deposit(800)
user2.make_withdrawal(300)
user2.make_withdrawal(100)
#third user makes 1 deposits and 3 withdrawals
user3.make_deposit(800)
user3.make_withdrawal(300)
user3.make_withdrawal(500)
user3.make_withdrawal(150)
#call display_user_balance method to display the users' account balances
user1.display_user_balance()
user2.display_user_balance()
user3.display_user_balance()
user1.transfer_money(user3,200)
print()
print("After calling transfer money method the account balances of the first and the third user")
# after calling transfer money method the account balances of the first and the third user
user1.display_user_balance()
user3.display_user_balance()
| true |
c069162616ae7c88cd340cf425e63b90e0770f46 | cs-fullstack-2019-spring/python-loops-cw-leejr1983 | /PythonLoopsCW.py | 1,708 | 4.34375 | 4 | from _ast import If
def main():
# problem1()
#problem2()
#problem3()
problem4()
# Exercise 1:
# Print -20 to and including 50.
# Use any loop you want.
def problem1():
for numbers in range(-20,51):
print (numbers)
# Exercise 2:
# Create a loop that prints even numbers from 0 to and including 20.
def problem2():
for numbers in range (0,21,2):
print(numbers)
# Exercise 3:
# Prompt the user for 3 numbers. Then print the 3 numbers along with their average after the 3rd number is entered.
# Refer to example below replacing NUMBER1, NUMBER2, NUMBER3, and THEAVERAGE with the actual values.
# Ex.Output
# The average of NUMBER1, NUMBER2, and NUMBER3 is THEAVERAGE
def problem3():
userInput= int(input("Please enter number 1"))
userInput2= int(input("Please enter number 2"))
userInput3= int(input("please enter number 3"))
average= int((userInput + userInput2 + userInput3) /3)
print("The average of",str(userInput),str(userInput2),str(userInput3),"is",str(average))
# Exercise 4:
# Password Checker - Ask the user to enter a password. Ask them to confirm the password.
# If it's not equal, keep asking until it's correct or they enter 'Q' to quit.
def problem4():
userInput= input("Please enter password")
userInput2= input("Please verify your password")
while (userInput2 != userInput or "q"):
if (userInput == userInput2):
print ("Thank you")
break
elif (userInput2 == "q"):
print ("User has chosen to quit")
break
else:
userInput2= input("Please verify your password")
if __name__ == '__main__':
main() | true |
50249cbfbfd0eb2e6a64cb97c00743ad91541cdf | Prabithapallat01/pythondjangoluminar | /flow_controls/looping/samlefor.py | 343 | 4.125 | 4 | #for i in range(start,stop):
#loop body
#for i in range(1,10):
#print(i)
#for i in range (10,0,-1):
# print(i)
# to print total of first 50 numbers
#total=0
#for i in range(1,51):
# total=total+i
#print(total)
# to print given number is prime or not
#to print allprime numbers btwn 5 to 50
#low=5
#upperlimi=50
#2 read a number | true |
fb167dcdd270d019402443230887932aecdd3ed4 | cs-fullstack-2019-fall/codeassessment2-LilPrice-Code | /q3.py | 708 | 4.40625 | 4 | # ### Problem 3
# Given 2 lists of claim numbers, write the code to merge the 2 lists provided to produce a new list by alternating values between the 2 lists. Once the merge has been completed, print the new list of claim numbers (DO NOT just print the array variable!)
# ```
# # Start with these lists
# list_of_claim_nums_1 = [2, 4, 6, 8, 10]
# list_of_claim_nums_2 = [1, 3, 5, 7, 9]
# ```
# Example Output:
# ```
# The newly created list contains: 2 1 4 3 6 5 8 7 10 9
# ```
# Starting variables
nums1 = [2, 4, 6, 8, 10]
nums2 = [1, 3, 5, 7, 9]
numall=[]
# adding to Array
for x in range(0,len(nums1)):
numall.append(nums1[x])
numall.append(nums2[x])
# Printing Array
print(numall) | true |
462c756db5826b1b0586f32e6bc0687f85128719 | Leg3nd3/Project_97 | /guessNumber.py | 426 | 4.25 | 4 | import random
number = random.randint(1, 5)
guess = int(input("Enter a number from 1 to 5: "))
while number != "guess":
print
if guess < number:
print("Guess is low")
guess = int(input("Enter a number from 1 to 5: "))
elif guess > number:
print("Guess is high")
guess = int(input("Enter a number from 1 to 5: "))
else:
print("You guessed it!")
break | true |
6184fe53341c9eb095ec008871ae31ecf8f5219e | nadiamarra/learning_python | /triangle.py | 776 | 4.28125 | 4 | def area(base,height):
"""(number,number)-> number
Return the area of a triangle with dimensions base and height.
>>>area(10,5)
25.0
>>>area(2.5,3)
3.75
"""
return base*height/2
def perimeter(side1,side2,side3):
"""(number,number,number) -> number
Return the perimeter of a triangle with sides of length side1, side2 and side3.
>>>perimeter(3,4,5)
12
>>>perimeter(10.5,6,9.3)
25.8
"""
return side1+side2+side3
def semiperimeter(side1,side2,side3):
"""(number,number,number)-> float
Return the semiperimeter of a triangle with sides of length side1,side2 and side3.
>>>semiperimeter(3,4,5)
6.0
>>>semiperimetre(10.5,6,9.3)
12.9
"""
return perimeter(side1,side2,side3)/2
| true |
8a68d28e002f59a91c15da4bf2a283958fbf7857 | nadiamarra/learning_python | /rock_paper_scissors_against_computer.py | 1,696 | 4.15625 | 4 | import random
player_wins=0
computer_wins=0
while player_wins<2 and computer_wins<2:
print("rock...\npaper...\nscissors...")
print(f"Player Score:{player_wins} Computer Score:{computer_wins}")
player=input("Player, make your move: ")
rand_num=random.randint(0,2)
if rand_num==0:
computer="rock"
elif rand_num==1:
computer="paper"
else:
computer="scissors"
print(f"Computer plays {computer}")
if player==computer:
print("It's a tie!")
elif player=="rock":
if computer=="scissors":
print("Player wins!")
player_wins+=1
elif computer=="paper":
print("Computer wins!")
computer_wins+=1
elif player=="paper":
if computer=="rock":
print("Player wins!")
player_wins+=1
elif computer=="scissors":
print("Computer wins!")
computer_wins+=1
elif player=="scissors":
if computer=="paper":
print("Player wins!")
player_wins+=1
elif computer=="rock":
print("Computer wins!")
computer_wins+=1
else:
print("Something went wrong")
print(f"FINAL SCORES... Player:{player_wins} Computer:{computer_wins}")
if player_wins>computer_wins:
print("Bravoooo")
else:
print("Shit")
| true |
39148beb2114fccdf719e143a4da66607eee1b22 | nadiamarra/learning_python | /invert_dict.py | 962 | 4.21875 | 4 | fruit_to_colour={
'banana':'yellow',
'cherry':'red',
'orange':'orange',
'pear':'green',
'peach':'orange',
'plum':'purple',
'pomegranate':'red',
'strawberry':'red'
}
#inverting fruit_to_colour
colour_to_fruit={} #accumulator set as the new dict name
for fruit in fruit_to_colour: #iterating over the keys
colour=fruit_to_colour[fruit] #assigning all the values to the variable colour
#adding to the new dict
colour_to_fruit[colour]=fruit
###issue: there are more than one fruit for each of the colours associated
###with those three missing fruits
##
###if colour is not already a key in the accumulator
###add colour:[fruit] as an entry
##
## if not(colour in colour_to_fruit):
## colour_to_fruit[colour]=[fruit]
##
#####otherwise, append fruit to the existing list
##
## else:
## colour_to_fruit[colour].append(fruit)
##
| true |
fc416eac9e468b582974225de2c8d4fe1f43470b | arpitgupta275/MyCaptain-Python | /task1.py | 401 | 4.46875 | 4 | import math
# accepts radius of circle and computes area
radius = float(input('Input the radius of the circle : '))
area = math.pi * radius * radius
print(f'The radius of the circle with radius {radius} is: {area}')
# accepts a filename and prints its extension
filename = input('Input the Filename: ')
f_extns = filename.split('.')
print ('The extension of the file is : ' + repr(f_extns[-1]))
| true |
0cd177b0f508ba272e1cca5ec047800dc4753cba | AaronDonaldson74/code-challenges | /python/biggest_smallest.py | 591 | 4.15625 | 4 | ### biggest / smallest function
def biggest_smallest(selection, list_of_numbers):
# list_of_numbers = [43, 53, 27, 40, 100, 201]
list_of_numbers.sort()
smallest_num = (list_of_numbers[0])
biggest_num = (list_of_numbers[-1])
# selection = ("small")
if selection == ("small"):
print("smallest value = ", list_of_numbers[0])
elif selection == ('big'):
print("largest value = ", list_of_numbers[-1])
else:
print(list_of_numbers)
biggest_smallest("small", [3, 52, 27, 50, 145, 221])
biggest_smallest("big", [43, 53, 27, 40, 100, 201]) | true |
092c64fb38b2fa9190c62f47d53bfa2f1cb693f3 | AaronDonaldson74/code-challenges | /python/birthday.py | 508 | 4.78125 | 5 | # Create a variable called name and assign it a string with your name. Create a variable called current_year and assign it an int. Create a variable called birth_year and assign it an int. Using the following variables print the following result. Please print it using the f"" way.
# Example result: "Hello, my name is Daniel and I'm 36 years old"
name = "Aaron"
current_year = 2020
birth_year = 1974
statement = f"Hello, my name is {name} and I am {current_year - birth_year} years old."
print(statement) | true |
c2fbd24d7c4efc16cb8b2ce178482511234394ab | rdvnkdyf/codewars-writing | /python/sum-of-odd-numbers.py | 569 | 4.21875 | 4 | """
Given the triangle of consecutive odd numbers:
1
3 5
7 9 11
13 15 17 19
21 23 25 27 29
Calculate the row sums of this triangle from the row index (starting at index 1) e.g.:
row_sum_odd_numbers(1); # 1
row_sum_odd_numbers(2); # 3 + 5 = 8
"""
import functools
def row_sum_odd_numbers(n):
oddNumbers=[]
startNumber=(n*n)-(n-1);
while(n>0):
oddNumbers.append(startNumber)
startNumber+=2
n-=1
sum=functools.reduce(lambda a,b:a+b,oddNumbers)
return sum
| true |
0bed93426d83ed50a1dfb8df94b2fee2e6dd1963 | Nusrat-H/python-for-everybody | /MyownfunctionD.py | 793 | 4.40625 | 4 | """
Write a program to prompt the user for hours and rate per hour
using input to compute gross pay. Pay should be the normal rate for hours
up to 40 and time-and-a-half for the hourly rate for all hours worked
above 40 hours. Put the logic to do the computation of pay in a function
called computepay() and use the function to do the computation. The function
should return a value. Use 45 hours and a rate of 10.50 per hour to test the
program (the pay should be 498.75). You should use input to read a string
and float() to convert the string to a number.
hrs = input("h: ")
rate = input("r:")
h = float(hrs)
r = float(rate)"""
def computepay(h,r):
if h <= 40:
print ("pay", (h*r))
elif h>40:
print ("pay", (40*r+(h-40)*1.5*r))
computepay(45,10.5)
| true |
f6a555bb8191ed9f969793247810259c6e809d41 | aycelacap/py_playground | /Fundamentals/Basics i/041_list_slicing.py | 394 | 4.375 | 4 | string = "hello"
string[0:2:1]
# string[start:stop:step]
# we can apply the concept of string slicing to lists
# lists are mutable
# with list slicing, we create a new copy listlists are mutable
amazon_cart = new_cart
# these two variable would point on the same place in memory
# if instead we want to copy a list, they now point to different spot in memory
new_cart = amazon_cart[:]
| true |
6cf892b2d5ca9fe205c819ba3487f60a30c400b1 | aycelacap/py_playground | /Fundamentals/Basics i/053_dictionary_methods_ii.py | 1,076 | 4.5 | 4 | # how else can we look for items in a dictionary?
user = {
'basket': [1, 2, 3]
'greet': 'hello'
}
print('basket' in user) #True
print('hello' in user.keys()) #False
print('greet' in user.keys()) #True
# how can we grab items
print(user.items()) #this prints out a list of the key/value pairs, in tuple form
print(user.clear()) #None
# user.clear() # in place removes what the dictionary has
# print(user) # {}
user2 = user.copy()
print(user)
print(user2)
# the computer will make a copy of the user dictionary and it will be saved as user2
print(user.clear())
print(user2)
# this will return None because .clear will remove what the dictionary has and user2 will still print a list of tuples of the dictionary
print(user.pop('age')) #will print the dictionary without the popped value
# will user be mutated?
print(user)
# the method .pop mutates the dictionary in place so yes
# how can we update values to an existing dictionary?
print(user.update({
'age': 55
}))
# this will also add a key/value to the existing dict
print(user.update({
'ages': 125
})) | true |
a29f118e72afd2fea0af99e51e1133487de93a94 | aycelacap/py_playground | /Fundamentals/Basics i/037_type_conversion.py | 608 | 4.25 | 4 | name = "Ayce"
age = 100
relationship_status = "complicated"
relationship_status = "single"
# create a program that can guess your age
birth_year = input("What year were you born?")
guess = 2020 - int(birth_year)
print("your age is: {guess}")
# string interpolation and input from user as seen in video
# if confused
print(type(birth_year))
# sometimes we store data into different data types. We need to convert data into different data types
# note:
bool
int
float
**complex
str
list
tuple
set
dict
age = 2019 - bool(birth_year)
# bool converts to true, 1, so your age would be 2018
# if false, 0
| true |
3f7dd2e108ad2bd674d6f8483e30e6e70750f0c0 | pawlodkowski/advent_of_code_2020 | /day_12/part1.py | 2,139 | 4.28125 | 4 | """
Part 1 of https://adventofcode.com/2020/day/12
"""
# TO-DO: Is it possible to contain the navigation information in a single data structure?
CARDINALS = {"E": (1, 0), "S": (0, -1), "W": (-1, 0), "N": (0, 1)}
BEARINGS = [(1, 0), (0, -1), (-1, 0), (0, 1)] # maps to current bearing
def read_data(filename: str) -> list:
with open(filename, "r") as f:
data = f.read().split("\n")
return data
def chart_path(start_location: tuple, start_bearing: int, instructions: list) -> tuple:
"""
Given starting coordinates (e.g. (0,0)) and initial bearing (e.g. 0)
and a list of navigation instructions, chart the path of the ship
and return the final coordinates of the ship after executing all the instructions.
Here is a key for the current bearing meaning:
0 <-> 'E'
1 <-> 'S'
2 <-> 'W'
3 <-> 'N'
"""
current_location = start_location
current_bearing = start_bearing
for command in instructions:
action = command[0]
value = int(command[1:])
no_rotation = action == "F" or action in CARDINALS
if no_rotation:
if action == "F":
change_x = BEARINGS[current_bearing][0] * value
change_y = BEARINGS[current_bearing][1] * value
else:
change_x = CARDINALS[action][0] * value
change_y = CARDINALS[action][1] * value
current_location = (
current_location[0] + change_x,
current_location[1] + change_y,
)
else:
if action == "R":
current_bearing = (current_bearing + (int(value / 90))) % 4
# modulus 4 is to reset the rotation back to zero so the numbers cycle
else:
current_bearing = (current_bearing - (int(value // 90))) % 4
return current_location
if __name__ == "__main__":
data = read_data("input.txt")
final = chart_path((0, 0), 0, data)
print(
f"Solution: the final manhattan distance from the ship's starting point is {abs(final[0]) + abs(final[1])}."
)
| true |
02301984b7cf81be680136da913bf3696c16cab6 | Farah-H/python_classes | /class_task.py | 1,808 | 4.34375 | 4 | # Task
# create a Cat class
class Cat:
# Create 2 class level variables
coward = False
cute = True
fluffy = True
# one function which returns 'MEOWWWWWWW', added some details :)
def purr(self,cute,coward,fluffy):
if cute and fluffy:
print('You approach this adorable cat..')
if coward:
print('Oh no! You scared the cat away.')
else:
print('MEOWWWWWW')
else:
print('Ohh that cat looks kind of grumpy. Let\'s walk away for now.')
# create 3 objects of the class
jack = Cat()
shinny = Cat()
garfield = Cat()
# display all information with each object
print(f'Jack\'s Attributes: coward = {jack.coward}, cute = {jack.cute}, fluffy = {jack.fluffy}')
jack.purr(jack.cute,jack.coward, jack.fluffy)
print(f'Shinny\'s Attributes: coward = {shinny.coward}, cute = {shinny.cute}, fluffy = {shinny.fluffy}')
shinny.purr(shinny.cute,shinny.coward, shinny.fluffy)
print(f'Garfield\'s Attributes: coward = {garfield.coward}, cute = {garfield.cute}, fluffy = {garfield.fluffy}')
garfield.purr(garfield.cute,garfield.coward, jack.fluffy)
# change the class variables values in each object and display the object's attributes + outcome of purr() function
jack.coward = True
print(f'Jack\'s new Attributes: coward = {jack.coward}, cute = {jack.cute}, fluffy = {jack.fluffy}')
jack.purr(jack.cute,jack.coward, jack.fluffy)
shinny.fluffy = False
print(f'Shinny\'s new Attributes: coward = {shinny.coward}, cute = {shinny.cute}, fluffy = {shinny.fluffy}')
shinny.purr(shinny.cute,shinny.coward, shinny.fluffy)
garfield.cute = False
print(f'Garfield\'s new Attributes: coward = {garfield.coward}, cute = {garfield.cute}, fluffy = {garfield.fluffy}')
garfield.purr(garfield.cute,garfield.coward, jack.fluffy) | true |
3fbba0b056c2aa515949f6be884331401a6d71ad | G8A4W0416/Module6 | /more_functions/validate_input_in_functions.py | 921 | 4.34375 | 4 | def score_input(test_name, test_score=0, invalid_message='Invalid test score, try again!'):
""" This takes in a test name, test score, and invalid message. The user is prompted for a valid test score until it
is in the range of 0-100, then prints out the valid input as 'Test name: ##'.
:param test_name: String name passed in
:param test_score: Int score passed in. Optional, with default value of 0 (zero)
:param invalid_message: String invalid message passed in. Optional, with default value of
'Invalid test score, try again!'
:return: String showing test name with valid test score
"""
while True:
try:
test_score = int(test_score)
if 0 <= test_score <= 100:
break
else:
return invalid_message
except ValueError:
return invalid_message
return test_name + ": " + str(test_score)
| true |
6832afafc0f5c16e3222c3ce6051b5585bd7710d | General-Gouda/PythonTraining | /Training/Lists.py | 713 | 4.25 | 4 | student_names = [] # Empty List variable
student_names = ["Mark","Katarina","Jessica"] # List variable with 3 entries
print(student_names)
student_names.append("Homer") # Adds Homer into the List
print(student_names)
if "Mark" in student_names: # Checks to see if the string "Mark" is in the List student_names
print(True)
else:
print(False)
print(len(student_names)) # Len gives the count of the number of elements within a List
del student_names[2] # Deletes the name Jessica and shifts all elements after Jessica to the left.
print(student_names)
print(student_names[1:]) # Skips first element in the list and gives the rest
print(student_names[1:-1]) # Ignores first and last element in List | true |
ac743ad6bd03bedb544e59d2d1797fc3ff2b7a9e | General-Gouda/PythonTraining | /Training/ForLoops.py | 975 | 4.4375 | 4 | student_names = ["Mark", "Katarina", "Jessica"]
for name in student_names:
print("Student name is {0}".format(name)) # Interates through each element in the List. There is no ForEach in Python. For does it automatically.
x = 0
for index in range(10): # Range(10) if it were printed would look like [0,1,2,3,4,5,6,7,8,9]
x += 10
print("The value of X is {0}".format(x))
print("")
for index in range(10):
x = index
print("The value of X is {0}".format(x)) # see?
print("")
# This time the range starts at the number 5 and goes to 9. The first number in the range must be.
# inside the range itself. 5 is inside the range 0 the 9 but 10 is outside so nothing is printed.
for index in range(5, 10):
x = index
print("The value of X is {0}".format(x))
print("")
# starts at 5 and increments by 2 (starting number, end of interations, increments of)
for index in range(5, 10, 2):
x = index
print("The value of X is {0}".format(x))
| true |
df05bbb841a4142ff87889cce1e1f014de49987c | ad-egg/holbertonschool-higher_level_programming | /0x0A-python-inheritance/100-my_int.py | 583 | 4.1875 | 4 | #!/usr/bin/python3
"""
this module contains a class MyInt which inherits from int
"""
class MyInt(int):
"""
this class MyInt inherits from int but has == and != operators inverted
"""
def __init__(self, value=0):
"""
instantiates an instance of MyInt with value
"""
self.__value = value
def __eq__(self, other):
"""
inverts == return value
"""
return self.__value != other
def __ne__(self, other):
"""
inverts != return value
"""
return self.__value == other
| true |
b7849c1c75bd8ae24fbe9c4d8b136b4b1c5bcd19 | ad-egg/holbertonschool-higher_level_programming | /0x08-python-more_classes/4-rectangle.py | 2,717 | 4.59375 | 5 | #!/usr/bin/python3
"""
This module contains an empty class that defines a rectangle.
"""
class Rectangle:
"""an empty class Rectangle that defines a rectangle
a rectangle is a parallelogram with four right angles
"""
def __init__(self, width=0, height=0):
"""
instantiates a rectangle with private instance attributes
height and width
"""
if not isinstance(width, int):
raise TypeError("width must be an integer")
elif width < 0:
raise ValueError("width must be >= 0")
else:
self.__width = width
if not isinstance(height, int):
raise TypeError("height must be an integer")
elif height < 0:
raise ValueError("height must be >= 0")
else:
self.__height = height
@property
def width(self):
"""
retrieves the width of the rectangle
"""
return self.__width
@width.setter
def width(self, value):
"""
sets the width of the rectangle
"""
if not isinstance(value, int):
raise TypeError("width must be an integer")
elif value < 0:
raise ValueError("width must be >= 0")
else:
self.__width = value
@property
def height(self):
"""
retrieves the height of the rectangle
"""
return self.__height
@height.setter
def height(self, value):
"""
sets the height of the rectangle
"""
if not isinstance(value, int):
raise TypeError("height must be an integer")
elif value < 0:
raise ValueError("height must be >= 0")
else:
self.__height = value
def area(self):
"""
this public instance method returns the area of the rectangle
"""
return self.width * self.height
def perimeter(self):
"""
this public instance method returns the perimeter of the rectangle
"""
if self.width == 0 or self.height == 0:
return 0
else:
return self.width * 2 + self.height * 2
def __str__(self):
"""
returns a string that is rectangle using hash characters and newlines
"""
string = ""
if self.width > 0 and self.height > 0:
string = "".join(('#' * self.width + '\n') * self.height)
string = string[:-1]
return string
def __repr__(self):
"""
returns a string representation of the rectangle that allows
creation of a new instance
"""
return "Rectangle({:d}, {:d})".format(self.width, self.height)
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.