宁妄判断一个数是否是纯粹素数。那问题描述是说，这个数本身必须是素数，然后每次去掉最高位之后剩下的数还是素数，直到最后剩下的一位数也是素数。那我得怎么做呢？
首先，我得明白什么是纯粹素数的条件。比如说，比如输入1013，输出是yes。那1013本身是素数，去掉最高位1之后得到013，也就是13，13是素数。再去掉最高位得到3，3也是素数。所以每一步都是素数，所以符合条件。那这样需要每一步都检查是否是素数。
那我的思路应该是这样的：首先，判断这个数本身是否是素数。如果不是的话，直接返回no。如果是的话，接着依次去掉最高位，形成新的数，再判断是否是素数。这个过程要一直持续到只剩下最后一位数为止，并且每一步都必须是素数。
那问题来了，怎么处理去掉最高位的步骤呢？比如，如何把一个数的最高位去掉？比如，1013去掉最高位是变成013，也就是13。那可以将这个数转换为字符串，然后去掉第一个字符，剩下的部分转换为整数。比如，n_str = str(n)，然后剩下的数是n_str[1:]，如果剩下的字符串不为空的话。这样处理可能比较简单。
所以，步骤可能是这样的：
1. 检查输入数N是否为素数。如果不是，直接输出no。
2. 如果是的话，将N转换为字符串，然后循环去掉第一个字符，生成新的数。
3. 对每一个新生成的数，检查是否为素数。
4. 只要其中有一个不是素数，就返回no。
5. 如果所有步骤都通过，返回yes。
那现在需要解决的问题有两个部分：一个是判断素数的函数，另一个是生成各个去掉最高位的数。
首先，关于素数的判断。对于大数来说，比如1e9，普通的试除法可能会比较慢。不过这里题目中的N最大是1e9，但每次去掉最高位后的数会越来越小。比如，最大的情况是当N是10位的时候，比如十亿，那么去掉最高位后变成九位数，比如000000000？或者原数可能是十位数？比如题目中的条件是N<=1e9，所以N最多是9位数。例如，最大的数是999,999,999。这时候，比如转换成字符串，每次去掉最高位，直到剩下最后一位。
那判断素数的函数需要高效。比如，对于n，如果n是偶数，可以直接排除。然后试除到sqrt(n)。对于较大的n来说，比如1e9，sqrt(n)是3e4左右，每次试除的话大概需要3e4次循环。这可能比较耗时。不过对于这道题来说，可能这样的时间还是可以接受的。比如，假设每个数都要做几次这样的判断，但总体的时间应该还是在允许的范围内。例如，最大的情况是，比如一个9位数，那么需要检查9次素数判断。每次素数判断可能需要最多到sqrt(当前数的值)。比如最大的中间数是比如9位数，那么第一次判断可能需要到3e4次循环。这可能对于Python来说，时间上可能有点紧张，但应该可以通过。或者是否有更好的方法？
或者，可以预处理一些小的素数，或者使用米勒-拉宾素性测试？但题目中给出的样例可能不会有太大的极端情况，或者测试数据不会特别大。所以可能用试除法就可以。但需要注意，在判断素数的时候，要处理n=1的情况。比如，1不是素数。还有n=2是素数。
所以，先写一个判断素数的函数。例如：
def is_prime(n):
if n <= 1:
return False
if n == 2:
return True
if n % 2 == 0:
return False
for i in range(3, int(n**0.5)+1, 2):
if n % i ==0:
return False
return True
这个函数对于n较大的情况可能较慢，比如当n是1e9的时候，这时候试除到3e4左右的数，应该还是可以的。比如，sqrt(1e9)是31622.7766，所以循环次数大约是3e4次的一半，即1.5e4次。对于Python来说，这样的循环次数可能还是可以接受的，尤其是在每个测试用例中最多需要做几次这样的判断。
那接下来，如何处理去掉最高位的数？
例如，对于1013来说，转换成字符串是’1013’。然后依次去掉最高位得到’013’（即13），然后去掉得到’13’中的第一位得到’3’。所以，每次去掉第一个字符，直到只剩一个字符。
所以，可以这样处理：将原始数转换为字符串，然后对于每一位的位置，生成对应的子串，并将其转换为整数，然后检查是否是素数。例如：
n_str = str(n)
for i in range(1, len(n_str)):
current_num = int(n_str[i:])
if not is_prime(current_num):
return False
然后，如果所有current_num都是素数，并且原始数n是素数，那么返回yes。
例如，对于输入样例1013，n_str是’1013’，长度是4。循环i从1到3：
i=1时，current_num是’013’即13 → 检查是否是素数。是的。
i=2时，current_num是’13’ → 是素数。
i=3时，current_num是’3′ → 是素数。
所有都满足，所以返回yes。
那这样处理的话，需要注意当n_str的长度为1的时候，不需要进入循环，直接判断是否是素数即可。比如，n=2的话，是素数，而且没有后续步骤，所以返回yes。
那整个流程的大致步骤是：
1. 将输入n转换为字符串，得到各个位数。
2. 检查各个位数是否为素数，包括原始数，以及每次去掉最高位的数。
例如，对于n=1013来说，需要检查1013、13、3这三个数是否都是素数。
那如何生成这些数呢？比如，将n_str从0位到末尾，每次截取不同的子串？
比如，对于n_str的长度为k，那么需要检查k次。例如，长度为4，那么检查：
n_str[0:], n_str[1:], n_str[2:], n_str[3:]
这样？或者是否应该检查所有可能的截断？比如，比如，原始数是四位的话，应该依次去掉最高位三次，得到三位、两位、一位的数。
比如，原题中的例子1013，是四位，所以需要检查1013（四位）、013→13（三位中的两位？或者原题中的例子的输出显示，1013是四位，所以循环次数是三位吗？
比如，原题中的例子输入是1013，那么处理步骤是：
1013 → 13 → 3 → 所以每次去掉最高位，直到剩下一位。所以，对于长度为4的字符串来说，需要处理三次去掉最高位后的结果。
比如，字符串长度是k的话，需要处理k次？或者k-1次？
比如，原题中的例子中，字符串长度是4，处理三次得到三位数、两位数、一位数。所以循环次数是k-1次。例如，i从1到k-1。每次取n_str[i:]转换为整数。
是的，比如，对于n_str的长度为k，那么总共有k个不同的截断方式吗？例如，原数本身是否包含在检查中？
原问题中的条件中，纯粹素数定义为：这个数本身是素数，然后去掉最高位剩下的数还是素数，再去掉剩下的数的最高位，直到最后一位。因此，原数本身必须被检查是否是素数，然后剩下的每个步骤的数也要检查是否是素数。比如，原数的检查是第一步，然后依次处理去掉最高位的各个数。
因此，例如，对于n=1013，判断的顺序是：
1013 → 素数吗？是。
然后，13 → 素数吗？是。
然后，3 → 素数吗？是。
所以，总共需要检查3次（包括原数吗？或者原数是第一个检查项）。
哦，原问题中的描述是，纯粹素数是一个素数，去掉最高位剩下的数仍为素数，然后继续下去。所以原数本身必须是素数，这是第一个条件。然后剩下的每个步骤中的数都必须满足素数。
所以，步骤应该是：
1. 检查原数是否为素数。如果不是，直接返回no。
2. 生成去掉最高位后的数，逐个检查是否是素数，直到剩下最后一位。
例如，原数可能有很多位数，比如，假设原数是五位数，那么需要检查四位、三位、两位、一位数的情况是否都是素数。
所以，原数是必须被检查的，然后生成各个截断后的数进行检查。
所以，代码的大致逻辑是：
n = 输入的数
s = str(n)
for i in range(len(s)):
current_num = int(s[i:])
if not is_prime(current_num):
print(‘no’)
exit
print(‘yes’)
这样？比如，例如，原数如果是1013，那么i的范围是0到3。i=0时，得到整个数1013，检查是否是素数。i=1时得到013（13），i=2时得到13，i=3时得到3。然后每个步骤都要通过。
那这样是否正确？
是的。因为对于纯粹素数的条件，必须每个截断后的数都是素数。比如，原数本身以及所有可能的截断后的数都必须满足素数条件。
例如，原题中的例子，每个截断后的数都满足。而如果有一个不满足，比如原数是素数，但某个截断后的数不是素数，那么结果就是no。
那这时候，代码的逻辑应该是这样的：
将输入的数字转换为字符串，然后对于每个可能的i（从0到len(s)-1），截取s[i:]转换为整数，检查是否是素数。如果有任何一个不是素数，则返回no。否则返回yes。
例如，比如，当原数是7，那么s的长度是1，i只能取0，检查7是否是素数。是的，所以返回yes。
当原数是23，那么s的长度是2。i=0时检查23是否为素数，是的。i=1时检查3是否为素数，是的。所以返回yes。
那这样的话，正确的逻辑应该是这样的。
那现在，如何实现这个过程？
首先，输入n，然后转换为字符串。然后循环每个i，从0到len(s)-1。每次取s[i:]转换为整数，并检查是否是素数。如果有任何一个不满足，直接输出no。否则，输出yes。
那这样的代码是否正确？
是的。比如，对于原题中的例子，每个截断后的数都是素数。而对于像n=23的例子，各步骤都满足。那对于n=29来说，原数是素数。截断后的数是9，9不是素数。所以整个结果应为no。
那现在，编写代码的思路就比较清晰了。然后需要考虑一些特殊情况，比如n=1的情况，这时候不是素数，所以直接返回no。或者n=2，返回yes。等等。
那现在，我需要先编写is_prime函数，然后处理输入，再遍历所有可能的截断后的数。
那关于截断后的数，比如当原数是1003，转换为字符串后，截断i=1时为’003’，转换为3。但原题中的例子1013截断i=1时的字符串是’013’，转换为13。所以，int函数会自动处理前导零的问题。例如，将’013’转换为13。所以，这一步没有问题。
那现在，代码的大体结构可以是：
n = int(input())
s = str(n)
for i in range(len(s)):
num = int(s[i:])
if not is_prime(num):
print(‘no’)
exit()
print(‘yes’)
同时需要确保is_prime函数正确。
那现在，测试几个例子：
测试样例1：输入1013，输出yes。各个截断后的数：
1013 → 是素数吗？需要确认。假设是的话。然后是13，是素数。然后是3，是素数。所以输出yes。
另一个例子，比如输入23：
23是素数，截断后的数是3，也是素数。所以输出yes。
输入29：29是素数，截断后的数是9，不是素数。所以输出no。
输入7：是素数，所以yes。
输入1：不是素数，所以no。
输入2：是素数，所以yes。
输入13：检查13→素数。截断后的数是3→素数。所以yes。
输入37→37是素数，截断后的数是7→素数。所以yes。
输入31→31是素数。截断后的数是1→不是素数。所以输出no。
所以，这样的逻辑是正确的。
那现在，编写is_prime函数，需要注意处理n=0、1的情况。
比如：
def is_prime(n):
if n <= 1:
return False
if n == 2:
return True
if n % 2 == 0:
return False
max_divisor = int(n**0.5) + 1
for d in range(3, max_divisor, 2):
if n % d == 0:
return False
return True
这样是否正确？
比如，n=3时，max_divisor是sqrt(3)+1≈1.732+1=2.732→int是2。所以循环不会执行，返回True。对的。
n=4的话，在进入函数时会被判断为偶数，返回False。
那这个函数应该正确。
那现在，把这些代码组合起来：
n = int(input())
def is_prime(n):
if n <= 1:
return False
if n == 2:
return True
if n % 2 == 0:
return False
max_divisor = int(n**0.5) + 1
for d in range(3, max_divisor, 2):
if n % d ==0:
return False
return True
s = str(n)
for i in range(len(s)):
num = int(s[i:])
if not is_prime(num):
print(‘no’)
exit()
print(‘yes’)
这样应该可以解决问题了。
那现在，测试一些情况：
比如输入1013：
各个截断后的数是1013、13、3、3。或者i从0到3：
i=0 → ‘1013’ → 1013是否是素数？假设是。那函数判断正确吗？
需要确认1013是否为素数。比如，1013的因数是否有？
比如，1013除以3，3×337=1011，余2。所以不被3整除。除以5，末位是3，不是5的倍数。7？计算可能比较麻烦。但假设1013是素数的话，那么程序会正确输出yes。
那对于这个例子，程序输出正确的结果。
另一个测试，输入2003：
假设2003是素数。那么截断后的数是003 →3，是素数。然后003去掉最高位得到03→3，然后3。所以，所有截断后的数都是素数。所以程序会输出yes？
哦，不。例如，原数2003是否是素数？假设是的话，那么截断后的数依次是2003，003（3），03（3），3。所以每个都是素数。所以输出yes。而程序是否正确处理？
比如，当i=1时，s[i:]是 ‘003’ → int是3。判断是否是素数。是的。i=2时，s[i:]是 ’03’ →3，是素数。i=3时，s[i:]是 ‘3’ →是素数。所以所有步骤通过。所以程序输出yes。
但原数2003是否是素数？比如，2003是否为素数？这可能要具体判断。比如，2003除以3的话，2+0+0+3=5，不是3的倍数。除以17：17×117=1989，余14。可能不是。所以2003可能是一个素数。所以程序在这种情况下会正确输出yes吗？
是的，只要每个截断后的数都是素数。
那看来这个程序应该可以正确处理这些情况。
那现在，关于时间的考虑。例如，当输入是一个9位数的大素数，比如999999937（假设这是素数），那么每次截断后的数都需要判断是否是素数。例如，999999937是否是素数？假设是的，那么截断后的数是99999937、9999937、…，直到7。每个数都需要进行素数判断。这样的情况下，程序是否会在合理的时间内完成？
对于较大的数，例如，最大的截断后的数是原数本身，比如9位数。这时候，素数判断的时间可能较长。例如，当n是1e9时，sqrt(n)是3e4，所以每个素数判断需要循环到3e4次的奇数。对于Python来说，这样的循环可能对于较大的输入会比较慢。但题目中的时间限制可能允许这样的解法，因为每个测试用例的总循环次数是有限的。例如，对于9位数，每次判断可能需要最多3e4次循环，每个截断后的数可能有9次判断，所以总共有约3e5次循环，这在Python中可能需要不到1秒的时间，可能可以接受。
或者，是否存在更高效的方法？比如，预先计算出所有可能的素数，或者使用更高效的素数判断方法？
不过，对于本题来说，可能试除法已经足够，因为输入规模不是特别大。
综上，这个程序应该可以正确解决问题。
为了解决这个问题，我们需要判断一个给定的正整数是否是纯粹素数。纯粹素数的定义是：该数本身是素数，并且每次去掉最高位后剩下的数仍然是素数，直到最后剩下的个位数也是素数。
方法思路
- 素数判断：首先我们需要一个高效的素数判断函数。对于给定的数，我们检查其是否为素数的方法是试除法，即检查从2到该数平方根之间的所有可能的因数。
- 截断处理：将输入的正整数转换为字符串，然后依次去掉最高位，生成新的数，并检查这些新生成的数是否都是素数。
- 逐层验证：从原始数开始，逐层截断并验证每个生成的数是否为素数。如果任何一层验证失败，立即返回结果“no”；如果所有层都通过验证，则返回“yes”。
n = int(input())
def is_prime(num):
if num <= 1:
return False
if num == 2:
return True
if num % 2 == 0:
return False
max_divisor = int(num ** 0.5) + 1
for d in range(3, max_divisor, 2):
if num % d == 0:
return False
return True
s = str(n)
for i in range(len(s)):
current = int(s[i:])
if not is_prime(current):
print("no")
exit()
print("yes")代码解释
- 输入处理：首先读取输入的整数。
- 素数判断函数：
is_prime函数用于判断一个数是否为素数。通过试除法，检查从3到该数平方根之间的所有奇数是否存在因数。 - 字符串转换和截断处理：将输入数转换为字符串，然后遍历每一个可能的截断位置，生成新的数并进行素数判断。
- 逐层验证：对每一个截断生成的数进行素数判断，如果有任何一个数不是素数，立即输出“no”并退出程序；如果所有截断数都是素数，输出“yes”。
该方法通过逐步截断和素数验证，确保了每一步的合法性，最终确定输入数是否为纯粹素数。
