Ваша задача - перевести 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 и т. Д. Выход «ГОЛЬФ».

Пример 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ḅḲ+Ṿɼ¡ẏƙẊƘ’

это числовой литерал. Символы между кавычками заменяются их индексами, основанными на 1, в кодовой странице Jelly , а результирующий массив интерпретируется как число base-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 ( п ) , где п является входом, и эти цифры не совсем маленькие ...)

объяснение

Вспомогательная константа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])

Попробуйте онлайн - запускает только самый маленький тестовый набор без нехватки памяти

Ungolfed:

Эта версия не использует 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

Попробуйте онлайн!

Это могло бы быть намного короче, если бы у Джапта было еще несколько функций ...

объяснение

`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

Попробуйте онлайн!

Проверьте все тестовые случаи одновременно! (слегка модифицированный)

Pyth , 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 

Python, 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" в выражении битового сдвига, которое я использую. Я также, как правило, черпал много вдохновения из этого блога, я хотел попробовать его сам, и это казалось хорошим испытанием.

Вот немного более читаемая версия, с некоторыми более разумными именами переменных