Göreviniz, 103 nolu bir sayıyı aşağıda açıklanan yöntemi kullanarak İngilizce kelimeye çevirmek.

Nasıl?

1. Girilen sayının asal çarpanlarının listesini (tekrarı ile birlikte) oluşturun.
2. Listeyi sırala:
   • Eğer 2 asal faktörlerden biri değildir, küçükten büyüğe sıralamak.
   • Eğer 2 asal faktörlerden biridir, listeden kaldırmak ve azalan kalan faktörleri sıralamak.

3. Aşağıdaki tabloyu kullanarak her faktörü bir harfe çevirin:

    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  
   

_{Not : Bu tablo, olası kelimelerin sayısını en üst düzeye çıkarmak için ampirik olarak oluşturulmuştur. Meraklı için, burada bu şekilde kodlanabilen 2,187 kelimenin listesi ( kaba bir dil içerebilir). Kesinlikle optimal olacağı garanti edilmiyor, ancak bu zorluk için yeterince iyi.}

Örnekler

Örnek 1: 579085261 (artan düzen)

1. Başlıca faktörler [37, 47, 53, 61, 103] .
2. 2 bir ana faktör değildir, bu yüzden listeyi artan düzende sıralı tutarız.
3. 37 = C, 47 = R, vb. Çıkış "CRAZY" dir.

Örnek 2: 725582 (azalan düzen)

1. Başlıca faktörler [2, 11, 13, 43, 59] .
2. 2 bir ana faktördür, bu yüzden onu kaldırır ve listeyi azalan düzende sıralar, ki aşağıdakileri verir:
   [59, 43, 13, 11] .
3. 59 = G, 43 = O, vb. Çıkış "GOLF" dir.

Örnek 3: 10757494 (tekrarlanan bir faktör ile)

1. Başlıca faktörler [2, 11, 71, 71, 97] .
2. 2 bir ana faktördür, bu yüzden onu kaldırır ve listeyi azalan düzende sıralar, ki şu sağlar:
   [97, 71, 71, 11] .
3. 97 = B, 71 = E, 11 = F Çıktı "BEEF" dir.

Açıklamalar ve kurallar

• Giriş sayısının en fazla bir defa 103 ile pürüzsüz ve bölünebilir olması garanti edilir.
• Tanım olarak, düzgün bir sayı pozitif bir tamsayıdır .
• Giriş ve çıkış herhangi bir makul formatta ele alınabilir. Çıktı küçük harf veya büyük harf olabilir. İzleyen beyaz boşluk kabul edilebilir. Önde gelen boşluk değil.
• Programınız / fonksiyonunuz büyük girişleri destekleyemiyorsa, lütfen cevabınızı belirtiniz.
• Bu kod golf, yani bayt cinsinden en kısa cevap kazanır.

Test durumları

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

Jöle , 29 27 bayt

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

1 byte'lık golf için @JonathanAllan'a teşekkürler!

Çevrimiçi deneyin!

Arka fon

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

sayısal bir değişmezdir. Tırnaklar arasındaki karakterler Jelly kod sayfasındaki 1-temelli indeksleri ile değiştirilir ve ortaya çıkan dizi 250-baz olarak yorumlanır. Bu, c: = 288824892868083015619552399 tamsayısını verir .

Nasıl çalışır

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

Jöle , 36 bayt

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

Çevrimiçi deneyin!

açıklama

Yardımcı sabit1£ (hazır “SPMFLQUIXNCWORAGZTEJHVDBKY ”1 ile üretilir)

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

Ana program

×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

Listedeki sıkıştırmamın diğer Jelly cevabını kolayca attığını, ancak onu kullanma algoritmamın çok daha etkili olabileceğini hissediyorum. Belki onları birleştirmeye çalışırım.

Jelly , 31 bayt, @ Leakynun'un yanıtından ilham aldı

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

Çevrimiçi deneyin! (daha hızlı çalışması için hafifçe değiştirilmiş)

