Ihre Aufgabe ist es, eine 103-glatte Zahl mit der unten beschriebenen Methode in ein englisches Wort zu übersetzen .

Wie?

1. Generieren Sie die Liste der Primfaktoren (mit Wiederholung) der eingegebenen Zahl.
2. Liste sortieren:
   • Wenn 2 nicht zu den Primfaktoren gehört, sortieren Sie die Liste in aufsteigender Reihenfolge.
   • Wenn 2 einer der Hauptfaktoren ist, entfernen Sie ihn aus der Liste und sortieren Sie die verbleibenden Faktoren in absteigender Reihenfolge.

3. Übersetzen Sie jeden Faktor anhand der folgenden Tabelle in einen Buchstaben:

    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  
   

_{Anmerkung : Diese Tabelle wurde empirisch erstellt, um die Anzahl der möglichen Wörter zu maximieren. Für die Neugierigen ist hier eine Liste von 2.187 Wörtern , die auf diese Weise codiert werden können (einschließlich unhöflicher Sprache). Es ist definitiv nicht garantiert, dass es optimal ist, aber es ist gut genug für diese Herausforderung.}

Beispiele

Beispiel 1: 579085261 (aufsteigende Reihenfolge)

1. Die Primfaktoren sind [37, 47, 53, 61, 103] .
2. 2 ist kein Primfaktor, daher wird die Liste in aufsteigender Reihenfolge sortiert.
3. 37 = C, 47 = R usw. Die Ausgabe ist "CRAZY".

Beispiel 2: 725582 (absteigende Reihenfolge)

1. Die Primfaktoren sind [2, 11, 13, 43, 59] .
2. 2 ist ein Primfaktor, also entfernen wir ihn und sortieren die Liste in absteigender Reihenfolge, was ergibt:
   [59, 43, 13, 11] .
3. 59 = G, 43 = O usw. Die Ausgabe ist "GOLF".

Beispiel 3: 10757494 (mit einem wiederholten Faktor)

1. Die Primfaktoren sind [2, 11, 71, 71, 97] .
2. 2 ist ein Primfaktor, also entfernen wir ihn und sortieren die Liste in absteigender Reihenfolge, was ergibt:
   [97, 71, 71, 11] .
3. 97 = B, 71 = E, 11 = F. Die Ausgabe ist "BEEF".

Erläuterungen und Regeln

• Die eingegebene Zahl ist garantiert 103-glatt und höchstens einmal durch 2 teilbar.
• Per Definition ist eine glatte Zahl eine positive ganze Zahl .
• Die Ein- und Ausgabe kann in jedem vernünftigen Format erfolgen. Die Ausgabe kann in Klein- oder Großbuchstaben erfolgen. Nachgestellte Leerzeichen sind akzeptabel. Führendes Leerzeichen ist das nicht.
• Wenn Ihr Programm / Ihre Funktion keine großen Eingaben unterstützen kann, geben Sie dies bitte in Ihrer Antwort an.
• Dies ist Codegolf, daher gewinnt die kürzeste Antwort in Bytes.

Testfälle

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

Jelly , 29 27 Bytes

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

Vielen Dank an @JonathanAllan für das Abschlagen von 1 Byte!

Probieren Sie es online!

Hintergrund

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

ist ein numerisches Literal. Die Zeichen zwischen den Anführungszeichen werden in der Jelly-Codepage durch ihre auf 1 basierenden Indizes ersetzt , und das resultierende Array wird als Basis-250-Zahl interpretiert. Dies ergibt die Ganzzahl c: = 288824892868083015619552399 .

Wie es funktioniert

Æ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.

Gelee , 36 Bytes

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

Probieren Sie es online!

Erläuterung

Hilfskonstante1£ (produziert “SPMFLQUIXNCWORAGZTEJHVDBKY ”mit einer 1 voran)

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

Hauptprogramm

×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

Ich habe das Gefühl, dass meine Komprimierung der Liste die andere Jelly-Antwort leicht übertrifft, aber dass mein Algorithmus für die Verwendung viel effizienter sein könnte. Vielleicht werde ich versuchen, sie zu kombinieren.

Jelly , 31 Bytes, inspiriert von @ Leakynuns Antwort

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

Probieren Sie es online! (leicht modifiziert, um viel schneller zu laufen)

