Rosetta Code

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

Page Discussion

Numbers divisible by their individual digits, but not by the product of their digits. (view source)

Revision as of 18:06, 16 May 2024

8,491 bytes added ,  30 days ago
Added Easylang
(Added Arturo implementation)
(Added Easylang)
 
(13 intermediate revisions by 11 users not shown)
Line 8:
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">F p(n)
 
<lang 11l>F p(n)
‘True if n is divisible by each of its digits,
but not divisible by the product of those digits.
Line 28 ⟶ 27:
V w = xs.last.len
print(xs.len" matching numbers:\n")
print(chunksOf(10)(xs).map(row -> row.map(cell -> cell.rjust(:w, ‘ ’)).join(‘ ’)).join("\n"))</langsyntaxhighlight>
 
{{out}}
Line 42 ⟶ 41:
 
=={{header|8086 Assembly}}==
<langsyntaxhighlight lang="asm"> cpu 8086
org 100h
section .text
Line 93 ⟶ 92:
section .data
db '*****'
dbuf: db 13,10,'$'</langsyntaxhighlight>
 
{{out}}
Line 144 ⟶ 143:
 
=={{header|Action!}}==
<langsyntaxhighlight Actionlang="action!">BYTE FUNC Check(INT x)
BYTE d
INT tmp,prod
Line 172 ⟶ 171:
FI
OD
RETURN</langsyntaxhighlight>
{{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]
Line 181 ⟶ 180:
 
=={{header|Ada}}==
<langsyntaxhighlight Adalang="ada">with Ada.Text_Io;
with Ada.Integer_Text_Io;
 
Line 219 ⟶ 218:
end if;
end loop;
end Numbers_Divisible;</langsyntaxhighlight>
{{out}}
<pre> 22 33 44 48 55 66 77 88 99 122 124 126 155 162 168
Line 226 ⟶ 225:
 
=={{header|ALGOL 68}}==
<langsyntaxhighlight lang="algol68">BEGIN # find numbers divisible by their digits but not the product of their digits #
INT max number = 999;
INT number count := 0;
Line 250 ⟶ 249:
FI
OD
END</langsyntaxhighlight>
{{out}}
<pre>
Line 259 ⟶ 258:
 
=={{header|ALGOL-M}}==
<langsyntaxhighlight lang="algolm">begin
integer function mod(a, b);
integer a, b;
Line 298 ⟶ 297:
end;
write("");
end</langsyntaxhighlight>
{{out}}
<pre> 22 33 44 48 55 66 77 88 99 122
Line 307 ⟶ 306:
 
=={{header|ALGOL W}}==
<langsyntaxhighlight lang="algolw">begin % find numbers divisible by their digits but not the product of their digits %
% returns true if n is divisible by its digits but not the product of its %
% digits, false otherwise %
Line 341 ⟶ 340:
end if_divisibleByDigitsButNotDigitProduct__i
end for_i
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 352 ⟶ 351:
=={{header|APL}}==
{{works with|Dyalog APL}}
<langsyntaxhighlight APLlang="apl">(⊢(/⍨)((⍎¨∘⍕)((∧/0=|)∧0≠(×/⊣)|⊢)⊢)¨)⍳999</langsyntaxhighlight>
{{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|Arturo}}==
 
=={{header|Arturo}}==
<lang rebol>valid?: function [n][
<syntaxhighlight lang="rebol">valid?: function [n][
digs: digits n
facts: factors n
Line 365 ⟶ 364:
]
 
print select 1..999 => valid?</langsyntaxhighlight>
 
{{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|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">main:
while n < 1000
{
n := A_Index
prod = 1
for i, v in StrSplit(n)
{
if (v = 0) || (n/v <> floor(n/v))
continue, main
prod *= v
}
if (n/prod = floor(n/prod))
continue
result .= n "`t"
}
MsgBox % result
</syntaxhighlight>
{{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|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f NUMBERS_DIVISIBLE_BY_THEIR_INDIVIDUAL_DIGITS_BUT_NOT_BY_THE_PRODUCT_OF_THEIR_DIGITS.AWK
# converted from C
Line 395 ⟶ 418:
return(n % p)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 407 ⟶ 430:
 
=={{header|BASIC}}==
<langsyntaxhighlight lang="basic">10 DEFINT A-Z
20 FOR I=1 TO 999
30 N=I: P=1
Line 417 ⟶ 440:
90 IF N THEN 40
100 IF I MOD P <> 0 THEN PRINT I,
110 NEXT I</langsyntaxhighlight>
{{out}}
<pre> 22 33 44 48 55
Line 430 ⟶ 453:
 
=={{header|BCPL}}==
<langsyntaxhighlight lang="bcpl">get "libhdr"
 
let divisible(n) = valof
Line 454 ⟶ 477:
$)
wrch('*N')
$)</langsyntaxhighlight>
{{out}}
<pre> 22 33 44 48 55 66 77 88 99 122
Line 463 ⟶ 486:
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
 
int divisible(int n) {
Line 490 ⟶ 513:
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 501 ⟶ 524:
 
=={{header|CLU}}==
<langsyntaxhighlight lang="clu">divisible = proc (n: int) returns (bool)
prod: int := 1
dgts: int := n
Line 525 ⟶ 548:
end
end
end start_up</langsyntaxhighlight>
{{out}}
<pre> 22 33 44 48 55 66 77 88 99 122
Line 534 ⟶ 557:
 
=={{header|COBOL}}==
<langsyntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.
PROGRAM-ID. DIV-BY-DGTS-BUT-NOT-PROD.
Line 583 ⟶ 606:
MULTIPLY DIGIT(D) BY NDIV.
IF NDIV IS NOT EQUAL TO N SET OK TO 0.
NOPE. EXIT.</langsyntaxhighlight>
{{out}}
<pre style='height: 50ex;'> 22
Line 632 ⟶ 655:
 
=={{header|Cowgol}}==
<langsyntaxhighlight lang="cowgol">include "cowgol.coh";
 
sub divisible(n: uint16): (r: uint8) is
Line 668 ⟶ 691:
n := n + 1;
end loop;
print_nl();</langsyntaxhighlight>
 
{{out}}
Line 679 ⟶ 702:
 
=={{header|Draco}}==
<langsyntaxhighlight lang="draco">proc nonrec divisible(word n) bool:
word dprod, c, dgt;
bool div;
Line 709 ⟶ 732:
fi
od
corp</langsyntaxhighlight>
{{out}}
<pre> 22 33 44 48 55 66 77 88 99 122
Line 716 ⟶ 739:
488 515 555 636 648 666 728 777 784 824
848 864 888 936 999</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
function IsDivisible(N: integer): boolean;
{Returns true if N is divisible by each of its digits}
{And not divisible by the product of all the digits}
var I: integer;
var S: string;
var B: byte;
var P: integer;
begin
Result:=False;
{Test if digits divide into N}
S:=IntToStr(N);
for I:=1 to Length(S) do
begin
B:=Byte(S[I])-$30;
if B=0 then exit;
if (N mod B)<>0 then exit;
end;
{Test if product of digits doesn't divide into N}
P:=1;
for I:=1 to Length(S) do
begin
B:=Byte(S[I])-$30;
P:=P * B;
end;
Result:=(N mod P)<>0;
end;
 
 
procedure ShowDivisibleDigits(Memo: TMemo);
{Show numbers that are even divisible by each of its digits}
{But not divisible by the product of all its digits}
var I,Cnt: integer;
var S: string;
begin
Cnt:=0;
S:='';
for I:=1 to 999 do
if IsDivisible(I) then
begin
Inc(Cnt);
S:=S+Format('%4D',[I]);
If (Cnt mod 10)=0 then S:=S+#$0D#$0A;
end;
Memo.Lines.Add('Count='+IntToStr(Cnt));
Memo.Lines.Add(S);
end;
 
</syntaxhighlight>
{{out}}
<pre>
Count=45
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|EasyLang}}==
{{trans|C}}
<syntaxhighlight>
func divisible n .
p = 1
c = n
while c > 0
d = c mod 10
if d = 0 or n mod d <> 0
return 0
.
p *= d
c = c div 10
.
return if n mod p > 0
.
for n = 1 to 999
if divisible n = 1
write n & " "
.
.
</syntaxhighlight>
{{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|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">
// 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 ""
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 730 ⟶ 845:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<langsyntaxhighlight lang="factor">USING: combinators.short-circuit grouping kernel math
math.functions math.ranges math.text.utils prettyprint sequences ;
 
Line 741 ⟶ 856:
} 3&& ;
 
1000 [1..b] [ needle? ] filter 9 group simple-table.</langsyntaxhighlight>
{{out}}
<pre>
Line 752 ⟶ 867:
 
=={{header|FOCAL}}==
<langsyntaxhighlight FOCALlang="focal">01.10 F I=1,999;D 2
01.20 Q
 
Line 768 ⟶ 883:
02.75 S Z=I/P
02.80 I (FITR(Z)-Z)2.85,2.65
02.85 T %4,I,!</langsyntaxhighlight>
 
{{out}}
Line 820 ⟶ 935:
=={{header|Forth}}==
{{works with|Gforth}}
<langsyntaxhighlight lang="forth">: divisible? { n -- ? }
1 { p }
n
Line 848 ⟶ 963:
 
main
bye</langsyntaxhighlight>
 
{{out}}
Line 861 ⟶ 976:
=={{header|FreeBASIC}}==
This function does a bit more than the task asks for, just to make things interesting.
<langsyntaxhighlight lang="freebasic">function divdignp( n as const integer ) as ubyte
'returns 1 if the number is divisible by its digits
' 2 if it is NOT divisible by the product of its digits
Line 879 ⟶ 994:
for i as uinteger = 1 to 999
if divdignp(i) = 3 then print i;" ";
next i : print</langsyntaxhighlight>
{{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
Line 887 ⟶ 1,002:
{{trans|Wren}}
{{libheader|Go-rcu}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 923 ⟶ 1,038:
}
fmt.Printf("\n%d such numbers found\n", len(res))
}</langsyntaxhighlight>
 
{{out}}
Line 938 ⟶ 1,053:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Data.List.Split (chunksOf)
import Text.Printf
 
Line 957 ⟶ 1,072:
where
n = takeWhile (< 1000) numbers
split = chunksOf 10 n</langsyntaxhighlight>
 
{{out}}
Line 969 ⟶ 1,084:
and another approach might be to obtain (unordered) digit lists numerically, rather than by string conversion.
 
<langsyntaxhighlight lang="haskell">import Data.Bool (bool)
import Data.List (unfoldr)
import Data.List.Split (chunksOf)
Line 1,005 ⟶ 1,120:
 
justifyRight :: Int -> Char -> String -> String
justifyRight n c = (drop . length) <*> (replicate n c <>)</langsyntaxhighlight>
{{Out}}
<pre> 22 33 44 48 55 66 77 88 99 122
Line 1,014 ⟶ 1,129:
 
=={{header|J}}==
<syntaxhighlight lang="j"> J>([ #~ ((10 #.^:_1inv]) ((0:~:*/@[|]) *. *./@(0:=|)) ])"0) >:i.999</lang>
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</syntaxhighlight>
{{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>
<code>([ #~ ... ) >:i.999</code> filters the numbers based on the predicate (shown as '...' here).
 
<code>((10 #.inv]) ... ])"0</code> extracts a predicate value for each number, with the number's digits as the left argument and the number itself as the right argument.
 
<code>((0~:*/@[|]) * */@(0=|))</code> is true if the product of the digits does not evenly divide the number (<code>(0~:*/@[|])</code>) AND all of the digits individually evenly divide the number (<code>*/@(0=|)</code>).
 
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<langsyntaxhighlight lang="jq">def digits:
tostring | explode | map( [.] | implode | tonumber);
 
Line 1,033 ⟶ 1,153:
| digits
| all( unique[]; $n % . == 0)
and ($n % prod != 0);</langsyntaxhighlight>
'''The Task'''
<langsyntaxhighlight lang="jq">"Numbers < 1000 divisible by their digits, but not by the product thereof:",
(range(1; 1000)
| select(is_divisible_by_digits_but_not_product))</langsyntaxhighlight>
{{out}}
<pre>
Line 1,090 ⟶ 1,210:
 
=={{header|Julia}}==
<langsyntaxhighlight 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)))
</langsyntaxhighlight>{{out}}
<pre>
22 33 44 48 55 66 77 88 99 122 124 126 155 162 168
Line 1,101 ⟶ 1,221:
 
=={{header|Ksh}}==
<langsyntaxhighlight lang="ksh">
#!/bin/ksh
 
Line 1,135 ⟶ 1,255:
(( ! i % 10 )) || _isdivisible ${i} || printf "%d " ${i}
done
</syntaxhighlight>
</lang>
{{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}}==
<langsyntaxhighlight MADlang="mad"> NORMAL MODE IS INTEGER
PRINT COMMENT $ $
Line 1,162 ⟶ 1,282:
 
VECTOR VALUES FMT = $I4*$
END OF PROGRAM </langsyntaxhighlight>
{{out}}
<pre style="height: 50ex;"> 22
Line 1,209 ⟶ 1,329:
936
999</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">ClearAll[SaveDivisible,DivisibleDigits]
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[#]]&]
Length[%]</syntaxhighlight>
{{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}
45</pre>
 
=={{header|Miranda}}==
<syntaxhighlight lang="miranda">main :: [sys_message]
main = [Stdout (table 12 5 numbers)]
 
table :: num->num->[num]->[char]
table cols cw = lay . map concat . split . map fmt
where split [] = []
split ls = take cols ls : split (drop cols ls)
fmt n = reverse (take cw ((reverse (shownum n)) ++ repeat ' '))
 
numbers :: [num]
numbers = [n | n<-[1..1000]; divisible n]
 
divisible :: num->bool
divisible n = False, if digprod = 0 \/ n mod digprod = 0
= and [n mod d = 0 | d <- digits n], otherwise
where digprod = product (digits n)
 
digits :: num->[num]
digits = map (mod 10) . takewhile (>0) . iterate (div 10)</syntaxhighlight>
{{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|Nim}}==
<langsyntaxhighlight Nimlang="nim">import strutils
 
iterator digits(n: Positive): int =
Line 1,230 ⟶ 1,387:
echo "Found ", result.len, " matching numbers."
for i, n in result:
stdout.write ($n).align(3), if (i + 1) mod 9 == 0: '\n' else: ' '</langsyntaxhighlight>
 
{{out}}
Line 1,239 ⟶ 1,396:
424 444 448 488 515 555 636 648 666
728 777 784 824 848 864 888 936 999</pre>
 
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">let test b x =
let rec loop m n =
if n < b
then x mod n = 0 && x mod (m * n) > 0
else let d = n mod b in d > 0 && x mod d = 0 && loop (m * d) (n / b)
in loop 1 x
 
let () =
Seq.ints 1 |> Seq.take 999 |> Seq.filter (test 10)
|> Seq.iter (Printf.printf " %u") |> print_newline</syntaxhighlight>
{{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|Pascal}}==
==={{header|Free Pascal}}===
<langsyntaxhighlight lang="pascal">
program DivByDgtsNotByProdOfDgts;
 
Line 1,284 ⟶ 1,456:
writeln;
writeln(' count : ',cnt);
END.</langsyntaxhighlight>
{{out}}
<pre>
Line 1,294 ⟶ 1,466:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">#!/usr/bin/perl
 
use strict;
Line 1,305 ⟶ 1,477:
} 1 .. 999;
 
print @numbers . " numbers found\n\n@numbers\n" =~ s/.{25}\K /\n/gr;</langsyntaxhighlight>
{{out}}
<pre>
Line 1,320 ⟶ 1,492:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<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>
Line 1,333 ⟶ 1,505:
<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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 1,340 ⟶ 1,512:
 
=={{header|PL/M}}==
<langsyntaxhighlight lang="plm">100H:
 
/* CHECK NUMBER */
Line 1,385 ⟶ 1,557:
 
CALL BDOS(0,0);
EOF</langsyntaxhighlight>
{{out}}
<pre style="height:50ex;">22
Line 1,434 ⟶ 1,606:
 
=={{header|Plain English}}==
<langsyntaxhighlight lang="plainenglish">To run:
Start up.
Loop.
Line 1,455 ⟶ 1,627:
Repeat.
If the number is evenly divisible by the digit product, say no.
Say yes.</langsyntaxhighlight>
{{out}}
<pre>
Line 1,462 ⟶ 1,634:
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">'''Numbers matching a function of their digits'''
 
from functools import reduce
Line 1,514 ⟶ 1,686:
if __name__ == '__main__':
main()
</syntaxhighlight>
</lang>
{{Out}}
<pre>45 matching numbers:
Line 1,525 ⟶ 1,697:
 
=={{header|Quackery}}==
<syntaxhighlight lang="quackery"> [ dup 0 = iff
 
<lang Quackery> [ dup 0 = iff
[ 2drop false ] done
mod 0 = ] is divisible ( n n --> b )
Line 1,548 ⟶ 1,719:
drop ] is meetscriteria ( n n --> b )
 
1000 times [ i^ meetscriteria if [ i^ echo sp ] ]</langsyntaxhighlight>
 
{{out}}
Line 1,555 ⟶ 1,726:
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" line>say "{+$_} matching numbers:\n{.batch(10)».fmt('%3d').join: "\n"}" given
 
(^1000).grep: -> $n { $n.contains(0) ?? False !! all |($n.comb).map($n %% *), $n % [*] $n.comb };</syntaxhighlight>
<lang perl6>say "{+$_} matching numbers:\n{.batch(10)».fmt('%3d').join: "\n"}" given
(^1000).grep: -> $n { $n.contains(0) ?? False !! all |($n.comb).map($n %% *), $n % [*] $n.comb };</lang>
 
{{out}}
Line 1,568 ⟶ 1,738:
 
=={{header|REXX}}==
<langsyntaxhighlight lang="rexx">/*REXX pgm finds integers 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.*/
Line 1,600 ⟶ 1,770:
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 ?</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 1,616 ⟶ 1,786:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
Line 1,654 ⟶ 1,824:
see nl + "Found " + row + " numbers" + nl
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,667 ⟶ 1,837:
done...
 
</pre>
 
=={{header|RPL}}==
{{works with|HP|48}}
≪ DUP →STR → n
≪ '''CASE'''
DUP 9 ≤ n "0" POS OR '''THEN''' DROP 0 '''END'''
≪ n j DUP SUB STR→ ≫ 'j' 1 n SIZE 1 SEQ <span style="color:grey">@ make list of digits</span>
DUP2 MOD ∑LIST '''THEN''' DROP2 0 '''END'''
ΠLIST MOD SIGN
'''END'''
≫ '<span style="color:blue">GOOD?</span>' STO
 
≪ 1 999 '''FOR''' j '''IF''' j <span style="color:blue">GOOD?</span> '''THEN''' j + '''END NEXT''' ≫ EVAL
{{out}}
<pre>
1: { 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|Rust}}==
<syntaxhighlight lang="rust">
fn to_digits( n : i32 ) -> Vec<i32> {
let mut i : i32 = n ;
let mut digits : Vec<i32> = Vec::new( ) ;
while i != 0 {
digits.push( i % 10 ) ;
i /= 10 ;
}
digits
}
 
fn my_condition( num : i32 ) -> bool {
let digits : Vec<i32> = to_digits( num ) ;
if ! digits.iter( ).any( | x | *x == 0 ) {
let prod : i32 = digits.iter( ).product( ) ;
return digits.iter( ).all( | x | num % x == 0 ) &&
num % prod != 0 ;
}
else {
false
}
}
 
fn main() {
let mut count : i32 = 0 ;
for n in 10 .. 1000 {
if my_condition( n ) {
print!("{:5}" , n) ;
count += 1 ;
if count % 10 == 0 {
println!( ) ;
}
}
}
println!();
}</syntaxhighlight>
{{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|Ruby}}==
<syntaxhighlight lang="ruby">res =(1..1000).select do |n|
digits = n.digits
next if digits.include? 0
digits.uniq.all?{|d| n%d == 0} &! (n % digits.inject(:*) == 0)
end
 
p res</syntaxhighlight>
{{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|Sidef}}==
<langsyntaxhighlight lang="ruby">^1000 -> grep {|n|
n.digits.all {|d| d `divides` n } && !(n.digits.prod `divides` n)
}.say</langsyntaxhighlight>
{{out}}
<pre>
Line 1,679 ⟶ 1,924:
 
=={{header|Snobol}}==
<langsyntaxhighlight lang="snobol"> define('divis(n)i,d,p') :(divis_end)
divis p = 1
i = n
Line 1,691 ⟶ 1,936:
loop output = divis(n) n
n = lt(n,1000) n + 1 :s(loop)
end</langsyntaxhighlight>
 
{{out}}
Line 1,743 ⟶ 1,988:
=={{header|Wren}}==
{{libheader|Wren-math}}
{{libheader|Wren-seq}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./math" for Int, Nums
import "./seqfmt" for LstFmt
import "/fmt" for Fmt
 
var res = []
Line 1,758 ⟶ 2,001:
}
System.print("Numbers < 1000 divisible by their digits, but not by the product thereof:")
for (chunk in Lst.chunks(res, 9)) Fmt.printtprint("$4d", chunkres, 9)
System.print("\n%(res.count) such numbers found")</langsyntaxhighlight>
 
{{out}}
Line 1,774 ⟶ 2,017:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">func Check(N);
\Return 'true' if N is divisible by its digits and not by the product of its digits
int N, M, Digit, Product;
Line 1,800 ⟶ 2,043:
Text(0, " such integers found below 1000.
");
]</langsyntaxhighlight>
 
{{out}}
Chkas
2,063

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/311340...364499"