精华内容
下载资源
问答
  • Python】对大数质因数分解的算法疑问前言我的代码百科代码 前言 我是一个初学者,在编写一个分解质因数的代码时,学习到了 Miller-Rabin素数测试算法 Pollard-Rho算法 这两个算法。于是自己编写了一段代码(下...

    【Python】对大数质因数分解的算法问题

    发现问题

      我是一个初学者,在编写一个分解质因数的代码时,学习到了 Miller-Rabin素数测试算法Pollard-Rho算法 这两个算法。试着编写了一段代码(下称C1),运行后效果还不错,但感觉好像哪里不对或者还可以优化,于是在网上搜索。最后在百度百科上看到了一段代码(下称C2),同样使用了上述两个算法。
      运行C2后发现,大多数情况下,运行速度差不多。但发现一个数字a,C2的运行时间比C1慢很多。难道我写的算法更优?

    数字a为11段1/7的循环节:142857142857142857142857142857142857142857142857142857142857142857
    

    C1运行数字a
    C2运行数字a

    尝试分析

      之后的尝试中,又发现1个数字b,会使得C1陷入死循环。分步解析后得出结论是,卡在了 find(n) 函数上。然后发现最可笑的是输入4无法得出因子2。那应该是我的算法错了吧?
      再去理解了一遍 Pollard-Rho算法 ,发现是因为我定义的 find(n) 函数中使用随机函数 f(x)=x^2+a 无法解出因子2,既然如此,加上一个判定即可解决。

    数字b为11段(1/7的循环节+111111):253968253968253968253968253968253968253968253968253968253968253968
    

    C1运行数字b
    C2运行数字b

    最后

      修复后尝试了一些大数,发现C1确实比C2要快。但我还是不敢确定C1的算法是否正确,还望有人可以指正。
      最后尝试一下数字c,算了好久还以为又死循环了,最后C1都运行了2次了C2还没出结果,无奈ctrl+c。看来对于这种大因子的合数分解,这个算法似乎并不好用。

    数字c为费马数2^128+1:340282366920938463463374607431768211457
    

    C1运行数字c

    我的代码(C1)

    import math
    import random
    import time
    start = time.perf_counter()
    
    
    # 判断输入是否为素数
    def prime(n):
        if n in {2, 3, 5, 7, 11}:
            return True
        if n % 2 == 0 or n % 3 == 0 or n % 5 == 0 or n % 7 == 0 or n % 11 == 0:
            return False
        t = 0
        u = n - 1
        while u % 2 == 0:
            t += 1
            u //= 2
        a = random.randint(2, n - 1)
        r = pow(a, u, n)
        if r != 1:
            while t > 1 and r != n - 1:
                r = (r * r) % n
                t -= 1
            if r != n - 1:
                return False
        return True
    
    
    # 寻找输入的一个因数
    def find(n, a):
        def f(x):
            return (x * x + a) % n
        
        # 补上因子为2的判定
        if n % 2 == 0:
            return 2
        
        x1 = random.randint(0, n)
        x2 = x1
        while True:
            x1 = f(x1)
            x2 = f(f(x2))
            p = math.gcd(abs(x2-x1), n)
            if p > 1:
                return p
            if x1 == x2:
                return n
    
    
    num = int(input('Positive integer:'))
    print(f'{num}=')
    
    prime_list = []
    
    while num != 1:
        if prime(num):
            prime_list.append(num)
            break
        else:
            c = find(num, random.randint(0, num-1))
            if prime(c):
                prime_list.append(c)
                num //= c
    
    prime_list.sort()
    print('*'.join(map(str, prime_list)))
    
    end = time.process_time()
    print(f'Running time: {end - start} Seconds')
    

    百科代码(C2)

    摘自百度百科分解质因数,我加入了统计运行时间和输出显示。

    import random
    import time
    start = time.perf_counter()
    
    
    def gcd(a, b):
        if a == 0:
            return b
        if a < 0:
            return gcd(-a, b)
        while b > 0:
            c = a % b
            a, b = b, c
        return a
    
    
    def mod_mul(a, b, n):
        result = 0
        while b > 0:
            if (b & 1) > 0:
                result = (result + a) % n
            a = (a + a) % n
            b = (b >> 1)
        return result
    
    
    def mod_exp(a, b, n):
        result = 1
        while b > 0:
            if (b & 1) > 0:
                result = mod_mul(result, a, n)
            a = mod_mul(a, a, n)
            b = (b >> 1)
        return result
    
    
    def MillerRabinPrimeCheck(n):
        if n in {2, 3, 5, 7, 11}:
            return True
        elif n == 1 or n % 2 == 0 or n % 3 == 0 or n % 5 == 0 or n % 7 == 0 or n % 11 == 0:
            return False
        k, u = 0, n - 1
        while not (u & 1) > 0:
            k += 1
            u = (u >> 1)
        random.seed(0)
        s = 5
        for i in range(s):
            x = random.randint(2, n - 1)
            if x % n == 0:
                continue
            x = mod_exp(x, u, n)
            pre = x
            for j in range(k):
                x = mod_mul(x, x, n)
                if x == 1 and pre != 1 and pre != n - 1:
                    return False
                pre = x
            if x != 1:
                return False
            return True
    
    
    def Pollard_rho(x, c):
        (i, k) = (1, 2)
        x0 = random.randint(0, x)
        y = x0
        while 1:
            i += 1
            x0 = (mod_mul(x0, x0, x) + c) % x
            d = gcd(y - x0, x)
            if d != 1 and d != x:
                return d
            if y == x0:
                return x
            if i == k:
                y = x0
                k += k
    
    
    def PrimeFactorsListGenerator(n):
        result = []
        if n <= 1:
            return None
        if MillerRabinPrimeCheck(n):
            return [n]
        p = n
        while p >= n:
            p = Pollard_rho(p, random.randint(1, n - 1))
        result.extend(PrimeFactorsListGenerator(p))
        result.extend(PrimeFactorsListGenerator(n // p))
        return result
    
    
    lis = PrimeFactorsListGenerator(int(input('n:')))
    print('*'.join(map(str, lis)))
    
    end = time.process_time()
    print(f'Running time: {end - start} Seconds')
    
    展开全文
  • #题目:打印出所有的“水仙花数”,所谓“水仙花数”是指一个三位数,其各位数字立方等于该数本身。例如:153是一个“水仙花数”,因为153=1的三次方+5的三次方+3的三次方。 def 水仙花数(): for i in ...

    题目9

    #题目:打印出所有的“水仙花数”,所谓“水仙花数”是指一个三位数,其各位数字立方和等于该数本身。例如:153是一个“水仙花数”,因为153=1的三次方+5的三次方+3的三次方。

    def 水仙花数():
    
        for i in range(100,1000):
           百位数= i//100
           十位数=i%10
           个位数=(i%100-十位数)/10
           if i==百位数**3+个位数**3+十位数**3:
               print(i)
               i+=1
               continue
    水仙花数()

    题目10

    #题目:将一个正整数分解质因数。例如:输入90,打印出90=2*3*3*5。

    num=int(input("请输入一个正整数:"))
    t=num
    s=[]
    def l(num):

    for i in range(2,t+1):
    if num%i==0:
    s.append(i)
    return l(num/i)
    l(num)
    输出合并 = '*'.join(str(x) for x in s)
    print("{0}={1}".format(num, 输出合并))
    print("Tips:如果返回原值,表示只能被自己整除”)

     

    转载于:https://www.cnblogs.com/xurui89/p/10506826.html

    展开全文
  • 问题描述】土生土长的北京妞儿,在胡同里长大房不多,就一个四合院近郊的别墅。不算美如天仙但还算标致,在清华读的经管,现在在做基金经理,个人擅长基本面分析,价值投资。现在只想找个聪明靠谱的IT男。硬性...
  • 用于处理大型数字数据数组(例如,四个纬度/经度/海拔/时间数据数组)的默认Python库为numpy,而netCDF数据格式在大气科学海洋学中通常使用,因为它可以方便地存储各种变量许多维度。 读取写入netCDF文件的...
  • 将在环Z上分解为n的问题简化为找到n的所有素数。 将数量分解为因子的方法可以分为特殊方法通用方法。 特殊方法对于某些类型的合成数有效,并且通常使用随机数生成器或伪随机显示。 这些方法包括ρ-Pollard方法,...
  • KNN 数据集及源代码 ...(1)分类问题都是监督(supervised)问题,也就是说一定数量的样本类别是已知的。 (2)既然我们已经有了一批分好类的样本,那么接下来的工作自然应该是通过已知样本训练分类...

    KNN

    数据集及源代码
    KNN(k-nearest neighbor)是一个简单而经典的机器学习分类算法,通过度量”待分类数据”和”类别已知的样本”的距离(通常是欧氏距离)对样本进行分类。
    这话说得有些绕口,且来分解一番:
    (1)分类问题都是监督(supervised)问题,也就是说一定数量的样本类别是已知的。
    (2)既然我们已经有了一批分好类的样本,那么接下来的工作自然应该是通过已知样本训练分类器(通过调节分类器的参数,使分类器能够正确对训练样本分类),把分类器训练好以后用于对未知样本的分类(或类别预测)。
    看上去就是这么回事,问题的关键在于分类器的训练。
    但对于KNN分类器来说,事情并不是这个样子的。其实KNN并没有这么复杂。因为KNN并没有什么参数要调,换句话说,KNN其实并不需要训练!
    作为最简单也最好理解的分类器,KNN只是假设数据都分布在欧式的特征空间内(以特征值为坐标区分不同样本的空间),然后我们恰好又知道全部数据在这个空间中的位置以及其中一部分数据的类别。那么现在我们怎么判断剩余那些数据的类别呢?
    为了让分类进行下去,这里其实我们假设:空间中距离越近的点属于一类的可能性越大。
    有了这条“公理”,那事情就好办多了。我们只需要计算每个待分类数据到全部已知类别数据的距离就好了。如图:
    在这里插入图片描述
    有正方形和三角形两个已知类,假如中间的圆形我们不知道它到底是三角形还是正方形。按照上面说的,我们可以正儿八经计算一下它到其他所有点的距离。在这里为了简便,我们目测一下发现它离旁边的三角形最近,好嘞,那么我们就把它归为三角形一类的。
    注意这里我们把未知点和离它最近的那一个点归为一类。这样的分类器,准确来说叫最近邻分类器(nearest-neighbor,NN)。这是KNN的特殊情况,是K=1的情况。
    那么K近邻,顾名思义,就是要一个未知点参考离它最近的前k个一直类别的点,看在这k个点里面,属于哪个类别的点最多,就认为未知点属于哪一类。还是上面的图,以圆形未知点为圆心,在实线画出的圆中,相当于k=3,也就是选了前三个离得最近的点,其中三角形2个,方形1个,所以未知点归到三角形一类。但是当考虑虚线范围内时,也就是k=5时,我们发现方形3个,三角形2个,所以这个时候未知点归到方形一类了。
    所以我们可以发现,不同的最近邻个数往往会导致不同的分类结果,一般来说,我们在实际应用中要根据实际情况和经验确定k的取值。

    算法流程
    对每一个未知点执行:
    1.计算未知点到所有已知类别点的距离
    2.按距离排序(升序)
    3.选取其中前k个与未知点离得最近的点
    4.统计k个点中各个类别的个数
    5.上述k个点里类别出现频率最高的作为未知点的类别

    优缺点

    1.优点:
    简单有效、易理解
    2.缺点:
    k近邻需要保存全部数据集,因此对内存消耗大,当数据集较大时对设备要求非常高;
    需要计算每个未知点到全部已知点的距离,可能会很耗时;
    分类结果不易理解

    原理:

    在这里插入图片描述
    如图已有分类基础上若新来了点该如何分类?

    根据离得最近的点中找最近的k个点以这几个点的类别(label)进行投票以最后比例确定新的点类别的更大可能性

    本质:如果两个样本足够的相似的话他们就有更高的可能性属于同一类。

    鸢尾花

    import numpy as np
    from math import sqrt
    #对003-AI-KNN-datasets-Iris.txt数据进行处理
    raw_data_X=np.loadtxt('003-AI-KNN-datasets-Iris.txt',dtype=float,delimiter=',',usecols=(0,1,2,3))
    raw_data_y=np.loadtxt('003-AI-KNN-datasets-Iris.txt',dtype=str,delimiter=',',usecols=(4))
    #把整个数据集以1:4的比例随机分为测试集和训练集
    arr = np.random.choice(int(len(raw_data_X)),size=30,replace=False)
    X_train=np.delete(raw_data_X,arr,axis=0)
    y_train=np.delete(raw_data_y,arr)
    print("训练集数据")
    print(X_train)
    x_test=[]
    y_test=[]
    for i in arr:
        x_test.append(raw_data_X[i])
        y_test.append(raw_data_y[i])
    X_test=np.array(x_test)
    print("测试集数据")
    print(X_test)
    k=9#k值可以自己设定
    

    欧式距离,曼哈顿距离

    def oushi(x_train,X_test,j):
        return d=sqrt(np.sum((x_train - X_test[j])**2))
    def manhadun(x_train,X_test,j):
        return d=np.sum(abs(x_train-X_test[j]))
    e=0
    for j in range(len(X_test)):
        distance=[]
        for x_train in X_train:
            #oushi(x_train,X_test,j)欧式距离
            #manhadun(x_train,X_test,j)曼哈顿距离
            distance.append(d)
            nearest=np.argsort(distance)
        b=0
        c=0
        a=0
        for l in nearest[:k]:
            #print(l)
            if y_train[l]=='Iris-setosa':
                a=a+1
            elif y_train[l]=='Iris-versicolor':
                b=b+1
            else:
                c=c+1
        if a==max(a,b,c):
            print('第{}组,预测值:Iris-setosa,真实值:{}'.format(j+1,y_test[j]))
            d='Iris-setosa'
        elif b==max(a,b,c):
            print('第{}组,预测值:Iris-versicolor,真实值:{}'.format(j+1,y_test[j]))
            d='Iris-versicolor'
        else:
            print('第{}组,预测值:Iris-virginica,真实值:{}'.format(j + 1, y_test[j]))
            d='Iris-virginica'
        #print(d)
        if d==y_test[j]:
            e=e+1
    print("准确率")
    print(e/len(y_test))
    

    结果

    欧式距离

    第1组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第2组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第3组,预测值:Iris-virginica,真实值:Iris-virginica
    第4组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第5组,预测值:Iris-virginica,真实值:Iris-virginica
    第6组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第7组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第8组,预测值:Iris-virginica,真实值:Iris-virginica
    第9组,预测值:Iris-setosa,真实值:Iris-setosa
    第10组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第11组,预测值:Iris-setosa,真实值:Iris-setosa
    第12组,预测值:Iris-virginica,真实值:Iris-virginica
    第13组,预测值:Iris-virginica,真实值:Iris-virginica
    第14组,预测值:Iris-virginica,真实值:Iris-virginica
    第15组,预测值:Iris-setosa,真实值:Iris-setosa
    第16组,预测值:Iris-virginica,真实值:Iris-virginica
    第17组,预测值:Iris-virginica,真实值:Iris-virginica
    第18组,预测值:Iris-virginica,真实值:Iris-virginica
    第19组,预测值:Iris-setosa,真实值:Iris-setosa
    第20组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第21组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第22组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第23组,预测值:Iris-virginica,真实值:Iris-virginica
    第24组,预测值:Iris-setosa,真实值:Iris-setosa
    第25组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第26组,预测值:Iris-setosa,真实值:Iris-setosa
    第27组,预测值:Iris-virginica,真实值:Iris-virginica
    第28组,预测值:Iris-virginica,真实值:Iris-virginica
    第29组,预测值:Iris-setosa,真实值:Iris-setosa
    第30组,预测值:Iris-virginica,真实值:Iris-versicolor
    准确率
    0.9666666666666667

    曼哈顿距离

    第1组,预测值:Iris-virginica,真实值:Iris-virginica
    第2组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第3组,预测值:Iris-virginica,真实值:Iris-virginica
    第4组,预测值:Iris-virginica,真实值:Iris-virginica
    第5组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第6组,预测值:Iris-virginica,真实值:Iris-virginica
    第7组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第8组,预测值:Iris-virginica,真实值:Iris-virginica
    第9组,预测值:Iris-virginica,真实值:Iris-virginica
    第10组,预测值:Iris-setosa,真实值:Iris-setosa
    第11组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第12组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第13组,预测值:Iris-virginica,真实值:Iris-virginica
    第14组,预测值:Iris-setosa,真实值:Iris-setosa
    第15组,预测值:Iris-setosa,真实值:Iris-setosa
    第16组,预测值:Iris-setosa,真实值:Iris-setosa
    第17组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第18组,预测值:Iris-versicolor,真实值:Iris-virginica
    第19组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第20组,预测值:Iris-setosa,真实值:Iris-setosa
    第21组,预测值:Iris-virginica,真实值:Iris-virginica
    第22组,预测值:Iris-virginica,真实值:Iris-virginica
    第23组,预测值:Iris-setosa,真实值:Iris-setosa
    第24组,预测值:Iris-setosa,真实值:Iris-setosa
    第25组,预测值:Iris-virginica,真实值:Iris-versicolor
    第26组,预测值:Iris-virginica,真实值:Iris-virginica
    第27组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第28组,预测值:Iris-virginica,真实值:Iris-virginica
    第29组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第30组,预测值:Iris-versicolor,真实值:Iris-versicolor
    准确率
    0.933333333333333

    皮尔森,余弦相似度,杰卡德

    def jiekade(x_train,X_test,j):
         d=int(len(set(X_test[j])&set(x_train)))/int(len(set(X_test[j])|set(x_train)))#杰卡德系数
    def piersen(x_train,X_test,j):
          d=np.sum((X_test[j]-np.sum(X_test[j])/int(len(X_test[j])))*(x_train-np.sum(x_train)/int(len(x_train))))/sqrt((np.sum((X_test[j]-np.sum(X_test[j])/int(len(X_test[j])))**2))*(np.sum((x_train-np.sum(x_train)/int(len(x_train)))**2)))#皮尔森相似系数
    def yuxain(x_train,X_test,j):
          d=np.sum(x_train*X_test[j])/(sqrt(np.sum(x_train**2))*sqrt(np.sum(X_test**2)))#余弦相似度
    e=0
    for j in range(len(X_test)):
        distance=[]
        for x_train in X_train:
            # def jiekade(x_train,X_test,j)杰卡德
            # def piersen(x_train,X_test,j)皮尔森
             #def yuxain(x_train,X_test,j)余弦
            distance.append(d)
            nearest=np.argsort(distance)
        b=0
        c=0
        a=0
        ynearest=nearest[::-1]
        for l in ynearest[:k]:
            if y_train[l]=='Iris-setosa':
                a=a+1
            elif y_train[l]=='Iris-versicolor':
                b=b+1
            else:
                c=c+1
        if a==max(a,b,c):
            print('第{}组,预测值:Iris-setosa,真实值:{}'.format(j+1,y_test[j]))
            d='Iris-setosa'
        elif b==max(a,b,c):
            print('第{}组,预测值:Iris-versicolor,真实值:{}'.format(j+1,y_test[j]))
            d='Iris-versicolor'
        else:
            print('第{}组,预测值:Iris-virginica,真实值:{}'.format(j + 1, y_test[j]))
            d='Iris-virginica'
        #print(d)
        if d==y_test[j]:
            e=e+1
    print("准确率")
    print(e/len(y_test))
    

    结果

    余弦相似度

    第1组,预测值:Iris-setosa,真实值:Iris-setosa
    第2组,预测值:Iris-setosa,真实值:Iris-setosa
    第3组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第4组,预测值:Iris-virginica,真实值:Iris-virginica
    第5组,预测值:Iris-virginica,真实值:Iris-virginica
    第6组,预测值:Iris-virginica,真实值:Iris-virginica
    第7组,预测值:Iris-setosa,真实值:Iris-setosa
    第8组,预测值:Iris-virginica,真实值:Iris-virginica
    第9组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第10组,预测值:Iris-versicolor,真实值:Iris-virginica
    第11组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第12组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第13组,预测值:Iris-virginica,真实值:Iris-virginica
    第14组,预测值:Iris-virginica,真实值:Iris-virginica
    第15组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第16组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第17组,预测值:Iris-virginica,真实值:Iris-virginica
    第18组,预测值:Iris-virginica,真实值:Iris-virginica
    第19组,预测值:Iris-setosa,真实值:Iris-setosa
    第20组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第21组,预测值:Iris-virginica,真实值:Iris-virginica
    第22组,预测值:Iris-setosa,真实值:Iris-setosa
    第23组,预测值:Iris-virginica,真实值:Iris-virginica
    第24组,预测值:Iris-virginica,真实值:Iris-virginica
    第25组,预测值:Iris-setosa,真实值:Iris-setosa
    第26组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第27组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第28组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第29组,预测值:Iris-virginica,真实值:Iris-virginica
    第30组,预测值:Iris-versicolor,真实值:Iris-versicolor
    准确率
    0.9666666666666667

    皮尔森

    第1组,预测值:Iris-setosa,真实值:Iris-setosa
    第2组,预测值:Iris-versicolor,真实值:Iris-virginica
    第3组,预测值:Iris-setosa,真实值:Iris-setosa
    第4组,预测值:Iris-setosa,真实值:Iris-setosa
    第5组,预测值:Iris-setosa,真实值:Iris-setosa
    第6组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第7组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第8组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第9组,预测值:Iris-virginica,真实值:Iris-virginica
    第10组,预测值:Iris-setosa,真实值:Iris-setosa
    第11组,预测值:Iris-setosa,真实值:Iris-setosa
    第12组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第13组,预测值:Iris-virginica,真实值:Iris-virginica
    第14组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第15组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第16组,预测值:Iris-setosa,真实值:Iris-setosa
    第17组,预测值:Iris-virginica,真实值:Iris-virginica
    第18组,预测值:Iris-virginica,真实值:Iris-virginica
    第19组,预测值:Iris-virginica,真实值:Iris-virginica
    第20组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第21组,预测值:Iris-setosa,真实值:Iris-setosa
    第22组,预测值:Iris-setosa,真实值:Iris-setosa
    第23组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第24组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第25组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第26组,预测值:Iris-setosa,真实值:Iris-setosa
    第27组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第28组,预测值:Iris-setosa,真实值:Iris-setosa
    第29组,预测值:Iris-setosa,真实值:Iris-setosa
    第30组,预测值:Iris-setosa,真实值:Iris-setosa
    准确率
    0.9666666666666667

    杰卡德

    第1组,预测值:Iris-setosa,真实值:Iris-setosa
    第2组,预测值:Iris-virginica,真实值:Iris-versicolor
    第3组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第4组,预测值:Iris-virginica,真实值:Iris-virginica
    第5组,预测值:Iris-versicolor,真实值:Iris-virginica
    第6组,预测值:Iris-virginica,真实值:Iris-virginica
    第7组,预测值:Iris-virginica,真实值:Iris-virginica
    第8组,预测值:Iris-virginica,真实值:Iris-virginica
    第9组,预测值:Iris-setosa,真实值:Iris-versicolor
    第10组,预测值:Iris-setosa,真实值:Iris-setosa
    第11组,预测值:Iris-setosa,真实值:Iris-setosa
    第12组,预测值:Iris-versicolor,真实值:Iris-virginica
    第13组,预测值:Iris-setosa,真实值:Iris-setosa
    第14组,预测值:Iris-virginica,真实值:Iris-virginica
    第15组,预测值:Iris-setosa,真实值:Iris-setosa
    第16组,预测值:Iris-setosa,真实值:Iris-setosa
    第17组,预测值:Iris-setosa,真实值:Iris-virginica
    第18组,预测值:Iris-virginica,真实值:Iris-virginica
    第19组,预测值:Iris-setosa,真实值:Iris-setosa
    第20组,预测值:Iris-versicolor,真实值:Iris-virginica
    第21组,预测值:Iris-setosa,真实值:Iris-setosa
    第22组,预测值:Iris-virginica,真实值:Iris-virginica
    第23组,预测值:Iris-virginica,真实值:Iris-virginica
    第24组,预测值:Iris-setosa,真实值:Iris-setosa
    第25组,预测值:Iris-setosa,真实值:Iris-setosa
    第26组,预测值:Iris-virginica,真实值:Iris-virginica
    第27组,预测值:Iris-versicolor,真实值:Iris-versicolor
    第28组,预测值:Iris-setosa,真实值:Iris-setosa
    第29组,预测值:Iris-setosa,真实值:Iris-setosa
    第30组,预测值:Iris-versicolor,真实值:Iris-versicolor
    准确率
    0.8

    手写数字识别

    from os import listdir
    from numpy import *
    import numpy as np
    import operator
    def KNN(test_data,train_data,train_label,k):
        # 已知分类的数据集(训练集)的行数
        dataSetSize=train_data.shape[0]
        # 求所有距离:先tile函数将输入点拓展成与训练集相同维数的矩阵,计算测试样本与每一个训练样本的距离
        all_distances=np.sqrt(np.sum(np.square(tile(test_data,(dataSetSize,1))-train_data),axis=1))
        # print("所有距离:",all_distances)
        # 按all_distances中元素进行升序排序后得到其对应索引的列表
        sort_distance_index=all_distances.argsort()
        #print("文件索引排序:",sort_distance_index)
        #选择距离最小的k个点
        classCount={}
        for i in range(k):
            # 返回最小距离的训练集的索引(预测值)
            voteIlabel=train_label[sort_distance_index[i]]
            # print('第',i+1,'次预测值',voteIlabel)
            classCount[voteIlabel]=classCount.get(voteIlabel,0)+1
        # 求众数:按classCount字典的第2个元素(即类别出现的次数)从大到小排序
        sortedClassCount=sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)
        print(sortedClassCount[0][0])
        return sortedClassCount[0][0]
    #文本向量化 32x32 -> 1x1024
    def img2vector(filename):
        returnVect=[]
        fr=open(filename)
        for i in range(32):
            lineStr=fr.readline()
            for j in range(32):
                returnVect.append(int(lineStr[j]))
        #print(returnVect)
        return returnVect
    #从文件名中解析分类数字
    def classnumCut(fileName):
        fileStr=fileName.split('.')[0]
        classNumStr=int(fileStr.split('_')[0])
        return classNumStr
    #构建训练集数据向量,及对应分类标签向量
    def trainingDataSet():
        train_label=[]
        trainingFileList=listdir('trainingDigits')
        m=len(trainingFileList)
        train_data= zeros((m,1024))
        # 获取训练集的标签
        for i in range(m):
            # fileNameStr:所有训练集文件名
            fileNameStr=trainingFileList[i]
            # 得到训练集索引
            train_label.append(classnumCut(fileNameStr))
            train_data[i, :] = img2vector('trainingDigits/%s' %fileNameStr)
        return train_label,train_data
    # 测试函数
    
    Nearest_Neighbor_number=9#k值可自己定义
    train_label,train_data=trainingDataSet()
    testFileList=listdir('testDigits')
    error_sum=0
    test_number=len(testFileList)
    for i in range(test_number):
        # 测试集文件名
        fileNameStr=testFileList[i]
        # 切片后得到测试集索引
        classNumStr=classnumCut(fileNameStr)
        test_data=img2vector('testDigits/%s' % fileNameStr)
        ##调用knn算法进行测试
        classifierResult = KNN(test_data, train_data, train_label, Nearest_Neighbor_number)
        print("第", i + 1, "组:", "预测值:", classifierResult, "真实值:", classNumStr)
        if (classifierResult != classNumStr):
            error_sum+=1
    print ("\n测试集总数为:",test_number)
    print ("测试出错总数:",error_sum)
    print ("\n错误率:",error_sum/float(test_number)*100,'%')
    

    结果

    第 1 组: 预测值: 0 真实值: 0
    第 2 组: 预测值: 0 真实值: 0
    第 3 组: 预测值: 0 真实值: 0
    第 4 组: 预测值: 0 真实值: 0
    第 5 组: 预测值: 0 真实值: 0
    第 6 组: 预测值: 0 真实值: 0
    第 7 组: 预测值: 0 真实值: 0
    第 8 组: 预测值: 0 真实值: 0
    第 9 组: 预测值: 0 真实值: 0
    第 10 组: 预测值: 0 真实值: 0
    第 11 组: 预测值: 1 真实值: 1
    第 12 组: 预测值: 1 真实值: 1
    第 13 组: 预测值: 1 真实值: 1
    第 14 组: 预测值: 1 真实值: 1
    第 15 组: 预测值: 1 真实值: 1
    第 16 组: 预测值: 1 真实值: 1
    第 17 组: 预测值: 1 真实值: 1
    第 18 组: 预测值: 1 真实值: 1
    第 19 组: 预测值: 1 真实值: 1
    第 20 组: 预测值: 1 真实值: 1
    第 21 组: 预测值: 2 真实值: 2
    第 22 组: 预测值: 2 真实值: 2
    第 23 组: 预测值: 2 真实值: 2
    第 24 组: 预测值: 2 真实值: 2
    第 25 组: 预测值: 2 真实值: 2
    第 26 组: 预测值: 2 真实值: 2
    第 27 组: 预测值: 2 真实值: 2
    第 28 组: 预测值: 2 真实值: 2
    第 29 组: 预测值: 2 真实值: 2
    第 30 组: 预测值: 2 真实值: 2
    第 31 组: 预测值: 3 真实值: 3
    第 32 组: 预测值: 3 真实值: 3
    第 33 组: 预测值: 3 真实值: 3
    第 34 组: 预测值: 3 真实值: 3
    第 35 组: 预测值: 3 真实值: 3
    第 36 组: 预测值: 3 真实值: 3
    第 37 组: 预测值: 3 真实值: 3
    第 38 组: 预测值: 3 真实值: 3
    第 39 组: 预测值: 3 真实值: 3
    第 40 组: 预测值: 3 真实值: 3
    第 41 组: 预测值: 9 真实值: 4
    第 42 组: 预测值: 9 真实值: 4
    第 43 组: 预测值: 9 真实值: 4
    第 44 组: 预测值: 9 真实值: 4
    第 45 组: 预测值: 1 真实值: 4
    第 46 组: 预测值: 4 真实值: 4
    第 47 组: 预测值: 9 真实值: 4
    第 48 组: 预测值: 4 真实值: 4
    第 49 组: 预测值: 4 真实值: 4
    第 50 组: 预测值: 4 真实值: 4
    第 51 组: 预测值: 9 真实值: 5
    第 52 组: 预测值: 5 真实值: 5
    第 53 组: 预测值: 5 真实值: 5
    第 54 组: 预测值: 5 真实值: 5
    第 55 组: 预测值: 5 真实值: 5
    第 56 组: 预测值: 5 真实值: 5
    第 57 组: 预测值: 5 真实值: 5
    第 58 组: 预测值: 5 真实值: 5
    第 59 组: 预测值: 5 真实值: 5
    第 60 组: 预测值: 5 真实值: 5
    第 61 组: 预测值: 6 真实值: 6
    第 62 组: 预测值: 6 真实值: 6
    第 63 组: 预测值: 6 真实值: 6
    第 64 组: 预测值: 6 真实值: 6
    第 65 组: 预测值: 6 真实值: 6
    第 66 组: 预测值: 6 真实值: 6
    第 67 组: 预测值: 6 真实值: 6
    第 68 组: 预测值: 6 真实值: 6
    第 69 组: 预测值: 6 真实值: 6
    第 70 组: 预测值: 6 真实值: 6
    第 71 组: 预测值: 7 真实值: 7
    第 72 组: 预测值: 7 真实值: 7
    第 73 组: 预测值: 7 真实值: 7
    第 74 组: 预测值: 7 真实值: 7
    第 75 组: 预测值: 7 真实值: 7
    第 76 组: 预测值: 7 真实值: 7
    第 77 组: 预测值: 7 真实值: 7
    第 78 组: 预测值: 7 真实值: 7
    第 79 组: 预测值: 7 真实值: 7
    第 80 组: 预测值: 7 真实值: 7
    第 81 组: 预测值: 8 真实值: 8
    第 82 组: 预测值: 9 真实值: 8
    第 83 组: 预测值: 8 真实值: 8
    第 84 组: 预测值: 5 真实值: 8
    第 85 组: 预测值: 9 真实值: 8
    第 86 组: 预测值: 8 真实值: 8
    第 87 组: 预测值: 8 真实值: 8
    第 88 组: 预测值: 8 真实值: 8
    第 89 组: 预测值: 8 真实值: 8
    第 90 组: 预测值: 8 真实值: 8
    第 91 组: 预测值: 9 真实值: 9
    第 92 组: 预测值: 9 真实值: 9
    第 93 组: 预测值: 9 真实值: 9
    第 94 组: 预测值: 9 真实值: 9
    第 95 组: 预测值: 9 真实值: 9
    第 96 组: 预测值: 9 真实值: 9
    第 97 组: 预测值: 9 真实值: 9
    第 98 组: 预测值: 9 真实值: 9
    第 99 组: 预测值: 9 真实值: 9
    第 100 组: 预测值: 9 真实值: 9

    测试集总数为: 100
    测试出错总数: 10

    错误率: 10.0 %

    展开全文
  • pangu.py:在中日韩语字符和数字字母之间添加空格。 pypinyin:汉字拼音转换工具 Python 版。 shortuuid:一个生成器库,用以生成简洁的,明白的,URL 安全的 UUID。 simplejson:Python 的 JSON 编码、解码器。 ...
  • Python编程 深入浅出递归

    多人点赞 热门讨论 2021-05-04 14:55:14
    文章目录一、初识递归二、进制转换三、递归可视化四、汉诺塔问题求解五、总结 ...给定一个列表,返回所有数的,列表中数字的个数不定,需要一个循环一个累加变量来迭代求和,那现在既不能用 fo

    一、初识递归

    递归(Recursion)是一种解决问题的方法,其精髓在于将问题分解为规模更小的相同问题,持续分解,直到问题规模小到可以用非常简单直接的方式来解决。递归的问题分解方式非常独特,其算法方面的明显特征就是:在算法流程中调用自身。

    递归为我们提供了一种对复杂问题的优雅解决方案,精妙的递归算法常会出奇简单,令人赞叹。

    给定一个列表,返回所有数的和,列表中数字的个数不定,需要一个循环和一个累加变量来迭代求和,那现在既不能用 for 循坏,也不能用 while 循环,我们可以用递归的方法来解决问题!

    思路:

    • 数列求和问题首先具备了基本结束条件:当列表长度为 1 的时候,直接输出所包含的唯一数。
    • 数列求和处理的数据对象是一个列表,而基本结束条件是长度为 1 的列表,那递归算法就要改变列表并向长度为 1 的状态演进,代码实现时具体做法是将列表长度减少1。
    • 调用自身:实际上可以理解为"问题分解成了规模更小的相同问题",在数列求和算法中就是"更短数列的求和问题"。

    递归实现数列求和如下:

    def sum_n(lst):
         return lst[0] if len(lst) <=1 else lst[0] + sum_n(lst[1:])
    
    print(sum_n([1, 3, 5, 7, 9]))
    

    递归算法三定律:

    • 递归算法必须要有结束条件(最小规模问题的直接解决)
    • 递归算法必须能改变状态向基本结束条件演进(减小问题规模)
    • 递归算法必须调用自身(解决减小了规模的相同问题)

    递归调用的实现:

    • 当一个函数被调用的时候,系统会把调用时的现场数据压入到系统调用栈。每次调用,压入栈的现场数据称为栈帧,当函数返回时,要从调用栈的栈顶取得返回地址,恢复现场,弹出栈帧,按地址返回。
    • 在调试递归算法程序的时候经常会碰到这样的错误:RecursionError: maximum recursion depth exceeded in comparison,原因递归的层数太多,但系统调用栈容量是有限的。

    爆栈是非常危险的操作,在实际开发写递归算法时应尽力避免。Python内置的 sys 模块可以获取和调整最大递归深度,操作如下:

    二、进制转换

    • 十进制有十个不同符号:dec_str=“0123456789”,比 10 小的整数,转换成十进制,直接查表就可以得到:dec_str[n],把比 10 大的整数,拆成一系列比十小的整数,逐个查表,比如七百六十九,拆成七、六、九,查表就可以得到769。
    • 所以,在递归三定律里,我们找到了 “基本结束条件”,就是小于 10 的整数拆解整数的过程就是向“基本结束条件”演进的过程”。
    • 我们用整数除,和求余数两个计算来将整数一步步拆开,除以 “进制基base”(//base) 对 “进制基” 求余数(%base)

    递归实现如下:

    def dec_conversion_n(n, base):
        str_list = "0123456789ABCDEF"
        if n < base:
            return str_list[n]  # 到了最小规模  查表
        else:   # 减小规模  调用自身
            return dec_conversion_n(n // base, base) + str_list[n % base]
    
    print(dec_conversion_n(233, 8))
    

    结果如下:


    还可以写得更优雅一些:

    def dec_conversion_n(n, base):
        str_list = "0123456789ABCDEF"
        return str_list[n] if n < base else dec_conversion_n(n // base, base) + str_list[n % base]
    
    print(dec_conversion_n(233, 8))
    

    余数总小于"进制基base",整数商小于进制基时,达到递归结束条件,可直接进行查表转换,整数商成为 “更小规模” 问题,通过递归调用自身解决。

    三、递归可视化

    通过可视化来展现递归调用。

    import turtle
    
    t = turtle.Turtle()
    def draw_spiral(line_len):
        if line_len > 0:
            t.forward(line_len)
            t.right(90)
            draw_spiral(line_len - 5)
    
    draw_spiral(160)
    turtle.done()
    


    用分形树更形象地展现递归调用。分形是在不同尺度上都具有相似性的事物,分形树特征:子图结构与自身相似,很容易想到递归。

    python中的 turtle 的使用,可以很方便地画出分形树,画分形树的思想也可以用到二叉树的遍历中,实现如下:

    def draw_tree(branch_len):
        if branch_len > 5:
            t.forward(branch_len)
            t.right(20)
            draw_tree(branch_len - 15)
            t.left(40)
            draw_tree(branch_len - 15)
            t.right(20)
            t.backward(branch_len)
    
    
    t = turtle.Turtle()
    t.left(90)
    t.penup()
    t.backward(100)
    t.pendown()
    t.pencolor('red')
    t.pensize(2)
    draw_tree(75)
    t.hideturtle()
    turtle.done()
    

    效果如下:


    把树分解为三个部分:树干、左边的小树、右边的小树分解后,正好符合递归的定义:对自身的调用。

    谢尔宾斯基三角形(英语:Sierpinski triangle)也是一种分形,由波兰数学家谢尔宾斯基在 1915 年提出,它是自相似集的例子。根据自相似特性,谢尔宾斯基三角形是由 3 个尺寸减半的谢尔宾斯基三角形按照品字形拼叠而成,由于我们无法真正做出谢尔宾斯基三角形(degree趋于无穷),只能做 degree 有限的近似图形。

    在 degree 有限的情况下,degree=n的三角形,是由 3 个 degree=n-1 的三角形,按照品字形拼叠而成。同时,这 3 个 degree=n-1 的三角形边长均为degree=n的三角形的一半(规模减小)。当degree=0,则就是一个等边三角形,这是递归基本结束条件。作图如下:

    # -*- coding: UTF-8 -*-
    """
    @Author  :叶庭云
    @公众号  :修炼Python
    @CSDN    :https://yetingyun.blog.csdn.net/
    """
    import turtle
    
    
    def drawTriangle(points, color, my_turtle):   # 绘制等边三角形
        my_turtle.fillcolor(color)
        my_turtle.up()
        my_turtle.goto(points[0][0], points[0][1])
        my_turtle.down()
        my_turtle.begin_fill()
        my_turtle.goto(points[1][0], points[1][1])
        my_turtle.goto(points[2][0], points[2][1])
        my_turtle.goto(points[0][0], points[0][1])
        my_turtle.end_fill()
    
    
    def getMid(p1, p2):       # 取两个点的中心
        return (p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2
    
    
    def sierpinski(points, degree, my_turtle):
        colormap = ['blue', 'red', 'green', 'white',
                    'yellow', 'violet', 'orange']
        drawTriangle(points, colormap[degree], my_turtle)
        if degree > 0:
            sierpinski([points[0],
                        getMid(points[0], points[1]),
                        getMid(points[0], points[2])],
                       degree - 1, my_turtle)
            sierpinski([points[1],
                        getMid(points[0], points[1]),
                        getMid(points[1], points[2])],
                       degree - 1, my_turtle)
            sierpinski([points[2],
                        getMid(points[2], points[1]),
                        getMid(points[0], points[2])],
                       degree - 1, my_turtle)
    
    
    def main():
        myTurtle = turtle.Turtle()
        myWin = turtle.Screen()
        myPoints = [[-100, -50], [0, 100], [100, -50]]   # 外轮廓三个顶点
        sierpinski(myPoints, 4, myTurtle)   # 画degree=5的三角形
        myWin.exitonclick()
    
    
    main()
    
    
    

    效果如下:

    四、汉诺塔问题求解

    问题来源:汉诺塔来源于印度传说的一个故事,上帝创造世界时作了三根金刚石柱子,在一根柱子上从上往下从小到大顺序摞着 64 片黄金圆盘。上帝命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定,在小圆盘上不能放大圆盘,在三根柱子之间一回只能移动一个圆盘,只能移动在最顶端的圆盘。有预言说,这件事完成时宇宙会在一瞬间闪电式毁灭。也有人相信婆罗门至今仍在一刻不停地搬动着圆盘。恩,当然这个传说并不可信,如今汉诺塔更多的是作为一个玩具存在。

    推荐一个可以在线玩汉诺塔小游戏的网站:
    http://www.htmleaf.com/Demo/201508272485.html

    移 3 个盘子演示如下:


    思路:

    • 将盘片塔从开始柱,经由中间柱,移动到目标柱:首先将上层N-1个盘片的盘片塔,从开始柱,经由目标柱,移动到中间柱;然后将第N个(最大的)盘片,从开始柱,移动到目标柱;
    • 最后将放置在中间柱的 N-1 个盘片的盘片塔,经由开始柱,移动到目标柱。基本结束条件,也就是最小规模问题变为:1个盘片的移动问题

    Python代码递归实现如下:

    def move_tower(height, start_pole, mid_pole, target_pole):
        if height >= 1:
            # 开始柱  目标柱  中间柱
            move_tower(height - 1, start_pole, target_pole, mid_pole)
            # 记录移动
            move_disk(height, start_pole, target_pole)
            # 中间柱  开始柱  目标柱
            move_tower(height - 1, mid_pole, start_pole, target_pole)
    
    def move_disk(disk, start_pole, target_pole):
        print(f"将 {disk} 号盘子从 {start_pole}号柱 移到 {target_pole}号柱")
    
    move_tower(3, "1", "2", "3")    # 2^n - 1次
    print("Complete!")
    

    结果如下:


    和动图里我们玩游戏的操作步骤一致!

    五、总结

    递归是解决某些具有自相似性的复杂问题的有效技术

    递归算法三定律:

    • 递归算法必须要有结束条件(最小规模问题的直接解决)
    • 递归算法必须能改变状态向基本结束条件演进(减小问题规模)
    • 递归算法必须调用自身(解决减小了规模的相同问题)

    注意:

    • 某些情况下,递归可以代替迭代循环,递归算法通常能够跟问题的表达自然契合。
    • 递归不总是最合适的算法,有时候递归算法会引发巨量的重复计算,"记忆化/函数值缓存"可以通过附加存储空间记录中间计算结果来有效减少重复计算。
    • 如果一个问题最优解包括规模更小相同问题的最优解,这时我们可以用动态规划来解决。
    展开全文
  • 一、用Python画语音信号的波形 音频信号是模拟信号,我们需要将其保存为数字信号,才能对语音进行算法操作,WAV是Microsoft开发的一种声音文件格式,通常被用来保存未压缩的声音数据。 语音信号有三个重要的参数:...
  • 数字组合实例2. 奖金计算实例3. 完全平方数实例4. 判断某一天实例5. 斐波那契数列实例6. 乘法口诀表实例7. 生兔子问题实例8. 求素数实例9. 水仙花数实例10. 分解质因数实例11. 重复数相加实例12. 求完数实例13. 落...
  • Python编程之打印水仙花数

    千次阅读 2019-03-23 08:33:46
    问题描述:打印出所有的"水仙花数",所谓"水仙花数"是指一个三位数,其各位数字立方等于该数本身。例如:153是一个"水仙花数",因为153=1的三次方+5的三次方+3的三次方。 程序分析:利用for循环控制100-999个数...
  • Python 递归函数 如果一个函数体直接或者间接调用自己,那么这...18117的数字和为:1+8+1+1+7=18.这样我们就可以分割这个数.把这个数分割成最低位7和不包含最低位数字的和1+8+1+1=11.这
  • PYTHON 递归函数

    千次阅读 2016-05-29 18:44:13
    如果一个函数体直接或者间接调用自己,那么这个函数就称为递归函数....在设计递归函数的时候,我们会寻找能把问题分解成简单的问题的方法.在这道题中,运算符%//可以用来把一个数分成两部分:最低
  • 任何优秀程序员所拥有的最基本的技能是将大问题分解为较小的子问题的能力,最好是彼此独立。 我们将看到如何使用Python快速高效地实现模块化,并且一点之后几乎毫不费力! 为什么选择Python? 由于Python的日益普及...
  • 为什么不用线性回归的代价函数表示,因为线性回归的代价函数可能是非凸的,对于分类问题,使用梯度下降很难得到最小值,上面的代价函数是凸函数 的图像如下,即y=1时: 可以看出,当趋于1,y=1,与预测值一致,...
  • 第四章—介绍python对象类型...python对象分为内置对象自己编写的对象,内置对象由很多的优点,能解决大部分的问题,除非除非你有内置类型无法提供的对象要处理 对象类型 字面量/构造示例 数字 1234, 3.1...
  • 现在有一道题目,要求利用python中re模块来匹配ip地址,我们应如何着手? 首先能想到的是ip地址是数字,正则表达式是如何匹配数字的呢?...2. 字符串内部是由4个1-3位的数字和3个.组成 3. 数字的范围是0...
  • 通常为了达到分解问题的效果,递归过程中要引入一个调用自身的函数。乍一看,递归算法并没有什么特别的地方,但是,利用递归我们能够写出极为简明的解决问题的方法,而且如果不用递归,这些问题将具有很大的编程难度...
  • python实现汉诺塔算法

    2021-01-20 05:03:02
    1、 算法当然还是递归解了,即把n个汉诺塔盘子分解成 n – 1 个盘子的移动一个底层盘子的移动,这样一来,问题就成了一连串的递归,然后就可以逐步求解了。 当然了,汉诺塔还有进阶问题,此处先不
  • 数字和字符串 - 整数 / 浮点数 / 复数 / 字符串 / 字符串基本操作 / 字符编码 运算符 - 数学运算符 / 赋值运算符 / 比较运算符 / 逻辑运算符 / 身份运算符 / 运算符的优先级 应用案例 - 华氏温度转换成摄氏温度 / ...
  • 今天,蒜头君突发奇想:如果想要把一个正整数 nnn 分解成不多于 kkk 个正整数相加的形式,那么一共有多少种分解的方式呢? 蒜头君觉得这个问题实在是太难了,于是他想让你帮帮忙。 输入格式 共一行,包含两个整数 n...
  • 分解 各国在中小学引入编程教育更多的是让孩子们从以计算机的方式来考虑问题培养逻辑思维能力编程思维并非是要把所有人都培养成程序员编程思维是一个非常重要的概念含义是将以大的问题分解问小的问题然后逐步解决...
  • Python实现秒解数独

    万次阅读 2018-10-18 16:28:16
    编程笼统的来说,就是个方法论,不论什么程序,都必须将问题的解决过程分解成计算机可以实现的若干个简单方法。俗话说,大道至简。对于只能明白01的计算机来说,就更需要细分步骤,一步一步的解决问题了。 首先来...
  • 我们介绍了适用于Python的PyMatting软件包,该软件包实现了多种解决Alpha遮罩问题的方法。 网站文档: : 基准: : 给定输入图像手绘的Trimap(顶部行),alpha遮罩估计前景对象的alpha通道,然后可以将其...
  • python实现水仙花数

    万次阅读 2017-12-28 14:40:10
    题目:打印出所有的"水仙花数",所谓"水仙花数"是指一个三位数,其各位数字立方等于该数本身。例如:153是一个"水仙花数",因为153=1的三次方+5的三次方+3的三次方。 程序分析:利用for循环控制100-999个数,每...
  • 不论什么程序,都必须将问题的解决过程分解成计算机可以实现的若干个简单方法。俗话说,大道至简。对于只能明白01的计算机来说,就更需要细分步骤,一步一步的解决问题了。 首先来思考一下解数独的基本概念。 数独...
  • 水仙花数是指一个 n 位正整数 ( n≥3 ),它的每个位上的数字的 n 次幂之等于它本身。(例如:1^3 + 5^3+ 3^3 = 153)。Python练习题问题如下:要求:打印输出所有的"水仙花数"。Python解题思路分析:...
  • 分治算法的基本思想是将一个规模...给定一个含有数字和运算符的字符串,为表达式添加括号,改变其运算优先级以求出不同的结果。你需要给出所有可能的组合的结果。有效的运算符号包含+,-以及*。 示例1: 输入: "2-1...
  • 把 2019 分解成 3 个各不相同的正整数之,并且要求每个正整数都不包含数字 2 4,一共有多少种不同的分解方法? 注意交换 3 个整数的顺序被视为同一种方法,例如 1000+1001+18 1001+1000+18 被视为同一种。 ...

空空如也

空空如也

1 2 3 4
收藏数 75
精华内容 30
关键字:

python数字和分解问题

python 订阅