blob_id stringlengths 40 40 | repo_name stringlengths 5 127 | path stringlengths 2 523 | length_bytes int64 22 545k | score float64 3.5 5.34 | int_score int64 4 5 | text stringlengths 22 545k |
|---|---|---|---|---|---|---|
d63588c573c00bb82bff49d550579c3cf990dd65 | LordofEchoes/Chess-Dog | /src/Board.py | 11,639 | 3.78125 | 4 | # Board Class
from Pawn import Pawn
from Knight import Knight
from Rook import Rook
from Bishop import Bishop
from King import King
from Queen import Queen
class ChessBoard:
def __init__(self):
self.board = [[" " for y in range(0,8)] for x in range(0,8)]
self.white = list()
self.black = li... |
2ad2af28bbdf1156a0233b791b67eabc14e6f840 | ShadowHammer/MadProgram | /Mad Program v2/Mad Program v2/Mad_Program.py | 7,119 | 3.65625 | 4 | #!/usr/local/bin/python3
from tkinter import *;
import tkinter as tk;
import os;
x=650
y=600
xStr=str(x)
yStr=str(y)
def main():
#Jeg laver første et vindue der hedder "Window" med titlen Madprogram
exit = False;
window = tk.Tk();
window.title("Madprogram");
window.geometry(xStr+'... |
e33cba62b32510844bcffd1b37fb848a956e3db6 | xiaomingxian/python_base | /0.test/约瑟夫.py | 1,252 | 3.5 | 4 | def main():
nums = 41
call = 3
# 参数定义：
peoples = []
for _ in range(nums):
# True定义状态为活
peoples.append(True)
result = []
num = 1
# 主逻辑
while (any(peoples)): # peoples中存在任何True元素
# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
... |
3348e918fe036839ac9557f91721447a37d9762a | xiaomingxian/python_base | /1.xxm/day12_minweb/4元类/Demo2_自定义元类_函数.py | 798 | 3.859375 | 4 | # coding=utf-8
# 自定义元类---函数
def MyType(lname, fus, params):
# 还可以进行其他 操作 例如python3的类 都继承object 可以遍历 fus 判断元组内有没有object 没有就添加
new_params = {}
for name, value in params.items():
# 过滤魔法/私有属性
if not name.startswith('__'):
new_params[name.upper()] = value
return type(lname, fus,... |
61ac28fdd39bef0934f08ce87548696201676bb0 | xta/California_School_Dashboard_Rank | /utils/csv_to_json.py | 1,254 | 4.03125 | 4 | # -*- coding: utf-8 -*-
import sys
import csv
import json
'''
Purpose
Convert a CSV to a JSON file
Usage
python3 csv_to_json.py file_in.csv file_out.json json_key
'''
def row_count(file_name):
with open(file_name) as in_file:
return sum(1 for _ in in_file)
if __name__ == '__main__':
asser... |
bca635b61e7def60ba191c76fd712e11a7ff1a54 | zyx528750635/program | /Test.py | 564 | 3.59375 | 4 | # _*_ coding ：UTF-8 _*_
# 开发人员 ：52875
# 开发时间 ：2019/6/11 19:44
# 文件名称 ：Test.PY
# 开发工具 ：PyCharm
capital = []
lower_case = []
number = []
for i1 in range(48, 58):
capital.append(chr(i1))
for i2 in range(65, 91):
lower_case.append(chr(i2))
for i3 in range(97, 123):
number.append(chr(i3))
p... |
7864339b9651c8726e9f41f458d436498809aaed | Xphera/appservicios | /appServicios/utils/Utils/Validators.py | 1,215 | 3.59375 | 4 | import re
from datetime import datetime, date, timedelta
def es_alfanumerico(valor,espacios = False):
"""
Calcula si una cadena de caracteres contine unicamente caracteres alfanumericos.
r"^[A-zñÑáéíóúÁÉÍÓÚ0-9 ]+$"
:param valor: cadena a evaluar
:param espacios: (bool) indica si la cadena puede o n... |
f9dda5c9814a797933079ec9e5775f59e63b74e2 | fossabot/experiment_code | /python_tricks/two_nums.py | 756 | 3.734375 | 4 | # -*- coding: utf-8 -*-
# @Author: jerry
# @Date: 2017-09-25 21:40:27
# @Last Modified by: jerry
# @Last Modified time: 2017-09-25 21:45:54
class Solution:
"""
@param numbers : An array of Integer
@param target : target = numbers[index1] + numbers[index2]
@return : [index1 + 1, index2 + 1] (index1 ... |
9937bc16eff459c0432af59ac2a956d29b2d0b71 | cayennes/advent | /y2022-python/day02.py | 722 | 3.578125 | 4 | #!/usr/bin/env python3
with open("input/day02.txt") as input:
content = input.readlines()
def translate(item):
return {"A": 1, "B": 2, "C": 3,
"X": 1, "Y": 2, "Z": 3}.get(item)
def parse(lines):
return [[translate(them), translate(me)]
for them, me in [line.split() for line in l... |
4a4f0e71027d92fa172f78811993aa1d62e2a6c7 | JuveVR/Homework_5 | /Exercise_2.py | 2,650 | 4.21875 | 4 | #2.1
class RectangularArea:
"""Class for work with square geometric instances """
def __init__(self, side_a, side_b):
"""
Defines to parameters of RectangularArea class. Checks parameters type.
:param side_a: length of side a
:param side_b:length of side a
"""
sel... |
63d8370eb3efcfe1cebf11dbd2ffdd7c747b2a37 | SandraAcosta/Clase3 | /hola.py | 396 | 4.03125 | 4 | opc = True
while opc:
print "ingrese un numero"
x = input ()
if x >= 15 and x<=20:
print "estas muy viejo"
elif x>20 and x<=35:
print "eres un adulto contemporaneo"
elif x>35 and x<=150:
print "eres un nio"
else:
print "no creo que seas humano"
... |
b594e98ce3a62764b03ad9b8413425deeb12b452 | skasero/cs491project2 | /perceptron.py | 1,444 | 3.578125 | 4 | #!/usr/bin/python3
import numpy as np
# perceptron_train
# returns the weights and bias for training data
def perceptron_train(X,Y):
# This is used to fix arrays that have 0 as their labels instead of -1
for i in range(0,len(Y)):
if(Y[i] != 1):
Y[i] = -1
index = 0
countTo... |
0b0e1f3f55ae4faa409b1fefb704b577aebb6c87 | saicataram/MyWork | /DL-NLP/Assignments/Assignment4/vowel_count.py | 801 | 4.3125 | 4 | """
*************************************************************************************
Author: SK
Date: 30-Apr-2020
Description: Python Assignments for practice;
a. Count no of vowels in the provided string.
*************************************************************************************
"""
def vowel_c... |
bd557b8cb881b1a6a0832b347c6855289a7c7cef | saicataram/MyWork | /DL-NLP/Assignments/Assignment4/lengthofStringinList.py | 528 | 4.375 | 4 | """
*************************************************************************************
Author: SK
Date: 30-Apr-2020
Description: Python Assignments for practice;
a. Count length of the string in list provided.
*************************************************************************************
"""
string = ... |
ef2b6f193874dcd23a1b7bc269f293d7ac18244b | mdettlaff/mdettla | /si/lab07/tautologyCNF.py | 2,405 | 3.578125 | 4 | #!/usr/bin/env python
# -*- coding: UTF-8 -*-
u"""Sprawdzanie czy podana formuła jest tautologią.
Formuła musi być w koniunkcyjnej postaci normalnej (CNF).
Przykład: (p V q) & (~q V r V ~s) & (s V ~t)
"""
class Literal:
u"""Pojedynczy symbol lub jego zaprzeczenie."""
def __init__(self, symbol, negated):
... |
d4aa13f6bd5d92ad0445200c91042b1b72f8f4cc | lilianaperezdiaz/cspp10 | /unit4/Lperez_rps.py | 2,982 | 4.3125 | 4 | import random
#function name: get_p1_move
# arguments: none
# purpose: present player with options, use input() to get player move
# returns: the player's move as either 'r', 'p', or 's'
def get_p1_move():
move=input("rock, paper, scissors: ")
return move
#function name: get_comp_move():
# argum... |
17154fa6ddbb3a0604a4f4b9b367e31b8dbed84d | lilianaperezdiaz/cspp10 | /unit1/Lperez_calcCtoF.py | 114 | 3.84375 | 4 | c= input()
c= float(c)
x= c*1.8
f= x+32
print (f)
F_T=str(f)
C_T=str(c)
print (C_T + "c is equal to " + F_T +"F") |
2b48bf8b4c0f65c8a1335b26475981e42c27a040 | ankovachev/SoftUni | /PythonADV/99_temp_problems/05_temp_pronlem.py | 248 | 3.734375 | 4 | a = 8
b = 4
c = a % b
d = a // b
print(f"{a} % {b} = {c}")
print(f"{a} // {b} = {d}")
a = 7
b = 4
c = a % b
d = a // b
print(f"{a} % {b} = {c}")
print(f"{a} // {b} = {d}")
aa = 19
print(aa)
print(type(aa))
bb = str(aa)
print(bb)
print(type(bb)) |
795a6e76b637c347763aa7d308fde8d29d52618d | ankovachev/SoftUni | /PythonADV/99_temp_problems/04_temp_problem.py | 264 | 3.8125 | 4 | import datetime
input_data_string = "8:00:00"
hh, mm, ss = input_data_string.split(":")
hh = int(hh)
mm = int(mm)
ss = int(ss)
a = datetime.datetime(1,1,1,hh,mm,ss)
b = a + datetime.timedelta(0,3) # days, seconds, then other fields.
print(a.time())
print(b.time()) |
2f3907e4ab5e2741602a168acd996dae25d1942e | huhudaya/leetcode- | /LeetCode/414. 第三大的数.py | 792 | 4.03125 | 4 | '''
给定一个非空数组，返回此数组中第三大的数。如果不存在，则返回数组中最大的数。要求算法时间复杂度必须是O(n)。
示例 1:
输入: [3, 2, 1]
输出: 1
解释: 第三大的数是 1.
示例 2:
输入: [1, 2]
输出: 2
解释: 第三大的数不存在, 所以返回最大的数 2 .
示例 3:
输入: [2, 2, 3, 1]
输出: 1
解释: 注意，要求返回第三大的数，是指第三大且唯一出现的数。
存在两个值为2的数，它们都排第二。
'''
from typing import List
class Solution:
def thirdMax(self, nums: List[in... |
f1ea2b04d8f79bb038248a7e4e8c2d5ebbba804b | huhudaya/leetcode- | /LeetCode/718. 最长重复子数组(最长公共子串).py | 1,009 | 3.703125 | 4 | # 718. 最长重复子数组.py
"""
给两个整数数组 A 和 B ，返回两个数组中公共的、长度最长的子数组的长度。
示例 1:
输入:
A: [1,2,3,2,1]
B: [3,2,1,4,7]
输出: 3
解释:
长度最长的公共子数组是 [3, 2, 1]。
说明:
1 <= len(A), len(B) <= 1000
0 <= A[i], B[i] < 100
链接：https://leetcode-cn.com/problems/maximum-length-of-repeated-subarray
"""
'''
动态规划思路:
1.明确dp数组的含义
2.明确base case
3.找状态转义方程
'''
... |
5bb5db7dcf066421e712866a0a8760a9162bc436 | huhudaya/leetcode- | /LeetCode/220. 存在重复元素 III(滑动窗口)好题.py | 1,389 | 3.578125 | 4 | # 220. 存在重复元素 III.py
'''
给定一个整数数组，判断数组中是否有两个不同的索引 i 和 j
使得 nums [i] 和 nums [j] 的差的绝对值最大为 t
并且 i 和 j 之间的差的绝对值最大为 ķ
示例 1:
输入: nums = [1,2,3,1], k = 3, t = 0
输出: true
示例 2:
输入: nums = [1,0,1,1], k = 1, t = 2
输出: true
示例 3:
输入: nums = [1,5,9,1,5,9], k = 2, t = 3
输出: false
链接：https://leetcode-cn.com/problems/contains-d... |
6c18e8e7ca9ef641685aa5697279647ab2bccfd0 | huhudaya/leetcode- | /程序员面试金典/面试题 08.01. 三步问题.py | 1,142 | 3.546875 | 4 | '''
三步问题。有个小孩正在上楼梯，楼梯有n阶台阶，小孩一次可以上1阶、2阶或3阶。实现一种方法，计算小孩有多少种上楼梯的方式。结果可能很大，你需要对结果模1000000007。
示例1:
输入：n = 3
输出：4
说明: 有四种走法
示例2:
输入：n = 5
输出：13
提示:
n范围在[1, 1000000]之间
'''
# 备忘录递归
class Solution:
def waysToStep(self, n: int) -> int:
memo = {}
memo[1] = 1
memo[2] = 3
memo[3] = 4... |
b9de7839f4ea1618aa4156a14fd4a6ef5b1820f4 | huhudaya/leetcode- | /程序员面试金典/面试题 17.18. 最短超串.py | 1,429 | 3.546875 | 4 | '''
假设你有两个数组，一个长一个短，短的元素均不相同。
找到长数组中包含短数组所有的元素的最短子数组，其出现顺序无关紧要。
返回最短子数组的左端点和右端点，如有多个满足条件的子数组，返回左端点最小的一个。若不存在，返回空数组。
示例 1:
输入:
big = [7,5,9,0,2,1,3,5,7,9,1,1,5,8,8,9,7]
small = [1,5,9]
输出: [7,10]
示例 2:
输入:
big = [1,2,3]
small = [4]
输出: []
'''
import sys
from typing import List
from collections import defaultdict
c... |
3bd30ee8dd9bab158a29b9b912ad0f4e196d0f4e | huhudaya/leetcode- | /LeetCode/440. 字典序的第K小数字.py | 2,816 | 3.65625 | 4 | '''
给定整数 n 和 k，找到 1 到 n 中字典序第 k 小的数字。
注意：1 ≤ k ≤ n ≤ 109。
示例 :
输入:
n: 13 k: 2
输出:
10
解释:
字典序的排列是 [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]，所以第二小的数字是 10。
'''
'''
我们求字典序第k个就是上图前序遍历访问的第k节点！
但是不需要用前序遍历，如果我们能通过数学方法求出节点1和节点2之间需要走几步，减少很多没必要的移动。
其实只需要按层节点个数计算即可，图中节点1和节点2在第二层，因为n = 13，节点1可以移动到节点2（同一层）所以在第二层需要移动1步。
第... |
2a6f5d9565e734235fa1cc312a3af9a33d5c3eb8 | huhudaya/leetcode- | /剑指offer/面试题40. 最小的k个数.py | 10,029 | 4.03125 | 4 | '''
输入整数数组 arr ，找出其中最小的 k 个数。
例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4
示例 1：
输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]
示例 2：
输入：arr = [0,1,2,1], k = 1
输出：[0]
限制：
0 <= k <= arr.length <= 10000
0 <= arr[i] <= 10000
'''
from typing import List
# 排序 O(NlogN)
class Solution:
def getLeastNumbers(self, arr: List[in... |
1941b7e762054d1f0b6c674664d2abe0fe5bc52d | huhudaya/leetcode- | /LeetCode/092. 反转链表 II.py | 3,992 | 3.796875 | 4 | # 92. 反转链表 II.py
'''
反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。
说明:
1 ≤ m ≤ n ≤ 链表长度。
示例:
输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL
链接：https://leetcode-cn.com/problems/reverse-linked-list-ii
'''
# Definition for singly-linked list.
class ListNode:
def __init__(self, x):
self.val = x
self... |
abcd521c65b0628df20b5bbbd36d26eae35066ee | huhudaya/leetcode- | /剑指offer/面试题10- II. 青蛙跳台阶问题.py | 805 | 3.515625 | 4 | '''
一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
示例 1：
输入：n = 2
输出：2
示例 2：
输入：n = 7
输出：21
提示：
0 <= n <= 100
注意：本题与主站 509 题相同：https://leetcode-cn.com/problems/fibonacci-number/
链接：https://leetcode-cn.com/problems/qing-wa-tiao-tai-jie-wen-ti-lcof
'''
class Solu... |
bf80f7db8370374e52346a09c1a75fe38e225fbc | huhudaya/leetcode- | /基础算法/归并排序.py | 1,755 | 3.84375 | 4 | # 思路是利用递归 注意递归的三要素
# 一定要有递归结束条件，不断调用自身，不断向递归结束条件靠近
# 核心思想，先递归sort，然后merge,不同于快排，快排是先排序，然后递归子快排
# 谁小移动谁
# 使用递归的时候需要注意一点，当不需要返回值得时候 不需要return，当需要有返回值的时候，一定要设置return
# 归并排序的空间复杂度有点高啊!
# 每次都需要一个子的空间
def mergeSort(alist):
if len(alist) > 1:
mid = len(alist) // 2
# 当使用list[:], 此时left和right是两个新开辟的链表
... |
f7343791fa4a35d2c48a604fafe4e4f4f8fa3f81 | huhudaya/leetcode- | /LeetCode/042. 接雨水.py | 3,644 | 3.921875 | 4 | # 42. 接雨水.py
'''
给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1]
表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。
感谢 Marcos 贡献此图。
示例:
输入: [0,1,0,2,1,0,1,3,2,1,2,1]
输出: 6
链接：https://leetcode-cn.com/problems/trapping-rain-water
'''
class Solution:
def trap(self, height) -> int:
# 双... |
a5e08a21655b8bd6f47ceef4513d10131d968845 | huhudaya/leetcode- | /剑指offer/剑指 Offer 39. 数组中出现次数超过一半的数字.py | 761 | 3.734375 | 4 | '''
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。
示例 1:
输入: [1, 2, 3, 2, 2, 2, 5, 4, 2]
输出: 2
限制：
1 <= 数组长度 <= 50000
'''
from typing import List
class Solution:
def majorityElement(self, nums: List[int]) -> int:
if nums is None or nums == []:
return -1
n = len(nums)
... |
dd9b3784f2eaaf57245fa15eac92bb895a2c69a6 | huhudaya/leetcode- | /LeetCode/004.寻找两个有序数组的中位数.py | 9,067 | 3.71875 | 4 | # 004.寻找两个有序数组的中位数.py
'''
给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。
请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。
你可以假设 nums1 和 nums2 不会同时为空。
示例 1:
nums1 = [1, 3]
nums2 = [2]
则中位数是 2.0
示例 2:
nums1 = [1, 2]
nums2 = [3, 4]
则中位数是 (2 + 3)/2 = 2.5
链接：https://leetcode-cn.com/problems/median-of-two-sorted-arrays
'''
# 二分法！ O(... |
3d8ea548da4891dd0124ca4f67f366dd64fe1a9a | huhudaya/leetcode- | /程序员面试金典/面试题 03.05. 栈排序.py | 3,190 | 3.734375 | 4 | '''
栈排序。 编写程序，对栈进行排序使最小元素位于栈顶。最多只能使用一个其他的临时栈存放数据，但不得将元素复制到别的数据结构（如数组）中。该栈支持如下操作：push、pop、peek 和 isEmpty。当栈为空时，peek 返回 -1。
示例1:
输入：
["SortedStack", "push", "push", "peek", "pop", "peek"]
[[], [1], [2], [], [], []]
输出：
[null,null,null,1,null,2]
示例2:
输入：
["SortedStack", "pop", "pop", "push", "pop", "isEmpty"]
[[], ... |
67c285419da28e7fbf17626dff2515676dd97875 | huhudaya/leetcode- | /剑指offer/面试题62. 圆圈中最后剩下的数字.py | 8,016 | 3.765625 | 4 | '''
0,1,,n-1这n个数字排成一个圆圈，从数字0开始
每次从这个圆圈里删除第m个数字。求出这个圆圈里剩下的最后一个数字。
例如，0、1、2、3、4这5个数字组成一个圆圈
从数字0开始每次删除第3个数字
则删除的前4个数字依次是2、0、4、1，因此最后剩下的数字是3。
示例 1：
输入: n = 5, m = 3
输出: 3
示例 2：
输入: n = 10, m = 17
输出: 2
'''
# 约瑟夫环
# Python 默认的递归深度不够，需要手动设置
# 时间和空间复杂度都是O(N)
'''
题目中的要求可以表述为：给定一个长度为 n 的序列，每次向后数 m 个元素并删除，那么最终留下的是第几个元素？
这个问题... |
e879ba8849510b693486910878007d6769ba12b8 | huhudaya/leetcode- | /LeetCode/1497. 检查数组对是否可以被 k 整除.py | 1,697 | 3.65625 | 4 | '''
给你一个整数数组 arr 和一个整数 k ，其中数组长度是偶数，值为 n 。
现在需要把数组恰好分成 n / 2 对，以使每对数字的和都能够被 k 整除。
如果存在这样的分法，请返回 True ；否则，返回 False 。
示例 1：
输入：arr = [1,2,3,4,5,10,6,7,8,9], k = 5
输出：true
解释：划分后的数字对为 (1,9),(2,8),(3,7),(4,6) 以及 (5,10)
示例 2：
输入：arr = [1,2,3,4,5,6], k = 7
输出：true
解释：划分后的数字对为 (1,6),(2,5) 以及 (3,4) 。
示例 3：
输入：arr = [1,2,3,4... |
0dfe73a481072f62172baa987310c7d69e60d68c | huhudaya/leetcode- | /LeetCode/015.三数之和.py | 1,640 | 3.640625 | 4 | # 015三数之和.py
'''
给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c
使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。
例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]
'''
from typing import List
class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
l... |
9c6055411762ab85229ee62fe7722f0c069f0cb1 | huhudaya/leetcode- | /LeetCode/117. 填充每个节点的下一个右侧节点指针 II.py | 3,557 | 4.1875 | 4 | '''
给定一个二叉树
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。
进阶：
你只能使用常量级额外空间。
使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。
示例：
输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A 所示，你的函数应... |
314f6080e1b6184de80b92f5c93aceb064084d81 | huhudaya/leetcode- | /程序员面试金典/面试题 04.08. 首个共同祖先.py | 1,508 | 3.765625 | 4 | '''
设计并实现一个算法，找出二叉树中某两个节点的第一个共同祖先。不得将其他的节点存储在另外的数据结构中。注意：这不一定是二叉搜索树。
例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]
3
/ \
5 1
/ \ / \
6 2 0 8
/ \
7 4
示例 1:
输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出: 3
解释: 节点 5 和节点 1 的最近公共祖先是节点 3。
示例 2:
输入: root = [3,5,1,6,2,0,8,null,null,7,4], p... |
cd65bf7314fd8eec1d38d878d90fe5e2706bbcf2 | huhudaya/leetcode- | /LeetCode/1071. 字符串的最大公因子.py | 2,102 | 3.578125 | 4 | '''
对于字符串 S 和 T，只有在 S = T + ... + T（T 与自身连接 1 次或多次）时，我们才认定 “T 能除尽 S”。
返回最长字符串 X，要求满足 X 能除尽 str1 且 X 能除尽 str2。
示例 1：
输入：str1 = "ABCABC", str2 = "ABC"
输出："ABC"
示例 2：
输入：str1 = "ABABAB", str2 = "ABAB"
输出："AB"
示例 3：
输入：str1 = "LEET", str2 = "CODE"
输出：""
提示：
1 <= str1.length <= 1000
1 <= str2.length <= 1000
str1[... |
a0cb76c0ab71152237c883438b4bccb4538746a4 | huhudaya/leetcode- | /LeetCode/538. 把二叉搜索树转换为累加树.py | 1,443 | 3.953125 | 4 | '''
给定一个二叉搜索树（Binary Search Tree），把它转换成为累加树（Greater Tree)，使得每个节点的值是原来的节点值加上所有大于它的节点值之和。
例如：
输入: 原始二叉搜索树:
5
/ \
2 13
输出: 转换为累加树:
18
/ \
20 13
注意：本题和 1038: https://leetcode-cn.com/problems/binary-search-tree-to-greater-sum-tree/ 相同... |
dce0e479473783cf9dac90bcc29a51e8bddf7a6c | huhudaya/leetcode- | /LeetCode/504. 七进制数.py | 481 | 3.546875 | 4 | '''
给定一个整数，将其转化为7进制，并以字符串形式输出。
示例 1:
输入: 100
输出: "202"
示例 2:
输入: -7
输出: "-10"
注意: 输入范围是 [-1e7, 1e7] 。
'''
class Solution:
def convertToBase7(self, num: int) -> str:
res = ''
numAbs = abs(num)
while numAbs >= 7:
res += str(numAbs % 7)
numAbs //= 7
res += s... |
dc6f550f530d06980747d5b08c013a4381659075 | huhudaya/leetcode- | /剑指offer/剑指 Offer 58 - II. 左旋转字符串.py | 3,240 | 4.0625 | 4 | '''
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。
请定义一个函数实现字符串左旋转操作的功能。
比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
示例 1：
输入: s = "abcdefg", k = 2
输出: "cdefgab"
示例 2：
输入: s = "lrloseumgh", k = 6
输出: "umghlrlose"
限制：
1 <= k < s.length <= 10000
'''
class Solution:
def reverseLeftWords(self, s: str, n: int) -> str:
... |
ec603e4b049f85e770e5a83339158ea03a691e43 | huhudaya/leetcode- | /utils/list2ListNode.py | 279 | 3.625 | 4 | # list转链表
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
def list2ListNode(list) -> ListNode:
dummy = ListNode(-1)
pre = dummy
for i in list:
pre.next = ListNode(i)
pre = pre.next
return dummy.next
|
7f854aa0270fbc9ba330f77832100dfa2d7b2268 | huhudaya/leetcode- | /LeetCode周赛/201场(滴滴)/5471. 和为目标值的最大数目不重叠非空子数组数目.py | 2,884 | 3.78125 | 4 | '''
给你一个数组 nums 和一个整数 target 。
请你返回 非空不重叠 子数组的最大数目，且每个子数组中数字和都为 target 。
示例 1：
输入：nums = [1,1,1,1,1], target = 2
输出：2
解释：总共有 2 个不重叠子数组（加粗数字表示） [1,1,1,1,1] ，它们的和为目标值 2 。
示例 2：
输入：nums = [-1,3,5,1,4,2,-9], target = 6
输出：2
解释：总共有 3 个子数组和为 6 。
([5,1], [4,2], [3,5,1,4,2,-9]) 但只有前 2 个是不重叠的。
示例 3：
输入：nums = [-2,6,6,3,... |
d5c8375ef4991d2b93e2cf44731cf5c99fc5d0eb | huhudaya/leetcode- | /LeetCode/279. 完全平方数.py | 2,508 | 3.546875 | 4 | '''
给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, ...）使得它们的和等于 n
你需要让组成和的完全平方数的个数最少
示例 1:
输入: n = 12
输出: 3
解释: 12 = 4 + 4 + 4.
示例 2:
输入: n = 13
输出: 2
解释: 13 = 4 + 9.
'''
class Solution:
def numSquares(self, n: int) -> int:
from collections import deque
deq = deque()
visited = set()
deq.ap... |
9995fc4844044f119540a3ba65fb92a0c0a0c96f | huhudaya/leetcode- | /LeetCode/054. 螺旋矩阵.py | 10,379 | 3.6875 | 4 | # 54. 螺旋矩阵.py
'''
给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。
示例 1:
输入:
[
[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ]
]
输出: [1,2,3,6,9,8,7,4,5]
示例 2:
输入:
[
[1, 2, 3, 4],
[5, 6, 7, 8],
[9,10,11,12]
]
输出: [1,2,3,4,8,12,11,10,9,5,6,7]
链接：https://leetcode-cn.com/problems/spiral-matrix
'''
from typing impor... |
76d7b8dd3cb5a9d1016b5cad4be16f10eb41f97c | huhudaya/leetcode- | /牛客面经整理/字节跳动题库答案/数组/递增数组，找出和为k的数对.py | 1,603 | 3.671875 | 4 | '''
作者：星__尘
链接：https://www.nowcoder.com/discuss/428158?source_id=profile_create&channel=2002
来源：牛客网
输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。
如果有多对数字的和等于s，则输出任意一对即可。
双指针遍历：用头尾两个指针，分别开始遍历，两个数字和大于k时，右指针向前移动，小于k时左指针向后移动。
public class Solution{
public ArrayList findPair(int[] nums,int k){
int n = nums.length;
... |
072ff1b85f48cd538b30a2b5ec538e66d8b852e9 | huhudaya/leetcode- | /剑指offer/剑指 Offer 41. 数据流中的中位数.py | 5,140 | 3.96875 | 4 | '''
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。
例如，
[2,3,4] 的中位数是 3
[2,3] 的中位数是 (2 + 3) / 2 = 2.5
设计一个支持以下两种操作的数据结构：
void addNum(int num) - 从数据流中添加一个整数到数据结构中。
double findMedian() - 返回目前所有元素的中位数。
示例 1：
输入：
["MedianFinder","addNum","addNum","findMedian","addNum","fi... |
33ace2008b854afdf395976fd086d9945f07450a | huhudaya/leetcode- | /牛客企业真题/网易/网易2019实习生招聘编程题集合/安置路灯.py | 1,374 | 3.734375 | 4 | '''
链接：https://www.nowcoder.com/questionTerminal/3a3577b9d3294fb7845b96a9cd2e099c?answerType=1&f=discussion
来源：牛客网
小Q正在给一条长度为n的道路设计路灯安置方案。
为了让问题更简单,小Q把道路视为n个方格,需要照亮的地方用'.'表示, 不需要照亮的障碍物格子用'X'表示。
小Q现在要在道路上设置一些路灯, 对于安置在pos位置的路灯, 这盏路灯可以照亮pos - 1, pos, pos + 1这三个位置。
小Q希望能安置尽量少的路灯照亮所有'.'区域, 希望你能帮他计算一下最少需要多少盏路灯。
输入描述:
输... |
fb6746416698011bcc91af0d1cf07739cc1bc2ec | huhudaya/leetcode- | /剑指offer/剑指 Offer 45. 把数组排成最小的数.py | 2,536 | 3.625 | 4 | '''
输入一个非负整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。
示例 1:
输入: [10,2]
输出: "102"
示例 2:
输入: [3,30,34,5,9]
输出: "3033459"
'''
# 内置排序
# 相当于一个排序的过程，先两两排序？？好像是这样？
from typing import List
import functools
# lambda
class Solution:
def minNumber(self, nums: List[int]) -> str:
def sort_rule(x, y):
a... |
fa15fe01923ab0a9292aa47f6ed9cb085b0584e9 | huhudaya/leetcode- | /LeetCode/1200. 最小绝对差.py | 1,882 | 3.828125 | 4 | '''
给你个整数数组 arr，其中每个元素都 不相同。
请你找到所有具有最小绝对差的元素对，并且按升序的顺序返回。
示例 1：
输入：arr = [4,2,1,3]
输出：[[1,2],[2,3],[3,4]]
示例 2：
输入：arr = [1,3,6,10,15]
输出：[[1,3]]
示例 3：
输入：arr = [3,8,-10,23,19,-4,-14,27]
输出：[[-14,-10],[19,23],[23,27]]
提示：
2 <= arr.length <= 10^5
-10^6 <= arr[i] <= 10^6
'''
from typing import List
import sy... |
4b901a26128fa2ff67e3971ec306183b1b159ebf | huhudaya/leetcode- | /LeetCode/101. 对称二叉树.py | 4,076 | 3.890625 | 4 | '''
给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
1
/ \
2 2
/ \ / \
3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
1
/ \
2 2
\ \
3 3
进阶：
你可以运用递归和迭代两种方法解决这个问题吗？
'''
'''
做递归思考三步：
递归的函数要干什么？
函数的作用是判断传入的两个树是否镜像。
输入：TreeNode left, TreeNode right
输出：是：true，不是：false
递归停止的条件是什么？... |
def253879ce7208634a63076445b344ae983e547 | huhudaya/leetcode- | /LeetCode/445. 两数相加 II.py | 1,371 | 3.875 | 4 | '''
给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。
将这两数相加会返回一个新的链表。
你可以假设除了数字 0 之外，这两个数字都不会以零开头。
进阶：
如果输入链表不能修改该如何处理？换句话说，你不能对列表中的节点进行翻转。
示例：
输入：(7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 8 -> 0 -> 7
'''
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
class Solution:... |
12ac1e40db76d866ae6ce392be1291f44c9d4748 | huhudaya/leetcode- | /剑指offer/面试题06. 从尾到头打印链表.py | 1,155 | 3.71875 | 4 | '''
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
示例 1：
输入：head = [1,3,2]
输出：[2,3,1]
限制：
0 <= 链表长度 <= 10000
链接：https://leetcode-cn.com/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof
'''
# 递归&回溯
from typing import List
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
class Solution:
... |
a871052cb0a76ba2973b821eaf388d6eb969edb7 | huhudaya/leetcode- | /LeetCode/263. 丑数.py | 1,391 | 3.9375 | 4 | '''
编写一个程序判断给定的数是否为丑数。
丑数就是只包含质因数 2, 3, 5 的正整数。
示例 1:
输入: 6
输出: true
解释: 6 = 2 × 3
示例 2:
输入: 8
输出: true
解释: 8 = 2 × 2 × 2
示例 3:
输入: 14
输出: false
解释: 14 不是丑数，因为它包含了另外一个质因数 7。
说明：
1 是丑数。
输入不会超过 32 位有符号整数的范围: [−231, 231 − 1]。
通过次数37,727提交次数76,492
'''
'''
根据定义， 任何一个丑叔都可以写成 n = 2^i * 3^j * 5^k
（i,j,k都是幂，输入法不太方便写成指数... |
ffdbd0d3408efb44a6b75cc3a038fa0fbc78bd85 | huhudaya/leetcode- | /LeetCode/121.买卖股票的最佳时机.py | 2,564 | 3.546875 | 4 | '''
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。
注意你不能在买入股票前卖出股票。
示例 1:
输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
示例 2:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
'''
'''
如果反过来想，固定卖出时... |
ff64f836ab3076c4dbf89494e50f92205ecdbd60 | huhudaya/leetcode- | /剑指offer/剑指 Offer 59 - I. 滑动窗口的最大值.py | 1,605 | 3.828125 | 4 | '''
给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。
示例:
输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
输出: [3,3,5,5,6,7]
解释:
滑动窗口的位置 最大值
--------------- -----
[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 ... |
8695f8eef8d0a52cc0c53b3d1a5ba2671663b3d6 | huhudaya/leetcode- | /LeetCode/227. 基本计算器 II.py | 3,242 | 4 | 4 | '''
实现一个基本的计算器来计算一个简单的字符串表达式的值。
字符串表达式仅包含非负整数，+， - ，*，/ 四种运算符和空格 。 整数除法仅保留整数部分。
示例 1:
输入: "3+2*2"
输出: 7
示例 2:
输入: " 3/2 "
输出: 1
示例 3:
输入: " 3+5 / 2 "
输出: 5
说明：
你可以假设所给定的表达式都是有效的。
请不要使用内置的库函数 eval。
'''
'''
那么，为什么说处理括号没有看起来那么难呢，因为括号具有递归性质。我们拿字符串3*(4-5/2)-6举例：
calculate(3*(4-5/2)-6)
= 3 * calculate(4-5/2) - 6
= 3 ... |
b41b72cd3745377db2e1c6368d835ace44d49a15 | huhudaya/leetcode- | /LeetCode/098. 验证二叉搜索树.py | 3,106 | 3.96875 | 4 | # 098. 验证二叉搜索树.py
'''
给定一个二叉树，判断其是否是一个有效的二叉搜索树。
假设一个二叉搜索树具有如下特征：
节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
示例 1:
输入:
2
/ \
1 3
输出: true
示例 2:
输入:
5
/ \
1 4
/ \
3 6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
根节点的值为 5 ，但是其右子节点值为 4 。
链接：https://leetcode-cn.com/pr... |
d717960b2780b50a21f2ce7e1a586d08c2937f38 | huhudaya/leetcode- | /LeetCode/212. 单词搜索 II.py | 2,593 | 4.21875 | 4 | '''
给定一个二维网格 board 和一个字典中的单词列表 words，找出所有同时在二维网格和字典中出现的单词。
单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。
同一个单元格内的字母在一个单词中不允许被重复使用。
示例:
输入:
words = ["oath","pea","eat","rain"] and board =
[
['o','a','a','n'],
['e','t','a','e'],
['i','h','k','r'],
['i','f','l','v']
]
输出: ["eat","oath"]
说明:
你可以假设所有输入都由... |
3b7e11f98e9c3d65a5aacf43f3b2ca6bbb932d86 | aljohn0422/implementation-practices-in-python | /structure/hash_table.py | 788 | 3.578125 | 4 | class HashTable:
def __init__(self):
self.table = [[] for _ in range(8)]
def __len__(self):
return len(self.table)
def _hash(self, key):
return key % len(self)
def put(self, key: int, value: int):
k = self._hash(key)
for i in self.table[k]:
if i[0] ... |
be3762d1ea5c2b35419f3f5474966d03ac6fd935 | sdeck51/ECE440 | /socketlab/client.py | 491 | 3.5 | 4 | from socket import *
import sys
print
# Create a TCP/IP socket
client = socket(AF_INET, SOCK_STREAM)
#Connect the socket to the port on the server given by the caller
server_address = (sys.argv[1],((int)(sys.argv[2])))
client.connect(server_address)
target = "GET " + sys.argv[3]
print "Request: ",target
client.send(tar... |
c5d224a3d63d0d67bc7a48fecec156cca41cdcf7 | Lundgren/ud120-intro-ml | /datasets_questions/explore_enron_data.py | 2,138 | 3.578125 | 4 | #!/usr/bin/python
"""
Starter code for exploring the Enron dataset (emails + finances);
loads up the dataset (pickled dict of dicts).
The dataset has the form:
enron_data["LASTNAME FIRSTNAME MIDDLEINITIAL"] = { features_dict }
{features_dict} is a dictionary of features associated with that pers... |
85b9813120fefce2862cf92ee43f5918752dcef3 | shalinc/Facebook-Community-Detection-and-Link-Prediction | /FBCommunityDetectionAndLinkPrediction.py | 17,194 | 3.75 | 4 | # coding: utf-8
#
# In this assignment, we'll implement community detection and link prediction algorithms using Facebook "like" data.
# The file `edges.txt.gz` indicates like relationships between facebook users. This was collected using snowball sampling: beginning with the user "Bill Gates", I crawled all the peopl... |
97a8acae73ec9910ccb864c9d55e3af9812099b3 | ManskeTierling/crud_python_mysql | /programa.py | 535 | 3.84375 | 4 | from funcao import add, delete, read
while True:
print('======== BANCO DE DADOS ========')
nome = str(input('Nome: '))
sobrenome = str(input('Sobrenome: '))
cpf = input('CPF: ')
email = input('E-mail: ')
telefone = int(input('Telefone: '))
print('''======== OPÇÕES ========
1. Adicionar
2. D... |
7919a0df0d90864e041d2d0653f4979a42a7bdd5 | MaattiiP/basics-exe2-py | /ej-12-pr2.py | 677 | 3.59375 | 4 | #-*- coding: utf-8 -*-
"""
dominoInfinite: No recibe argumentos --> No devuelve valores
Pide al usuario ingresar la cantidad de fichas a generar
Imprime en pantalla las fichas
"""
def dominoInfinite ():
print ("Muestra en pantalla las fichas de domino")
cantFichas = int(input("Ingrese ... |
4a79f1684dde29b3840959b65988c53ba523b03c | kchatr/sudoku-solver | /sudoku-solver.py | 4,529 | 4.03125 | 4 | '''
Representation of a traditional 9x9 sudoku board
A1 A2 A3| A4 A5 A6| A7 A8 A9
B1 B2 B3| B4 B5 B6| B7 B8 B9
C1 C2 C3| C4 C5 C6| C7 C8 C9
---------+---------+---------
D1 D2 D3| D4 D5 D6| D7 D8 D9
E1 E2 E3| E4 E5 E6| E7 E8 E9
F1 F2 F3| F4 F5 F6| F7 F8 F9
---------+---------+---------
G1 G2 G3| G4 G5 G6| G7 G... |
287660ee7a1580903b9815b83106e8a5bd6e0c20 | 5folddesign/100daysofpython | /day_002/day_004/climbing_record_v4.py | 2,228 | 4.15625 | 4 | #python3
#climbing_record.py is a script to record the grades, and perceived rate of exertion during an indoor rock climbing session.
# I want this script to record: the number of the climb, wall type, grade of climb, perceived rate of exertion on my body, perceived rate of exertion on my heart, and the date and time... |
6367b485bbbeb065dc379fa1164072db6bac22e4 | risbudveru/machine-learning-deep-learning | /Machine Learning A-Z/Part 2 - Regression/Section 4 - Simple Linear Regression/Simple linear reg Created.py | 1,590 | 4.3125 | 4 | import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
# Importing the dataset
#X is matrix of independent variables
#Y is matrix of Dependent variables
#We predict Y on basis of X
dataset = pd.read_csv('Salary_data.csv')
X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 1].values
# Spli... |
2af39a5f4a74ed28d2b963356e18cc9916f31b6c | Patrick-Akbar/cellular-automata-classification | /Grid.py | 7,249 | 3.875 | 4 | import pygame
#Grid object used to analyse and display the results of an automaton
class Grid:
def __init__(self, k, data):
#Input data is a nested list (technically a list of strings, but strings are lists of characters in Python, and the Grid object treats it like an ordinary list)
self.dat... |
9c82f1f5345319c662956dfdc74772e7500859eb | aishwaryaiyer22/Leetcode-Problems | /binary_tree/bin_tree_to_dll.py | 592 | 3.515625 | 4 | class Node :
def __init__(self, key):
self.left = null
self.right = null
self.key = key
def listify(Node root):
if root is None:
return (None, None)
(left_first, left_last) = listify(root.left)
(right_first, right_last) = listify(root.right)
first = last = root
... |
8e34c6ba21a8ee19cb1f3281ebdf704a9c729064 | gammay/nltk_building_blocks | /nltk_building_blocks/01_nltk_tokenize.py | 609 | 3.859375 | 4 | text = "Computers don't speak English. So, we've to learn C, C++, ,C#, Java, Python and the like! Yay!"
from nltk.tokenize import sent_tokenize
sentences = sent_tokenize(text)
print(len(sentences), 'sentence(s): ', sentences)
from nltk.tokenize import word_tokenize
words = word_tokenize(text)
print(len(words)... |
a336bcd22bf55b68efd3208717461f207984f6e3 | renan09/Assignments | /Python/PythonAssignments/Assign6/MainmathsNew.py | 657 | 4 | 4 | #6. Implement a child class called mathnew and
# parent classes as sqroot, addition, subtraction, multiplication and division.
# Use the super () function to inherit the parent methods.
from addition import addition
from multiplication import multiplication
from substraction import substraction
from division import ... |
84c9145c5802f5f1b2c2e70b8e2038b573220bd5 | renan09/Assignments | /Python/PythonAssignments/Assign8/fibonacci2.py | 489 | 4.15625 | 4 | # A simple generator for Fibonacci Numbers
def fib(limit):
# Initialize first two Fibonacci Numbers
a, b = 0, 1
# One by one yield next Fibonacci Number
while a < limit:
yield a
#print("a : ",a)
a, b = b, a + b
#print("a,b :",a," : ",b)
# Create a gener... |
6bf37dd7d6c725e8f636d765e7a21f11695e5b86 | knimini/python-szkolenia | /tut2/zagadnienia.py | 1,448 | 3.671875 | 4 | 'generatory wyjatki list comperhensions klasy'
'''
List comperhension
'''
l = []
for i in range(5):
l.append(i**2)
l = [x**2 for x in range(5)]
zdanie = 'Chciałbym aby te zdanie było w uppercase'
nowe_zdanie = ''
for slowo in zdanie.split():
nowe_zdanie += slowo.upper() + ' '
nowe_zdanie = ' '.join(slowo.upp... |
20aeb42d6e83f5d770210661e6b91687d8e5aceb | knimini/python-szkolenia | /tut2/live.py | 627 | 3.5 | 4 | from PIL import Image
im = Image.open('eye.jpg')
im.show()
img2 = im.copy()
width, height = img2.size
img3 = im.copy()
width2, height2 = img3.size
def change_pixels(width, height, img, fun):
for i in range(width):
for j in range(height):
val = img.getpixel((i,j))
new_val = fun(val... |
7f5d6dfb709196cd256775f299bc97360c3cf742 | knimini/python-szkolenia | /tut1/dict_comprehensions.py | 248 | 3.84375 | 4 | # generate a dictionary where the keys are numbers between 1 and 20 (both included) and the values are square of keys.
d=dict()
for i in range(1,21):
d[i]=i**2
for (k,v) in d.items():
print (v)
#
d = {k:k**2 for k in range(1,21)}
print(d)
|
92f047b095d3baca823813e530dfec6433708230 | HappySusan2016/blueberry-berry-development | /scripts/fix_scaff13.py | 999 | 3.78125 | 4 | """
Created on July 21, 2020
Author: Jiali
This script is used to flip the sequences
Usage: python fix_scaff13.py <input_fasta.fa> <int> <output.fasta>
"""
import argparse
parser=argparse.ArgumentParser(description="takes a location to break the sequences and flip the two parts")
parser.add_argument("-i", help="input ... |
b54367b39a36de6fd5b12c82a2f0f056417af979 | Alopezm5/CORRECTO-2 | /.history/leccion_20210910224928.py | 430 | 3.78125 | 4 | from datetime import date
class Calculos:
def antiguedad(self,fecha):
hoy=date.today()
if hoy<fecha:
return -1
else:
anio=fecha.year
mes=fecha.month
dia=fecha.day
aa=0
while fecha<hoy:
aa=1
... |
19f81e94e74490c234194513b23c2ed309501cc7 | BarbosaKO/trabalhos-da-faculdade | /4-Semestre/Complexidade_de_algoritmos/Lista_Exercicios/oDesafioDoMonge.py | 232 | 3.640625 | 4 | def func_Secreta(a):
if a == 0:
return 10
elif a == 1:
return 11
elif a == 2:
return 27
else:
return func_Secreta(a-2)-func_Secreta(a-3)
while True:
try:
print(func_Secreta(int(input())))
except:
break |
0d9361c9c0986457fc8746620131d8f0ba1d4bcd | sudhakumari2/dictionary | /question8dic.py | 295 | 3.859375 | 4 | # question number 8
students=[]
marks=[]
i=1
while i<=10:
student=input("enter sudent name")
students.append(student)
j=1
while j<=1:
num=int(input("enter marks"))
marks.append(num)
j+=1
i+=1
dictionary = dict(zip(students, marks))
print(dictionary)
|
79099101426b667a5e9ebb94cd6d845d14510d67 | leobalestra/pyhton-jogo-aprendendo-logica-fatec | /Jogo1.py | 1,579 | 3.5625 | 4 | # Leonardo Balestra
from random import randint
min = 0
max = 500
x = -5
N = []
qtd = 0
print("\n************************************************************************")
print("**** Jogo 1 - Aprendendo Lógica em Python - FATEC-SP - Prof. Banin ****")
print("***********************************************... |
f841df5254e7753090d9c4e6dfc96e931e35b4a4 | lovely7261/loop_question | /oil.py | 485 | 3.6875 | 4 | #i=1
#while(i<=5):
# print(i)
#i=i+1
# j=5
# while(j>=1):
# j=j-1
# print(j,end=" ")
#print()
#i=0
#while(i<6):
# i=i+1
# print(i," ")
#j=1
#hile(i<5):
#j=j-1
# print(j, end=" ")
# j=j+1
#print( )
#i=1
#while (i<=10):
#i=i*10
#print(i)
#num=... |
4072264b3f46fcddd7e80a9fba54f1a2989d5832 | lovely7261/loop_question | /lovelypy/if-elis.py | 84 | 3.78125 | 4 | a=10
b=90
if a<b:
print("a is less then")
else:
print("b is less then ") |
329452b90db7dbd9bfe28cf736dd0ec7e450cfad | lovely7261/loop_question | /asciinumbers.py | 178 | 3.671875 | 4 | asciiNumber = 65
for i in range(0, 7):
for j in range(0, i + 2):
character = chr(asciiNumber)
print(character, end=' ')
asciiNumber +=1
print(" ") |
8fa278a0adcf19426d8b40a82aa53992b685341a | itssekhar/Pythonpractice | /oddandeven.py | 515 | 4.125 | 4 | num=int(input("enter a numer:"))
res=num%2
if(res>0):
print("odd number")
else:
print("even number")
""" Using function"""
def Number(n):
res=n%2
if res>0:
return "odd"
else:
return "even"
Number(2)
"""Using main function for to find an even and odd number """
def tofin... |
8d94d4003ca9643269ccdff48e8f8aa5d18b478c | JayRuiz/Python_example | /token_ex.py | 270 | 3.796875 | 4 |
input = 'Jay, Kim, 1971, 10, 17, male'
tokens = input.split(',')
firstName = tokens[0]
lastName = tokens[1]
birthDate = (int(tokens[2]), int(tokens[3]), int(tokens[4]))
isMale = (tokens[5] == 'male')
print 'Howday!', firstName, lastName
print 'Birthday', birthDate
|
ae0a94e2ffe6ca2cc64b67a4e0ec5c26d72beae0 | s3nt1n3lz21/myRaspberryPiProjects | /buttonMultiLED/ButtonLightWater.py | 4,231 | 3.84375 | 4 | ########################################################################
# Filename : ButtonLightWater.py
# Description : Button To Control Display Of A 10 LED Bar Graph
# Author : Neil Smith
# First Created : 14/07/2019
# Last Modification : 18/07/2019
#####################################################... |
7559742af5047e836ba22d3c8f6717aa7e9308c0 | zaego123/onedrive-public | /py_learn/def_gerator/def_genrator.py | 5,591 | 3.875 | 4 | 通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。
要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：
>>> L = [x * x for x in r... |
b81c2a8c1f52ea5077b70a41950bba9e5282a400 | zaego123/onedrive-public | /py_learn/slice-iter-etc.py | 2,884 | 3.90625 | 4 | #slice切片
L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
L[0,3]
#记住倒数第一个元素的索引是-1。
前10个数，每两个取一个：
>>> L[:10:2]
[0, 2, 4, 6, 8]
所有数，每5个取一个：
>>> L[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]
字符串'xxx'也可以看成是一种list，每个元素就是一个字符。
#迭代
只要是可迭代对象，无论有无下标，都可以迭代，比如dict就可以迭代：
>>> d = {'a': 1, 'b... |
8c8bdde3a57ec94e2ae2ce4d52366a95be422ea0 | sasschaps/learning | /python/random.py | 176 | 3.6875 | 4 | def bob():
print "Hello Sarah"
print "Hello Sarah"
print "Hello Sarah"
def sum(a, b):
c = 23
if c > b:
return c - 100
else:
return a + b
bob()
print sum(13, 107)
|
be1a6beb03d6f54c3f3d42882c84031cd415dc83 | shaversj/100-days-of-code-r2 | /days/27/longest-lines-py/longest_lines.py | 675 | 4.25 | 4 | def find_longest_lines(file):
# Write a program which reads a file and prints to stdout the specified number of the longest lines
# that are sorted based on their length in descending order.
results = []
num_of_results = 0
with open(file) as f:
num_of_results = int(f.readline())
for... |
049c5f71fc8d8203517c0e7991288da1662c134f | shaversj/100-days-of-code-r2 | /days/30/flavius-josephus/flavius-josephus-py.py | 1,058 | 3.953125 | 4 | def flavius_josephus(num_of_people, nth_person):
people = create_list_of_people(num_of_people)
# https://stackoverflow.com/questions/12444979/josephus-problem-using-list-in-python
nth_person -= 1 # pop automatically skips the dead guy
idx = nth_person
while len(people) > 1:
print(people.po... |
f99e68cfa634143883bfce882bc3b399bf1f1fcf | shaversj/100-days-of-code-r2 | /days/08/llist-py/llist.py | 862 | 4.21875 | 4 | class Node:
def __init__(self, data):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = None
def add(self, data):
new_node = Node(data)
node = self.head
# Get to the last node
previous = None
while node is... |
96d5b125384cd37755b0025d9699bd6b656b601c | shaversj/100-days-of-code-r2 | /days/39/rotation-py/solution.py | 760 | 3.875 | 4 | def is_rotation(word, rotated_word):
from collections import deque
d = deque(word)
count = 0
while count != len(word):
d.rotate(1)
print(d)
if "".join(d) == rotated_word:
return True
else:
count += 1
return False
# print(is_rotation("Hello",... |
f09add834a1e9f6dcc740d80a079c249d3e9cde4 | DiwakarBasnet/OpenCV | /Vehicles and Pedestrians/detect_in_image.py | 1,069 | 3.6875 | 4 | import cv2
# create opencv image
img = cv2.imread('highway.png')
#img = cv2.imread('pedestrian.jpg')
# Pre-trained classifier
car_tracker_file = 'cars.xml'
pedestrian_tracker_file = 'full_body.xml'
# create classifier
car_tracker = cv2.CascadeClassifier(car_tracker_file)
pedestrian_tracker = cv2.CascadeC... |
97c33a577ecada5c7ed5d493230f6fbed1b16c85 | GR-python/solved-problems | /askisi5.py | 1,577 | 3.703125 | 4 | """
Να γραφεί πρόγραμμα, το οποίο διαβάζει από το πληκτρολόγιο Π
μονοψήφιους θετικούς ακεραίους αριθμούς και εκτυπώνει τους αριθμούς και το πλήθος εμφάνισής τους
κατά αύξουσα σειρά πλήθους εμφανίσεων (όπου Π τα 2 τελευταία ψηφία του ΑΜ σας).
"""
def repetition(p):
a=[0,1,2,3,4,5,6,7,8,9]
b=[0]*10
while sum(b)... |
949df4a00dae19b12ba6a155c341e4082d162129 | wslxko/LeetCode | /hot100/number2.py | 1,064 | 3.78125 | 4 | '''
给定一个范围在 1 ≤ a[i] ≤ n ( n = 数组大小 ) 的 整型数组，数组中的元素一些出现了两次，另一些只出现一次。
找到所有在 [1, n] 范围之间没有出现在数组中的数字。
您能在不使用额外空间且时间复杂度为O(n)的情况下完成这个任务吗? 你可以假定返回的数组不算在额外空间内。
示例:
输入:
[4,3,2,7,8,2,3,1]
输出:
[5,6]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-all-numbers-disappeared-in-an-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明... |
1b674c9fc4380e20bd33d2e1d67cafbb3560e85a | wslxko/LeetCode | /tencentSelect/number30在排序数组中查找元素的第一个和最后一个位置.py | 1,260 | 3.796875 | 4 | '''
给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
你的算法时间复杂度必须是 O(log n) 级别。
如果数组中不存在目标值，返回 [-1, -1]。
示例 1:
输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]
示例 2:
输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-first-and-last-position-of-element... |
891c3407ec43e164c92155019f8ca7de69b8f687 | wslxko/LeetCode | /tencentSelect/number28下一个排列.py | 1,052 | 3.828125 | 4 | '''
实现获取下一个排列的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。
如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
必须原地修改，只允许使用额外常数空间。
以下是一些例子，输入位于左侧列，其相应输出位于右侧列。
1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/next-permutation
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
'''
import itertools
class Solution... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.