Numbers divisible by their individual digits, but not by the product of their digits.

Numbers divisible by their individual digits, but not by the product of their digits. is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Task

Find and show positive decimal integers divisible by their individual digits,   but not by the product of their digits,   where   n   <   1000

Factor

Works with: Factor version 0.99 2021-02-05

<lang factor>USING: combinators.short-circuit grouping kernel math math.functions math.ranges math.text.utils prettyprint sequences ;

needle? ( n -- ? )

   dup 1 digit-groups dup product
   {
       [ 2nip zero? not ]
       [ nip divisor? not ]
       [ drop [ divisor? ] with all? ]
   } 3&& ;

1000 [1..b] [ needle? ] filter 9 group simple-table.</lang>

Output:

22  33  44  48  55  66  77  88  99
122 124 126 155 162 168 184 222 244
248 264 288 324 333 336 366 396 412
424 444 448 488 515 555 636 648 666
728 777 784 824 848 864 888 936 999

Julia

<lang julia>isonlydigdivisible(n) = (d = digits(n); !(0 in d) && all(x -> n % x == 0, d) && n % prod(d) != 0)

foreach(p -> print(rpad(p[2], 5), p[1] % 15 == 0 ? "\n" : ""), enumerate(filter(isonlydigdivisible, 1:1000)))

</lang>

Output:

22   33   44   48   55   66   77   88   99   122  124  126  155  162  168  
184  222  244  248  264  288  324  333  336  366  396  412  424  444  448
488  515  555  636  648  666  728  777  784  824  848  864  888  936  999

REXX

<lang rexx>/*REXX pgm finds numbers divisible by its individual digits, but not by product of digs.*/ parse arg hi cols . /*obtain optional argument from the CL.*/ if hi== | hi=="," then hi= 1000 /*Not specified? Then use the default.*/ if cols== | cols=="," then cols= 10 /* " " " " " " */ w= 10 /*width of a number in any column. */

                   @ndnp= ' base ten integers  < '   commas(hi)   " that are divisible" ,
                          'by its digits, but not by the product of its digits'

if cols>0 then say ' index │'center(@ndnp, 1 + cols*(w+1) ) if cols>0 then say '───────┼'center("" , 1 + cols*(w+1), '─') finds= 0; idx= 1 /*initialize # of found numbers & index*/ $= /*a list of integers found (so far). */

    do j=1  for hi-1;    L= length(j);    != 1  /*search for integers within the range.*/
    if pos(0, j)>0  then iterate                /*Does J have a zero?  Yes, then skip. */
           do k=1  for L;    x= substr(j, k, 1) /*extract a single decimal digit from J*/
           if j//x\==0   then iterate j         /*J ÷ by this digit?  No, then skip it.*/
           != ! * x                             /*compute the running product of digits*/
           end   /*k*/
    if j//!==0           then iterate           /*J ÷ by its digit product?  Yes, skip.*/
    finds= finds + 1                            /*bump the number of  found  integers. */
    if cols==0           then iterate           /*Build the list  (to be shown later)? */
    $= $ right( commas(j), w)                   /*add the number found to the  $  list.*/
    if finds//cols\==0   then iterate           /*have we populated a line of output?  */
    say center(idx, 7)'│'  substr($, 2);   $=   /*display what we have so far  (cols). */
    idx= idx + cols                             /*bump the  index  count for the output*/
    end   /*j*/

if $\== then say center(idx, 7)"│" substr($, 2) /*possible display residual output.*/ if cols>0 then say '───────┴'center("" , 1 + cols*(w+1), '─') say say 'Found ' commas(finds) @ndnp exit 0 /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ commas: parse arg ?; do jc=length(?)-3 to 1 by -3; ?=insert(',', ?, jc); end; return ?</lang>

output   when using the default inputs:

 index │      base ten integers  <  1,000  that are divisible by its digits, but not by the product of its digits
───────┼───────────────────────────────────────────────────────────────────────────────────────────────────────────────
   1   │         22         33         44         48         55         66         77         88         99        122
  11   │        124        126        155        162        168        184        222        244        248        264
  21   │        288        324        333        336        366        396        412        424        444        448
  31   │        488        515        555        636        648        666        728        777        784        824
  41   │        848        864        888        936        999
───────┴───────────────────────────────────────────────────────────────────────────────────────────────────────────────

Found  45  base ten integers  <  1,000  that are divisible by its digits, but not by the product of its digits

Ring

<lang ring> load "stdlib.ring"

decimals(0) see "working..." + nl see "Numbers divisible by their individual digits, but not by the product of their digits are:" + nl

row = 0 limit = 1000

for n = 1 to limit

   flag = 1
   pro = 1
   strn = string(n)
   for m = 1 to len(strn)
       temp = strn[m]
       if temp != 0
          pro = pro * number(temp)
       ok
       if n%temp = 0
          flag = 1
       else
          flag = 0
          exit
       ok
    next
    bool = ((n%pro) != 0)
    if flag = 1 and bool
       row = row + 1
       see "" + n + " "
       if row%10 = 0
          see nl
       ok
    ok

next

see nl + "Found " + row + " numbers" + nl see "done..." + nl </lang>

Output:

working...
Numbers divisible by their individual digits, but not by the product of their digits are:
22 33 44 48 55 66 77 88 99 122 
124 126 155 162 168 184 222 244 248 264 
288 324 333 336 366 396 412 424 444 448 
488 515 555 636 648 666 728 777 784 824 
848 864 888 936 999 
Found 45 numbers
done...