1 #这是我所能写的 2 while True: 3 try: 4 n = int(input()) 5 nums = input().split() 6 k = int(input()) 7 if k>0: 8 print(nums[-k]) 9 else: 10 print(0) 11 except: 12 break 13 14 ################################ 15 while True: 16 try: 17 input_num = int(input()) 18 input_arr = input().split() 19 k = int(input()) 20 if k != 0: 21 print(int(input_arr[- k])) 22 else: 23 print(0) 24 except: 25 break 26 27 ################################################################## 28 while True: 29 try: 30 count, num_list, k = int(input()), [int(x) for x in input().split()], int(input()) 31 print(num_list[-k] if k else 0) 32 except EOFError: 33 break 34 ################################################################### 35 #链表做法，直接逆向遍历 36 class Node(object): 37 def __init__(self, val=0): 38 self.val = val 39 self.next = None 40 41 42 while True: 43 try: 44 head = Node() 45 count, num_list, k = int(input()), list(map(int, input().split())), int(input()) 46 while k: 47 head.next = Node(num_list.pop()) 48 head = head.next 49 k -= 1 50 print(head.val) 51 except EOFError: 52 break 53 ################################################################### 54 class Node(): 55 def __init__(self,data): 56 self.data=data 57 self.next=None 58 class LinkList(): 59 def __init__(self): 60 self.head=None 61 def isempty(self): 62 return self.head==None 63 def append(self,data): 64 node=Node(data) 65 if self.isempty(): 66 self.head=node 67 else: 68 cur=self.head 69 while cur.next != None: 70 cur=cur.next 71 cur.next=node 72 def search(self,n,k): 73 cur=self.head 74 if n<=0: 75 print(0) 76 return False 77 elif cur != None: 78 for i in range(k-1): 79 cur=cur.next 80 print(cur.data) 81 if __name__ == '__main__': 82 while True: 83 try: 84 n=int(input()) 85 s=input().split() 86 k=int(input()) 87 l=LinkList() 88 for i in range(n): 89 l.append(s[i]) 90 l.search(n,n-k+1) 91 except: 92 break
1 # //杨辉三角规律 行号 第一个偶数在该行第几个 2 # // 1 1 -1 3 # // 1 1 1 2 -1 4 # // 1 2 3 2 1 3 2 5 # // 1 3 6 7 6 3 1 4 3 6 # // 1 4 10 16 19 16 10 4 1 5 2 7 # // 1 5 15 30 45 51 45 30 15 5 1 6 4 8 # // 9 # // 首个偶数在该行第几个的规律： -1 -1 （2 3 2 4）···（2 3 2 4） 10 #穷举出所求行的数字，判断所求行偶数的位置 11 while True: 12 try: 13 n = int(input()) 14 arr = [[] for i in range(n)] 15 arr[0] = [1] 16 arr[1] = [1,1,1] 17 18 m = 2 19 while m < n : 20 column_num = 2*m + 1 21 for i in range(column_num): 22 # print(i) 23 # print(arr[m-1][i-2 if i-2 >=0 else 0:i+1]) 24 arr[m].append(sum(arr[m-1][i-2 if i-2 >=0 else 0:i+1])) 25 m = m+1 26 def cal(n,arr): 27 for i,j in enumerate(arr[n-1]): 28 if j%2 == 0: 29 return i+1 30 return -1 31 index = cal(n,arr) 32 print(index) 33 except: 34 break 35 36 ################################################################################ 37 while True: 38 try: 39 n = int(input()) 40 # 误区！！！把三角形求出来再去找偶数在数据量大到时候会超时 41 # array = [[0] * (2 * n - 1) for i in range(n)] 42 43 # for i in range(n): 44 # array[i][n-1-i] = 1 45 # array[i][i-n] = 1 46 47 # for i in range(1, n): 48 # for j in range(1, 2 * n - 2): 49 # array[i][j] = array[i-1][j-1] + array[i-1][j] + array[i-1][j+1] 50 # for x in array[n-1]: 51 # if x % 2 == 0: 52 # print(array[n-1].index(x) + 1) 53 # break 54 # else: 55 # print(-1) 56 57 if n <= 2: 58 print(-1) 59 elif (n - 2) % 2 == 1: 60 print(2) 61 elif n % 4 == 0: 62 print(3) 63 elif (n - 2) % 4 == 0: 64 print(4) 65 except: 66 break
1 """ 2 题目的关键点在于找规律，如下代码可以打印出从第三行开始的奇数和偶数的规律（0 3 表示偶数，1 4 表示奇数） 5 """ 6 7 def func(n): 8 odd = [1, 1, 1] 9 for i in range(3, n + 1): 10 odd = [1, odd[0] ^ odd[1]] + [odd[j] ^ odd[j + 1] ^ odd[j + 2] for j in range(len(odd) - 2)] + [ 11 odd[-2] ^ odd[-1], 1] 12 print(odd) 13 return odd.index(0) if 0 in odd else -1 14 15 16 """ 17 func(100) 18 [1, 0, 1, 0, 1] 19 [1, 1, 0, 1, 0, 1, 1] 20 [1, 0, 0, 0, 1, 0, 0, 0, 1] 21 [1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1] 22 [1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1] 23 [1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1] 24 [1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1] 25 [1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1] 26 [1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1] 27 [1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1] 28 [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] 29 [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] 30 [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] 31 [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] 32 [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] 33 [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] 34 [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] 35 [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] 36 """ 37 #经过观察发现每4行偶数出现的位置就会循环一次（位置分别是[2, 3, 2, 4]) 38 39 while True: 40 try: 41 n = int(input()) 42 if n == 1 or n == 2: 43 print(-1) 44 continue 45 n -= 3 46 n %= 4 47 res = [2, 3, 2, 4] 48 print(res[n]) 49 except EOFError: 50 break 51 ############################## 52 while True: 53 try: 54 n = int(input()) 55 if n < 3: 56 print(-1) 57 continue 58 res, temp = [1, 1, 1], [] 59 for _ in range(3, n+1): 60 res = [0] + res + [0] 61 i, Max = 0, len(res) 62 while i + 2 <= Max: 63 temp.append(sum(res[i:i+3])) 64 i += 1 65 res = [1] + temp + [1] 66 temp = [] 67 for i, n in enumerate(res): 68 if n % 2 == 0: 69 print(i+1) 70 break 71 except: 72 break 73 74 75 76
使用eval函数，参考博客：python中的exec()、eval()以及complie()
https://www.cnblogs.com/yyds/p/6276746.html
https://www.cnblogs.com/yangmingxianshen/p/7810496.html
https://blog.csdn.net/GreenHandCGL/article/details/79668427
1 while True: 2 try: 3 print(int(eval(input()))) 4 except: 5 break
堆栈类class Stack
1 """ 2 这道题的考察用法应该是用堆栈，因为python3没有栈，所以用list仿造一个堆栈。 3 4 堆栈类class Stack 5 """ 6 class Stack: 7 def __init__(self): 8 self.items = [] 9 10 def push(self, item): 11 self.items.append(item) 12 13 def pop(self): 14 return self.items.pop() 15 16 def peek(self): 17 return self.items[-1] 18 19 def size(self): 20 return len(self.items) 21 22 """ 23 分割器 24 本题首先给出一个字符串，所以要定义一个splitter，分割数字和字符。 25 26 这里我用的是一个双指针的办法，pre是前一个字符，如果是数字字符，就用0，如果是别的运算字符，就用1。 27 28 当发现从数字变成运算符的时候，lst增加整个数字。 29 30 当发现从运算符变成数字的时候，lst分别增加每一个运算符。 31 32 每次增加，再把该项设为空字符。 33 """ 34 35 36 def splitter(string): 37 lst = [] 38 pre = -1 # 0 means num, 1 means char 39 now = -1 40 num = '' 41 char = '' 42 for ii in string: 43 if ii.isdigit(): 44 num += ii 45 now = 0 46 else: 47 char += ii 48 now = 1 49 if now == 1 and pre == 0: 50 lst.append(int(num)) 51 num = '' 52 elif now == 0 and pre == 1: 53 lst += list(char) 54 char = '' 55 pre = now 56 if now == 0: 57 lst.append(int(num)) 58 else: 59 lst += list(char) 60 return lst 61 62 """ 63 简单运算 64 先定义一个简单运算器，处理不含括号的运算式，遵循先乘除，后加减，从左到右的原则。 65 66 定义两个栈， 67 68 首先要处理负数，在简单运算中，只有第一个数字可能是负数（标准的表达式）。 所以，如果第一个运算符是取负运算符，先执行之，再入栈。如果不是，直接入栈。 69 70 然后执行乘法和除法，因为store栈是正向入栈的，出栈的时候是从表达式的右边向左边，这会出错。所以先把store栈堆入calc栈中。再从calc栈进行从左到右的运算。每次遇到乘号或者除号就从两个栈各取一个运算，然后入栈store。这样即使是连续乘除也不会错。 71 72 然后执行加减法，逻辑和乘除一样。 73 """ 74 75 76 def simple_calculator(lst): 77 stack_store = Stack() 78 stack_calc = Stack() 79 80 # Negative 81 if lst[0] == '-': 82 stack_store.push(-lst[1]) 83 for ii in lst[2:]: 84 stack_store.push(ii) 85 else: 86 for ii in lst: 87 stack_store.push(ii) 88 89 # Multiply & Divide 90 while stack_store.size() > 0: 91 stack_calc.push(stack_store.pop()) # 先把栈堆入calc栈当中 92 while stack_calc.size() > 0: 93 element = stack_calc.pop() 94 if element == '*': 95 res = stack_store.pop() * stack_calc.pop() # 遇到乘号和除号就运算，然后放入store当中 96 stack_store.push(res) 97 elif element == '/': 98 res = stack_store.pop() / stack_calc.pop() 99 stack_store.push(res) 100 else: 101 stack_store.push(element) 102 103 # addition & subtraction 104 while stack_store.size() > 0: 105 stack_calc.push(stack_store.pop()) # 加减也是同理的 106 while stack_calc.size() > 0: 107 element = stack_calc.pop() 108 if element == '+': 109 res = stack_store.pop() + stack_calc.pop() 110 stack_store.push(res) 111 elif element == '-': 112 res = stack_store.pop() - stack_calc.pop() 113 stack_store.push(res) 114 else: 115 stack_store.push(element) 116 117 return stack_store.peek() # 此时store栈中应该只有一个元素，那就是结果了。 118 119 """ 120 计算器（带括号） 121 处理完了不带括号的，再处理带括号的。 122 123 同样的，使用栈进行括号处理。 124 125 在前面，我们首先已经获得了一个不带括号的简单运算器，返回值是一个数字（注意，可以是浮点数。但是输入值必须是整型，其实稍微改一改splitter也可以处理浮点运算） 126 127 同样的，生成两个栈。从store栈往calc栈移动，如果遇到了左括号，则从calc栈开始出栈元素，放入空列表lst2中。当遇到右括号时，停止出栈，把lst2放入简单计算器中计算结果。 128 129 随后，把结果入栈calc。 130 131 因为是遇到第一个左括号就开始从calc出栈，直到遇到右括号为止，这样保证了是从最里面的括号开始计算。 132 133 运算完之后，又继续出入栈，直到整个队列不含括号。并且全部入栈calc。 134 135 随后，calc出栈，再进行一次简单运算，就可以得到结果。 136 """ 137 138 def calculator(lst): 139 stack_store = Stack() 140 stack_calc = Stack() 141 for ii in lst: 142 stack_store.push(ii) # 先把列表放入栈中。 143 while stack_store.size() > 0: 144 element = stack_store.pop() # 从store栈移动向calc栈，遇到左括号执行行为。 145 if element == '(': 146 lst2 = [] 147 ele2 = stack_calc.pop() # 遇到左括号后，从cal栈出栈一个list。这里是不含括号的，执行简单运算。 148 while ele2 != ')': 149 lst2.append(ele2) 150 ele2 = stack_calc.pop() 151 stack_calc.push(simple_calculator(lst2)) # 把简单运算的结果放入calc栈中，同时两个括号正好已经被取出，无视之。 152 else: 153 stack_calc.push(element) # 没遇到左括号就直接放入calc 154 lst3 = [] 155 for ii in range(stack_calc.size()): # 最后，剩下一个不含括号的表达式，再次执行。得到最终结果 156 lst3.append(stack_calc.pop()) 157 return simple_calculator(lst3) 158 159 160 #主程序 161 162 while True: 163 try: 164 lst = splitter(input()) 165 print(calculator(lst)) 166 except: 167 break 168 """ 169 总结 170 用堆栈是比较好处理一些需要在字符串中来回的问题的。比如说括号，需要找到最里面的一个，再反向找另一个，用两个堆栈比较合适。 171 172 对于从左到右的运算，其实是队列，当然，两个字符串也就是队列了。 173 174 对于python来说，用list加上指针，利用切片的办法，完全可以做出一样的行为。 175 176 不管是从左到右，还是回头计算。只不过这道题要求了栈，才特地构建了这个类。 177 178 当然，人生苦短，如果是面试，我们需要认真的讲解自己的想法。如果是机考，建议直接eval！！ 179 """
1 exp_list = [] 2 h_exp_list = [] 3 stack_1 = [] 4 stack_2 = [] 5 6 7 def strtolist(): 8 """处理输入""" 9 r_exp = list(input()) 10 for i in range(len(r_exp)): 11 if (r_exp[i] == '[') or (r_exp[i] == '{'): 12 r_exp[i] = '(' 13 if (r_exp[i] == ']') or (r_exp[i] == '}'): 14 r_exp[i] = ')' 15 16 flag = 1 17 number = 0 18 19 for i in range(len(r_exp)): 20 # 对负数的处理，第一个数是负数和左括号后面有减号就是负数。 21 if (i == 0 and r_exp[i] == '-') or (r_exp[i - 1] == '(' and '-' == r_exp[i]): 22 flag = -1 23 elif '0' <= r_exp[i] <= '9': 24 number = number * 10 + int(r_exp[i]) 25 if len(r_exp) == i + 1 or r_exp[i + 1] < '0' or r_exp[i + 1] > '9': 26 exp_list.append(flag * number) 27 number = 0 28 flag = 1 29 else: 30 exp_list.append(r_exp[i]) 31 32 33 def process(ch): 34 "中缀表达式转后缀表达式" 35 if ('(' == ch): # 读到左括号时，将其压入堆栈中。 36 stack_1.append(ch) 37 # 遇到右括号时，右括号本身不入栈，从栈顶开始弹出操作符，放入输出流，直到遇到一个左括号为止，将这个左括号弹出，但是不放入输出流。 38 elif (')' == ch): 39 while True: 40 tmp = stack_1.pop() 41 if tmp != '(': 42 h_exp_list.append(tmp) 43 else: 44 break 45 elif '*' == ch or '/' == ch: 46 while True: 47 if 0 == len(stack_1): 48 stack_1.append(ch) 49 break 50 else: 51 tmp = stack_1.pop() 52 if (tmp == '*') or (tmp == '/'): 53 h_exp_list.append(tmp) 54 else: 55 stack_1.append(tmp) 56 stack_1.append(ch) 57 break 58 elif '+' == ch or '-' == ch: 59 while True: 60 if 0 == len(stack_1): 61 stack_1.append(ch) 62 break 63 else: 64 tmp = stack_1.pop() 65 if '(' != tmp: 66 h_exp_list.append(tmp) 67 else: 68 stack_1.append(tmp) 69 stack_1.append(ch) 70 break 71 else: 72 h_exp_list.append(ch) 73 74 75 strtolist() 76 77 for ch in exp_list: 78 process(ch) 79 80 L = len(stack_1) 81 while L: 82 h_exp_list.append(stack_1.pop()) 83 L -= 1 84 85 86 def calcuValue(h_exp_list): 87 for i in range(len(h_exp_list)): 88 if h_exp_list[i] in ['+', '-', '*', '/']: 89 op2 = stack_2.pop() 90 op1 = stack_2.pop() 91 if h_exp_list[i] == '+': 92 res = op1 + op2 93 elif h_exp_list[i] == '-': 94 res = op1 - op2 95 elif h_exp_list[i] == '*': 96 res = op1 * op2 97 elif h_exp_list[i] == '/': 98 res = op1 / op2 99 stack_2.append(res) 100 else: 101 stack_2.append(h_exp_list[i]) 102 103 104 calcuValue(h_exp_list) 105 result_list = str(stack_2[0]).split('.') 106 if result_list[-1] == '0': 107 print(result_list[0]) 108 else: 109 print(stack_2[0])
1 def isSuShu(x): 2 if x <= 2: 3 return True 4 else: 5 for i in range(2, int(x ** 0.5) + 1): 6 if x % i == 0: 7 return False 8 else: 9 return True 10 11 while True: 12 try: 13 n = int(input()) 14 15 for i in range(int(n / 2), n): 16 if isSuShu(i) and isSuShu(n - i): 17 print(n - i) 18 print(i) 19 break 20 except: 21 break 22 23 ############################### 24 import copy 25 while True: 26 try: 27 n = int(input()) 28 s_i=[] 29 for i in range(2,int(n/2)+1): 30 for j in range(2,i): 31 if i%j ==0: 32 break 33 else: 34 s_i.append(i) 35 s_j = copy.deepcopy(s_i) 36 for i in s_i: 37 for j in range(2,n-i): 38 if (n-i)%j==0: 39 s_j.remove(i) 40 break 41 t=max(s_j) 42 print(t) 43 print(n-t) 44 45 except: 46 break 47 ############################## 48 list_prime = [2,3] 49 def isprime(num): 50 n = 0 51 if num > 2: 52 for i in range(2,int(num**0.5)+1): 53 if num%i == 0 and i != 1: 54 n = n+1 55 break 56 if n == 0: 57 return 1 58 else: 59 return 0 60 61 for i in range(4,1000): 62 if isprime(i): 63 list_prime.append(i) 64 65 import bisect 66 while 1: 67 try: 68 a = int(input()) 69 place = bisect.bisect(list_prime,a//2) 70 for i in range(1,place+1): 71 if isprime(a - list_prime[place-i]): 72 print(list_prime[place-i]) 73 print(a-list_prime[place-i]) 74 break 75 except: 76 break 77 78 79 #############################33 80 import math 81 82 83 def prime(m): 84 """求一个数的质因子""" 85 lst = [] 86 for i in range(2, int(math.sqrt(m)) + 1): 87 while m % i == 0: 88 lst.append(i) 89 m = m // i 90 if m >= 2: 91 lst.append(m) 92 return lst 93 94 95 while True: 96 try: 97 n = int(input()) 98 prime_num = [] # 预定义列表，用于放置输入偶数以内的素数（质数） 99 temp = [] # 预定义列表，用于放置相加等于输入偶数的素数（质数） 100 for i in range(2, n + 1): # 输入的偶数大于2 101 if len(prime(i)) == 1: # 质因子只有一个，即质因子只包含本身，即素数。此处获取到的素数列表必然为升序 102 prime_num.append(i) 103 for i in range(len(prime_num)): # 开始遍历循环输入偶数范围内的所有素数，获取相加等于输入偶数的素数 104 for j in range(i, len(prime_num)): # 注意j从i开始遍历，保证列表中当前元素不会和前边元素相加 105 if prime_num[i] + prime_num[j] == n: 106 temp.append(prime_num[i]) 107 temp.append(prime_num[j]) 108 # 获取到的相加等于输入偶数的素数列表，差值最小的两个素数必然位于列表末尾（因为素数列表prime_num是升序） 109 print(temp[-2]) 110 print(temp[-1]) 111 except: 112 break 113 114 115 ########################33 116 while True: 117 try: 118 a = int(input()) 119 b = [] 120 121 122 # 质数判断 123 def prime(n): 124 s = [] 125 for i in range(1, n // 2 + 1): 126 if n % i == 0: 127 s.append(i) 128 if len(s) != 1: 129 return False 130 else: 131 return True 132 133 134 # 找到所有质数对 135 for i in range(2, a // 2 + 1): 136 for j in range(i, a): 137 if i + j == a and prime(i) and prime(j): 138 b.append([i, j]) 139 140 d = {} # 新建字典 141 # 找到质数对的最短距离 142 for i in range(len(b)): 143 d[i] = b[i][1] - b[i][0] 144 mini = min(d.values()) 145 # 看哪个质数对达到了最短举例就输出对应的质数对 146 for i in range(len(b)): 147 if d[i] == mini: 148 print(b[i][0]) 149 print(b[i][1]) 150 except: 151 break 152 #################################
我的
1 while True: 2 try: 3 n = int(input()) 4 l1,l2,l3 = [],[],[] 5 dict1={} 6 for a in range(2,n): 7 if n %a !=0 and a <n//2: 8 l1.append(a ) 9 #print(l1) #得到了一个奇数的列表 10 for b in range(2,n): 11 if n %b !=0 and b >n//2: 12 l2.append(b) 13 print(l2) #得到了一个奇数的列表 14 for i in range(len(l1)): 15 for j in range(len(l2)): 16 if l1[i]+l2[j]==n: 17 dict1[l1[i]] =l2[j] 18 print(dict1) 19 for k in dict1: 20 l3 .append( dict1[k]-k) 21 # print(l3) 22 # print(min(l3)) 23 for k,v in dict1.items(): 24 if v-k==min(l3): 25 print(k,v) 26 27 except: 28 break
1
