Votre tâche consiste à traduire un nombre lisse-103 en un mot anglais, en utilisant la méthode décrite ci-dessous.

Comment?

1. Générez la liste des facteurs premiers (avec répétition) du nombre saisi.
2. Trier la liste:
   • Si 2 n'est pas l'un des facteurs premiers, triez la liste par ordre croissant.
   • Si 2 est l'un des facteurs premiers, supprimez-le de la liste et triez les facteurs restants par ordre décroissant.

3. Traduisez chaque facteur dans une lettre, en utilisant le tableau suivant:

    3 = S   13 = L   29 = X   43 = O   61 = Z   79 = H  101 = K  
    5 = P   17 = Q   31 = N   47 = R   67 = T   83 = V  103 = Y  
    7 = M   19 = U   37 = C   53 = A   71 = E   89 = D  
   11 = F   23 = I   41 = W   59 = G   73 = J   97 = B  
   

_{Remarque : Ce tableau a été construit de manière empirique afin de maximiser le nombre de mots possibles. Pour les plus curieux, voici une liste de 2 187 mots qui peuvent être encodés de cette façon (peuvent inclure un langage grossier). Ce n'est certainement pas garanti d'être optimal, mais c'est assez bon pour ce défi.}

Exemples

Exemple 1: 579085261 (ordre croissant)

1. Les facteurs premiers sont [37, 47, 53, 61, 103] .
2. 2 n'est pas un facteur premier, nous conservons donc la liste triée par ordre croissant.
3. 37 = C, 47 = R, etc. La sortie est "CRAZY".

Exemple 2: 725582 (ordre décroissant)

1. Les facteurs premiers sont [2, 11, 13, 43, 59] .
2. 2 est un facteur premier, nous le supprimons et trions la liste par ordre décroissant, ce qui donne:
   [59, 43, 13, 11] .
3. 59 = G, 43 = O, etc. La sortie est "GOLF".

Exemple 3: 10757494 (avec un facteur répété)

1. Les facteurs premiers sont [2, 11, 71, 71, 97] .
2. 2 est un facteur premier, nous le supprimons et trions la liste par ordre décroissant, ce qui donne:
   [97, 71, 71, 11] .
3. 97 = B, 71 = E, 11 = F. La sortie est "BEEF".

Clarifications et règles

• Il est garanti que le numéro d’entrée est lisse et divisible par 2 au maximum une fois.
• Par définition, un nombre entier est un entier positif .
• L'entrée et la sortie peuvent être traitées dans n'importe quel format raisonnable. La sortie peut être en minuscule ou en majuscule. Les espaces de fin sont acceptables. Les espaces blancs ne sont pas.
• Si votre programme / fonction ne peut pas prendre en charge de grandes entrées, veuillez le spécifier dans votre réponse.
• C'est le code golf, donc la réponse la plus courte en octets est gagnante.

Cas de test

34874          --> ARM
483254         --> BAR
353722         --> EAR
494302         --> EGG
39061          --> FAT
6479           --> FUN
60421          --> ICE
54166          --> JAM
48911474       --> BETA
2510942        --> BOOM
2303854        --> DOOM
844261         --> FIRE
1606801        --> MAZE
1110085        --> PAGE
5212974        --> BALLS
67892046       --> BEANS
885396199      --> CREEK
67401037       --> FUNKY
27762173       --> QUICK
1238440506     --> ARROWS
33045832681    --> CRAGGY
1362714005     --> PIRATE
137302698      --> TROLLS
358310128062   --> BEGGARS
40255151586    --> DETAILS
164633248153   --> FIXATED
621172442227   --> UNRATED
2467812606     --> VACUUMS
86385078330    --> GROWNUPS
26607531423091 --> UNWORTHY

Gelée , 29 à 27 octets

ÆEµØA“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?xḊṚḢ}¡

Merci à @JonathanAllan pour le golf d'un octet!

Essayez-le en ligne!

Contexte

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’

est un littéral numérique. Les caractères entre les guillemets sont remplacés par leurs index basés sur 1 dans la page de code Jelly , et le tableau résultant est interprété comme un nombre base 250. Cela donne le nombre entier c: = 288824892868083015619552399 .

Comment ça marche

ÆEµØA“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?xḊṚḢ}¡  Main link. Argument: n

ÆE                           Yield the exponents of n's prime factorization, with.
                             zeroes. This yields an array A.
  µ                          Begin a new monadic chain with argument A.
   ØA                        Set the return value to “ABC...XYZ”.
     “¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?        Select the c-th permutation of the alphabet, yielding
                             s := “SPMFLQUIXNCWORAGZTEJHVDBKY”.
                      Ḋ      Dequeue; yield A without its first element, stripping
                             the exponent of 2.
                     x       Repeat the k-th letter of s r times, where r is the
                             exponent of the k-th odd prime number.
                          ¡  Combine the two links to the left into a quicklink:
                        Ḣ}     - Apply head to the right argument (A), yielding the
                                 exponent of 2. Since n is at most divisible by the
                                 first power of 2, this yields 1 for even numbers
                                 and 0 for odd ones. Call the link to the left that
                                 many times on the previous return value.
                       Ṛ       - Reverse the string to the left.

Gelée , 36 octets

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA1;;⁶
×107ÆE¢×UḢ¡t⁶

Essayez-le en ligne!

Explication

Constante d'assistance1£ (produit “SPMFLQUIXNCWORAGZTEJHVDBKY ”avec un 1 ajouté)

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA1;;⁶
“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’          288824892868083015619552399 (compressed representation)
              œ?ØA      th permutation of the alphabet
                  1;    prepend 1
                    ;⁶  append a space

Programme principal

×107ÆE¢×UḢ¡t⁶
×107           Multiply {the input} by 107
    ÆE         Convert to a list of frequencies for each factor
      ¢×       {Vectorized} multiply by the return value of 1£
        UḢ¡    Delete the first value, reverse the list that many times
           t⁶  Delete trailing/leading space

J'ai l'impression que ma compression de la liste surpasse facilement l'autre réponse de Jelly, mais que mon algorithme d'utilisation pourrait être beaucoup plus efficace. Peut-être que je vais essayer de les combiner.

Jelly , 31 bytes, inspiré par la réponse de @ Leakynun

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA⁷;
ÆfÆCị¢U⁸¡U

Essayez-le en ligne! (légèrement modifié pour courir beaucoup plus vite)

Est-ce qu’il est incohérent d’imprimer une nouvelle ligne de fin (mais PPCG autorise normalement les réponses avec ou sans nouvelle ligne, alors je suppose que cela fonctionne aussi?). Est très lent (O ( n ) où n est l'entrée, et ces nombres ne sont pas tout à fait petits…)

Explication

Constante d'assistance1£ (produit “¶SPMFLQUIXNCWORAGZTEJHVDBKY”, où ¶est newline)

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA⁷;
“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’          288824892868083015619552399 (compressed representation)
              œ?ØA      th permutation of the alphabet
                  ⁷;    prepend newline

Programme principal

ÆfÆCị¢U⁸¡U
Æf          Produce list of prime factors (repeating repeated factors)
  ÆC        Map the nth prime to n
    ị¢      Index into the output of 1£
      U     Reverse
        ¡   a number of times
       ⁸    equal to the input
         U  Reverse again

05AB1E , 39 38 octets

ÒW<iR¨}26LØR•6Ê2"£´õþÕàçŸôëÂÛ*™•36BS:J

Utilise le codage CP-1252 . Essayez-le en ligne!

Python 2, 220 217 octets

n=input()
i=1
L=[]
exec'i+=1;c=0\nwhile n%i<1:c+=1;n/=i\nif c:L+=[i]*c\n'*n
T='SPMFLQUIXNCWORAGZTEJHVDBKY'
print''.join(T[[p for p in range(3,104)if all(p%k for k in range(2,p))].index(q)]for q in[L,L[:0:-1]][L[0]<3])

Essayez-le en ligne - exécute uniquement le plus petit scénario de test sans manquer de mémoire

Ungolfed:

Cette version ne l'utilise pas exec, vous pouvez donc tester tous les cas de test sans manquer de mémoire.

n=input()
i=1
L=[]
while~-n:
 i+=1;c=0
 while n%i<1:c+=1;n/=i
 if c:L+=[i]*c
if L[0]<3:L=L[:0:-1]
T='SPMFLQUIXNCWORAGZTEJHVDBKY'
print''.join(T[[p for p in range(3,104)if all(p%k for k in range(2,p))].index(q)]for q in L)

Essayez-le en ligne

Ruby , 139 138 134 125 120 115 + 7 = 146 145 141 132 127 122 octets

Utilise le -rprimedrapeau pour +7 octets.

-1 octet de @daniero. -4 octets en se rappelant que je peux simplement faire une vérification de la divisibilité régulière au lieu de vérifier l'existence de la division première 2.

-9 octets de la solution Python de @ mbomb007 me rappelant un moyen plus rapide de récupérer la lettre correspondante.

-5 octets, car les espaces de fin sont maintenant autorisés.

-5 octets de découverte Enumerable#find_index

->n{x=Prime.prime_division n;x.reverse!if n%2<1;x.map{|i,c|" SPMFLQUIXNCWORAGZTEJHVDBKY"[Prime.find_index i]*c}*''}

Essayez-le en ligne! (tous les cas de test)

Explication

->n{                                   # Anonymous procedure with one argument n
    x=Prime.prime_division n;          # Get prime factorization of n, sorted
                                       # p0^e0 * p1^e1 ... -> [[p0,e0],[p1,e1],...]
    x.reverse!if n%2<1;                # Reverse if divisible by 2
    x.map{|i,c|                        # For each prime/exponent pair:
        " SPMFLQUIXNCWORAGZTEJHVDBKY"[ # Get corresponding character by obtaining:
            Prime.find_index i]        # Determine index of the current prime
                               *c      # Repeat the letter by the supplied exponent
                                 }*''} # Join all letter sequences together

Bash + utilitaires GNU + paquet bsd-games, 170

Cela semble plutôt non optimal, mais cela fonctionne:

p='printf %03d\n'
a=(`factor $1`)
x=$[a[1]<3]
$p `primes 3 104`|paste - <(fold -1<<<SPMFLQUIXNCWORAGZTEJHVDBKY)|join -o1.2 - <($p ${a[@]:x+1})|(((x))&&tac||cat)|tr -d \\n

Essayez-le en ligne .

Gelée , 33 octets

ÆfÆCUṖ$¹e@?1’ị“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA¤

Essayez-le en ligne!

Japt , 51 50 octets

49 octets de code, +1 pour le -Pdrapeau.

%2?Uk :Uk Åw)£`yspmflquixncÙgz’jhvdbk`g#ho fj bX

Essayez-le en ligne!

Cela pourrait être bien plus court si seulement Japt avait quelques fonctionnalités en plus ...

Explication

`yspmflquixncÙgz’jhvdbk`est exactement la même chaîne que tout le monde utilise compressée autant que Japt peut la compresser (3 octets de moins que l'original!). À l'heure actuelle, le seul outil de compression intégré de Japt remplace les paires courantes de lettres minuscules par un caractère à un octet.

Examinons donc le code actuel:

%2?Uk :Uk Å  w)
%2?Uk :Uk s1 w)
%2?             // If the input mod 2 is non-zero,
   Uk           //   take the prime factors of the input (U).
      :Uk       // Otherwise, take the prime factors of the input,
          s1 w  //   slice off the first one (2), and reverse.

Puis £est utilisé pour remplacer chaque élément Xdans le résultat comme ceci:

"string"g#h o fj bX
"string"g104o fj bX

         104o         // Create the range [0...104).
              fj      // Filter to only items Z where Z.j() is truthy (Z is prime).
                      // This results in the list of prime numbers from 2 to 103.
                 bX   // Take the index of X in this list.
"string"g             // Get the char in the compressed string at that index.
                      // For `y`, the index is 26, but since the string is only 26 chars
                      // long, Japt wraps around and grabs the first char in the string.

Le résultat est un tableau de caractères à ce stade, de sorte que l' -Pindicateur le joint en une seule chaîne et le résultat est envoyé implicitement à la sortie.

Gelée , 40 octets

Æfḟ2ÆCṚ⁸Ḃ¤¡Ṛị“YSPMFLQUIXNCWORAGZTEJHVDBK

Essayez-le en ligne!

Vérifiez tous les tests en une fois! (légèrement modifié)

Pyth , 54 à 47 octets

7 octets grâce à isaacg

s__W%Q2@L."AZ❤O❤❤❤❤❤❤Q❤9❤❤×❤❤"xL_MP#r_3_103-PQ2

( ❤représente un caractère non imprimable)

Pyth n'a pas beaucoup d'intégrateurs principaux ...

Hexdump:

0000000: 73 5f 5f 57 25 51 32 40 4c 2e 22 41 5a 03 4f f3 s__W%Q2@L."AZ.O.
0000010: 14 af 15 ed f5 51 90 39 d5 18 d7 20 a8 22 78 4c .....Q.9... ."xL
0000020: 5f 4d 50 23 72 5f 33 5f 31 30 33 2d 50 51 32    _MP#r_3_103-PQ2

Essayez-le en ligne!

J , 59 octets

'SPMFLQUIXNCWORAGZTEJHVDBKY'{~(p:>:i.26)i.[:|.@}.^:(2={.)q:

Essayez-le en ligne!

Assez facile...

'SPMFLQUIXNCWORAGZTEJHVDBKY'{~(p:>:i.26)i.[:|.@}.^:(2={.)q:
                              (p:>:i.26)                      first 26 primes after 2
                                        i.                    for which the indices is
                                                         q:   prime factors
                                            |.@}.             remove first and reverse
                                                 ^:           if
                                                   (2={.)     the first entry is 2
                            {~                                reverse index
'..........................'                                  hardcoded string

PHP, 173 octets

for($i=2;1<$n=&$argn;$n%$i?++$i:$r[]=$i.!$n/=$i)for($t=$i;$i>2&!$w[$i]&&$i%--$t;$t>2?:$w[$i]=SPMFLQUIXNCWORAGZTEJHVDBKY[$p++]);$r[0]>2?:rsort($r);foreach($r as$s)echo$w[$s];

Version en ligne

Étendu

for($i=2;1<$n=&$argn; # loop till input is 1
$n%$i?++$i:$r[]=$i.!$n/=$i) #after loop add value to result if input is divisible and divide input
  for($t=$i;$i>2&!$w[$i]&&$i%--$t; # loop if number is gt 2 and not in letter array till number is divisible 
  $t>2?:$w[$i]=SPMFLQUIXNCWORAGZTEJHVDBKY[$p++]) # if is prime add to letter array
  ; # make nothing in the loop
$r[0]>2?:rsort($r); # reverse result array if 2 is in result array
foreach($r as$s) # loop result array
  echo$w[$s]; # Output 

PHP, 178 octets

for($z=2;$p<26;$t>1?:$w[$z]=SPMFLQUIXNCWORAGZTEJHVDBKY[$p++])for($t=++$z;$z%--$t;);for($i=2;1<$n=&$argn;)$n%$i?++$i:$r[]=$i.!$n/=$i;$r[0]>2?:rsort($r);foreach($r as$s)echo$w[$s];

Version en ligne

Étendu

for($z=2;$p<26;
$t>1?:$w[$z]=SPMFLQUIXNCWORAGZTEJHVDBKY[$p++]) # after loop if is prime add to letter array
  for($t=++$z;$z%--$t;); 
for($i=2;1<$n=&$argn;)  # loop till input is 1
  $n%$i?++$i:$r[]=$i.!$n/=$i; #add value to result if input is divisible and divide input
$r[0]>2?:rsort($r); # reverse result array if 2 is in result array
foreach($r as$s) # loop result array
  echo$w[$s]; # Output 

Python, 1420 octets

lambda x:(lambda a,b,e,k,l,m,q,p:len.__name__[:a].join(dict(zip((lambda n:(lambda n,f,g:f(n,e,[],f,g))(n,lambda n,i,r,f,g:g(n,i+b,r,f,g)if i<n else r,lambda n,i,r,f,g:f(n,i,[r,r+[i]][all(i%x!=a for x in[e]+r)],f,g)))(l*e*(k*l+b)),(lambda n,o,t:(lambda n,f,g:f(n, len.__name__[:a],f,g))(n,lambda n,s,f,g:g(n,s,f,g)if n>o else s,lambda n,s,f,g:f(n//t,s+chr(n%t),f,g)))((((((k<<e)-b)<<m)+m)<<((k<<q)+(k<<b)))+(((((k<<e)-b)<<e)+b)<<((k<<q)-(b<<b)))+((((((b<<k)+b))<<l)+b)<<((((k<<e)-b)<<l)+(b<<b)))+(((((k<<e)-b)<<l)-k)<<((m<<m)+p))-(((p<<m)-b)<<((m<<m)-(b<<b)))+(((m<<k)+b)<<((((m<<e)-b)<<k)-(b<<b)))+(((((k<<e)-b)<<l)-m)<<((((b<<l)+b)<<k)+k))-(((((b<<l)-b)<<l)-p)<<((b<<p)+(b<<b)))-(((p<<k)-b)<<((((b<<l)-b)<<k)+k))-(((k<<q)-b)<<((p<<l)))+(((m<<m)+m)<<((((k<<e)+b)<<k)-b))-(((k<<m)+b)<<((k<<m)-b))-(((m<<m)+k)<<((((k<<e)-b)<<k)-(b<<b)))+(((((k<<e)+b)<<e)+b)<<((m<<l)-(b<<e)))-(((((k<<e)+b)<<e)+b)<<((((b<<l)+b)<<e)-b))+((((((b<<k)+b))<<k)+b)<<((p<<k)))+(((((k<<e)-b)<<k)-k)<<((k<<l)))+(((m<<l)+b)<<((m<<k)))+(((m<<e)-b)<<((b<<m)+(b<<b)))+((((((b<<k)+b))<<e)-b)<<((k<<k)+b))+(((m<<k)-b)<<((b<<l)+b))-((((k<<e)-b))<<((k<<e)))+(((m<<e)+b)<<e)-b,b,b<<l*e)))[i]for i in(lambda x: [x.remove(e), x[::-b]][b] if e in x else x)((lambda x:(lambda x,g,h:g(x,b,[],g,h))(x,lambda x,n,r,g,h:h(x,n+b,r,g,h)if x>b else r,lambda x,n,r,g,h:h(x//n,n,r+[n],g,h)if x%n==a else g(x,n,r,g,h)))(x))))(*[x for x in range(True<<len(len.__name__))])

Cela pourrait certainement être court-circuité, mais c’est ma tentative de le résoudre sans chiffres ni littéraux de chaîne. Je réalise que c'est un problème de code-golf et que ce n'est pas tout à fait court mais je voulais le partager quand même, je ne sais pas si cela enfreint les règles ou pas.

C'était très amusant à faire, j'ai utilisé l'algorithme de ce billet de blog pour réduire la représentation numérique ASCII de "SPMFLQUIXNCWORAGZTEJHVDBKY" dans l'expression de décalage de bit que j'utilise. En général, je me suis également beaucoup inspiré de ce blog, je voulais l’essayer moi-même et c’était un bon défi de le faire.

Voici une version légèrement plus lisible, avec quelques noms de variables plus sensibles aussi