PYTHON 牛客刷题记录

sorted()：针对可遍历对象进行排序，生成新的列表。
sort()：只可针对列表排序。

# 针对字典,则根据key进行默认的升序，然后输出key的升序列表
a={'0':'5','1':'7'}
sorted(a)
>>>[0,1]
# 第二个参数：key
a=[{'age':25,'name':'Jack'},{'age':20,'name':'Mack'}]
sorted(a,key=lambda x:x['age'])
>>>[{'age':20,'name':'Mack'}，{'age':25,'name':'Jack'}]
# 第三个参数：reserve=False，默认Falue为升序，True为倒序。
a=[3,2,6,7,1]
sorted(a,reserve=True)
>>>[7,6,3,2,1]

描述
数据表记录包含表索引index和数值value（int范围的正整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照index值升序进行输出。
提示:
0 <= index <= 11111111
1 <= value <= 100000

输入描述：
先输入键值对的个数n（1 <= n <= 500）
接下来n行每行输入成对的index和value值，以空格隔开

输出描述：
输出合并后的键值对（多行）
输入：
4
0 1
0 2
1 2
3 4
复制
输出：
0 3
1 2
3 4

while True:
    try:
        n=int(input())
        dct={}
        for i in range(n):
            key,value=map(int,input().split())
            if key not in dct:
                dct[key]=value
            else:
                dct[key]+=value
        for i in sorted(dct):
            print(i,dct[i])
    except:
        break

join()：将序列(可以是字符串，不能是int)以指定的字符进行拼接，形成字符串。
列表变成字符串map(str,lst)
描述
题目标题：

将两个整型数组按照升序合并，并且过滤掉重复数组元素。
输出时相邻两数之间没有空格。

输入描述：
输入说明，按下列顺序输入：
1 输入第一个数组的个数
2 输入第一个数组的数值
3 输入第二个数组的个数
4 输入第二个数组的数值

输出描述：
输出合并之后的数组

示例1
输入：
3
1 2 5
4
-1 0 3 2
复制
输出：
-101235

while True:
    try:
        m,x,n,y=input(),input().split(),input(),input().split()
        res=map(str,sorted(map(int,set(x+y))))
        print(''.join(res))
    except:
        break

描述
功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）
数据范围： 1 \le n \le 2 \times 10^{9} + 14 \1≤n≤2×10
9
+14
输入描述：
输入一个整数
输出描述：
按照从小到大的顺序输出它的所有质数的因子，以空格隔开。

示例1
输入：
180
复制
输出：
2 2 3 3 5

import math
while True:
    try:
        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)
    except:
        break
# 可能质数因子是本身
# 可能剩下来的质数大于n^1/2
# math.sqrt()的使用，这是求质数时减少算法的必用方法
# 最好的办法：每次能被除的时候，直接输出，结尾带上end=" "
# n=n//i，每次被除完，n需要更新值。且//代表整除，/有1位小数。
# while 和 if的区别：if循环语句只执行1次，成功就不回来。while条件判断，遇到FALSE才退出循环

解题思路：创建节点类，创建链表类(包含判断是否为空、元素添加、输出第N个节点值)。目标函数：创建实例，再调用添加、输出的方法。
描述
输入一个单向链表，输出该链表中倒数第k个结点，链表的倒数第1个结点为链表的尾指针。

链表结点定义如下：
struct ListNode
{
int m_nKey;
ListNode* m_pNext;
};
正常返回倒数第k个结点指针，异常返回空指针.
要求：
(1)正序构建链表;
(2)构建后要忘记链表长度。
数据范围：链表长度满足 1 \le n \le 1000 \1≤n≤1000 ， k \le n \k≤n ，链表中数据满足 0 \le val \le 10000 \0≤val≤10000

本题有多组样例输入。

输入描述：
输入说明
1 输入链表结点个数
2 输入链表的值
3 输入k的值

输出描述：
输出一个整数

示例1
输入：
8
1 2 3 4 5 6 7 8
4
复制
输出：
5

# 定义一个结点类
class Node(object):
    # 初始化类的属性
    def __init__(self,data):
        self.data=data
        self.next=None # 用来保存下一个结点对象，初始化为None
# 定义一个链表类
class LinkList(object):
    def __init__(self,node=None):
        self.head=node
        
    # 判断链表是否为空
    def is_empty(self):
        if self.head is None:
            return True
        else:
            return False
    
    # 链表尾部添加对象，首先一定得判断链表是否为空
    def append(self,item):
        node=Node(item) # 用item的值，创建链表
        
        if self.is_empty():
            self.head=node
        
        else:
            cur=self.head 
            
            while cur.next is not None:
                cur=cur.next 
            cur.next=node
            
    # 输出打印第N个节点的值
    def print_node(self,num):
        cur=self.head
        for i in range(0,num-1):
            cur=cur.next 
        print(cur.data)

if __name__=='__main__':
    while True:
        try:
            n,lst,k=int(input()),input().split(),int(input())
            if k==0:
                print(0)
            else:
                # 注意给单链表添加元素的方法
                link_lst=LinkList()
                for i in lst:
                    link_lst.append(i)
            link_lst.print_node(n-k+1)  # 此处可直接输出结果
        except:
            break