diff --git a/.gitignore b/.gitignore index 99efc91..b6e4761 100644 --- a/.gitignore +++ b/.gitignore @@ -127,4 +127,3 @@ dmypy.json # Pyre type checker .pyre/ -.DS_Store diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index de288e1..0000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "python.formatting.provider": "black" -} \ No newline at end of file diff --git "a/Python\345\237\272\347\241\200\347\237\245\350\257\206/\345\237\272\347\241\200\346\225\260\346\215\256\347\261\273\345\236\213/\345\255\227\347\254\246\344\270\262.md" "b/Python\345\237\272\347\241\200\347\237\245\350\257\206/\345\237\272\347\241\200\346\225\260\346\215\256\347\261\273\345\236\213/\345\255\227\347\254\246\344\270\262.md" deleted file mode 100644 index e69de29..0000000 diff --git "a/Python\345\237\272\347\241\200\347\237\245\350\257\206/\350\257\255\346\263\225/lambda\350\257\255\346\263\225.md" "b/Python\345\237\272\347\241\200\347\237\245\350\257\206/\350\257\255\346\263\225/lambda\350\257\255\346\263\225.md" deleted file mode 100644 index c73ad65..0000000 --- "a/Python\345\237\272\347\241\200\347\237\245\350\257\206/\350\257\255\346\263\225/lambda\350\257\255\346\263\225.md" +++ /dev/null @@ -1,251 +0,0 @@ -# Lambda语法详解 - -## 一、lambda 语法 - -- lambda 函数的语法只包含一个语句，表现形式如下： - `lambda [arg1 [,arg2,.....argn]]:expression` -- 其中，lambda 是 Python 预留的关键字，\[arg…\] 和 expression 由用户自定义。 -- 具体介绍如下: - **\[arg…\] 是参数列表**，它的结构与 Python 中函数(function)的参数列表是一样的。 - \[arg…\] 可以有非常多的形式。例如： - - ```python3 - a, b - a=1, b=2 - *args - **kwargs - a, b=1, *args - 空 - ...... - ``` - - **expression 是一个参数表达式**，表达式中出现的参数需要在`[arg......]`中有定义，并且表达式只能是单行的，只能有一个表达式。 - 以下都是合法的表达式： - - ```python3 - 1 - None - a + b - sum(a) - 1 if a >10 else 0 - ...... - ``` - -## 二、lambda 特性 - -- **lambda 函数是匿名的：** - 所谓匿名函数，通俗地说就是没有名字的函数。lambda函数没有名字。 -- **lambda 函数有输入和输出：** - 输入是传入到参数列表argument\_list的值，输出是根据表达式expression计算得到的值。 -- **lambda 函数拥有自己的命名空间：** - 不能访问自己参数列表之外或全局命名空间里的参数，只能完成非常简单的功能。 - 常见的lambda函数示例： - - ```python3 - lambda x, y: x*y# 函数输入是x和y，输出是它们的积x*y - lambda:None# 函数没有输入参数，输出是None - lambda *args: sum(args)# 输入是任意个数参数，输出是它们的和(隐性要求输入参数必须能进行算术运算) - lambda **kwargs: 1# 输入是任意键值对参数，输出是1 - ``` - -## 三、lambda 常见用法 - -由于[lambda](https://so.csdn.net/so/search?q=lambda&spm=1001.2101.3001.7020)语法是固定的，其本质上只有一种用法，那就是定义一个lambda函数。 -在实际中，根据这个lambda函数应用场景的不同，可以将lambda函数的用法扩展为以下几种： - -- **1、将lambda函数赋值给一个变量，通过这个变量间接调用该lambda函数。** - **示例：** - `add = lambda x, y: x+y` - 相当于定义了加法函数`lambda x, y: x+y`，并将其赋值给变量`add`，这样变量`add`就指向了具有加法功能的函数。 - 这时我们如果执行`add(1, 2)`，其输出结果就为 `3`。 - -- **2、将lambda函数赋值给其他函数，从而将其他函数用该lambda函数替换。** - **示例：** - - ```python3 - # 为了把标准库time中的函数sleep的功能屏蔽(Mock)，我们可以在程序初始化时调用： - time.sleep=lambda x: None - # 这样，在后续代码中调用time库的sleep函数将不会执行原有的功能。 - # 例如： - time.sleep(3)# 程序不会休眠 3 秒钟，而是因为lambda输出为None，所以这里结果是什么都不做 - ``` - -- **3、将lambda函数作为参数传递给其他函数。** - 典型的用法就是下面我们常见的几种高阶函数。 - -## 四、lambda 用法之高阶函数 - -- **map() 函数：** - **描述：** - map() 会根据提供的函数对指定序列做`映射`。 - 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。 - **语法：** - `map(function, iterable, ...)` - **参数：** - function ----> 函数 - iterable ----> 一个或多个序列 - **返回值：** - Python 2.x 版本返回的是列表 - Python 3.x 版本返回的是迭代器 - **示例：** - - ```python3 - # ===========一般写法：=========== - # 1、计算平方数 - def square(x): - return x ** 2 - - map(square, [1,2,3,4,5])# 计算列表各个元素的平方 - # 结果： - [1, 4, 9, 16, 25] - - # ===========匿名函数写法：============ - # 2、计算平方数，lambda 写法 - map(lambda x: x ** 2, [1, 2, 3, 4, 5]) - # 结果： - [1, 4, 9, 16, 25] - - # 3、提供两个列表，将其相同索引位置的列表元素进行相加 - map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) - # 结果： - [3, 7, 11, 15, 19] - - ``` - -- **reduce() 函数：** - **描述：** - reduce() 函数会对参数序列中`元素进行累积`。 - 函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。 - - **语法：** - `reduce(function, iterable[, initializer])` - **参数：** - function  ----> 函数，有两个参数 - iterable   ----> 可迭代对象 - initializer ----> 可选，初始参数 - **返回值：** - 返回函数计算结果。 - - **实例：** - - ```python3 - # ===========一般写法：=========== - # 1、两数相加 - def add(x, y): - return x + y - - reduce(add, [1, 3, 5, 7, 9]) # 计算列表元素和：1+3+5+7+9 - # 结果： - 25 - - """ - ===========执行步骤解析：=========== - 调用 reduce(add, [1, 3, 5, 7, 9])时，reduce函数将做如下计算： - 1先计算头两个元素：f(1, 3)，结果为4； - 2再把结果和第3个元素计算：f(4, 5)，结果为9； - 3再把结果和第4个元素计算：f(9, 7)，结果为16； - 4再把结果和第5个元素计算：f(16, 9)，结果为25； - 5由于没有更多的元素了，计算结束，返回结果25。 - """ - # ===========匿名函数写法：=========== - # 2、两数相加，lambda 写法 - reduce(lambda x, y: x + y, [1, 2, 3, 4, 5]) - # 结果： - 15 - - # 当然求和运算可以直接用Python内建函数sum()，没必要动用reduce。 - - # 3、但是如果要把序列 [1, 3, 5, 7, 9] 变换成整数 13579，reduce就可以派上用场： - from functools import reduce - - def fn(x, y): - return x * 10 + y - - reduce(fn, [1, 3, 5, 7, 9]) - # 结果： - 13579 - ``` - -- **sorted() 函数：** - **描述：** - sorted() 函数对所有可迭代的对象进行`排序操作`。 - - **sort 与 sorted 区别：** - sort 是 list 的一个方法，而 sorted 可以对所有可迭代的对象进行排序操作。 - list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。 - - **语法：** - `sorted(iterable[, cmp[, key[, reverse]]])` - **参数说明：** - iterable ----> 可迭代对象。 - cmp ----> 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。 - key ----> 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。 - reverse ----> 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。 - **返回值：** - 返回重新排序的列表。 - - **示例：** - - ```python3 - # ===========一般用法：=========== - # 1、简单排序 - a = [5,7,6,3,4,1,2] - b = sorted(a) # 使用sorted，保留原列表，不改变列表a的值 - print(a) - [5, 7, 6, 3, 4, 1, 2] - print(b) - [1, 2, 3, 4, 5, 6, 7] - - # ===========匿名函数用法：=========== - L=[('b',2),('a',1),('c',3),('d',4)] - # 2、利用参数 cmp 排序 - sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) - # 结果： - [('a', 1), ('b', 2), ('c', 3), ('d', 4)] - # 3、利用参数 key 排序 - sorted(L, key=lambda x:x[1]) - # 结果： - [('a', 1), ('b', 2), ('c', 3), ('d', 4)] - - # 4、按年龄升序 - students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] - sorted(students, key=lambda s: s[2]) - # 结果： - [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] - # 5、按年龄降序 - sorted(students, key=lambda s: s[2], reverse=True) - # 结果： - [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] - ``` - -- **filter() 函数：** - **描述：** - filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。 - - 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。 - **语法：** - `filter(function, iterable)` - **参数：** - function ----> 判断函数。 - iterable  ----> 可迭代对象。 - **返回值：** - Pyhton2.7 返回列表，Python3.x 返回迭代器对象，具体内容可以查看：Python3 filter() 函数 - - **实例：** - - ```python3 - # ===========一般用法：=========== - # 1、过滤出列表中的所有奇数 - def is_odd(n): - return n % 2 == 1 - - newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) - print(list(newlist)) - # 结果： [1, 3, 5, 7, 9] - - # ===========匿名函数用法：=========== - # 2、将列表[1, 2, 3]中能够被3整除的元素过滤出来 - newlist = filter(lambda x: x % 3 == 0, [1, 2, 3]) - print(list(newlist)) - # 结果： [3] - ``` diff --git "a/Python\345\237\272\347\241\200\347\237\245\350\257\206/\350\257\255\346\263\225/set\345\207\275\346\225\260.md" "b/Python\345\237\272\347\241\200\347\237\245\350\257\206/\350\257\255\346\263\225/set\345\207\275\346\225\260.md" deleted file mode 100644 index cfdb90b..0000000 --- "a/Python\345\237\272\347\241\200\347\237\245\350\257\206/\350\257\255\346\263\225/set\345\207\275\346\225\260.md" +++ /dev/null @@ -1,158 +0,0 @@ -# Python的Set函数 - -## 描述 - - set函数是Python的内置函数，用于创建一个空集合，或者将一个可迭代对象转化为一个无序集合。 - -## 语法 - - ```python - set(iterable) - ``` - -## 参数说明 - - | 名称 | 含义 | 备注 | - |:--------:|:---------------------------:|:-------------------------------:| - | iterable | 待转化为无序集合的可迭代对象，包括列表、字符串和字典等 | 可省略的参数。当该参数省略时，将创建一个不包含任何元素的空集合 | - -## 举例 - -### 1. 无参 - - 创建一个空集合赋给一个变量，输出变量的类型和值： - - ```python - a = set() - - print(type(a)) - print(a) - ``` - -  输出结果为： - - ```python - - set() - ``` - - 此时变量a是集合类型，没有任何元素。 - -### 2. 将字符串转化为集合 - - ```python - a = 'I love Python3!' - - b = set(a) - - print(b) - ``` - - 输出结果为： - - ```python - {'v', 't', '!', 'e', 'h', '3', 'l', 'y', 'n', ' ', 'o', 'P', 'I'} - ``` - -### 3. 将列表转化为集合 - - ```python - a = [] - b = [23, 45, 6, 7, 21, 22, 530, 'wdf'] - - print(set(a)) - print(set(b)) - ``` - - 输出结果为： - - ```python - set() - {6, 7, 45, 530, 21, 22, 23, 'wdf'} - ``` - -### 4. 将元组转化为集合 - - ```python - a = () - b = (23, 45, 6, 7, 23, 22, 530, 'wdf') - - print(set(a)) - print(set(b)) - ``` - - 输出结果为： - - ```python - set() - {6, 7, 'wdf', 45, 530, 22, 23} - ``` - -### 5. 将字典转化为集合 - - ```python - a = {} - b = {'China':'Beijing', 'Japan':'Tokyo', 'Mongolia':'Ulan Bator'} - - print(set(a)) - print(set(b)) - ``` - - 输出结果为： - - ```python - set() - {'Japan', 'Mongolia', 'China'} - ``` - - 可以看出将字典转化为集合时，只是收录了字典中的key。 - -## 6. 多个重复元素的可迭代对象 - - ```python - a = 'wwwwwwwwww' - b = [1,1,1,1,1,1] - c = ('sdf', 'sdf', 'sdf') - d = {1:12, 2:23, 1:345} - - print(set(a)) - print(set(b)) - print(set(c)) - print(set(d)) - ``` - - 输出结果： - - ```python - {'w'} - {1} - {'sdf'} - {1, 2} - ``` - -## 注意事项 - -1. 当使用set的有参函数时，参数必须是可迭代对象。当参数不是可迭代对象时，Python会抛出异常。例如： - - ```python - a = 1.23 - - print(set(a)) - ``` - - 结果： - - ```python - Traceback (most recent call last): - File "Test.py", line 3, in - print(set(a)) - TypeError: 'float' object is not iterable - ``` - - 异常会提示float类型不是可迭代的。 - -2. 转化为集合后，序列是随机的，可能跟转化前的序列不同。 - -3. 由于集合不包含重复元素，使用set()函数后会将之前的可迭代序列中的重复元素删除。 - -4. 将字典转化为集合，仅仅只是将键（key）收录到集合中。如果想将字典中的值转化为集合，可以用字典函数values() diff --git a/README.md b/README.md index a98f2da..1abd1b0 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,2 @@ # AlgorithmPractices Algorithm Practices in Python3 - -## 涉及到的数学基础知识可参考OI-Wiki -https://oi-wiki.org/math/ \ No newline at end of file diff --git "a/\345\212\233\346\211\243\344\271\240\351\242\230\350\256\255\347\273\203/1.\344\270\244\346\225\260\344\271\213\345\222\214.py" "b/\345\212\233\346\211\243\344\271\240\351\242\230\350\256\255\347\273\203/1.\344\270\244\346\225\260\344\271\213\345\222\214.py" deleted file mode 100644 index 07efe0d..0000000 --- "a/\345\212\233\346\211\243\344\271\240\351\242\230\350\256\255\347\273\203/1.\344\270\244\346\225\260\344\271\213\345\222\214.py" +++ /dev/null @@ -1,16 +0,0 @@ -# -# @lc app=leetcode.cn id=1 lang=python3 -# -# [1] 两数之和 -# - -# @lc code=start -class Solution: - def twoSum(self, nums: List[int], target: int) -> List[int]: - ans = dict() - for i in range(len(nums)): - if target - nums[i] in ans: - return [ans[target - nums[i]], i] - ans[nums[i]] = i -# @lc code=end - diff --git "a/\345\212\233\346\211\243\344\271\240\351\242\230\350\256\255\347\273\203/206.\345\217\215\350\275\254\351\223\276\350\241\250.py" "b/\345\212\233\346\211\243\344\271\240\351\242\230\350\256\255\347\273\203/206.\345\217\215\350\275\254\351\223\276\350\241\250.py" deleted file mode 100644 index f6b8f73..0000000 --- "a/\345\212\233\346\211\243\344\271\240\351\242\230\350\256\255\347\273\203/206.\345\217\215\350\275\254\351\223\276\350\241\250.py" +++ /dev/null @@ -1,16 +0,0 @@ -# -# @lc app=leetcode.cn id=206 lang=python3 -# -# [206] 反转链表 -# - -# @lc code=start -# Definition for singly-linked list. -# class ListNode: -# def __init__(self, val=0, next=None): -# self.val = val -# self.next = next -class Solution: - def reverseList(self, head: ListNode) -> ListNode: -# @lc code=end - diff --git "a/\345\212\233\346\211\243\344\271\240\351\242\230\350\256\255\347\273\203/27.\347\247\273\351\231\244\345\205\203\347\264\240.py" "b/\345\212\233\346\211\243\344\271\240\351\242\230\350\256\255\347\273\203/27.\347\247\273\351\231\244\345\205\203\347\264\240.py" deleted file mode 100644 index dcfec95..0000000 --- "a/\345\212\233\346\211\243\344\271\240\351\242\230\350\256\255\347\273\203/27.\347\247\273\351\231\244\345\205\203\347\264\240.py" +++ /dev/null @@ -1,18 +0,0 @@ -# -# @lc app=leetcode.cn id=27 lang=python3 -# -# [27] 移除元素 -# - -# @lc code=start -class Solution: - def removeElement(self, nums: List[int], val: int) -> int: - l = 0 - for r in nums: - if r != val: - nums[l] = r - l += 1 - - return l -# @lc code=end - diff --git "a/\345\212\233\346\211\243\344\271\240\351\242\230\350\256\255\347\273\203/283.\347\247\273\345\212\250\351\233\266.py" "b/\345\212\233\346\211\243\344\271\240\351\242\230\350\256\255\347\273\203/283.\347\247\273\345\212\250\351\233\266.py" deleted file mode 100644 index 4a4b1be..0000000 --- "a/\345\212\233\346\211\243\344\271\240\351\242\230\350\256\255\347\273\203/283.\347\247\273\345\212\250\351\233\266.py" +++ /dev/null @@ -1,21 +0,0 @@ -# -# @lc app=leetcode.cn id=283 lang=python3 -# -# [283] 移动零 -# - -# @lc code=start -class Solution: - def moveZeroes(self, nums: List[int]) -> None: - """ - Do not return anything, modify nums in-place instead. - """ - n = len(nums) - l = r = 0 - while r < n: - if nums[r] != 0: - nums[l], nums[r] = nums[r], nums[l] - l += 1 - r += 1 -# @lc code=end - diff --git "a/\345\212\233\346\211\243\344\271\240\351\242\230\350\256\255\347\273\203/485.\346\234\200\345\244\247\350\277\236\347\273\255-1-\347\232\204\344\270\252\346\225\260.py" "b/\345\212\233\346\211\243\344\271\240\351\242\230\350\256\255\347\273\203/485.\346\234\200\345\244\247\350\277\236\347\273\255-1-\347\232\204\344\270\252\346\225\260.py" deleted file mode 100644 index dabbe1f..0000000 --- "a/\345\212\233\346\211\243\344\271\240\351\242\230\350\256\255\347\273\203/485.\346\234\200\345\244\247\350\277\236\347\273\255-1-\347\232\204\344\270\252\346\225\260.py" +++ /dev/null @@ -1,21 +0,0 @@ -# -# @lc app=leetcode.cn id=485 lang=python3 -# -# [485] 最大连续 1 的个数 -# - -# @lc code=start -class Solution: - def findMaxConsecutiveOnes(self, nums: List[int]) -> int: - count = 0 - ans = 0 - for i in nums: - if i == 1: - count += 1 - if ans < count: - ans = count - else: - count = 0 - return ans -# @lc code=end - diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\344\270\255\347\255\211/HJ16 \350\264\255\347\211\251\345\215\225.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\344\270\255\347\255\211/HJ16 \350\264\255\347\211\251\345\215\225.py" deleted file mode 100644 index 6196c47..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\344\270\255\347\255\211/HJ16 \350\264\255\347\211\251\345\215\225.py" +++ /dev/null @@ -1,58 +0,0 @@ -""" -描述 -王强决定把年终奖用于购物，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子： - - 主件 附件 - 电脑 打印机，扫描仪 - 书柜 图书 - 书桌 台灯，文具 - 工作椅 无 - -如果要买归类为附件的物品，必须先买该附件所属的主件，且每件物品只能购买一次。 -每个主件可以有 0 个、 1 个或 2 个附件。附件不再有从属于自己的附件。 -王强查到了每件物品的价格（都是 10 元的整数倍），而他只有 N 元的预算。除此之外，他给每件物品规定了一个重要度，用整数 1 ~ 5 表示。 -他希望在花费不超过 N 元的前提下，使自己的满意度达到最大。满意度是指所购买的每件物品的价格与重要度的乘积的总和， -假设设第ii件物品的价格为：v[i]，重要度为：w[i]，共选中了 k 件物品，编号依次为：j1,j2,...,jk， -则满意度为：v[j1]*w[j1],v[j2]*w[j2],...,v[jk]*w[jk]。请你帮助王强计算可获得的最大的满意度。 - -输入描述： -输入的第 1 行，为两个正整数N，m，用一个空格隔开： -（其中 N （ N<32000 ）表示总钱数， m （m <60 ）为可购买的物品的个数。） -从第 2 行到第 m+1 行，第 j 行给出了编号为 j-1 的物品的基本数据，每行有 3 个非负整数 v p q -（其中 v 表示该物品的价格（ v<10000 ）， p 表示该物品的重要度（ 1 ~ 5 ）， q 表示该物品是主件还是附件。如果 q=0 ，表示该物品为主件，如果 q>0 ，表示该物品为附件， q 是所属主件的编号） - -输出描述： -输出一个正整数，为张强可以获得的最大的满意度。 -""" -""" -思路见：https://blog.nowcoder.net/n/82b5f014a8654c8b8dbff4fe4fa727bd -""" -n, m = map(int,input().split()) -primary, annex = {}, {} -for i in range(1,m+1): - x, y, z = map(int, input().split()) - if z==0: - primary[i] = [x, y] - else: - if z in annex: - annex[z].append([x, y]) - else: - annex[z] = [[x,y]] -dp = [0]*(n+1) -for key in primary: - w, v= [], [] - w.append(primary[key][0])#1、主件 - v.append(primary[key][0]*primary[key][1]) - if key in annex:#存在附件 - w.append(w[0]+annex[key][0][0])#2、主件+附件1 - v.append(v[0]+annex[key][0][0]*annex[key][0][1]) - if len(annex[key])>1:#附件个数为2 - w.append(w[0]+annex[key][1][0])#3、主件+附件2 - v.append(v[0]+annex[key][1][0]*annex[key][1][1]) - w.append(w[0]+annex[key][0][0]+annex[key][1][0])#4、主件+附件1+附件2 - v.append(v[0]+annex[key][0][0]*annex[key][0][1]+annex[key][1][0]*annex[key][1][1]) - for j in range(n,-1,-10):#物品的价格是10的整数倍 - for k in range(len(w)): - if j-w[k]>=0: - dp[j] = max(dp[j], dp[j-w[k]]+v[k]) -print(dp[n]) \ No newline at end of file diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\344\270\255\347\255\211/HJ17 \345\235\220\346\240\207\347\247\273\345\212\250.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\344\270\255\347\255\211/HJ17 \345\235\220\346\240\207\347\247\273\345\212\250.py" deleted file mode 100644 index e956ba8..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\344\270\255\347\255\211/HJ17 \345\235\220\346\240\207\347\247\273\345\212\250.py" +++ /dev/null @@ -1,34 +0,0 @@ -""" -描述 -开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标， -并将最终输入结果输出到输出文件里面。 - -输入： -合法坐标为A(或者D或者W或者S) + 数字（两位以内） -坐标之间以;分隔。 -非法坐标点需要进行丢弃。如AA10; A1A; $%$; YAD; 等。 -下面是一个简单的例子 如： -A10;S20;W10;D30;X;A1A;B10A11;;A10; -处理过程： -起点（0,0） -+ A10 = （-10,0） -+ S20 = (-10,-20) -+ W10 = (-10,-10) -+ D30 = (20,-10) -+ x = 无效 -+ A1A = 无效 -+ B10A11 = 无效 -+ 一个空 不影响 -+ A10 = (10,-10) -结果 （10， -10） - -数据范围： -每组输入的字符串长度满足 1 ≤ n ≤ 10000，坐标保证满足 -2**31 <= x,y <= 2**31 - 1，且数字部分仅含正数 - -输入描述： -一行字符串 - -输出描述： -最终坐标，以逗号分隔 -""" - diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\205\245\351\227\250/HJ101 \350\276\223\345\205\245\346\225\264\345\236\213\346\225\260\347\273\204\345\222\214\346\216\222\345\272\217\346\240\207\350\257\206\357\274\214\345\257\271\345\205\266\345\205\203\347\264\240\346\214\211\347\205\247\345\215\207\345\272\217\346\210\226\351\231\215\345\272\217\350\277\233\350\241\214\346\216\222\345\272\217.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\205\245\351\227\250/HJ101 \350\276\223\345\205\245\346\225\264\345\236\213\346\225\260\347\273\204\345\222\214\346\216\222\345\272\217\346\240\207\350\257\206\357\274\214\345\257\271\345\205\266\345\205\203\347\264\240\346\214\211\347\205\247\345\215\207\345\272\217\346\210\226\351\231\215\345\272\217\350\277\233\350\241\214\346\216\222\345\272\217.py" deleted file mode 100644 index 2d98ef5..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\205\245\351\227\250/HJ101 \350\276\223\345\205\245\346\225\264\345\236\213\346\225\260\347\273\204\345\222\214\346\216\222\345\272\217\346\240\207\350\257\206\357\274\214\345\257\271\345\205\266\345\205\203\347\264\240\346\214\211\347\205\247\345\215\207\345\272\217\346\210\226\351\231\215\345\272\217\350\277\233\350\241\214\346\216\222\345\272\217.py" +++ /dev/null @@ -1,31 +0,0 @@ -# 描述 -# 输入整型数组和排序标识，对其元素按照升序或降序进行排序 - -# 数据范围： 1 <= n <= 1000，元素大小满足 0 <= val <= 100000 -# 输入描述： -# 第一行输入数组元素个数 -# 第二行输入待排序的数组，每个数用空格隔开 -# 第三行输入一个整数0或1。0代表升序排序，1代表降序排序 - -# 输出描述： -# 输出排好序的数字 -import sys -n = int(input().strip()) -l = list(map(int, input().strip().split(' '))) -sort_order = int(input().strip()) -if 1 <= n <= 1000: - if len(l) == n: - for i in l: - if (i < 0) | (i > 100000): - print("数组元素大小超出限制范围") - sys.exit() - if sort_order == 0: - l.sort() - else: - l.sort(reverse=True) - for i in l: - print(i, end=' ') - else: - print(f"数组长度不为{n}") -else: - print("数组长度超出限制范围") diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\205\245\351\227\250/HJ46 \346\210\252\345\217\226\345\255\227\347\254\246\344\270\262.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\205\245\351\227\250/HJ46 \346\210\252\345\217\226\345\255\227\347\254\246\344\270\262.py" deleted file mode 100644 index 277a2a9..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\205\245\351\227\250/HJ46 \346\210\252\345\217\226\345\255\227\347\254\246\344\270\262.py" +++ /dev/null @@ -1,20 +0,0 @@ -# 描述 -# 输入一个字符串和一个整数 k ，截取字符串的前k个字符并输出 - -# 数据范围：字符串长度满足 1 <= n <= 1000 ， 1 <= k <= n -# 输入描述： -# 1.输入待截取的字符串 - -# 2.输入一个正整数k，代表截取的长度 - -# 输出描述： -# 截取后的字符串 -input_str,k = input(),int(input()) -str_length = len(input_str) -if input_str != "": - if 1 <= k <= str_length: - print(input_str[0:k]) - else: - print("输入的整数不在正确范围内") -else: - print("输入的字符串不符合要求") diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\205\245\351\227\250/HJ58 \350\276\223\345\205\245n\344\270\252\346\225\264\346\225\260\357\274\214\350\276\223\345\207\272\345\205\266\344\270\255\346\234\200\345\260\217\347\232\204k\344\270\252.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\205\245\351\227\250/HJ58 \350\276\223\345\205\245n\344\270\252\346\225\264\346\225\260\357\274\214\350\276\223\345\207\272\345\205\266\344\270\255\346\234\200\345\260\217\347\232\204k\344\270\252.py" deleted file mode 100644 index 7155d21..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\205\245\351\227\250/HJ58 \350\276\223\345\205\245n\344\270\252\346\225\264\346\225\260\357\274\214\350\276\223\345\207\272\345\205\266\344\270\255\346\234\200\345\260\217\347\232\204k\344\270\252.py" +++ /dev/null @@ -1,17 +0,0 @@ -# 描述 -# 输入n个整数，找出其中最小的k个整数并按升序输出 - -# 本题有多组输入样例 - -# 数据范围：1 <= n <= 1000，输入的整数满足 1 <= val <= 10000 -# 输入描述： -# 第一行输入两个整数n和k -# 第二行输入一个整数数组 - -# 输出描述： -# 从小到大输出最小的k个整数，用空格分开。 -n, k = map(int, input().strip().split(sep=' ')) -l = list(map(int, input().strip().split(' '))) -l = sorted(l) -for i in range(k): - print(l[i], end=' ') diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\205\245\351\227\250/HJ7 \345\217\226\350\277\221\344\274\274\345\200\274.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\205\245\351\227\250/HJ7 \345\217\226\350\277\221\344\274\274\345\200\274.py" deleted file mode 100644 index 49b7548..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\205\245\351\227\250/HJ7 \345\217\226\350\277\221\344\274\274\345\200\274.py" +++ /dev/null @@ -1,12 +0,0 @@ -# 描述 -# 写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于 0.5 ,向上取整；小于 0.5 ，则向下取整。 - -# 数据范围：保证输入的数字在 32 位浮点数范围内 -# 输入描述： -# 输入一个正浮点数值 - -# 输出描述： -# 输出该数值的近似整数值 - -a = input() -print(int(float(a) + 0.5)) \ No newline at end of file diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\205\245\351\227\250/HJ9 \346\217\220\345\217\226\344\270\215\351\207\215\345\244\215\347\232\204\346\225\264\346\225\260.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\205\245\351\227\250/HJ9 \346\217\220\345\217\226\344\270\215\351\207\215\345\244\215\347\232\204\346\225\264\346\225\260.py" deleted file mode 100644 index 9f88b58..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\205\245\351\227\250/HJ9 \346\217\220\345\217\226\344\270\215\351\207\215\345\244\215\347\232\204\346\225\264\346\225\260.py" +++ /dev/null @@ -1,29 +0,0 @@ -# 描述 -# 输入一个 int 型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。 -# 保证输入的整数最后一位不是 0 。 - -# 数据范围： 1 <= n <= 10^8 - -# 输入描述： -# 输入一个int型整数 - -# 输出描述： -# 按照从右向左的阅读顺序，返回一个不含重复数字的新的整数 - -num1 = input() -if int(num1) < 0: - print("请输入正确的数字，范围是1到10^8") -else: - a = list(num1) - # 将整个字符串列表逆序 - a = a[::-1] - num = [] - # 判断原输入的字符串末位是否是0 - if a[0] != "0": - # 依次从字符串取值 - for i in a: - if i not in num: - num.append(i) - print(i, end="") - else: - print("输入的整数末位是0，程序退出") diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\233\260\351\232\276/HJ28 \347\264\240\346\225\260\344\274\264\344\276\243.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\233\260\351\232\276/HJ28 \347\264\240\346\225\260\344\274\264\344\276\243.py" deleted file mode 100644 index d950936..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\345\233\260\351\232\276/HJ28 \347\264\240\346\225\260\344\274\264\344\276\243.py" +++ /dev/null @@ -1,21 +0,0 @@ -# 描述 -# 题目描述 -# 若两个正整数的和为素数，则这两个正整数称之为“素数伴侣”，如2和5、6和13，它们能应用于通信加密。现在密码学会请你设计一个程序，从已有的 N （ N 为偶数）个正整数中挑选出若干对组成“素数伴侣”，挑选方案多种多样，例如有4个正整数：2，5，6，13，如果将5和6分为一组中只能得到一组“素数伴侣”，而将2和5、6和13编组将得到两组“素数伴侣”，能组成“素数伴侣”最多的方案称为“最佳方案”，当然密码学会希望你寻找出“最佳方案”。 - -# 输入: - -# 有一个正偶数 n ，表示待挑选的自然数的个数。后面给出 n 个具体的数字。 - -# 输出: - -# 输出一个整数 K ，表示你求得的“最佳方案”组成“素数伴侣”的对数。 - - -# 数据范围： 1 <= n <= 100，输入的数据大小满足 2 <= val <= 30000 -# 输入描述： -# 输入说明 -# 1 输入一个正偶数 n -# 2 输入 n 个整数 - -# 输出描述： -# 求得的“最佳方案”组成“素数伴侣”的对数。 diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ1 \345\255\227\347\254\246\344\270\262\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ1 \345\255\227\347\254\246\344\270\262\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246.py" deleted file mode 100644 index 3e5226d..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ1 \345\255\227\347\254\246\344\270\262\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246.py" +++ /dev/null @@ -1,17 +0,0 @@ -""" -描述 -计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾） - -输入描述： -输入一行，代表要计算的字符串，非空，长度小于5000。 - -输出描述： -输出一个整数，表示输入字符串最后一个单词的长度。 -""" - -words = input().rstrip() -if len(words) < 5000: - list_words = words.split(" ") - print(len(list_words[-1])) -else: - print("字符串长度大于等于5000") diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ10 \345\255\227\347\254\246\344\270\252\346\225\260\347\273\237\350\256\241.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ10 \345\255\227\347\254\246\344\270\252\346\225\260\347\273\237\350\256\241.py" deleted file mode 100644 index 9e2fc2f..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ10 \345\255\227\347\254\246\344\270\252\346\225\260\347\273\237\350\256\241.py" +++ /dev/null @@ -1,17 +0,0 @@ -""" -描述 -编写一个函数，计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内( 0~127 ，包括 0 和 127 )，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次 -例如，对于字符串 abaca 而言，有 a、b、c 三种不同的字符，因此输出 3 。 - -数据范围： 1 <= n <= 500 - -输入描述： -输入一行没有空格的字符串。 - -输出描述： -输出 输入字符串 中范围在(0~127，包括0和127)字符的种数。 -""" - -print(len(set(input().replace("\n", "")))) - -# print(len(set(map(lambda x: x, input().replace('\n',''))))) diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ100 \347\255\211\345\267\256\346\225\260\345\210\227.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ100 \347\255\211\345\267\256\346\225\260\345\210\227.py" deleted file mode 100644 index 0284783..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ100 \347\255\211\345\267\256\346\225\260\345\210\227.py" +++ /dev/null @@ -1,23 +0,0 @@ -""" -描述 -等差数列 2，5，8，11，14...... -（从 2 开始的 3 为公差的等差数列） -输出求等差数列前n项和 - -数据范围：1 ≤ n ≤ 1000 - -输入描述： -输入一个正整数n。 - -输出描述： -输出一个相加后的整数。 -""" - -while True: - try: - s = int(input()) - w = 3 * s + 2 - L = range(2, w, 3) - print(sum(L)) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ102 \345\255\227\347\254\246\347\273\237\350\256\241.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ102 \345\255\227\347\254\246\347\273\237\350\256\241.py" deleted file mode 100644 index cd71d3c..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ102 \345\255\227\347\254\246\347\273\237\350\256\241.py" +++ /dev/null @@ -1,12 +0,0 @@ -""" -描述 -输入一个只包含小写英文字母和数字的字符串，按照不同字符统计个数由多到少输出统计结果，如果统计的个数相同，则按照ASCII码由小到大排序输出。 - -数据范围：字符串长度满足 1 ≤ len(str) ≤ 1000 - -输入描述： -一个只包含小写英文字母和数字的字符串。 - -输出描述： -一个字符串，为不同字母出现次数的降序表示。若出现次数相同，则按ASCII码的升序输出。 -""" diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ106 \345\255\227\347\254\246\351\200\206\345\272\217.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ106 \345\255\227\347\254\246\351\200\206\345\272\217.py" deleted file mode 100644 index 65c6b30..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ106 \345\255\227\347\254\246\351\200\206\345\272\217.py" +++ /dev/null @@ -1,19 +0,0 @@ -""" -描述 -将一个字符串str的内容颠倒过来，并输出。 - -数据范围：1 ≤ len(str) ≤ 10000 - -输入描述： -输入一个字符串，可以有空格 - -输出描述： -输出逆序的字符串 -""" - -while True: - try: - s = list(input()) - print("".join(s[::-1])) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ108 \346\261\202\346\234\200\345\260\217\345\205\254\345\200\215\346\225\260.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ108 \346\261\202\346\234\200\345\260\217\345\205\254\345\200\215\346\225\260.py" deleted file mode 100644 index 814f001..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ108 \346\261\202\346\234\200\345\260\217\345\205\254\345\200\215\346\225\260.py" +++ /dev/null @@ -1,24 +0,0 @@ -""" -描述 -正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。 - -数据范围： 1 ≤ a,b ≤ 100000 - -输入描述： -输入两个正整数A和B。 - -输出描述： -输出A和B的最小公倍数。 -""" - -while True: - try: - a, b = list(map(int, input().split())) - if a < b: - a, b = b, a - for i in range(a, a * b + 1, a): - if i % b == 0: - print(i) - break - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ11 \346\225\260\345\255\227\351\242\240\345\200\222.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ11 \346\225\260\345\255\227\351\242\240\345\200\222.py" deleted file mode 100644 index 145ab67..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ11 \346\225\260\345\255\227\351\242\240\345\200\222.py" +++ /dev/null @@ -1,16 +0,0 @@ -""" -描述 -输入一个整数，将这个整数以字符串的形式逆序输出 -程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001 - - -数据范围： 0 <= n <=e 2**30-1 - -输入描述： -输入一个int整数 - -输出描述： -将这个整数以字符串的形式逆序输出 -""" - -print(input()[::-1]) diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ12 \345\255\227\347\254\246\344\270\262\345\217\215\350\275\254.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ12 \345\255\227\347\254\246\344\270\262\345\217\215\350\275\254.py" deleted file mode 100644 index eae401e..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ12 \345\255\227\347\254\246\344\270\262\345\217\215\350\275\254.py" +++ /dev/null @@ -1,12 +0,0 @@ -""" -描述 -接受一个只包含小写字母的字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000） - -输入描述： -输入一行，为一个只包含小写字母的字符串。 - -输出描述： -输出该字符串反转后的字符串。 -""" - -print((input()[::-1]).lower()) diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ13 \345\217\245\345\255\220\351\200\206\345\272\217.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ13 \345\217\245\345\255\220\351\200\206\345\272\217.py" deleted file mode 100644 index bc98c81..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ13 \345\217\245\345\255\220\351\200\206\345\272\217.py" +++ /dev/null @@ -1,20 +0,0 @@ -""" -描述 -将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I” - -所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符 - -数据范围：输入的字符串长度满足 1 <= n <= 1000 - -注意本题有多组输入 -输入描述： -输入一个英文语句，每个单词用空格隔开。保证输入只包含空格和字母。 - -输出描述： -得到逆序的句子 -""" - -s = input().split() # 接收输入内容 -s1 = s[::-1] # 把输入内容倒序排列 -for x in s1: - print(x, end=" ") # 输出元素之间用空格分隔 diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ14 \345\255\227\347\254\246\344\270\262\346\216\222\345\272\217.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ14 \345\255\227\347\254\246\344\270\262\346\216\222\345\272\217.py" deleted file mode 100644 index ff5a971..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ14 \345\255\227\347\254\246\344\270\262\346\216\222\345\272\217.py" +++ /dev/null @@ -1,22 +0,0 @@ -""" -描述 -给定 n 个字符串，请对 n 个字符串按照字典序排列。 - -数据范围： 1 <= n <= 1000，字符串长度满足 1 <= len <= 100 - -输入描述： -输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。 - -输出描述： -数据输出n行，输出结果为按照字典序排列的字符串。 -""" - -while True: - try: - num = int(input()) - stack = [] - for i in range(num): - stack.append(input()) - print("\n".join(sorted(stack))) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ15 \346\261\202int\345\236\213\346\255\243\346\225\264\346\225\260\345\234\250\345\206\205\345\255\230\344\270\255\345\255\230\345\202\250\346\227\2661\347\232\204\344\270\252\346\225\260.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ15 \346\261\202int\345\236\213\346\255\243\346\225\264\346\225\260\345\234\250\345\206\205\345\255\230\344\270\255\345\255\230\345\202\250\346\227\2661\347\232\204\344\270\252\346\225\260.py" deleted file mode 100644 index 5f822e5..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ15 \346\261\202int\345\236\213\346\255\243\346\225\264\346\225\260\345\234\250\345\206\205\345\255\230\344\270\255\345\255\230\345\202\250\346\227\2661\347\232\204\344\270\252\346\225\260.py" +++ /dev/null @@ -1,15 +0,0 @@ -""" -描述 -输入一个 int 型的正整数，计算出该 int 型数据在内存中存储时 1 的个数。 - -数据范围：保证在 32 位整型数字范围内 - -输入描述： - 输入一个整数（int类型） - -输出描述： - 这个数转换成2进制后，输出1的个数 -""" - -num = int(input()) -print(bin(num).count("1")) diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ2 \350\256\241\347\256\227\346\237\220\345\255\227\347\254\246\345\207\272\347\216\260\346\254\241\346\225\260.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ2 \350\256\241\347\256\227\346\237\220\345\255\227\347\254\246\345\207\272\347\216\260\346\254\241\346\225\260.py" deleted file mode 100644 index 54a7897..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ2 \350\256\241\347\256\227\346\237\220\345\255\227\347\254\246\345\207\272\347\216\260\346\254\241\346\225\260.py" +++ /dev/null @@ -1,18 +0,0 @@ -""" -描述 -写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，然后输出输入字符串中该字符的出现次数。（不区分大小写字母） - -数据范围： 1 <= n <= 1000 - -输入描述： -第一行输入一个由字母和数字以及空格组成的字符串，第二行输入一个字符。 - -输出描述： -输出输入字符串中含有该字符的个数。（不区分大小写字母） -""" - -string1, s = input(), input() -if 1 <= len(string1) <= 1000: - print(string1.lower().count(s.lower())) -else: - print("输入的字符串长度超出限制范围") diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ21 \347\256\200\345\215\225\345\257\206\347\240\201.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ21 \347\256\200\345\215\225\345\257\206\347\240\201.py" deleted file mode 100644 index c962dc2..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ21 \347\256\200\345\215\225\345\257\206\347\240\201.py" +++ /dev/null @@ -1,68 +0,0 @@ -""" -描述 -现在有一种密码变换算法。 -九键手机键盘上的数字与字母的对应： 1--1， abc--2, def--3, ghi--4, jkl--5, mno--6, pqrs--7, tuv--8 wxyz--9, 0--0，把密码中出现的小写字母都变成九键键盘对应的数字，如：a 变成 2，x 变成 9. -而密码中出现的大写字母则变成小写之后往后移一位，如：X ，先变成小写，再往后移一位，变成了 y ，例外：Z 往后移是 a 。 -数字和其它的符号都不做变换。 - -数据范围： 输入的字符串长度满足 1 <= n <= 100 - -输入描述： -输入一组密码，长度不超过100个字符。 - -输出描述： -输出密码变换后的字符串 -""" - -# while True: -# try: -# s = input() -# res = [] -# for i in s: -# if i.isdigit(): -# res.append(i) -# elif i.isupper() and i != 'Z': -# res.append(chr(ord(i.lower()) + 1)) -# elif i == 'Z': -# res.append('a') -# else: -# if i in 'abc': -# res.append('2') -# elif i in 'def': -# res.append('3') -# elif i in 'ghi': -# res.append('4') -# elif i in 'jkl': -# res.append('5') -# elif i in 'mno': -# res.append('6') -# elif i in 'pqrs': -# res.append('7') -# elif i in 'tuv': -# res.append('8') -# else: -# res.append('9') -# print(''.join(res)) -# except: -# break - -while True: - try: - A = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" - B = "22233344455566677778889999bcdefghijklmnopqrstuvwxyza0123456789" - list1 = [] - list2 = [] - for i in A: - list1.append(i) - for i in B: - list2.append(i) - C = [] - a = input() - for i in a: - if i in list1: - C.append(list2[list1.index(i)]) - else: - C.append(i) - print("".join(C)) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ22 \346\261\275\346\260\264\347\223\266.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ22 \346\261\275\346\260\264\347\223\266.py" deleted file mode 100644 index bf0905f..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ22 \346\261\275\346\260\264\347\223\266.py" +++ /dev/null @@ -1,45 +0,0 @@ -""" -描述 -某商店规定：三个空汽水瓶可以换一瓶汽水，允许向老板借空汽水瓶（但是必须要归还）。 -小张手上有n个空汽水瓶，她想知道自己最多可以喝到多少瓶汽水。 -数据范围：输入的正整数满足 1 ≤ n ≤ 100 - -注意：本题存在多组输入。输入的 0 表示输入结束，并不用输出结果。 - -输入描述： -输入文件最多包含 10 组测试数据，每个数据占一行，仅包含一个正整数 n（ 1<=n<=100 ），表示小张手上的空汽水瓶数。n=0 表示输入结束，你的程序不应当处理这一行。 - -输出描述： -对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。 -""" - -# while True: -# n=int(input()) -# if n==0:break -# print(n//2) - -# import sys -# data = sys.stdin -# for x in data: -# x = int(x.strip()) -# if x != 0: -# print(int(x // 2)) - -import sys - - -def f(n): - if n == 0: - return 0 - if n == 1: - return 0 - if n >= 2: - return f(n - 2) + 1 - - -if __name__ == "__main__": - data = sys.stdin - for x in data: - x = int(x.strip()) - if x != 0: - print(f(x)) diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ23 \345\210\240\351\231\244\345\255\227\347\254\246\344\270\262\344\270\255\345\207\272\347\216\260\346\254\241\346\225\260\346\234\200\345\260\221\347\232\204\345\255\227\347\254\246.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ23 \345\210\240\351\231\244\345\255\227\347\254\246\344\270\262\344\270\255\345\207\272\347\216\260\346\254\241\346\225\260\346\234\200\345\260\221\347\232\204\345\255\227\347\254\246.py" deleted file mode 100644 index b42577f..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ23 \345\210\240\351\231\244\345\255\227\347\254\246\344\270\262\344\270\255\345\207\272\347\216\260\346\254\241\346\225\260\346\234\200\345\260\221\347\232\204\345\255\227\347\254\246.py" +++ /dev/null @@ -1,35 +0,0 @@ -""" -描述 -实现删除字符串中出现次数最少的字符，若出现次数最少的字符有多个，则把出现次数最少的字符都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。 - -数据范围：输入的字符串长度满足 1 ≤ n ≤ 20 ，保证输入的字符串中仅出现小写字母 - -输入描述： -字符串只包含小写英文字母, 不考虑非法输入，输入的字符串长度小于等于20个字节。 - -输出描述： -删除字符串中出现次数最少的字符后的字符串。 -""" - -""" -思路： -step1：输入一组字符串s，同时创建一个新的字典dic； -step2：遍历字符串s，如果元素在字典里，dic[i]累加次数，否则，dic[i]为1； -step3：使得MIN为出现最小次数的值； -step4：重新遍历s，如果i在字典中记录的次数等于MIN，则在原字符串s中用空字符替换； -step5：输出打印s -""" - -# 解法： -s = input() -dic = {} -for i in s: - if i in dic: - dic[i] += 1 - else: - dic[i] = 1 -MIN = min(dic.values()) -for i in s: - if dic[i] == MIN: - s = s.replace(i, "") -print(s) diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ31 \345\215\225\350\257\215\345\200\222\346\216\222.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ31 \345\215\225\350\257\215\345\200\222\346\216\222.py" deleted file mode 100644 index 2d3280b..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ31 \345\215\225\350\257\215\345\200\222\346\216\222.py" +++ /dev/null @@ -1,25 +0,0 @@ -""" -描述 -对字符串中的所有单词进行倒排。 - -说明： -1、构成单词的字符只有26个大写或小写英文字母； -2、非构成单词的字符均视为单词间隔符； -3、要求倒排后的单词间隔符以一个空格表示；如果原字符串中相邻单词间有多个间隔符时，倒排转换后也只允许出现一个空格间隔符； -4、每个单词最长20个字母； - -数据范围：字符串长度满足 1 ≤ n ≤ 10000 - -输入描述： -输入一行，表示用来倒排的句子 - -输出描述： -输出句子的倒排结果 -""" - -a = input() -for i in a: - if not i.isalpha(): - a = a.replace(i, " ") -b = a.split() -print(*b[::-1]) diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ34 \345\233\276\347\211\207\346\225\264\347\220\206.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ34 \345\233\276\347\211\207\346\225\264\347\220\206.py" deleted file mode 100644 index a4b5679..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ34 \345\233\276\347\211\207\346\225\264\347\220\206.py" +++ /dev/null @@ -1,51 +0,0 @@ -""" -描述 -Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过代码解决。 -Lily使用的图片使用字符"A"到"Z"、"a"到"z"、"0"到"9"表示。 - -数据范围：每组输入的字符串长度满足 1 ≤ n ≤ 1000 - -输入描述： -一行，一个字符串，字符串中的每个字符表示一张Lily使用的图片。 - -输出描述： -Lily的所有图片按照从小到大的顺序输出 -""" - -# while True: -# try: -# print(''.join(sorted(input()))) -# except EOFError: break - -while True: - try: - a = input() - a = list(a) # 将字符串放入列表中，每个字符为一项 - for i in range(len(a)): - a[i] = ord(a[i]) # 先转化为ASCLL码 - a.sort() # 按照ASCLL排序 - for i in range(len(a)): - a[i] = chr(a[i]) # 再将每个ASCLL还原为字符 - print("".join(a)) # 按要求输出 - except: - break - -# s = input() -# s_lsit=[] # 这个空列表用于装字符串全部转换后的ASCII码 -# for item in s: -# s_lsit.append(ord(item)) #遍历每一个元素，转换为ASCII码，追加进列表 -# pass -# news_list=sorted(s_lsit) # ACSII码列表排序 -# res_list=[]# 这个空列表装排序后各个ASCII码转回字符 -# for item in news_list: -# res_list.append(chr(item))# 遍历每一个ASCII码，转换为字符，追加列表 -# pass -# print("".join(res_list)) # 将列表打印为字符串 -# pass -# while True: -# try: -# s=str(input()) -# func(s) -# pass -# except: -# break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ35 \350\233\207\345\275\242\347\237\251\351\230\265.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ35 \350\233\207\345\275\242\347\237\251\351\230\265.py" deleted file mode 100644 index f39aeeb..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ35 \350\233\207\345\275\242\347\237\251\351\230\265.py" +++ /dev/null @@ -1,70 +0,0 @@ -""" -描述 -蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形。 - -例如，当输入5时，应该输出的三角形为： -1 3 6 10 15 -2 5 9 14 -4 8 13 -7 12 -11 - -输入描述： -输入正整数N（N不大于100） - -输出描述： -输出一个N行的蛇形矩阵。 -""" - -while True: - try: - num = int(input()) - for i in range(num): - if i == 0: - res = [(x + 2) * (x + 1) // 2 for x in range(num)] - else: - res = [x - 1 for x in res[1:]] - print(" ".join(map(str, res))) - except: - break - -""" -另一种思路： -把蛇形矩阵旋转45度其实就是个金字塔，最上面是1，最右下方是最大的数，即10 -原本： -1 3 6 10 -2 5 9 -4 8 -7 -旋转一下： -1 -2 3 -4 5 6 -7 8 9 10 -list1就是旋转后的矩阵 -然后可以发现旋转后的矩阵里每一行的最后一个元素，就是蛇形矩阵中第一行的元素，倒数第二个元素就是第二行的，依次类推。 -""" - -# # 解法： -# while 1: -# try: -# n = int(input()) -# list1 = [] -# for i in range(1,n+1): -# list1.append([0]*i) -# a = 0 -# for i in range(n): -# for j in range(i+1): -# a = a + 1 -# list1[i][j]=a -# list2,she = [],[] -# for i in range(1,n+1): -# for line in list1: -# if line: -# list2.append(line.pop(-1)) -# she.append(" ".join(map(str,list2))) -# list2 = [] -# for i in she: -# print(i) -# except: -# break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ37 \347\273\237\350\256\241\346\257\217\344\270\252\346\234\210\345\205\224\345\255\220\347\232\204\346\200\273\346\225\260.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ37 \347\273\237\350\256\241\346\257\217\344\270\252\346\234\210\345\205\224\345\255\220\347\232\204\346\200\273\346\225\260.py" deleted file mode 100644 index 805e3ce..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ37 \347\273\237\350\256\241\346\257\217\344\270\252\346\234\210\345\205\224\345\255\220\347\232\204\346\200\273\346\225\260.py" +++ /dev/null @@ -1,72 +0,0 @@ -""" -描述 -有一种兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子。 -例子：假设一只兔子第3个月出生，那么它第5个月开始会每个月生一只兔子。 -一月的时候有一只兔子，假如兔子都不死，问第n个月的兔子总数为多少？ -数据范围：输入满足 1 <= n <= 31 - -输入描述： -输入一个int型整数表示第n个月 - -输出描述： -输出对应的兔子总数 -""" - -# 思路： -# 本来想用递归算法，但本人不太擅长递归编程，所以总结出简单的逻辑规律，用简单的方式循环迭代。附python代码，以下文字为变量的含义，具体思路看代码 -# 归纳：所有兔子就三种,每个月更新三种的数量，迭代完全部相加即为所有兔子数量 -# k3-第三个月及以上，可生育 -# k2-第二个月，不可生育 -# k1-第一个月，小萌新 -# 解法： -# import sys - - -# for s in sys.stdin: -# m = int(s) -# k3 = 0 -# k2 = 0 -# k1 = 0 -# for i in range(m): -# k3 = k3 + k2 -# k2 = k1 -# if k3==0 and k2 == 0: -# k1 = 1 -# elif k3==0 and k2 == 1: -# k1 = 0 -# else: -# k1 = k3 -# print(k1+k2+k3) - -# 思路2：斐波那契数列：1 1 2 3 5 8 13 21 34 f(n)=f(n-1)+f(n-2) n>2,n从0开始 -# 解法1：递归法 -while True: - try: - month = int(input()) - n = month - 1 - - def func(n): - if n < 2: # 基线条件 - return 1 - else: # 递归条件 - return func(n - 1) + func(n - 2) - - print(func(n)) - except: - break - -# 解法2：循环列表法 -# import sys - - -# for s in sys.stdin:#s=input()读入数据的1行 -# month=int(s) -# L=[] -# for i in range(month): -# if i<2:#前两个月都为1 -# total=1 -# L.append(total) -# else: -# total=L[i-1]+L[i-2]#之后均为前两个数的和 -# L.append(total) -# print(L[-1])#最后的列表L=[1, 1, 2, 3, 5, 8, 13, 21, 34] diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ4 \345\255\227\347\254\246\344\270\262\345\210\206\351\232\224.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ4 \345\255\227\347\254\246\344\270\262\345\210\206\351\232\224.py" deleted file mode 100644 index 14856c4..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ4 \345\255\227\347\254\246\344\270\262\345\210\206\351\232\224.py" +++ /dev/null @@ -1,26 +0,0 @@ -""" -描述 -•输入一个字符串，请按长度为8拆分每个输入字符串并进行输出； -•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。 - -输入描述： -连续输入字符串(每个字符串长度小于等于100) - -输出描述： -依次输出所有分割后的长度为8的新字符串 -""" - -import re - - -s = input().strip() -# 判断是否为空字符串 -if s != "": - # 判断字符串长度是否能被8整除 - if len(s) % 8 != 0: - # 不能整除则计算还差几位，并补充字符串“0” - s += "0" * (8 - (len(s) % 8)) - # 使用正则获取切割后的字符串列表 - l = re.findall(r".{8}", s) - for i in l: - print(i) diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ40 \347\273\237\350\256\241\345\255\227\347\254\246.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ40 \347\273\237\350\256\241\345\255\227\347\254\246.py" deleted file mode 100644 index a49df58..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ40 \347\273\237\350\256\241\345\255\227\347\254\246.py" +++ /dev/null @@ -1,42 +0,0 @@ -""" -描述 -输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数。 - -数据范围：输入的字符串长度满足 1 ≤ n ≤ 1000 - -输入描述： -输入一行字符串，可以有空格 - -输出描述： -统计其中英文字符，空格字符，数字字符，其他字符的个数 -""" - -# 解法1： -# while True: -# try: -# s = input() -# l = [0, 0, 0] -# for i in s: -# l[0] += int(i.isalpha()) -# l[1] += int(i == ' ') -# l[2] += int(i.isnumeric()) -# print(l[0]) -# print(l[1]) -# print(l[2]) -# print(len(s)-l[0]-l[1]-l[2]) -# except: -# break - -# 解法2： -import re - - -while True: - try: - s = input() - print(len("".join(re.findall(r"[a-zA-Z]+", s)))) - print(len("".join(re.findall(r" ", s)))) - print(len("".join(re.findall(r"\d", s)))) - print(len("".join(re.findall(r"[^a-zA-Z0-9 ]+", s)))) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ5 \350\277\233\345\210\266\350\275\254\346\215\242.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ5 \350\277\233\345\210\266\350\275\254\346\215\242.py" deleted file mode 100644 index 55bd229..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ5 \350\277\233\345\210\266\350\275\254\346\215\242.py" +++ /dev/null @@ -1,19 +0,0 @@ -""" -描述 -写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。 - -数据范围：保证结果在 1 <= n <= 2**31-1 - -输入描述： -输入一个十六进制的数值字符串。 - -输出描述： -输出该数值的十进制字符串。不同组的测试用例用\n隔开。 -""" - -while True: - try: - s = input() - print(int(s, 16)) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ51 \350\276\223\345\207\272\345\215\225\345\220\221\351\223\276\350\241\250\344\270\255\345\200\222\346\225\260\347\254\254k\344\270\252\347\273\223\347\202\271.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ51 \350\276\223\345\207\272\345\215\225\345\220\221\351\223\276\350\241\250\344\270\255\345\200\222\346\225\260\347\254\254k\344\270\252\347\273\223\347\202\271.py" deleted file mode 100644 index aad49b2..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ51 \350\276\223\345\207\272\345\215\225\345\220\221\351\223\276\350\241\250\344\270\255\345\200\222\346\225\260\347\254\254k\344\270\252\347\273\223\347\202\271.py" +++ /dev/null @@ -1,63 +0,0 @@ -""" -描述 -输入一个单向链表，输出该链表中倒数第k个结点，链表的倒数第1个结点为链表的尾指针。 - -链表结点定义如下： -struct ListNode -{ - int m_nKey; - ListNode* m_pNext; -}; -正常返回倒数第k个结点指针，异常返回空指针. - -要求： -(1)正序构建链表; -(2)构建后要忘记链表长度。 -数据范围：链表长度满足 1 ≤ n ≤ 1000，k ≤ n，链表中数据满足 0 ≤ val ≤ 10000 -本题有多组样例输入。 - -输入描述： -输入说明 -1 输入链表结点个数 -2 输入链表的值 -3 输入k的值 - -输出描述： -输出一个整数 -""" - -# 思路： -# 因为华为认为倒数0节点上是没有值的，所以注意处理k是0的情况 -# 无脑list，纯考试够用 -# 解法1： -while True: - try: - count, num_list, k = ( - int(input()), - [int(x) for x in input().split()], - int(input()), - ) - print(num_list[-k] if k else 0) - except EOFError: - break - -# 链表做法，直接逆向遍历 -# 解法2： -# class Node(object): -# def __init__(self, val=0): -# self.val = val -# self.next = None - - -# while True: -# try: -# head = Node() -# count, num_list, k = int(input()), list( -# map(int, input().split())), int(input()) -# while k: -# head.next = Node(num_list.pop()) -# head = head.next -# k -= 1 -# print(head.val) -# except EOFError: -# break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ53 \346\235\250\350\276\211\344\270\211\350\247\222\347\232\204\345\217\230\345\275\242.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ53 \346\235\250\350\276\211\344\270\211\350\247\222\347\232\204\345\217\230\345\275\242.py" deleted file mode 100644 index b7a1ce8..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ53 \346\235\250\350\276\211\344\270\211\350\247\222\347\232\204\345\217\230\345\275\242.py" +++ /dev/null @@ -1,79 +0,0 @@ -""" -描述 - 1 - 1 1 1 - 1 2 3 2 1 - 1 3 6 7 6 3 1 -1 4 10 16 19 16 10 4 1 - -以上三角形的数阵，第一行只有一个数1，以下每行的每个数，是恰好是它上面的数、左上角数和右上角的数，3个数之和（如果不存在某个数，认为该数就是0）。 -求第n行第一个偶数出现的位置。如果没有偶数，则输出-1。例如输入3,则输出2，输入4则输出3，输入2则输出-1。 - -数据范围： 1 ≤ n ≤ 10**9 - -输入描述： -输入一个int整数 - -输出描述： -输出返回的int值 -""" - -# 解法1： -# import sys - -# alt = [2, 3, 2, 4] # 发现规律，从第三行开始2324循环 -# for line in sys.stdin: -# n = int(line.strip()) -# if n < 3: -# print(-1) -# if n >= 3: -# print(alt[(n - 3) % 4]) # 所以对4求余，映射到上面alt列表中 - -# 思路： -# 题目的关键点在于找规律，如下代码可以打印出从第三行开始的奇数和偶数的规律（0表示偶数，1表示奇数） -def func(n): - odd = [1, 1, 1] - for i in range(3, n + 1): - odd = ( - [1, odd[0] ^ odd[1]] - + [odd[j] ^ odd[j + 1] ^ odd[j + 2] for j in range(len(odd) - 2)] - + [odd[-2] ^ odd[-1], 1] - ) - print(odd) - return odd.index(0) if 0 in odd else -1 - - -""" -func(100) -[1, 0, 1, 0, 1] -[1, 1, 0, 1, 0, 1, 1] -[1, 0, 0, 0, 1, 0, 0, 0, 1] -[1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1] -[1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1] -[1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1] -[1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1] -[1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1] -[1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1] -[1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1] -[1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1] -[1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1] -[1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1] -[1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1] -[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1] -[1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1] -[1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1] -[1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1] -""" -# 经过观察发现每4行偶数出现的位置就会循环一次（位置分别是[2, 3, 2, 4]) -while True: - try: - n = int(input()) - if n == 1 or n == 2: - print(-1) - continue - n -= 3 - n %= 4 - res = [2, 3, 2, 4] - print(res[n]) - except EOFError: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ54 \350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ54 \350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.py" deleted file mode 100644 index e8f7b73..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ54 \350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.py" +++ /dev/null @@ -1,174 +0,0 @@ -""" -描述 -给定一个字符串描述的算术表达式，计算出结果值。 -输入字符串长度不超过 100 ，合法的字符包括 ”+, -, *, /, (, )” ， ”0-9” 。 -数据范围：运算过程中和最终结果均满足 |val| <= 2**31-1 ，即只进行整型运算，确保输入的表达式合法 - -输入描述： -输入算术表达式 - -输出描述： -计算出结果值 -""" - -# # 思路1： -# # 这道题的考察用法应该是用堆栈，因为python3没有栈，所以用list仿造一个堆栈。 -# class Stack: -# def __init__(self): -# self.items = [] - -# def push(self, item): -# self.items.append(item) - -# def pop(self): -# return self.items.pop() - -# def peek(self): -# return self.items[-1] - -# def size(self): -# return len(self.items) - -# # 分割器 -# # 本题首先给出一个字符串，所以要定义一个splitter，分割数字和字符。 -# # 这里我用的是一个双指针的办法，pre是前一个字符，如果是数字字符，就用0，如果是别的运算字符，就用1。 -# # 当发现从数字变成运算符的时候，lst增加整个数字。 -# # 当发现从运算符变成数字的时候，lst分别增加每一个运算符。 -# # 每次增加，再把该项设为空字符。 - - -# def splitter(string): -# lst = [] -# pre = -1 # 0 means num, 1 means char -# now = -1 -# num = '' -# char = '' -# for ii in string: -# if ii.isdigit(): -# num += ii -# now = 0 -# else: -# char += ii -# now = 1 -# if now == 1 and pre == 0: -# lst.append(int(num)) -# num = '' -# elif now == 0 and pre == 1: -# lst += list(char) -# char = '' -# pre = now -# if now == 0: -# lst.append(int(num)) -# else: -# lst += list(char) -# return lst - -# # 简单运算 -# # 先定义一个简单运算器，处理不含括号的运算式，遵循先乘除，后加减，从左到右的原则。 -# # 定义两个栈， -# # 首先要处理负数，在简单运算中，只有第一个数字可能是负数（标准的表达式）。 所以，如果第一个运算符是取负运算符，先执行之，再入栈。如果不是，直接入栈。 -# # 然后执行乘法和除法，因为store栈是正向入栈的，出栈的时候是从表达式的右边向左边，这会出错。所以先把store栈堆入calc栈中。再从calc栈进行从左到右的运算。 -# # 每次遇到乘号或者除号就从两个栈各取一个运算，然后入栈store。这样即使是连续乘除也不会错。然后执行加减法，逻辑和乘除一样。 - - -# def simple_calculator(lst): -# stack_store = Stack() -# stack_calc = Stack() - -# # Negative -# if lst[0] == '-': -# stack_store.push(-lst[1]) -# for ii in lst[2:]: -# stack_store.push(ii) -# else: -# for ii in lst: -# stack_store.push(ii) - -# # Multiply & Divide -# while stack_store.size() > 0: -# stack_calc.push(stack_store.pop()) # 先把栈堆入calc栈当中 -# while stack_calc.size() > 0: -# element = stack_calc.pop() -# if element == '*': -# res = stack_store.pop() * stack_calc.pop() # 遇到乘号和除号就运算，然后放入store当中 -# stack_store.push(res) -# elif element == '/': -# res = stack_store.pop() / stack_calc.pop() -# stack_store.push(res) -# else: -# stack_store.push(element) - -# # addition & subtraction -# while stack_store.size() > 0: -# stack_calc.push(stack_store.pop()) # 加减也是同理的 -# while stack_calc.size() > 0: -# element = stack_calc.pop() -# if element == '+': -# res = stack_store.pop() + stack_calc.pop() -# stack_store.push(res) -# elif element == '-': -# res = stack_store.pop() - stack_calc.pop() -# stack_store.push(res) -# else: -# stack_store.push(element) - -# return stack_store.peek() # 此时store栈中应该只有一个元素，那就是结果了。 - -# # 计算器（带括号） -# # 处理完了不带括号的，再处理带括号的。 -# # 同样的，使用栈进行括号处理。 -# # 在前面，我们首先已经获得了一个不带括号的简单运算器，返回值是一个数字（注意，可以是浮点数。但是输入值必须是整型，其实稍微改一改splitter也可以处理浮点运算） -# # 同样的，生成两个栈。从store栈往calc栈移动，如果遇到了左括号，则从calc栈开始出栈元素，放入空列表lst2中。当遇到右括号时，停止出栈，把lst2放入简单计算器中计算结果。 -# # 随后，把结果入栈calc。 -# # 因为是遇到第一个左括号就开始从calc出栈，直到遇到右括号为止，这样保证了是从最里面的括号开始计算。 -# # 运算完之后，又继续出入栈，直到整个队列不含括号。并且全部入栈calc。 -# # 随后，calc出栈，再进行一次简单运算，就可以得到结果。 - - -# def calculator(lst): -# stack_store = Stack() -# stack_calc = Stack() -# for ii in lst: -# stack_store.push(ii) # 先把列表放入栈中。 -# while stack_store.size() > 0: -# element = stack_store.pop() # 从store栈移动向calc栈，遇到左括号执行行为。 -# if element == '(': -# lst2 = [] -# ele2 = stack_calc.pop() # 遇到左括号后，从cal栈出栈一个list。这里是不含括号的，执行简单运算。 -# while ele2 != ')': -# lst2.append(ele2) -# ele2 = stack_calc.pop() -# # 把简单运算的结果放入calc栈中，同时两个括号正好已经被取出，无视之。 -# stack_calc.push(simple_calculator(lst2)) -# else: -# stack_calc.push(element) # 没遇到左括号就直接放入calc -# lst3 = [] -# for ii in range(stack_calc.size()): # 最后，剩下一个不含括号的表达式，再次执行。得到最终结果 -# lst3.append(stack_calc.pop()) -# return simple_calculator(lst3) - - -# # 主程序： -# while True: -# try: -# lst = splitter(input()) -# print(calculator(lst)) -# except: -# break - -# # 总结 -# # 用堆栈是比较好处理一些需要在字符串中来回的问题的。比如说括号，需要找到最里面的一个，再反向找另一个，用两个堆栈比较合适。 -# # 对于从左到右的运算，其实是队列，当然，两个字符串也就是队列了。 -# # 对于python来说，用list加上指针，利用切片的办法，完全可以做出一样的行为。 -# # 不管是从左到右，还是回头计算。只不过这道题要求了栈，才特地构建了这个类。 -# # 当然，人生苦短，如果是面试，我们需要认真的讲解自己的想法。如果是机考，建议直接eval！！ - -# eval解法： -while True: - try: - str_input = input() - - print(eval(str_input)) - - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ56 \345\256\214\345\205\250\346\225\260\350\256\241\347\256\227.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ56 \345\256\214\345\205\250\346\225\260\350\256\241\347\256\227.py" deleted file mode 100644 index add2860..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ56 \345\256\214\345\205\250\346\225\260\350\256\241\347\256\227.py" +++ /dev/null @@ -1,42 +0,0 @@ -""" -描述 -完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。 -它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。 -例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。 -输入n，请输出n以内(含n)完全数的个数。 - -数据范围： 1 <= n <= 5 * 10**5 - -输入描述： -输入一个数字n - -输出描述： -输出不超过n的完全数的个数 - -思路： -1. 定义一个真因子列表的方法 -2. 用循环判断约数和是否等于本身 -""" - -# 解法： -def factorlist(num): - if num == 1: - return False - list = [] - for i in range(1, num): - if num % i == 0: - list.append(i) - return list - - -while True: - try: - n = int(input()) - count = 0 - for j in range(2, n + 1): - m = sum(factorlist(j)) - if m == j: - count += 1 - print(count) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ6 \350\264\250\346\225\260\345\233\240\345\255\220.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ6 \350\264\250\346\225\260\345\233\240\345\255\220.py" deleted file mode 100644 index 3ff42e9..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ6 \350\264\250\346\225\260\345\233\240\345\255\220.py" +++ /dev/null @@ -1,24 +0,0 @@ -""" -描述 -功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ） - - -数据范围： 1 <= n <= 2 * 10**9 + 14 - -输入描述： -输入一个整数 - -输出描述： -按照从小到大的顺序输出它的所有质数的因子，以空格隔开。 -""" - -import math - - -n = int(input()) -for i in range(2, int(math.sqrt(n)) + 1): - while n % i == 0: - print(i, end=" ") - n = n // i -if n > 2: - print(n) diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ60 \346\237\245\346\211\276\347\273\204\346\210\220\344\270\200\344\270\252\345\201\266\346\225\260\346\234\200\346\216\245\350\277\221\347\232\204\344\270\244\344\270\252\347\264\240\346\225\260.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ60 \346\237\245\346\211\276\347\273\204\346\210\220\344\270\200\344\270\252\345\201\266\346\225\260\346\234\200\346\216\245\350\277\221\347\232\204\344\270\244\344\270\252\347\264\240\346\225\260.py" deleted file mode 100644 index 5bf72b2..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ60 \346\237\245\346\211\276\347\273\204\346\210\220\344\270\200\344\270\252\345\201\266\346\225\260\346\234\200\346\216\245\350\277\221\347\232\204\344\270\244\344\270\252\347\264\240\346\225\260.py" +++ /dev/null @@ -1,84 +0,0 @@ -""" -描述 -任意一个偶数（大于2）都可以由2个素数组成，组成偶数的2个素数有很多种情况，本题目要求输出组成指定偶数的两个素数差值最小的素数对。 - -数据范围：输入的数据满足 4 ≤ n ≤ 1000 - -输入描述： -输入一个大于2的偶数 - -输出描述： -从小到大输出两个素数 -""" - -""" -质数（prime number）又称素数，有无限个。一个大于1的自然数，除了1和它本身外，不能被其他自然数（质数）整除， -换句话说就是该数除了1和它本身以外不再有其他的因数；否则称为合数。 -根据算术基本定理，每一个比1大的整数，要么本身是一个质数，要么可以写成一系列质数的乘积； -而且如果不考虑这些质数在乘积中的顺序，那么写出来的形式是唯一的。最小的质数是2。 -""" - -# 判断一个数n是否为素数: -# 思路1：我们在每次得到一个数后，都去计算，去尝试因式分解它，看它除了1和自身之外还有没有其他因子，如果有其他因子，则因子必然成对存在， -# 除了1以外，任何合数最小的因子就是2，那最大的因子就是 n/2，因此可以使用循环判断n是否能被从2-n/2之间的整数整除。 -# 实现方法1： - - -# 思路1延伸：在上面的基础上，其实不需要遍历到 n/2，只需要到 根号n（包含根号n） 就可以了。 -# 实现方法2： - - -# 思路2：如果一个数不能整除比它小的任何素数，那么这个数就是素数，这种“打印”素数表的方法效率很低，不推荐使用，可以学习思想 -# 实现方法3： - - -# 思路3：普通筛法——埃拉托斯特尼(Eratosthenes)筛法（百度百科对埃拉托斯特尼筛法简单描述：要得到自然数n以内的全部素数，必须把不大于根号n（包括根号n）的所有素数的倍数剔除，剩下的就是素数。） -""" -详细列出计算步骤如下： -列出2以后的所有序列： -2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 -标出序列中的第一个素数，也就是2，序列变成： -2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 -将剩下序列中，划掉2的倍数，序列变成： -2 3 5 7 9 11 13 15 17 19 21 23 25 -如果这个序列中最大数小于最后一个标出的素数的平方，那么剩下的序列中所有的数都是素数，否则回到第二步。 -本例中，因为25大于2的平方，我们返回第二步： -剩下的序列中第一个素数是3，将主序列中3的倍数划掉，主序列变成： -2 3 5 7 11 13 17 19 23 25 -我们得到的素数有：2，3 -25仍然大于3的平方，所以我们还要返回第二步： -序列中第一个素数是5，同样将序列中5的倍数划掉，主序列成了： -2 3 5 7 11 13 17 19 23 -我们得到的素数有：2，3，5 。 -因为23小于5的平方，跳出循环. -结论：2到25之间的素数是：2 3 5 7 11 13 17 19 23。 -""" -# 实现方法4： - - -# 思路4：线性筛法——欧拉筛法 -""" -我们再思考一下上面的埃拉托斯特尼筛法，会发现，在“剔除“非素数时，有些合数会重复赋值。这样就增加了复杂度，降低了效率。 -比如：范围上限N = 16时 -2是素数，剔除”2 的倍数“，他们是：4，6， 8，10， 12， 14， 16 -3是素数，剔除”3 的倍数”，他们时，6，9，12，15 -6，12是重复的。如何减少重复呢？ -""" -# 实现方法5： - - -while True: - try: - n = int(input()) - m = int(n / 2) - a = 0 - for i in range(1, m + 1): - for j in range(2, i): - if i % j == 0 or (n - i) % j == 0: - break - else: - a = i - print(a) - print(n - a) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ61 \346\224\276\350\213\271\346\236\234.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ61 \346\224\276\350\213\271\346\236\234.py" deleted file mode 100644 index be08aca..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ61 \346\224\276\350\213\271\346\236\234.py" +++ /dev/null @@ -1,38 +0,0 @@ -""" -描述 -把m个同样的苹果放在n个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？ -注意：如果有7个苹果和3个盘子，（5，1，1）和（1，5，1）被视为是同一种分法。 - -数据范围：0 ≤ m ≤ 10，1 ≤ n ≤ 10。 - -输入描述： -输入两个int整数 - -输出描述： -输出结果，int型 -""" - -""" -放苹果分为两种情况，一种是有盘子为空，一种是每个盘子上都有苹果。 -令(m,n)表示将m个苹果放入n个盘子中的摆放方法总数。 -1.假设有一个盘子为空，则(m,n)问题转化为将m个苹果放在n-1个盘子上，即求得(m,n-1)即可 -2.假设所有盘子都装有苹果，则每个盘子上至少有一个苹果，即最多剩下m-n个苹果，问题转化为将m-n个苹果放到n个盘子上 -即求(m-n，n) -""" - - -def f(m, n): - if m < 0 or n < 0: - return 0 - elif m == 1 or n == 1: - return 1 - else: - return f(m, n - 1) + f(m - n, n) - - -while True: - try: - m, n = map(int, input().split()) - print(f(m, n)) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ62 \346\237\245\346\211\276\350\276\223\345\205\245\346\225\264\346\225\260\344\272\214\350\277\233\345\210\266\344\270\2551\347\232\204\344\270\252\346\225\260.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ62 \346\237\245\346\211\276\350\276\223\345\205\245\346\225\264\346\225\260\344\272\214\350\277\233\345\210\266\344\270\2551\347\232\204\344\270\252\346\225\260.py" deleted file mode 100644 index f4c6e1a..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ62 \346\237\245\346\211\276\350\276\223\345\205\245\346\225\264\346\225\260\344\272\214\350\277\233\345\210\266\344\270\2551\347\232\204\344\270\252\346\225\260.py" +++ /dev/null @@ -1,20 +0,0 @@ -""" -描述 -输入一个正整数，计算它在二进制下的1的个数。 -注意多组输入输出！！！！！！ - -数据范围： 1 <= n <= 2**31 - 1 - -输入描述： -输入一个整数 - -输出描述： -计算整数二进制中1的个数 -""" - -while True: - try: - n = int(input()) - print(bin(n).count("1")) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ72 \347\231\276\351\222\261\344\271\260\347\231\276\351\270\241\351\227\256\351\242\230.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ72 \347\231\276\351\222\261\344\271\260\347\231\276\351\270\241\351\227\256\351\242\230.py" deleted file mode 100644 index b6108ae..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ72 \347\231\276\351\222\261\344\271\260\347\231\276\351\270\241\351\227\256\351\242\230.py" +++ /dev/null @@ -1,60 +0,0 @@ -""" -描述 -公元五世纪，我国古代数学家张丘建在《算经》一书中提出了“百鸡问题”：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？ -现要求你打印出所有花一百元买一百只鸡的方式。 - -输入描述： -输入任何一个整数，即可运行程序。 - -输出描述： - 输出有数行，每行三个整数，分别代表鸡翁，母鸡，鸡雏的数量 -""" - -""" -题目翻译之后的意思是，公鸡一只5元，母鸡一只3元，小鸡三只1元 -用100元买100只鸡，给出所有的购买方案 -""" - -""" -解法1：暴力遍历 -实现思路 -直观的我们可以看出公鸡最多20只就超出了价格 -母鸡最多34只就超出价格 -小鸡100只超出了数量范围 -因此在这个三个范围内进行暴力遍历尝试，输出符合题目要求的结果即可 -时间复杂度为O(n^3)不推荐 -""" - -# while True: -# try: -# ppp = input() -# for a in range(21): # a 最多买20只 -# for b in range(34): # b 最多买33只 -# for c in range(101): # c 最多买100只 -# if a + b + c == 100 and 5*a + 3*b + 1*c/3 == 100: -# print(a,b,c) -# except: -# break - -""" -解法2：数学推导 -实现思路 -我们假定公鸡、母鸡、小鸡数量为a,b,c -则有 a+b+c=100 , 5a+3b+c/3=100 -消去c可知 -b = 25-7a/4 -因此我么可以知道a必须是4的倍数，而且b如果为正数的话要求a最大只能取3 -根据这个结果进行循环遍历，得到输出即可 -题解链接：https://blog.nowcoder.net/n/f7253737fb1c4b749c31edb770e457f5?f=comment -时间复杂度O(1) -""" -while True: - try: - ppp = input() - for i in range(4): # 数学推导，公鸡只能取0，4，8，12只 - a = 4 * i - b = 25 - 7 * i - c = 100 - a - b - print(a, b, c) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ73 \350\256\241\347\256\227\346\227\245\346\234\237\345\210\260\345\244\251\346\225\260\350\275\254\346\215\242.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ73 \350\256\241\347\256\227\346\227\245\346\234\237\345\210\260\345\244\251\346\225\260\350\275\254\346\215\242.py" deleted file mode 100644 index 6fbd9a8..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ73 \350\256\241\347\256\227\346\227\245\346\234\237\345\210\260\345\244\251\346\225\260\350\275\254\346\215\242.py" +++ /dev/null @@ -1,56 +0,0 @@ -""" -描述 -根据输入的日期，计算是这一年的第几天。 -保证年份为4位数且日期合法。 -进阶：时间复杂度：O(n)，空间复杂度：O(1) - -输入描述： -输入一行，每行空格分割，分别是年，月，日 - -输出描述： -输出是这一年的第几天 -""" - -""" -思路： -题目给出我们年、月、日的信息 -题目希望我们输出这个年月日对应在该年份中是第几天 -""" - -""" -方法一：调用datetime库 -实现思路 -datetime库中的strftime方法支持以天数的方式输出 -其中日期格式化符号%j就是天数表示 -但是这样输出的结果是从001到366为止的字符串 -我们还要从左边去掉所有的0才是最终的结果 -时间复杂度O(1) -""" -# import datetime - -# while True: -# try: -# y,m,d = map(int, input().split()) -# d = datetime.date(y, m, d) # 录入日期 -# print(d.strftime("%j").lstrip("0")) # 指定输出一年内的天数并且去掉左边的0 -# except: -# break - -""" -方法二：平闰年区别计算 -实现思路 -我们知道闰年的二月份是29天，平年的二月份是28天 -因此在计算某个日子是多少天的时候，要根据平年闰年的不同进行分类塔伦 -知道这一点后加和所有的天数即可 -时间复杂度O(1) -题解链接：https://blog.nowcoder.net/n/b1456a7cbab840cda74546d6c537a763?f=comment -""" -while True: - try: - y, m, d = map(int, input().split()) - month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] # 平年的月份 - if y % 400 == 0 or (y % 100 != 0 and y % 4 == 0): - month[1] = 29 # 闰年的月份 - print(sum(month[: m - 1]) + d) # 统计时间 - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ76 \345\260\274\347\247\221\345\275\273\346\226\257\345\256\232\347\220\206.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ76 \345\260\274\347\247\221\345\275\273\346\226\257\345\256\232\347\220\206.py" deleted file mode 100644 index a6abf15..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ76 \345\260\274\347\247\221\345\275\273\346\226\257\345\256\232\347\220\206.py" +++ /dev/null @@ -1,27 +0,0 @@ -""" -描述 -验证尼科彻斯定理，即：任何一个整数m的立方都可以写成m个连续奇数之和。 -例如： -1^3=1 -2^3=3+5 -3^3=7+9+11 -4^3=13+15+17+19 -输入一个正整数m（m≤100），将m的立方写成m个连续奇数之和的形式输出。 - -数据范围：1 ≤ m ≤ 100 -进阶：时间复杂度：O(m) ，空间复杂度：O(1) - -输入描述： -输入一个int整数 - -输出描述： -输出分解后的string -""" - -while True: - try: - m = int(input()) - l = [i for i in range(m * (m - 1) + 1, m * (m + 1)) if i % 2 != 0] - print("+".join(map(str, l))) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ8 \345\220\210\345\271\266\350\241\250\350\256\260\345\275\225.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ8 \345\220\210\345\271\266\350\241\250\350\256\260\345\275\225.py" deleted file mode 100644 index 964ace0..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ8 \345\220\210\345\271\266\350\241\250\350\256\260\345\275\225.py" +++ /dev/null @@ -1,27 +0,0 @@ -""" -描述 -数据表记录包含表索引index和数值value（int范围的正整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照index值升序进行输出。 - - -提示: -0 <= index <= 11111111 -1 <= value <= 100000 - -输入描述： -先输入键值对的个数n（1 <= n <= 500） -接下来n行每行输入成对的index和value值，以空格隔开 - -输出描述： -输出合并后的键值对（多行） -""" - -size = int(input()) -dic = {} -for i in range(size): - line = list(map(int, input().split(" "))) - print(line) - key = line[0] - value = line[1] - dic[key] = dic.get(key, 0) + value -for item in sorted(dic): - print(item, dic[item]) diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ80 \346\225\264\345\236\213\346\225\260\347\273\204\345\220\210\345\271\266.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ80 \346\225\264\345\236\213\346\225\260\347\273\204\345\220\210\345\271\266.py" deleted file mode 100644 index 9c207a2..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ80 \346\225\264\345\236\213\346\225\260\347\273\204\345\220\210\345\271\266.py" +++ /dev/null @@ -1,45 +0,0 @@ -""" -描述 -题目标题： -将两个整型数组按照升序合并，并且过滤掉重复数组元素。 -输出时相邻两数之间没有空格。 - -输入描述： -输入说明，按下列顺序输入： -1 输入第一个数组的个数 -2 输入第一个数组的数值 -3 输入第二个数组的个数 -4 输入第二个数组的数值 - -输出描述： -输出合并之后的数组 -""" - -# 解法1： -# while true: -# try: -# s0,s1,s3,s2 = input(), input().split(), input(), input().split() -# s = map(str,sorted(map(int, set(s1+s2)))) -# print(''.join(s)) -# except: -# break - -""" -思路： -step1:输入第一个数组的个数、输入第一个数组的数值、输入第二个数组的个数、输入第二个数组的数值；将两个数组的数值合并；创建一个空列表，便于存放整合后的数； -step2:遍历新数组，如果不在空列表中，则添加进去，并将空列表排序； -step3:遍历空列表，逐个打印 -""" -# 解法2： -n1 = int(input()) -nums1 = list(map(int, input().split())) -n2 = int(input()) -nums2 = list(map(int, input().split())) -nums = nums1 + nums2 -c = [] -for i in nums: - if i not in c: - c.append(i) -c.sort() -for i in c: - print(i, end="") diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ81 \345\255\227\347\254\246\344\270\262\345\255\227\347\254\246\345\214\271\351\205\215.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ81 \345\255\227\347\254\246\344\270\262\345\255\227\347\254\246\345\214\271\351\205\215.py" deleted file mode 100644 index 5cfa588..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ81 \345\255\227\347\254\246\344\270\262\345\255\227\347\254\246\345\214\271\351\205\215.py" +++ /dev/null @@ -1,23 +0,0 @@ -""" -描述 -判断短字符串S中的所有字符是否在长字符串T中全部出现。 -请注意本题有多组样例输入。 - -数据范围:1 ≤ len(S), len(T) ≤ 200 -进阶：时间复杂度：O(n)，空间复杂度：O(n) - -输入描述： -输入两个字符串。第一个为短字符串，第二个为长字符串。两个字符串均由小写字母组成。 - -输出描述： -如果短字符串的所有字符均在长字符串中出现过，则输出字符串"true"。否则输出字符串"false"。 -""" -while True: - try: - S, T = input(), input() - if set(S) & set(T) == set(S): - print("true") - else: - print("false") - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ83 \344\272\214\347\273\264\346\225\260\347\273\204\346\223\215\344\275\234.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ83 \344\272\214\347\273\264\346\225\260\347\273\204\346\223\215\344\275\234.py" deleted file mode 100644 index 3ec1712..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ83 \344\272\214\347\273\264\346\225\260\347\273\204\346\223\215\344\275\234.py" +++ /dev/null @@ -1,115 +0,0 @@ -""" -描述 -有一个m*n大小的数据表，你会依次进行以下5种操作： -1.输入m和n ，初始化m*n大小的表格。 -2.输入x1,y1,x2,y2，交换坐标在（x1,y1）和（x2,y2）的两个数。 -3.输入x，在第x行上方添加一行。 -4.输入y，在第y列左边添加一列。 -5.输入x、y，查找坐标为(x,y)的单元格的值。 -请编写程序，判断对表格的各种操作是否合法。 - -详细要求: -1.数据表的最大规格为9行*9列，对表格进行操作时遇到超出规格应该返回错误。 -2.对于插入操作，如果插入后行数或列数超过9了则应返回错误。如果插入成功了则将数据表恢复至初始化的m*n大小，多出的数据则应舍弃。 -3.所有输入坐标操作，对m*n大小的表格，行号坐标只允许0~m-1，列号坐标只允许0~n-1。超出范围应该返回错误。 - -本题含有多组样例输入！行列从0开始标号 -数据范围：数据组数：1 ≤ t ≤ 5 -进阶：时间复杂度：O(1)，空间复杂度：O(1) - -输入描述： -输入数据按下列顺序输入： -1 表格的行列值 -2 要交换的两个单元格的行列值 -3 输入要插入的行的数值 -4 输入要插入的列的数值 -5 输入要查询的单元格的坐标 - -输出描述： -输出按下列顺序输出： -1 初始化表格是否成功，若成功则返回0， 否则返回-1 -2 输出交换单元格是否成功 -3 输出插入行是否成功 -4 输出插入列是否成功 -5 输出查询单元格数据是否成功 -""" - -# 思路：这道题的本质就是数与数之间比大小， 只不过外面套了一个所谓的包装辅以大量的描述来干扰你。 这道题其实就是输入5次数据，然后比5次大小而已。 - -# # 解法1： -# def create_table(x, y): -# if 0 < x <= 9 and 0 < y <= 9: -# global mytable -# mytable = [[i + j for j in range(y)] for i in range(x)] -# print("0") -# else: -# print("-1") - - -# def func(x, a): -# return True if x in range(a) else False - - -# def exchange_value(x1, y1, x2, y2): -# if all(map(func, [x1, x2], [a, a])) and all(map(func, [y1, y2], [b, b])): -# mytable[x1][y1], mytable[x2][y2] = mytable[x2][y2], mytable[x1][y1] -# print("0") -# else: -# print("-1") - - -# def add_row(x): -# if func(x, a) and a + 1 <= 9: -# mytable.insert(x - 1, [j for j in range(b)]) -# mytable.pop() -# print("0") -# else: -# print("-1") - - -# def add_colomn(y): -# if func(y, b) and b + 1 <= 9: -# for i in range(a): -# mytable[i].insert(y - 1, i) -# mytable[i].pop() -# print("0") -# else: -# print("-1") - - -# def check_cell(x, y): -# if func(x, a) and func(y, b): -# print("0") -# else: -# print("-1") - - -# while True: -# try: -# a, b = map(int, input().split()) -# create_table(a, b) -# c, d, e, f = map(int, input().split()) -# exchange_value(c, d, e, f) -# g = int(input()) -# add_row(g) -# h = int(input()) -# add_colomn(h) -# k, l = map(int, input().split()) -# check_cell(k, l) -# except: -# break - -# # 解法2： -while True: - try: - m, n = map(int, input().split()) - x1, y1, x2, y2 = map(int, input().split()) - x, y = int(input()), int(input()) - x3, y3 = map(int, input().split()) - print(0 if m <= 9 and n <= 9 else -1) - print(0 if x1 < m and x2 < m and y1 < n and y2 < n else -1) - print(0 if 9 > m > x else -1) - print(0 if 9 > n > y else -1) - print(0 if x3 < m and y3 < n else -1) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ84 \347\273\237\350\256\241\345\244\247\345\206\231\345\255\227\346\257\215\344\270\252\346\225\260.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ84 \347\273\237\350\256\241\345\244\247\345\206\231\345\255\227\346\257\215\344\270\252\346\225\260.py" deleted file mode 100644 index a604a72..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ84 \347\273\237\350\256\241\345\244\247\345\206\231\345\255\227\346\257\215\344\270\252\346\225\260.py" +++ /dev/null @@ -1,32 +0,0 @@ -""" -描述 -找出给定字符串中大写字符(即'A'-'Z')的个数。 - -数据范围：字符串长度：1 ≤ ∣s∣ ≤ 250 -字符串中可能包含空格或其他字符 -进阶：时间复杂度：O(n)，空间复杂度：O(n) - -输入描述： -对于每组样例，输入一行，代表待统计的字符串 - -输出描述： -输出一个整数，代表字符串中大写字母的个数 -""" - -""" -思路： -step1:输入一串字符串，并创建一个空串，便于存放大写字母； -step2:遍历字符串，如果在A到Z之间，就把该大写字母加到空串中； -step3:打印空串长度 -""" - -while True: - try: - n = input() - c = "" - for i in n: - if "A" <= i <= "Z": - c += i - print(len(c)) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ85 \346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ85 \346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262.py" deleted file mode 100644 index d38a6d0..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ85 \346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262.py" +++ /dev/null @@ -1,40 +0,0 @@ -""" -描述 -给定一个仅包含小写字母的字符串，求它的最长回文子串的长度。 -所谓回文串，指左右对称的字符串。 -所谓子串，指一个字符串删掉其部分前缀和后缀（也可以不删）的字符串 - -数据范围：字符串长度1 ≤ s ≤ 350 -进阶：时间复杂度：O(n)，空间复杂度：O(n) - -输入描述： -输入一个仅包含小写字母的字符串 - -输出描述： -返回最长回文子串的长度 -""" - -""" -思路： -1. 抽丝剥茧 -这是一道非常基础的问题，也是每一个学习编程的人都回避不了的问题。 -对于第一次接触这个问题的学习者，可以对问题作如下理解： -回文：即是要求子串本身是对称的； -最长：即是要求在所有子串中找到符合要求的。 -2. 化繁为简 -根据上一部分的分析，我们可以很容易的想到暴力的解法：在每一个位置检查所有的合法的长度的子串是否是对称的。 -""" - -while True: - try: - s = input() - res = [] - - for i in range(len(s)): - for j in range(i + len(res), len(s) + 1): - if s[i:j] == s[i:j][::-1]: - res.append(j - i) - if res != "": - print(max(res)) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ86 \346\261\202\346\234\200\345\244\247\350\277\236\347\273\255bit\346\225\260.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ86 \346\261\202\346\234\200\345\244\247\350\277\236\347\273\255bit\346\225\260.py" deleted file mode 100644 index 4de77c5..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ86 \346\261\202\346\234\200\345\244\247\350\277\236\347\273\255bit\346\225\260.py" +++ /dev/null @@ -1,22 +0,0 @@ -""" -描述 -求一个int类型数字对应的二进制数字中1的最大连续数，例如3的二进制为00000011，最大连续2个1 - -数据范围：数据组数：1 ≤ t ≤ 5，1 ≤ n ≤ 500000 -进阶：时间复杂度：O(logn)，空间复杂度：O(1) - -输入描述： -输入一个int类型数字 - -输出描述： -输出转成二进制之后连续1的个数 -""" - -while True: - try: - x = int(input()) - byte_x = bin(x)[2:] - list1 = sorted(list(set(byte_x.split("0"))), key=lambda x: len(x), reverse=True) - print(len(list1[0])) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ87 \345\257\206\347\240\201\345\274\272\345\272\246\347\255\211\347\272\247.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ87 \345\257\206\347\240\201\345\274\272\345\272\246\347\255\211\347\272\247.py" deleted file mode 100644 index 11f57d5..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ87 \345\257\206\347\240\201\345\274\272\345\272\246\347\255\211\347\272\247.py" +++ /dev/null @@ -1,125 +0,0 @@ -""" -描述 -密码按如下规则进行计分，并根据不同的得分为密码进行安全等级划分。 - -一、密码长度: -5 分: 小于等于4 个字符 -10 分: 5 到7 字符 -25 分: 大于等于8 个字符 - -二、字母: -0 分: 没有字母 -10 分: 密码里的字母全都是小（大）写字母 -20 分: 密码里的字母符合”大小写混合“ - -三、数字: -0 分: 没有数字 -10 分: 1 个数字 -20 分: 大于1 个数字 - -四、符号: -0 分: 没有符号 -10 分: 1 个符号 -25 分: 大于1 个符号 - -五、奖励（只能选符合最多的那一种奖励）: -2 分: 字母和数字 -3 分: 字母、数字和符号 -5 分: 大小写字母、数字和符号 - -最后的评分标准: ->= 90: 非常安全 ->= 80: 安全（Secure） ->= 70: 非常强 ->= 60: 强（Strong） ->= 50: 一般（Average） ->= 25: 弱（Weak） ->= 0: 非常弱（Very_Weak） - -对应输出为： - -VERY_SECURE -SECURE -VERY_STRONG -STRONG -AVERAGE -WEAK -VERY_WEAK - -请根据输入的密码字符串，进行安全评定。 - -注： -字母：a-z, A-Z -数字：0-9 -符号包含如下： (ASCII码表可以在UltraEdit的菜单view->ASCII Table查看) -!"#$%&'()*+,-./ (ASCII码：0x21~0x2F) -:;<=>?@ (ASCII码：0x3A~0x40) -[\]^_` (ASCII码：0x5B~0x60) -{|}~ (ASCII码：0x7B~0x7E) - -提示: -1 <= 字符串的长度 <= 300 -输入描述： -输入一个string的密码 - -输出描述： -输出密码等级 -""" - -while 1: - try: - # 密码长度 - score = 0 - s = input() - if len(s) <= 4: - score += 5 - elif len(s) >= 8: - score += 25 - else: - score += 10 - # 密码内容 - low = 0 - upp = 0 - dig = 0 - sym = 0 - for i in s: - if i.islower(): - low = 1 - elif i.isupper(): - upp = 1 - elif i.isdigit(): - dig += 1 - elif i.isascii(): - sym += 1 - if dig > 1: - dig = 2 - if sym > 1: - sym = 2.5 - score += int(10 * (low + upp + dig + sym)) - # 强度奖励 - ben = 0 - if low != 0 or upp != 0: - if dig != 0: - ben = 2 - if sym != 0: - ben = 3 - if low != 0 and upp != 0: - ben = 5 - score += ben - # 得分判定 - if score >= 90: - print("VERY_SECURE") - elif score >= 80: - print("SECURE") - elif score >= 70: - print("VERY_STRONG") - elif score >= 60: - print("STRONG") - elif score >= 50: - print("AVERAGE") - elif score >= 25: - print("WEAK") - else: - print("VERY_WEAK") - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ91 \350\265\260\346\226\271\346\240\274\347\232\204\346\226\271\346\241\210\346\225\260.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ91 \350\265\260\346\226\271\346\240\274\347\232\204\346\226\271\346\241\210\346\225\260.py" deleted file mode 100644 index c8be01c..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ91 \350\265\260\346\226\271\346\240\274\347\232\204\346\226\271\346\241\210\346\225\260.py" +++ /dev/null @@ -1,46 +0,0 @@ -""" -描述 -请计算n*m的棋盘格子（n为横向的格子数，m为竖向的格子数）从棋盘左上角出发沿着边缘线从左上角走到右下角，总共有多少种走法，要求不能走回头路，即：只能往右和往下走，不能往左和往上走。 -注：沿棋盘格之间的边缘线行走 - -数据范围：1 ≤ n,m ≤ 8 - -输入描述： -输入两个正整数n和m，用空格隔开。(1 ≤ n,m ≤ 8) - -输出描述： -输出一行结果 -""" - -# def func(x,y): -# if x < 0 or y < 0: -# return 0 -# elif x == 0 or y == 0: -# return 1 -# else: -# return func(x-1, y)+func(x, y-1) - -# while True: -# try: -# a,b = map(int,input().split()) -# c = func(a, b) -# print(c) -# except: -# break - - -# 动态规划解决 -# nowcoder不能导入numpy模块，只能手工创建二维数组 -# 重点注意二维数据的创建方法，重点注意其横竖坐标，注意注意 -# dp = [[1 for i in range(n+1)] for j in range(m+1)]，横坐标是 n, 竖坐标是m - -while True: - try: - n, m = map(int, input().split(" ")) - dp = [[1 for i in range(n + 1)] for j in range(m + 1)] - for i in range(1, m + 1): - for j in range(1, n + 1): - dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - print(dp[m][n]) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ94 \350\256\260\347\245\250\347\273\237\350\256\241.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ94 \350\256\260\347\245\250\347\273\237\350\256\241.py" deleted file mode 100644 index 27c5a1d..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ94 \350\256\260\347\245\250\347\273\237\350\256\241.py" +++ /dev/null @@ -1,30 +0,0 @@ -""" -描述 -请实现一个计票统计系统。你会收到很多投票，其中有合法的也有不合法的，请统计每个候选人得票的数量以及不合法的票数。 -（注：不合法的投票指的是投票的名字不存在n个候选人的名字中！！） - -数据范围：每组输入中候选人数量满足 1 ≤ n ≤ 100，总票数量满足 1 ≤ n ≤ 100 - -输入描述： -第一行输入候选人的人数n，第二行输入n个候选人的名字（均为大写字母的字符串），第三行输入投票人的人数，第四行输入投票。 - -输出描述： -按照输入的顺序，每行输出候选人的名字和得票数量（以" : "隔开，注：英文冒号左右两边都有一个空格！），最后一行输出不合法的票数，格式为"Invalid : "+不合法的票数。 -""" - -while True: - - try: - n = int(input()) - name_list = input().split() - m = int(input()) - vote_list = input().split() - - valid_count = 0 - for i in name_list: - valid_count += vote_list.count(i) - print(i + " : " + str(vote_list.count(i))) - print("Invalid : " + str(m - valid_count)) - - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ96 \350\241\250\347\244\272\346\225\260\345\255\227.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ96 \350\241\250\347\244\272\346\225\260\345\255\227.py" deleted file mode 100644 index 8ff45d3..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ96 \350\241\250\347\244\272\346\225\260\345\255\227.py" +++ /dev/null @@ -1,41 +0,0 @@ -""" -描述 -将一个字符中所有的整数前后加上符号“*”，其他字符保持不变。连续的数字视为一个整数。 - -数据范围：字符串长度满足 1 ≤ n ≤ 100 - -输入描述： -输入一个字符串 - -输出描述： -字符中所有出现的数字前后加上符号“*”，其他字符保持不变 -""" - -# while True: -# try: -# s = input() -# s_o = '' -# char_pre = '' -# for i in s: #遍历字符串 -# if i.isdigit() : #遇到数字，判断其前面是否非数字，是则表示数字的开始，先插入‘*’ -# if char_pre.isdigit() != True: -# s_o +='*' -# else: #非数字情况，判断其前是否为数字，是则表示数字结束，插入‘*’ -# if char_pre.isdigit(): -# s_o +='*' -# s_o += i #把当前字符带出来 -# char_pre = i #当前字符更新到 前字符 -# if i.isdigit(): #结束的时候，判断是否数字结束，如果是的话，插入‘*’ -# s_o +='*' -# print(s_o) -# except: -# break - - -import re - -while True: - try: - print(re.sub("(\d+)", "*\g<1>*", input())) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ97 \350\256\260\350\264\237\345\235\207\346\255\243.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ97 \350\256\260\350\264\237\345\235\207\346\255\243.py" deleted file mode 100644 index 827f52c..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ97 \350\256\260\350\264\237\345\235\207\346\255\243.py" +++ /dev/null @@ -1,31 +0,0 @@ -""" -描述 -首先输入要输入的整数个数n，然后输入n个整数。输出为n个整数中负数的个数，和所有正整数的平均值，结果保留一位小数。 -0即不是正整数，也不是负数，不计入计算。如果没有正数，则平均值为0。 - -数据范围： 1 ≤ n ≤ 2000，输入的整数都满足 ∣val∣ ≤ 1000 - -输入描述： -首先输入一个正整数n， -然后输入n个整数。 - -输出描述： -输出负数的个数，和所有正整数的平均值。 -""" - -a = int(input()) -b = list(map(int, input().split())) -num1 = 0 -num2 = 0 -sum = 0 -for i in b: - if i < 0: - num1 += 1 # 负整数数量 - elif i > 0: - num2 += 1 # 正整数数量 - sum += i # 正整数之和 -if num2 != 0: # 避免分母为0的情况 - c = round(sum / num2, 1) # 保留一位小数 - print(num1, c) -else: - print(num1, "0.0") diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ99 \350\207\252\345\256\210\346\225\260.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ99 \350\207\252\345\256\210\346\225\260.py" deleted file mode 100644 index 5645673..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\347\256\200\345\215\225/HJ99 \350\207\252\345\256\210\346\225\260.py" +++ /dev/null @@ -1,35 +0,0 @@ -""" -描述 -自守数是指一个数的平方的尾数等于该数自身的自然数。例如：25^2 = 625，76^2 = 5776，9376^2 = 87909376。请求出n(包括n)以内的自守数的个数 - -数据范围：1 ≤ n ≤ 10000 - -输入描述： -int型整数 - -输出描述： -n以内自守数的数量。 -""" - -""" -思路 -遍历 -用range，从0开始，一直到n+1（这里要注意不能漏最后一个） -一个数字的末尾是2，3，4，7，8，9的话，不可能题目要求，平方的末尾都和自己不一样； -数字to字符串，对i的整体和j的倒数几位直接对比计数即可。 -""" - -while True: - try: - n = int(input()) - c = 0 - for i in range(n+1): - if i%10 in [2, 3, 4, 7, 8, 9]: - continue - j = str(i**2) - i = str(i) - if i==j[-len(i):]: - c += 1 - print(c) - except: - break diff --git "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\350\276\203\351\232\276/HJ3 \346\230\216\346\230\216\347\232\204\351\232\217\346\234\272\346\225\260.py" "b/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\350\276\203\351\232\276/HJ3 \346\230\216\346\230\216\347\232\204\351\232\217\346\234\272\346\225\260.py" deleted file mode 100644 index c7c2496..0000000 --- "a/\347\211\233\345\256\242\344\271\240\351\242\230\350\256\255\347\273\203/\350\276\203\351\232\276/HJ3 \346\230\216\346\230\216\347\232\204\351\232\217\346\234\272\346\225\260.py" +++ /dev/null @@ -1,8 +0,0 @@ -# 描述 -# 明明生成了NN个1到500之间的随机整数。请你删去其中重复的数字，即相同的数字只保留一个，把其余相同的数去掉，然后再把这些数从小到大排序，按照排好的顺序输出。 - -# 数据范围： 1 <= n <= 1000，输入的数字大小满足 1 <= val <= 500 -# 输入描述： -# 第一行先输入随机整数的个数 N 。 接下来的 N 行每行输入一个整数，代表明明生成的随机数。 具体格式可以参考下面的"示例"。 -# 输出描述： -# 输出多行，表示输入数据处理后的结果 diff --git "a/\351\205\215\345\245\227\350\265\204\346\226\231/labuladong\347\232\204\345\210\267\351\242\230\346\217\222\344\273\266/Chrome\345\210\267\351\242\230\346\217\222\344\273\266V4.0.0.crx" "b/\351\205\215\345\245\227\350\265\204\346\226\231/labuladong\347\232\204\345\210\267\351\242\230\346\217\222\344\273\266/Chrome\345\210\267\351\242\230\346\217\222\344\273\266V4.0.0.crx" deleted file mode 100644 index b216d97..0000000 Binary files "a/\351\205\215\345\245\227\350\265\204\346\226\231/labuladong\347\232\204\345\210\267\351\242\230\346\217\222\344\273\266/Chrome\345\210\267\351\242\230\346\217\222\344\273\266V4.0.0.crx" and /dev/null differ diff --git "a/\351\205\215\345\245\227\350\265\204\346\226\231/labuladong\347\232\204\345\210\267\351\242\230\346\217\222\344\273\266/Chrome\345\210\267\351\242\230\346\217\222\344\273\266\345\256\211\350\243\205\346\214\207\345\215\227.md" "b/\351\205\215\345\245\227\350\265\204\346\226\231/labuladong\347\232\204\345\210\267\351\242\230\346\217\222\344\273\266/Chrome\345\210\267\351\242\230\346\217\222\344\273\266\345\256\211\350\243\205\346\214\207\345\215\227.md" deleted file mode 100644 index c7e232d..0000000 --- "a/\351\205\215\345\245\227\350\265\204\346\226\231/labuladong\347\232\204\345\210\267\351\242\230\346\217\222\344\273\266/Chrome\345\210\267\351\242\230\346\217\222\344\273\266\345\256\211\350\243\205\346\214\207\345\215\227.md" +++ /dev/null @@ -1,5 +0,0 @@ -# 功能说明 - -请移步这里： - -https://mp.weixin.qq.com/s/wIxflO1dvXzDlibhEcENcQ \ No newline at end of file diff --git "a/\351\205\215\345\245\227\350\265\204\346\226\231/labuladong\347\232\204\345\210\267\351\242\230\346\217\222\344\273\266/Jetbrains\345\210\267\351\242\230\346\217\222\344\273\266\345\256\211\350\243\205\346\214\207\345\215\227.md" "b/\351\205\215\345\245\227\350\265\204\346\226\231/labuladong\347\232\204\345\210\267\351\242\230\346\217\222\344\273\266/Jetbrains\345\210\267\351\242\230\346\217\222\344\273\266\345\256\211\350\243\205\346\214\207\345\215\227.md" deleted file mode 100644 index a2310d8..0000000 --- "a/\351\205\215\345\245\227\350\265\204\346\226\231/labuladong\347\232\204\345\210\267\351\242\230\346\217\222\344\273\266/Jetbrains\345\210\267\351\242\230\346\217\222\344\273\266\345\256\211\350\243\205\346\214\207\345\215\227.md" +++ /dev/null @@ -1 +0,0 @@ -不喜欢在网页刷题的读者，可以安装 JetBrains 插件在 JetBrains 的 IDE 全家桶中刷题，其功能和 Chrome 插件相同，安装及功能手册 [请看这里](https://mp.weixin.qq.com/s/NF8mmVyXVfC1ehdMOsO7Cw)。 \ No newline at end of file diff --git "a/\351\205\215\345\245\227\350\265\204\346\226\231/labuladong\347\232\204\345\210\267\351\242\230\347\254\224\350\256\260/labuladong\347\232\204\345\210\267\351\242\230\347\254\224\350\256\260V4.0.pdf" "b/\351\205\215\345\245\227\350\265\204\346\226\231/labuladong\347\232\204\345\210\267\351\242\230\347\254\224\350\256\260/labuladong\347\232\204\345\210\267\351\242\230\347\254\224\350\256\260V4.0.pdf" deleted file mode 100644 index 4750f4b..0000000 Binary files "a/\351\205\215\345\245\227\350\265\204\346\226\231/labuladong\347\232\204\345\210\267\351\242\230\347\254\224\350\256\260/labuladong\347\232\204\345\210\267\351\242\230\347\254\224\350\256\260V4.0.pdf" and /dev/null differ diff --git "a/\351\205\215\345\245\227\350\265\204\346\226\231/labuladong\347\232\204\347\256\227\346\263\225\347\247\230\347\261\215/labuladong\347\232\204\347\256\227\346\263\225\347\247\230\347\261\215V4.0.pdf" "b/\351\205\215\345\245\227\350\265\204\346\226\231/labuladong\347\232\204\347\256\227\346\263\225\347\247\230\347\261\215/labuladong\347\232\204\347\256\227\346\263\225\347\247\230\347\261\215V4.0.pdf" deleted file mode 100644 index 0102377..0000000 Binary files "a/\351\205\215\345\245\227\350\265\204\346\226\231/labuladong\347\232\204\347\256\227\346\263\225\347\247\230\347\261\215/labuladong\347\232\204\347\256\227\346\263\225\347\247\230\347\261\215V4.0.pdf" and /dev/null differ