Mô tả thử thách

Một số Smith là một hỗn số có tổng các chữ số bằng tổng của các khoản tiền của các chữ số của thừa số nguyên tố của nó. Cho một số nguyên N, xác định xem đó có phải là số Smith hay không.

Một vài con số đầu tiên là Smith 4, 22, 27, 58, 85, 94, 121, 166, 202, 265, 274, 319, 346, 355, 378, 382, 391, 438(dãy A006753 trong OEIS).

Đầu vào / đầu ra mẫu

18: False (sum of digits: 1 + 8 = 9; factors: 2, 3, 3; sum of digits of factors: 2 + 3 + 3 = 8)
22: True
13: False (meets the digit requirement, but is prime)
666: True (sum of digits: 6 + 6 + 6 = 18; factors: 2, 3, 3, 37; sum of digits of factors: 2 + 3 + 3 + 3 + 7 = 18)
-265: False (negative numbers can't be composite)
0: False (not composite)
1: False (not composite)
4937775: True

Ghi chú

• Mã của bạn có thể là một hàm (phương thức) hoặc một chương trình làm việc đầy đủ,
• Thay vì các từ như Truevà False, bạn có thể sử dụng bất kỳ giá trị trung thực và giả mạo nào, miễn là nó rõ ràng chúng là gì,
• Đây là một thử thách chơi gôn , vì vậy hãy viết mã của bạn càng ngắn càng tốt!

Thạch , 12 11 byte

Æfḟȯ.DFżDSE

Trả về 1 cho số Smith và 0 nếu không. Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Lý lịch

Æf(thừa số nguyên tố) và D(số nguyên sang số thập phân) được triển khai sao cho P(sản phẩm) và Ḍ(số thập phân thành số nguyên) tạo thành nghịch đảo trái.

Đối với các số nguyên -4 đến 4 , Æftrả về giá trị sau.

-4 -> [-1, 2, 2]
-3 -> [-1, 3]
-2 -> [-1, 2]
-1 -> [-1]
 0 -> [0]
 1 -> []
 2 -> [2]
 3 -> [3]
 4 -> [2, 2]

Đối với các số -10, -1, -0,5, 0, 0,5, 1, 10 , Dtrả về các giá trị sau.

-11   -> [-1, -1]
-10   -> [-1, 0]
 -1   -> [-1]
 -0.5 -> [-0.5]
  0   -> [0]
  0.5 -> [0.5]
  1   -> [1]
 10   -> [1, 0]
 11   -> [1, 1]

Làm thế nào nó hoạt động

Æfḟȯ.DFżDSE  Main link. Argument: n (integer)

Æf           Yield the prime factorization of n.
  ḟ          Filter; remove n from its prime factorization.
             This yields an empty array if n is -1, 0, 1, or prime.
   ȯ.        If the previous result is an empty array, replace it with 0.5.
     D       Convert all prime factors to decimal.
      F      Flatten the result.
        D    Yield n in decimal.
       ż     Zip the results to both sides, creating a two-column array.
         S   Compute the sum of each column.
             If n is -1, 0, 1, or prime, the sum of the prime factorization's
             digits will be 0.5, and thus unequal to the sum of the decimal array.
             If n < -1, the sum of the prime factorization's digits will be
             positive, while the sum of the decimal array will be negative.
          E  Test both sums for equality.

Python 2, 122 115 110 106 byte

n=m=input()
s=0
for d in range(2,n):
 while n%d<1:n/=d;s+=sum(map(int,`d`))
print n<m>s==sum(map(int,`m`))

Đã lưu 4 byte nhờ Dennis

Dùng thử trên ideone.com

Giải trình

Đọc một số trên stdin và xuất ra Truenếu số đó là số Smith hoặc Falsenếu không.

n=m=input()                  # stores the number to be checked in n and in m
s=0                          # initializes s, the sum of the sums of digits of prime factors, to 0
for d in range(2,n):         # checks all numbers from 2 to n for prime factors
 while n%d<1:                # while n is divisible by d
                             #   (to include the same prime factor more than once)
  n/=d                       # divide n by d
  s+=sum(map(int,`d`))       # add the sum of the digits of d to s
print                        # print the result: "True" if and only if
      n<m                    #   n was divided at least once, i.e. n is not prime
      >                      #   and m>s (always true) and
      s==sum(map(int,`m`))   #   s is equal to the sum of digits of m (the input)

Brachylog , 19 byte

@e+S,?$pPl>1,P@ec+S

Hãy thử trực tuyến!

Giải trình

@e+S,                 S is the sum of the digits of the input.
     ?$pP             P is the list of prime factors of the input.
        Pl>1,         There are more than 1 prime factors.
             P@e      Split each prime factor into a list of digits.
                c     Flatten the list.
                 +S   The sum of this list of digits must be S.

05AB1E , 11 17 byte

X›0si¹ÒSO¹SOQ¹p_&

Giải trình

X›0si              # if input is less than 2 then false, else
       SO          # sum of digits
     ¹Ò            # of prime factors with duplicates
            Q      # equal to
          SO       # sum of digits
         ¹         # of input
                &  # and
             ¹p_   # input is not prime

Hãy thử trực tuyến!

PowerShell v3 +, 183 byte

param($n)$b=@();for($a=$n;$a-gt1){2..$a|?{'1'*$_-match'^(?!(..+)\1+$)..'-and!($a%$_)}|%{$b+=$_;$a/=$_}}$n-notin$b-and(([char[]]"$n")-join'+'|iex)-eq(($b|%{[char[]]"$_"})-join'+'|iex)

Không có kiểm tra nguyên tố tích hợp. Không có bao thanh toán tích hợp. Không có chữ số tổng hợp. Mọi thứ đều được làm bằng tay. : D

Lấy đầu vào $nlà một số nguyên, đặt $bbằng một mảng trống. Đây $blà bộ sưu tập các yếu tố chính của chúng tôi.

Tiếp theo là một forvòng lặp. Trước tiên, chúng tôi đặt $abằng số đầu vào của chúng tôi và điều kiện là cho đến khi $anhỏ hơn hoặc bằng với 1. Vòng lặp này sẽ tìm các yếu tố chính của chúng tôi.

Chúng tôi lặp từ 2lên đến $a, sử dụng Where-Object( |?{...}) để rút ra các số nguyên tố cũng là các yếu tố !($a%$_). Những cái đó được đưa vào một vòng lặp bên trong |%{...}đặt yếu tố vào $bvà phân chia $a(do đó cuối cùng chúng ta sẽ nhận được 1).

Vì vậy, bây giờ chúng tôi có tất cả các yếu tố chính của chúng tôi trong $b. Thời gian để xây dựng đầu ra Boolean của chúng tôi. Chúng ta cần phải xác minh rằng $nlà -notin $b, bởi vì nếu nó là phương tiện mà $nlà số nguyên tố, và do đó không phải là số Smith. Ngoài ra, ( -and) chúng tôi cần đảm bảo rằng hai tập hợp chữ số của chúng tôi là -equal. Boolean kết quả được để lại trên đường ống và đầu ra là ẩn.

NB - Yêu cầu v3 hoặc mới hơn cho -notintoán tử. Tôi vẫn đang chạy đầu vào cho 4937775(điều này chậm để tính toán), vì vậy tôi sẽ cập nhật thông tin này khi kết thúc. Sau hơn 3 giờ, tôi đã gặp lỗi stackoverflow. Vì vậy, có một số giới hạn ở đâu đó. Ồ tốt

Điều này sẽ hoạt động cho đầu vào âm, bằng 0 hoặc một, bởi vì bên phải của ý -andchí sẽ phát hiện ra lỗi trong khi nó cố gắng tính tổng các chữ số (hiển thị bên dưới), điều này sẽ khiến một nửa đi đến $falsekhi được đánh giá. Vì STDERR được bỏ qua theo mặc định và đầu ra chính xác vẫn được hiển thị, điều này là tốt.

Các trường hợp thử nghiệm

PS C:\Tools\Scripts\golfing> 4,22,27,58,85,94,18,13,666,-265,0,1|%{"$_ -> "+(.\is-this-a-smith-number.ps1 $_)}
4 -> True
22 -> True
27 -> True
58 -> True
85 -> True
94 -> True
18 -> False
13 -> False
666 -> True
Invoke-Expression : Cannot bind argument to parameter 'Command' because it is an empty string.
At C:\Tools\Scripts\golfing\is-this-a-smith-number.ps1:1 char:179
+ ... "$_"})-join'+'|iex)
+                    ~~~
    + CategoryInfo          : InvalidData: (:String) [Invoke-Expression], ParameterBindingValidationException
    + FullyQualifiedErrorId : ParameterArgumentValidationErrorEmptyStringNotAllowed,Microsoft.PowerShell.Commands.InvokeExpressionCommand

