Deskripsi tantangan

Angka Smith adalah angka gabungan yang jumlah digitnya sama dengan jumlah jumlah digit faktor prima. Diberi bilangan bulat N, tentukan apakah itu nomor Smith atau bukan.

Beberapa nomor Smith pertama adalah 4, 22, 27, 58, 85, 94, 121, 166, 202, 265, 274, 319, 346, 355, 378, 382, 391, 438(urut A006753 di Oei).

Contoh input / output

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

Catatan

• Kode Anda dapat berupa fungsi (metode) atau program kerja penuh,
• Alih-alih kata-kata seperti Truedan False, Anda dapat menggunakan nilai-nilai yang benar dan salah, asalkan jelas apa itu,
• Ini adalah tantangan kode-golf , jadi buat kode Anda sesingkat mungkin!

Jelly , 12 11 byte

Æfḟȯ.DFżDSE

Mengembalikan 1 untuk angka Smith dan 0 sebaliknya. Cobalah online! atau verifikasi semua kasus uji .

Latar Belakang

Æf (faktorisasi utama) dan D (integer-ke-desimal) diimplementasikan sehingga P(produk) dan Ḍ(desimal-ke-integer) membentuk invers kiri.

Untuk bilangan bulat -4 hingga 4 , Æfkembalikan yang berikut ini.

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

Untuk angka -10, -1, -0.5, 0, 0.5, 1, 10 , Dmengembalikan yang berikut.

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

Bagaimana itu bekerja

