工作室课题研究宣传稿_工作室课题级别划分规定?

问题描述：
幸运数是波兰数学家乌拉姆命名的。它采用与生成素数类似的“筛法”生成。
首先从1开始写出自然数1,2,3,4,5,6,…
1 就是第一个幸运数。
我们从2这个数开始。把所有序号能被2整除的项删除，变为：
1 _ 3 _ 5 _ 7 _ 9 …
把它们缩紧，重新记序，为：
1 3 5 7 9 … 。这时，3为第2个幸运数，然后把所有能被3整除的序号位置的数删去。注意，是序号位置，不是那个数本身能否被3整除!! 删除的应该是5，11, 17, …
此时7为第3个幸运数，然后再删去序号位置能被7整除的(19,39,…)
最后剩下的序列类似：
1, 3, 7, 9, 13, 15, 21, 25, 31, 33, 37, 43, 49, 51, 63, 67, 69, 73, 75, 79, …
输入要求：
输入两个正整数m n, 用空格分开 (m < n < 1000*1000)
输出要求：
程序输出 位于m和n之间的幸运数的个数（不包含m和n）。
Sample Input 1
1 20
Sample Output 1
5
HINT:时间限制：1.0s 内存限制：256.0M

#解题思路：既然是求在一个区间的幸运数，那我们可以先求出大的数到1的幸运数，在求出小的数的，然后相减即可
python代码为：

def f(x):  # f返回1-x中有多少个幸运数字
    if x == 1:
        return 1
    s = [i for i in range(1,x + 1)]
    temp = 2
    cnt = 1
    #print("0",s)
    #flag = 1
    while len(s) >= temp:
        s1 = [s[i] for i in range(len(s)) if (i + 1) % temp != 0]#用来存储幸运数字的
     #   print(flag,s1)
        temp = s1[cnt]
        cnt += 1
        s = s1
      #  flag += 1
    if m in s1 or n in s1:
        return len(s1)
    else:
        return len(s1)
m, n = map(int, input().split())  # 完成输入
print(f(n) - f(m))

问题描述：
一个有N个元素的集合有2^{N个不同子集（包含空集），现在要在这2}N个集合中取出若干集合（至少一个），使得它们的交集的元素个数为K，求取法的方案数，答案模1000000007。
输入要求：
输入一行两个整数N，K
输出要求：
输出一个整数表示答案。
Sample Input 1
3 2
Sample Output 1
6
HINT:时间限制：1.0s 内存限制：256.0MB
1 <= K <= N <= 10 ^ 6。
解题思路：先定义3个数组，和4个标志数组，然后进行提取求和操作。
c++代码为：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

问题描述：
作为一名网络警察，你的任务是监视电子邮件，看其中是否有一些敏感的关键词。不过，有些狡猾的犯罪嫌疑人会改变某些单词的字母顺序，以逃避检查。请编写一个程序，发现这种调整过顺序的关键词。程序的输入有两行，第一行是关键词列表，第二行是待检查的句子。程序的输出为在该句子中所找到的经过顺序调整的关键词。（单词全部为小写，单词之间以一个空格分隔，每一行的单词个数不限）
输入要求：
第一行是关键词列表，第二行是待检查的句子。
出去要求：
经过顺序调整的关键词。（单词全部为小写，单词之间以一个空格分隔，每一行的单词个数不限）
Sample Input 1
guns mines missiles
aameric ssell snug dan iimsssle ot sit neeemis
Sample Output 1
guns missiles
HINT:时间限制：1.0s 内存限制：256.0MB

#解题思路:先将关键词排序，然后将排序之后的关键词和原关键词组成一个字典，然后将输出的句子也是如此，然后进行键值对比较进行输出。
python代码为：

key = input().split()
sentence = input().split()
KEY = {}
SENT = {}
P = []
for i in key:
    k = list(i)
    k.sort()
    KEY["".join(k)] = i
#print(KEY)
for i in sentence:
    sen = list(i)
    sen.sort()
    SENT["".join(sen)] = i
#print(SENT)
for i in KEY.keys():
    for j in SENT.keys():
        if j == i:
            P.append(KEY[i])
print(" ".join(P))

问题描述：
给定区间[L, R] ， 请计算区间中素数的个数。
输入要求：
两个数L和R。
输出要求：
一行，区间中素数的个数。
Sample Input 1
2 11
Sample Output 1
5
HINT:时间限制：1.0s 内存限制：256.0MB
2 <= L <= R <= 2147483647 R-L <= 1000000

解题思路：用个for循环一个限制区间，一个在区间里判断。利用for else语句可以计算2
python代码为：

n, m = map(int, input().split())
count = []
if n == 2:
    count.append(1)
    n +=1
for i in range(n, m + 1):
    for j in range(2, i):
        if i % j == 0:
            break
    else:
        count.append(1)
print(len(count))

L,R = map(int,input().split())
count = []
for i in range(L,R+1):
    for j in range(2,i):
        if i % j == 0:
            break
    else:
            count.append(i)
print(len(count))
但是不知道为啥都不能ac

//可以ac的代码
#include
#define ll long long
int f[1000001];
int t[1000001];
int s=0;
void init(ll l,ll r)
{
    for(ll i=2;i*i(l+1)/i?2:(l+1)/i)*i;j 
凶手 
问题描述：
 巴斯维克命案抓住了六个嫌疑犯，他们的口供如下：
 A：我不是罪犯
 B：A、C中有一个是罪犯
 C：A和B说了假话
 D：C和F说了假话
 E：其他五个人中，只有A和D说了真话
 F：我是罪犯
 他们中只有一半说了真话，凶手只有一个。
 本题可能有多种可能性，即正确答案（找到唯一的凶手）可能有多个，但每一个可能的答案（某一个是凶手）都满足上述口供。
 请编程找出可能的凶手输出。
 样例：（假设唯一的凶手是A或者D或者E，则输出结果为三行，按字母顺序依次输出）
 A
 D
 E
 输入输出要求上所示
 HINT:时间限制：1.0s 内存限制：256.0MB
 
解题思路:首先可以判断出c一定说了假话，所以对于d我们直接写出!=6即可，然后依次cout+=1，最后判断cout，和i输出结果
 python代码为：
 
#首先可以判断出c一定说了假话，所以对于d我们直接写出!=6即可，然后依次cout+=1，最后判断cout，和i输出结果

for i in range(6):
    cout = 0
    if i != 1:
        cout += 1
    if i == 1 or i == 3:
        cout += 1
    if i != 6:
        cout += 1
    if i != 1 and i != 3 and i != 6:
        cout += 1
    if i == 6:
        cout += 1
    if cout == 3:
        if i == 1:
            print("A")
        if i == 2:
            print("B")
        if i == 3:
            print("C")
        if i == 4:
            print("D")
        if i == 5:
            print("E")
        if i ==6:
            print("F")
 
测试 
质因数 
问题描述：
 将一个正整数N(1 输入要求：
 一行，一个正整数
 输出要求：
 两行，第一行为用空格分开的质因数
 第二行为质因数的个数
 Sample Input 1
 66
 Sample Output 1
 2 3 11
 3
 HINT:时间限制：1.0s 内存限制：256.0MB
 
解题思路;本题主要逻辑，从i=2开始，依次取模，找到则存进flag中，然后输出
 python代码为：
 
#本体主要逻辑，从i=2开始，依次取模，找到则存进flag中，然后输出

n = int(input())
i = 2
flag = []
while i <= n:
    if i == n:
        flag.append(i)
        break
    elif n % i == 0:
        flag.append(i)
        n = n / i
    else:
        i += 1
for i in flag:
    print(i,end=" ")
print("")
print(len(flag))
 
淘淘的名单 
问题描述：
 by ZBY…  淘淘拿到了一份名单，他想对上面的名字进行处理，挑出一些特殊的名字，他请你来帮忙。
 淘淘关注以下名字：
 如果这个名字是“WYS”，他希望你的程序输出“KXZSMR”。
 如果这个名字是“CQ”，他希望你的程序输出“CHAIQIANG”。
 如果这个名字是“LC“，他希望你的程序输出“DRAGONNET”。
 如果这个名字是“SYT”或“SSD”或“LSS”或“LYF”，他希望你的程序输出“STUDYFATHER”。
 如果这个名字与上述任意名字都不相同，他希望你的程序输出“DENOMINATOR”。
 输入要求：
 第一行有一个整数N，表示淘淘手中名单里的人数。
 接下来N行，每行有一个字符串，即名单里的人名。
 输出要求：
 输出N行，每行输出每个人名的判断结果。
 Sample Input 1
 9
 WYS
 CQ
 WYS
 LC
 SYT
 SSD
 LSS
 LYF
 ZBY
 Sample Output 1
 KXZSMR
 CHAIQIANG
 KXZSMR
 DRAGONNET
 STUDYFATHER
 STUDYFATHER
 STUDYFATHER
 STUDYFATHER
 DENOMINATOR
 HINT:时间限制：100ms 内存限制：8.0MB
 对于 50% 数据，N <= 1000，且名单中的名字仅可能为“WYS”,“CQ”,“LC”三者之一，没有其他的名字。
 对于 100% 数据，N <= 10000，人名仅由大写字母组成，长度不超过5。
 
解题思路：先将目标存成一个字典，然后我们可以将输入的字符串与字典的键相比较，相等则输出值，不相等则输出DENOMINATOR。
 python代码为：
 
#

Name = {'WYS':'KXZSMR', 'CQ':'CHAIQIANG', 'LC':'DRAGONNET', 'SYT':'STUDYFATHER', 'SSD':'STUDYFATHER', 'LSS':'STUDYFATHER', 'LYF':'STUDYFATHER'}
Num = int(input())
IN = []
for i in range(Num):
    a = input()
    IN.append(a)
for i in range(Num):
    for k in Name.keys():
        if IN[i] == k:
            print(Name[k])
            break
    else:
        print("DENOMINATOR")
 
现代诗如蚯蚓 
问题描述：
 现代诗如蚯蚓
 断成好几截都不会死
 字符串断成好几截
 有可能完全一样
 请编写程序
 输入字符串
 输出该字符串最多能断成多少截完全一样的子串
 输入要求：
 一行，一个字符串
 输出要求：
 一行，一个正整数表示该字符串最多能断成的截数
 Sample Input 1
 abcabcabcabc
 Sample Output 1
 4
 HINT:时间限制：1.0s 内存限制：256.0MB
 最多能断成四个”abc”，也就是abc重复四遍便是原串
 同时也能断成两个”abcabc”
 最坏情况是断成一个原串”abcabcabcabc”
 
解题思路：首先设置一个v作为计数器，然后进行循环地板除，然后判断循环字符串的长度能否为i，不能则继续执行，取出字符串的前i个字符，进行重复，如果相等则结束
 python代码为：
 
#

a = input()
n = len(a)
v = 1
for i in range(1, n // 2):  # 地板除
    if n % i != 0:  # 判断循环子字符串的长度能否为i
        continue  # 跳出本次循环

    temp = a[:i] * (n // i)  # 将字符串的前i个字符取出，重复(n//i)次
    if temp == a:  # 判断temp和s是否相等
        v = n // i
        break
print(v)
 
质数的后代 
问题描述：
 在上一季里，曾提到过质数的孤独，其实从另一个角度看，无情隔膜它们的合数全是质数的后代，因为合数可以由质数相乘结合而得。
 如果一个合数由两个质数相乘而得，那么我们就叫它是质数们的直接后代。现在，给你一系列自然数，判断它们是否是质数的直接后代。
 输入要求：
 第一行一个正整数T，表示需要判断的自然数数量
 接下来T行，每行一个要判断的自然数
 输出要求：
 共T行，依次对于输入中给出的自然数，判断是否为质数的直接后代，是则输出Yes，否则输出No
 Sample Input 1
 4
 3
 4
 6
 12
 Sample Output 1
 No
 Yes
 Yes
 No
 HINT:时间限制：1.0s 内存限制：256.0MB
 1<=T<=20
 2<=要判断的自然数<=105
 
解题思路：定义一个flag用来存储目标，然后在循环中进行取模和标志v的运算。然后输出
 python代码为：
 
#

Num = int(input())
flag = []
for i in range(Num):
    a = int(input())
    num = 1
    v = 0
    while v <= 2:
        num += 1
        if a % num == 0:
            a /= num
            if a == 1:
                v += 1
                break
            else:
                num = 1
                v += 1
    if v == 2:
        flag.append("Yes")
    else:
        flag.append("No")
for j in flag:
    print(j)
 
彩票 
问题描述：
 为丰富男生节活动，贵系女生设置彩票抽奖环节，规则如下：
 1、每张彩票上印有7个各不相同的号码，且这些号码的取值范围为[1, 33]；
 2、每次在兑奖前都会公布一个由七个互不相同的号码构成的中奖号码；
 3、共设置7个奖项，特等奖和一等奖至六等奖。兑奖规则如下：
 特等奖：要求彩票上的7个号码都出现在中奖号码中；
 一等奖：要求彩票上的6个号码出现在中奖号码中；
 二等奖：要求彩票上的5个号码出现在中奖号码中；
 。。。。
 六等奖：要求彩票上的1个号码出现在中奖号码中；
 注：不考虑号码出现的顺序，例如若中奖号码为23 31 1 14 19 17 18，则彩票12 8 9 23 1 16 7由于其中有两个号码（23和1）出现在中奖号码中，所以该彩票中了五等奖。
 现已知中奖号码和李华买的若干彩票的号码，请你写一个程序判断他的彩票中奖情况。
 输出要求：
 第一行一个正整数n，表示彩票数量，第二行7个整数，表示中奖号码，下面n行每行7个整数，描述n张彩票。
 输出要求：
 7个空格隔开的数字，第1个数字表示特等奖的中奖张数，第2个数字表示一等奖的中奖张数，第3个数字表示二等奖的中奖张数……第7个数字表示六等奖的中奖张数。
 Sample Input 1
 3
 1 2 3 4 5 6 7
 11 12 13 14 15 16 17
 12 13 14 15 16 17 18
 8 7 10 9 31 30 29
 Sample Output 1
 0 0 0 0 0 0 1
 HINT:时间限制：1.0s 内存限制：256.0MB
 30%的数据n<=100；
 70%的数据n<=1000；
 100%的数据n<=100000。
 提示：数组定义为全局变量，可以分配更多内存。
 
解题思路：先将中奖号码保存为flag，然后在依次比较，如果在flag中，则+=1。
 python代码为：
 
#

def F():
    for i in range(n):
        temp = list(map(int, input().split()))
        num = 0
        for j in range(7):
            if temp[j] in flag:
               num += 1
        if num != 0:
            Y[-num] += 1

n = int(input())
flag = list(map(int, input().split()))
Y = [0] * 7 #直接重复7此，【0，0，0，0，0，0，0】
#print(Y)
F()
for i in range(7):
    print(Y[i],end=" ")
 
相关连接：
 /和%和//（地板除）
 位运算符
 for / else语句