Ваше завдання полягає в перекладі 103-гладкого числа на англійське слово, використовуючи описаний нижче метод.

Як?

1. Створіть список простих факторів (з повторенням) вхідного числа.
2. Сортування списку:
   • Якщо 2 не є одним із найважливіших факторів, сортуйте список у порядку зростання.
   • Якщо 2 є одним із головних факторів, видаліть його зі списку та сортуйте решта факторів у порядку зменшення.

3. Перекладіть кожен фактор на лист, використовуючи наступну таблицю:

    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  
   

_{Примітка . Ця таблиця була побудована емпірично, щоб максимально збільшити кількість можливих слів. Для допитливих, ось список 2187 слів, які можна закодувати таким чином (може включати грубу мову). Оптимально не гарантовано, але це досить добре для цього виклику.}

Приклади

Приклад 1: 579085261 (по порядку зростання)

1. Основними факторами є [37, 47, 53, 61, 103] .
2. 2 не є основним фактором, тому ми зберігаємо список, відсортований у порядку зростання.
3. 37 = C, 47 = R і т. Д. Вихід "CRAZY".

Приклад 2: 725582 (порядок зменшення)

1. Основними факторами є [2, 11, 13, 43, 59] .
2. 2 є основним фактором, тому ми видаляємо його і сортуємо список у порядку зменшення, який дає:
   [59, 43, 13, 11] .
3. 59 = G, 43 = O і т. Д. Вихід "GOLF".

Приклад 3: 10757494 (з повторним коефіцієнтом)

1. Основними факторами є [2, 11, 71, 71, 97] .
2. 2 є основним фактором, тому ми видаляємо його і сортуємо список у порядку зменшення, який дає:
   [97, 71, 71, 11] .
3. 97 = B, 71 = E, 11 = F. Вихід "BEEF".

Роз'яснення та правила

• Гарантоване число введення буде 103-гладким і ділиться не більше ніж 2.
• За визначенням гладке число - це додатне ціле число .
• Введення та вихід можна обробляти у будь-якому розумному форматі. Вихід може бути малі або великі. Приймаючи пробіли проміжків є прийнятними. Провідні пробіли - ні.
• Якщо ваша програма / функція не може підтримувати великі введення, вкажіть це у своїй відповіді.
• Це кодовий гольф, тому найкоротша відповідь у байтах виграє.

Тестові справи

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

Желе , 29 27 байт

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

Дякуємо @JonathanAllan за те, що виграли 1 байт!

Спробуйте в Інтернеті!

Фон

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

є числовим буквалом. Символи між цитатами замінюються їхніми індексами на основі кодової сторінки Jelly , а отриманий масив інтерпретується як число-250. Це дає ціле число c: = 288824892868083015619552399 .

Як це працює

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

Желе , 36 байт

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

Спробуйте в Інтернеті!

Пояснення

Помічна константа1£ (виробляється “SPMFLQUIXNCWORAGZTEJHVDBKY ”з 1 попередньою)

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

Основна програма

×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

У мене є відчуття, що моє стискання списку легко перемагає іншу відповідь Jelly, але мій алгоритм його використання може бути набагато ефективнішим. Можливо, я спробую їх поєднати.

Желе , 31 байт, натхненний відповіддю @ Leakynun

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

Спробуйте в Інтернеті! (трохи змінено, щоб працювати набагато швидше)

Невідповідний чи друкує він трейлінг нового рядка (але PPCG, як правило, дозволяє відповідати з або без трейлінг нового рядка, тому я думаю, це теж працює?). Це дуже повільно (O ( n ), де n є входом, а ці числа не зовсім малі ...)

Пояснення

Постійна помічник1£ (створює “¶SPMFLQUIXNCWORAGZTEJHVDBKY”, де ¶є новий рядок)

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

Основна програма

Æ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 байт

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

Використовує кодування CP-1252 . Спробуйте в Інтернеті!

Python 2, 220 217 байт

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

Спробуйте в Інтернеті - працює лише найменший тестовий випадок, не втрачаючи пам'яті

Безголовки:

Ця версія не використовується exec, тому ви можете фактично перевірити всі тестові випадки, не втративши пам'ять.

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)

Спробуйте в Інтернеті

Рубі , 139 138 134 125 120 115 + 7 = 146 145 141 132 127 122 байт

Використовує -rprimeпрапор на +7 байт.

-1 байт від @daniero. -4 байти, пам’ятаючи, що я можу просто робити звичайну перевірку подільності замість перевірки основного поділу на існування 2.

-9 байт з рішення Python @ mbomb007, що нагадує мені про коротший спосіб отримати відповідне письмо.

-5 байт, оскільки тепер дозволений пробіл.

-5 байт від виявлення 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}*''}

Спробуйте в Інтернеті! (усі тестові випадки)

Пояснення

->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 утиліти + пакет bsd-ігор, 170

Здається, досить неоптимально, але це працює:

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

Спробуйте в Інтернеті .

Желе , 33 байти

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

Спробуйте в Інтернеті!

Japt , 51 50 байт

49 байт коду, +1 для -Pпрапора.

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

Спробуйте в Інтернеті!

Це може бути набагато коротше, якби тільки у Japt була ще пара функцій ...

Пояснення

`yspmflquixncÙgz’jhvdbk`- це лише та сама рядок, що всі інші використовують стиснуте стільки, скільки Japt може її стиснути (на 3 байти коротше, ніж оригінал!). Наразі єдиний вбудований інструмент стиснення Japt замінює загальні пари малих літер однобайтовими знаками.

Тож давайте вивчимо власне код:

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

Потім £використовується для заміни кожного елемента 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.

Результат - це масив символів у цей момент, тому -Pпрапор об'єднує його в єдиний рядок, і результат неявно відправляється на вихід.

Желе , 40 байт

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

Спробуйте в Інтернеті!

Перевірте всі тести одразу! (трохи змінено)

Піта , 54 47 байт

7 байт завдяки isaacg

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

( ❤являє собою недрукований символ)

У Pyth не так багато вбудованих ...

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

Спробуйте в Інтернеті!

J , 59 байт

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

Спробуйте в Інтернеті!

Досить просто ...

'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 байт

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

Інтернет-версія

Розширено

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 байт

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

Інтернет-версія

Розширено

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 

Пітон, 1420 байт

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

Це, безумовно, може бути скороченим деяким, але це моя спроба вирішити це без чисел чи рядкових літералів. Я усвідомлюю, що це проблема коду-гольфу, і це не зовсім коротко, але хотів поділитися все одно, не впевнений, чи порушує це якісь правила чи ні.

Мені було дуже цікаво зробити, я використав алгоритм у цій публікації блогу, щоб зменшити числове представлення ASCII "SPMFLQUIXNCWORAGZTEJHVDBKY" до виразу біт-зсуву, який я використовую. Я також зазвичай брав багато натхнення з цього блогу, хотів спробувати його сам, і це здавалося гарним викликом зробити це.

Ось трохи читабельніша версія, яка містить і більш розумні імена змінних