23

考虑数字99999999。该数字显然是回文。99999999的最大素数是137。如果用99999999除以137，则得到729927。该数字也是回文。

729927的最大素数是101。729927/101 = 7227也是回文。

7227的最大素数是73。7227/73 = 99也是回文。

通过进一步除以最大素数，您得到9、3和最后1，它们是一位数字，也是回文。由于1没有素数，该过程到此结束。

现在将这个观察结果概括起来，我将超级回文定义为一个回文，该回文要么为1，要么除以它的最大素数便得到另一个超级回文。

^{学分：https：//math.stackexchange.com/questions/200835/are-there-inre-infinitely-many-super-palindromes}

给定数字N，确定它是否是超级回文，并相应地打印真或假值。

您的程序应为这些输入打印真实值：

您的程序应为这些输入打印一个false值：

请记住，这是code-golf，因此，字节数最少的代码将获胜。

code-golf number palindrome

— 倪
source

3

输入会N一直是回文吗？

— Sherlock16年

@ Sherlock9号。

— 奥利弗镍

2

然后，您可以在假测试用例中添加非回文法吗？它将阐明规范。

— Sherlock16年

8

果冻，13 12 9 8 字节

Æf×\D⁼U$

在线尝试！或验证所有测试用例。

怎么运行的

Æf×\D⁼U$  Main link. Argument: n

Æf        Yield all prime factors of n, with multiplicities and in ascending order.
  ×\      Take the cumulative product.
    D     Decimal; convert each product into the array of its base 10 digits.
       $  Combine the two links to the left into a monadic chain.
      U     Upend; reverse all arrays of decimal digits.
     ⁼      Test for equality.

— 丹尼斯
source

6

Mathematica，64个字节

And@@PalindromeQ/@FixedPointList[#/FactorInteger[#][[-1,1]]&,#]&

未命名的函数，返回True或False。通过从输入开始，然后迭代功能“我除以我的最大素数”来形成列表，直到输出不变为止。（幸运的是，Mathematica现在认为1的最大素数是1。）然后测试列表项是否为回文（是内置的！boo函数名称长度！）并将And它们全部组合在一起。

— 格雷格·马丁
source

巧妙地利用（a）FactorInteger[1]与FixedPoint

— -LegionMammal978

是的，它曾经有帮助！:)

— 格雷格·马丁

6

Mathematica，51个字节

#<2||PalindromeQ@#&&#0[#/FactorInteger[#][[-1,1]]]&

递归匿名函数。将数字作为输入并返回True或False作为输出。

— 军团哺乳动物978
source

6

05AB1E，9 8字节

多亏了Adnan，节省了一个字节。

Ò.pPDíïQ

在线尝试！

说明

n = 7227 用作例子

Ò           # prime factors with duplicates
            # STACK: [3, 3, 11, 73]
 .p         # prefixes
            # STACK: [[3], [3, 3], [3, 3, 11], [3, 3, 11, 73]]
   P        # product
            # STACK: [3, 9, 99, 7227]
    D       # duplicate
            # STACK: [3, 9, 99, 7227], [3, 9, 99, 7227]
     í      # reverse each
            # STACK: [3, 9, 99, 7227], ['3', '9', '99', '7227']
      ï     # convert to  int
            # STACK: [3, 9, 99, 7227], [3, 9, 99, 7227]
       Q    # check for equality
            # STACK: 1
            # implicit output

— 艾米尼亚
source

我认为Ò.pPDíïQ也应该起作用。

— 阿德南

5

Pyth- 15 12字节

~~击败果冻：P~~：/

不幸的是，所有这些隐式映射在组合成显式映射时都不会变短，因为最后一个是自动展开。

.A_IM`M*M._P

测试套件。

获取素数分解的所有前缀，其乘积将为中间超级回文，并检查它们是否均为回文。

— 马尔蒂森
source

4

Mathematica，71 63字节

And@@PalindromeQ/@FoldList[1##&,Join@@Table@@@FactorInteger@#]&

说明

FactorInteger@#

分解输入。（例如8668 -> {{2, 2}, {11, 1}, {197, 1}}；对于输出中的每个列表，第一个元素是质因子，第二个元素是幂。

Join@@Table@@ ...

对于每个因子-功率对，将第一个元素乘以第二个元素，然后将整个对象弄平。（{{2, 2}, {11, 1}, {197, 1}} -> {{2, 2}, {11}, {197}} -> {2, 2, 11, 197}）

FoldList[1##&, ... ]

遍历列表，增加元素。（{2, 2, 11, 197} -> {2, 2 * 2, 2 * 2 * 11, 2 * 2 * 11 * 197} -> {2, 4, 44, 8668}）

And@@PalindromeQ/@ ...

检查所有得出的数字是否都是回文，然后应用And运算符。（{2, 4, 44, 8668} -> {True, True, True, True}-> True）

— 郑焕民
source

oooo，做得好！现在我得去看看，如果我可以节省2个字节的地方....

— 格雷格·马丁

3

Brachylog，14个字节

1|r?$ph:?r/:0&

在线尝试！

说明

这实现了挑战说明中解释的公式。

计算素因数分解后缀的所有乘积，并检查它们是否均为回文，则要长1个字节（1|$p:@]f:{*.r}a）。

1                  Input = 1
 |                 OR
  r?               Reversing the Input results in the Input
    $p             Get the prime factors of the Input
      h            Take the first one (the biggest)
       :?r/        Divide the Input by that prime factor
           :0&     Call this predicate recursively with that new number as input

— 致命
source

2

拍框238字节

(define(p n)(=(string->number(list->string(reverse(string->list(number->string n)))))n))
(if(= n 1)#t(begin(let o((n n))(define pd(prime-divisors n))(if(null? pd)#f(begin(let((m(/ n(last pd))))
(cond[(= m 1)#t][(p m)(o m)][else #f])))))))

取消高尔夫：

(define (f n)
  (define (palin? n)                      ; define palindrome of number
    (=(string->number
       (list->string
        (reverse
         (string->list
          (number->string n)))))
      n))
  (if(= n 1)#t
     (begin
       (let loop ((n n))
         (define pd (prime-divisors n))   ; find prime divisors
         (if (null? pd) #f                ; end if none- not superpalindrome
             (begin
               (let ((m (/ n (last pd)))) ; divide by largest prime divisor
                 (cond                    ; test quotient
                   [(= m 1) #t]           ; end if 1: super-palindrome found
                   [(palin? m) (loop m)]  ; loop with quotient if palindrome
                   [else #f]              ; end if not palindrome
                   ))))))))

测试：

(f 1)
(f 101)
(f 121)
(f 282)
(f 313)
(f 353)
(f 373)
(f 393)
(f 474)
(f 737)
(f 919)
(f 959)
(f 1331)
(f 1441)
(f 2882)
(f 6446)
(f 7887)
(f 8668)
(f 9559)
(f 9779)
(f 99999999)

输出：

#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t

— 恩索
source

我不熟悉Racket，但是您的辅助函数palin是否必须是一个五字节长的名称？

— 罗曼·格拉夫（RomanGräf）

我已经更正了它，但是没有正确粘贴到这里。238个字节的名称仅为“ p”。感谢您指出。

— rnso

2

J，30个字节

0:`(%1>.{:@q:)@.((-:|.)@":)^:_

错误代表错误，代表错误代表1。

初次尝试，没有错误，为false，40个字节：

0:`(([:$:]%{:@q:)`[@.(1&=))@.((-:|.)@":)

说明

0:`(%1>.{:@q:)@.((-:|.)@":)^:_
                           ^:_  repeat until convergent
              @.((-:|.)@":)     if the number is palindromic:
   (         )                   do the stuff inside, which is a 4-train
        {:@q:                    largest prime factor
     1>.                         (or 1, if smaller than 1)
    %                            divide the original number by this value
0:`                             otherwise, return 0
                                (because of ^:_, this will be passed into q:, which will
                                error because 0 cannot be factored.)

测试用例

   NB. collect errors; 0 if errored, otherwise the result of the function
   NB. left arg: values; right arg: boxed name of function
   errors =: 4 : 0
    f =. y`:6
    l =: ''
    for_e. x do.
        try.
            l =. l , f e
        catch.
            l =. l , 0
        end.
    end.
    l
)
   s =: 0:`(%1>.{:@q:)@.((-:|.)@":)^:_
   t =: 1 101 121 282 313 353 373 393 474 737 919 959 1331 1441 2882 6446 7887 8668 9559 9779
   f =: 323 432 555 583 585 646 642 696 777 969 989 2112 3553 4554 5242 5225 5445 8080 8118 9988
   t ,. f
   1  323
 101  432
 121  555
 282  583
 313  585
 353  646
 373  642
 393  696
 474  777
 737  969
 919  989
 959 2112
1331 3553
1441 4554
2882 5242
6446 5225
7887 5445
8668 8080
9559 8118
9779 9988
   (t ,. f) errors"1 0 <'s'
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0

— 科纳·奥布莱恩
source

2

he（Aheui），309个字节（100个字符* 3个字节+ 9个换行符）

방빩반룸있쁏멐솔쌀잌
앟놂숙참뿔썁썸뻙솝셜
본서번분번뮴딸냥별쀼
슉눇번낢퉅쑫썬쌀본묳
뽇서본석첫삭뽑롷떵춤
분촐럶사눙읽숟뗘분뻨
듐삭빶쏘윙잉썩손뵬괆
쌰뭉쇼텰궮변번첳웅텩
뽇흶아희쾯볻훼윺엄솝
코드골프욉쁍숙쌉삼쏩

我很高兴我真的完成了！

我是该语言的新手，因此欢迎提供任何改进字节数的技巧。

在这里尝试！（复制并粘贴代码）

清洁版

방빠반루ㅇ쀼머솔쌀이
아노숙차뿌썁썸뻐솝셜
본서번분번뮤따냐별쀼
슉누번나투쑫썬쌀본묘
뽀서본석처삭뽀로떠추
분초러사누이숟뗘분뻐
듀삭빠쏘ㅇ이썩손뵬ㅇ
쌰뭉쇼텨이변번처우텨
뽀희ㅇㅇㅇ볻ㅇ유어솝
ㅇㅇㅇㅇㅇㅇ숙쌉삼쏩

— 郑焕民
source

普通版和清除器有什么区别？

— 奥利弗·尼

@Oliver第一个版本没有NOP（ㅇ），并且具有更复杂的字符（它们是相同的代码；我只是使第一个看起来更加深奥）。第二个版本是为那些想真正阅读程序而又不费吹灰之力的人准备的。

— JungHwan Min

0

Scala，138个字节

def?(n:Int):Int={val p=Stream.from(2).filter(n%_==0)(0)
if(p==n)n else?(n/p)}
def s(i:Int):Boolean=i<2||(i+"")==(i+"").reverse&&s(i/ ?(i))

取消高尔夫：

def largestFactor(n:Int):Int={
  val p=Stream.from(2).filter(n%_==0).head
  if(p==n)n else largestFactor(n/p)}
def superPalindrome(i:Int):Boolean=i<2||(i+"")==(i+"").reverse&&superPalindrome(i/ largestFactor(i))

说明：

def?(n:Int):Int={                       //define a method for the largest prime factor
  val p=Stream.from(2).filter(n%_==0)(0)  //find the first factor of n
  if(p==n)n else?(n/p)                    //if it's n, return n else the next factor
}
def s(i:Int):Boolean=                     //method for the superprime
  i<2                                     //if s<2 return true
  ||                                      //else return:
    (i+"")==(i+"").reverse                  //is i a palindrome
    &&                                      //and
    s(i/ ?(i))                              //is i divided by it's largestPrimeFactor a superpalindrome

— corvus_192
source

0

JavaScript（ES6），78个字节

(n,d=2,p=1)=>n%d?n<2||f(n,d+1,p):[...p=p*d+''].reverse().join``==p&&f(n/d,d,p)

递归构建素因数分解前缀，并检查其回文性。

— 尼尔
source

0

Java 7，133字节

int c(int a){int x=a,y=0,z=a,i=2;for(;x>0;y=y*10+x%10,x/=10);for(;z>1;i++)for(;z%i<1;z/=i);if(a<2)return 1;return y!=a?0:c(a/(i-1));}

不打高尔夫球

    static int c( int a ){
    int x = a , y = 0 , z = a , i = 2 ;

    for ( ; x > 0 ; y = y * 10 + x % 10 , x /= 10 ) ;

    for ( ; z > 1 ; i++ )
    for ( ; z % i < 1 ; z /= i ) ; 

    if ( a < 2 )
      return 1 ;

    return y != a ? 0 : c( a / ( i - 1 ) ) ;       
 }

— 数字结
source

0

其实 29个位元组

尽管我不确定在哪里，但该代码可能有几个部分可以使用。欢迎打高尔夫球。在线尝试！

╗1`X╜$;R=;╝╜yN╜\;╗1<&`╬X╜DY╛&

开球

          Implicit input n.
╗         Save n to register 0.
1`...`╬   Run the following function on the stack while TOS is truthy.
  X         Discard the previous truthy.
  ╜         Push n from register 0.
  $         Push str(n).
  ;R=       Check if str(n) == str(n)[::-1], i.e. if n is a palindrome.
  ;╝        Save a copy of (is n a palindrome?) to register 1.
  ╜yN       Get the largest prime factor of n.
  ╜\        Divide n by its largest prime factor.
  ;╗        Save a copy of n // l_p_f to register 0.
  1<        Check if 1 < n // l_p_f. This returns 0 only if n // l_p_f is 1.
  &         Logical AND (is n a palindrome?) and (is n // l_p_f > 1?).
            This quits if we have reached a non-palindrome or we have reached 1.
X         Discard the falsey that ended the previous function.
╜         Get the last value saved to register 0 (could be 1 or a non-palindrome // l_p_f)
DY        This returns 1 if register 0 was a 1, else 0.
╛&        Logical AND with register 1 (was the last n a palindrome?) to get our result.
          Implicit return.

— 夏洛克9
source

找到超级回文！