-265 -> False
Invoke-Expression : Cannot bind argument to parameter 'Command' because it is an empty string.
At C:\Tools\Scripts\golfing\is-this-a-smith-number.ps1:1 char:179
+ ... "$_"})-join'+'|iex)
+                    ~~~
    + CategoryInfo          : InvalidData: (:String) [Invoke-Expression], ParameterBindingValidationException
    + FullyQualifiedErrorId : ParameterArgumentValidationErrorEmptyStringNotAllowed,Microsoft.PowerShell.Commands.InvokeExpressionCommand

0 -> False
Invoke-Expression : Cannot bind argument to parameter 'Command' because it is an empty string.
At C:\Tools\Scripts\golfing\is-this-a-smith-number.ps1:1 char:179
+ ... "$_"})-join'+'|iex)
+                    ~~~
    + CategoryInfo          : InvalidData: (:String) [Invoke-Expression], ParameterBindingValidationException
    + FullyQualifiedErrorId : ParameterArgumentValidationErrorEmptyStringNotAllowed,Microsoft.PowerShell.Commands.InvokeExpressionCommand

1 -> False

MATL, 17 byte

YftV!UsGV!Us=wnqh

Đầu ra các mảng trung thực hoặc falsey trong đó một đầu ra trung thực đòi hỏi tất cả các phần tử phải khác không.

