숫자는 99999999입니다.이 숫자는 분명히 회문입니다. 99999999의 가장 큰 소수는 137입니다. 99999999를 137로 나누면 729927이됩니다.이 숫자는 회문이기도합니다.

729927의 가장 큰 주요 요인은 101입니다. 729927 / 101 = 7227은 다시 회문입니다.

7227의 가장 큰 주요 요인은 73입니다. 7227 / 73 = 99는 다시 회문입니다.

가장 큰 소수로 더 세분화하면 9, 3 및 1을 얻게되며, 1 자리 숫자는 회문입니다. 1에는 주요 요인이 없으므로 절차가 여기서 끝납니다.

이제 저는이 관찰을 일반화하여 수퍼 팔린 드를 1 개 또는 가장 큰 주요 요인으로 나눈 다른 수퍼 팔린 드를 제공하는 회문으로 정의합니다.

^{크레딧 : /math/200835/are-there-infinitely-many-super-palindromes}

숫자 N이 주어지면 그것이 초 회문인지 아닌지를 결정하고 그에 따라 진실 또는 거짓 값을 인쇄하십시오.

프로그램은 다음 입력에 대해 정확한 값을 인쇄해야합니다.

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

프로그램은 다음 입력에 대해 잘못된 값을 인쇄해야합니다.

323
432
555
583
585
646
642
696
777
969
989
2112
3553
4554
5242
5225
5445
8080
8118
9988

이것은 code-golf 이므로 바이트 수가 가장 짧은 코드가 우선합니다.

젤리 , 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.

Mathematica, 64 바이트

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

이름이없는 함수, 반환 True또는 False. 입력에서 시작한 다음 출력이 변경되지 않을 때까지 "나의 가장 큰 소수로 나눈 값"기능을 반복하여 목록을 구성합니다. (다행스럽게도 Mathematica는 이제 1의 가장 큰 주요 요소는 1이라고 생각합니다.) 그런 다음 목록 항목이 회문 (yay built-in! boo function name length!)인지 테스트 And하고 모두 함께 s합니다.

수학, 51 바이트

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

재귀 익명 기능. 숫자를 입력 및 리턴 True또는 False출력으로 사용합니다.

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

Pyth- 15 12 바이트

비트 젤리 : P : /

불행히도, 모든 암시 적 맵은 명시적인 맵으로 결합 될 때 더 짧아지지 않습니다. 마지막 맵은 자동 표시이기 때문입니다.

.A_IM`M*M._P

테스트 스위트 .

소인수 분해의 모든 접두사를 가져 오며, 그 결과 곱은 중간 수퍼 팔린 드롬이되며 모든 것이 회문인지 확인합니다.

매스 매 티카, 71 63 바이트

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

설명

FactorInteger@#

입력을 고려하십시오. (예 8668 -> {{2, 2}, {11, 1}, {197, 1}}; 출력의 각 목록에 대해, 제 1 요소는 주요 인자이고, 제 2 요소는 전력이다.

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)

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

라켓 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

J, 30 바이트

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

거짓에 대한 오류, 진실에 대한 1

초기 시도, 잘못된 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

아희 (Aheui) , 309 바이트 (100 자 * 3 바이트 + 9 줄 바꿈)

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

나는 실제로 그것을 끝내서 너무 행복하다!

이 언어를 처음 사용하므로 바이트 수를 개선하는 데 도움이되는 팁을 환영합니다.

여기 사용해보십시오! (코드를 복사하여 붙여 넣기)

클리너 버전

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

스칼라, 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

자바 스크립트 (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)

소인수 분해 접두사를 재귀 적으로 작성하고 회 문성이 있는지 확인합니다.

자바 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 ) ) ;       
 }

실제로 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.