579085261是CRAZY，725582是GOLF，10757494是…？

39

您的任务是使用以下描述的方法将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
code-golf  string  primes  cipher 
— Arnauld
source
9
噢，废话... 05AB1E在Òon上使用时命中了缓存579085261，感觉<s> Emigna </ s> Adnan已经开始。
— 魔术章鱼缸
您可以允许多个因子2，然后使其增加，以便增加因子的数量可以更改反转开始的索引。
— mbomb007'4
@ mbomb007是的，有许多可能的变体。我最初的想法是通过处理字母组来编码任何单词。
— Arnauld
5
关于此挑战的测试案例使人想起了那些在Facebook上“发现您的X名称”的事情。查找您所在电影的标题！第一步，选择您喜欢的质数<=103...您的结果是PIRATE MAZE或DOOM VACUUMS...
— mbomb007 '04
2
@ Qwerp-Derp它首先被随机打乱，并针对约10万6千个单词的字典进行了测试，该字典最多包含11个字母（该文件在我的HD上保存了很长时间-我认为它最初是从TWL中提取的）。然后，我强迫'S'成为第一个或最后一个，以最大化多个单词，并尝试以良好的组合（递归）进行几个单独的字母交换。最后，我失去了耐心，写下了挑战。:-)实际上，在进行所有这些操作之前，我曾尝试考虑Word中按位置划分的字母计数，但这并不是很好。
— Arnauld

Answers:

13

果冻，29 27字节

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

感谢@JonathanAllan打高尔夫球1个字节！

在线尝试！

背景

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

是数字文字。在Jelly代码页中，引号之间的字符将替换为其从1开始的索引，并且所得数组被解释为以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.
— 丹尼斯
source
10

果冻，36字节

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

在线尝试！

说明

Helper常数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（ñ），其中ñ是输入，并且这些数字不算少...）

说明

Helper常数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
这是存储字母排列的一种非常好的方法……
— Leaky Nun
啊，您也使用了我的置换原子：D
— Jonathan Allan
9

05AB1E，39 38字节

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

使用CP-1252编码。在线尝试！

— 阿德南
source
8
我知道那是你们中的一员哈哈哈。刮到垃圾中途完成的答案
— 魔术章鱼缸
6
@carusocomputing缓存命中次数可能带来一些时间压力哈哈
— Adnan
Ø无论如何，这是使我击败20个字节的一部分：P。
— 魔术章鱼缸
— Emigna
2
效率不是很高；）
— Emigna
8

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)

在线尝试

— mbomb007
source
8

红宝石，139 138 134 125 120 115 + 7 = 146 145 141 132 127 122字节

使用-rprime+7个字节的标志。

@daniero的-1个字节。记住-4个字节，我可以进行常规的除数检查，而不用检查素数除法是否存在2。

@ mbomb007的Python解决方案中的-9个字节使我想起了一种检索匹配字母的较短方法。

-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
— 价值墨水
source
好东西。您可以删除之间的空间zip和"
— 达尼罗
7

Bash + GNU实用程序+ bsd-games程序包，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

在线尝试。

— 数字创伤
source
6

Japt，51 50字节

49个字节的代码，-P标志+1 。

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

在线尝试！

如果仅Japt具有更多功能，则可能会更短...

说明

`yspmflquixncÙgz’jhvdbk`与Japt可以压缩的其他字符串所使用的压缩字符串相同（比原始字符串短3个字节！）。Japt目前唯一的内置压缩工具用单字节char替换了常见的小写字母对。

因此，让我们检查一下实际的代码：

%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标志将其连接为单个字符串，并将结果隐式发送到输出。

— ETH生产
source
5

Pyth，54 47字节

感谢isaacg 7个字节

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

（❤代表不可打印的字符）

Pyth没有很多主要的内置组件...

十六进制转储：

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

在线尝试！

— 漏尼姑
source
— isaacg
@isaacg我尝试过，但我不知道为什么最后一个会产生奇怪的结果。
— Leaky Nun
我不知道您的意思：pyth.herokuapp.com/…–
— isaacg
@isaacg这很奇怪。
— Leaky Nun
5

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
— 科纳·奥布莱恩
source
3

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
— 约格·赫尔瑟曼
source
1

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

当然可以缩短一些，但这是我尝试不使用数字或字符串文字来解决它的尝试。我意识到这是一个代码高尔夫问题，这不正是短，但想反正共享，不知道这是否破裂的任何规则或不。

这样做很有趣，我在此博客文章上使用了算法，将“ SPMFLQUIXNCWORAGZTEJHVDBKY”的ASCII数值表示形式减少到我使用的位移表达式中。通常，我也从这个博客中获得了很多启发，我想自己尝试一下，这似乎是一个很好的挑战。

这是一个更具可读性的版本，也带有一些更合理的变量名

— 比约约
source
至少有一个可以删除的空间。
— mbomb007 '17
2
欢迎来到编程难题和代码高尔夫球！这是一场高尔夫代码竞赛，因此您的目标应该是使代码尽可能短。我们的帮助中心指出，应对挑战的所有解决方案均应严格遵循所采用的获胜标准。[...]代码高尔夫球比赛的参赛作品需要打高尔夫球
— 丹尼斯（Dennis）
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.