Dùng thử trực tuyến

Thạch , 27 25 23 byte

(tiếp tục chơi golf có thể chắc chắn có thể)

ḢDS×
ÆFÇ€SḢ
DS=Ça<2oÆP¬

Trả về 0sai hoặc 1đúng

Tất cả các trường hợp thử nghiệm tại TryItOnline

Làm sao?

DS=Ça<2oÆP¬ - main link takes an argument, n
DS          - transform n to a decimal list and sum up
   Ç        - call the previous link (ÆFÇ€SḢ)
  =         - test for equality
     <2     - less than 2?
    a       - logical and
        ÆP  - is prime?
       o    - logical or
          ¬ - not
            - all in all tests if the result of the previous link is equal to the digit
              sum if the number is composite otherwise returns 0.

ÆFÇ€SḢ - link takes an argument, n again
ÆF     - list of list of n's prime factors and their multiplicities
  Ç€   - apply the previous link (ḢDS×) for each
    S  - sum up
     Ḣ - pop head of list (there will only be one item)

ḢDS× - link takes an argument, a factor, multiplicity pair
Ḣ    - pop head, the prime factor - modifies list leaving the multiplicity
 DS  - transform n to a decimal list and sum up
   × - multiply the sum with the multiplicity

Trên thực tế, 18 byte

Thật không may, Trên thực tế không có một phần tử tích hợp nào mang lại nhiều yếu tố chính cho số nhân, vì vậy tôi đã phải hack cùng nhau. Gợi ý chơi golf chào mừng. Hãy thử trực tuyến!

;w`i$n`MΣ♂≈Σ@$♂≈Σ=

Ungolfing

         Implicit input n.
;w       Duplicate n and get the prime factorization of a copy of n.
`...`M   Map the following function over the [prime, exponent] lists of w.
  i        Flatten the list. Stack: prime, exponent.
  $n       Push str(prime) to the stack, exponent times.
            The purpose of this function is to get w's prime factors to multiplicity.
Σ        sum() the result of the map.
          On a list of strings, this has the same effect as "".join()
♂≈Σ      Convert every digit to an int and sum().
@        Swap the top two elements, bringing other copy of n to TOS.
$♂≈Σ     Push str(n), convert every digit to an int, and sum().
=        Check if the sum() of n's digits is equal 
          to the sum of the sum of the digits of n's prime factors to multiplicity.
         Implicit return.

Haskell, 120 105 byte

1%_=[];a%x|mod a x<1=x:div a x%x|0<1=a%(x+1)
p z=sum[read[c]|c<-show z]
s x|z<-x%2=z<[x]&&sum(p<$>z)==p x

Octave, 80 78 byte

t=num2str(factor(x=input('')))-48;disp(any(t<0)&~sum([num2str(x)-48 -t(t>0)]))

Giải trình:

factor(x=input(''))                 % Take input, store as x and factor it
num2str(factor(x=input('')))-48     % Convert it to an array (123 -> [1 2 3]) 
                                    % and store as t
any(t<0)                            % Check if there are several prime factors
                                    % [2 3] -> [2 -16 3]
sum([num2str(x)-48 -t(t>0)])        % Check if sum of prime factor
                                    % is equal the sum of digits

