blob_id
string
repo_name
string
path
string
length_bytes
int64
score
float64
int_score
int64
text
string
af4779e613ae4ea2c34a0d4a89d5bfc03e69cc18
kmutya/Nonlinear-Optimization
/unconstrained_optimization.py
7,640
3.578125
4
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Fri Mar 29 13:57:51 2019 @author: Kartik """ import numpy as np #arrays from numpy import linalg as LA #Linear Algebra import matplotlib.pyplot as plt #plotting import sympy #symbolic computing package from sympy.utilities.lambdify import lambdify #convert sympy objects to python interpretable ################################################## # CREATING FUNCTIONS USING SYMPY ################################################## #Create functions using SymPy v = sympy.Matrix(sympy.symbols('x[0] x[1]')) #import SymPy objects #create a function as a SymPy expression f_sympy1 = v[0]**2 - 2.0 * v[0] * v[1] + 4 * v[1]**2 #first function print('This is what the function looks like: ', f_sympy1) f_sympy2 = 0.5*v[0]**2 + 2.5*v[1]**2 #second function f_sympy3 = 4*v[0]**2 + 2*v[1]**2 + 4*v[0]*v[1] - 3*v[0] #third function ################################################## # CONVERTING SYMPY EXPRESSIONS INTO REGULAR EXPRESSIONS ################################################## #Extract Main function def f_x(f_expression, values): '''Takes in SymPy function expression along with values of dim 1x2 and return output of the function''' f = lambdify((v[0],v[1]), f_expression) #convert to function using lambdify return f(values[0],values[1]) #Evaluate the function at the given value #Extract gradients def df_x(f_expression, values): '''Takes in SymPy function expression along with values of dim 1x2 and returns gradients of the original function''' df1_sympy = np.array([sympy.diff(f_expression, i) for i in v]) #first order derivatives dfx_0 = lambdify((v[0],v[1]), df1_sympy[0]) #derivative w.r.t x_0 dfx_1 = lambdify((v[0],v[1]), df1_sympy[1]) #derivative w.r.t x_1 evx_0 = dfx_0(values[0], values[1]) #evaluating the gradient at given values evx_1 = dfx_1(values[0], values[1]) return(np.array([evx_0,evx_1])) #Extract Hessian def hessian(f_expression): '''Takes in a SymPy expression and returns a Hessian''' df1_sympy = np.array([sympy.diff(f_expression, i) for i in v]) #first order derivatives hessian = np.array([sympy.diff(df1_sympy, i) for i in v]).astype(np.float) #hessian return(hessian) ################################################## # FUNCTIONS TO VISUALIZE ################################################## #Function to create a 3-D plot of the loss surface def loss_surface(sympy_function): '''Plots the loss surface for the given function''' #x = sympy.symbols('x') return(sympy.plotting.plot3d(sympy_function, adaptive=False, nb_of_points=400)) #Function to create a countour plot def contour(sympy_function): '''Takes in SymPy expression and plots the contour''' x = np.linspace(-3, 3, 100) #x-axis y = np.linspace(-3, 3, 100) #y-axis x, y = np.meshgrid(x, y) #creating a grid using x & y func = f_x(sympy_function, np.array([x,y])) plt.axis("equal") return plt.contour(x, y, func) #Function to plot contour along with the travel path of the algorithm def contour_travel(x_array, sympy_function): '''Takes in an array of output points and the corresponding SymPy expression to return travel contour plot ''' x = np.linspace(-2, 2, 100) #x-axis y = np.linspace(-2, 2, 100) #y-axis x, y = np.meshgrid(x, y) #creating a grid using x & y func = f_x(sympy_function, np.array([x,y])) plt.axis("equal") plt.contour(x, y, func) plot = plt.plot(x_array[:,0],x_array[:,1],'x-') return (plot) ################################################## #ALGORITHMS ################################################## ####Newton Method def Newton(sympy_function, max_iter, start, step_size = 1, epsilon = 10**-2): i = 0 x_values = np.zeros((max_iter+1,2)) x_values[0] = start norm_values = [] while i < max_iter: norm = LA.norm(df_x(sympy_function, x_values[i])) if norm < epsilon: break else: grad = df_x(sympy_function, x_values[i]) hessian_inv = LA.inv(hessian(sympy_function)) p = -np.dot(grad, hessian_inv) x_values[i+1] = x_values[i] + step_size*p norm_values.append(norm) i+=1 print('No. of steps Newton takes to converge: ', len(norm_values)) return(x_values, norm_values) ####Steepest Descent Method def SDM(sympy_function, max_iter, start, step_size, epsilon = 10**-2): i = 0 x_values = np.zeros((max_iter+1,2)) x_values[0] = start norm_values = [] while i < max_iter: norm = LA.norm(df_x(sympy_function, x_values[i])) if norm < epsilon: break else: p = -df_x(sympy_function, x_values[i]) #updated direction to move in x_values[i+1] = x_values[i] + step_size*p #new x-value norm_values.append(norm) i+=1 print('No. of steps SDM takes to converge: ', len(norm_values)) return(x_values, norm_values) #### Conjugate Gradient Method def CGM(sympy_function, max_iter, start, step_size, epsilon = 10**-2): i = 0 x_values = np.zeros((max_iter+1,2)) x_values[0] = start grad_fx = np.zeros((max_iter+1,2)) p = np.zeros((max_iter+1,2)) norm_values = [] while i < max_iter: grad_fx[i] = df_x(sympy_function, x_values[i]) norm = LA.norm(df_x(sympy_function, x_values[i])) if norm < epsilon: break else: if i == 0: beta = 0 p[i] = - np.dot(step_size,df_x(sympy_function, x_values[i])) else: beta = np.dot(grad_fx[i],grad_fx[i]) / np.dot(grad_fx[i-1],grad_fx[i-1]) p[i] = -df_x(sympy_function, x_values[i]) + beta * p[i-1] x_values[i+1] = x_values[i] + step_size*p[i] norm_values.append(norm) i += 1 print('No. of steps CDM takes to converge: ', len(norm_values)) return(x_values, norm_values) ################################################## #IMPLEMENTATION ################################################## #Case 1 loss_surface(f_sympy1) contour(f_sympy1) #Newton newton_values1, newton_norm1 = Newton(f_sympy1, 9, [-3.0,2.0]) contour_travel(newton_values1, f_sympy1) #SDM sdm_values1, sdm_norm1 = SDM(f_sympy1, 40, [-3.0,2.0], 0.15) contour_travel(sdm_values1, f_sympy1) #CGM cgm_values1, cgm_norm1 = CGM(f_sympy1, 50, [-3.0,2.0], 0.15) contour_travel(cgm_values1, f_sympy1) #Case2 loss_surface(f_sympy2) contour(f_sympy2) #Newton newton_values2, newton_norm2 = Newton(f_sympy2, 9, [-3.0,2.0]) contour_travel(newton_values2, f_sympy2) #SDM sdm_values2, sdm_norm2 = SDM(f_sympy2, 50, [-3.0,2.0], 0.15) contour_travel(sdm_values2, f_sympy2) #CGM cgm_values2, cgm_norm2 = CGM(f_sympy2, 50, [-3.0,2.0], 0.15) contour_travel(cgm_values2, f_sympy2) #Case3 loss_surface(f_sympy3) contour(f_sympy3) #Newton newton_values3, newton_norm3 = Newton(f_sympy3, 9, [-3.0,2.0]) contour_travel(newton_values3, f_sympy3) #SDM sdm_values3, sdm_norm3 = SDM(f_sympy3, 50, [-3.0,2.0], 0.15) contour_travel(sdm_values3, f_sympy3) #CGM cgm_values3, cgm_norm3 = CGM(f_sympy3, 50, [-3.0,2.0], 0.15) contour_travel(cgm_values3, f_sympy3)
8d8c6d7bf7cd63ece8498ad8a5e7653dfb9d008a
rondemora/lstm_predictor
/trader_simulator.py
7,411
4
4
""" Simulates a trader in the stock market during the test dataset for different models: 1. LSTM 2. Prophet 3. Other implemented trading strategies """ from keras.models import load_model import lstm import data_preprocessor import prophet import random import numpy as np import pandas as pd from sklearn.metrics import mean_squared_error from math import sqrt class Colors: BLUE = '\033[94m' GREEN = '\033[92m' ENDC = '\033[0m' class Trader: def __init__(self, initial_capital): self.capital = initial_capital self.stock = 0 def buy_or_hold_order(self, current_price): """ Simulates a buy in the market. The maximum number of shares are bought. """ if self.capital >= current_price: # Both options are considered: stock was previously zero or different than zero: stock_to_buy = self.capital // current_price self.capital -= stock_to_buy * current_price self.stock += stock_to_buy # print(Colors.GREEN+'REAL BUY ++++++++++++++++'+Colors.ENDC) # else: # print(Colors.GREEN+'+++'+Colors.ENDC) def sell_order(self, current_price): """ Simulates a sell order in case the trader holds any stock. """ if self.stock > 0: self.capital += self.stock * current_price self.stock = 0 # print(Colors.BLUE+'REAL SELL --------------------------------'+Colors.ENDC) # else: # print(Colors.BLUE+'---'+Colors.ENDC) def calculate_roi(current_value, cost): return (current_value - cost) / cost def simulate_trade(real_values, predictions, initial_capital): """ Simulates any trading entity, given an array of real prices and predictions """ trader = Trader(initial_capital) for day in range(len(predictions)): if predictions[day] > real_values[day]: trader.buy_or_hold_order(real_values[day]) else: trader.sell_order(real_values[day]) # At the end of the dataset, a sell order is placed to convert all stocks to liquid with the price of the last # observation: trader.sell_order(real_values[len(predictions) - 1]) return calculate_roi(trader.capital, initial_capital) def simulate_trade_buy_hold(real_prices, initial_capital): """ Simulates a trading entity which follows a simple buy and hold strategy """ trader = Trader(initial_capital) trader.buy_or_hold_order(real_prices[0]) trader.sell_order(real_prices[len(real_prices) - 1]) return calculate_roi(trader.capital, initial_capital) def simulate_trade_random(real_prices, initial_capital): """ Simulates trading entity following a random behaviour """ trader = Trader(initial_capital) for day in range(len(real_prices)): if random.choice([True, False]): trader.buy_or_hold_order(real_prices[day]) else: trader.sell_order(real_prices[day]) return calculate_roi(trader.capital, initial_capital) def predict_average_method(real_prices, days_window): """ Makes the predictions for the SMA method """ predictions = [] for day in range(len(real_prices)): predictions.append(calculate_mean(day, days_window, real_prices)) return np.array(predictions) def calculate_mean(index, elems_before, array): min_index = max(0, index - elems_before) max_index = index sum = 0 # max_index + 1 since the current day is also included in the calculation for elem in range(min_index, max_index + 1): sum += array[elem] return sum / len(range(min_index, max_index + 1)) if __name__ == "__main__": initial_capital = 10000 input_seq_length = 5 # Timesteps: must be changed depending on the model. # LSTM and Prophet models to execute lstm_model = 'model_5_500_8_96.h5' prophet_model = 'prophet_predictions_9000_5_0.13_25.csv' # Since the Prophet prediction DataFrame contains all the predictions and not only the ones in the test dataset, # it will be needed to extract only the ones used for the rest of the model: initial_date_prophet = 11671 # Prepares the test and train dataser for several models to use X_train, y_train, X_test, y_test = data_preprocessor.prepare_data_lstm(input_seq_length, lstm.SCALER, lstm.N_FEATURES) # LSTM MODEL ======================================================================== model = load_model(lstm.MODELS_FOLDER + lstm_model) rmse, y_test_scaled, predictions_lstm = lstm.predict_model(model, X_test, y_test, lstm.SCALER) roi_lstm = simulate_trade(y_test_scaled, predictions_lstm, initial_capital) print('ROI(LSTM) = ' + str(roi_lstm)) # PROPHET MODEL ======================================================================= df_predictions_prophet = pd.read_csv( prophet.BASE_FOLDER + prophet.RAW_FOLDER + prophet_model) # We select only from 2008-05-14 to 2019-12-05, which are the dates tested with the LSTM predictions_prophet = df_predictions_prophet[initial_date_prophet:] predictions_prophet = np.array(predictions_prophet[['yhat']]) roi_prophet = simulate_trade(y_test_scaled, predictions_prophet, initial_capital) print('ROI(Facebook Prophet) = ' + str(roi_prophet)) # AVERAGE MODEL ====================================================================== sliding_window = 20 # Days to include in the average (current day also included) predictions_average = predict_average_method(y_test_scaled, sliding_window) roi_average = simulate_trade(y_test_scaled, predictions_average, initial_capital) print('ROI(SMA ' + str(sliding_window) + ' DAYS) = ' + str(roi_average)) # AVERAGE MODEL ====================================================================== sliding_window = 60 # Days to include in the average (current day also included) predictions_average_2 = predict_average_method(y_test_scaled, sliding_window) roi_average_2 = simulate_trade(y_test_scaled, predictions_average_2, initial_capital) print('ROI(SMA ' + str(sliding_window) + ' days) = ' + str(roi_average_2)) # BUY AND HOLD MODEL ================================================================== roi_bh = simulate_trade_buy_hold(y_test_scaled, initial_capital) print('ROI(Buy&Hold) = ' + str(roi_bh)) # RANDOM MODEL (mean of several simulations) =========================================== simulations = 1000 roi_random = 0 for i in range(simulations): roi_random += simulate_trade_random(y_test_scaled, initial_capital) print('ROI(random) = ' + str(roi_random / simulations)) # LAST VALUE MODEL ===================================================================== # In this model, the prediction for the next day is the Nth-previous day closing price shift_observations = 5 predictions_last_value = np.roll(y_test_scaled, shift_observations) roi_last_value = simulate_trade(y_test_scaled, predictions_last_value, initial_capital) print('ROI(last value) = ' + str(roi_last_value)) # RMSE between the predictions and a shif of N observations # print('\tRMSE(predictions, predictions-'+str(shift_observations)+') = '+str(sqrt(mean_squared_error(y_test_scaled, predictions_last_value))))
ba9c0bcd80f26936d0fc42729056ed59291603b6
Adrian0207/-LetsGo_Python
/Ejercicios_POO/ejercicio1.py
1,317
3.875
4
''' Crear una clase Persona que tenga como atributo Nombre, Edad y DNI. Aplique el uso de decoradores. Crear una funcion que permita verificar si es mayor a 18 años Usar la funcion __str__ para imprimir el nombre y la edad ''' class Persona(): def __init__(self,nombre="",edad=0,dni=""): self.__nombre=nombre self.__edad=edad self.__dni=dni '''Decorador de nombre''' @property def nombre(self): return self.__nombre @nombre.setter def nombre(self,nombre): self.__nombre=nombre '''Decorador de edad''' @property def edad(self): return self.__edad @edad.setter def edad(self,edad): self.__edad=edad '''Decorador de DNI''' @property def dni(self): return self.__dni @dni.setter def dni(self,dni): self.__dni=dni def esMayorDeEdad(self): if self.edad >= 18: print('Es mayor de edad') else: print('Es menor de edad') def __str__(self): return 'Nombre: {} Edad: {}'.format(self.nombre, self.edad) p1 = Persona() print(p1) p2 = Persona('Pepe', 5); print(p2); p2.esMayorDeEdad() p3 = Persona('Jorge', 18); print(p3); p3.esMayorDeEdad() p4 = Persona('Maria', 30); print(p4); p4.esMayorDeEdad()
7208bf6250ee0f0e34ebfbff44bfe9d4e38ca59c
Parkyunhwan/Programmers
/Level_1/최대공약수와최소공배수.py
746
3.59375
4
# version1 # 유클리드 호제법을 이용한 최소공배수 최대공약수 구하기 # 작은 값은 big으로 간다. 서로의 나머지는 small로 간다. small이 0이 될 때까지 계속한다. def gcd(a, b): while b != 0: tmp = a % b a = b b = tmp return a def solution(n, m): answer = [] if (n < m): tmp = n # 3 n = m # 12 m = tmp # 3 temp = gcd(n, m) answer.append(temp) answer.append((n * m) / temp) return answer # version2 # 파이썬의 특성을 이용해서 한번에 계산해본 버전 def gcdlcd(n, m): n , m = max(n, m), min(n, m) a , b = n , m while m != 0: tmp , n = n%m , m m = tmp return [n,(a*b)/n]
4628cb33312da7e7024301c5fdef2c367470c542
marcos-mpc/CursoEmVideo-Mundo-2
/ex061.py
146
3.78125
4
termo = int(input('TERMO: ')) razao = int(input('RAZÃO: ')) cont = 0 while cont < 10: print(termo, end=' ') termo += razao cont += 1
8d80b107dde8aad1ccc9cc9f4e81c8ebd264230b
Neela25/python-75-hackathon
/dict.py
709
4.0625
4
#Creating 3 dictionaries consisting of student details student1=dict(name="Neela",regno="16C050",sem=5) student2={"name":"Meena","regno":"16C040","sem":5} student3=dict(name="Abi",regno="16C003",sem=5) #Using setdefault() method,the value for key roll is obtained in n #Since key roll is not in the dictionary,it is set n=student2.setdefault("roll",59057) #Printing the dictionaries for i in student1 and student2 and student3: print(student1[i],student2[i],student3[i]) #Since roll is only in student2, the loop doesn't print it and it is printed separately print(student2) #Output '''Neela Meena Abi 16C050 16C040 16C003 5 5 5 {'name': 'Meena', 'regno': '16C040', 'sem': 5, 'roll': 59057}'''
f5eccea0d481a56b3b13b3738ec4880d41c466cf
huyuexin/helloworld
/list2.py
285
4.09375
4
squares=[] for values in range(1,11): square = values ** 2 squares.append(square) print(squares) squares=[] for values in range(1,31,3): squares.append(values) print(squares) print(squares[0:3]) print(squares[2:5]) print(squares[2:]) print(squares[-3:])
5d73b593bf3f45a06eb22909a01e86cf8babdf6b
deepak1214/CompetitiveCode
/LeetCode_problems/Spiral Matrix/solution.py
1,916
3.5
4
#Logic: #First, four variables containing the indices for the corner points of the array are initialized. #The algorithm starts from the top left corner of the array, and traverses the first row from left to right. #Once it traverses the whole row it does not need to revisit it, thus, it increments the top corner index. #Once complete, it traverses the rightmost column top to bottom. Again, once this completes, #there is no need to revisit the rightmost column, thus, it decrements the right corner index. #Next, the algorithm traverses the bottommost row and decrements the bottom corner index afterward. #Lastly, the algorithm traverses the leftmost column, incrementing the left corner index once it’s done. #This continues until the left index is greater than the right index, and the top index is greater than the bottom index. class Solution: def spiralOrder(self, matrix: List[List[int]]) -> List[int]: if not matrix: return [] start_row = 0 start_col = 0 end_row = len(matrix) end_col = len(matrix[0]) output = [] while(start_row<end_row and start_col<end_col): for i in range(start_col,end_col): output.append(matrix[start_row][i]) start_row+=1 for j in range(start_row,end_row): output.append(matrix[j][end_col-1]) end_col-=1 if(end_row<=start_row): break for k in range(end_col-1,start_col-1,-1): output.append(matrix[end_row-1][k]) end_row-=1 if(end_col<=start_col): break for l in range(end_row-1,start_row-1,-1): output.append(matrix[l][start_col]) start_col+=1 return output
0bcbeadeba532d6056209f34202662c855cadfe0
chrhck/pyABC
/pyabc/pyabc_rand_choice.py
436
3.546875
4
import numpy as np def fast_random_choice(weights): """ this is at least for small arrays much faster than numpy.random.choice. For the Gillespie overall this brings for 3 reaction a speedup of a factor of 2 """ cs = 0 u = np.random.rand() for k in range(weights.size): cs += weights[k] if u <= cs: return k raise Exception("Random choice error {}".format(weights))
275f18aa119f11353e1c0be3ea3fe1f2d2116eb3
rwalroth/roboto_gui
/roboto_gui/CommandLine.py
2,392
3.5
4
from PyQt5.QtWidgets import QLineEdit, QWidget, QHBoxLayout, QPushButton from PyQt5 import QtCore class CommandLine(QLineEdit): """Widget to simulate a command line interface. Stores past commands, support enter to send and up and down arrow navigation. attributes: current: int, index of current command commands: list, list of previous commands """ sendCommand = QtCore.pyqtSignal(str) def __init__(self, parent=None): super().__init__(parent) self.current = -1 self.commands = [''] def keyPressEvent(self, QKeyEvent): """Handles return, up, and down arrow key presses. """ key = QKeyEvent.key() if key == QtCore.Qt.Key_Return or key == QtCore.Qt.Key_Enter: self.send_command() elif key == QtCore.Qt.Key_Up: self.current -= 1 if self.current < -len(self.commands): self.current = -len(self.commands) self.setText(self.commands[self.current]) elif key == QtCore.Qt.Key_Down: self.current += 1 if self.current > -1: self.current = -1 self.setText(self.commands[self.current]) else: super().keyPressEvent(QKeyEvent) def send_command(self, q=None): """Adds the current text to list of commands, clears the command line, and moves current index to -1. Subclasses should overwrite this to actually send the command, and call this method after to handle command storage. """ command = self.text() if not (command.isspace() or command == ''): self.commands.insert(-1, command) self.setText('') self.current = -1 self.sendCommand.emit(command) class CommandLineWidget(QWidget): sendCommand = QtCore.pyqtSignal(str) def __init__(self, parent=None): super(CommandLineWidget, self).__init__(parent) self.layout = QHBoxLayout() self.setLayout(self.layout) self.commandLine = CommandLine(self) self.layout.addWidget(self.commandLine) self.sendButton = QPushButton(self) self.sendButton.setText("Send") self.layout.addWidget(self.sendButton) self.sendButton.clicked.connect(self.commandLine.send_command) self.commandLine.sendCommand.connect(self.sendCommand)
020d405a5555b920cbf6c1e4c38f4fe95ab1f086
akashlahane33/AkashPythonCodes
/FilterMapreduce.py
246
3.59375
4
from functools import reduce nums = [2,3,4,5,6,7,8,9,5,4,33,55,33,654,54] evens = list(filter(lambda n : n%2==0,nums)) doubles = list(map(lambda n : n*2,evens)) sum = reduce(lambda a,b : a + b,doubles) print(evens) print(doubles) print(sum)
0b45c3d7ba91c51e821d2d7435d268a48b67f44d
mfa1980/python-012021
/Lekce 3/Ukoly/priklad15.py
1,715
3.5
4
""" Prodej vstupenek Vytvoř program na prodej vstupenek do letního kina. Ceny vstupenek jsou v tabulce níže. Datum Cena 1. 7. 2021 - 10. 8. 2021 250 Kč 11. 8. 2021 - 31. 8. 2021 180 Kč Mimo tato data je středisko zavřené. Tvůj program se nejprve zeptá uživatele na datum a počet osob, pro které uživatel chce vstupenky koupit. Uživatel zadá datum ve středoevropském formátu. Převeď řetězec zadaný uživatelem na datum pomocí funkce datetime.strptime(). Pokud by uživatel zadal příjezd mimo otevírací dobu, vypiš, že letní kino je v té době uzavřené. Pokud je letní kino otevřené, spočítej a vypiš cenu za ubytování. Data lze porovnávat pomocí známých operátorů <, >, <=, >=, ==, !=. Tyto operátory můžeš použít v podmínce if. Níže vidíš příklad porovnání dvou dat. Program vypíše text "První datum je dřívější než druhé datum.". prvni_udalost = datetime(2021, 7, 1) druha_udalost = datetime(2021, 7, 3) if prvni_datum < druhe_datum: print("Druhá událost se stala po první události") """ from datetime import datetime, timedelta datum = input("Zadej datum představení ve formátu DD.MM.RRRR: ") datum = datetime.strptime(datum,"%d.%m.%Y") #print(datum) pocet = int(input("Zadej počet vstupenek: ")) zacatek_prvni = datetime(2021,7,1) konec_prvni = datetime(2021,8,10) zacatek_druha = datetime(2021,8,11) konec_druha = datetime(2021,8,31) cena = 0 if datum >= zacatek_prvni and datum <= konec_prvni: cena = pocet * 250 print (f"Cena za vstupenky je {cena} Kč.") elif datum >= zacatek_druha and datum <= konec_druha: cena = pocet * 180 print (f"Cena za vstupenky je {cena} Kč.") else: print("Letní kino je uzavřené.")
32927fa81e1f43cca294874da6a9ee96de4453bf
neizod/problems
/codejam/18/2/falling-balls.py
1,560
3.546875
4
#!/usr/bin/env python3 def get_destination(last_row): nudge = 0 destination = [None for _ in last_row] for index, size in enumerate(last_row): destination[nudge:nudge+size] = [index] * size nudge += size return destination def get_table(last_row): if last_row[0] == 0 or last_row[-1] == 0: return [] table = [] destination = get_destination(last_row) count = [1 for _ in last_row] while count != last_row: next_destination = [None for _ in last_row] row = '' for index, dest in enumerate(destination): if dest is not None and index > dest: count[index] -= 1 count[index-1] += 1 next_destination[index-1] = dest row += '/' elif dest is not None and index < dest: count[index] -= 1 count[index+1] += 1 next_destination[index+1] = dest row += '\\' else: next_destination[index] = dest row += '.' destination = next_destination table += [row] table += ['.'*len(last_row)] return table def main(): for case in range(int(input())): input() last_row = [int(n) for n in input().split()] answer = get_table(last_row) feasible = 'IMPOSSIBLE' if not answer else len(answer) print('Case #{}: {}'.format(case+1, feasible)) for line in answer: print(line) if __name__ == '__main__': main()
ff3e3d679882abb9b0ab87c0ed7a5c790cd3f289
sdmgill/python
/Learning/Chapter10/FindStringInFiles.py
1,618
3.53125
4
def get_lines_with(input_str, substr): """ Get all lines containing a substring. Args: input_str (str): String to get lines from. substr (str): Substring to look for in lines. Returns: list[str]: List of lines containing substr. """ lines = [] for line in input_str.strip().split('\n'): if substr.upper() in line: #lines.append(line) print(line) #print(lines) def txt_lines_with(fname, substr): """ Get all lines in a .txt file containing a substring. Args: fname (str): File name to open. substr (str): Substring to look for in lines. Returns: list[str]: List of lines containing substr. """ f_contents = open(fname, 'r').read() return get_lines_with(f_contents, substr) #path = r'C:\Users\seangi\OneDrive - Ports America\_Projects\EDW\Claims\DocsAndNotes\4-20 Release DB Scripts\DB scripts\1-JDICM_Upgrade_From_2016.20_To_Latest.sql' #path = r'C:\Users\seangi\OneDrive - Ports America\_Projects\EDW\Claims\DocsAndNotes\4-20 Release DB Scripts\DB scripts\2-JDICM_AllProcs.sql' #path = r'C:\Users\seangi\OneDrive - Ports America\_Projects\EDW\Claims\DocsAndNotes\4-20 Release DB Scripts\DB scripts\3-JDICM_Maintenance.sql' #path = r'C:\Users\seangi\OneDrive - Ports America\_Projects\EDW\Claims\DocsAndNotes\4-20 Release DB Scripts\DB scripts\4-Ports CM-6123 Incidents display as claims-24611.sql' path = r'C:\Users\seangi\OneDrive - Ports America\_Projects\EDW\Claims\DocsAndNotes\4-20 Release DB Scripts\DB scripts\PythonTestFile.sql' txt_lines_with(path,"DROP TABLE")
2ea7e3e8fd4f05be82bbee822a99d8cba6b5d5ce
gabriellaec/desoft-analise-exercicios
/backup/user_222/ch47_2019_03_28_12_22_57_662078.py
175
3.859375
4
mes=int(input('numero do mes')) lista=['janeiro','fevereiro','março','abril','maio','junho','julho','agosto','setembro','outubro','novembro','dezembro'] print(lista[mes-1])
a657f0ae35e6f4bd6430d74f546c410e65b9b812
susunini/leetcode
/281.zigzag-iterator.py
2,477
4
4
# # [281] Zigzag Iterator # # https://leetcode.com/problems/zigzag-iterator # # Medium (50.16%) # Total Accepted: # Total Submissions: # Testcase Example: '[1,2]\n[3,4,5,6]' # # # Given two 1d vectors, implement an iterator to return their elements # alternately. # # # For example, given two 1d vectors: # # v1 = [1, 2] # v2 = [3, 4, 5, 6] # # # # By calling next repeatedly until hasNext returns false, the order of elements # returned by next should be: [1, 3, 2, 4, 5, 6]. # # # # Follow up: What if you are given k 1d vectors? How well can your code be # extended to such cases? # # # Clarification for the follow up question - Update (2015-09-18): # The "Zigzag" order is not clearly defined and is ambiguous for k > 2 cases. # If "Zigzag" does not look right to you, replace "Zigzag" with "Cyclic". For # example, given the following input: # # [1,2,3] # [4,5,6,7] # [8,9] # # It should return [1,4,8,2,5,9,3,6,7]. # # class ZigzagIterator(object): """ Google. Design. 21%. """ def __init__(self, v1, v2): """ Initialize your data structure here. :type v1: List[int] :type v2: List[int] """ self.lists = [v1, v2] self.pointers = [0 if li else sys.maxint for li in self.lists] def next(self): """ :rtype: int """ pointer = min(self.pointers) list_index = self.pointers.index(pointer) list = self.lists[list_index] res = list[pointer] self.pointers[list_index] += 1 if self.pointers[list_index] >= len(list): self.pointers[list_index] = sys.maxint return res def hasNext(self): """ :rtype: bool """ return any([self.pointers[i] != sys.maxint for i in range(len(self.pointers))]) class ZigzagIterator(object): """ queue. 50%. """ def __init__(self, v1, v2): """ Initialize your data structure here. :type v1: List[int] :type v2: List[int] """ self.queue = [v for v in (v1, v2) if v] def next(self): """ :rtype: int """ v = self.queue.pop(0) res = v.pop(0) if v: self.queue.append(v) return res def hasNext(self): """ :rtype: bool """ return bool(self.queue) # Your ZigzagIterator object will be instantiated and called as such: # i, v = ZigzagIterator(v1, v2), [] # while i.hasNext(): v.append(i.next())
c2cb3276c020e883219a49a70291127bc3f11f6f
gtshepard/TechnicalInterviewPrep2020
/assignments/week1/day3/garrison_shepard_lc/find_all_anagrams/garrison_shepard_LC_438.py
577
3.640625
4
def findAnagrams(s, p): result = [] p = sorted(p) #generate all substrings for i in range(len(s)): j = i + 1 for j in range(len(s)+1): if len(s[i:j]) is len(p): #sort string of same length sub_str = sorted(s[i:j]) # should be same if anagram if sub_str == p: result.append(i) return result # run time is O(N^2*N log N) space O(1) # passes 22 of 36 test cases exceeds time limit on 23rd test case # see image in folder for leetcode results
1aa18a01c26f4d9b5af8bf5fc22e01039ff57813
ronak-kachalia/python-tutorial
/Python Lectures/28- if __name__ == '__main__'/first_module.py
631
3.859375
4
# ============================================================================= # __name__ is a python reserved variable that stores name of the current module. # if the current module is the one which is run directly by Python then __name__ = '__main__' # else, if it is not run directly by python, then __name__ = '{Name of the Module}' # ============================================================================= # print(f'First module\'s name: {__name__}') print('This is always going to run') #%% def main(): print(f'First module\'s name: {__name__}') if __name__ == '__main__': main() else: print(__name__)
e1b652e525c423db8e42b9dcd2da24561b057c85
ParthDeshpande27/PH-354-2019-IISc-Assignment-Problems
/hw5/01/1.py
622
3.703125
4
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Sat Mar 9 12:02:37 2019 @author: alankar """ import numpy as np np.random.seed(500) dice1 = np.random.randint(low=1,high=6) dice2 = np.random.randint(low=1,high=6) print('Dice 1: %d'%dice1) print('Dice 2: %d'%dice2) N = int(1.e6) dice1 = np.random.randint(low=1,high=7,size=N) dice2 = np.random.randint(low=1,high=7,size=N) counter = 0 for i in range(N): if(dice1[i]==6 and dice2[i]==6): counter+=1 print('Probability of getting a double six: %f'%(counter/N)) """ Output: Dice 1: 3 Dice 2: 2 Probability of getting a double six: 0.027814 """
3f2573a4d86c6c02c0041404f362c0106251b9e1
vcatafesta/chili
/python/decorators.py
6,665
4.125
4
def outer_function(): message = 'Hi' def inner_function(): print(message) return inner_function() outer_function() hi_func = outer_function() ################################################################################# def outer_function(msg): message = msg def inner_function(): print(message) return inner_function() hi_func = outer_function('Hi') by_func = outer_function('Bye') ################################################################################# def cumprimentar(nome): return 'Hello ' + nome greet_someone = cumprimentar print(greet_someone('Vilmar')) ################################################################################# def greet(name): def get_message(): return "Hello " result = get_message() + name return result print(greet('Vilmar')) ################################################################################# def hello(nome): return 'Alo ' + nome def call_func(func): other_name = 'Evili' return func(other_name) print(call_func(hello)) ################################################################################# def compose_greet_func(): def get_message(): return "Hello there!" return get_message greet = compose_greet_func() print(greet()) ################################################################################# def compose_greet_func(nome): def get_message(): return "Ola " + nome + "!" return get_message greet = compose_greet_func("John") print(greet()) ################################################################################# def get_text(name): return "lorem ipsum, {0} dolor sit amet".format(name) def p_decorate(func): def func_wrapper(name): return "<p>{0}</p>".format(func(name)) return func_wrapper my_get_text = p_decorate(get_text) print(my_get_text("John")) ################################################################################# def p_decorate(func): def func_wrapper(name): return "<p>{0}</p>".format(func(name)) return func_wrapper @p_decorate def get_text(name): return "lorem ipsum, {0} dolor sit amet".format(name) print(get_text("John")) ################################################################################# def p_decorate(func): def func_wrapper(name): return "<p>{0}</p>".format(func(name)) return func_wrapper def strong_decorate(func): def func_wrapper(name): return "<strong>{0}</strong>".format(func(name)) return func_wrapper def div_decorate(func): def func_wrapper(name): return "<div>{0}</div>".format(func(name)) return func_wrapper get_text = div_decorate(p_decorate(strong_decorate(get_text))) @div_decorate @p_decorate @strong_decorate def get_text(name): return "lorem ipsum, {0} dolor sit amet".format(name) print(get_text("John")) ################################################################################# def p_decorate(func): def func_wrapper(self): return "<p>{0}</p>".format(func(self)) return func_wrapper class Person(object): def __init__(self): self.name = "John" self.family = "Doe" @p_decorate def get_fullname(self): return self.name + " " + self.family my_person = Person() print(my_person.get_fullname()) ################################################################################# def p_decorate(func): def func_wrapper(*args, **kwargs): return "<p>{0}</p>".format(func(*args, **kwargs)) return func_wrapper class Person(object): def __init__(self): self.name = "John" self.family = "Doe" @p_decorate def get_fullname(self): return self.name + " " + self.family my_person = Person() print(my_person.get_fullname()) ################################################################################# def tags(tag_name): def tags_decorator(func): def func_wrapper(name): return "<{0}>{1}</{0}>".format(tag_name, func(name)) return func_wrapper return tags_decorator @tags("p") def get_text(name): return "Hello " + name print(get_text("John")) ################################################################################# from functools import wraps def tags(tag_name): def tags_decorator(func): @wraps(func) def func_wrapper(name): return "<{0}>{1}</{0}>".format(tag_name, func(name)) return func_wrapper return tags_decorator @tags("p") def get_text(name): """returns some text""" return "Hello " + name print(get_text.__name__) # get_text print(get_text.__doc__) # returns some text print(get_text.__module__) # __main__ ################################################################################# import time def timing_function(some_function): """ Outputs the time a function takes to execute. """ def wrapper(): t1 = time.time() some_function() t2 = time.time() return "Time it took to run the function: " + str((t2 - t1)) + "\n" return wrapper @timing_function def my_function(): num_list = [] for num in (range(0, 10000)): num_list.append(num) print("\nSum of all the numbers: " + str((sum(num_list)))) print(my_function()) ################################################################################# def decorator_function(original_function): def wrapper_function(*args, **kwargs): print('wrapper executado antes de {}'.format( original_function.__name__)) return original_function(*args, **kwargs) return wrapper_function @decorator_function def display(): print('Display function ran') @decorator_function def display_info(name, age): print("display_info ran with arguments ({},{})".format(name, age)) display_info('Vilmar', 50) display() ################################################################################# from funcoes import sci_logger @sci_logger def display_info_log(name, age): print("display_info ran with arguments ({},{})".format(name, age)) display_info_log('Vilmar', 50) display_info_log('Vilmar', 150) display_info_log('Vilmar', 250) display_info_log('Vilmar', 350)
f9212a3a72f965cad9c72387e1669cea7bb7353a
Troy-Wang/LeetCode
/201611_Week2/20161108_2.py
507
3.859375
4
""" Count Numbers with Unique Digits Given a non-negative integer n, count all numbers with unique digits, x, where 0 <= x < 10n. """ class Solution(object): def countNumbersWithUniqueDigits(self, n): """ :type n: int :rtype: int """ if n == 0: return 1 if n > 10: n = 10 count = 0 current = 1 for i in range(n - 1): current *= 9 - i count += current return count * 9 + 10
889809ecfa1525b20408b3e63edcb25409273c9a
gcctryg/cs362_hw4
/q2.py
694
3.734375
4
import unittest def calc_avg(num): sumNum = 0 for i in num: sumNum = sumNum + i length = len(num) avg = ( sumNum / length) if length != 0 else 0 return avg class testCase(unittest.TestCase): def test_func(self): self.assertEqual(calc_avg([1,3,5,7,9]), 5) self.assertEqual(calc_avg([1,3,5,7,9]), 25) def test_emptyList(self): self.assertTrue(calc_avg([1,2,3,4,5])) self.assertTrue(calc_avg([])) def test_divZero(self): with self.assertRaises(ValueError): calc_avg([]) with self.assertRaises(ValueError): calc_avg([1,2,3,4]) if __name__ == '__main__': unittest.main()
c28faf8c80a3b738e80aaebfce38ecd275b67972
shantanu-python/Python
/prime.py
428
4.125
4
import math def is_prime(a): n = abs(a) if (n<2): return False elif (n%2==0): return False n1 = int(math.sqrt(n))+ 1 return all(n%i for i in range(3,n1,2)) q = None while(q!= "q"): x = int(input("Enter the number :")) p = is_prime(x) s = "is prime." if p else "is not prime." print(x,s) q = input("Press q to exit , any other key to continue :")
a22d626df17fcca840d974e601e4169f4cce5de3
rescenic/Softuni-Python-v2
/python-fundamentals/09 RegEx - Excercise/01. Capture the Numbers.py
159
3.5625
4
import re pattern = r'\d+' numbers = [] line = input() while line: numbers.extend(re.findall(pattern, line)) line = input() print(' '.join(numbers))
65ea595058056595299b2c9d3df6279623e0868f
bssrdf/pyleet
/F/FindLatestGroupofSizeM.py
2,006
3.578125
4
''' -Medium- Given an array arr that represents a permutation of numbers from 1 to n. You have a binary string of size n that initially has all its bits set to zero. At each step i (assuming both the binary string and arr are 1-indexed) from 1 to n, the bit at position arr[i] is set to 1. You are given an integer m and you need to find the latest step at which there exists a group of ones of length m. A group of ones is a contiguous substring of 1s such that it cannot be extended in either direction. Return the latest step at which there exists a group of ones of length exactly m. If no such group exists, return -1. Example 1: Input: arr = [3,5,1,2,4], m = 1 Output: 4 Explanation: Step 1: "00100", groups: ["1"] Step 2: "00101", groups: ["1", "1"] Step 3: "10101", groups: ["1", "1", "1"] Step 4: "11101", groups: ["111", "1"] Step 5: "11111", groups: ["11111"] The latest step at which there exists a group of size 1 is step 4. Example 2: Input: arr = [3,1,5,4,2], m = 2 Output: -1 Explanation: Step 1: "00100", groups: ["1"] Step 2: "10100", groups: ["1", "1"] Step 3: "10101", groups: ["1", "1", "1"] Step 4: "10111", groups: ["1", "111"] Step 5: "11111", groups: ["11111"] No group of size 2 exists during any step. Example 3: Input: arr = [1], m = 1 Output: 1 Example 4: Input: arr = [2,1], m = 2 Output: 2 Constraints: n == arr.length 1 <= n <= 10^5 1 <= arr[i] <= n All integers in arr are distinct. 1 <= m <= arr.length ''' from typing import List class Solution: def findLatestStep(self, arr: List[int], m: int) -> int: A = arr if m == len(A): return m length = [0] * (len(A) + 2) res = -1 for i, a in enumerate(A): left, right = length[a - 1], length[a + 1] if left == m or right == m: res = i length[a - left] = length[a + right] = left + right + 1 return res if __name__ == "__main__": print(Solution().findLatestStep(arr = [3,5,1,2,4], m = 1))
f8e91d79531c94dd1c38e90a513aacc7af7a21f4
edutilos6666/PythonExamples
/NumberExample.py
1,885
3.96875
4
import math import random def example2(): 'random methods' print('random.random() = ', random.random()) print('random.randint(10, 1000) =', random.randint(10, 1000)) print('random.randrange(10, 1000) =', random.randrange(10, 1000)) print('random.randrange(10, 1000, 2) = ', random.randrange(10, 1000, 2)) print('random.randrange(10, 1000, 3) = ', random.randrange(10, 1000, 3)) numbers = [1, 2,3, 4, 5, 6, 7, 8, 9] names = ["foo", "bar", "bim", "pako", "edu"] print('numbers = ', numbers) print('names = ', names) print('random.choice(numbers) = ', random.choice(numbers)) print('random.choice(names) = ', random.choice(names)) print('random.uniform(10, 1000) = ', random.uniform(10, 1000)) random.shuffle(numbers) random.shuffle(names) print('numbers after shuffle = ', numbers) print('names after shuffle = ', names) print() def example1(): 'math methods' str = '100' n = int(str) f = float(str) print('int(str) = ',n) print('float(str) = ', f) print('math.pi = ', math.pi) print('math.e = ', math.e) print('math.sin(math.pi/3) = ', math.sin(math.pi/3)) print('math.cos(math.pi/3) = ', math.cos(math.pi/3)) print('math.tan(math.pi/3) = ', math.tan(math.pi/3)) print('math.asin(0.5) = ', math.asin(0.5)) print('math.acos(0.5) = ', math.acos(0.5)) print('math.atan(0.5) = ', math.atan(0.5)) print('math.ceil(0.6) = ', math.ceil(0.6)) print('math.floor(0.6) = ', math.floor(0.6)) print('math.fabs(-0.5) = ', math.fabs(-0.5)) print('math.factorial(10) = ', math.factorial(10)) print('math.log(64, 2) = ', math.log(64, 2)) print('math.log2(64) = ', math.log2(64)) print('math.log10(1000) = ', math.log10(1000)) print('math.log1p(e**4) = ', math.log1p(math.e**4)) print('math.pow(10, 3) = ', math.pow(10, 3)) print()
a08ace17e89a52ed82d2467cb7dea5823fac6923
RansomBroker/self-python
/Recursive/binarySearchTree.py
1,101
4.15625
4
class Node: #make constructor for insert data def __init__(self, key): self.left = None self.right = None self.value = key #insert item based on root def insertTree(self, root, node): if root is None: root = node else: #insert value to right if root.value < node.value: if root.right is None: root.right = node else: self.insertTree(root.right, node) if root.value > node.value: if root.left is None: root.left = node else: self.insertTree(root.left, node) # will print tree def tree(self, root): if root: self.tree(root.left) print(root.value) self.tree(root.right) root = Node(40) root.insertTree(root, Node(10)) root.insertTree(root, Node(15)) root.insertTree(root, Node(9)) root.insertTree(root, Node(6)) root.insertTree(root, Node(24)) root.insertTree(root, Node(32)) root.tree(root)
0bd84834e8d43615e9a21b3b7544af06ebb1983f
priscilasvn10/Python_Desafios
/Desafio081.py
568
3.984375
4
'''ler vários números e colocar na lista a) quantos números foram digitados b)ordem decrescente c)se o valor 5 foi digitado e está ou não na lista''' num = [] i = 0 while True: num.append(int(input('Digite um número: '))) c = str(input('Deseja continuar? [S/N] ')).upper().strip()[0] if c == 'N': break print('='*30) print(f'Foram digitados {len(num)} números.') num.sort(reverse=True) print(f'A ordem decrescente é: {num}') if 5 in num: print('O valor 5 foi digitado na lista.') else: print('O valor 5 não foi digitado na lista.')
d2c2746a4575cfbcadcc42469929b9e316a4b8f5
github-markdown-ui/github-markdown-ui
/test/helpers.py
414
3.828125
4
from re import sub def remove_whitespace(text: str) -> str: """Removes all whitespace from a string (including newline characters) after a > or before a <. This function allows us to write the expected HTML syntax outputs of the test cases in a more readable form, as long as we don't put whitespace around < or > characters within HTML tags. """ return sub(r'(?<=>)\s+|\s+(?=<)', '', text)
a1768e5e3122e215c586a96248f962d1713ca816
geislor/python-tdd-exercises
/count_num_vowels.py
233
3.984375
4
""" Exercise 4 """ VOWELS = ['a', 'e', 'i', 'o', 'u', 'y'] def count_num_vowels(s): """ Returns the number of vowels in a string s. whit listcomprehension """ return len([i for i in s if i.lower() in VOWELS ])
1cd259421166313dd885b7ec7c09362b2a5e0c5b
qmnguyenw/python_py4e
/geeksforgeeks/python/python_all/121_14.py
3,246
4.25
4
Python | Group and count similar records Sometimes, while working with records, we can have a problem in which we need to collect and maintain the counter value inside records. This kind of application is important in web development domain. Let’s discuss certain ways in which this task can be performed. **Method #1 : Using loop +Counter() + set()** The combination of above functionalities can be employed to achieve this task. In this, we run a loop to capture each tuple and add to set and check if it’s already existing, then increase and add a counter value to it. The cumulative count is achieved by using Counter(). __ __ __ __ __ __ __ # Python3 code to demonstrate working of # Group and count similar records # using Counter() + loop + set() from collections import Counter # initialize list test_list = [('gfg', ), ('is', ), ('best', ), ('gfg', ), ('is', ), ('for', ), ('geeks', )] # printing original list print("The original list : " + str(test_list)) # Group and count similar records # using Counter() + loop + set() res = [] temp = set() counter = Counter(test_list) for sub in test_list: if sub not in temp: res.append((counter[sub], ) + sub) temp.add(sub) # printing result print("Grouped and counted list is : " + str(res)) --- __ __ **Output :** > The original list : [(‘gfg’, ), (‘is’, ), (‘best’, ), (‘gfg’, ), (‘is’, ), > (‘for’, ), (‘geeks’, )] > Grouped and counted list is : [(2, ‘gfg’), (2, ‘is’), (1, ‘best’), (1, > ‘for’), (1, ‘geeks’)] **Method #2 : UsingCounter() + list comprehension + items()** This is one liner approach and recommended to use for programming. The task of loops is handled by list comprehension and items() is used to access all the elements of Counter converted dictionary to allow computations. __ __ __ __ __ __ __ # Python3 code to demonstrate working of # Group and count similar records # using Counter() + list comprehension + items() from collections import Counter # initialize list test_list = [('gfg', ), ('is', ), ('best', ), ('gfg', ), ('is', ), ('for', ), ('geeks', )] # printing original list print("The original list : " + str(test_list)) # Group and count similar records # using Counter() + list comprehension + items() res = [(counter, ) + ele for ele, counter in Counter(test_list).items()] # printing result print("Grouped and counted list is : " + str(res)) --- __ __ **Output :** > The original list : [(‘gfg’, ), (‘is’, ), (‘best’, ), (‘gfg’, ), (‘is’, ), > (‘for’, ), (‘geeks’, )] > Grouped and counted list is : [(2, ‘gfg’), (2, ‘is’), (1, ‘best’), (1, > ‘for’), (1, ‘geeks’)] Attention geek! Strengthen your foundations with the **Python Programming Foundation** Course and learn the basics. To begin with, your interview preparations Enhance your Data Structures concepts with the **Python DS** Course. My Personal Notes _arrow_drop_up_ Save
4c8b05377b1b43858fc1cdc43c2828636fd21f4e
Praneta-Paithankar/CSCI-B505-Applied-Algorithm
/Assignment 1/Sorting.py
6,066
4.1875
4
import time,FileOperations #Sort numbers using bubble sort def bubble_sort(numbers): for i in xrange(0, len(numbers)-1): for j in xrange(len(numbers)-1, i, -1): if numbers[j] < numbers[j-1]: numbers[j], numbers[j-1] = numbers[j-1], numbers[j] return numbers #sort numbers using insertion sort def insertion_sort(numbers): for j in xrange(1,len(numbers)-1): key = numbers[j] i = j-1 while i >= 0 and numbers[i]>key: numbers[i+1] = numbers[i] i=i-1 numbers[i+1] = key return numbers #get input def get_input(file_name): input_list = [] with open(file_name) as f: for line in f: numbers = map(int, line[1:-2].split(",")) input_list.append(numbers) return input_list #Read data from file and use bubble sort for sorting random numbers def run_bubblesort(): with open("Output/bubblesortOutput.csv", "w") as csvfile: #f.write("Number of input : average time \n") for x in xrange(400, 10000, 400): print "No of inputs:{0}\n".format(x) time_list=[] file_name = "Input/{0}random.txt".format(x) input = get_input(file_name) for numbers in input: start_time = time.time() sorted_numbers= bubble_sort(numbers) end_time=time.time() time_list.append(end_time-start_time) #print sorted_numbers print time_list avg_time=sum(time_list)/len(time_list) print avg_time csvfile.write("{0},{1}\n".format(x, avg_time)) return #Read data from file and use insertion sort for sorting random numbers def run_insertionsort(): with open("Output/insertionsortOutput.csv", "w") as f: #f.write("Number of input :average time\n") for x in xrange(400, 10000, 400): print "No of inputs:{0}\n".format(x) time_list=[] file_name = "Input/{0}random.txt".format(x) input = get_input(file_name) for numbers in input: start_time = time.time() sorted_numbers= insertion_sort(numbers) end_time=time.time() time_list.append(end_time-start_time) #print sorted_numbers print time_list avg_time = sum(time_list) / len(time_list) print avg_time f.write("{0},{1}\n".format(x, avg_time)) #Read data from file and use bubble sort for sorting non-decreasing random numbers def run_non_decreasing_bubblesort(): with open("Output/NonDecreasingBubbleSort.csv","w") as f: #f.write("Number of input : time\n") for x in xrange(400, 10000, 400): print "No of inputs:{0}\n".format(x) file_name = "Input/{0}nondecreasing.txt".format(x) input = get_input(file_name) numbers= input[0] start_time = time.time() sorted_numbers = bubble_sort(numbers) end_time = time.time() runtime = end_time - start_time #print sorted_numbers print runtime f.write("{0},{1}\n".format(x, runtime)) return #Read data from file and use bubble sort for sorting non-increasing random numbers def run_non_increasing_bubblesort(): with open("Output/NonIncreasingBubbleSort.csv","w") as f: #f.write("Number of input : time \n ") for x in xrange(400, 10000, 400): print "No of inputs:{0}\n".format(x) file_name = "Input/{0}nonincreasing.txt".format(x) input = get_input(file_name) numbers = input[0] start_time = time.time() sorted_numbers = bubble_sort(numbers) end_time = time.time() runtime = end_time - start_time #print sorted_numbers print runtime f.write("{0},{1}\n".format(x, runtime)) return #Read data from file and use insertion sort for sorting non-decreasing random numbers def run_non_decreasing_insertionsort(): with open("Output/NonDecreasingInsertionSort.csv", "w") as f: #f.write("Number of input : time\n") for x in xrange(400, 10000, 400): print "No of inputs:{0}\n".format(x) file_name = "Input/{0}nondecreasing.txt".format(x) input = get_input(file_name) numbers = input[0] start_time = time.time() sorted_numbers = insertion_sort(numbers) end_time = time.time() runtime = end_time - start_time #print sorted_numbers print runtime f.write("{0},{1}\n".format(x, runtime)) return #Read data from file and use insertion sort for sorting non-increasing random numbers def run_non_increasing_insertionsort(): with open("Output/NonIncreasingInsertionSort.csv", "w") as f: #f.write("Number of input :time \n") for x in xrange(400, 10000, 400): print "No of inputs:{0}\n".format(x) file_name = "Input/{0}nonincreasing.txt".format(x) input = get_input(file_name) numbers = input[0] start_time = time.time() sorted_numbers = insertion_sort(numbers) end_time = time.time() runtime = end_time - start_time #print sorted_numbers print runtime f.write("{0},{1}\n".format(x, runtime)) return def main(): FileOperations.create_folder("Output") print "random bubble sort" run_bubblesort() print "random insertion sort" run_insertionsort() print "non-decreasing bubble sort" run_non_decreasing_bubblesort() print "non-increasing insertion sort" run_non_decreasing_insertionsort() print "non-decreasing bubble sort" run_non_increasing_bubblesort() print "non-increasing insertion sort" run_non_increasing_insertionsort() print "Operations completed" if __name__ == '__main__': main()
d71625a6eff62580a14c614696ac4b2b2a0f9836
Deiv101/functions_tutorial
/functions_tutorial.py
7,807
3.84375
4
# Creating a function def my_function(): print("Hello from a function") # Calling a Function my_function() #################################################################################################################################################################### # Arguments def my_function(fname): print(fname + " Rakojoana") my_function("David") my_function("Lilly") my_function("Amo") #################################################################################################################################################################### # Number of Parameters def my_function(fname, lname): print(fname + " " + lname) my_function("Deiv", "Rakojoana") #################################################################################################################################################################### # Arbitrary Arguments, *args """ If you do not know how many arguments that will be passed into your function, add a * before the parameter name in the function definition. This way the function will receive a tuple of arguments, and can access the items accordingly: """ def my_function(*cities): print("The capital city is " + cities[2]) my_function("Mafeteng", "Mohale's Hoek", "Maseru", "Quthing", "Mokhotlong", "Thaba-Tseka", "Berea", "Qacha's Nek", "Leribe") #################################################################################################################################################################### # Keyword Arguments """You can also send arguments with the key = value syntax. This way the order of the arguments does not matter.""" def my_function(city3, city2, city1): print("The 3rd city is " + city3) my_function(city1="Mafeteng", city2="Berea", city3="Maseru") #################################################################################################################################################################### # Passing a list as an argument def my_function(food): for x in food: print(x) fruits = ["apple", "banana", "cherry"] my_function(fruits) #################################################################################################################################################################### # Return values def my_function(x): return 5 * x print(my_function(10000)) print(my_function(4)) print("\t", my_function("Deiv")) #################################################################################################################################################################### # Recursion def tri_recursion(k): if k > 0: result = k + tri_recursion(k - 1) print(result) else: result = 0 return result print("\n\nRecursion Example Results") tri_recursion(6) #################################################################################################################################################################### def greet(name): """ This function greets to the person passed in as a parameter """ print("Hello, " + name + ". Good morning") greet("Amo") #################################################################################################################################################################### # Example of return def abs_value(num): """This function returns the absolute value of the entered number""" if num >= 0: return num else: return -num print(abs_value(-5)); print(abs_value(3)) ########################################################################################################################### print("\t") def greet(name, msg): """This function greets the person with the provided message""" print("Hello" + name + ", " + msg) greet("Amo", "Top of the morning to you!") ########################################################################################################################### # Default arguments def greet(name, msg = "Good morning!"): """This function greets the person with the provided message""" """If the message is not provided, it defaults to 'Good morning!'""" print("Hello, ", name,'' + msg) greet("Amo,") greet("Amo,", "How are you this morning?") ########################################################################################################################### print("\n") # Recursive function def factorial(x): """This is a recursive function to find the factorial of an integer""" if x == 1: return 1 else: return (x * factorial(x-1)) num = 7 print("The factorial of num", num, "is", factorial(num)) ########################################################################################################################### print("\n") def calc(num1, num2): add = num1 + num2 print("The Sum of ", num1, "&", num2, "is", add) calc(2, 4) ########################################################################################################################### print("\n") def func(a, b, c): lis = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] if num in lis: print("The fifth number is", lis[5]) else: return num func(2, 4, 6) ########################################################################################################################### print("\n") def iter(a): x = int(input("Enter a number: ")) while x <= 0: print("The number you entered is: ", x) break else: return x iter(2) ########################################################################################################################### print("\n") def lumelisa(name): print("Lumela " + name) lumelisa("Amo") #################################################################################################################################################################### 18/11/2021 def square(number): """Calculate the square of number.""" return number ** 2 square(5) #################################################################################################################################################################### def maximum(a, b, c): """Return the maximum of three values.""" max_value = a if b > max_value: max_value = b if c > max_value: max_value = c return max_value #################################################################################################################################################################### def func(a): num = int(input("Enter a number: ")) if num != 0: print("You entered a number that's not a zero") else: print("You hit a zero") return num func(1) #################################################################################################################################################################### def factorial(number): """Return factorial of a number.""" if number <= 1: return 1 return number * factorial(number - 1) # recursive call for i in range(11): print(f'{i}! = {factorial(i)}') #################################################################################################################################################################### # Lists and Tuples a_list = [] for number in range(1, 6): a_list +=[number] #################################################################################################################################################################### numbers = [3, 7, 1, 4, 2, 8, 5, 6] key = 1000 if key in numbers: print(f'found {key} at index {numbers.index(search_key)}') else: print(f'{key} not found') ####################################################################################################################################################################
8e72fb71eeaec9570b6721e89afeb3c783af2aac
GiovanniCassani/discriminative_learning
/nonwords/neighbors.py
6,763
3.515625
4
__author__ = 'GCassani' import helpers as help from collections import defaultdict, Counter def map_neighbours_to_pos(neighbours_file, wordform2pos, ids2words): """ :param neighbours_file: the file with the neighbours retrieved for each test item: each item is on a different column, with neighbours retrieved for it in the same column :param wordform2pos: a dictionary mapping wordforms to the set of pos tags with which the wordform was found in the input corpus :param ids2words: a dictionary mapping column indices to test items :return neighbours: a dictionary mapping each test item to the list of pos tags of the words retrieved as neighbours. in case a neighbour is ambiguous with respect to the category, all categories with which it was retrieved are considered """ neighbours = defaultdict(list) with open(neighbours_file, "r") as f: for line in f: words = line.strip().split('\t') for col_id, word in enumerate(words): if not word in ids2words.values(): if ':' in word: neighbours[ids2words[col_id]].append(word.split(':')[1]) else: target_tags = wordform2pos[word] for tag in target_tags: neighbours[ids2words[col_id]].append(tag) return neighbours ######################################################################################################################## def get_tag_distribution(neighbours): """ :param neighbours: a dictionary mapping words to the list of pos tags of the neighbors :return neighbours_distr: a dictionary mapping each test word to each category which appears in the neighborhood and its frequency of occurrence :return pos_set: a set containing the unique pos tags found in the neighbours list """ neighbours_distr = defaultdict(dict) pos_set = set() for word in neighbours: neighbours_list = neighbours[word] distr = Counter(neighbours_list) for pos in distr: neighbours_distr[word][pos] = distr[pos] pos_set.add(pos) return neighbours_distr, pos_set ######################################################################################################################## def write_neighbor_summary(output_file, neighbours_distr, pos_set, table_format="long", cond="minimalist"): """ :param output_file: the path where the summary will be written to :param neighbours_distr: a dictionary mapping words to the pos tags of its neighboring vectors and their frequency count in the neighbor list :param pos_set: an iterable of strings, indicating the pos tags encountered across the neighbors :param cond: a string indicating the input used for the experiment :param table_format: a string indicating how to print data to table, either 'long' or 'wide'. In the long format, five columns are created, first the nonword followed by its intended pos tag, then the condition, then the category, then the frequency. In the wide format, each category is a different column, with each nonword-category cell indicating how many neighbors tagged with the category were found in the neighborhood of the nonword. An extra column indicates the condition. """ pos_tags = sorted(pos_set) with open(output_file, "w") as f: if table_format == "wide": f.write("\t".join(["Nonword", "Target", "Condition", "\t".join(pos_tags)])) f.write('\n') for word in neighbours_distr: baseform, target = word.split("|") counts = [] for tag in pos_tags: try: counts.append(str(neighbours_distr[word][tag])) except KeyError: counts.append("0") f.write('\t'.join([baseform, target, cond, '\t'.join(counts)])) f.write('\n') elif table_format == "long": f.write("\t".join(["Nonword", "Target", "Condition", "Category", "Count"])) f.write('\n') for word in neighbours_distr: baseform, target = word.split("|") for tag in pos_tags: try: f.write('\t'.join([baseform, target, cond, tag, str(neighbours_distr[word][tag])])) except KeyError: f.write('\t'.join([baseform, target, cond, tag, '0'])) f.write('\n') else: raise ValueError("unrecognized format %s!" % table_format) ######################################################################################################################## def nn_analysis(neighbours_file, tokens_file, output_file, cond="minimalist", table_format="long"): """ :param neighbours_file: the path to the file containing neighbours for the target words :param tokens_file: the path to the file containing summary information about tokens, lemmas, pos tags, and triphones :param output_file: the path where the summary will be written to :param cond: a string indicating the input used for the experiment :param table_format: a string indicating how to print data to table, either 'long' or 'wide'. In the long format, five columns are created, first the nonword followed by its intended pos tag, then the condition, then the category, then the frequency. In the wide format, each category is a different column, with each nonword-category cell indicating how many neighbors tagged with the category were found in the neighborhood of the nonword. An extra column indicates the condition. """ ids2words = help.map_indices_to_test_words(neighbours_file) words2pos = help.map_words_to_pos(tokens_file) neighbors2pos = map_neighbours_to_pos(neighbours_file, words2pos, ids2words) neighbors_distr, pos_set = get_tag_distribution(neighbors2pos) write_neighbor_summary(output_file, neighbors_distr, pos_set, cond=cond, table_format=table_format)
95a5575a9d0d210d3b7be2c99aeb587c9f0a2c40
aowenb/Purwadhika-Excercise
/soal 5.py
521
3.640625
4
x = input('masukkan sebuah kalimat : ') print('kalimat original : ',x) def counter(x): up = [] low = [] for i in x[::1]: if i.isupper() == True: up.append(i) else: low.append(i) for i in low: if i == ' ': low.remove(' ') return len(up), len(low) # 0 adalah Kapital dan 1 adalah non kapital print('banyaknya Jumlah Huruf Kapital Di Kalimat adalah ', counter(x)[0]) print('banyaknya Jumlah Huruf Kapital Di Kalimat adalah ', counter(x)[1])
753aa4778234c296d70b2cfc2b01673aa93f58b5
parolaraul/itChallengeML2017
/Peru - Buscando Numeros - 60 pts/peru.py
806
3.796875
4
# Peru pi = open('pi', 'r').read() def is_prime(n): if n == 2 or n == 3: return True if n < 2 or n%2 == 0: return False if n < 9: return True if n%3 == 0: return False r = int(n**0.5) f = 5 while f <= r: if n%f == 0: return False if n%(f+2) == 0: return False f +=6 return True #number as string def is_Capicua(given_str): if (len(given_str) % 2 == 0): a,b = given_str[:len(given_str)/2], given_str[len(given_str)/2:][::-1] else: a,b = given_str[:(len(given_str)-1)/2], given_str[(len(given_str)+1)/2:][::-1] return a==b counter = 0 for i in range(0,len(pi)): numero = pi[i]+pi[i+1]+pi[i+2]+pi[i+3]+pi[i+4]+pi[i+5]+pi[i+6] if is_prime(int(numero)) and is_Capicua(numero): counter+=1 print numero if counter == 7: print numero,i break
8b47a892df850416f780588f2791e63fd00f3d32
LachubCz/VUT-FIT-MIT
/6_semestr/DIP/src/pero/src/arabic_helper.py
572
3.609375
4
import arabic_reshaper import re def normalize_text(text): text = reverse_transcription(text) text = arabic_reshaper.reshape(text) text = reverse_transcription(text) return text def reverse_transcription(transcription): transcription = transcription[::-1] number_patter = r"[0-9]+" matches = re.findall(number_patter, transcription) if matches: for match in matches: i = transcription.index(match) transcription = transcription[:i] + match[::-1] + transcription[i+len(match):] return transcription
af18dd3717966e3b12ca843ec77ce44b9472110e
Rifat951/PythonExercises
/Lists/exercises.py
3,331
4.53125
5
# 3-4. Guest List: If you could invite anyone, living or deceased, to dinner, who # would you invite? Make a list that includes at least three people you’d like to # invite to dinner. Then use your list to print a message to each person, inviting # them to dinner print("\n\n##########################################") guest = [] guest.append('rafi') guest.append('pafi') guest.append('tafi') for x in guest: print("{} is invited ".format(x)) # 3-5. Changing Guest List: You just heard that one of your guests can’t make the # dinner, so you need to send out a new set of invitations. You’ll have to think of # someone else to invite. # • Start with your program from Exercise 3-4. Add a print statement at the # end of your program stating the name of the guest who can’t make it. # • Modify your list, replacing the name of the guest who can’t make it with # the name of the new person you are inviting. # • Print a second set of invitation messages, one for each person who is still # in your list. print("\n\n##########################################") a=guest.pop() # pop needs to be integer print("{} cannot come".format(a)) print('\nAdd new Guest') guest.insert(2,'new_guest') for x in guest: print("{} is invited ".format(x)) # 3-6. More Guests: You just found a bigger dinner table, so now more space is # available. Think of three more guests to invite to dinner. # • Start with your program from Exercise 3-4 or Exercise 3-5. Add a print # statement to the end of your program informing people that you found a # bigger dinner table. # • Use insert() to add one new guest to the beginning of your list. # • Use insert() to add one new guest to the middle of your list. # • Use append() to add one new guest to the end of your list. # • Print a new set of invitation messages, one for each person in your list. print("\n\n##########################################") guest.insert(0,'rifat') guest.insert(2,'sifat') guest.insert(5,'tifat') print(guest) # 3-7. Shrinking Guest List: You just found out that your new dinner table won’t # arrive in time for the dinner, and you have space for only two guests. # • Start with your program from Exercise 3-6. Add a new line that prints a # message saying that you can invite only two people for dinner. # • Use pop() to remove guests from your list one at a time until only two # names remain in your list. Each time you pop a name from your list, print # a message to that person letting them know you’re sorry you can’t invite # them to dinner. # • Print a message to each of the two people still on your list, letting them # know they’re still invited. # • Use del to remove the last two names from your list, so you have an empty # list. Print your list to make sure you actually have an empty list at the end # of your program. print("\n\n##########################################") for x in range(len(guest)): if x ==4: break else: print("{} they cannot come ".format(guest.pop())) print("\n\n{} are Remaining and Invited for dinner".format(guest)) # for x in range(len(guest)): # del x # # print("{} list".x) # print(guest) del guest[0] print(guest) del guest[0] print(guest)
7b6dc37fb7010ad5636b9abafa56503ca1312f6e
opensourcex123/Data_Analysis
/demo1 pyplot的中文显示.py
309
3.625
4
# 作者:宁方笑 # 开发时间:2021/5/27 21:38 import numpy as np import matplotlib.pyplot as plt a=np.arange(0.0,5.0,0.02) plt.xlabel('横轴:时间',fontproperties='kaiti',fontsize=20) plt.ylabel('纵轴:振幅',fontproperties='kaiti',fontsize=20) plt.plot(a,np.cos(2*np.pi*a),'r--') plt.show()
fd0ab39f0ab8d3065121cf5dfa9b65b83fc36bf9
curieux/ProgMathSci
/matrix.py
5,940
4.125
4
#!/usr/bin/env python """ A sample python module for working with matrices. Abraham D. Smith """ import numbers class Matrix: def __init__(self, listOfLists): """ Construct a Matrix object from a list-of-lists, packed by row. Some minimal sanity checks are in place. """ if not isinstance(listOfLists,list): raise ValueError("listOfLists must be a list of lists") if not all([ isinstance(row,list) for row in listOfLists]): raise ValueError("listOfLists must be a list of lists") nRows = len(listOfLists) nCols = len(listOfLists[0]) if not all( [ len(row) == nCols for row in listOfLists ] ): raise ValueError("List-of-lists has mismatched rows, so it cannot be a Matrix.") if not all( [ all([ isinstance(elem,numbers.Number) for elem in row ]) for row in listOfLists ]): raise(ValueError("A Matrix must contain Numbers")) ## give ourselves some attributes. self._nRows=nRows self._nCols=nCols self._dict = dict() for i in range(self._nRows): for j in range(self._nCols): self._dict[(i,j)]=listOfLists[i][j] def __getitem__(self,key): rowKey,colKey=key """ Get row or element """ if not (rowKey,colKey) in self: raise IndexError("Row or Column out of range for a {r} by {c} Matrix".format(r=self._nRows,c=self._nCols)) return self._dict[(rowKey,colKey)] def __setitem__(self,key,value): rowKey,colKey=key if not (rowKey,colKey) in self: raise IndexError("Row or Column out of range for a {r} by {c} Matrix".format(r=self._nRows,c=self._nCols)) if not isinstance(value,numbers.Number): raise ValueError("Matrix entry must be a Number") self._dict[(rowKey,colKey)]=value def __iter__(self): return ( keypair for keypair in sorted(self._dict) ) def __contains__(self,(rowKey,colKey)): return (rowKey,colKey) in self._dict.keys() def dimension(self): """ compute the dimension of a Matrix, with minimal error correction. To us, matrices are lists-of-lists, packed row-by-row """ return (self._nRows,self._nCols) ## note, this is a tuple def __add__(self,other): """ compute the element-by-element sum of two matrices. """ if not other.dimension() == self.dimension(): raise ValueError("Cannot add matrices of different dimensions.") nRows,nCols=self.dimension() newMatrix=Matrix( [ [0]*nCols ]*nRows ) for i,j in newMatrix: newMatrix[i,j] = self[i,j] + other[i,j] return newMatrix def __rmul__(self,num): """ scalar multplication of a matrix """ nRows,nCols=self.dimension() newMatrix=Matrix( [ [0]*nCols ]*nRows ) for i,j in newMatrix: newMatrix[i,j] = num*self[i,j] return newMatrix def __equals__(self,other): if not other.dimension() == self.dimension(): return False return all( [ self[i,j] == other[i,j] for (i,j) in self ]) def __mul__(self, other): """ compute the matrix product """ nRows,nInner=self.dimension() nInnerB,nCols=other.dimension() if not nInner == nInnerB: raise ValueError("Dimension mismatch for matrix multiplication.") newMatrix=Matrix( [ [0]*nCols ]*nRows ) for i,j in newMatrix: products=[self[i,k]*other[k,j] for k in range(nInner)] newMatrix[i,j] = sum(products) return newMatrix def transpose(self): """ construct the transpose of a matrix. This could be cleverer. """ nCols,nRows=self.dimension() ## SWAPPED! newMatrix=Matrix( [ [0]*nCols ]*nRows ) for i,j in newMatrix: newMatrix[i,j] = self[j,i] return newMatrix def __pow__(self,num): """ scalar multplication of a matrix """ nRows,nCols=self.dimension() if not nRows==nCols: raise ValueError("Cannot take a power of a non-square matrix.") if not type(num) == int and num >= 1: raise ValueError("Can only take positive integer powers.") if num==1: return self #print "... descending to {nn}".format(nn=num-1) return self.__pow__(num-1)*self def __str__(self): """ pretty-print the matrix """ nRows,nCols=self.dimension() string="" for i in range(nRows): string+="|" for j in range(nCols): string+="\t{}\t".format(self[i,j]) string+="|\n" string+="\n" return string if __name__ == "__main__": # This is called if we run as "./test.py" print "Running example tests for Matrix class." A = Matrix([[ 12, 45, 167], [3, 6, 2]]) try: A1= Matrix("abcdef") A2= Matrix( [["a", "b", "c"], ["d", "e", "f"]] ) A3= Matrix( [["a", "b", "c"], ["d", "e"]] ) except Exception as e: print e pass B=Matrix([[ 4, 3, 1], [6, 7, 3] ]) C=Matrix([[ 1, 2, 3, 4], [9, 2, 2, 1], [ 5, 4, 3, 2]]) D=Matrix([[ 1,0],[0,2]]) print A.dimension() print "A" print A print "B" print B print "A+B" print A+B #print add_matrix(A1,B1) ## I find this hillarious,too #print add_matrix(A2,B2) ## I find this hillarious #print mult_matrix(A,B) ## throws exception #print mult_matrix(A,C) #print mult_matrix(A2,C) ## throws exception print "3A" print 3*A print "At" print A.transpose() print "C" print C print "AC" print A*C #print_matrix(transpose(A)) print "D" print D print "D**10" print D**10
01f6cf366b6bda4a6f30d97aa2988b9ee21f284e
david-luk4s/sock
/Sock.py
951
3.703125
4
from turtle import Screen, Turtle, mainloop def main(): space = Screen() space.setup(450, 450), space.title('Sock') space.bgcolor('green') pen = Turtle(shape='circle') pen.shapesize(0.3), pen.width(5) create_sock(pen) pen.ht() def create_sock(pen): pen.color('black', 'red'), pen.speed(9) pen.seth(90) pen.pu(), pen.goto(100, -100), pen.pd() pen.begin_fill() pen.fd(140), pen.circle(20, 60), pen.fd(140) pen.circle(20, 90), pen.fd(70), pen.circle(20, 90) pen.fd(70), pen.circle(-20, 60), pen.fd(79.74) pen.circle(50, 90), pen.fd(15.62), pen.circle(50, 90) pen.end_fill() pen.color('black', 'white'), pen.speed(9) pen.seth(60) pen.pu(), pen.goto(3.40, 107.32), pen.pd() pen.begin_fill() for i in range(2): pen.circle(20, 90), pen.fd(50) pen.circle(20, 90), pen.fd(110) pen.end_fill() if __name__ == "__main__": main() mainloop()
c0211a75f578b1abe7b728a92778887eaa691b3f
daniel-reich/turbo-robot
/ZdnwC3PsXPQTdTiKf_17.py
653
4.34375
4
""" Create a function that takes two numbers and a mathematical operator `+ - / *` and will perform a calculation with the given numbers. ### Examples calculator(2, "+", 2) ➞ 4 calculator(2, "*", 2) ➞ 4 calculator(4, "/", 2) ➞ 2 ### Notes If the input tries to divide by 0, return: `"Can't divide by 0!"` """ def calculator(num_1: int, operator: str, num_2: int) -> int: if num_2 == 0 and operator == "/": return"Can't divide by 0!" funcs = { "+": int.__add__, "-": int.__sub__, "*": int.__mul__, "/": int.__floordiv__ } return funcs[operator](num_1, num_2)
139dd916ecf9a6189f5febc55171bf4fcb5452b1
hwankyusong/Prime_Factorizer
/prime_factorizer_v2.py
328
3.53125
4
#returns prime factorization in list form #fixed emptying list issue from math import * L=[] def prime(n): if len(L) != 0: del L[:] return helper(n) return helper(n) def helper(n): for i in range(2,round(sqrt(n))+1): if n % i == 0: L.append(i) return helper(n/i) L.append(n) return L
735097a9a3df21715ca85f19a381d29b3840c887
kyoz/learn
/languages/python/1.learn_py_the_hard_way/ex15.py
251
3.71875
4
from sys import argv script, filename = argv txt = open(filename) print(f"Here's your file {filename} content:") print(txt.read()) print("Type the filename again:") new_file_name = input("> ") new_txt = open(new_file_name) print(new_txt.read())
fd101c8e4759db09b4434d728a23870f0d24bc6a
Rohan07Singh/264789_Daily_Commit
/Word_check.py
249
4.09375
4
def is_word_present(sentence, word): s=sentence.split(" ") for i in s: if(i==word): print("True") print("False") s=input("Enter a sentence") word=input("Enter the word to be searched") is_word_present(s,word)
4941aeb787364f333c38e187ef47f60caa619cbd
Worcester-Preparatory-School-Comp-Sci/python-1-FrankTheTank87
/Great Lakes .py
480
4.125
4
#Frank Carter, 9-16-19 water = float(input("How many milliliters of water are in the Great Lakes? ")) usa = float(input("What is the surface area in centimeters of the 48 contiguous US states? ")) def depth(x): x = water/usa return(x) print("If all the water in the Great Lakes covered the USA, the water would be ",depth(water)," centimeters deep.") #typically, you would not want your user research and put in these values which are generally constant # good work otherwise
90a86804d1f7eec8c3af0eda8be0703d517f1ab4
AnotherContinent/thinkful
/FizzBuzz.py
368
4.0625
4
import sys num_input = raw_input("Please enter a number: ") try: num_input = int(num_input) except ValueError: print("That is not a valid integer.") else: for n in range(1,num_input): if n % 5 == 0 and n % 3 == 0: print("FizzBuzz") elif n % 5 == 0: print("Buzz") elif n % 3 == 0: print("Fizz") else: print(n)
c2676db89b7aa05a499bf1b0af4db1b39a934651
jvfiel/pythonbasic1
/level2_list.py
407
3.984375
4
#LISTS bags = ['Hand Bag','Shoulder Bag'] print(bags) print("---------------------") for bag in (bags): print(bag) print("--------------------") #Looping through the list and enumerate for i,bag in enumerate(bags): print(i, bag) #In principle index always starts at 0 print("--------------------") #split by comma to list/array bags = 'Hand Bag,Shoulder Bag' bags = bags.split(',') print(bags)
73f670325e65f119cb956b2f8a51ec64ee788f95
kyungtae92/python-basic
/day1015/function14.py
722
3.890625
4
# 원의 넓이 : 반지름 * 반지름 * 3.14 # 원의 둘레 : 원의 넓이 * 높이 def circleArea(radius): print('radius: ', id(radius)) area = radius * radius * 3.14 return area def circleVolume(radius, height): vol = circleArea(radius) * height return vol def printCircle(area, vol, radius): print('반지름 %d인 원의 넓이 %.2f !' % (radius, area)) print('반지름 %d인 원의 둘레 %.2f !' % (radius, vol)) def main(): radius = int(input('반지름 : ')) height = int(input('원의 높이 : ')) area = circleArea(radius) vol = circleVolume(radius, height) printCircle(area, vol ,radius) print('radius: ', id(radius)) main()
3d601056471a4541d63b99266c8b698207489e49
hakan7822/Projet3Macgyver
/class_Square.py
1,219
3.890625
4
import pygame from pygame.locals import * from class_Coordinates import * from class_Item import * class Square: """ Description. A class that will define the squares of the laby. """ def __init__(self, coord, is_wall): """Use Coordinates and is_Wall boolean as arguments. Starts with no item on it.""" self.is_wall = is_wall self.coord = coord self.has_item = False self.item = Item(None, 'ressource/empty.png') def get_is_wall(self): """Return a boolean to know if the square is a wall.""" return self.is_wall def get_has_item(self): """Return a boolean to know if there's an item on the square.""" return self.has_item def set_has_item(self, state): """Set the state of the has_item boolean.""" self.has_item = state def get_coord(self): """Return the square's position as a Coordinate type object.""" return self.coord def set_item(self, item): """Change the Item attribute of the square. Uses an Item type object.""" self.item = item def get_item(self): """Return the item on the square.""" return self.item
cca8e76be7a8651b3dfe346d7975d0900d8af01a
gitForKrish/PythonInPractice
/PythonCrashCourse/Theories/p07_Functions.py
1,696
3.78125
4
def greet_user(): """ Message for greeting """ print('hello') greet_user() def greet_user(name): """ Message for greeting """ print(f'hello, {name.title()}') greet_user('jack') # greet_user() # TypeError: greet_user() missing 1 required positional argument: 'name' def describe_animal(animal_type, pet_name): ''' Method will describe an animal ''' print(f"I have a {animal_type.title()}") print(f"My {animal_type.title()} name is {pet_name.title()}") # Positional Arguments describe_animal('dog', 'jack') # Keywords Arguments describe_animal(animal_type='cat', pet_name='buli') describe_animal(pet_name='tommy', animal_type='dog') # default value def describe_animal(pet_name, animal_type = 'dog'): ''' Method with default arguments ''' print(f"I have a {animal_type.title()}") print(f"My {animal_type.title()} name is {pet_name.title()}") describe_animal('kalu') describe_animal('supert', 'tiger') describe_animal(animal_type='cat',pet_name='lione') # Function returning value def get_formatted_name(first_name, last_name): ''' Get Formatted Name ''' return f"{first_name.title()} {last_name.title()}" my_name = get_formatted_name('krishnendu', 'mandal') print(my_name) def get_formatted_name(first_name, last_name, middle_name=''): ''' Get Formatted Name ''' full_name = '' if middle_name: full_name = f"{first_name.title()} {middle_name.title()} {last_name.title()}" else: full_name = f"{first_name.title()} {last_name.title()}" return full_name my_name = get_formatted_name('krishnendu', 'mandal') print(my_name) father_name = get_formatted_name('tarun','mondal','kumar') print(father_name)
2e9e54bdf97bbd79c74085a86a401ebe65936270
ebbitten/ScratchEtc
/Challenges/ZombitPath v 2.1a.py
2,337
3.609375
4
import operator def answer(food,grid): #initialize the input that we'll get all of the permutations of paths from N=len(grid) #if N>=20: # return -1 bestFood=201 directions=[[0,1,0],[0,0,1]] growingBranch=[[food,0,0]] #paths that need to have branches added found=False while not found: branch=findNextBranch(growingBranch) if atEnd(branch,N): if branch[0]<bestFood: bestFood=branch[0] else: spawnBranch(branch,directions,growingBranch,grid,N) #liveBranch=list(growingBranch) #growingBranch=[] growingBranch.remove(branch) found=checkIfDone(growingBranch,bestFood) if bestFood==201: bestFood=-1 return bestFood def spawnBranch(branch,directions,growingBranch,grid,N): #figure out a way to create new growingBranches from the current live branch for move in directions: #check for both edge of grid, as well as foodLeft attmptMove=[branch[0]+move[0],branch[1]+move[1],branch[2]+move[2]] #try evaluating all on one line and just have food at end to avoid indexError if attmptMove[1]<N and attmptMove[2]<N: attmptMove[0]=attmptMove[0]-grid[attmptMove[1]][attmptMove[2]] if attmptMove[0]>=0: growingBranch.append(attmptMove) def atEnd(branch,N): #check to see if a branch is at the end of the grid if (branch[1]!=(N-1) or branch[2]!=(N-1)): return False else: return True def checkIfDone(liveBranch,bestFood): if not liveBranch: found=True elif bestFood==0: found=True else: found=False return found def findNextBranch(growingBranch): #lets start by just trying to find branches with the least food left return min(growingBranch) grid=[[0, 8, 6, 8, 7, 8, 7], [10, 2, 8, 3, 3, 2, 8], [2, 9, 1, 6, 9, 9, 2], [3, 8, 10, 2, 7, 8, 1], [4, 4, 9, 7, 6, 10, 8], [6, 10, 7, 8, 6, 1, 1], [10, 1, 3, 2, 9, 2, 5]] food=150 import random def genGrid(N): grid=[] for i in range(N): rowval=[] for j in range(N): cellval=random.randint(1,10) rowval.append(cellval) grid.append(rowval) grid[0][0]=0 return grid def genFood(): return random.randint(1,200)
34eca39f58c01591a82ba1bec326b21d55110c85
nsa18685/my_first_python
/4장/쳌4.22.py
104
3.703125
4
num = eval(input("수를 입력하세요: ")) num = True if num>0 and num <= 100 else False print(num)
8846dbb60c1199a399b6db4832c3ddcc4c2d7ea8
victor12416/Elam_Cabrera
/The Dealer ;).py
7,111
4.125
4
Inventory_list = ['Infiniti, Subaru, Lexus, GMC, Toyota, BMW, Honda, Lincoln' ] #individual list of cars Infiniti = ['Q50,QX80,QX30'] Subaru= ['Impreza,Legacy,Forester'] Lexus = ['Rx,IS,Ls'] GMC = ['Acadia,Yukon,Canyon'] Toyota = ['Corolla,Land Crusier,C-HR'] BMW = ['3 Series,X5,5 Series'] Honda = ['Accord,Civic,CR-V'] Lincoln = ['Continential,Navigator,MKZ'] #Dialoge print('Hi welcome to elam autoshop,') print('if your new i got just the thing for you.') print('Just pick one of your favorite car brands and well start from there.') print('Here are some of the top leading Brands') print('~~>If the Brand is not listed amagon the intial inventory') print('please enter (N/A)') print('') #user Input print(Inventory_list) UI = input() print('') #adds Brands and 3 cars into it if UI == 'N/A': print('Please Enter the name of the brand you') print('want to add to the selection') new_brand = input() print('Now we need to add three cars to add to the suggested Brand') new_car1 = input("1. ") new_car2 = input("2. ") new_car3 = input("3. ") new_brand_car_list = [new_car1, new_car2, new_car3] Inventory_list.append(new_brand) print("You added a new " + new_brand + " list to the database " + "with these models " + str(new_brand_car_list)) print('') NUI = input('Do you want to go ahead and pick the brand you suggested(Y/N)') if NUI == 'Y': print('') print('Here are the cars you picked from ' + new_brand) print(new_brand_car_list) print('') import random car_price = (random.randint(40,100)) User_car_selection = input('What car are you going to go for:') if User_car_selection == new_car1: print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == new_car2: print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == new_car3: print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') else: print('') print(Inventory_list) print('What brand are you going to go for') UI = input() #Randomiser import random car_price = (random.randint(50,100)) #scans for UI input and prints accordingly if UI == 'Infiniti': print('Here are the top cars from ' + UI) print(Infiniti) User_car_selection = input('What car are you going to go for:') if User_car_selection == 'Q50': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == 'QX80': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == 'QX30': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if UI == 'Subaru': print('Here are the top cars from ' + UI) print(Subaru) User_car_selection = input('What car are you going to go for:') if User_car_selection == 'Impreza': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == 'Legacy': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == 'Forester': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if UI == 'Lexus': print('Here are the top cars from ' + UI) print(Lexus) User_car_selection = input('What car are you going to go for:') if User_car_selection == 'Rx': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == 'IS': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == 'Ls': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if UI == 'GMC': print('Here are the top cars from ' + UI) print(GMC) User_car_selection = input('What car are you going to go for:') if User_car_selection == 'Acadia': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == 'Yukon': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == 'Canyon': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if UI == 'Toyota': print('Here are the top cars from ' + UI) print(Toyota) User_car_selection = input('What car are you going to go for:') if User_car_selection == 'Corolla': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == 'Land Crusier': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == 'C-HR': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if UI == 'BMW': print('Here are the top cars from ' + UI) print(BMW) User_car_selection = input('What car are you going to go for:') if User_car_selection == '3 Series': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == 'X5': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == '5 Series': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if UI == 'Honda': print('Here are the top cars from ' + UI) print(Honda) User_car_selection = input('What car are you going to go for:') if User_car_selection == 'Accord': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == 'Civic': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == 'CR-V': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if UI == 'Lincoln': print('Here are the top cars from' + UI) print(Lincoln) User_car_selection = input('What car are you going to go for:') if User_car_selection == 'Continential': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == 'Navigator': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000') if User_car_selection == 'MKZ': print('The cuurent going price for ' + User_car_selection + ' is ' + str(car_price) + ',000')
a2547f366d7f74fb83b1fdf7dc6b0a5c92923d84
nguyenkims/projecteuler-python
/src/p25.py
366
3.65625
4
def fib_gen(n): '''generate n first Fibonacci numbers''' a,b,i=0,1,1 yield a,0 yield b,1 while i < n: i += 1 if a > b: b = a+b yield b,i else: a = b +a yield a,i def test() : t = fib_gen(10) for i in t: print i # test() def final(): k = 1000 t = fib_gen(6*k) for i,j in t: if len(str(i)) > k: print k,j return final()
3253b5f418d1c40fc7a3590828fb1367e9632bfe
Juan-Tena/Codigo_VBA
/Trabajo_Serializacion.py
396
3.53125
4
import pickle lista_nombres=["Pedro", "Ana", "Maria","Isabel"] fichero_binario=open("lista_nombre","wb") #Escritura binaria pickle.dump(lista_nombres, fichero_binario) fichero_binario.close() del(fichero_binario) #Ahora, una vez creado el fichero binario, vamos a rescatar la información que contiene import pickle fichero=open("lista_nombre", "rb") lista=pickle.load(fichero) print(lista)
40a5b2ef1a707beeca6fbcce913af48d670dca79
bendell02/nowCoder
/01_code/prj188_median.py
380
3.84375
4
#!/usr/bin/python #-*- coding:utf-8 -*- #Author: Ben def median(nums1, nums2): nums = nums1+nums2 nums.sort() l = len(nums) return nums[(l-1)/2] while True: try: nums1 = map(int, raw_input().split()) nums1.pop(0) nums2 = map(int, raw_input().split()) nums2.pop(0) print median(nums1, nums2) except: break
467d5a3efb104f4a98fd54bc1975c8cf1186c732
serenascalzi/python-specialization
/exercises/chapter01-exercises.py
854
3.859375
4
# chapter 1 # why should you learn to write programs? # secondary memory - stores information for the long term, even beyond a power cycle # program - set of instructions that specifies a computation # compiler - translates a program written in a high-level language into a low-level language all at once, in preparation for later execution # interpreter - executes a program in a high-level language by translating it one line at a time # machine code - python source file # primt 'Hello world!' - invalid syntax, print misspelled # x = 123 - variable stored in main memory x = 43 x = x + 1 print(x) # 44 # central processing unit - brain # main memory - short-term memory # secondary memory - long-term memory # input device - headphones # output device - microphone # syntax error - fix grammar thru reading, running, ruminating & retreating
1cc01064b5ed36b656b4e96809279d6a8eca04b0
shohruh-abduakhatov-portfolio/go-apteka-py
/web/ui_methods.py
761
3.78125
4
def has_access(self, roles): user = self.current_user """ user_roles = user["roles"] has_access = False for role in user_roles: if _checkRole(role, roles) == True: has_access = True break return has_access """ return True def _checkRole(role, roles): ''' Check given role is inside or equals to roles ''' # Roles is a list not a single element if isinstance(roles, list): found = False for r in roles: if r.value == role["value"]: found = True break if found == True: return True # Role is a single string else: if roles.value == role: return True return False
a36a06e81672816e45fd24bee6066bc28188420a
mcxu/code-sandbox
/PythonSandbox/src/sorting/merge_sort.py
1,974
3.796875
4
''' Merge Sort ''' from utils.number_utils import NumberUtils class Prob: def mergeSort(self, array): if not array or len(array)==1: return array median = int(len(array)/2) left = array[:median] right = array[median:] #print("mergeSort: median:{}, l:{}, r:{}".format(median,left,right)) sl = self.mergeSort(left) sr = self.mergeSort(right) return Prob.mergeArrays(sl,sr) # merge pre-sorted arrays def mergeArrays(self, l,r): print("merging arrays: l:{}, r:{}".format(l,r)) out = [] i = 0 j = 0 while(i<len(l) and j<len(r)): lv = l[i]; rv = r[j] #print("=====\ni={}, j={}".format(i,j)) #print("l:{}, r:{}, lv:{}, rv:{}".format(l,r, lv, rv)) if lv <= rv: out.append(lv) i += 1 else: out.append(rv) j += 1 if i < len(l): # handle remaining left out += l[i:] elif j < len(r): # handle remaining right out += r[j:] return out @staticmethod def test_mergeArrays(): a = [1,4,7,128,129,130] b = [2,5,6,12,56,102,103,104,105,106,110,120,130] out = Prob.mergeArrays(a,b) print(out) @staticmethod def test_mergeSort(): a= [1,5,4,2,3] s = Prob.mergeSort(a) print("s: ", s) @staticmethod def test_mergeSort2(): a = [] s = Prob.mergeSort(a) print("sorting empty: ", s) @staticmethod def test_mergeSort3(): a = NumberUtils.generateRandomNumbers(0, 10000, 100, allowDuplicates=False) s = Prob.mergeSort(a) print("sorted: ", s) #Prob.test_countingSort() #Prob.test_mergeArrays() #Prob.test_mergeSort() #Prob.test_mergeSort2() #Prob.test_mergeSort3()
1b6790391e5b6903372f0c9ff5bf76b3c396b2d2
B14nk/Sorting_Algorithms
/Mergesort/Mergesort.py
723
3.671875
4
arr = [1,4,324,56,7,456, 45, 34, 3267,768, 100] def mergesort(arr): if len(arr) <= 1: return arr else: l = mergesort(arr[0:len(arr)/2]) r = mergesort(arr[len(arr)/2:len(arr)]) return merge(l, r) def merge(l, r): if len(l) == 0: return r if len(r) == 0: return l i, j = 0, 0 run = True output = [] while run: if l[i] < r[j]: output.append(l[i]) i += 1 else: output.append(r[j]) j += 1 if i == len(l): output += r[j:] run = False if j == len(r): output += l[i:] run = False return output print(mergesort(arr))
d4ccf81e659edef409ce7f6b7c4ca621d90cee51
Crasti/Homework
/Lesson4/Task4.6.py
782
4.21875
4
""" Реализовать два небольших скрипта: а) бесконечный итератор, генерирующий целые числа, начиная с указанного, б) бесконечный итератор, повторяющий элементы некоторого списка, определенного заранее. Подсказка: использовать функцию count() и cycle() модуля itertools. """ from itertools import count from itertools import cycle # Часть задания А for el in count(int(input("Enter start integer: "))): print(el) # Часть задания Б string = "String" iterat = cycle(string) print(next(iterat)) print(next(iterat)) print(next(iterat)) print(next(iterat))
59bf9e3eddbd3e50a5b0e787c1fa14e71ac55632
macasubo/python_bootcamp
/python01/ex03/matrix.py
2,448
3.703125
4
class Matrix: def __init__(self, data=[], shape=()): if type(data) == type(list()): self.data = data if len(shape) == 0: self.shape = (len(self.data), len(self.data[0])) else: self.shape = shape elif type(data) == type(tuple()): self.data = list() self.data = [[0 for item in range(data[1])] for row in range(data[0])] self.shape = data def __repr__(self): return f'Object: shape: {self.shape}, data: {self.data}' def __str__(self): return ', '.join([f'{key}: {value}' for key, value in self.__dict__.items()]) def __add__(self, other): if type(other) == Matrix: return [[self.data[y][x] + other.data[y][x] for x in range(other.shape[1])] for y in range(self.shape[0])] elif type(other) == type(list()): return [[self.data[y][x] + other[y] for x in range(self.shape[1])] for y in range(self.shape[0])] else: print("Error: invalid type") def __radd__(self, other): return self.__add__(other) def __sub__(self, other): if type(other) == Matrix: return [[self.data[y][x] - other.data[y][x] for x in range(other.shape[1])] for y in range(self.shape[0])] elif type(other) == type(list()): return [[self.data[y][x] - other[y] for x in range(self.shape[1])] for y in range(self.shape[0])] else: print("Error: invalid type") def __rsub__(self, other): if type(other) == Matrix: return [[other.data[y][x] - self.data[y][x] for x in range(other.shape[1])] for y in range(self.shape[0])] elif type(other) == type(list()): return [[other[y] - self.data[y][x] for x in range(self.shape[1])] for y in range(self.shape[0])] else: print("Error: invalid type") def __mul__(self, other): if type(other) == type(list()): other = Matrix([other]) if type(other) == Matrix: res = Matrix((self.shape[0], other.shape[1])) for y in range(self.shape[0]): for x in range(other.shape[1]): for z in range(self.shape[1]): res.data[y][x] += self.data[y][z] * other.data[z][x] return res # elif type(other) in [type(int()), type(float())]: else: print("Error: invalid type") # def __rmul__(self, other): # if type(other) == Matrix: # res = Matrix((self.shape[0], other.shape[1])) # for y in range(self.shape[0]): # for x in range(other.shape[1]): # for z in range(self.shape[1]): # res.data[y][x] += self.data[y][z] * other.data[z][x] # return res
43059fbcd356ec0f13831956367ede3368efeeff
marcus255/coding
/euler/37/37.py
740
3.875
4
def isPrime2(Number): return 2 in [Number,2**Number%Number] def isPrime(n): for i in range(2,int(n**0.5)+1): if n%i==0: return False return True num = 11 primes_sum = 0 primes_count = 0; while(primes_count < 11): if isPrime(num): temp_num = num temp_num_2 = num while temp_num > 9 and temp_num_2 > 9: temp_num = temp_num // 10 temp_num_2 = temp_num_2 - int(str(temp_num_2)[0] + '0' * (len(str(temp_num_2)) - 1)) if not (isPrime(temp_num) and isPrime(temp_num_2)): break if temp_num in [2, 3, 5, 7] and temp_num_2 in [2, 3, 5, 7]: primes_count += 1 primes_sum += num print('{}: {}'.format(primes_count, num)) num += 1 print('The sum of these primes is ' + str(primes_sum))
32be62f0179a2b2e07235c3da0cea65355b6326b
SEugene/python
/task_1_3.py
1,304
3.640625
4
num_list = [] for num in range(21): num_list.append(num) for ind in range(len(num_list)): last_num_hun = num_list[ind] % 100 last_num_ten = num_list[ind] % 10 if 10 < last_num_hun < 15: print('{} процентов'.format(num_list[ind])) elif 1 < last_num_ten < 5: print('{} процента'.format(num_list[ind])) elif last_num_ten == 1: print('{} процент'.format(num_list[ind])) else: print('{} процентов'.format(num_list[ind])) # алгоритм решения получился универсальным - не зависящим от диапазона, ниже добавил код, который определяет # склонение слова "процент" при вводе любого целого числа rand_num = int(input('Введите любое целое число для проверки склонения слова "процент": ')) last_num_hun = rand_num % 100 last_num_ten = rand_num % 10 if 10 < last_num_hun < 15: print('{} процентов'.format(rand_num)) elif 1 < last_num_ten < 5: print('{} процента'.format(rand_num)) elif last_num_ten == 1: print('{} процент'.format(rand_num)) else: print('{} процентов'.format(rand_num))
e8852066638f03d2fe567ce9b75ed686de97e3ef
shonihei/road-to-mastery
/algorithms/sorting-algorithms/insertionsort.py
1,288
3.5625
4
import random, sys m = 0 # keeps track of number of comparisons def wrapper(l): lst = l[:] insertion_sort(lst) return lst def insertion_sort(lst): global m for i in range(1, len(lst)): cur = i for j in range(i - 1, -1, -1): m += 1 if lst[cur] < lst[j]: lst[cur], lst[j] = lst[j], lst[cur] cur -= 1 else: break def percent_sorted(u, s): c = 0 for i in range(len(u)): j = s.index(u[i]) if i <= j: c += 1 return c / len(u) def test(lo, hi, n, test_size): global buckets global m buckets = dict() worst_case = n**2 for test in range(test_size): l = random.sample(range(lo, hi), n) sorted_lst = wrapper(l) percent_same = m / worst_case buckets[percent_same] = buckets.get(percent_same, []) + [m] m = 0 for k, v in sorted(buckets.items()): avg = sum(v) / len(v) print("{:.2f}% sorted: {:.2f} comparisons".format(k * 100, avg)) #lo, hi, n = int(sys.argv[1]), int(sys.argv[2]), int(sys.argv[3]) #l = random.sample(range(lo, hi), n) #insertion_sort(l) #print("random list of {} elements sorted with {} comparisons".format(n, m)) #print(l)
3f2b3fb132ef8cfab2063dee8d8a87570a60d4e3
blidt/metodosNumericos
/newton/newton.py
490
3.96875
4
from math import * def newtonIterationFunction(x): return x - (((-8*exp(1-x)+7/x)) / (8*exp(1-x)-7/x**2)) def function(x): return -8*exp(1-x)+7/x x = 1.6 c = 1 xold = 0 fc = 1 for i in range(1000): print "Iteraciones: ",str(i),"Valor aproximado: ", str(x), "Intervalo", str(c), "f(c)", str(fc) c = abs(x - xold) fc = function(x) xold = x x = newtonIterationFunction(x) if (abs(c) < 0.000000005) : print ("Solucion encontrada!") break
61c1ed60d436e5cb70c3cc74cf375bf20baf8a76
cikent/Python-Projects
/Automate-The-Boring-Stuff-With-Python/Section_03_Functions/Lesson_10_Global_&_Local_Scope/Local_Variable_Execution_Error_example.py
276
3.890625
4
""" Upon execution, the function 'spam()' throws an exception because eggs is utilized as a Local variable before assignment """ def spam(): print(eggs) # ERROR! -- can't use a local variable before it is assigned a value eggs = 'spam local' eggs = 'global' spam()
ca469bd9acb7c2fdba8ec887fc1e1eb531140dfb
PascalUlor/code-challenges
/python/linked_list_1.py
6,447
4.25
4
# Create Node constructror class ListNode(object): def __init__(self, value=None): self.data = value self.next_node = None #address to next node # def __str__(self): # return f"{self.data} → {self.next_node}" # node = ListNode(5) # node.next_node = 2 # print(node) # create List Constructor that takes a value class Linked_List(object): # # set node as None # # set head for linked list and # # set a temp/pointer variable to track address of linked lists def __init__(self): self.head = None self.pointer = None self.list_size = 0 # def __str__(self): # return f"Head→{self.head}" def insert_node(self, data): #add a new node to linked list self.list_size += 1 #increment list size new_node = ListNode(data) # initialize new node if self.head is None: # at start of linked list the head is also the pointer self.head = new_node self.pointer = self.head else: # if linked list already exists self.pointer.next_node = new_node # pointer will hold address to new node self.pointer = new_node # newly added node becomes new pointer def get_size(self): # optimal approach with (O)1 return self.list_size def get_size_traver(self): # (O)n works if we did not have size increment on inserting node actual_node = self.head size = 0 while actual_node is not None: size += 1 actual_node = actual_node.next_node return size def insert_at_start(self, data): self.list_size += 1 # increment size of array new_node = ListNode(data) if self.head is None: #if there is no head it means linked list is empty self.head = new_node # set head to new node if linked list is empty else: #if linked list is not empty set the address ref of new node to head new_node.next_node = self.head # now make the new node the head self.head = new_node def remove_node(self, data): # base case to ensure list in not empty if self.head is None: return # decrement size of list self.list_size -= 1 # set head node to a variable current_node = self.head prev_node = None # since head node has no previous # traverse list while current_node.data != data: prev_node = current_node current_node = current_node.next_node # if specified node to be deleted is the head then it wont have a previous if prev_node is None: self.head = current_node.next_node else: prev_node.next_node = current_node.next_node def traverse_node(self): actual_node = self.head linked_list_string = "" # traverse list while actual_node is not None: # print(f"{actual_node.data}") linked_list_string += f"{actual_node.data} → " actual_node = actual_node.next_node linked_list_string += 'None' if self.head is None: print('list is empty') print(linked_list_string) def insert_at_end(self, data): self.list_size += 1 new_node = ListNode(data) actual_node = self.pointer # traverse to find the last node while actual_node.next_node is not None: actual_node = actual_node.next_node actual_node.next_node = new_node def insert_at_pos(self, pos, data): if pos > self.list_size: print('invalid position') else: self.list_size += 1 new_node = ListNode(data) current_node = self.head i = 0 while i < pos: current_node = current_node.next_node i += 1 new_node.next_node = current_node.next_node current_node.next_node = new_node def remove_from_pos(self, pos): if pos > self.list_size: print('invalid position') else: self.list_size -= 1 current_node = self.head i = 0 while i < pos-1: current_node = current_node.next_node i += 1 pos_next = current_node.next_node current_node.next_node = pos_next.next_node def remove_from_end(self): #(O)n # base case to ensure list in not empty if self.head is None: return # decrement size of list self.list_size -= 1 # set head node to a variable current_node = self.head prev_node = None # since head node has no previous # traverse list while current_node.next_node is not None: prev_node = current_node current_node = current_node.next_node # if specified node to be deleted is the head then it wont have a previous if prev_node is None: self.head = current_node.next_node else: prev_node.next_node = current_node.next_node def remove_start(self): #(O)1 # base case to ensure list in not empty if self.head is None: return # decrement size of list self.list_size -= 1 # set head node to a variable current_node = self.head self.head = current_node.next_node def reverse_list(self): # to reverse a llist we need 3 pointers # prev, current and nextnode current_node = self.head temp_next_node = self.head prev_node = None while temp_next_node is not None: temp_next_node = temp_next_node.next_node current_node.next_node = prev_node prev_node = current_node current_node = temp_next_node self.head = prev_node list_node = Linked_List() list_node.insert_node(23) list_node.insert_node(3) list_node.insert_node(1) # list_node.insert_at_start(0) # list_node.remove_node(0) list_node.insert_at_end(100) list_node.insert_at_pos(10, 4) # list_node.insert_at_pos(4, 4) list_node.traverse_node() # print('after deletion') # list_node.remove_from_end() # list_node.remove_start() # list_node.remove_from_pos(1) list_node.traverse_node() list_node.reverse_list() print('after reversal') list_node.traverse_node() # print(list_node)
15c5346462fcc619d7b98b02513d02c1a6f904b1
superdun/9BillionNames
/9billion.py
1,040
3.546875
4
#! usr/bin/python #coding=utf-8 / import time from itertools import groupby,count #打印神的一个名字 def printGodsName(words): godsName = "" #神没有带有三个连续字母的名字 if max(len(list(g)) for k, g in groupby(words) )>=3: return for singleWord in words[::-1]: godsName+=chr(65+singleWord) print godsName #26进制 def twentySixDecimal(words,i=0): if words[i]==26: words[i] = 0 if i == len(words)-1: words.append(0) else: words[i+1]+=1 i+=1 twentySixDecimal(words,i) return words #启动V型电脑 def RunMarkV(bitCount): words = [-1] for i in count(): if i==(26**bitCount+26*(1-26**(bitCount-1))/(-25)): break words[0] += 1 words = twentySixDecimal(words) printGodsName(words) #如果运行到这里世界还没有毁灭的话.....呼一口气,乘坐DC-3离开 time.sleep(1) print u"神是脆弱的东西,他们闻点儿科学的气味或者喝点常识的药水都会死掉" def main(): bitCount = 9 RunMarkV(bitCount) if __name__ == '__main__': main()
8c03e411ea674d15b2520c39b15478f7abf37ad1
sejal-varu/bigdata
/python/exception/play_input.py
264
3.890625
4
print 'Program starts' n = raw_input('Enter n : ') try : i = int(n) except ValueError: #Executes when error print 'Hey! Please enter numerals only' else: #Executes when no error raised in corresponding try block print 'The number is ', i print 'Program ends'
2cf6cfffa8082ad0ef28188e2c5eaf74cb952a61
shaileshr/leetcode
/binaryTrees/create_list_from_tree.py
907
4
4
from typing import List class BinaryTreeNode: def __init__(self, data=None, left=None, right=None): self.data = data self.left = left self.right = right def create_list_of_leaves(tree: BinaryTreeNode) -> List[BinaryTreeNode]: # TODO - you fill in here. #result = [] #def create_list_of_leaves_helper(node): # if not node: # return # # if not node.left and not node.right: # result.append(node) # # if node.left: # create_list_of_leaves_helper(node.left) # if node.right: # create_list_of_leaves_helper(node.right) # # create_list_of_leaves_helper(tree) # return result if not tree: return [] elif not tree.left and not tree.right: return [tree] else: return create_list_of_leaves(tree.left) + create_list_of_leaves(tree.right)
3f2430fdf31e1e51064473a1a1de043e7299de17
MotherTeresaHS/ICS3U-2019-Group22
/docs/readthedocs_examples/egg+bomb_function_example.py
1,335
3.5625
4
#!/usr/bin/env python3 # Created by: Douglass Jeffrey # Created on: Dec 2019 # This file is the contains the egg and bomb moving functions for Egg collector def game_scene(): # Function to make eggs reappear at the top of the screen def show_egg(): for egg_number in range(len(eggs)): if eggs[egg_number].x < 0: # meaning it is off the screen, eggs[egg_number].move(random.randint(0 + constants.SPRITE_SIZE, constants.SCREEN_X - constants.SPRITE_SIZE), constants.OFF_TOP_SCREEN) break # Function to make bombs reappear at the top of the screen def show_bomb(): for bomb_number in range(len(bombs)): if bombs[bomb_number].x < 0: # meaning it is off the screen bombs[bomb_number].move(random.randint (0 + constants.SPRITE_SIZE, constants.SCREEN_X - constants.SPRITE_SIZE), constants.OFF_TOP_SCREEN - random.randint(0, 50)) break if __name__ == "__main__": game_scene()
886597afcc7737a15d17249d495c02b420d8f12c
IHAGI-c/GIS_class_2
/decorator2.py
326
3.796875
4
def decorator(func): def decorated(a, b): if a > 0 and b > 0: func(a, b) else: print('err') return decorated @decorator def area(a, b): T_A = a * b * 1/2 S_A = a * b print('삼각형의 넓이 :', T_A) print('사각형의 넓이 :', S_A) area(2,8) area(-2,4)
dff38823f0c0b8932ac6f4ae4362bec85c9fc3fd
Cathryne/Python
/ex31.py
2,723
4.40625
4
# Exercise 31: Making Decisions # http://learnpythonthehardway.org/book/ex31.html # enables restarting of program import sys import os def restart_program(): """Restarts the current program, without returning anything before-hand Hence, clean-up and save data before calling.""" python = sys.executable os.execl(python, python, * sys.argv) door = raw_input("\nYou enter a dark room with three doors. Do you go through the door to your _front_, _left_ or _right_? ") # while loop to prevent invalid responses # strange problem: only 1st answer was accepted by (logical) code "while door != ("1st" or "2nd" or "3rd") # strange problem: only 3rd answer was accepted by (logical) code "while door != ("1st" and "2nd" and "3rd") # possible explanation: while & if blocks execute only if statement is true. # truth terms need "" here, because numbers haven't been converted by int() and are thus still strings while door != "left" and door != "right" and door != "front": door = raw_input("Please pick a door: front, left or right. ") # Study Drill 1: New game part with input check and restart function if door == "front": gold = int(raw_input("\nYou find three chests of gold. How many do you take for your self? ")) if gold == 0: raw_input("\nYou found the easter-egg and get to play again, after pressing any key.") restart_program() # numbers converted to integers here, thus no "" necessary while gold != 1 and gold != 2 and gold != 3: gold = raw_input("How many gold chests do you take? 1, 2 or 3? ") if gold <= 2: print "\nOK, that's reasonable. A ladder appears from above and ceiling cat helps you get out into the fresh air.\n" elif gold == 3: print "\nYou're a greedy one! The weight of the gold breaks your back and the floor. You fall into the darkness.\n" elif door == "left": print """\nThere's a giant bear here eating a cheese cake. 1. Take the cake. 2. Scream at the bear.""" bear = raw_input("What do you do? ") if bear == "1": print "The bear eats your face off. Good job!" elif bear == "2": print "The bear eats your legs off. Good job!" else: raw_input("\nYour answer doesn't fit to the options. Press anything to start the game now. ") restart_program() elif door == "right": print """\nYou stare into the endless abyss at Cthulhu's retina." 1. Blueberries. 2. Yellow jacket clothespins. 3. Understanding revolvers yelling melodies.""" insanity = raw_input("What will it be? ") if insanity == "1" or insanity == "2": print "\nYour body survives powered by a mind of jello. Good job!\n" else: print "\nThe insanity rots your eyes into a pool of muck. Good job!\n"
b116cdb1760778af80afabb2e367dfd1e982aef3
EdikCarlos/Exercicios_Python_basico
/ex_Aumento_multiplo.py
346
3.78125
4
sal = float(input('Qual o valor do salário atual do funcionário?: ')) sal1 = sal + (sal * 10/100) sal2 = sal + (sal * 15/100) if sal <= 1250 : print('O salário do funcionário terá um aumento de 15%, indo para R${:.2f}.'.format(sal2)) else: print('O salário do funcionário terá um aumento de 10%, indo para R${:.2f}.'.format(sal1))
fcc607412cf4bc6fe9cc73bc32504498b6ca47b1
udayreddy026/pdemo_Python
/logical_aptitude/08-04-2021/Armstrong.py
562
4.0625
4
# # Armstrong Number means number ex:153 = 1cub+5cub+3cub = same as give number is called armstrong # # num = 153 # temp = num # arm_total = 0 # while num > 0: # l_num = num % 10 # num = num // 10 # arm_total = arm_total+(l_num**3) # # print(arm_total) # # if arm_total == temp: # print(arm_total, "is armstrong") # else: # print(arm_total, "is not armstrong") # x = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100] # for i in x: # print(i) for i in range(len(x)-1, -1, -1): print(x[i]) print() for i in range(0, len(x), 2): print(x[i])
d1bd4b8f9483d961a0bc151fa10d5299ef3befeb
shikhalakra/python-code
/python_code1/candidate_code_1488906186.py
486
3.671875
4
''' Read inputSTDIN. Print your output to STDOUT ''' #Use input() to read inputSTDIN and use print to write your output to STDOUT def main(): n=int(raw_input()) for i in xrange(0,n): for j in xrange(0,i): print " ", for k in xrange(0,n-i): print "*", for l in xrange(0,n-i-1): if l!=(n-i-2): print "*", else: print "*" # Write code here main()
d8e56d189545c8e3269f4727da34e595866353b8
leorossa/first_platformer
/player.py
1,934
3.734375
4
#!/usr/bin/env python # -*- coding: utf-8 -*- from pygame import * MOVE_SPEED = 7 WIDTH = 22 HEIGHT = 26.5 COLOR = "#7cdbef" JUMP_POWER = 10 GRAVITY = 0.35 # Сила которая удет тянуть наш прямоугольник class Player(sprite.Sprite): """класс нашего прямоугольника""" def __init__(self, x, y): sprite.Sprite.__init__(self) self.xvel = 0 #скорость нашего прямоугольника, 0 стояние на месте self.startX = x #начальная позиция self.startY = y self.image = Surface((WIDTH, HEIGHT)) #его изображение self.image.fill(Color(COLOR)) #заливка цветом self.rect = Rect(x, y, WIDTH, HEIGHT) #прямоугольные объект self.yvel = 0 # скорость вертикального перемещения self.onGround = False # на земле ли я? def update(self, left, right, up): if up: if self.onGround: # прыгаем только тогда когда можно оттолкнуться от земли self.yvel = -JUMP_POWER if left: self.xvel = -MOVE_SPEED # Лево = x - n if right: self.xvel = MOVE_SPEED # Право = x + n if not(left or right): # Стоим когда нет указаний идти self.xvel = 0 if not self.onGround: self.yvel += GRAVITY self.onGround = False; # мы не знаем когда мы на земле self.rect.y += self.yvel # переносим положение на yvel self.rect.x += self.xvel # переносим свое положение на xvel def draw(self, screen): # Выводим себя на экран screen.blit(self.image, (self.rect.x,self.rect.y))
026a1a25d52e9fb46ad80ea9c7208b2d43981f27
LexLau/dev-sprint2
/chap7.py
451
3.90625
4
# Enter your answrs for chapter 7 here # Name: Alex # Ex. 7.5 def estimate_pi(): total = 0 k = 0 factor = 2 * math.sqrt(2) / 9801 while True: num = factorial(4*k) * (1103 + 26390*k) den = factorial(k)**4 * 396**(4*k) term = factor * num /den total += term if abs(term) < 1e-15: break k += 1 return 1 / total print estimate_pi() # How many iterations does it take to converge? # I definitely could not figure this out on my own.
7271b4f9cae55ed3257ea33a8d77ea7b7979499c
3salaz/python-Devops
/scripts/scriptThree.py
196
4.21875
4
# Given a word # Have the program remove the given suffix # Use the strip method # Strip Method def suffixStrip(suffix, word): return print(word.rstrip(suffix)) suffixStrip('ed',"murdered")
d30565c4578a12deb775c04d6f42c8cd27420934
RJBrooker/insult.ai
/insultAI.py
1,141
3.6875
4
""" Insult.AI is an API for predicting the offensiveness of insults. It takes a piece of text and returns a prediction of how insulting it is. Its built using hug, gunicorn and pyTorch. The model is trained on top of torchMoji [1] using transfer learning and the “Detecting Insults In Social Commentary” dataset [2]. [1] https://github.com/huggingface/torchMoji [2] https://www.kaggle.com/c/detecting-insults-in-social-commentary/data """ import hug import insultModel as m import numpy as np @hug.post('/insult', output=hug.output_format.json ) def sentimentEndpoint( text:hug.types.text, language:hug.types.one_of([ 'en' ])='en', docType:hug.types.one_of(['PLAIN_TEXT'])='PLAIN_TEXT', ): """Analyzes comments and predicts their offensiveness.""" scores = m.score(text) return { "language": language , "sentences": scores } # test the endpoint api = hug.API(__name__) response = hug.test.post(api, '/insult', { "text": "You're so fake, Barbie is jealous. I like you. You are the worst" } ) print(response.data) assert (response.status=='200 OK' and response.data is not None) print( "SUCCESS" )
f168c90dd32996fca9d37991aad6938260189345
EDG-UPF-ADS/Python-1
/Todas/somatorio Z.py
214
3.796875
4
# FUAQ ler valor para Z. calcular e mostrar o somatório # dos valores pares entre 1 e z. z=int(input('Insira um Numero p/ Somatório: ')) acum=0 for i in range(2,z): if(i%2==0): acum=acum+i print(acum)
8612554ef86f3e5cb07a58fefea7d570f5ef115a
martsavy/stepik-basic-python
/exercises/func13_13.5.2.py
1,139
4.34375
4
""" Змеиный регистр Напишите функцию convert_to_python_case(text), которая принимает в качестве аргумента строку в «верблюжьем регистре» и преобразует его в «змеиный регистр». Примечание 1. Почитать подробнее о стилях именования можно тут. Примечание 2. Следующий программный код: print(convert_to_python_case('ThisIsCamelCased')) print(convert_to_python_case('IsPrimeNumber')) должен выводить: this_is_camel_cased is_prime_number """ # объявление функции def convert_to_python_case(text): res = text[0:1].lower() for c in text[1:]: if c.isupper(): res = res + '_' + c.lower() else: res += c return res # проверка print(convert_to_python_case('ThisIsCamelCased')) print(convert_to_python_case('IsPrimeNumber')) # считываем данные txt = input() # вызываем функцию print(convert_to_python_case(txt))
95907c6f1fb8ae387bbdb1303443b43116d40baf
tonyzhangqi2000/learning
/day02/exercise05.py
232
3.59375
4
""" 练习:判断闰年 四年一润,百年不润 四百年再润 """ import day01.helloworld as hw year = int(input("输入年:")) print((year % 400) == 0 or ((year % 4) == 0 and (year % 100) != 0)) hw.HW()
12e1b6c65dfed071739226aee435641b5021b25a
dolomaniuk/python_project
/cours/week_1/KMperDay/solution.py
124
3.734375
4
N = int(input()) # km per day M = int(input()) # count of day days = M // N if M % N > 0: days += 1 print(days)
528b8ac11e24dc3a672293e151fa8f4d307bb4b6
ozmaws/Chapter-2-Projects
/Project2.9.py
414
4.1875
4
#math notes #10,000km between npole and equator #90 degrees between npole and equator #1 degree = 60 min #1 min = 1 mile #Request the inputs kilometer = int(input("Enter the number of kilometers: ")) # Compute the nautical miles nauticalMiles = ( kilometer / 10000 ) * 90 * 60 # Display the corresponding nautical miles print("The corresponding number of nautical miles is " + str(nauticalMiles))
9f515d876147d885018c5b8f4b7728db9e10b206
diegomonroy/Platzi-Curso-de-Python-y-Django
/clases.py
598
3.59375
4
class Persona: def saludo_general(self): return "Hola Persona" class Estudiante(Persona): #Hereda de object, siempre se nombra con mayuscula def __init__(self, nombre, edad): #Es el cosntructor, self se usa siempre en clases self.nombre = nombre self.edad = edad def hola(self): #Es la funcion que contiene nuestra clase Estudiante return "Mi nombre es %s\n" % self.nombre e = Estudiante("Arturo",21) #Asi creamos un objeto de la clase Estudiante print e.saludo_general() e1 = Estudiante("Fabian",21) e2 = Estudiante("Pablo",21) print e.hola(), e1.hola(), e2.hola();
893f0d34e8e792f675420b6e24fef7f9190495f3
rachelkelly/game
/main.py
2,383
3.84375
4
# first game maybe class Room(object): def __init__(self): #self.name = name ### doooon't get it here #self.foo = thing1 #self.bar = thing2 # these are placeholdery, I feel like putting "pass" # in the __init__ fn would be a bad time at this juncstuah # zed did also say to not put too much in the __init__ # ... so what DO I put into it pass class Inventory(Room): #why am I calling Room? hmmm bc you have to be IN the room #to instantiate the Inventory class, maybe? #ok but all in all this class is looking better, if #only I could just GET to it, esp now that I've got the #invlist as part of the megafauna! def inventorycheck(self): print "inventory:\n %s" % invlist def inventoryadd(self, addnew): #don't know if putting var addnew in here is necessary right now if addnew in invlist: print "can't have more than one, homes" elif addnew not in invlist: print "cool! now the %s is in your inventory." %addnew invlist.append(addnew) print "want to see what's in the bag now?" invchk = raw_input("> ") if 'y' in invchk: self.inventorycheck() elif 'n' in invchk: print "ok you don't have to, anyway it's over now" exit(0) else: print "error in adding item to inventory" class BookRoomHaHa(Room): def book(self): print "ok, you ate the book." exit(0) def bookviewing(self): print "you're in a room. who knows what kind yet?" print "so what do you do?" get_it_done = raw_input("> ") if "book" in get_it_done: # want to make this more abstractly, like, if VAR in get_it_done # then do some kind of "do you or don't you" inv taking action print "ok booktest go" self.book() #from stackoverflow # http://stackoverflow.com/questions/5615648/python-call-function-within-class elif "shelf" in get_it_done: print "you see a few books I guess, I don't know, man!" elif "thing2" in get_it_done: print "thing 2" elif "get" in get_it_done: print "buddy, you got it." print "for now, just tell me what you got, again: " addnew = raw_input("> ") #print "oktest!" # ok this piece is fine, now how to jump from one class # to another # why not just: #Inventory.inventoryadd() # doesn't work woh wohhhh else: print "try again doof" self.bookviewing() class DontDoIt(Room): pass invlist = [] crum = BookRoomHaHa() crum.bookviewing()
221c6092a536825b8275a329c5118b1bccbccc11
kensenwangka/UJIAN_1
/KENSEN_20DESEMBER2019_UJIAN_1.py
1,220
3.703125
4
# Soal 1 def hashtag(string): hashtag = "".join(string.title().split()) return [False, f"#{hashtag}"][bool(string and 0 < len(hashtag) <= 140)] # print(hashtag("Helo there how are you doing")) # print(hashtag(" ")) # Soal 2 def create_phone_number(n): return "({}{}{}) {}{}{}-{}{}{}{}".format(*n) # print(create_phone_number([1, 2, 3, 4, 5, 6, 7, 8, 9, 0])) # Soal 3 def sort_odd_even(num): even = sorted(x for x in num if x % 2 == 0) odd = sorted((x for x in num if x % 2 != 0), reverse=True) return [(even if x % 2 == 0 else odd).pop() for x in num] # print(sort_odd_even([5, 3, 2, 8, 1, 4])) # Soal 4 # "Height" nya di ganti N aja ya biar cepet def hollowTriangle(n): return ['_' * (n - i - 1) + '#' + '_' * (2 * i - 1) + '#' * (i >= 1) + '_' * (n - i - 1) \ for i in range(n - 1)] + ['#' * (2 * n - 1)] # print(hollowTriangle(6)) # gak ngerti gw wkwkwk jadi yaudah seadanya hehe # selamat natal dan tahun baru 2020. semoga liburannya menyenangkan di Jogja. see you! # nyari apaan?
a064fa90bb4314027b4814da9a7d66ede0152171
deepsinghsodhi/python-OOPS-assignments
/inheritance task/RBI bakn_inheritance.py
3,830
4.1875
4
''' All the banks operating in India are controlled by RBI. RBI has set a well defined guideline (e.g. minimum interest rate, minimum balance allowed, maximum withdrawal limit etc) which all banks must follow. For example, suppose RBI has set minimum interest rate applicable to a saving bank account to be 4% annually; however, banks are free to use 4% interest rate or to set any rates above it. Write a program to implement bank functionality in the above scenario and demonstrate the dynamic polymorphism concept. Note: Create few classes namely Customer, Account, RBI (Base Class) and few derived classes (SBI, ICICI, PNB etc). Assume and implement required instance variables and methods in each class. ''' class RBI: #<<<< RBI >>>>> def __init__(self, min_bal = 5000 , min_rate = 4, max_wdr = 50000 ): self.min_bal = min_bal self.min_rate = min_rate self.max_wdr = max_wdr print("init by RBI class by super") def getRBI(self): print("*************RBI Rules*************") print("Minimum Balance allowed:", self.min_bal) print("Minimum Rate of Intrest:", self.min_rate) print("Maximum Withdrawl Limit:", self.max_wdr) class Account: def __init__(self): self.acno = acno self.actype = 'Saving' self.bal = 0.00 print("init by Account class by super") super().__init__() def getAccount(self): print("********Account Details**************") print("AC Number:", self.acno) print("Bank Balance:", self.bal) print("Account Type:", self.actype) super().getRBI() ''' def deposit(self): # amount = int(input("Enter amount to be deposited: ")) # self.bal = self.bal + amount print("\n Amount Deposited:", self.bal) def withdraw(self): amount = int(input("Enter amount to be withdrawn: ")) if self.bal >= amount and amount <= self.max_wdr: self.bal -= amount print("\n You Withdrew:", amount) print("Availabel Balance:", self.bal) else: print("Insuficiant Balance!") ''' class Customer: #<<<<< Customer >>>>>>> def __init__(self): self.cname = cname self.add = add self.mob = mob self.dob = dob super().__init__() # calling Account class constructor.. def getCustomer(self): print("***************Customer Details***************") print("Name :", self.cname) print("Address :", self.add) print("Mobile :", self.mob) print("DOB :", self.dob) super().getAccount() # Calling 'getAccount' of 'Account' Class class SBI(Customer, Account, RBI): def __init__(self, minbal, minrate, maxwdr): self.minbal = minbal self.minrate = minrate self.maxwdr = maxwdr super().__init__() super().getCustomer() def check(self): if self.minbal >= self.min_bal: print("Minimum balance is:", self.minbal) else: print("Minimum balance is lower than RBI Minimum balance", ) if self.minrate < self.min_rate: print('Minimum rate of Interest is lower than RBI') else: print('Minimum rate is:', self.minrate) sbi = SBI() sbi.getCustomer() sbi.check(5000, 5, 2000) ''' class BOI(RBI, Customer, Account): def __init__(self, min_bal, min_rate, max_wdr): self.min_bal = 10000 self.min_rate = 5 self.max_wdr = 40000 class PNB(RBI, Account): def __init__(self, min_bal, min_rate, max_wdr): self.min_bal = 10000 self.min_rate = 5 self.max_wdr = 40000 '''
120432dd70141685477c73483f0d741830505204
gbaghdasaryan94/Kapan
/Garnik/Python 3/Loops/2.py
450
4.28125
4
# 2. Write a Python program to convert temperatures to and from celsius, fahrenheit. temp = input("Enter temperature: ") if temp[-1] == 'C' and temp[:-1].isdigit(): print("The temperature in farenheit is", (int(temp[:-1]) * 9/5 + 32)) elif temp[-1] == 'F' and temp[:-1].isdigit(): print("The temperature in celsius is", (float(temp[:-1]) * 5/9)) else: print("Please use valid imput format: Should be number + C/F (20C or 68F)")
2a0a4994e7174f9d0a0573030e1a86fb353a13be
ruinanzhang/Leetcode_Solution
/6-Largest Number Smaller In Binary Search Tree.py
2,471
3.796875
4
# Tag : Binary Search Tree # 136.Largest Number Smaller In Binary Search Tree # ----------------------------------------------------------------------------------- # Description: # In a binary search tree, find the node containing # the largest number smaller than the given target number. # If there is no such number, return -2^31. # ----------------------------------------------------------------------------------- # Assumptions: # The given root is not null. # There are no duplicate keys in the binary search tree. # ----------------------------------------------------------------------------------- # Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x): # self.val = x # self.left = None # self.right = None # ************************************************************************************* # Solution: # !!!! Similar to find the cloest # !!!! The condition to update helper node is different # !!!! Might have better solution, this is hacky def largestSmaller(self, root, target): """ input: TreeNode root, int target return: int """ r_val = root.val node = root # If root is the node we re looking for: if root.val < target and root.right is None: return root.val res = find_node(node, root,target) # if we can't find such node, we will return the root node value and if it's larger than the target, # we can't find target # else it might be our target is the root if res >= target: return -2147483648 else: return res def find_node(node, root,target): # If reach a leaf node, return the node with smallest difference if root is None: return node.val # If helper node's value is ever be the target, update it if get_dif(node,target) == 0: node.val = root.val # If curr node smaller than target: if root.val < target: # If value in hepler node larger than target, update anyway if node.val >= target: node.val = root.val else: # If value in hepler node is already smaller, update when have smaller difference if get_dif(root, target) < get_dif(node, target): node.val = root.val # Do regular search: if root.val >= target : return find_node(node,root.left,target) if root.val < target : return find_node(node,root.right,target) def get_dif(node,target): return abs(node.val - target)
764f4d3a884ea043de7ebc0e70e80e0461e1aeb2
Tammyqian/Python
/works/test/demo2.py
701
3.78125
4
import pandas as pd df1 = pd.DataFrame({'HPI':[80,85,88,85], 'Int_rate':[2, 3, 2, 2], 'US_GDP_Thousands':[50, 55, 65, 55]}, index = [2001, 2002, 2003, 2004]) print df1['HPI'] print '--------------------' # if df1['HPI'] >= 80 : # print df1['HPI'][0] # if df1.HPI>=80: # print df1['HPI'][0] print df1[df1['HPI']==75 | 85].count() print '--------------------' print df1[(df1['HPI']==75) | (df1['HPI']==85)] print df1[(df1['HPI']== 75) | (df1['HPI']== 85)].count().to_dict() print '---------------------' print df1[df1['Int_rate']==1 | 3].count().to_dict() print df1[(df1['Int_rate']== 1) | (df1['Int_rate']== 3)].count().to_dict()
89268608f88608bc648a807a48fc36c634ac18b4
nchanay/night-class
/python labs/contactoop.py
1,205
4
4
# contact list with OOP class ContactList: """ Contact list with class objects """ def __init__(self, csv=None, props=None): if csv is None: self.props = props self.contacts = {} else: self.load(csv) def load(self, csv): """ reads csv file and parses it into a dictionary of dictionaries """ with open(csv) as f: lines = f.read().split('\n') contact_list = {} props = lines[0].split(',') for i in range(1, len(lines)): row = lines[i].split(',') contact = dict(zip(props, row)) contact_list[contact['name']] = contact self.contacts = contact_list self.props = props def save(self, csv): contacts = [','.join(self.props)] for name in self.contacts: contact = self.contacts[name] contacts.append(','.join(contact.values())) with open(csv, 'w')as f: f.write('\n'.join(contacts)) return f'your file has saved' if __name__ == '__main__': contacts = ContactList('contacts.csv') print(contacts.contacts) print(contacts.props)
edc76bb95787df715aaad8814b7494b9626f516d
nsdeo12/thinkPython
/Data/5_Execption Handling/3_Exception_finally.py
810
3.609375
4
try: testfile = open('data.txt') try: txns = testfile.readlines() print ("File data = ",txns) finally: print ("In Inner finally") except IOError: print ('unable to access test file\n') finally: print ("In Outer finally") #testfile.close() print ("In END!!!!") """ 1) open('data11111.txt') this file does not exists >>> unable to access test file In Outer finally In END!!!! 2) testfile = open('data.txt') >>> File data = ['datalitics\n', 'Welcome to datalitics\n', 'Pune\n', '2015 BYE!!!!'] In Inner finally In Outer finally In END!!!! 3) testfile = open('data.txt') try: txns = testfile.readlines() print "File data = ",tx NameError """ """ if testfile <> None testfile.close() """
e186e1228ac647348157f1cc7fbd633399a577ea
t4d-classes/python_03222021_afternoon
/language_demos/dictionary2_demo.py
347
3.921875
4
person = { "first_name": "Bob", "last_name": "Smith" } # print(person["age"]) # print(person.get("age")) # print(person.get("first_name")) # if "age" not in person: # person["age"] = 34 # print(person["age"]) print(person.setdefault("age", 34)) print(person.popitem()) print(person.pop("address", "123 Oak Lane")) print(person)
6c46cddf38030d28f463267c8772ff3d1512c32c
ojhermann-ucd/comp10280
/p19p3.py
4,686
3.8125
4
""" Pseudocode create list of items we want to find, count, and compare create associated index list on each line: - count each bracket and associated partner - keep a running tally compare the counts and report accordingly """ import sys import os import datetime #list of strings to find in the document sList = ["(", ")", "[", "]", "{", "}", "<", ">"] countList = [] #i would have liked ot use a dictionary for i in sList: countList.append(0) #files readFile = "p19p3read.txt" recordFile = "p19p3record.txt" #existence variables readExist = os.path.isfile(readFile) recordExist = os.path.isfile(recordFile) #existence checks if not readExist: print(readFile, "does not exists.") sys.exit() if not recordExist: recordFile = open(recordFile, "w") recordFile.close() #program with open(readFile, "r") as reader: with open(recordFile, "a+") as writer: writer.write("in file ") writer.write(readFile) #identify the file writer.write("\n") #add a line after writer.write("at ") writer.write(str(datetime.datetime.now())) #add the datetime writer.write("\n") #add a line #count the shit for line in reader: for i in sList: countList[sList.index(i)] += line.count(i) #not necessary, but keeping for kicks with open(recordFile, "a+") as writer: for i in range(0, len(sList), 1): writer.write(str(sList[i])) #show character of interest; using str() in case future list contains non-string characters writer.write(" occurs ") writer.write(str(countList[i])) #show count of character of interest writer.write(" times.") writer.write("\n") writer.write("\n") #total count section print("") print("This section reports on the total occurances of the relevant brackets") for i in range(0, len(sList), 2): #compare each even indexed object with the next time, which by construction is its pair print(sList[i], "occurs", countList[i], "and", sList[i + 1], "occurs", countList[i + 1], end = "") if countList[i] == countList[i + 1]: print(", so they are balanced") else: print(", so they are not balanced", end = "") if countList[i] > countList[i + 1]: print("there are ", countList[i] - countList[i + 1], "more", sList[i], "than", sList[i + 1]) else: print("; there are ", countList[i + 1] - countList[i], "more", sList[i + 1], "than", sList[i]) print("") #( lb0 = [] #) rb0 = [] #[ lb1 = [] #] rb1 = [] #{ lb2 = [] #} rb2 = [] #< lb3 = [] #> rb3 = [] #collectionList collectionList = [lb0, rb0, lb1, rb1, lb2, rb2, lb3, rb3] with open(readFile, "r") as reader: lineCount = -1 for line in reader: lineCount += 1 #count each line for indexing cCount = -1 for c in line: cCount += 1 #count each character for indexing for i in range(0, len(sList), 1): if c == sList[i]: collectionList[i].append(str(lineCount) + str(cCount)) #index each occurance with a UID #Overview of balance print("This section gives an overview of the balance of brackets in", readFile) for r in range(0, len(sList), 2): leftLength = len(collectionList[r]) rightLength = len(collectionList[r + 1]) print("There are", str(leftLength), sList[r], "and", str(rightLength) , sList[r], end = ", so ") if leftLength < rightLength: print("there are", str(rightLength - leftLength), "more", sList[r + 1], "than", sList[r]) else: print("there are", str(leftLength - rightLength), "more", sList[r], "than", sList[r + 1]) print("") #location of bad guys print("This section identifies the position of illegal brackets in", readFile, "(it will be empty if there are no illegal brackets)") for r in range(1, len(sList), 2): rightLocation = 0 leftLocation = 0 rightList = collectionList[r] leftList = collectionList[r - 1] rightLength = len(rightList) leftLength = len(leftList) if rightLength == 0: for i in leftList: print("Illegal", sList[r - 1], "at line", str(i[0]), ", position", str(i[1::])) elif leftLength == 0: for i in rightList: print("Illegal", sList[r], "at line", str(i[0]), ", position", str(i[1::])) else: while leftLocation < len(leftList) and rightLocation < len(rightList): if leftList[leftLocation] < rightList[rightLocation]: leftLocation += 1 rightLocation += 1 else: print("Illegal", sList[r], "at line", str(rightList[rightLocation][0]), ", position", str(rightList[rightLocation][1::])) rightLocation += 1 for i in range(leftLocation, len(leftList), 1): print("Illegal", sList[r - 1], "at line", str(leftList[leftLocation][0]), ", position", str(leftList[leftLocation][1::])) for i in range(rightLocation, len(rightList), 1): print("Illegal", sList[r], "at line", str(rightList[rightLocation][0]), ", position", str(rightList[rightLocation][1::])) print("")
4494c79f8b28b0d03b657746752ad6b2f62e77a7
fabinhosp2/lista-exercicios-python
/aula001_Exe003/calcula.py
970
4.15625
4
class Calculadora: def soma(self, num1, num2): return num1 + num2 def sub(self, num1, num2): return num1 - num2 def multi(self, num1, num2): return num1 * num2 def divi(self, num1, num2): return num1 / num2 def calcula_todos(self, num1, num2): print(f'As operações de {num1} e {num2}:') print(f'de soma é: {str(self.soma(num1, num2))}') print(f'de subtração é: {str(self.sub(num1, num2))}') print(f'de multiplicação é: {str(self.multi(num1, num2))}') print(f'de divisão é: {str(self.divi(num1, num2))}') print('=-' * 30) print(f'As operações de {num1} e {num2} + 1:') print(f'de soma é: {str(self.soma(num1, num2) + 1)}') print(f'de subtração é: {str(self.sub(num1, num2) + 1)}') print(f'de multiplicação é: {str(self.multi(num1, num2) + 1)}') print(f'de divisão é: {str(self.divi(num1, num2) + 1)}')
7835e3bfdbaaa90472e8c155bef216d9a0af7d20
Aasthaengg/IBMdataset
/Python_codes/p02594/s904973923.py
94
3.890625
4
import math X = int(input()) if X>=30: aircon='Yes' else: aircon='No' print(aircon)