Sonunda yeni bir satır yazdırıp yazdırmamada tutarsız (PPCG normalde son satırda ya da sonda olmayan cevaplara izin veriyor, sanırım bu da işe yarıyor?). Mı çok (O (yavaş n ) nerede n ... girdidir ve bu sayılar tam olarak küçük değildir)

açıklama

Yardımcı sabit1£ ( newline “¶SPMFLQUIXNCWORAGZTEJHVDBKY”nerede ¶üretilir)

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

Ana program

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

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

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin!

Python 2,220 217 bayt

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

Çevrimiçi deneyin - yalnızca en küçük test senaryosunu, hafıza tükenmeden çalıştırır

Ungolfed:

Bu sürüm kullanmaz exec, bu nedenle aslında tüm test durumlarını hafızanız dolmadan test edebilirsiniz.

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)

Çevrimiçi deneyin

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

-rprimeBayrağı +7 bayt için kullanır .

@Daniero'dan -1 bayt. -4 bayt aslının varlığını kontrol etmek yerine sadece düzenli bir bölünebilirlik kontrolü yapabileceğimi hatırlayarak 2.

@ Mbomb007's Python çözümünden -9 bayt, eşleşen harfi almak için bana daha kısa bir yol hatırlatan.

-5 bayt çünkü sondaki boşluk boşluğa izin veriliyor.

- Keşfeden 5 bayt 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}*''}

Çevrimiçi deneyin! (tüm test durumları)

açıklama

->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 yardımcı programları + bsd-games paketi, 170

Oldukça uygun değil gibi görünüyor, ama işe yarıyor:

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

Çevrimiçi deneyin .

Jöle , 33 bayt

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

Çevrimiçi deneyin!

Japt , 51 50 bayt

49 bayt kod, -Pbayrak için +1 .

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

Çevrimiçi deneyin!

Bu, Japt’in birkaç özelliği daha olsaydı, daha kısa olabilirdi ...

açıklama

`yspmflquixncÙgz’jhvdbk`diğer herkesin, Japt'in sıkıştırabileceği kadar sıkıştırdığı bir dizi (orijinalinden 3 byte daha kısa!). Japt'in şu andaki tek yerleşik sıkıştırma aracı, ortak küçük harfli harfleri tek baytlık bir karakterle değiştirir.

Öyleyse gerçek kodu inceleyelim:

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

Ardından £, sonuçtaki her öğeyi değiştirmek için kullanılır X:

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

Sonuç bu noktada bir karakter dizisidir, bu nedenle -Pbayrak onu tek bir dizgeye ekler ve sonuç çıktıya dolaylı olarak gönderilir.

Jöle , 40 bayt

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

Çevrimiçi deneyin!

Tüm test durumlarını bir kerede doğrulayın! (biraz değiştirilmiş)

Pyth , 54 47 bayt

İsaacg sayesinde 7 bayt

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

( ❤yazdırılamayan bir karakteri temsil eder)

Pyth'in pek çok ana özelliği yoktur ...

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

Çevrimiçi deneyin!

J , 59 bayt

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

Çevrimiçi deneyin!

Oldukça basit...

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

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

Çevrimiçi sürüm

Expanded

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 Bayt

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

Çevrimiçi sürüm

Expanded

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 bayt

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

Bu kesinlikle bazılarını kısaltabilirdi, ancak bu benim sayı veya string değişmezleri ile çözme girişimim. Bunun bir kod-golf problemi olduğunun farkındayım ve bu tam olarak kısa değil ama yine de paylaşmak istiyor, bunun herhangi bir kuralı ihlal edip etmediğinden emin değil.

Yapması çok eğlenceliydi, kullandığım bit-shift ifadesine ASCII "SPMFLQUIXNCWORAGZTEJHVDBKY" nin sayısal gösterimini azaltmak için bu blog yazısındaki algoritmayı kullandım. Ayrıca bu blogdan çok fazla ilham aldım, kendim denemek istedim ve bu da bunu yapmak için iyi bir meydan okumaya benziyordu.

İşte biraz daha okunabilir bir versiyon, biraz daha mantıklı değişken isimleri