Numbers divisible by their individual digits, but not by the product of their digits.: Difference between revisions

{{trans|Python}}

‘True if n is divisible by each of its digits,

but not divisible by the product of those digits.

V w = xs.last.len

print(xs.len" matching numbers:\n")

{{out}}

=={{header|8086 Assembly}}==

org 100h

section .text

section .data

db '*****'

{{out}}

=={{header|Action!}}==

BYTE d

INT tmp,prod

FI

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Numbers_divisible_by_their_individual_digits,_but_not_by_the_product_of_their_digits.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

with Ada.Integer_Text_Io;

end if;

end loop;

{{out}}

<pre> 22 33 44 48 55 66 77 88 99 122 124 126 155 162 168

=={{header|ALGOL 68}}==

INT max number = 999;

INT number count := 0;

FI

OD

{{out}}

<pre>

=={{header|ALGOL-M}}==

integer function mod(a, b);

integer a, b;

end;

write("");

{{out}}

<pre> 22 33 44 48 55 66 77 88 99 122

=={{header|ALGOL W}}==

% returns true if n is divisible by its digits but not the product of its %

% digits, false otherwise %

end if_divisibleByDigitsButNotDigitProduct__i

end for_i

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

{{out}}

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

=={{header|Arturo}}==

digs: digits n

facts: factors n

]

{{out}}

=={{header|AutoHotkey}}==

while n < 1000

{

}

MsgBox % result

{{out}}

<pre>22 33 44 48 55 66 77 88 99 122 124 126

=={{header|AWK}}==

# syntax: GAWK -f NUMBERS_DIVISIBLE_BY_THEIR_INDIVIDUAL_DIGITS_BUT_NOT_BY_THE_PRODUCT_OF_THEIR_DIGITS.AWK

# converted from C

return(n % p)

}

{{out}}

<pre>

=={{header|BASIC}}==

20 FOR I=1 TO 999

30 N=I: P=1

90 IF N THEN 40

100 IF I MOD P <> 0 THEN PRINT I,

{{out}}

<pre> 22 33 44 48 55

=={{header|BCPL}}==

let divisible(n) = valof

$)

wrch('*N')

{{out}}

<pre> 22 33 44 48 55 66 77 88 99 122

=={{header|C}}==

int divisible(int n) {

return 0;

{{out}}

=={{header|CLU}}==

prod: int := 1

dgts: int := n

end

end

{{out}}

<pre> 22 33 44 48 55 66 77 88 99 122

=={{header|COBOL}}==

PROGRAM-ID. DIV-BY-DGTS-BUT-NOT-PROD.

MULTIPLY DIGIT(D) BY NDIV.

IF NDIV IS NOT EQUAL TO N SET OK TO 0.

{{out}}

<pre style='height: 50ex;'> 22

=={{header|Cowgol}}==

sub divisible(n: uint16): (r: uint8) is

n := n + 1;

end loop;

{{out}}

=={{header|Draco}}==

word dprod, c, dgt;

bool div;

fi

od

{{out}}

<pre> 22 33 44 48 55 66 77 88 99 122

=={{header|F_Sharp|F#}}==

// Nigel Galloway. April 9th., 2021

let rec fN i g e l=match g%10,g/10 with (0,_)->false |(n,_) when i%n>0->false |(n,0)->i%(l*n)>0 |(n,g)->fN i g (e+n) (l*n)

seq{1..999}|>Seq.filter(fun n->fN n n 0 1)|>Seq.iter(printf "%d "); printfn ""

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2021-02-05}}

math.functions math.ranges math.text.utils prettyprint sequences ;

} 3&& ;

{{out}}

<pre>

=={{header|FOCAL}}==

01.20 Q

02.75 S Z=I/P

02.80 I (FITR(Z)-Z)2.85,2.65

{{out}}

=={{header|Forth}}==

{{works with|Gforth}}

1 { p }

n

main

{{out}}

=={{header|FreeBASIC}}==

This function does a bit more than the task asks for, just to make things interesting.

'returns 1 if the number is divisible by its digits

' 2 if it is NOT divisible by the product of its digits

for i as uinteger = 1 to 999

if divdignp(i) = 3 then print i;" ";

{{out}}

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

{{trans|Wren}}

{{libheader|Go-rcu}}

import (

}