Ist inkonsistent, ob eine nachgestellte Zeile gedruckt wird (PPCG lässt normalerweise Antworten mit oder ohne nachgestellte Zeile zu, also funktioniert das wohl auch?). Ist sehr langsam (O ( n ), wobei n die Eingabe ist und diese Zahlen nicht genau klein sind ...)

Erläuterung

Helper Konstante1£ (produziert “¶SPMFLQUIXNCWORAGZTEJHVDBKY”, wo ¶ist Neue - Zeile)

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

Hauptprogramm

Æ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 Bytes

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Python 2 220 217 Bytes

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])

Probieren Sie es online aus - es wird nur der kleinste Testfall ohne Speichermangel ausgeführt

Ungolfed:

Diese Version wird nicht verwendet exec, sodass Sie alle Testfälle testen können, ohne dass der Arbeitsspeicher knapp wird.

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)

Probieren Sie es online aus

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

Verwendet das -rprimeFlag für +7 Bytes.

-1 Byte von @daniero. -4 Bytes, indem ich daran denke, dass ich einfach eine reguläre Teilbarkeitsprüfung durchführen kann, anstatt die Primzahldivision auf das Vorhandensein von zu prüfen 2.

-9 Bytes aus der Python-Lösung von @ mbomb007, die mich an einen kürzeren Weg erinnert, den passenden Buchstaben abzurufen.

-5 Bytes, da abschließende Leerzeichen jetzt zulässig sind.

-5 Bytes von der Entdeckung 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}*''}

Probieren Sie es online! (alle Testfälle)

Erläuterung

->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 + GNU-Dienstprogramme + BSD-Spiele-Paket, 170

Scheint ziemlich nicht optimal, aber es funktioniert:

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

Probieren Sie es online aus .

Gelee , 33 Bytes

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

Probieren Sie es online!

Japt , 51 50 Bytes

49 Byte Code, +1 für das -PFlag.

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

Probieren Sie es online!

Dies könnte viel kürzer sein, wenn nur Japt ein paar Features mehr hätte ...

Erläuterung

`yspmflquixncÙgz’jhvdbk`ist genau derselbe String, den alle anderen Benutzer komprimiert haben, so oft Japt ihn komprimieren kann (3 Byte kürzer als das Original!). Das derzeit einzige in Japt integrierte Komprimierungsprogramm ersetzt gängige Paare von Kleinbuchstaben durch ein Einzelbyte-Zeichen.

Schauen wir uns also den aktuellen Code an:

%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.

Anschließend £wird jedes Element Xim Ergebnis folgendermaßen ersetzt:

"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.

Das Ergebnis ist an dieser Stelle ein Array von Zeichen. Das -PFlag fügt es zu einer einzelnen Zeichenfolge zusammen und das Ergebnis wird implizit an die Ausgabe gesendet.

Gelee , 40 Bytes

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

Probieren Sie es online!

Überprüfen Sie alle Testfälle auf einmal! (leicht verändert)

Pyth , 54 47 Bytes

7 bytes dank isaacg

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

(steht ❤für ein nicht druckbares Zeichen)

Pyth hat nicht viele erstklassige Funktionen ...

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

Probieren Sie es online!

J , 59 Bytes

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

Probieren Sie es online!

Ziemlich einfach...

'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 Bytes

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];

Online Version

Erweitert

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 Bytes

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];

Online Version

Erweitert

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 Bytes

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__))])

Dies könnte definitiv einige kurzschließen, aber es ist mein Versuch, es ohne Zahlen oder String-Literale zu lösen. Mir ist klar, dass dies ein Code-Golf-Problem ist und dass dies nicht gerade kurz ist, aber ich wollte es trotzdem teilen, nicht sicher, ob dies gegen Regeln verstößt oder nicht.

Es hat viel Spaß gemacht, den Algorithmus in diesem Blog-Beitrag zu verwenden, um die numerische ASCII-Darstellung von "SPMFLQUIXNCWORAGZTEJHVDBKY" auf den von mir verwendeten Bit-Shift-Ausdruck zu reduzieren. Ich habe mich auch generell sehr von diesem Blog inspirieren lassen, ich wollte es selbst ausprobieren und das schien eine gute Herausforderung zu sein.

Hier ist eine etwas besser lesbare Version mit einigen sinnvolleren Variablennamen