Herausforderungsbeschreibung

Eine Smith-Zahl ist eine zusammengesetzte Zahl, deren Ziffernsumme gleich der Ziffernsumme ihrer Primfaktoren ist. NBestimmen Sie anhand einer Ganzzahl , ob es sich um eine Smith-Zahl handelt oder nicht.

Die ersten paar Smith Zahlen sind 4, 22, 27, 58, 85, 94, 121, 166, 202, 265, 274, 319, 346, 355, 378, 382, 391, 438(Sequenz A006753 in OEIS).

Sample 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

Anmerkungen

• Ihr Code kann eine Funktion (Methode) oder ein voll funktionsfähiges Programm sein.
• Anstelle von Wörtern wie Trueund Falsekönnen Sie auch alle anderen wahren und falschen Werte verwenden, sofern klar ist, um welche es sich handelt.
• Dies ist eine Code-Golf- Herausforderung, also mach deinen Code so kurz wie möglich!

Jelly , 12 11 Bytes

Æfḟȯ.DFżDSE

Gibt 1 für Smith-Zahlen und sonst 0 zurück . Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Hintergrund

Æf(Primfaktorisierung) und D(Ganzzahl bis Dezimalzahl) werden so implementiert, dass P(Produkt ) und (Ganzzahl bis Dezimalzahl) Ḍlinke Inverse bilden.

Für die ganzen Zahlen -4 bis 4 , Æfgibt die folgende.

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

Für die Zahlen -10, -1, -0,5, 0, 0,5, 1, 10 wird DFolgendes zurückgegeben.

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

Wie es funktioniert

Æ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 Bytes

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

4 Bytes gespart dank Dennis

Probieren Sie es auf ideone.com

Erläuterung

Liest eine Nummer auf stdin und gibt aus, Trueob die Nummer eine Smith-Nummer ist oder Falsenicht.

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 Bytes

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

Probieren Sie es online!

Erläuterung

@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 Bytes

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

Erläuterung

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

Probieren Sie es 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)

Keine eingebaute Hauptprüfung. Kein eingebautes Factoring. Keine eingebaute Ziffernsumme. Alles ist handgemacht. : D

Übernimmt die Eingabe $nals Ganzzahl und setzt sie $bgleich einem leeren Array. Hier $bist unsere Sammlung von Primfaktoren.

Weiter ist eine forSchleife. Wir setzen zuerst $agleich unserer Eingangszahl und die Bedingung ist bis $aist kleiner als oder gleich 1. Diese Schleife wird unsere Primfaktoren finden.

Wir durchlaufen eine Schleife von 2bis zu $aund verwenden Where-Object( |?{...}), um Primzahlen zu extrahieren , die auch Faktoren sind !($a%$_). Diese werden in einer inneren Schleife zugeführt |%{...}, die den Faktor in platziert $bund dividieren $a(so werden wir schließlich bekommen 1).

Jetzt haben wir alle unsere Hauptfaktoren in $b. Zeit für die Formulierung unserer Booleschen Ausgabe. Wir müssen sicherstellen , dass $nist -notin $b, denn wenn es ist , dass Mittel , die eine $nPrimzahl ist, und so ist kein Smith Zahl. Zusätzlich ( -and) müssen wir sicherstellen, dass unsere zwei Sätze von Ziffernsummen gleich sind -eq. Der resultierende Boolesche Wert verbleibt in der Pipeline und die Ausgabe ist implizit.

NB - Erfordert v3 oder neuer für den -notinBetreiber. Ich führe immer noch die Eingabe für aus 4937775(dies ist langsam zu berechnen), daher aktualisiere ich diese, sobald dies abgeschlossen ist . Nach mehr als 3 Stunden habe ich einen Stackoverflow-Fehler erhalten. Also gibt es irgendwo eine Obergrenze. Naja.

Dies funktioniert bei negativen Eingaben (0 oder 1), da die rechte Seite der -andeinen Fehler ausblendet, während versucht wird, die Ziffernsummen (siehe unten) zu berechnen. Dadurch wird diese Hälfte $falsebei der Auswertung auf " 0" gesetzt. Da STDERR standardmäßig ignoriert wird und weiterhin die richtige Ausgabe angezeigt wird, ist dies in Ordnung.

Testfälle

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 Bytes

YftV!UsGV!Us=wnqh

