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

39

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
Arnauld
quelle
9
Ohhh Mist ... 05AB1E Cache-Treffer bei Verwendung von Òon 579085261, fühle mich wie <s> Emigna </ s> Adnan hat bereits begonnen.
Magic Octopus Urn
Sie hätten auch mehrere Faktoren von 2 zulassen können und es dann so gemacht, dass das Erhöhen der Anzahl der Faktoren den Index ändert, bei dem die Umkehr beginnt.
mbomb007
@ mbomb007 Ja, es gibt viele mögliche Varianten. Meine ursprüngliche Idee war es, ein Wort durch die Bearbeitung von Buchstabengruppen zu kodieren .
Arnauld
5
Die Testfälle bei dieser Herausforderung erinnern an die Dinge, die Sie auf Facebook mit "Entdecke Ihren X-Namen" gemacht haben. Finde den Titel des Films, in dem du bist! Schritt eins, wählen Sie Ihre Lieblingsprimzahl <=103... Ihr Ergebnis ist PIRATE MAZE, oder DOOM VACUUMS...
mbomb007
2
@ Qwerp-Derp Es wurde zuerst nach dem Zufallsprinzip gemischt und anhand eines Wörterbuchs mit ~ 106.000 Wörtern und bis zu 11 Buchstaben getestet (die Datei befindet sich seit langer Zeit auf meiner Festplatte - ich glaube, sie wurde ursprünglich aus der TWL extrahiert ). Dann zwang ich 'S', entweder das erste oder das letzte zu sein, um die Mehrzahl der Wörter zu maximieren, und versuchte ein paar einzelne Briefwechsel in einer guten Kombination (rekursiv). Schließlich verlor ich die Geduld und schrieb die Herausforderung. :-) Eigentlich habe ich vor allem versucht, die Anzahl der Buchstaben nach Position in Word zu berücksichtigen, aber es war nicht so toll.
Arnauld

Antworten:

13

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.
Dennis
quelle
10

Gelee , 36 Bytes

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

Probieren Sie es online!

Erläuterung

Hilfskonstante (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 Konstante (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

quelle
Das ist eine sehr schöne Möglichkeit, eine Permutation des Alphabets zu speichern ...
Undichte Nonne
Ah, Sie haben auch mein Permutationsatom verwendet: D
Jonathan Allan
9

05AB1E , 39 38 Bytes

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

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

Adnan
quelle
8
Ich wusste, dass es einer von euch war, hahaha. kratzt auf halbem Weg Antwort in den Müll
Magic Octopus Urn
6
@carusocomputing die Cache-Hits können einige Zeit Druck bringen haha
Adnan
Øwar der Teil davon, der meine sowieso um 20 Bytes schlug: P.
Magic Octopus Urn
2
Es ist nicht sehr effizient, nein;)
Emigna
8

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

mbomb007
quelle
8

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
Wert Tinte
quelle
Schön. Sie können das Leerzeichen zwischen zipund entfernen"
daniero
7

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 .

Digitales Trauma
quelle
6

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.

ETHproductions
quelle
5

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!

Undichte Nonne
quelle
@isaacg Ich habe es versucht, und ich weiß nicht, warum es für den letzten ein seltsames Ergebnis erzeugt.
Undichte Nonne
Ich weiß nicht, was du meinst: pyth.herokuapp.com/…
isaacg
@isaacg Das ist sehr komisch.
Undichte Nonne
5

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

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

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

Billyoyo
quelle
Es gibt mindestens ein Feld, das entfernt werden kann.
mbomb007
2
Willkommen bei Programming Puzzles & Code Golf! Dies ist ein Code-Golf-Wettbewerb. Ihr Ziel sollte es sein, Ihren Code so kurz wie möglich zu halten. In unserer Hilfe heißt es, dass alle Lösungen für [...] Herausforderungen ein ernstzunehmender Anwärter auf die verwendeten Gewinnkriterien sein sollten. [...] Eine Teilnahme an einem Codegolfwettbewerb muss absolviert werden
Dennis,