Thử nó trực tuyến .

Bình thường, 21 byte

&&>Q1!P_QqsjQTssmjdTP

Một chương trình lấy đầu vào của một số nguyên và in True hoặc Falsecó liên quan.

Dùng thử trực tuyến

Làm thế nào nó hoạt động

&&>Q1!P_QqsjQTssmjdTP  Program. Input: Q
           jQT         Yield digits of the base-10 representation of Q as a list
          s            Add the digits
                    P  Yield prime factors of Q (implicit input fill)
                mjdT   Map base-10 representation across the above, yielding digits of each
                       factor as a list of lists
               s       Flatten the above
              s        Add up the digits
         q             Those two sums are equal
&                      and
  >Q1                  Q>1
 &                     and
     !P_Q              Q is not prime
                       Implicitly print

Perl 6 , 92 88 87 byte

{sub f(\i){my \n=first i%%*,2..i-1;n??n~f i/n!!i}
!.is-prime&&$_>1&&.comb.sum==.&f.comb.sum}

{sub f(\i){my \n=first i%%*,2..^i;n??[n,|f i/n]!!|i}
$_>.&f>1&&.comb.sum==.&f.comb.sum}

Một hàm ẩn danh trả về Bool.

• Bây giờ thực hiện 100% thủ công và kiểm tra tính nguyên thủy.
• Đã lưu một số byte bằng cách kiểm tra cả "đầu vào> 1" và "số yếu tố> 1" với một so sánh chuỗi, vì m> (m) .

( thử trực tuyến )

EDIT: -1 byte nhờ b2gills

Java 7, 509 506 435 426 419 230 byte

boolean c(int n){return n<2|p(n)?0>1:d(n)==f(n);}int d(int n){return n>9?n%10+d(n/10):n;}int f(int n){int r=0,i;for(i=1;++i<=n;)for(;n%i<1;n/=i,r+=i>9?d(i):i);return r;}boolean p(int n){int i=2;while(i<n)n=n%i++<1?0:n;return n>1;}

Tôi nên đã lắng nghe bình luận của @Bas VềAlanTuring ..

Đây là một trong những câu hỏi mà tôi nghĩ "Java + this = no", tôi đã nêu lên ý tưởng: P

À .. Một số ngôn ngữ lập trình sử dụng một byte cho các thừa số nguyên tố hoặc kiểm tra chính, nhưng Java chắc chắn không phải là một trong số chúng.

EDIT: Giảm một nửa số byte mà tôi đã có thời gian để suy nghĩ về nó.

Ungolfed (sắp xếp ..) và các trường hợp thử nghiệm:

Hãy thử nó ở đây.

class M{
  static boolean c(int n){
    return n < 2 | p(n)
            ? 0 > 1 //false
            : d(n) == f(n);
  }

  // Sums digits of int
  static int d(int n) {
    return n > 9
            ? n%10 + d(n/10)
            : n;
  }

  // Convert int to sum of prime-factors
  static int f(int n) {
    int r = 0,
        i;
    for(i = 1; ++i <= n; ){
      for( ; n % i < 1; n /= i,
                        r += i > 9 ? d(i) : i);
    }
    return r;
  }

  // Checks if the int is a prime
  static boolean p(int n){
    int i = 2;
    while(i < n){
      n = n % i++ < 1
           ? 0
           : n;
    }
    return n > 1;
  }

  public static void main(String[] a){
    System.out.println(c(18));
    System.out.println(c(22));
    System.out.println(c(13));
    System.out.println(c(666));
    System.out.println(c(-256));
    System.out.println(c(0));
    System.out.println(c(1));
    System.out.println(c(4937775));
  }
}

Đầu ra:

false
true
false
true
false
false
false
true

Brachylog (mới hơn) , 11 byte

¬ṗ&ẹ+.&ḋcẹ+

Hãy thử trực tuyến!

Vị ngữ thành công nếu đầu vào là số Smith và thất bại nếu không.

               The input
¬ṗ             is not prime,
  &            and the input's 
   ẹ           digits
    +          sum to
     .         the output variable,
      &        and the input's 
       ḋ       prime factors' (getting prime factors of a number < 1 fails)
        c      concatenated
         ẹ     digits
          +    sum to
               the output variable.

Japt , 14 11 byte

ìx ¥Uk x_ìx

-3 byte nhờ @Shaggy

Hãy thử trực tuyến!

JavaScript (ES6),  87 86  84 byte