fmt.Printf("\n%d such numbers found\n", len(res))

{{out}}

=={{header|Haskell}}==

import Text.Printf

where

n = takeWhile (< 1000) numbers

{{out}}

and another approach might be to obtain (unordered) digit lists numerically, rather than by string conversion.

import Data.List (unfoldr)

import Data.List.Split (chunksOf)

justifyRight :: Int -> Char -> String -> String

{{Out}}

<pre> 22 33 44 48 55 66 77 88 99 122

=={{header|J}}==

<code>([ #~ ... ) >:i.999</code> filters the numbers based on the predicate (shown as '...' here).

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

tostring | explode | map( [.] | implode | tonumber);

| digits

| all( unique[]; $n % . == 0)

'''The Task'''

(range(1; 1000)

{{out}}

<pre>

=={{header|Julia}}==

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

<pre>

22 33 44 48 55 66 77 88 99 122 124 126 155 162 168

=={{header|Ksh}}==

#!/bin/ksh

(( ! i % 10 )) || _isdivisible ${i} || printf "%d " ${i}

done

{{out}}<pre>

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 </pre>

=={{header|MAD}}==

PRINT COMMENT $ $

VECTOR VALUES FMT = $I4*$

{{out}}

<pre style="height: 50ex;"> 22

=={{header|Mathematica}}/{{header|Wolfram Language}}==

SaveDivisible[n_,0] := False

SaveDivisible[n_,m_] := Divisible[n,m]

DivisibleDigits[n_Integer] := AllTrue[IntegerDigits[n],SaveDivisible[n,#]&]

Select[Range[999],DivisibleDigits[#]\[And]!SaveDivisible[#,Times@@IntegerDigits[#]]&]

{{out}}

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

=={{header|Nim}}==

iterator digits(n: Positive): int =

echo "Found ", result.len, " matching numbers."

for i, n in result:

{{out}}

=={{header|Pascal}}==

==={{header|Free Pascal}}===

program DivByDgtsNotByProdOfDgts;

writeln;

writeln(' count : ',cnt);

{{out}}

<pre>

=={{header|Perl}}==

use strict;

} 1 .. 999;

{{out}}

<pre>

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">didbntp</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">w</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">p</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1000</span><span style="color: #0000FF;">),</span><span style="color: #000000;">didbntp</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"found %d didbntp thingies less than one thousand: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">),</span><span style="color: #008000;">","</span><span style="color: #0000FF;">)})</span>

{{out}}

<pre>

=={{header|PL/M}}==

/* CHECK NUMBER */

CALL BDOS(0,0);

{{out}}

<pre style="height:50ex;">22

=={{header|Plain English}}==

Start up.

Loop.

Repeat.

If the number is evenly divisible by the digit product, say no.

{{out}}

<pre>

=={{header|Python}}==

from functools import reduce

if __name__ == '__main__':

main()

{{Out}}

<pre>45 matching numbers:

=={{header|Quackery}}==

[ 2drop false ] done

mod 0 = ] is divisible ( n n --> b )

drop ] is meetscriteria ( n n --> b )

{{out}}

=={{header|Raku}}==

{{out}}

=={{header|REXX}}==

parse arg hi cols . /*obtain optional argument from the CL.*/

if hi=='' | hi=="," then hi= 1000 /*Not specified? Then use the default.*/

exit 0 /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

=={{header|Ring}}==

load "stdlib.ring"

see nl + "Found " + row + " numbers" + nl

see "done..." + nl

{{out}}

<pre>

=={{header|Sidef}}==

n.digits.all {|d| d `divides` n } && !(n.digits.prod `divides` n)

{{out}}

<pre>

=={{header|Snobol}}==

divis p = 1

i = n

loop output = divis(n) n

n = lt(n,1000) n + 1 :s(loop)

{{out}}

{{libheader|Wren-seq}}

{{libheader|Wren-fmt}}

import "/seq" for Lst

import "/fmt" for Fmt

System.print("Numbers < 1000 divisible by their digits, but not by the product thereof:")

for (chunk in Lst.chunks(res, 9)) Fmt.print("$4d", chunk)

{{out}}

=={{header|XPL0}}==

\Return 'true' if N is divisible by its digits and not by the product of its digits

int N, M, Digit, Product;

Text(0, " such integers found below 1000.

");

{{out}}