text stringlengths 37 1.41M |
|---|
def fact(n):
f=1
for i in range(1,(n+1)):
f=f*i
return f
for i in range(1,6):
print ("Factorial of ", i , " is ", fact(i))
|
#Задача 5. Вариант 11.
#Напишите программу, которая бы при запуске случайным образом
#отображала имя одного из девяти оленей Санта Клауса.
#Крутова Дарья
#15.09.2016
import random
oleni = ['Dasher',
'Prancer',
'Vixen',
'Comet',
'Cupid',
'Donder',
'Blitzen',
'Rudolph']
olen = random.choice(oleni)
print('Программа случайным образом отображает имя одного из оленей Саны.')
print(olen)
input("\n\nHaжмитe Enter. чтобы выйти.") |
class Employee:
num_of_employee = 0
raise_amount =1.04 #class variable
def __init__(self, firstName, lastName, pay): #constructor
# instance variables
self.firstName = firstName
self.lastName = lastName
self.pay = pay
self.email = firstName + '.' + lastName + '@company.com'
Employee.num_of_employee += 1
def getFullName(self):
return '{} {}'.format(self.firstName, self.lastName)
def apply_raise(self):
self.pay = int(self.pay * self.raise_amount)
@classmethod
def set_raise_amt(cls, amount):
cls.raise_amount = amount
@classmethod #alternative constructor
def from_string(cls, employee_str):
firstName, lastName, pay = employee_str.split('-')
return cls(firstName, lastName, pay)
@staticmethod #use static methods when you dont access the instance or class
def is_workday(day):
if day.weekday() == 5 or day.weekday() == 6: #saturday and sunday
return False
return True
employee1 = Employee('Patrick', 'Wang', 5000)
employee2 = Employee('Test','User', 4000 )
import datetime
my_date = datetime.date(2018, 6, 12)
print(employee1.num_of_employee)
print(employee2.num_of_employee)
|
# This file will play a tic tac toe game
def main():
tic_tac_toe()
if __name__ == '__main__':
main()
# functions are need
def tic_tac_toe():
curr_board = initial_board() # This will generate a board
print_board(curr_board)
lst_pl1 = []
lst_pl2 = []
while win is False:
player1 = raw_input("Please enter the location for player1 in the format (*,*): ")
lst_pl1.append(player1)
curr_board = player(player1,1)
print_board(curr_board)
win = win(lst_pl1,player1)
if win is TRUE:
print "player 1 wins"
break
else:
player2 = raw_input("Please enter the location for player2 in the format (*,*): ")
lst_pl2.append(player2)
curr_board = player(player2,2)
print_board(curr_board)
win = win(lst_pl2,player2)
print "player2 wins"
def initial_board():
line1 = [(1,1),(1,2),(1,3)]
line2 = [(2,1),(2,2),(2,3)]
line3 = [(3,1),(3,2),(3,3)]
board = [line1,line2,line3]
return board
def print_board(board):
for line in board:
print line
def player(var,flag_player):
if flag_player == 1:
curr_board[var[0]][var[1]] == 'X'
elif flag_plaer == 2:
curr_board[var[0]][var[1]] == 'O'
return curr_board
def find(lst,a):
result = []
for i, x in enumerate(lst):
if x==a:
result.append(i)
return result
def win(lst,flag_player):
row = []
col = []
if (1,1) in lst and (2,2) in lst and (3,3) in lst:
print flag_player,"wins"
return False
elif (3,1) in lst and (2,2) in lst and (1,3) in lst:
print flag_player,"wins"
return False
else:
for x in lst:
row.append(x[0])
col.append(x[1])
for i in range(len(row)):
if row.count(row[i]) == 3 or col.count(col[i]) == 3:
print flag_player,"wins"
break
return False
return True
|
"""
Python code to demonstrate naive method to compute zip
"""
def my_zip(lst1, lst2):
new_list = []
for x in range(0, len(lst1)):
new_list.append((lst1[x], lst2[x]))
return new_list
def my_zip2(lst1, lst2):
return list(map(lambda x, y: (x, y), lst1, lst2))
def my_zip3(lst1, lst2):
return list((lst1[x], lst2[x]) for x in range(0, len(lst1)))
|
def my_range(start: int, end: int = None, step: int = None):
"""
Python code to demonstrate naive method to compute range
"""
if step is None:
step = 1
if end is None:
start = 0
end = start
if type(end) != int or type(start) != int or type(step) != int:
raise TypeError('Please enter a correct type !!!')
while True:
if start < end:
yield start
start += step
elif start > end:
yield start
start -= step
|
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 10 22:28:07 2018
@author: hashimoto
"""
import pandas as pd
xls_input = pd.read_excel('第3表.xls',
skiprows=3, # 先頭3行無視
skip_footer=2, # 末尾2無視
parse_cols='W,Y:AJ',
index_col=0) # 西暦列をインデックス指定
print(xls_input)
# インプットの項目数（行数 * カラム数）を返却します。
print(xls_input.size)
#行数を確認
print(len(xls_input))
#カラム数を確認
print(len(xls_input.columns))
#次元の確認
print(xls_input.shape)
#カラム情報
print(xls_input.columns)
|
class MyBase:
coeff = 2
def __init__(self,x):
self.x = x
def mult(self):
return self.coeff * self.x
class MyDeriv(MyBase):
coeff = 3
def __init__(self, x, y):
super().__init__(x)
self.y = y
def mult2(self):
return self.coeff * self.y
a = MyBase(3)
print(a.mult())
b = MyDeriv(3, 5)
print(b.mult2())
print(b.mult())
|
# Simulador de Árbitro de Barramento
# Entradas
n_perifericos = int(input('Insira a quantidade de perifericos: '))
perifericos = []
print('\nInforme quais são os perfirecos:')
for i in range(0,n_perifericos):
perifericos.append(int( input() ))
periferico_prioridade = {}
print('\nInforme a prioridade de cada periferico:')
for i in perifericos:
periferico_prioridade[i] = (int( input() ))
print('\nInforme a ordem de solicitação dos periféricos (1 a 3, sendo 1 a mais baixa) (Digite S para sair): ')
ordem_time_solicitacao = []
while (True):
valor = input()
if (valor == 's' or valor =='S'):
break
else:
ordem_time_solicitacao.append([int(valor),0])
print('\nInforme o tempo (multiplo de 5) para cada periferico')
for i in ordem_time_solicitacao:
i[1] = int(input())
print('\nPeriferico e prioridade:\n',periferico_prioridade)
print('\nOrdem e tempo:\n',ordem_time_solicitacao, '\n')
# Dayse chaning
def daisyChaining (ordem_time):
dayse_chaning = []
for i in ordem_time:
dayse_chaning.append(i[0])
print("Dayse Chaning:", ' '.join(map(str, dayse_chaning)))
return dayse_chaning
# Fixa
def prioridadeFixa(ordem_time, peri_prioridade):
fixa = []
for i in range(1,4): #esse for considera que a prioridade varia de 1 a 3
prioridade_atual = 4 - i
for j in ordem_time:
if peri_prioridade[j[0]] == prioridade_atual:
fixa.append(j[0])
print("Prioridade fixa:", ' '.join(map(str, fixa)))
return fixa
# Rotativa
def rotativa(ordem_time, peri_prioridade):
peri_prioridade_inverso = peri_prioridade.copy()
#inverte prioridades considerando que varia de 1 a 3
for key, value in peri_prioridade_inverso.items():
if value == 3:
peri_prioridade_inverso[key] = 1
elif value == 1:
peri_prioridade_inverso[key] = 3
else:
pass
rotativa = []
for i in range(1,4): #esse for considera que a prioridade varia de 1 a 3
prioridade_atual = 4 - i
for j in ordem_time_solicitacao:
if peri_prioridade_inverso[j[0]] == prioridade_atual:
rotativa.append(j[0])
print("Prioridade rotativa:", ' '.join(map(str, rotativa)))
return rotativa
# Justiça
def justica(ordem_time):
ordem_time_copy = [row[:] for row in ordem_time]
justice = []
while(ordem_time_copy):
for i in ordem_time_copy:
if i[1] > 0:
justice.append(i[0])
i[1] = i[1] - 5
for i in ordem_time_copy:
if i[1] == 0:
ordem_time_copy.remove(i)
print("Justiça:", ' '.join(map(str, justice)))
return justice
daisyChaining(ordem_time_solicitacao)
prioridadeFixa(ordem_time_solicitacao,periferico_prioridade)
rotativa(ordem_time_solicitacao,periferico_prioridade)
justica(ordem_time_solicitacao) |
inteiro = int(input("Digite um inteiro:"))
if inteiro % 3 == 0 and inteiro % 5 == 0:
print("FizzBuzz")
else:
print(inteiro)
|
import math
class Bhaskara:
## Functions
def delta(self, a, b, c):
return int((b ** 2 - 4 * a * c))
# Inputs
def main(self):
a = float(input('Digite "a":'))
b = float(input('Digite "b":'))
c = float(input('Digite "c":'))
print(self.calcula_raizes(a, b, c))
# Print Roots
def calcula_raizes(self, a, b, c):
delt = self.delta(a, b, c)
if delt == 0:
raiz = (-b + math.sqrt(delt)) / (2 * a)
return 1, raiz
else:
if delt < 0:
return 0
else:
raiz1 = (-b + math.sqrt(delt)) / (2 * a)
raiz2 = (-b - math.sqrt(delt)) / (2 * a)
return 2, raiz1, raiz2
|
def ordenada(lista):
ordem = True
for index in range(len(lista)-1):
if lista[index] > lista[index + 1]:
ordem = False
return ordem
|
inteiro = int(input("Digite um número inteiro: "))
i = 1
if inteiro > 1:
for i in range(2, inteiro):
if (inteiro % i) == 0:
print("não primo")
break
else:
print("primo")
else:
print("não primo")
|
import math
a = float(input('Digite "a":'))
b = float(input('Digite "b":'))
c = float(input('Digite "c":'))
delta = b**2 - 4*a*c
def raiz1(a,b,delta):
raiz = (-b + math.sqrt(delta)) / (2 * a)
return raiz
def raiz2(a,b,delta):
raiz = (-b - math.sqrt(delta)) / (2 * a)
return raiz
if delta == 0:
print(f"a raiz desta equação é {raiz1(a,b,delta)}")
elif delta < 0 :
print(f"esta equação não possui raízes reais")
else:
if raiz1(a,b,delta) < raiz2(a,b,delta):
print(f"as raízes desta equação são {raiz1(a,b,delta)} e {raiz2(a,b,delta)}")
else:
print(f"as raízes desta equação são {raiz2(a, b, delta)} e {raiz1(a, b, delta)}")
|
import math
class Triangulo:
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
def retangulo(self):
if math.sqrt(self.a**2 + self.b**2) == self.c:
return True
return False
# t = Triangulo(1, 3, 5)
# print(t.retangulo())
# # deve devolver False
# u = Triangulo(3, 4, 5)
# print(u.retangulo())
# # deve devolver True |
from dna import DNA
import random
import math
class Population():
def __init__(self, strength, mutation_rate, aim):
self.strength = strength
self.mutation_rate = mutation_rate
self.aim = aim
self.population = []
def get_strength(self):
return self.strength
def get_mutation_rate(self):
return self.mutation_rate
def calc_fitness(self):
for i in self.population:
i.calc_fitness()
def find_best_fitness(self):
best_fitness = -1
best_fit = None
for i in self.population:
if i.fitness > best_fitness:
best_fitness = i.fitness
best_fit = i.dna
return {'fitness': best_fitness, 'fit': best_fit}
def create_population(self):
for i in range(self.strength):
self.population.append(DNA(self.aim, self.mutation_rate))
self.population[i].create_dna()
self.calc_fitness()
def selection1(self):
m = DNA.get_total_fitness()
num1 = random.randint(1, m + 10)
num2 = random.randint(1, m + 10)
num_1 = num1
num_2 = num2
first_population = None
second_population = None
i = 0
while first_population == None or second_population == None:
if first_population == None:
num1 -= self.population[4].fitness
if num1 <= 0:
first_population = self.population[i]
if second_population == None:
num2 -= self.population[2].fitness
if num2 <= 0:
second_population = self.population[i]
i += 1
if i >= self.strength:
if num2 == num_2 or num1 == num_1:
first_population = self.population[random.randint(0, self.strength - 1)]
second_population = self.population[random.randint(0, self.strength - 1)]
else:
i = 0
return {'first': first_population, 'second': second_population}
def selection(self):
mating_pool = []
for i in self.population:
n = math.floor(i.fitness * 100)
for j in range(n):
mating_pool.append(i)
first = mating_pool[random.randint(0, len(mating_pool) - 1)]
second = mating_pool[random.randint(0, len(mating_pool) - 1)]
return {'first': first, 'second': second}
def crossover(self, first, second):
point = random.randint(0, len(self.aim) - 1)
new_dna = DNA(self.aim, self.mutation_rate)
for i in range(len(self.aim)):
if i <= point:
new_dna.dna.append(first.dna[i])
else:
new_dna.dna.append(second.dna[i])
new_dna.calc_fitness()
return new_dna
def evolve(self):
for i in range(self.strength):
res = self.selection()
first = res['first']
second = res['second']
res = self.crossover(first, second)
self.population[i] = res
self.population[i].mutate()
def print_population(self):
for i in range(self.strength):
print(self.population[i].dna, end=" ")
print(self.population[i].fitness, end=" POP\n")
|
class Grunts:
"""Modeling a Grunt enemy."""
def __init__(self, name, rank, type, armor_color, shield, grenade_count,
shield_strength, health_points, points, *weapon):
"""Establish the attributes of a Grunt."""
self.name = name.title()
self.rank = rank.title()
self.type = type.title()
self.armor_color = armor_color.title()
self.shield = shield
self.grenade_count = grenade_count
self.shield_strength = shield_strength
self.health_points = health_points
self.points = points
self.weapon = weapon
# def get_weapon(self): Trying to produce a variable to clean up formatting when weapons
# for x in self.weapon: print out.
# print(f"{x.title()}")
# return x
#
# y = get_weapon
# y(grunt_major)
def describe_grunt_minor(self):
"""Describe an Grunt Minor"""
print(f"The following is a breakdown of the enemy known as: {self.name.title()}")
print(
f"Name: {self.name} "
f"\nRank: {self.rank} "
f"\nType: {self.type} "
f"\nArmor Color: {self.armor_color} "
f"\nShield: {self.shield} "
f"\nGrenade Count: {self.grenade_count} "
f"\nShield Strength: {self.shield_strength} "
f"\nHealth: {self.health_points} "
f"\nPoints: {self.points}")
print("\nWeapon(s): ".strip())
for item in self.weapon:
print(f"{item.title()}")
def describe_grunt_major(self):
"""Describe a Grunt Major"""
print(f"The following is a breakdown of the enemy known as: {self.name.title()}")
print(
f"Name: {self.name} "
f"\nRank: {self.rank} "
f"\nType: {self.type} "
f"\nArmor Color: {self.armor_color} "
f"\nShield: {self.shield} "
f"\nGrenade Count: {self.grenade_count} "
f"\nShield Strength: {self.shield_strength} "
f"\nHealth: {self.health_points} "
f"\nPoints: {self.points}")
print("\nWeapon(s): ".strip())
for item in self.weapon:
print(f"{item.title()}")
def describe_grunt_specops(self):
"""Describe a Grunt Spec Ops"""
print(f"The following is a breakdown of the enemy known as: {self.name.title()}")
print(
f"Name: {self.name} "
f"\nRank: {self.rank} "
f"\nType: {self.type} "
f"\nArmor Color: {self.armor_color} "
f"\nShield: {self.shield} "
f"\nGrenade Count: {self.grenade_count} "
f"\nShield Strength: {self.shield_strength} "
f"\nHealth: {self.health_points} "
f"\nPoints: {self.points}")
print("\nWeapon(s): ".strip())
for item in self.weapon:
print(f"{item.title()}")
grunt_minor = Grunts(
'grunt minor',
'minor',
'light infantry',
'orange',
None,
None,
100,
15,
'needler',
'plasma pistol',
)
grunt_major = Grunts(
'grunt major',
'major',
'light infantry',
'red',
None,
2,
None,
150,
25,
'plasma pistol',
'needler',
)
grunt_specops = Grunts(
'grunt spec ops',
'special operations',
'special infantry',
'black',
None,
4,
None,
150,
25,
'fuel rod gun',
'plasma pistol',
'needler',
)
# grunt_major.y()
grunt_major.describe_grunt_major()
print("\n")
grunt_minor.describe_grunt_minor()
print("\n")
grunt_specops.describe_grunt_specops()
|
import os
import random
from .Game import Game
class TicTacToe(Game):
def __init__(self):
""" TicTacToe Game """
super(TicTacToe, self).__init__()
self.playerLetter = 'X'
self.computerLetter = 'O'
@staticmethod
def clear():
""" Clear console/terminal """
if os.name == 'posix':
os.system('clear')
else:
os.system('cls')
def play(self):
""" Starting match """
self.clear()
self.turn = self.randomInitialTurn()
self.playing = True
while self.playing:
self.clear()
if self.turn == 'player':
self.turnPlayer()
else:
self.turnComputer()
def endGame(self):
""" Enclose Match """
self.playing = False
@staticmethod
def randomInitialTurn():
""" Select first start player """
if random.randint(0, 1) == 0:
return 'computer'
else:
return 'player'
def turnPlayer(self):
self.draw()
self.makeMove(self.playerLetter, self.getPlayerMove())
if self.isWinner(self.playerLetter):
self.draw()
self.endGame()
print('[You won!]')
elif self.isFull:
self.draw()
self.endGame()
print('[Tie]')
else:
self.turn = 'computer'
def turnComputer(self):
self.makeMove(self.computerLetter, self.getComputerMove())
if self.isWinner(self.computerLetter):
self.draw()
self.endGame()
print('[You lost.]')
elif self.isFull:
self.draw()
self.endGame()
print('[Tie]')
else:
self.turn = 'player'
if __name__ == '__main__':
game = TicTacToe()
game.clear()
print("""
######################################
##### T i c T a c T o e #####
######################################
Game map : )
""")
game.drawMap()
input('[PRESS ANY KEY TO CONTINUE...]')
while True:
game.play()
if not input('Play Again? (y/n)').lower().startswith('y'):
break
else:
game.reset()
|
import json
import time
"""
Miscellaneous functions unrelated to making the tree
"""
def loadWords(filepath):
"""
loads words from filepath
"""
with open(filepath) as f:
return json.load(f)
def possibleWords(substr, word_list):
"""
given a substring, returns a list of all possible words with that substring
# """
temp = []
for i in word_list:
if substr in i:
temp.append(i)
return temp
def isWord(word, word_list):
if word in word_list:
return True
else:
return False
def filter(word_list):
"""
filters the wordlist, a list
"""
print(f"Length before filtering: {len(word_list)}")
word_list = [i for i in word_list if i.isalpha() and i.islower()]
word_list = [i for i in word_list if len(i) >= 4]
print(f"Length after filtering: {len(word_list)}")
return word_list
def main():
"""
filters the wordlist
"""
# filters the word list to remove
startTime = time.time()
# opens dictionary
with open("words/u.txt") as f:
word_list = json.load(f)
word_list = filter(word_list)
with open("words/ubuntu_f.txt", 'w') as fout:
fout.write(json.dumps(word_list))
endTime = time.time()
print(f"Program completed in {round(endTime - startTime, 2)} seconds")
if __name__ == "__main__":
main() |
# Uses python2
import sys
def binary_search(array, x):
high = len(array) - 1 # Offset to handle zero indexed array
low = 0
while low <= high:
mid = (low + high) / 2
if x == array[mid]:
return mid
elif x < array[mid]:
high = mid - 1
elif x > array[mid]:
low = mid + 1
return -1
# write your code here
def linear_search(a, x):
for i in range(len(a)):
if a[i] == x:
return i
return -1
if __name__ == '__main__':
data = [int(i) for i in sys.stdin.read().split()]
n = data[0]
m = data[n + 1]
a = data[1 : n + 1]
for x in data[n + 2:]:
# replace with the call to binary_search when implemented
print str(binary_search(a, x)) + ' '
|
# Uses python2
import sys
"""
A natural subproblem in this case is the following:
C(n) is the minimum number of operations
required to obtain n from 1 (using the three primitive operations).
How to express C(n) through C(n/3), C(n/2), C(n - 1)?
QUESTION How many operations required to go from C(n - 1) to C(n)?
ANSWER 1 more operation because we can use the +1 op
http://d.pr/i/4r7V
"""
def optimal_sequence(N):
"""return optimal sequence"""
min_num_ops = [0, 0]
for i in range(2, N + 1):
min_num_ops.append(min_num_ops[i - 1] + 1)
if i % 2 == 0:
num_ops = min_num_ops[(i / 2)] + 1
if num_ops < min_num_ops[i]:
min_num_ops[i] = num_ops
if i % 3 == 0:
num_ops = min_num_ops[(i / 3)] + 1
if num_ops < min_num_ops[i]:
min_num_ops[i] = num_ops
return create_optimal_sequence(N, min_num_ops)
def create_optimal_sequence(N, min_num_ops):
sequence = [N]
cur_val = N
i = 1
while cur_val > 0:
min_op = min_num_ops[cur_val - 1]
sequence.append(cur_val - 1)
updated_val = cur_val - 1
if cur_val % 2 == 0:
if min_num_ops[cur_val / 2] < min_op:
sequence[i] = cur_val / 2
updated_val = cur_val / 2
if cur_val % 3 == 0:
if min_num_ops[cur_val / 3] < min_op:
sequence[i] = cur_val / 3
updated_val = cur_val / 3
cur_val = updated_val
i += 1
sequence.reverse()
return sequence[1:]
if __name__ == '__main__':
input = sys.stdin.read()
n = int(input)
sequence = list(optimal_sequence(n))
print(len(sequence) - 1)
for x in sequence:
print str(x) + " "
|
class Queue:
def __init__(self):
self.items = []
self.consumerTime = 0
self.producerTime = 0
self.graphTime = 0
self.numberOfItemsSent = 0
self.numberOfItemsConsume = 0
def isEmpty(self):
return len(self.items) < 3
def enqueue(self, item):
self.items.insert(0,item)
def dequeue(self):
return self.items.pop()
def size(self):
return len(self.items) |
import math
p1 = math.radians(float(input("Enter latitude 1: ")))
m1 = math.radians(float(input("Enter longtitude 1: ")))
p2 = math.radians(float(input("Enter latitude 2: ")))
m2 = math.radians(float(input("Enter longtitude 2: ")))
R = 6372.8
dp = p2 - p1
dm = m2 - m1
a = (math.sin(dp/2))**2 + math.cos(p1) * math.cos(p2) * (math.sin(dm/2))**2
c = 2 * math.asin(math.sqrt(a))
d = R * c
print('The distance between those two point is about {:.0f} km'.format(d))
|
# 3.1 (Validating User Input) Modify the script of Fig. 3.3 to validate its inputs. For any
# input, if the value entered is other than 1 or 2, keep looping until the user enters a correct
# value. Use one counter to keep track of the number of passes, then calculate the number
# of failures after all the user’s inputs have been received.
fail = 0
passed = 0
counter = 1
while counter <= 10:
x=int(input("enter a number"))
if x == 1:
passed += 1
else:
fail +=1
counter +=1
print(passed)
print(fail) |
#Insertion sort
import random
def sort(array):
for i in range(len(array)):
valueToInsert = array[i]
holePos = i
while(holePos > 0 and valueToInsert < array[holePos - 1]):
array[holePos] = array[holePos - 1]
holePos = holePos - 1
array[holePos] = valueToInsert
return array
def main():
print '************************* INSERTION SORT ***************************'
length = int(raw_input('Enter the length of the array: '))
array = [None]*length
for i in range(length):
array[i] = random.randint(1,length)
print 'ORIGINAL ARRAY: ',array ,'\n\n'
array = sort(array)
print 'SORTED ARRAY: ',array,'\n\n'
if __name__ == '__main__':
main() |
# 집합 (set)
# 집합 (set) 자료형 (순서x, 중복x)
#선언
a = set([])
print(type(a))
b = set([1, 2, 3, 4])
c = set([1, 4, 5, 6])
d = set([1, 2, 'pen', 'cap', 'Plate'])
e = {'foo', 'bar', 'baz', 'fodd', 'qux'} #-> 키없이 나열하면 셋임!
f = {42, 'foo', (1, 2, 3), 3.141234}
print('a - ', type(a), a)
print('b - ', type(b), b)
print('c - ', type(c), c)
print('d - ', type(d), d)
print('e - ', type(e), e)
print('f - ', type(f), f)
# 튜플 변환 (set -> tuple)
t = tuple(b)
print('t - ', type(t))
print('t - ', t[0], t[1:3])
# 리스트 변환 (set -> list)
l = list(c)
l2 = list(e)
print('l - ', l)
print('l2 - ', l2)
# 길이
print(len(a))
print(len(b))
print(len(c))
print(len(d))
# 집합 자료형 활용
s1 = set([1, 2, 3, 4, 5, 6])
s2 = set([4, 5, 6])
print('s1 & s2 : ', s1 & s2)
print('s1 & s2 : ', s1.intersection(s2))
print('s1|s2 : ', s1|s2)
print('s1|s2 : ', s1.union(s2))
print('s1 - s2 : ', s1 - s2)
print('s1 - s2 : ', s1.difference(s2))
# 중복 원소 확인
print('s1 & s2 : ', s1.isdisjoint(s2)) #교집합이 있느 있으면 펄
# 부분 집합 확인
print('subset :',s1.issubset(s2)) # s1이 s2의 부분집합이냐
print('superset :',s1.issuperset(s2))
# 추가 & 제거
s1 = set([1, 2, 3, 4])
s1.add(5)
print('s1 - ', s1)
s1.remove(2)
print('s1 - ', s1)
s1.discard(7) # -> 에러(예외)가 발생하지 않음.
print('s1 - ', s1)
s1.clear()
|
# while문
customer = '토르'
index = 5
while index >= 1:
print('{0}, 커피가 준비 되었습니다. {1} 번 남았어요.'.format(customer, index))
index -= 1
if index == 0:
print('커피 아웃입니다.')
customer = '아이언맨'
index = 1
while True:
print('{0}, 커피가 준비 되었습니다. 호출 {1} 회.'.format(customer, index))
index += 1
customer = '토르'
person = 'unknown'
while person != customer : # person이 customer 가 아니라면 계속 반복
print('{0}, 커피가 준비 되었습니다.'.format(customer))
person = input('이름이 어떻게 되세요?') |
# 표준 입출력
import sys
print('python', 'java', sep=' vs ')
print('python', 'java', sep=' , ', end='?') # end : 문장의 끝 부분을 변경 & 문장 한 줄로 붙임
print(' 무엇이 더 재밌을까요?')
print('python', 'java', file=sys.stdout) # 표준 출력
print('python', 'java', file=sys.stderr) # 표준 에러
# 시험 성적
scores = {'수학':0, '영어':50, '코딩':100}
for subject, score in scores.items(): # .items() : 키와 밸류 쌍으로 나옴
# print(subject, score)
print(type(subject),type(score))
print(subject.ljust(4), str(score).rjust(4), sep = ':') # ljust(8) : 8 개의 공간을 확보하고 왼쪽 정렬
# 은행 대기순번표
# 001, 002, 003
for num in range(1,21):
print('대기번호 : ' + str(num).zfill(3))
# 표준 입력
answer = input('아무 값이나 입력하세요 : ')
print(type(answer)) # str으로 나옴, 항상 문자열로 저장됨
|
# chapter03-01
# 숫자형
# 파이썬 지원 자료형
"""
int : 정수
float : 실수
complex : 복소수
bool : 불린
str : 문자열 (시퀀스)
list : 리스트 (시퀀스)
tuple : 튜블(시퀀스)
set : 집합
dict : 사전
"""
# 데이터 타입
str1 = "Python"
bool = True
str2 = 'Anaconda'
float_v = 10.0 # 10 == 10.0 false
int_v = 7
list = [str1, str2]
print(list)
dict = {
"name": "Machine Learning",
"version" : 2.0
}
tuple = (7, 8, 9)
set = {7, 8, 9}
print(type(str1))
print(type(str2))
print(type(bool))
print(type(int_v))
print(type(float_v))
print(type(int_v))
print(type(dict))
print(type(tuple))
print(type(set))
# 숫자형 연산자
"""
+
-
*
/
// : 몫
% : 나머지
abs() : 절대값
pow(x, y) x**y -> x의 y승
"""
#정수 선언
i = 77
i2 = -14
big_int = 312645987494465496789864894649848948949498489875646531658998
#정수 출력
print(i)
print(i2)
print(big_int)
#실수 출력
f = 0.312645987494465496789864894649848948949498489875646531658998
f2 = 3.141592
f3 = -3.9
f4 = 3/9
print(f)
print(f2)
print(f3)
print(f4)
#연산 실습
i1 = 39
i2 = 393
i3 = 9889489
i4 = 6412233131
f1 = 1.234
f2 = 3.939
print("f1 + f2 : ", f1 + f2)
print()
# 형 변환 실습
a = 3.
b = 6
c = .7
d = 12.7
# 타입 출력
print(type(a), type(b), type(c), type(d))
#형 변환 핵심!
print(float(b))
print(int(c))
print(int(d))
print(int(True)) # True : 1, False = 0
print(float(False))
print(complex('3')) # 문자형 -> 숫자형
print(complex(False))
# 수치 연산 함수
print(abs(-7))
x, y = divmod(100, 8)
print(x, y)
print(pow(5,3), 5**3)
# 외부 모듈
import math
print(math.ceil(5.1))
print(math.pi)
|
# First Option with one string
#data="Hello Python"
#print(data)
# Second option
# We can store a string in double quotes in whole single quote string and vise versa
#myURL='www."gmail".com'
#print(myURL)
# now Three quotes"""- for the multiple line
#myURL="""
# This is my python program
# website is "www.python.com
# call Whatsup :
# """
#print(myURL)
# Concatinating the string
#print("Hello" + myURL+ "Thank you")
# * opeartor can be used to display multiple times
#print(myURL * 3)
# take input from the user
name=input("Please enter your first name and last name : ")
address=input("Please enter your address: ")
profile=input("Please enter your job profile : ")
print(" Person " + name + " lives in " + address +" Working as " + profile)
|
# syntax
# for i in range(10, 5, -2):
# print(i)
# taking input from user
number = input("Please enter the number : ")
for i in range(10, 0, -1):
print(int(number)*i)
|
list1=[23, 33.4, "Testing", 55, 66, "World"]
# Here I am fetching by index
#print(list1[1])
# Range of Index
# print(list1[3:5])
# We are going to give starting index
#print(list1[2:])
# We are going to give End index
#print(list1[:4])
# Update any data in list
#list1[3]=100
#print(list1[3])
# insert a value
# list1.insert(2, "ABCD")
# print(list1)
# Remove a list
list1.remove(55)
print(list1)
|
#i = 5 # initialize the value
#while (i < 10): # Run this loop till its meets criteria
# print(i) # Printing the value
# i += 1 # to increment the value and its similar to i=i+1
# number for the user
number=input("Please enter the number : ")
i=1
while (i<10):
print(int(number)* i)
i+=1
|
import numpy as np
import random
def create_board():
return np.zeros((3,3))
def place(board, player, position):
if board[position] == 0:
board[position] = player
board = create_board()
place(board, 1, (0, 0))
def possibilities(board):
return list(zip(np.where(board == 0)[0], np.where(board == 0)[1]))
#print(possibilities(board))
def random_place(board,player):
position=random.choice(possibilities(board))
place(board,player,position)
random_place(board,2)
for i in range(3):
for player in [1, 2]:
random_place(board,player)
print(board)
def row_win(board, player):
for row in board:
if np.array_equal(row,np.full(3,player)):
return True
return False
print(row_win(board,1))
def col_win(board, player):
for col in board.T:
if np.array_equal(col,np.full(3,player)):
return True
return False
print(col_win(board,1))
def diag_win(board, player):
if (board[0,0]==player and board[1,1]==player and board[2,2]==player) or (board[2,0]==player and board[1,1]==player and board[0,2]==player):
return True
return False
print(diag_win(board,1))
def evaluate(board):
winner = 0
for player in [1, 2]:
# Check if `row_win`, `col_win`, or `diag_win` apply. if so, store `player` as `winner`.
if row_win(board,player) or col_win(board,player) or diag_win(board,player):
return player
if np.all(board != 0) and winner == 0:
winner = -1
return winner
print(evaluate(board))
def play_game():
board = create_board()
while True:
for player in [1,2]:
random_place(board,player)
check=evaluate(board)
if check!=0:
#print(board)
return check
print(play_game())
import time
import matplotlib.pyplot as plt
start=time.time()
results=[]
for i in range(0,1000):
results.append(play_game())
plt.hist(results)
plt.show()
end=time.time()
print(end-start)
def play_strategic_game():
board, winner = create_board(), 0
board[1,1] = 1
while winner == 0:
for player in [2,1]:
random_place(board,player)
winner=evaluate(board)
if winner != 0:
break
return winner
print(play_strategic_game() )
start=time.time()
results=[]
for i in range(0,1000):
results.append(play_strategic_game())
plt.hist(results)
plt.show()
end=time.time()
print(end-start) |
num1=int(input("Enter 1st no."))
num2=int(input("Enter 2nd no."))
num3=int(input("Enter 3rd no."))
if(num1>num2 and num1>num3):
print("{0} is greatest.".format(num1))
elif(num2>num1 and num2>num3):
print("{0} is greatest.".format(num2))
else:
print("{0} is greatest.".format(num3))
|
n = input ()
flag = 0
while n > 1:
if n % 2 == 0:
n /= 2
else:
print "NIE"
flag = 1
break
if flag == 0:
print "TAK"
|
def Combo(nums, target):
res = []
nums.sort()
dfs(nums, target, 0, [], res)
return res
def dfs(nums, target, index, path, res):
if target <0:
return
if target == 0:
res.append(path)
else:
for i in range(index, len(nums)):
if i > 0 and nums[i] == nums[i-1]:
continue
else:
dfs(nums,target-nums[i],i+1,path + [nums[i]],res)
print(Combo([2,3,4,6,7],7))
|
def plus_one(num):
flag = 1
for i in num:
if i != 9:
flag = 0
if flag == 1:
num[0] = 1
for i in range(1,len(num)):
num[i]=0
num.append(0)
return num
def plusone(num):
number = 0
for digit in num:
number = number*10 + digit
return [int(i) for i in str(number+1)]
print(plusone([9,9]))
|
from BST import Binary_Tree
def level_order(r):
stack = []
stack.append(r.root)
answer =[[r.root.value]]
count = 1
while stack:
temp = stack.pop(0)
if temp.left:
stack.append(temp.left)
if temp.right:
stack.append(temp.right)
count = count -1
if count ==0:
answer = answer + [[ item.value for item in stack]]
count = len(stack)
return answer
myTree = Binary_Tree()
myTree.insert(5)
myTree.insert(4)
myTree.insert(40)
myTree.insert(32)
print(level_order(myTree))
def low_level_order(r): #bottom up
def show(r, height):
res =[]
if height ==1:
res.append(r.value)
elif height>1:
show(r.left, i-1)
show(r.right, i-1)
return res
height = r.height()
res1 =[[]]
for i in range(height):
res1 = res1 + [show(r, i)]
return res1
myTree = Binary_Tree()
myTree.insert(5)
myTree.insert(4)
myTree.insert(40)
myTree.insert(32)
print(low_level_order(myTree.root))
|
def steal_values(num):
choose={}
for i in range(len(num)):
val = num[i]
if i>0 and i <len(num)-1 and val > num[i+1] + num[i-1]:
choose[i] = val
elif i ==0 and val > num[i+1]:
choose[i] = val
elif i == len(num)-1 and val > num[i-1]:
choose[i] = val
i = i +2
sum=0
for i in choose:sum = sum + choose[i]
return sum
print(steal_values([6,2,3,7]))
|
def first_missing_positive(num):
num.sort()
for i in range(0,len( num)):
if num[i] <=0:
continue
if num [ i] != num[i-1]+1:
return num[i-1]+1
return -1
print(first_missing_positive([0,-1,2,3]))
|
def rotate_list(num,k):
result = num[k:] + num[:k]
return result
print(rotate_list([1,2,3,4,5],2))
|
class ListNode(object):
def __init__(self, x):
self.val = x
self.next = None
def addTwoNumbers( l1, l2):
l1 = l1[::-1]
l2 = l2[::-1]
for i in range(max(len(l2),len(l1))):
if l2[i] and l1[i]:
answ[i] = l2[i] + l1[i]
elif l2[i]:
answ[i] = l2[i]
elif l1[i]:
answ[i] = l1[i]
def addTwoLists(l1,l2):
dummy = curr = ListNode(0)
carry = 0
while l1 or l2 :
if l1:
carry = carry + l1.val
l1=l1.next
if l2:
carry = carry + l2.val
l2 = l2.next
##carry, val = divmod(carry,10)
curr.next = ListNode(carry%10)
curr = curr.next
carry= carry//10
return dummy.next
a = ListNode(1)
b = ListNode(2)
c = ListNode(3)
a1 = ListNode(1)
b1 = ListNode(2)
c1 = ListNode(3)
a.next =b
b.next =c
a1.next =b1
b1.next =c1
a.next =b
l = addTwoLists(a,a1)
while l:
print(l.val)
l=l.next
|
class ListNode(object):
def __init__(self, x):
self.val = x
self.next = None
def swapPairs(head):
prev_head = ListNode(-1)
prev_head = head.next
while head!=None and head.next!=None:
temp = head.next.next
head.next.next = temp.next
swap = head.next
swap.next = head
head.next = temp
head = temp
return prev_head
a = ListNode(1)
b = ListNode(2)
c = ListNode(3)
d = ListNode(4)
e = ListNode(5)
a.next = b
b.next = c
c.next = d
d.next = None
e.next = None
final = swapPairs(a)
while final.next != None:
print(final.val)
final = final.next
|
class ListNode(object):
def __init__(self, x):
self.val = x
self.next = None
def mergeKLists(l):
merge =[]
for i in l:
while i:
merge.append(i.val)
i = i.next
merge.sort()
merged_list = ListNode(-1)
prev = ListNode(-1)
prev.next = merged_list
for i in merge:
merged_list.next = ListNode(i)
merged_list = merged_list.next
return prev.next.next
a = ListNode(1)
b = ListNode(2)
c = ListNode(3)
d = ListNode(4)
e = ListNode(5)
a.next = b
b.next = c
c.next = d
d.next = e
e.next = None
a1 = ListNode(1)
b1 = ListNode(2)
c1 = ListNode(3)
d1 = ListNode(4)
e1 = ListNode(5)
a1.next = b1
b1.next = c1
c1.next = d1
d1.next = e1
e1.next = None
a2 = ListNode(1)
b2 = ListNode(2)
c2 = ListNode(3)
d2 = ListNode(4)
e2 = ListNode(5)
a2.next = b2
b2.next = c2
c2.next = d2
d2.next = e2
e2.next = None
final = mergeKLists([a,a1,a2])
print(final)
while final.next != None:
print(final.val)
final = final.next
|
''' 30th Jan 2021'''
''' A multi-player dice game '''
''' You can choose howevermany players you want to play in the game '''
''' One Edge case when all values are the same still needs to be resolved'''
import random
def find_winner(arr):
l = len(arr)
win_val = 0
for i in range(0, l):
if arr[i] < win_val:
continue
else:
for j in range(i+1, l):
if arr[j] > arr[i]:
win_pos, win_val = j, arr[j]
else:
win_pos, win_val = i, arr[i]
print(f'Player {win_pos+1} won by rolling a total of {win_val}')
def main():
# Let's play
num_players = int(input('Enter the number of players: '))
dice_sum_results = []
for p in range(0, num_players):
print(f'Now Playing Player = {p+1}')
dice_rolls = int(input('How many dice would you like to roll? '))
dice_size = int(input('How many sides are the dice? '))
dice_sum = 0
for i in range(0, dice_rolls):
roll = random.randint(1,dice_size)
dice_sum += roll
if roll == 1:
print(f'You rolled a {roll}; Critical Fail!')
elif roll == 6:
print(f"You rolled a {roll}; Critical Success!")
else:
print(f"You rolled a {roll}")
dice_sum_results.append(dice_sum)
print(f'You have rolled a total of {dice_sum}')
print(f'The players rolled the following totals respectively: {dice_sum_results}')
# Find the winning player
find_winner(dice_sum_results)
if __name__== "__main__":
main() |
import math
import string
import sys
l = []
l.c
def read_file(filename):
try:
fp = open(filename)
L = fp.readlines()
except IOError:
print "Error opening the file", filename
sys.exit()
return L
def get_words_from_string(line):
"""
Return a list of the words in the given input string,
converting each word to lower-case.
Input: line (a string)
Output: a list of strings
(each string is a sequence of alphanumeric characters)
"""
line = line.translate(translation_table)
word_list = line.split()
return word_list
def get_words_from_line_list(L):
"""
[description]
Arguments:
L {[type]} -- [description]
"""
word_list = []
for line in L:
words_in_line = get_words_from_string(line)
word_list.extend(words_in_line)
return word_list
l1 = min(len(string.uppercase), len(string.lowercase))
translation_table = string.maketrans(string.punctuation+string.uppercase[:11],
" "*len(string.punctuation)+string.lowercase[:11])
def count_frequency(word_list):
"""
Return a list giving pairs of form: (word,frequency)
"""
D = {}
for new_word in word_list:
if D.has_key(new_word):
D[new_word] = D[new_word]+1
else:
D[new_word] = 1
return D.items()
def merge_sort(A):
n = len(A)
if n == 1:
return A
mid = n//2
L = merge_sort(A[:mid])
R = merge_sort(A[mid:])
return merge(L, R)
|
#author:ChaozhuangZHANG
#complexity:o(nlogn)
#language:python
#description of the question:
'''
A peak element is an element that is greater than its neighbors.
Given an input array where num[i] ≠ num[i+1], find a peak element and return its index.
'''
class Solution(object):
def findPeakElement(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
left,right=0,len(nums)-1
while left<right:
mid = (left+right)/2
if nums[mid]<nums[mid+1]:
left = mid+1
elif nums[mid]<nums[mid-1]:
right = mid-1
else:
return mid
return left
a= Solution()
b=a.findPeakElement([1,2,3,4,2])
print b
|
'''
Домашнее задание ко второму уроку
'''
'''
Задача 1
Вывести на экран циклом пять строк из нулей, причем каждая строка должна быть пронумерована.
'''
# i = 1
# while i<6:
# print(i, '00000000000000000000')
# i=i+1
'''
Задача 2
Пользователь в цикле вводит 10 цифр. Найти количество введеных пользователем цифр 5.
'''
# number_of_fives = 0
# for i in range(10):
# a = int(input('Введите цифру: '))
# if a==5:
# number_of_fives = number_of_fives+1
# print('Количество введенных цифр 5:', number_of_fives)
'''
Задача 3
Найти сумму ряда чисел от 1 до 100. Полученный результат вывести на экран.
'''
# sum = 0
# for i in range(1,101):
# sum+= i
# print(sum)
'''
Задача 4
Найти произведение ряда чисел от 1 до 10. Полученный результат вывести на экран.
'''
# mult = 1
# for i in range(1,11):
# mult*= i
# print(mult)
'''
Задача 5
Вывести цифры числа на каждой строчке.
'''
# source_number = int(input('Введите целое число: '))
# aux_number = source_number
# quantity_of_digits = 0
# while aux_number > 0:
# aux_number = aux_number//10
# quantity_of_digits+= 1
# print('Количество цифр в числе:', quantity_of_digits)
# aux_number = source_number
# for i in range(quantity_of_digits-1, 0, -1):
# print(aux_number//(10**i))
# aux_number = aux_number - aux_number//(10**i)*(10**i)
# print(source_number%10)
'''
Задача 6
Найти сумму цифр числа.
'''
# number = int(input('Введите целое число: '))
# sum = 0
# while number > 0:
# sum+= number%10
# number = number//10
# print('Сумма цифр числа равна', sum)
'''
Задача 7
Найти произведение цифр числа.
'''
# number = int(input('Введите целое число: '))
# mult = 1
# while number > 0:
# mult*= number%10
# number = number//10
# print('Произведение цифр числа равна', mult)
'''
Задача 8
Дать ответ на вопрос: есть ли среди цифр числа 5?
'''
# number = int(input('Введите целое число: '))
# answer = 0
# while number > 0:
# if number%10 == 5:
# answer+= 1
# number = number//10
# if answer>0:
# print('Количество цифр 5 в числе:', answer)
# else:
# print ('В числе нет цифр 5')
'''
Задача 9
Найти максимальную цифру в числе
'''
# number = int(input('Введите целое число: '))
# maximal_digit = 0
# while number > 0:
# if number%10 > maximal_digit:
# maximal_digit = number%10
# number = number//10
# print('Максимальная цифра в числе равна', maximal_digit)
'''
Задача 10
Найти количество цифр 5 в числе
'''
# number = int(input('Введите целое число: '))
# number_of_fives = 0
# while number > 0:
# if number%10 == 5:
# number_of_fives = number_of_fives+1
# number = number//10
# print('Количество цифр 5 во введенном числе равно', number_of_fives)
|
inputs = [line.rstrip('\n') for line in open("inputs/03.txt")]
def one():
intersects = []
for string in inputs:
half = len(string) // 2
one = string[:half]
two = string[half:]
intersects.append([element for element in one if element in two])
counter = 0
for i in intersects:
char = i[0]
if ord(char) < 96:
counter += ord(char) - 38
else:
counter += (ord(char) - 96)
print(counter)
def two():
intersects = []
for x in range(len(inputs) // 3):
index = 3 * x
one = set(inputs[index])
two = set(inputs[index + 1])
three = set(inputs[index + 2])
set1 = one.intersection(two)
result = set1.intersection(three)
intersects.append(result)
counter = 0
for i in intersects:
char1 = list(i)
char = char1[0]
if ord(char) < 96:
counter += ord(char) - 38
else:
counter += (ord(char) - 96)
print(counter)
one()
two()
|
"""
쉽게 설명한 병합 정렬
입력:
리스트 a
출력:
정렬된 리스트
"""
def merge_sort(a):
n = len(a)
# 종료 조건: 정렬할 리스트의 자료 개수가 한 개 이하이면 정렬할 필요 없음
if n <= 1:
return a
# 그룹을 나누어 각각 병합 정렬을 호출하는 과정
mid = n // 2 # 중간을 기준으로 두 그룹으로 나눔
group_1 = merge_sort(a[:mid]) # 재귀 호출로 첫 번째 그룹을 정렬
group_2 = merge_sort(a[mid:]) # 재귀 호출로 두 번째 그룹을 정렬
# 두 그룹을 하나로 병합
result = []
while group_1 and group_2: # 두 그룹에 모두 자료가 남아 있는 동안 반복
if group_1[0] < group_2[0]: # 두 그룹의 맨 앞 자료 값을 비교
# group_1 값이 더 작으면 그 값을 빼내어 결과로 추가
result.append(group_1.pop(0))
else:
# group_2 값이 더 작으면 그 값을 빼내어 결과로 추가
result.append(group_2.pop(0))
# 아직 남아있는 자료들을 결과에 추가
# group_1과 group_2 중 이미 빈 것은 while을 바로 지나감
while group_1:
result.append(group_1.pop(0))
while group_2:
result.append(group_2.pop(0))
return result
d = [6, 8, 3, 9, 10, 1, 2, 4, 7, 5]
print(merge_sort(d)) |
def main():
"""
元组中的元素是无法修改的，事实上我们在项目中尤其是多线程环境
中可能更喜欢使用的是那些不变对象
（一方面因为对象状态不能修改，所以可以避免由此引起的不必要的程序错误，简单的说就是一个不变的对象要比可变的对象更加容易维护；
另一方面因为没有任何一个线程能够修改不变对象的内部状态，一个不变对象自动就是线程安全的，
这样就可以省掉处理同步化的开销。一个不变对象可以方便的被共享访问）。
所以结论就是：如果不需要对元素进行添加、删除、修改的时候，可以考虑使用元组，当然如果一个方法要返回多个值，使用元组也是不错的选择。
元组在创建时间和占用的空间上面都优于列表。
我们可以使用sys模块的getsizeof函数来检查存储同样的元素的元组和列表各自占用了多少内存空间，这个很容易做到。
我们也可以在ipython中使用魔法指令%timeit来分析创建同样内容的元组和列表所花费的时间，下图是我的macOS系统上测试的结果。
"""
t = ('wdz',29,True,'安徽六安')
print(t)
print(t[0])
print(t[3])
for member in t:
print(member)
# 元祖的元素不能被修改
# 将元祖装换成列表
person = list(t)
person[0] = 'hjj'
person[3] = '浙江杭州'
print(person)
#列表转换成元祖
newt = tuple(person)
print(newt)
if __name__=='__main__':
main()
|
#!/usr/bin/env python3
__author__ = 'luoshun'
class Student(object):
#可读属性
@property
def score(self):
return self.__score
#可写属性
@score.setter
def score(self,value):
self.__score = value
#可读属性
@property
def age(self):
return 2015-self.__score
s = Student()
print('input your score')
s1=input()
s.score = int(s1)
print(s.age)
|
import csv
# The DictWriter and The DictReader is not covered
# In this example
def write_csv(data, filename):
if filename[-4:] != '.csv':
filename += '.csv'
if type(data) not in (type([]), type(())):
print(type(data))
raise TypeError
with open(filename, 'w', newline='') as file:
writer = csv.writer(file)
for line in data:
writer.writerow(line)
def read_csv(filename):
data = []
try:
open(filename)
except FileNotFoundError as e:
filename += '.csv'
try:
open(filename)
except FileNotFoundError:
raise e
with open(filename, 'r', newline='') as file:
reader = csv.reader(file)
for line in reader:
data.append(tuple(line))
return tuple(data)
def main():
data = (
('Name', 'Class', 'Section', 'Subjects'),
('Suchith', 12, 'C', 'Computer, Math'),
('Edel', 12, 'A', 'Physics, Math'),
('Monniiesh', 12, 'A', 'Chemistry')
)
write_csv(data, 'sample_data')
data = read_csv('sample_data')
display_table(data)
if __name__ == '__main__':
from custom_packages import __main__
from custom_packages.print_tables import display as display_table
# main()
|
#!/usr/bin/env python3
"""
Bradley N. Miller, David L. Ranum
Problem Solving with Algorithms and Data Structures using Python
Copyright 2005
Updated by Roman Yasinovskyy, 2017
"""
class Deque:
"""Queue implementation as a list"""
def __init__(self):
"""Create new deque"""
self._items = []
def is_empty(self):
"""Check if the deque is empty"""
return not bool(self._items)
def add_front(self, item):
"""Add an item to the front of the deque"""
self._items.append(item)
def add_rear(self, item):
"""Add an item to the rear of the deque"""
self._items.insert(0, item)
def remove_front(self):
"""Remove an item from the front of the deque"""
return self._items.pop()
def remove_rear(self):
"""Remove an item from the rear of the deque"""
return self._items.pop(0)
def size(self):
"""Get the number of items in the deque"""
return len(self._items)
|
"""Unit testing for inheritance """
import unittest
class InheritanceTesting(unittest.TestCase):
def test_methods(self):
class Base(object):
def myfunc(self):
return "Base.myfunc"
def stuff(self):
return "Base.stuff"
self.myfunc()
class Derived(Base):
def myfunc(self):
Base.myfunc(self)
return "Derived.myfunc"
d = Derived()
self.assertEqual(d.myfunc(), "Derived.myfunc")
b = Derived()
self.assertEqual(b.stuff(), "Base.stuff")
def test_override_method(self):
class SuperClass:
def apply(self):
return "SuperClass"
class SubClassA(SuperClass):
def apply(self):
return "SubClassA"
x = SubClassA()
self.assertEqual(x.apply(), "SubClassA")
def test_mro(self):
class O(object): pass
class F(O): pass
class E(O): pass
class D(O): pass
class C(D,F): pass
class B(D,E): pass
class A(B,C): pass
self.assertEqual(A.__bases__, (B, C))
self.assertEqual(A.__mro__, (A, B, C, D, E, F, O, object))
class O(object): pass
class F(O): pass
class E(O): pass
class D(O): pass
class C(D,F): pass
class B(E,D): pass
class A(B,C): pass
self.assertEqual(A.__mro__,(A, B, E, C, D, F, O, object))
class O(object): pass
class A(O): pass
class B(O): pass
class C(O): pass
class D(O): pass
class E(O): pass
class K1(A,B,C): pass
class K2(D,B,E): pass
class K3(D,A): pass
class Z(K1,K2,K3): pass
self.assertEqual(K1.__mro__, (K1, A, B, C, O, object))
self.assertEqual(K2.__mro__, (K2, D, B, E, O, object))
self.assertEqual(K3.__mro__, (K3, D, A, O, object))
self.assertEqual(Z.__mro__, (Z, K1, K2, K3, D, A, B, C, E, O, object))
self.assertEqual(object.__bases__, ())
self.assertEqual(object.__mro__, tuple([object]))
class X(object): pass
class Y(X): pass
self.assertEqual(X.__bases__, tuple([object]))
self.assertEqual(X.__mro__, (X, object))
self.assertEqual(Y.__bases__, tuple([X]))
self.assertEqual(Y.__mro__, (Y, X, object))
def test_issubclass(self):
class Foo:
pass
class Bar(Foo):
pass
class Baz(Bar):
pass
class XXX:
pass
class Frob(Baz,XXX):
pass
self.assertTrue(issubclass(Bar,Foo))
self.assertFalse(issubclass(Foo,Bar))
self.assertTrue(issubclass(Baz,Foo))
self.assertTrue(issubclass(Baz,Bar))
self.assertTrue(issubclass(Foo,object))
self.assertTrue(issubclass(Frob,XXX))
def test_skulpt_bugs(self):
for _cls in (int, dict, set, list, object, tuple):
self.assertTrue(issubclass(_cls, object))
for error in (Exception, TypeError, ValueError, AttributeError):
self.assertTrue(issubclass(error, Exception))
self.assertEqual(int.__mro__, (int, object))
self.assertEqual(Exception.__mro__, (Exception, BaseException, object))
self.assertEqual(TypeError.__bases__, (Exception,))
# test type and object
self.assertTrue(isinstance(type, object))
self.assertTrue(isinstance(type, type))
self.assertTrue(isinstance(object, object))
self.assertTrue(isinstance(object, type))
self.assertTrue(issubclass(type, object))
self.assertFalse(issubclass(object, type))
if __name__ == '__main__':
unittest.main()
|
#!/usr/bin/env python3
"""
Bradley N. Miller, David L. Ranum
Problem Solving with Algorithms and Data Structures using Python
Copyright 2005
Updated by Roman Yasinovskyy, 2017
"""
from pythonds3.trees.binary_heap import BinaryHeap
class PriorityQueue(BinaryHeap):
"""
This implementation of binary heap takes (key, value) pairs where key signifies priority
We will assume that the keys are all comparable.
"""
def change_priority(self, new_priority, value):
"""Change the priority"""
key_to_move = 0
for i in range(len(self._heap)):
if self._heap[i][1] == value:
key_to_move = i
break
if key_to_move > -1:
self._heap[key_to_move] = (new_priority, self._heap[key_to_move][1])
self._perc_up(key_to_move)
|
import unittest
class ExceptionTest(unittest.TestCase):
def test_finally(self):
finally_ran = False
try:
pass
finally:
finally_ran = True
self.assertTrue(finally_ran)
finally_ran = False
try:
raise Exception()
except:
pass
else:
self.assertFalse(True, "'else' should not fire if exception raised")
finally:
finally_ran = True
self.assertTrue(finally_ran)
finally_ran = False
try:
try:
raise Exception()
finally:
finally_ran = True
self.assertTrue(False, "No re-raise after 'finally'")
except:
pass
self.assertTrue(finally_ran)
def test_finally_return(self):
finally_ran = [False]
def r1():
try:
return 42
self.assertTrue(False, "Execution continued after return")
finally:
finally_ran[0] = True
self.assertEqual(r1(), 42)
self.assertTrue(finally_ran[0], "'finally' block did not run")
def r2():
try:
return 42
self.assertTrue(False, "Execution continued after return")
finally:
return 43
self.assertEqual(r2(), 43)
def r3():
try:
raise Exception()
finally:
return 42
self.assertEqual(r3(), 42)
finally_ran = [False]
def r4():
try:
raise Exception()
except:
return 42
finally:
finally_ran[0] = True
self.assertEqual(r4(), 42)
self.assertTrue(finally_ran[0], "'finally' block did not run")
def r5():
try:
raise Exception()
except:
return 42
finally:
return 43
self.assertEqual(r5(), 43)
finally_ran = [False, False]
def r6():
try:
try:
raise Exception()
finally:
finally_ran[0] = True
return 42
finally:
finally_ran[1] = True
self.assertEqual(r6(), 42)
self.assertEqual(finally_ran, [True, True])
def r7():
try:
return 42
finally:
raise Exception()
self.assertRaises(Exception, r7)
def test_finally_break_continue(self):
finally_ran = [False,False]
normal_execution_continued = False
try:
while True:
try:
try:
break
finally:
finally_ran[0] = True
self.assertFalse(True, "Execution got past 'break' statement")
finally:
finally_ran[1] = True
self.assertFalse(True, "Execution got past 'break' statement")
normal_execution_continued = True
finally:
self.assertEqual(finally_ran, [True, True]);
self.assertTrue(normal_execution_continued, "'break' skipped too many finallies")
finally_ran = [False,False]
normal_execution_continued = False
try:
while not finally_ran[0]:
try:
try:
continue
finally:
finally_ran[0] = True
self.assertFalse(True, "Execution got past 'continue' statement")
finally:
finally_ran[1] = True
self.assertFalse(True, "Execution got past 'continue' statement")
normal_execution_continued = True
finally:
self.assertEqual(finally_ran, [True, True]);
self.assertTrue(normal_execution_continued, "'continue' skipped too many finallies")
if __name__ == "__main__":
unittest.main()
|
"""Unit test for biwise operators"""
import unittest
class OperatorsTest(unittest.TestCase):
def test_bitwise_and(self):
self.assertEqual(5&7, 5)
x = 5
x &= 7
self.assertEqual(x, 5)
self.assertEqual(0b1111 & 0b0001, 0b0001)
self.assertEqual(0O7740 & 0O7400, 0O7400)
self.assertEqual(0x0ff0 & 0xf00f, 0x0000)
self.assertEqual(745 & 348, 72)
def test_bitwise_xor(self):
self.assertEqual(2^7, 5)
self.assertEqual(7^2&2, 5)
x = 2
x ^= 7
self.assertEqual(x, 5)
self.assertEqual(0b0110 ^ 0b0101, 0b0011)
self.assertEqual(0O1200 ^ 0O1034,0O0234)
self.assertEqual(0x10f0 ^ 0x01f0, 0x1100)
self.assertEqual(3847 ^ 4958, 7257)
def test_bitwise_or(self):
self.assertEqual(7^2|4, 5)
x=4
x|=1
self.assertEqual(x, 5)
a = 1|2|3|4|5|6|0x80
self.assertEqual(a, 135)
self.assertEqual(0b0101 | 0b1010, 0b1111)
self.assertEqual(0x0ff0 | 0x0000, 0x0ff0)
self.assertEqual(0O0505 | 0O1000, 0O1505)
self.assertEqual(124 | 37, 125)
def test_shift(self):
self.assertRaises(ValueError, lambda x: 3 >> x, -3)
self.assertEqual(0b0110 << 2, 0b11000)
self.assertEqual(0b0110 >> 2, 0b0001)
self.assertEqual(0O2763 << 2, 0O13714)
self.assertEqual(0O2763 >> 2, 0O574)
self.assertEqual(0x5a01 << 2, 0x16804)
self.assertEqual(0x5a01 >> 2, 0x1680)
self.assertEqual(1834 << 2, 7336)
self.assertEqual(1834 >> 2, 458)
self.assertEqual((1834<<30)>>28, 7336)
self.assertEqual((1<<33)>>32, 2)
over_32bits = 0xa * 2**34
self.assertEqual(over_32bits >> 2, over_32bits / 4)
self.assertEqual(-0xa >> 2, -3)
def test_more_shifts(self):
for i in range(1, 70):
self.assertEqual((1<<i)>>(i-1), 2)
self.assertEqual((-1<<i)>>(i-1), -2)
self.assertEqual((0xb<<i)>>(i+1), 5)
def test_not(self):
self.assertEqual(~0b0011, -0b0100)
self.assertEqual(~0x4a30, -0x4a31)
self.assertEqual(~2398, -2399)
self.assertEqual(~0O1234, -0O1235)
if __name__ == '__main__':
unittest.main()
|
# Bradley N. Miller, David L. Ranum
# Solución de problemas con algoritmos y estructuras de datos usando Python
# Copyright 2014
#
#arbolBinario.py
class ArbolBinario:
def __init__(self,objetoRaiz):
self.clave = objetoRaiz
self.hijoIzquierdo = None
self.hijoDerecho = None
def insertarIzquierdo(self,nuevoNodo):
if self.hijoIzquierdo == None:
self.hijoIzquierdo = ArbolBinario(nuevoNodo)
else:
t = ArbolBinario(nuevoNodo)
t.hijoIzquierdo = self.hijoIzquierdo
self.hijoIzquierdo = t
def insertarDerecho(self,nuevoNodo):
if self.hijoDerecho == None:
self.hijoDerecho = ArbolBinario(nuevoNodo)
else:
t = ArbolBinario(nuevoNodo)
t.hijoDerecho = self.hijoDerecho
self.hijoDerecho = t
def esHoja(self):
return ((not self.hijoIzquierdo) and (not self.hijoDerecho))
def obtenerHijoDerecho(self):
return self.hijoDerecho
def obtenerHijoIzquierdo(self):
return self.hijoIzquierdo
def asignarValorRaiz(self,obj):
self.clave = obj
def obtenerValorRaiz(self):
return self.clave
def inorden(self):
if self.hijoIzquierdo:
self.hijoIzquierdo.inorden()
print(self.clave)
if self.hijoDerecho:
self.hijoDerecho.inorden()
def postorden(self):
if self.hijoIzquierdo:
self.hijoIzquierdo.postorden()
if self.hijoDerecho:
self.hijoDerecho.postorden()
print(self.clave)
def preorden(self):
print(self.clave)
if self.hijoIzquierdo:
self.hijoIzquierdo.preorden()
if self.hijoDerecho:
self.hijoDerecho.preorden()
def imprimirExpresion(self):
if self.hijoIzquierdo:
print('(', end=' ')
self.hijoIzquierdo.imprimirExpresion()
print(self.clave, end=' ')
if self.hijoDerecho:
self.hijoDerecho.imprimirExpresion()
print(')', end=' ')
def evalPostorden(self):
opers = {'+':operator.add, '-':operator.sub, '*':operator.mul, '/':operator.truediv}
res1 = None
res2 = None
if self.hijoIzquierdo:
res1 = self.hijoIzquierdo.evalPostorden() #// \label{peleft}
if self.hijoDerecho:
res2 = self.hijoDerecho.evalPostorden() #// \label{peright}
if res1 and res2:
return opers[self.clave](res1,res2) #// \label{peeval}
else:
return self.clave
def inorden(arbol):
if arbol != None:
inorden(arbol.obtenerHijoIzquierdo())
print(arbol.obtenerValorRaiz())
inorden(arbol.obtenerHijoDerecho())
def imprimirExpresion(arbol):
if arbol.hijoIzquierdo:
print('(', end=' ')
imprimirExpresion(arbol.obtenerHijoIzquierdo())
print(arbol.obtenerValorRaiz(), end=' ')
if arbol.hijoDerecho:
imprimirExpresion(arbol.obtenerHijoDerecho())
print(')', end=' ')
def imprimirExpresion(arbol):
valorCadena = ""
if arbol:
valorCadena = '(' + imprimirExpresion(arbol.obtenerHijoIzquierdo())
valorCadena = valorCadena + str(arbol.obtenerValorRaiz())
valorCadena = valorCadena + imprimirExpresion(arbol.obtenerHijoDerecho())+')'
return valorCadena
def evalPostorden(arbol):
operadores = {'+':operator.add, '-':operator.sub, '*':operator.mul, '/':operator.truediv}
res1 = None
res2 = None
if arbol:
res1 = evalPostorden(arbol.obtenerHijoIzquierdo()) #// \label{peleft}
res2 = evalPostorden(arbol.obtenerHijoDerecho()) #// \label{peright}
if res1 and res2:
return operadores[arbol.obtenerValorRaiz()](res1,res2) #// \label{peeval}
else:
return arbol.obtenerValorRaiz()
def altura(arbol):
if arbol == None:
return -1
else:
return 1 + max(altura(arbol.hijoIzquierdo),altura(arbol.hijoDerecho))
t = ArbolBinario(7)
t.insertarIzquierdo(3)
t.insertarDerecho(9)
inorden(t)
import operator
x = ArbolBinario('*')
x.insertarIzquierdo('+')
l = x.obtenerHijoIzquierdo()
l.insertarIzquierdo(4)
l.insertarDerecho(5)
x.insertarDerecho(7)
print(imprimirExpresion(x))
print(evalPostorden(x))
print(altura(x))
|
# simple one-to-one RNN experiment that takes in a word and learns to predict the next word but
# without a continuing state
# quick tutorial: https://pytorch.org/tutorials/beginner/nlp/sequence_models_tutorial.html
# difference between LSTM and LSTMCell: https://stackoverflow.com/questions/57048120/pytorch-lstm-vs-lstmcell
# this sample uses the LSTM
import numpy as np
import torch
import torch.nn as nn
from torch.nn import functional as F
from argparse import ArgumentParser
from tqdm import trange
# set seeds for reproducibility
np.random.seed(4)
torch.manual_seed(4)
args = ArgumentParser(description="test rnn")
args.add_argument("--vocab_size", type = int, default = 100, help = "vocabulary size")
args.add_argument("--edim", type = int, default = 8, help = "embedding dimension")
args.add_argument("--maxlen", type = str, default = 20, help = "maximum length of sequences")
args.add_argument("--minlen", type = str, default = 4, help = "minimum length of sequences")
args.add_argument("--num", type = int, default = 1000, help = "number of samples of dummy language")
args.add_argument("--batch_size", type = int, default = 8, help = "batch size for training")
args.add_argument("--lr", type = float, default = 0.001, help = "batch_size in training")
args.add_argument("--epochs", type = int, default = 50, help = "number of training epochs")
args = args.parse_args()
special_tokens = {"[pad]": args.vocab_size, "[bos]": args.vocab_size+1, "[eos]": args.vocab_size+2}
dummy_language = []
for seq in [
np.random.randint(args.vocab_size, size = (l)).tolist()
for l in np.random.randint(args.minlen, args.maxlen - 2, size = (args.num))
]:
# sequence maxlen is -2 for special tokens
seq = [special_tokens["[bos]"]] + seq + [special_tokens["[eos]"]]
if len(seq) < args.maxlen:
seq += [special_tokens["[pad]"],]*(args.maxlen - len(seq))
dummy_language.append(seq)
args.vocab_size = args.vocab_size + 3
dummy_language = np.array(dummy_language)
# for x in dummy_language[:20]:
# print(x)
# --- Making the model --- #
class SimpleLSTM(nn.Module):
def __init__(self, config) -> None:
super().__init__()
print(config.vocab_size)
self.wte = nn.Embedding(config.vocab_size, config.edim)
self.lstm = nn.LSTM(config.edim, config.edim)
self.lm_head = nn.Linear(config.edim, config.vocab_size)
def forward(self, sentence, _flat = True):
# for shapes assume the input has size torch.Size([3, 20])
input_shape = sentence.shape
embeds = self.wte(sentence) # torch.Size([3, 20, 8])
embeds = embeds.view(input_shape[0]*input_shape[1], 1, -1) # torch.Size([20*3, 1, 8])
lstm_out, _ = self.lstm(embeds)
out = self.lm_head(lstm_out.view(input_shape[0], input_shape[1], -1)) # [3,20,vocab_size]
lm_scores = F.log_softmax(out, dim=1)
return lm_scores
# make model and loss fn
model = SimpleLSTM(args)
loss_function = nn.NLLLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
# run one dummy epoch
print("----- BEFORE -----")
with torch.no_grad():
b = torch.tensor(dummy_language[:3])
inputs = b[:,:-1]
# print(inputs.shape) # torch.Size([3, 19])
tag_scores = model(inputs)
# print(tag_scores.shape) # torch.Size([3, 19, 103])
print("target:", inputs[0, :-1])
print("output:", torch.argmax(tag_scores[0], dim = -1))
# to train the network
print("----- LEARNING -----")
for e in trange(args.epochs):
for i in range(len(dummy_language)):
model.zero_grad()
b = torch.from_numpy(dummy_language[i*args.batch_size:(i+1)*args.batch_size])
if b.shape[0] == 0:
continue
to_shape = b.shape[0]*(b.shape[1]-1)
outputs = model(b[:,:-1])
outputs = outputs.view(to_shape, -1)
# print("OP:", outputs.shape)
# print(b[:, 1:].shape)
target = b[:, 1:].reshape(to_shape,)
# print("TR:", target.shape)
loss = loss_function(outputs, target)
# print("loss:", loss)
loss.backward()
optimizer.step()
# see what it has learned
print("----- AFTER -----")
with torch.no_grad():
# inputs = prepare_sequence(training_data[0][0], word_to_ix)
inputs = torch.tensor(dummy_language[:3])
# print(inputs.shape) # torch.Size([3, 20])
tag_scores = model(inputs[:, :-1])
# print(tag_scores.shape) # torch.Size([3, 20, 103])
print("target:", inputs[0, :-1])
print("output:", torch.argmax(tag_scores[0], dim=-1))
|
nome = raw_input('digite o seu nome: ')
idade = int(raw_input('digite a sua idade: '))
print 'Bom dia, ' + nome + '! ' + 'Ano passado voce tinha ' + str(idade-1) + ' anos!'
|
entrada = raw_input()
numerosComoString = entrada.split(" ")
numeros = [int(numero) for numero in numerosComoString]
c, n = numeros
print c % n |
n = int(raw_input('digite um numero: '))
if ((n%2)==0):
print str(n) + ' e par!'
else:
print str(n) + ' e impar!'
if (n>10):
print str(n) + ' e maior que 10!'
elif (n<10):
print str(n) + ' e menor que 10!'
else:
print str(n) + ' e igual a 10!'
temp = int(raw_input('Entre com a temperatura: '))
if temp < 0:
print 'Quente...'
elif 0 <= temp <= 20:
print 'Muito quente'
elif 21 <= temp <= 25:
print 'Quente pra porra'
elif 26 <= temp <= 35:
print 'Bahia'
else:
print 'Inferno!'
|
# coding : utf-8
import sqlite3
class ChessBoard(object):
"""docstring for ChessBoard"""
def __init__(self, arg):
super(ChessBoard, self).__init__()
self.arg = arg
def printBoard(chessbook):
# 1|2|3
# 4|5|6
# 7|8|9
print "{0}|{1}|{2}\n{3}|{4}|{5}\n{6}|{7}|{8}".format(chessbook)
|
import sys
import numpy as np
intToPlayer = {0: ' ', 1: 'X', 2: 'O'}
def main():
sys.stdout.write("Let's play tic-tac-toe!\n")
game()
def game():
board = np.zeros((3, 3), dtype=int)
hasWon = isWinScenario(board)
while not hasWon:
turn(1, board)
print_board(board);
hasWon = isWinScenario(board)
sys.stdout.write("Congratulations!\n")
def turn(player, board):
row = input("What row would you like to play? ")
col = input("What column would you like to play? ")
board[row][col] = player
def isWinScenario(board):
for i in range(2):
if isRowWin(board[i]):
return True
col = [row[i] for row in board]
if isRowWin(col):
return True
for diag in [np.diag(board), np.diag(np.fliplr(board))]:
if isRowWin(diag):
return True
return False
def isRowWin(row):
return all(x == row[0] and x != 0 for x in row)
def print_board(board):
text_board = "";
for i in range(3):
for j in range(3):
suffix = "|" if j != 2 else ""
char = intToPlayer[board[i][j]]
text_board += char + suffix
text_board += "\n"
if i != 2:
text_board += "_ _ _\n"
sys.stdout.write(text_board)
if __name__ == "__main__":
main()
|
l = range(5)
print l
print l * 5
l[0] = 1
print l
print l[2]
print l[2L]
l[:] = l
l = range(5)
while l:
print l.pop()
l = range(7, -1, -2)
print sorted(l)
print l
l = range(5)
l[0] = l
print l
for i in xrange(-10, 10):
l2 = range(5)
l2.insert(i, 99)
print i, l2
for i in xrange(-5, 4):
l3 = range(5)
print i, l3.pop(i), l3
print range(5).pop(2L)
for i in xrange(-5, 4):
l3 = range(5)
l3[:i] = [7, 8]
print i, l3
print [1, 2, 3, 4, 5]
# test count method
l = [1, 2, 1, 2, 3]
print l.count(1)
print l.count(42)
print l.remove(1)
print l
try:
l.remove(54)
assert 0
except ValueError, e:
print e
print "ok"
print l
for i in xrange(5):
l = range(i)
l.reverse()
print l
# list index
list_index = [1, 2, 3, 4, 5]
for i in xrange(1, 6):
assert list_index.index(i) == i-1
try:
print list_index.index(i, 3L, 4L)
except ValueError as e:
print e
try:
print list_index.index(i, -1, -1)
except ValueError as e:
print e
assert list_index.index(3) == 2
assert [1, '2'].index('2') == 1
# growing and shrinking a list:
l = []
for i in xrange(100):
l.append(i)
while l:
del l[0]
print l
for i in xrange(100):
l.append(i)
while l:
del l[0]
l = range(5)
l.extend(range(5))
print l
# Repeating a list
x = [0, 1, 2]
print 2 * x
print x * 2
print range(5) == range(5)
print range(5) == range(4)
class C(object):
def __eq__(self, rhs):
print "C.eq"
return False
# Should not call C().__eq__
print [C()] == [1, 2]
l2 = l = range(5)
l3 = range(4)
l[:] = l3
print l, l2, l3
print l is l2
print l is l3
l = []
l[:] = range(5)
print l
for i in xrange(3):
for j in xrange(5):
l = range(i)
l[j:] = ["added"]
print i, j, l
l = range(i)
l[:j] = ["added"]
print i, j, l
for k in xrange(5):
l = range(i)
l[j:k] = ["added"]
print i, j, k, l
def G():
yield "a"
yield "b"
yield "c"
l = [0, 1, 2, 3, 4, 5]
l[1:] = G()
print l
l = [1, 3, 5, 7, 2, 4]
print l.sort(key=lambda x:x%3)
print l
print l.sort(reverse=True)
print l
# If the keyfunc throws an exception, we shouldn't see any modifications:
l = range(9)
try:
print sorted(l, key=lambda i:1.0/(5-i))
except ZeroDivisionError:
pass
print l
idxs = [-100, -50, -5, -1, 0, 1, 5, 50, 100]
for i1 in idxs:
for i2 in idxs:
l = range(10)
del l[i1:i2]
print i1, i2, l
l = []
del l[:]
print l
l = range(5)
l[2:4] = tuple(range(2))
print l
l[::-1] = l
print l
l = [None]*4
try:
l[::-1] = range(5)
except ValueError as e:
print e
l[::-1] = range(4)
print l
del l[::2]
print l
for i in xrange(3):
for j in xrange(3):
for k in xrange(3):
l1 = [i]
l2 = [j, k]
print l1 < l2, l1 <= l2, l1 > l2, l1 >= l2
def mycmp(k1, k2):
types_seen.add((type(k1), type(k2)))
if k1 == k2:
return 0
if k1 < k2:
return -1
return 1
types_seen = set()
l = ["%d" for i in xrange(20)]
l.sort(cmp=mycmp)
print types_seen
print l
"""
types_seen = set()
l = range(20)
l.sort(cmp=mycmp, key=str)
print types_seen
print l
"""
print repr(list.__hash__)
|
#Exception Handling
# Divide by zero
try:
x = 5/0
except:
print("Error dividing by zero")
# Summary: "Try" lets you run code that might be contain an error, "except" lets you catch the error.
# Handling number conversion errors
try:
x = int("fred")
except:
print("Error converting fred to a number")
# Better handling of number conversion errors
number_entered = False
while not number_entered:
number_string = input("Enter an integer: ")
try:
n = int(number_string)
number_entered = True
except:
print("Error, invalid integer")
# Checking for an error when opening a file
# Error opening file
try:
my_file = open("myfile.txt")
except:
print("Error opening file")
# Handling different types of errors
import sys
# multiple errors
try:
my_file = open("myfile.txt")
my_line = myfile.readline()
my_int = int(s.strip())
my_calculated_value = 101 / my_int
except IOError:
print("I/O error")
except ValueError:
print ("Could not convert data into an interger.")
except ZeroDivisionError:
print("Division by zero error")
except:
print("Unexpected error:", sys.exc_info()[0])
# Exception Objects
# When you're linking to more information about the error, use the 'as' keyword
try:
x = 5 / 0
except ZeroDivisionError as e:
print(e)
# Exception may be generated with the raise command
# Use the "if" "raise" format if possible as this reduces drag on code
def get_input():
user_input = input("Enter Something: ")
if len(user_input) == 0:
raise IOError("Users entered nothing")
get_input()
# Write down the process in words
# We're writing code that asks a user for input,
# if it happens that the user entered nothing
# Rather than run an error, it notifies us through the raise command
# Now write it in code:
# Create variable
def get_input():
user_input = input("Enter your password: ")
if len(user_input) == 0:
raise IOError("You didn't enter a password. Please try again.")
get_input
# In a simple path code, limit the use of exceptions when you can run if statements instead.
# Let's have a refresher practice run on writing up exceptions
try:
x = ("Yes, I'm a string beeches")
number = int(x)
except:
print ("You input a string instead of an integer")
|
#!/usr/bin/env/python
for name in ("Manny!", "Moe!", "Jack!"):
print 'Hi ya ', name
for name in ("Manny!", "Moe!", "Jack!"):
print 'Hi ya ', name
|
#!/usr/bin/env python3
from heapq import *
class max_heap1():
def __init__(self):
self.l = []
def heappush(self, item):
heappush(self.l, -item)
def heappop(self):
x = heappop(self.l)
return -x
def heapsize(self):
return len(self.l)
def heappeek(self):
return -self.l[0]
class max_heap():
def __init__(self):
self.heap = []
def heappush(self, x):
heappush(self.heap, -x)
def heappop(self):
x = heappop(self.heap)
return -x
def heappeek(self):
return -self.heap[0]
def heapsize(self):
return len(self.heap)
#m1 = max_heap()
#m1.heappush(34)
#m1.heappush(7)
#m1.heappush(31)
#print(m1.heappeek())
#m1.heappush(44)
#print(m1.heappeek())
#m1.heappop()
#print(m1.heappeek())
#m1.heappop()
#print(m1.heappeek())
#m1.heappop()
#print(m1.heappeek())
m2 = max_heap1()
m2.heappush(24)
m2.heappush(17)
m2.heappush(11)
#print(m1.heappeek())
#m1.heappush(44)
#print(m1.heappeek())
#m1.heappop()
#print(m1.heappeek())
#m1.heappop()
#print(m1.heappeek())
#m1.heappop()
print(m2.heappeek())
'''
class MaxHeapObj(object):
def __init__(self,val): self.val = val
#def __lt__(self,other): return self.val > other.val
def __lt__(self,other): return self.val > other.val
def __eq__(self,other): return self.val == other.val
def __str__(self): return str(self.val)
#maxh = []
#heapq.heappush(maxh,MaxHeapObj(x))
#x = maxh[0].val # fetch max value
#x = heapq.heappop(maxh).val # pop max value
#
class MinHeap(object):
def __init__(self): self.h = []
def heappush(self,x): heapq.heappush(self.h,x)
def heappop(self): return heapq.heappop(self.h)
def __getitem__(self,i): return self.h[i]
def __len__(self): return len(self.h)
class MaxHeap(MinHeap):
def heappush(self,x): heapq.heappush(self.h,MaxHeapObj(x))
def heappop(self): return heapq.heappop(self.h).val
def __getitem__(self,i): return self.h[i].val
#Example usage:
#
#minh = MinHeap()
maxh = MaxHeap()
# add some values
#minh.heappush(12)
maxh.heappush(12)
#minh.heappush(4)
maxh.heappush(4)
# fetch "top" values
#print(minh[0],maxh[0]) # "4 12"
print(maxh[0]) # "4 12"
# fetch and remove "top" values
#print(minh.heappop(),maxh.heappop()) # "4 12"
print(maxh.heappop()) # "4 12"
print(maxh.heappop()) # "4 12"
'''
|
#!/usr/bin/env python3
def power(base, exp):
res = 1
orig_base=base
orig_exp = exp
while exp:
print(base, exp, res)
if exp & 1:
res = res * base
base *= base
exp = exp >> 1
print("Power(", orig_base,",",orig_exp,"):", res)
power(3, 7)
|
#!/usr/bin/env python3
def find_minimum(arr):
n = arr.size()
if(n==1):
return arr.get(0)
if(n==2) {
return Math.min(arr.get(0), arr.get(1));
}
if(n==3) {
return Math.min(arr.get(0), Math.min(arr.get(1), arr.get(2)));
}
*
* All numbers of array are unique as given in question so don't consider the cases when
* numbers are equal and get confuse.
*/
/*
* consider example [4, 7, 8, 10, 15].
* for this given array was [4, 7, 8, 10, 15] which was sorted in ascending order
* and rotated right by 0
*/
if(arr.get(0)-arr.get(n-1)<0 && arr.get(0)-arr.get(1)<0 && arr.get(n-2)-arr.get(n-1)<0) {
return arr.get(0);
}
/*
* consider example [15, 10, 8, 7, 4].
* for this given array was [15, 10, 8, 7, 4] which was sorted in descending order
* and rotated right by 0
*/
if(arr.get(0)-arr.get(n-1)>0 && arr.get(0)-arr.get(1)>0 && arr.get(n-2)-arr.get(n-1)>0) {
return arr.get(n-1);
}
if(arr.get(0)-arr.get(n-1) > 0) {
/*
* consider example [10, 13, 15, 4, 6, 8].
* for this given array was [4, 6, 8, 10, 13, 15] which was sorted in ascending order
* and rotated right by 3
*/
return find_minimum_in_increasing(arr);
}
else {
/*
* consider example [8, 6, 4, 15, 13, 10].
* for this given array was [15, 13, 10, 8, 6, 4] which was sorted in descending order
* and rotated right by 3
*/
return find_minimum_in_decreasing(arr);
}
}
public static int find_minimum_in_increasing(List<Integer> arr) {
int low = 0;
int high = arr.size()-1;
while(low<=high) {
if(arr.get(low)-arr.get(high)<=0) {
return arr.get(low);
}
int mid = (low+high)/2;
if(arr.get(mid)-arr.get(low)>=0) {
//Minimum is in right subarray
low = mid + 1;
}else {
//Minimum is in left subarray
high = mid;
}
}
return -1;
}
public static int find_minimum_in_decreasing(List<Integer> arr) {
int low = 0;
int high = arr.size()-1;
while(low<=high) {
if(arr.get(low)-arr.get(high)>=0) {
return arr.get(high);
}
int mid = (low + high)/2;
if(arr.get(mid)-arr.get(low)<0) {
//Minimum is in right subarray
low = mid;
}else {
//Minimum is in left subarray
high = mid;
}
}
return -1;
}
// ============================= End ==============================
}
|
#!/usr/bin/env python3
def second_smallest(A):
cur = 0
potential = float('inf')
while cur < len(A):
l = left(cur)
r = right(cur)
if A[l] == A[cur]:
equal_node = l
other_node = r
else:
equal_node = r
other_node = l
if potential > a[other_node]:
potential = a[other_node]
cur = equal_node
return potential
def left(i):
return (2 * i + 1)
def right(i):
return (2 * i + 2)
def build(A):
n = len(A)
h = int(ceil(log2(n)))
nleafs = int(pow(2, h))
total_n = 2 * nleafs - 1 # n leaves and n-1 internal nodes
L = [0] * total_n
construct(A, 0, n-1, 0, L)
actual_elems = 2 * n - 1
return L, actual_elems
def construct(A, st, end, idx, L):
if st == end:
L[idx] = A[st]
return A[st]
m = int((st+end)/2)
lidx = left(idx)
ridx = right(idx)
L[lidx] = construct(A, st, m, lidx, L)
L[ridx] = construct(A, m+1, end, ridx, L)
return L[idx]
|
#!/usr/bin/env python3
def wildcard(s, res, idx):
if idx == len(s):
print(res)
return
#for i in range(idx, len(s)):
i = idx
cur_char = s[i]
if cur_char == '?':
wildcard(s, res+'0', i+1)
wildcard(s, res+'1', i+1)
else:
res += cur_char
wildcard(s, res, i+1)
def main():
#s = "?"
#s = "a?"
s = "a?bc?d"
wildcard(s, "", 0)
if __name__ == "__main__":
main()
|
#!/usr/bin/env python3
"""
Given an array of n elements, where each element is at most k positions away from its target position, write an algorithm that sorts in O(n log k) time
Input : arr[] = {6, 5, 3, 2, 8, 10, 9}, k = 3
Output : arr[] = {2, 3, 5, 6, 8, 9, 10}
Input : arr[] = {10, 9, 8, 7, 4, 70, 60, 50}, k = 4
Output : arr[] = {4, 7, 8, 9, 10, 50, 60, 70}
import
def ksort(l, k):
pass
- prepare min heap with first k chars
cur_idx=-1
next_elem=k
loop if next_elem < len(l):
next_elem+1
cur_idx+1
pop min elem, put in cur_idx
take next elem from input and put in heap
repeat from loop:
if all elements are consumed, then
keep popping min and put in the result
Write a simple regex verifier. The regex patterns to match are a-z . *
Where <dot> stands for any character, and
<star> means the previous single character 0 or more times.
The regex must match the entire string, not a substring
input: abaac, abac
pattern: ab*c, a.a*c, .*, .*c, .*d
"""
def regex_matcher(input, pat, i, pidx):
# i could end, and pidx is at the end: success
if i == len(input) and pidx == len(pat):
return True
# i is not at end, pidx is at the end: error
if i != len(input) and pidx == len(pat):
return False
# i is at end, pidx is not at the end, -*, -b*, -.*, -b, -.
if i == len(input) and pidx != len(pat):
first_p = pat[pidx]
if pidx+1 == len(pat):
return False
second_p = pat[pidx+1]
if second_p == '*':
regex_matcher(input, pat, i, pidx+2)
if input[i] == pat[pidx] or pat[pidx] == '.':
return regex_matcher(input, pat, i+1, pidx+1)
elif pat[pidx] == '*':
prev_p = pat[pidx - 1]
if input[i] == prev_p or prev_p == '.':
return regex_matcher(input, pat, i+1, pidx) or regex_matcher(input, pat, i, pidx+1)
else:
return regex_matcher(input, pat, i, pidx+1)
elif input[i] != pat[pidx]:
return False
#s = "aabcb"
#p = "aa*.b"
#input: abaac, abac
#pattern: ab*c, a.a*c, .*, .*c, .*d
s="abaac"
#p = "ab*c"
#p = "a.a*c"
p = "a.b*.a*c"
print(regex_matcher(s, p, 0, 0))
|
#!/usr/bin/env python
""" Stack class """
class Stack:
def __init__(self):
self.stack = []
print "Created stack"
def push(self, elem):
self.stack.append(elem)
def pop(self):
elem = 0
try:
elem = self.stack.pop()
except IndexError:
print "Empty Stack"
return elem
def main():
stack = Stack()
stack.push(12)
stack.push(16)
stack.push(1)
print stack.pop()
print stack.pop()
print stack.pop()
print stack.pop()
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
def count_coin_change(T, D):
n = len(D)
res = [[0] * (T+1) for _ in range(n+1)]
for i in range(n, -1, -1):
for t in range(T+1):
if i == n:
res[i][t] = 0
elif t == 0:
res[i][t] = 1
else:
print("d[i] <= t", D[i], t)
res[i][t] = res[i+1][t]
if D[i] <= t:
res[i][t] += res[i][t - D[i]]
for i in range(n+1):
print(res[i])
return res[0][T]
def main():
#T = 13
T = 14
D = [3, 8, 7, 9]
print(count_coin_change(T, D))
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def serialize(node, output):
if not node:
output.append(-1)
return
output.append(node.data)
serialize(node.left, output)
serialize(node.right, output)
def deserialize(output, idx):
i = idx[0]
if not output or output[i] == -1:
return None
node = Node(output[i])
idx[0] += 1
node.left = deserialize(output, idx)
idx[0] += 1
node.right = deserialize(output, idx)
return node
def print_tree(node):
if not node:
return
print(node.data, end = ", ")
print_tree(node.left)
print_tree(node.right)
n1 = Node(1)
n2 = Node(2)
n3 = Node(3)
n4 = Node(4)
n5 = Node(5)
n6 = Node(6)
n7 = Node(7)
n4.left = n1
n1.right = n2
n2.right = n3
n4.right = n7
n7.left = n6
n6.left = n5
print_tree(n4)
print()
output = []
serialize(n4, output)
print(output)
idx = [0]
node1 = deserialize(output, idx)
print_tree(node1)
print()
|
#!/usr/bin/env python3
class Vertex:
def __init__(self, label):
self.label = label
self.nbrs = []
def add_edge(self, node):
self.nbrs.append(node)
def explore(node, seen, comp):
if node.label in seen:
return
seen.add(node.label)
comp.append(node.label)
for nbr in node.nbrs:
explore(nbr, seen, comp)
return
def dfs(node_list):
seen = set()
for node in node_list:
if node.label not in seen:
comp = []
explore(node, seen, comp)
print(comp)
return
def test1():
n1 = Vertex(1)
n2 = Vertex(2)
n3 = Vertex(3)
n1.add_edge(n2)
n2.add_edge(n3)
l = []
l.append(n1)
l.append(n2)
l.append(n3)
return l
def test2():
n1 = Vertex(1)
n2 = Vertex(2)
n3 = Vertex(3)
n4 = Vertex(4)
n5 = Vertex(5)
n6 = Vertex(6)
n7 = Vertex(7)
n1.add_edge(n2)
#n1.add_edge(n3)
n2.add_edge(n4)
#n3.add_edge(n4)
n4.add_edge(n3)
n4.add_edge(n5)
n4.add_edge(n6)
n6.add_edge(n4)
n5.add_edge(n7)
n6.add_edge(n7)
l = []
l.append(n1)
l.append(n2)
l.append(n3)
l.append(n4)
l.append(n5)
l.append(n6)
l.append(n7)
return l
def main():
l = test1()
dfs(l)
l = test2()
dfs(l)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
def missing_elem_xor(a, k):
n = len(a)
xor_nums = 0
for i in range(k+1):
xor_nums ^= i
for i in range(n):
xor_nums = a[i] ^ xor_nums
print("missing_elem_xor:", xor_nums)
def missing_elem_set(a, k):
s = set()
n = len(a)
for i in range(n):
s.add(a[i])
for i in range(1, k+1):
if i not in s:
print("missing number:", i)
def missing_elem_bf(a, k):
n = len(a)
for i in range(1, k+1):
found = False;
for j in range(n):
if a[j] == i:
found = True
break
if not found:
print("missing number:", i)
return
def main():
print("Running missing element")
#a = [1, 2, 3, 5, 6]
#a = [2, 3, 4, 5, 6]
a = [1, 2, 3, 4, 5]
k = 6
#missing_elem_bf(a, k)
#missing_elem_set(a, k)
missing_elem_xor(a, k)
main()
|
#!/usr/bin/env python3
from operator import itemgetter
def getMergedIntervals(a1):
#
# Write your code here.
#
#a = sorted(a1, key=itemgetter(0))
a = sorted(a1, key=lambda x: x[0])
#print(a1)
#a1.sort(key=lambda x: x[0])
#a = a1
#print(a)
st, end = a[0]
op = []
for st1, end1 in a[1:]:
if st1 <= end:
end = max(end1, end)
else:
op.append([st,end])
st = st1
end = end1
op.append([st,end])
return op
def main():
print("Finding merge interval")
#a = [[10, 12], [1, 2], [1000, 100000], [-1000000000, 1000000000], [2, 5], [7, 10], [123, 456]]
a = [[20, 30], [4, 30], [40, 43], [10, 30], [3, 30]]
print(getMergedIntervals(a))
main()
|
#!/usr/bin/env python3
from tree_creation import print_level_tree
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def bst_sorted_arr(l, st, end):
if st > end:
return None
mid = st + (end - st)//2
root = Node(l[mid])
root.left = bst_sorted_arr(l, st, mid - 1)
root.right = bst_sorted_arr(l, mid + 1, end)
return root
def main():
l = [3, 5, 7, 10, 21, 2, 12, 43, 19, 9]
l = sorted(l)
print(l)
root = bst_sorted_arr(l, 0, len(l) - 1)
print_level_tree(root)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
from collections import deque
from random import randint
class Vertex:
def __init__(self, data):
self.data = data
self.neighbors = []
def add_edge(self, a):
self.neighbors.append(a)
def dfs(node):
seen = set()
print("in dfs")
def _dfs(node):
seen.add(node.data)
for nxt in node.neighbors:
if nxt.data not in seen:
_dfs(nxt)
print(node.data)
_dfs(node)
def bfs_using_vars(node):
seen = set()
q = deque()
q.append(node)
num_prelevel = 1
cur_level = 0
s = str(node.data)
while q:
node = q.popleft()
num_prelevel -= 1
print("after pop:", num_prelevel)
if not num_prelevel:
print(s)
s = ''
cur_level += 1
seen.add(node.data)
for nxt in node.neighbors:
if nxt.data not in seen:
q.append(nxt)
num_prelevel += 1
s += str(nxt.data) + ','
print("num_prelevel", num_prelevel, "string:", s)
def bfs(node):
seen = set()
q = deque()
l = []
prev_level = level = 0
q.append([node, level])
s = ''
while q:
node, level = q.popleft()
seen.add(node.data)
if (level != prev_level):
print(s)
s = ''
prev_level = level
s += str(node.data) + ","
for nxt in node.neighbors:
if nxt.data not in seen:
q.append([nxt, level + 1])
print(s)
node1 = Vertex(1)
node2 = Vertex(2)
node3 = Vertex(3)
node4 = Vertex(4)
node5 = Vertex(5)
node6 = Vertex(6)
node1.add_edge(node2)
node2.add_edge(node4)
node2.add_edge(node5)
node4.add_edge(node3)
node5.add_edge(node4)
node5.add_edge(node6)
node6.add_edge(node1)
node6.add_edge(node2)
bfs(node1)
#if __name__ == '__main__' :
# pass
|
#!/usr/bin/env python3
def alternate(l):
n = len(l)
pi, ni = 0, 0
pos_list = [0] * n
neg_list = [0] * n
for i in range(n):
if l[i] >= 0:
pos_list[pi] = l[i]
pi += 1
else:
neg_list[ni] = l[i]
ni += 1
i, j, k = 0, 0, 0
while i < pi and j < ni:
l[k] = pos_list[i]
i += 1
l[k+1] = neg_list[j]
j += 1
k += 2
while i < pi:
l[k] = pos_list[i]
i += 1
k += 1
while j < ni:
l[k] = neg_list[j]
j += 1
k += 1
print(l)
#l = [1, 3, 6, -2, -9, -1, 5, 8, -6]
l = [1, 3, 6, -2, 5, 8, -6]
print(l)
alternate(l)
|
#!/usr/bin/env python3
class Node:
def __init__(self, data):
self.data = data
self.prev = None
self.next = None
def printlist(head):
print("List: [", end = '')
while head:
print(head.data, end=",")
head = head.next
print("]")
n1 = Node(1)
n2 = Node(2)
n3 = Node(3)
n4 = Node(4)
#n5 = Node(5)
#n6 = Node(6)
#n7 = Node(7)
#n8 = Node(8)
#n9 = Node(9)
n1.next = n2
n2.next = n3
n3.next = n4
#n4.next = n5
#n5.next = n6
#n6.next = n7
#n7.next = n8
#n8.next = n9
head = n1
printlist(head)
def clone_list(node):
prev = None
head = None
while node:
clone = Node(node.data)
node = node.next
if not prev:
head = clone
else:
prev.next = clone
prev = clone
clone.next = None
return head
clone_head = clone_list(head)
printlist(clone_head)
print(head == clone_head)
|
f1 = str(input('Digite uma frase: ')).strip().lower()
print('A letra A aparece {} vezes na frase.'.format(f1.count('a')))
print('A primeira letra A aparece na posição {}'.format(f1.find('a')+1))
print('A última letra A aparece na posição {}'.format(f1.rfind('a')+1))
|
maior = 0
menor = 0
for c in range(1, 6):
peso = float(input(f'Peso da {c}° pessoa:'))
if c == 1:
maior = peso
menor = peso
else:
if c > peso:
maior = peso
if c < peso:
menor = peso
print(f'O maior peso é {maior}Kg')
print(f'O menor peso é {menor}Kg')
|
d1 = float(input('Quanto dinheiro você tem na carteira? R$'))
s = d1 / 5.38
print('Com R${} você pode comprar US${:.2f}'.format(d1, s))
|
dist = int(input('Qual a distância da viagem? '))
print('Você está prestes a começar uma viagem de {}Km'.format(dist))
if dist > 200:
print(f'O preço de sua viagem será de R${dist * 0.45:.2f}')
else:
print(f'O preço de sua viagem será de R${dist * 0.5:.2f}')
|
aluno = dict()
aluno['nome'] = str(input('Nome: '))
aluno['média'] = float(input(f'Média de {aluno["nome"]}: '))
print('=-=' * 30)
print(f'- nome é igual a {aluno["nome"]}')
print(f'- média é igual a {aluno["média"]}')
if aluno["média"] >= 7:
print('- situação é igual a aprovado')
if aluno["média"] >= 5 and aluno["média"] < 7:
print('- situação é Recuperação')
if aluno["média"] < 5:
print('- situação é reprovado')
|
valor = float(input('Qual o valor do imóvel? R$'))
salario = float(input('Qual seu salário mensal? R$'))
finan = int(input('Em quantos anos pretende financiar? '))
prest = valor / (finan * 12)
max = salario * 0.3
print('Para pagar uma casa de R${:.2f} em {} anos, '.format(valor, finan), end='')
print('o valor da prestação será de R${:.2f}'.format(prest))
if prest >= max:
print('Empréstimo NEGADO!')
else:
print('Empréstimo CONCEDIDO!')
|
n1 = int(input('Digite um número: '))
n2 = int(input('Digite outro número: '))
n3 = int(input('Digite mais um número: '))
n4 = int(input('Digite o último número: '))
tupla = (n1, n2, n3, n4)
print(f'Você digitou os valores {tupla}')
print(f'O valor 9 apareceu {tupla.count(9)} vezes.')
if 3 in tupla:
print(f'O valor 3 apareceu na {tupla.index(3) + 1}° posição.')
else:
print('O valor 3 não foi digitado.')
print('Os valores pares digitados foram: ', end='')
for n in tupla:
if n % 2 == 0:
print(f'{n} ', end='')
|
n1 = str(input('Digite seu nome completo: ')).strip().capitalize()
print('Muito prazem em te conhecer!')
nome = n1.split()
print('Seu primeiro nome é {}.'.format(nome[0]))
print('Seu último nome é {}.'.format(nome[len(nome) - 1].capitalize()))
|
largura = float(input('Largura da parede: '))
altura = float(input('Altura da parede: '))
lxa = largura * altura
print('Sua parede tem dimensão de {}x{} e sua área é de {}m².'.format(largura, altura, lxa))
print('Para pintar essa parede, você precisará de {}l de tinta'.format(lxa / 2))
|
user = input("Enter a string of positive integers seperated by spaces: ")
print()
num = user.split()
t = 0
while t <len(num):
num[t] = int(num[t])
t+= 1
for n in num:
print(n*'*') |
import unittest
# m > 0, n > 0
def divide(m:int, n:int) -> int:
i = 0
while m >= n:
m -= n
i += 1
return i
class TestFunc(unittest.TestCase):
def test1(self):
m, n = 4, 2
self.assertEqual(divide(m, n), m//n)
def test2(self):
m, n = 213210909, 324324
self.assertEqual(divide(m, n), m//n)
def test3(self):
m, n = 332432897912321987953, 29384732984723
self.assertEqual(divide(m, n), m//n)
if __name__ == "__main__":
unittest.main()
|
# Question 11:Write a program that accepts a sentence and calculate the number of letters and digits.
# Suppose the following input is supplied to the program:
# i/p: Hello Priya 1287
# o/p: LETTERS 10
# DIGITS 4
str=raw_input("enter string")
d=l=0
for c in str:
if c.isdigit():
d=d+1
elif c.isalpha():
l=l+1
else:
pass
print("letters",l)
print("digits",d)
'''
output:
[root@demo pragya_g16]# python eleven,py
enter string pragya
('letters', 6)
('digits', 0)
'''
|
# Question 6: Write a program that takes inputs from user their name and their age. And display the year in which they will turn 100 years old
import time
import datetime
Name=raw_input("Enter your Name:")
Age=int(input("Enter your Age:"))
#print '/n'Prac
print 'Hi %s ,Your present Age is %d'%(Name,Age)
#print '/n'
#cd=time.strftime("%d/%m/%Y")
#cd-age
#print cd.year
cd1=datetime.datetime.now()
cdy=cd1.year
by=int(cdy-Age)
print 'Your Bday year is %d'%by
#print '/n'
by1=int(by+100)
print 'Your age will be 100 years by'
'''
output:
[root@demo pragya_g16]# python sixthmain.py
Enter your Name:pragya
Enter your Age:24
Hi pragya ,Your present Age is 24
Your Bday year is 1993
Your age will be 100 years by 2093
'''
|
"""Simulated Weather Data."""
import datetime
import json
import random
LOCATIONS = ['Hitchin Weather Station',
'Ashwell',
'FBP Langford',
'Grosvenor Court',
'St. Martins, Isles of Scilly',
'Boswedden House']
class Sample:
"""Simulated weather station sample."""
def __init__(self, location):
temp_celsius = random.randint(18, 21)
wind_speed = random.randint(5, 15)
wind_direction = random.sample(
['N', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW'],
1
)
humidity = random.randint(60, 70)
pressure = random.randint(1010, 1020)
self.location = location
self.timestamp = datetime.datetime.now().isoformat()
self.data = {
'location': location,
'temp_celsius': temp_celsius,
'wind_speed_mph': wind_speed,
'wind_direction': wind_direction,
'humidity_percent': humidity,
'pressure_mb': pressure
}
@property
def json(self):
"""Get data as json.
:returns (str): json str representation.
"""
return json.dumps(self.data)
def make_sample():
return Sample(random.sample(LOCATIONS, 1)[0])
|
import sys
from histogram import Histogram
class Listogram(list, Histogram):
''' Histogram Implemented with list of lists '''
def __init__(self, file=None):
''' Initializes new listogram instance '''
super(Listogram, self).__init__() ## inits new instance of listogram (list)
#* Add type/token count to keep those methods to O(1)
self.types = 0
self.tokens = 0
#* If file is not empty, create listogram
if file is not None:
# words = self.create_text(file) ## method is part of histogram class
for word in file:
self.add_count(word)
def add_count(self, word, count=1):
''' given words either adds to frequency or adds word in listogram '''
self.tokens += count
for lst in self:
if lst[0] == word:
lst[1] += count
return
self.append([word, count]) # if word not in list, append an inner list for word
self.types += 1
def frequency(self, word):
''' returns the frequency of a word in a listogram '''
for lst in self:
if lst[0] == word:
return lst[1] ## lst[1] hold freq value
return 0
def __contains__(self, word):
""" Returns bool whether word is in listogram """
for lst in self:
if lst[0] == word:
return True
return False
def _index(self, target):
""" Takes a target word and returns index # """
for i, lst in enumerate(self):
if lst[0] == target:
return i
def print_listogram(self):
for lst in self:
print('Type: {} - Tokens: {}'.format(lst[0], lst[1]))
def sort_listogram(self):
''' Takes in listogram as input and sorts it by frequency '''
for i in range(len(self)):
for j in range(len(self)):
# checking the freq value in listogram (comparing)
if self[j][1] > self[i][1]:
self[j], self[i] = self[i], self[j]
return self
def to_file(self, file):
"""Takes listogram and writes it to file """
with open(file, 'w') as write_file:
for i in range(len(self)):
write_file.write('Type: {}, Tokens: {}\n'.format(self[i][0], self[i][1]))
def print_histogram(word_list):
print('word list: {}'.format(word_list))
# Create a listogram and display its contents
histogram = Listogram(word_list)
print('listogram: {}'.format(histogram))
print('{} tokens, {} types'.format(histogram.tokens, histogram.types))
for word in word_list[-2:]:
freq = histogram.frequency(word)
print('{!r} occurs {} times'.format(word, freq))
print()
def main():
''' Runs some test stuff on listogram class '''
file = sys.argv[1]
my_listo = Listogram(file)
sorted_listo = my_listo.sort_listogram()
my_listo.to_file('test.txt')
# print(sorted_listo)
if __name__ == '__main__':
main()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.