Ausgänge truthy oder Falsey Arrays , wo ein truthy Ausgang erfordert , dass alle Elemente nicht gleich Null sein.

Probieren Sie es online aus

Jelly , 27 25 23 Bytes

(Weiteres Golfen wahrscheinlich definitiv möglich)

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

Gibt 0False oder 1True zurück

Alle Testfälle bei TryItOnline

Wie?

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

Eigentlich 18 Bytes

Leider ist in Actually keine Faktorisierung integriert, die der Multiplizität die Primfaktoren einer Zahl gibt. Ich musste also eine zusammen hacken. Golfvorschläge sind willkommen. Probieren Sie es online!

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

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

Oktave, 80 78 Bytes

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

Erläuterung:

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

Probieren Sie es online aus .

Pyth, 21 Bytes

&&>Q1!P_QqsjQTssmjdTP

Ein Programm, das die Eingabe einer Ganzzahl annimmt und Trueoder Falsenach Bedarf ausgibt.

Probieren Sie es online aus

Wie es funktioniert

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

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

Eine anonyme Funktion, die einen Bool zurückgibt.

• Jetzt erfolgt eine 100% manuelle Faktorisierung und Primalitätsprüfung.
• Einige Bytes wurden gespart, indem sowohl "Eingang> 1" als auch "Anzahl der Faktoren> 1" mit einem verketteten Vergleich getestet wurden, da m> Ω (m) .

( online ausprobieren )

BEARBEITEN: -1 Byte dank b2gills

Java 7, 509 506 435 426 419 230 Bytes

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

Ich hätte @BasicallyAlanTuring 's Kommentar anhören sollen .

Dies ist eine der Fragen, bei denen ich dachte "Java + this = no", ich habe jedoch für die Idee gestimmt: P

Na ja ... Einige Programmiersprachen verwenden ein einzelnes Byte für die Primfaktoren oder den Primcheck, aber Java ist sicherlich keine davon.

EDIT: Die Anzahl der Bytes wurde halbiert, da ich etwas Zeit hatte, darüber nachzudenken.

Ungolfed (sort-off ..) & Testfälle:

Probieren Sie es hier aus.

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

Ausgabe:

false
true
false
true
false
false
false
true

Brachylog (neuer) , 11 Bytes

¬ṗ&ẹ+.&ḋcẹ+

Probieren Sie es online!

Prädikat ist erfolgreich, wenn die Eingabe eine Smith-Zahl ist, und schlägt fehl, wenn dies nicht der Fall ist.

               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 Bytes

ìx ¥Uk x_ìx

-3 Bytes dank @Shaggy

Probieren Sie es online!

JavaScript (ES6),  87 86  84 Bytes

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)

Probieren Sie es online!

Pyke, 16 Bytes

Pm[`mbs(sQ[qRlt*

Probieren Sie es hier aus!

Perl 6 , 80 Bytes

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

Probieren Sie es online!

Anonymer Codeblock, der eine Ganzzahl akzeptiert und einen Booleschen Wert zurückgibt.

APL (Dyalog Extended) , 36 29 Byte ^SBCS

Diese Antwort ist der ⍭Monade von Extended zu verdanken, die die Primfaktoren einer Zahl ⊤zurückgibt , und das ist bei der Basisumwandlung besser als in Dyalog Unicode.

Edit: -7 Bytes dank dzaima.

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

Probieren Sie es online!

Erläuterung

{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 , ^31-30 Bytes

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

Probieren Sie es online!

C (GCC) , 139 136 Bytes

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

Probieren Sie es online!

-3 Bytes dank ceilingcat

Erläuterung:

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

Schläger 176 Bytes

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

Liefert 1 wenn wahr und 0 wenn falsch:

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

Ausführliche Version:

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

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

geliehene Python-Lösung von @levitatinglion ... zumindest ist dies kürzer als Java ...

degolfed bei play.rust-lang.org

APL (NARS), 33 Zeichen, 66 Bytes

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

"π⍵" gibt die Listenfaktoren von ⍵ zurück, vorausgesetzt, die Eingabe ist eine positive ganze Zahl> = 1; Prüfung:

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

C (gcc) 177 Bytes

Definiert eine Funktion Q, die 0 für Smith-Nummern und ungleich Null für Nicht-Smith-Nummern zurückgibt

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

Probieren Sie es online!

Erläuterung:

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

Probieren Sie es online!