Discussion: classnph

  1. #41
    Membre confirmé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    254
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 60
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 254
    Points : 616
    Points
    616
    Billets dans le blog
    21

    Par défaut print('nphysic_11a.py En {}'

    Quoi de plus subtil que d'entraver la multiplicité des lecteurs/cueilleurs de ce code, en cherchant parmi les communs rencontrés. Ainsi, on limite les itérations (+=6), en produisant les communs qui sont d'excellents producteurs de nombres préalables premiers. Et si ce cheminement se poursuit, ma foi on aura là une série non négligeable...

    Le code vous en dira bien plus que moi, et d'avantage si affinité

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série communs. En Général Python
    import time
    import copy
    """MusicAToumic En"""
    # Programme      nphysic_11a : 27 août 2017
    """Découvrir les multiples d'un NOMBRE
    1- Tableau(imem[NP]) des :ip;dv: de type (1, 5)
    2- Copie (imem) sur tableau(itab)
    3- Boucle (imem) sur (itab)
    4- :ion1::ion2: Motif de progression
    5- Modélisation :ip:
    6- :print: Points d'analyses
    Typogramme nucloïde
    P = Points de récupération 'u15171w-14925...'
    NP = Nombre Pemier: Signé '°'
    NpP = Nombre préalable Premier: Types '1&5'
    NpPip = Tableau :imem[ip(NP)]: Résultat "ip"
    NpPdv = Tableau :imem[dv(NP)]: Résultat "ip"
    NC = Nombre Commun :itab[NC]: Résultat "ip"
    Les premiers tempéraments préalables NpP '1&5'
    Fonction :imemap: Nombres Premiers NP
    Les multiplications NP produisent NC
    Mes premiers pas sur sur cette échelle
    """
    dod0 = time.time()
     
    def onuno(uno):
        """ Pour un nombre :uno:
        À la recherche des sous-multiples
        """
        u1 = u2 = 0
        if uno == 0:  # :uno=0: Zéro issue
            uno = 1
            u1 = 1
        if uno == 1:  # :uno=1: Un issue
            u2 = 1
        uo5 = so5 = int(uno ** .5)
        uo6 = uno % 6
        u25 = s25 = int(uno ** .25)
        iut = sut = ((uo5 - u25) // 2)
        """
        La partie suivante fabrique trois groupes liés (sut,so5,s25)
        Chaque groupe a un "[0]Type(1&5)". Sert au tri (1&5).
        "[1]Type(1)|[2]Type(5)". À raison des compteurs incrémentés :6:
        Et, en incrémentant de six chaque lignée (1&5), on ne rate pas
        le nombre préalable se trouvant sur la lignée(1), (occasionnel
        lorsqu'on incrémente uniquement la lignée (5)).
        """
        # Initialisations des tableaux-types
        s00 = []  # Goupe :sut:
        s01 = []  # Goupe :so5:
        s02 = []  # Goupe :s25:
        if int(sut % 6) in (1, 5):
            s00.append(int(sut % 6))
            if s00[0] == 1:
                s00.append(sut)
                s00.append(sut + 4)
                # :s00[0]: = type état 1
                # :s00[1]: = nombre type 1
                # :s00[2]: = nombre type 5
            else:
                s00.append(sut + 2)
                s00.append(sut)
                # :s00[0]: = type état 5
                # :s00[1]: = nombre type 1
                # :s00[2]: = nombre type 5
        else:
            while 1:
                sut += 1
                if int(sut % 6) in (1, 5):
                    s00.append(int(sut % 6))
                    s00[0] = int(sut % 6)
                    # :s00[0]: = nombre type état
                    if s00[0] == 1:
                        s00.append(sut)
                        s00.append(sut + 4)
                    else:
                        s00.append(sut + 2)
                        s00.append(sut)
                    break
        if int(so5 % 6) in (1, 5):
            s01.append(int(so5 % 6))
            # :s01[0]: = nombre type état
            if s01[0] == 1:
                s01.append(so5)
                s01.append(so5 + 4)
            else:
                s01.append(so5 + 2)
                s01.append(so5)
        else:
            while 1:
                so5 -= 1
                if int(so5 % 6) in (1, 5):
                    s01.append(int(so5 % 6))
                    if s01[0] == 1:
                        s01.append(so5)
                        s01.append(so5 + 4)
                    else:
                        s01.append(so5 - 4)
                        s01.append(so5)
                    break
        if int(s25 % 6) in (1, 5):
            s02.append(int(s25 % 6))
            # :s02[0]: = nombre type état s25
            if s02[0] == 1:
                s02.append(s25)
                s02.append(s25 + 4)
            else:
                s02.append(s25 - 4)
                s02.append(s25)
        else:
            while 1:
                s25 += 1
                if int(s25 % 6) in (1, 5):
                    s02.append(int(s25 % 6))
                    if s02[0] == 1:
                        s02.append(s25)
                        s02.append(s25 + 4)
                    else:
                        s02.append(s25 - 4)
                        s02.append(s25)
                    break
        # Affectations des compteurs-types
        """v = s01[1)  # :so5: Racine(uno). Type 1
        w = x = s02[1]  # :s25: Racine(so5). Type 1
        :v5,y5,w5,z5,x5: Sont de type 5
        """
        # Section :v >= y:
        v = s01[1]  # Nombre type 1
        v5 = s01[2]  # Nombre type 5
        y = s00[1]  # Nombre type 1
        y5 = s00[2]  # ...
        # Section :w >= u:
        """:u: est incrémenté de 1"""
        w = s02[1]
        w5 = s02[2]
        # Section :z >= x:
        z = s00[1]
        z5 = s00[2]
        x = s02[1]
        x5 = s02[2]
        # Blocages généraux
        if s00[1] > 4:
            if s01[1] < int(s02[1]):
                v1 = y
                z1 = x
            else:
                v1 = s01[1] - int((s02[1]))
                z1 = s00[1] - int((s02[1]))
            if v1 % 6 != 1:
                if v1 % 6 == 0:
                    v1 += 1
                else:
                    v2 = v1 % 6 - 1
                    v1 -= v2
            if z1 % 6 != 1:
                if z1 % 6 == 0:
                    z1 += 1
                else:
                    v2 = z1 % 6 - 1
                    z1 -= v2
        else:
            """ Comme les issues(0&1)
            Lorsqu':uno: = Complexe racine² inférieure"""
            if uo5 % 6 == 1:
                v = uno
            else:
                v2 = uo5 % 6 - 1
                v = uo5 + v2
            v1 = 1
            z = 0
            z1 = 0
            w = 0
        # Tableau :imem[ip(NP)]:
        imem = []
        if iut > u25:  # Si oui: Commence à 1
            u = 1
        else:  # Si non: Commence à 2. Sinon ERREUR
            u = 2
        v_ = w_ = z_ = 0  # Indices des terminaux (v_ pour v...)
        # Fonction d'appel à condition NP
        itabmx = [0]
        def imemap(uz):
            """ Les nombres premiers NP
            Des préalables premiers :uz: déjà '1&5' """
            # Condition du niveau bas (1, 2, 3, 4, 5, 6, 7)
            if not uno % uz and uz % 6 in (1, 3, 5) \
                    and 0 < uz < 8 and uz not in imem:
                imem.append(uz)  # Tableau :imem[ip(NP)]:
            else:
                # :rim: Reconstruction à chaque tour
                rim = [mm for mm in imem if mm > 1]
                for rr in rim:
                    if not uz % rr:
                        break
                else:
                    if uo5 > uz > 1:
                        imem.append(uz)
     
        if u1 == 0:  # Zéro issue
            # À la recherche des sous-multiples
            while 1:
                # Ordonnée conditionnée aux sous-multiples
                # Condition du niveau bas (1, 2, 3, 4, 5)
                if not uno % u and u % 6 in (1, 2, 3, 5) \
                        and u < 6 and u not in imem:
                    imem.append(u)  # Tableau :imem[ip(NP)]:
                # :v >= y: :sq5|sut: Environnement
                if v > v1 and v_ == 0:  # Si oui: Faire
                    if not uno % v and v not in imem:
                        imemap(v)  # Envoi :imemap: Sortant :v: NpP
                        if v == uo5:  # Carré rencontré Type 1
                            imemap(v)
                    if not uno % v5 \
                            and v5 not in imem:
                        imemap(v5)  # Envoi :imemap: Sortant :v5: NpP
                        if v5 == uo5:  # Carré rencontré Type 5
                            imemap(v5)
                    if not uno % y \
                            and y not in imem:  # y = iut(+6)
                        imemap(y)
                    if not uno % y5 \
                            and y5 not in imem:  # y5 = iut(+6)
                        imemap(y5)
                else:  # Si non: Indice terminal
                    v_ = 1
                # :w >= u: :s25|u: Environnement
                if w >= u - 6 and w_ == 0:  # Si oui: Faire
                    if w != 0:
                        if not uno % w and w not in imem:  # w = u25(-6)
                            imemap(w)
                        if not uno % u and u not in imem \
                                and u % 6 in (1, 5) \
                                and u > 1:  # u = u(+1)
                            imemap(u)
                        if not uno % w5 and w5 > 1 \
                                and w5 not in imem:  # w5 = u25(-6)
                            imemap(w5)
                    else:
                        w_ = 1
                else:  # Si non: Indice terminal
                    w_ = 1
                # :z >= x: :sut|s25: Environnement
                if z > z1 and z_ == 0:  # Si oui: Faire z_
                    if z != 0:
                        if not uno % z \
                                and z not in imem:  # z = iut(-6)
                            imemap(z)
                        if not uno % x \
                                and x not in imem:  # x = u25(+6)
                            imemap(x)
                        if not uno % z5 and z5 not in imem \
                                and z5 > 1:  # z5 = iut(-6)
                            imemap(z5)
                        if not uno % x5 \
                                and x5 not in imem:  # x5 = u25(+6)
                            imemap(x5)
                    else:
                        z_ = 1
                else:  # Si non: Indice terminal z_
                    z_ = 1
                # Ordonnées positives et négatives
                if v_ == 0:
                    if v1 == 1:
                        v -= 1
                    else:
                        v -= 6  # sq5 typ1
                        y += 6  # sut typ1
                        v5 -= 6  # sq5 typ5
                        y5 += 6  # sut typ5
                if w_ == 0:
                    w -= 6  # s25 typ1
                    u += 1  # u
                    w5 -= 6  # s25 typ5
                if z_ == 0:
                    z -= 6  # sut typ1
                    x += 6  # s25 typ1
                    z5 -= 6  # sut typ5
                    x5 += 6  # s25 typ5
                vwz = v_ + w_ + z_  # :vwz: Cumul des terminaux
                if vwz > 2:  # :vwz=3: Le tour est fait !
                    break
        if u2 == 1:  # :uno=1: Un issue
            imem.append(1)
        # Tableau :imem[ip(NP)]: Trier
        imem.sort()
        # 2- Copie (imem) sur tableau(itab)
        itab = copy.copy(imem)
        if u1 == 0:  # Zéro issue
            # Les multiplications NP produisent NC
            while 1:
                ion1 = len(imem)
                for i in imem:
                    for y in itab:
                        i1 = y * i
                        if i1 > uo5:
                            i1 = uno // i1
                            if i1 % 6 in (1, 5) and i1 not in itab \
                               and not uno % i1:
                                imemap(i1)
                        elif i1 not in itab and not uno % i1:
                            itab.append(i1)
                            # NC = Nombre Commun :itab[NC]: Résultat "ip"
                itab.sort()
                ion2 = len(imem)
                if ion1 == ion2:  # 4- :ion1::ion2: Motif de progression
                    itabmx[0] = uno // max(itab)
                    if itabmx[0] // uno != 1:
                        imemap(itabmx[0])
                if len(imem) is not ion1:
                    pass
                else:
                    break
     
            print('Nombres Premiers :ip:', imem)  # Affiche (les) NP
            for i in itab:  # Démultiplier :i: produire :d:
                d = uno // i
                ip, dv = i, d
                if ip < dv or ip == dv:  # Déblocage :uno = 2 ou 4:
                    print('%s * %s  typ %s*%s' % (ip, dv, ip % 6, dv % 6))
        else:
            # Zéro issue :uno;onu:
            print('%s * %s  typ %s*%s' % (uno, onu, uno % 6, onu % 6))
            uno = 0
            uo6 = uno % 6
        print('Cosmic', uno, 'typ', uo6, 'long', len(itab))
        print('nphysic_11a.py En {}'.format(time.time() - dod0))
    onu = 9999876543210000123456789999
    onuno(onu)
    Pour vous rassurer, les prints

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
     
    Nombres Premiers :ip: [1, 3, 11, 101]
    1 * 9999876543210000123456789999  typ 1*3
    3 * 3333292181070000041152263333  typ 3*3
    9 * 1111097393690000013717421111  typ 3*1
    11 * 909079685746363647586980909  typ 5*3
    33 * 303026561915454549195660303  typ 3*3
    99 * 101008853971818183065220101  typ 3*5
    101 * 99008678645643565578780099  typ 5*3
    303 * 33002892881881188526260033  typ 3*3
    909 * 11000964293960396175420011  typ 3*5
    1111 * 9000788967785778688980009  typ 1*3
    3333 * 3000262989261926229660003  typ 3*3
    9999 * 1000087663087308743220001  typ 3*1
    Cosmic 9999876543210000123456789999 typ 3 long 12
    nphysic_11a.py En 7.668458700180054
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple

  2. #42
    Membre confirmé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    254
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 60
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 254
    Points : 616
    Points
    616
    Billets dans le blog
    21

    Par défaut nphermier_0a.py Simpliste

    Il y a des raisons de croire que le développement engendre la connaissance, en raison d'une conséquence liée au vecteur numéral. D'un côté, le nombre peut-être grand et donner lieu à une importante série de traitements gourmands en temps d'exécution. D'autre part, les qualités relatives à la multiplication des nombres entre eux et leurs effets visibles sur les produits. Alors on ne peut pas éviter de penser que les nombres sont finalement organisés, et que les relations peuvent être profondes. Il est important de savoir que la profondeur est distinguée, qu'elle est composée d'éléments distinctifs.

    Le programme précédent (nphysic_11a.py) a de nombreux traitements ne gênant pas le développement de l'idée originale, et grâce à sa logique heureusement simplifiable. Son enseignement donne l'occasion d'écrire un code plus simple, en ne gardant que la principale ligne de conduite de son algorithme. Résolu avec les nombres premiers aux production des communs, et de la science qui en découle. La relation avec les différents niveaux de profondeur estimée en grandeur numérale du nombre à traiter, pour que finalement on puisse interpréter le langage numéral après avoir compris sa systématique.

    Je voudrais remercier dans ce texte la communauté Pycharm de Jet Brain, qui fort compétant de disposer d'un éditeur de code agréable

    Code quantum d'un débutant non autonome et de ses deux amis Python et Pycharm
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série première. En Général Python
    # MusicAtoumic nphermier_1 Le 9 septembre 2017
    import time
    import copy
    t = time.time()
    nombre = 9854632157861
    carre = carre1 = int(nombre ** .5)
    hautniveau = []
    """Pontage niveau haut:
    Définir le carré en deux lignes (1&5)
    Lié au reste de la division :carre % 6:"""
    if carre % 6 == 1:
        carre1 = carre
        carre5 = carre1 + 4
    else:
        differe = (carre % 6) - 1
        carre1 -= differe
        carre5 = carre1 + 4
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers"""
    basniveau = [2, 3, 5]
    for i in range(7):
        if i in basniveau and not nombre % i:
            hautniveau.append(i)
    """Hauts niveaux premiers:
    Chercher dans l'alignement des nombres premiers"""
    for p1 in range(7, carre, 6):
        p5 = p1 + 4
        # Lorsque le haut niveau n'a pas d'élément bas
        if not hautniveau:
            if not nombre % p1:
                hautniveau.append(p1)
            if not nombre % p5:
                hautniveau.append(p5)
            # Partie inverse   
            if not nombre % carre1:
                hautniveau.append(carre1)
            if not nombre % carre5:
                hautniveau.append(carre5)
        # Lorsque le haut niveau a un élément bas
        else:
            if not nombre % p1 and p1 not in hautniveau:
                for i in hautniveau:
                    if not p1 % i:
                        break
                else:
                    hautniveau.append(p1)
            if not nombre % p5 and p5 not in hautniveau:
                for i in hautniveau:
                    if not p5 % i:
                        break
                else:
                    hautniveau.append(p5)
            # Partie inverse
            if not nombre % carre1 and carre1 not in hautniveau:
                for i in hautniveau:
                    if not carre1 % i:
                        break
                else:
                    hautniveau.append(carre1)
            if not nombre % carre5 and carre5 not in hautniveau:
                for i in hautniveau:
                    if not carre5 % i:
                        break
                else:
                    hautniveau.append(carre5)
        carre1 -= 6
        carre5 -= 6
        # Contrôle jonction (+/-)
        if p1 >= carre1:
            break
    print('Hautniveau En:', time.time() - t)
    """Désigne la communauté:
    Les nombres premiers associés :hautniveau:
    Produisent la communauté des multiples communs"""
    hautniveau.append(1)
    hautniveau.sort()
    print('Premiers', hautniveau)
    communs = copy.copy(hautniveau)
    for com1 in hautniveau:
        for com2 in communs:
            produit = com1 * com2
            # Condition de recherche
            if produit > carre:
                break
            elif produit not in communs and not nombre % produit:
                communs.append(produit)
                communs.sort()
                # Ordonnance des communs
    for i in communs:
        print('{} * {} typ {}*{}'.format(i, nombre // i, i % 6, (nombre // i) % 6))
    print('nphermier_0a.py En:', time.time() - t)
    print('', )
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple

  3. #43
    Membre confirmé
    Avatar de toumic
    Homme Profil pro
    Gammologie Univers
    Inscrit en
    mai 2009
    Messages
    254
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 60
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Gammologie Univers
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2009
    Messages : 254
    Points : 616
    Points
    616
    Billets dans le blog
    21

    Par défaut

    Citation Envoyé par toumic Voir le message
    Il y a des raisons de croire que le développement engendre la connaissance,,,

    Je voudrais remercier dans ce texte la communauté Pycharm de Jet Brain, qui fort compétant de disposer d'un éditeur de code agréable

    Code quantum d'un débutant non autonome et de ses deux amis Python et Pycharm
    Pas facile de s'y retrouver parmi les communautés des multiples, car chaque nombre comporte une communauté différente. Et comme le code évolue en fonction des communs rencontrés, il est toujours probable qu'il ne soit pas totalement estimable comme son titre de réussite le demande

    L'algorithme relatif aux nombres a encore évolué, visiblement :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
     
    #!/usr/bin/env python3.6
    # -*- coding: utf-8 -*-
    # Série première. En Général Python
    # MusicAtoumic nphermier_5a Le 17 septembre 2017
    import time
    import copy
    t = time.time()
    nombre = 7999178931971
    typ6 = nombre % 6
    carre = int(nombre ** .5)
    hautniveau = []
    horscourse = []
    palier = int(nombre ** .46)
    if typ6 in (1, 5):
        cartyp6 = int(nombre ** .473)
        borne = int(nombre ** .4)
    else:
        cartyp6 = int(nombre ** .437)
        borne = int(nombre ** .36)
    """Pontage niveau haut:
    Définir le carré en deux lignes (1&5)
    Lié au reste de la division :carre % 6:"""
    carre1 = carre
    if carre % 6 == 1:
        carre5 = carre1 + 4
    else:
        differe = (carre % 6) - 1
        carre1 -= differe
        carre5 = carre1 + 4
    """Bas niveau des premiers:
    Création du haut niveau des nombres premiers
    Lié au bas niveau des nombres premiers"""
    basniveau = [2, 3, 5]
    for i in range(7):
        if i in basniveau and not nombre % i:
            hautniveau.append(i)
     
    def compare(c):
        if not nombre % c and c <= carre:
            if c not in horscourse:
                horscourse.append(c)
            for haut in hautniveau:
                if not c % haut:
                    break
            else:
                if c <= carre and c not in hautniveau:
                    hautniveau.append(c)
     
    """Hauts niveaux premiers:
    Chercher dans l'alignement des nombres premiers"""
    for p1 in range(7, cartyp6, 6):
        p5 = p1 + 4
        # Lorsque le haut niveau n'a pas d'élément bas
        if not hautniveau:
            if not nombre % p1:
                hautniveau.append(p1)
            if not nombre % p5:
                hautniveau.append(p5)
            # Partie inverse
            if not nombre % carre1:
                hautniveau.append(carre1)
            if not nombre % carre5:
                hautniveau.append(carre5)
        # Lorsque le haut niveau a un élément bas
        else:
            if not nombre % p1 and p1 not in hautniveau:
                compare(p1)
            if not nombre % p5 and p5 not in hautniveau:
                compare(p5)
            # Partie inverse
            if not nombre % carre1 and carre1 not in hautniveau:
                compare(carre1)
            if not nombre % carre5 and carre5 not in hautniveau:
                compare(carre5)
        carre1 -= 6
        carre5 -= 6
        """Condition du palier:
            Nombres démunis en communs"""
        if p1 > palier and 2 > len(hautniveau):
            break
        """Condition de la borne:
        Nombres premiers complémentaires"""
        if p1 > borne and 1 < len(hautniveau):
            produit = 1
            hautniveau.sort()
            hautniveau.reverse()
            for unit in hautniveau:
                produit *= unit
                result = nombre // produit
                if result > 1 and not nombre % result:
                    if produit > carre and result not in horscourse:
                        compare(result)
                    elif nombre > produit < carre:
                        compare(produit)
            else:
                horscourse.sort()
                h = hh = 0
                while not hh:
                    h -= 1
                    fx_ip = nombre // horscourse[-1]
                    fx_mu = fx_ip * min(hautniveau)
                    if fx_mu < carre:
                        ho_dv = horscourse[h] // min(hautniveau)
                        if not nombre % ho_dv:
                            if ho_dv % 6 in (1, 5):
                                compare(ho_dv)
                        if not nombre % fx_mu:
                            if fx_mu > carre:
                                if (nombre // fx_mu) % 6 in (1, 5):
                                    compare(nombre // fx_mu)
                                    hh = 1
                            else:
                                if fx_mu % 6 in (1, 5):
                                    compare(fx_mu)
                    else:
                        hh = 1
                break
     
    """Désigne la communauté:
    Les nombres premiers associés :hautniveau:
    Produisent la communauté des multiples communs"""
    hautniveau.append(1)
    hautniveau.sort()
    print('Premiers', hautniveau)
    communs = copy.copy(hautniveau)
    for com1 in hautniveau:
        for com2 in communs:
            produit = com1 * com2
            # Condition de recherche
            if produit > carre:
                break
            elif produit not in communs and not nombre % produit:
                communs.append(produit)
                communs.sort()
                # Ordonnance des communs
    for i in communs:
        print('{} * {} typ {}*{}'.format(i, nombre // i, i % 6, (nombre // i) % 6))
    print('nphermier_5a.py En:', time.time() - t)
    print('', )

    Pour cause cet exemple :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    Premiers [1, 758339]
    1 * 7999178931971 typ 1*5
    758339 * 10548289 typ 5*1
    nphermier_5a.py En: 0.2581496238708496
    music@toumic
    Révolution tellement quantique qu'inimaginable
    Lien : Saison 6 encore cours évolutif (txt) Pour un code ludique coloré
    Acoustic music | Première napharmony | Multi commun
    music's univers | confins numériques | couple multiple

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo