579085261 est CRAZY, 725582 est GOLF, 10757494 est…?

39

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
Arnauld
la source
9
Ohhh merde ... 05AB1E cache hit lors de l'utilisation Òsur 579085261, se sent comme <s> Emigna </ s> Adnan a déjà commencé.
Urne Magique Octopus
Vous auriez pu autoriser plusieurs facteurs de 2, puis faire en sorte que l'augmentation du nombre de facteurs modifie l'indice auquel l'inversion commence.
mbomb007
@ mbomb007 Oui, il existe de nombreuses variantes possibles. Mon idée de départ était d'encoder n'importe quel mot en travaillant sur des groupes de lettres.
Arnauld
5
Les cas de test de ce défi rappellent ceux de "Découvrez votre nom X" sur Facebook. Trouvez le titre du film dans lequel vous êtes! Première étape, choisissez votre nombre premier favori <=103... votre résultat est PIRATE MAZE, ou DOOM VACUUMS...
mbomb007
2
@ Qwerp-Derp Il a d'abord été mélangé de manière aléatoire et testé contre un dictionnaire de ~ 106 000 mots, comportant jusqu'à 11 lettres (le fichier est sur mon disque dur depuis longtemps - je pense qu'il a été extrait à l'origine du TWL ). Ensuite, j'ai forcé 'S' à être le premier ou le dernier pour maximiser les mots au pluriel et j'ai essayé quelques échanges de lettres individuelles sur une bonne combinaison (de manière récursive). Finalement, j'ai perdu patience et j'ai écrit le défi. :-) En fait, avant tout, j’essayais de prendre en compte le nombre de lettres par position dans Word , mais ce n’était pas si terrible.
Arnauld

Réponses:

13

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.
Dennis
la source
10

Gelée , 36 octets

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

Essayez-le en ligne!

Explication

Constante d'assistance (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'assistance (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

la source
C'est une très bonne façon de stocker une permutation de l'alphabet ...
Leaky Nun
Ah, vous avez également utilisé mon atome de permutation: D
Jonathan Allan
9

05AB1E , 39 38 octets

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

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

Adnan
la source
8
Je savais que c'était l'un de vous hahaha. finit la réponse à la poubelle
Urne Octopus Magique
6
@carusocomputing les cache cache peuvent faire monter la pression du temps haha
Adnan
Øétait la partie de ce qui a battu le mien de 20 octets quand même: P.
Urne magique Octopus
Je pense que vous pouvez faire ? Ò26ÝØR • 1Si ¾ ± = et ÔìÍècS|ÁÜ7d • 36BS: Já¹GR pour 37.
Emigna
2
Ce n'est pas très efficace non;)
Emigna
8

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

mbomb007
la source
8

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
Valeur d'encre
la source
Joli. Vous pouvez supprimer l'espace entre zipet"
daniero le
7

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 .

Trauma numérique
la source
6

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.

ETHproductions
la source
5

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!

Fuite Nun
la source
@isaacg Je l'ai essayé, et je ne sais pas pourquoi cela produit un résultat étrange pour le dernier.
Leaky Nun
Je ne sais pas ce que vous voulez dire: pyth.herokuapp.com/…
isaacg
@isaacg C'est très bizarre.
Leaky Nun
5

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
Conor O'Brien
la source
3

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 
Jörg Hülsermann
la source
1

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

Billyoyo
la source
Il y a au moins un espace qui peut être supprimé.
mbomb007
2
Bienvenue dans Programming Puzzles & Code Golf! Il s’agit d’une compétition de codes de golf. L’objectif doit donc être de rendre votre code aussi court que possible. Notre centre d'aide affirme que toutes les solutions aux défis [...] devraient constituer un sérieux prétendant aux critères gagnants utilisés. [...] Une entrée à un concours de golf de code doit être jouée au golf
Dennis