Æ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`))

Disimpan 4 byte berkat Dennis

Cobalah di ideone.com

Penjelasan

Membaca angka pada stdin dan menghasilkan Truejika angka tersebut adalah angka Smith atau Falsejika bukan.

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

Cobalah online!

Penjelasan

@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_&

Penjelasan

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

Cobalah online!

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)

Tidak ada pemeriksaan prima bawaan. Tidak ada anjak bawaan. Tidak ada jumlah digit bawaan. Tangan semuanya dibuat. : D

Mengambil input $nsebagai integer, set $bsama dengan array kosong. Sini,$b adalah kumpulan faktor-faktor utama kami.

Berikutnya adalah forloop. Kami pertama-tama menyetel $asama dengan nomor input kami, dan kondisinya adalah sampai$a kurang dari atau sama dengan 1. Loop ini akan menemukan faktor utama kami.

Kami 2beralih dari hingga $a, menggunakan Where-Object( |?{...}) untuk mengeluarkan bilangan prima yang juga merupakan faktor !($a%$_). Mereka dimasukkan ke dalam loop-dalam |%{...}yang menempatkan faktor ke dalam $bdan membelah $a(dengan demikian kita akhirnya akan sampai1 ).

Jadi, sekarang kita memiliki semua faktor utama kita $b. Saatnya merumuskan output Boolean kami. Kita perlu untuk memverifikasi bahwa $nini -notin $b, karena jika itu adalah bahwa cara yang $nprima, dan bukan nomor Smith. Selain itu, ( -and) kita perlu memastikan bahwa dua set jumlah digit kita adalah -equal. Boolean yang dihasilkan ditinggalkan di jalur pipa dan outputnya implisit.

NB - Membutuhkan v3 atau yang lebih baru untuk -notinoperator. Saya masih menjalankan input untuk 4937775(ini lambat untuk menghitung), jadi saya akan memperbarui ini ketika selesai. Setelah 3+ jam, saya mendapat kesalahan stackoverflow. Jadi, ada beberapa batas atas di suatu tempat. Baiklah.

Ini akan bekerja untuk input negatif, nol, atau satu, karena tangan kanan -andakan menghilangkan kesalahan saat mencoba menghitung jumlah digit (ditunjukkan di bawah), yang akan menyebabkan setengahnya pergi $falseketika dievaluasi. Karena STDERR diabaikan secara default , dan output yang benar masih ditampilkan, ini baik-baik saja.

Uji kasus

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

Keluaran array truey atau falsey di mana output yang sebenarnya mensyaratkan bahwa semua elemen tidak nol.

Cobalah online

Jelly , 27 25 23 byte

(Golf lebih lanjut mungkin pasti mungkin)

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

Pengembalian 0untuk False atau 1untuk True

Semua test case di TryItOnline

Bagaimana?

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

Sebenarnya, 18 byte

Sayangnya, Actually tidak memiliki faktorisasi bawaan yang memberikan faktor prima pada multiplisitas, jadi saya harus meretasnya bersama. Saran bermain golf diterima. Cobalah online!

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

Tidak melakukanolf

         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

Oktaf, 80 78 byte

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

Penjelasan:

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

Cobalah online .

Pyth, 21 byte

&&>Q1!P_QqsjQTssmjdTP

Suatu program yang mengambil input bilangan bulat dan mencetak Trueatau Falsesebagai yang relevan.

Cobalah online

Bagaimana itu bekerja

&&>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}

Fungsi anonim yang mengembalikan Bool.

• Sekarang melakukan faktorisasi manual 100% dan pemeriksaan keaslian.
• Menyimpan beberapa byte dengan menguji "input> 1" dan "jumlah faktor> 1" dengan satu perbandingan berantai, karena m> Ω (m) .

( coba online )

EDIT: -1 byte berkat 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;}

Saya seharusnya mendengarkan komentar @BasicallyAlanTuring ..

Ini adalah salah satu pertanyaan di mana saya berpikir "Java + this = no", saya tervotasikan untuk ide itu: P

Ah well .. Beberapa bahasa pemrograman menggunakan byte tunggal untuk faktor-prima atau pemeriksaan-prima, tetapi Java jelas bukan salah satu dari mereka.

EDIT: Mengurangi separuh jumlah byte sekarang karena saya punya waktu untuk memikirkannya.

Tidak disatukan (sort-off ..) & uji kasus:

Coba di sini.

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

Keluaran:

false
true
false
true
false
false
false
true

Brachylog (lebih baru) , 11 byte

¬ṗ&ẹ+.&ḋcẹ+

Cobalah online!

Predikat berhasil jika inputnya adalah nomor Smith dan gagal jika bukan.

               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 terima kasih kepada @Shaggy

Cobalah online!

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)

Cobalah online!

Pyke, 16 byte

Pm[`mbs(sQ[qRlt*

Coba di sini!

Perl 6 , 80 byte

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

Cobalah online!

Blok kode anonim yang mengambil bilangan bulat dan mengembalikan boolean.

APL (Dyalog Extended) , 36 29 byte ^SBCS

Jawaban ini berutang golfnya ke ⍭monad Extended untuk mengembalikan faktor-faktor utama nomor, dan itu⊤ lebih baik di konversi basis daripada di Dyalog Unicode.

Sunting: -7 bytes berkat dzaima.

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

Cobalah online!

Penjelasan

{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

Cobalah online!

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;}

Cobalah online!

-3 bytes berkat ceilingcat

Penjelasan:

/* 
 * 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 == _ */
    }                                           /* ; */
}                                               /* } */

Racket 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))

Mengembalikan 1 jika benar dan 0 jika salah:

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

Versi detail:

(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))

Karat - 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})}

meminjam solusi python oleh @levitatinglion ... setidaknya ini lebih pendek dari Java ...

degolfed di play.rust-lang.org

APL (NARS), 33 char, 66 byte

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

"π⍵" daftar faktor pengembalian ⍵, anggap inputnya adalah satu bilangan bulat positif> = 1; uji:

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

C (gcc), 177 Bytes

Menentukan fungsi Qyang mengembalikan 0 untuk angka smith dan bukan nol untuk angka non-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;}

Cobalah online!

Penjelasan:

// 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 # (Visual C # Interactive Compiler) , 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;}

Cobalah online!