m=>(i=2,S=0,g=n=>([...i+''].map(v=>s-=v,s=S),i-m?n%i?g(n,i++):g(n/i,S=s):s==2*S))(m)

Hãy thử trực tuyến!

Pyke, 16 byte

Pm[`mbs(sQ[qRlt*

Hãy thử nó ở đây!

Perl 6 , 80 byte

{.[0]==.flat.skip.sum}o($!={.comb.sum,($/=first $_%%*,2..^$_)&&map $!,$/,$_/$/})

Hãy thử trực tuyến!

Khối mã ẩn danh nhận một số nguyên và trả về một boolean.

APL (Dyalog Extended) , 36 29 byte ^SBCS

Câu trả lời này có được sự đáng gờm của mình đối với ⍭đơn vị của Extended vì đã trả lại các yếu tố chính của một số, và điều đó⊤ tốt hơn khi chuyển đổi cơ sở so với trong Unicode Dyalog.

Chỉnh sửa: -7 byte nhờ dzaima.

{2>⍵:0⋄(⊃=+/-⊃×2<≢)+⌿10⊤⍵,⍭⍵}

Hãy thử trực tuyến!

Giải trình

{1⋄(3)2}  A dfn, a function in brackets. ⋄ is a statement separator.
          The numbers signify the sections in the order they are explained.

2>⍵:0  If we have a number less than 2,
       we immediately return 0 to avoid a DOMAIN ERROR.

+⌿10⊤⍵,⍭⍵
        ⍭⍵  We take the factors of ⍵, our input as our right argument,
      ⍵,    and append it to our input again.
   10⊤      before converting the input and its factors into a matrix of their base-10 digits
            (each row is the places, units, tens, hundreds, etc.)
+⌿         And taking their sum across the columns of the resulting matrix,
            to give us the sum of their digits, their digit-sums.

(⊃=+/-⊃×2<≢)  We run this section over the list of sums of digits above.
 ⊃=+/-⊃       We check if the main digit-sum (of our input)
               Is equal to the sum of our digit-sums
               (minus our main digit-sum that is also still in the list)
        ×2<≢   The trick here is that we can sneak in our composite check
               (if our input is prime there will be only two numbers, 
               the digit-sum of the prime,
               and the digit-sum of its sole prime factor, itself)
               So if we have a prime, we zero our (minus our main sum)
               in the calculation above, so that primes will not succeed in the check.
               We return the result of the check.

J , ³¹ 30 byte

0&p:*](=+/)&(1#."."0@":)q: ::1

Hãy thử trực tuyến!

C (gcc) , 139 136 byte

S(m,i,t,h,_){t=m=m<2?2:m;for(_=h=i=1;m>1;h=1){while(m%++h);for(m/=h;i+=h%10,h/=10;);}while(t%++h);for(m=t;_+=m%10,m/=10;);m=t-h?i==_:0;}

Hãy thử trực tuyến!

-3 byte nhờ trần

Giải trình:

/* 
 * Variable mappings:
 *  is_smith      => S
 *  argument      => m
 *  factor_digits => i
 *  arg_copy      => t
 *  least_factor  => h
 *  digit_sum     => _    
 */
int is_smith(int argument){                     /* S(m,i,t,h,_){ */
    int factor_digits;
    int arg_copy;
    int least_factor;
    int digit_sum;

    /* 
     * The cases of 0 and 1 are degenerate. 
     * Mapping them to a non-degenerate case with the right result.
     */
    if (argument < 2) {                         /* t=m=m<2?2:m; */
        argument = 2;
    }
    arg_copy = argument;

    /* 
     * Initializing these to 1 instead of zero is done for golf reasons.
     * In the end we just compare them, so it doesn't really matter.
     */
    factor_digits = 1;                          /* for(_=h=i=1; */
    digit_sum = 1;

    /* Loop over each prime factor of argument */
    while (argument > 1) {                      /* m>1; */

        /*
         * Find the smallest factor 
         * Note that it is initialized to 1 in the golfed version since prefix
         * increment is used in the modulus operation.
         */
        least_factor = 2;                       /* h=1){ */
        while (argument % least_factor != 0)    /* while(m% */
            least_factor++;                     /* ++h); */
        argument /= least_factor;               /* for(m/=h; */

        /* Add its digit sum to factor_digits */
        while (least_factor > 0) {
            factor_digits += least_factor % 10; /* i+=h%10, */
            least_factor /= 10;                 /* h/=10;) */
        }                                       /* ; */

    }                                           /* } */

    /* In the golfed version we get this for free in the for loop. */
    least_factor = 2;
    while (arg_copy % least_factor != 0)        /* while(t% */
        least_factor++;                         /* ++h); */

    /* Restore the argument */
    argument = arg_copy;                        /* for(m=t; */

    /* Compute the arguments digit sum */
    while (argument > 0) {
        digit_sum += argument % 10;             /* _+=m%10, */
        argument /= 10;                         /* m/=10;) */
    }                                           /* ; */

    /* This return is done by assigning to first argument when golfed. */
                                                /* m= */
    if (arg_copy == least_factor) {             /* t==h? */
        return 0; /* prime input */             /* 0 */
    } else {                                    /* : */
        return digit_sum == factor_digits;      /* i == _ */
    }                                           /* ; */
}                                               /* } */

Vợt 176 byte

(define(sd x)(if(= x 0)0(+(modulo x 10)(sd(/(- x(modulo x 10))10)))))
(require math)(define(f N)
(if(=(for/sum((i(factorize N)))(*(sd(list-ref i 0))(list-ref i 1)))(sd N))1 0))

Trả về 1 nếu đúng và 0 nếu sai:

(f 27)
1
(f 28)
0
(f 85)
1
(f 86)
0

Phiên bản chi tiết:

(define (sd x)   ; fn to find sum of digits
  (if (= x 0)
      0
      (+ (modulo x 10)
         (sd (/ (- x (modulo x 10)) 10)))))

(require math)
(define (f N)
  (if (= (for/sum ((i (factorize N)))
           (* (sd (list-ref i 0))
              (list-ref i 1)))
         (sd N)) 1 0))

Rust - 143 byte

fn t(mut n:u32)->bool{let s=|k:u32| (2..=k).fold((0,k),|(a,m),_|(a+m%10,m/10));s(n).0==(2..n).fold(0,|mut a,d|{while n%d<1{n/=d;a+=s(d).0};a})}

mượn giải pháp trăn bằng cách @levitatinglion ... ít nhất thì điều này ngắn hơn Java ...

suy đồi tại play.rust-lang.org

APL (NARS), 33 char, 66 byte

{1≥≢k←π⍵:0⋄s←{+/⍎¨⍕⍵}⋄(s⍵)=+/s¨k}

"π⍵" các hệ số danh sách trả về của ⍵, giả sử đầu vào là một số nguyên dương> = 1; kiểm tra:

  h←{1≥≢k←π⍵:0⋄s←{+/⍎¨⍕⍵}⋄(s⍵)=+/s¨k}
  (h¨1..100)/1..100
4 22 27 58 85 94 

C (gcc), 177 byte

Xác định hàm Qtrả về 0 cho số smith và nonzero cho số không smith

#define r return
O(D,i){for(i=0;D>0;i+=D%10,D-=D%10,D/=10);r i;}D(O,o){for(o=1;o<O;)if(O%++o<1)r o;r O;}Q(p,q,i,j){if(p^(q=D(i=p))){for(j=0;p>1;q=D(p/=q))j+=O(q);r j^O(i);}r 1;}

Hãy thử trực tuyến!

Giải trình:

// Return the sum of digits of D if D > 0, otherwise 0
O(D,i){
    // While D is greater than 0:
    // Add the last digit of D to i, and remove the last digit from D
    for(i=0;D>0;i+=D%10,D-=D%10,D/=10);
    return i;
}
// Return the smallest prime factor of O if O>1 else O
D(O,o){
    // Iterate over numbers less than O
    for(o=1;o<O;)
        // If O is divisible by o return o
        if(O%++o<1)
            return o;
    // Otherwise return O
    return O;
}
Q(p,q,i,j){
    // Set q to D(p) and i to p
    // If p != D(p) (i.e, p is composite and > 0)
    if(p^(q=D(i=p))){
        // Iterate over the prime factors of p and store their digit sum in j
        for(j=0;p>1;q=D(p/=q))
            j+=O(q);
        // i is the original value of p. If O(i)^j == 0, O(i) == j
        return j^O(i);
    }
    // If p was composite or < 0, return 1
    return 1;
}

C # (Trình biên dịch tương tác Visual C #) , 122 byte

n=>{int m=n,b=0,a=$"{n}".Sum(x=>x-'0');for(int i=2;i<m;i++)if(n%i==0){b+=$"{i}".Sum(x=>x-'0');n/=i;i=1;}return n>0&&a==b;}

Hãy thử trực tuyến!