Gapful numbers: Difference between revisions
m (added other site with gapful numbers counted 74632687 up to 1e9) |
(added =={{header|Pascal}}==) |
||
Line 143: | Line 143: | ||
(1000000000 1000000001 1000000005 1000000008 1000000010 1000000016 1000000020 1000000027 1000000030 1000000032) |
(1000000000 1000000001 1000000005 1000000008 1000000010 1000000016 1000000020 1000000027 1000000030 1000000032) |
||
</pre> |
</pre> |
||
=={{header|Pascal}}== |
|||
{{trans|Go}}{{works with|Free Pascal}}{{works with|Delphi}} |
|||
Put write in procedures, to lower register pressure. |
|||
Small improvement by memorizing upper and lower digit. |
|||
Only recognizable for huge amounts of tests 100|74623687 ( up to 1 billion )-> takes 7,2s instead of 11.25s |
|||
<lang pascal>program gapful; |
|||
{$IFDEF FPC} |
|||
{$MODE DELPHI}{$OPTIMIZATION ON,ALL}{$CODEALIGN proc=16,loop=4}{$ALIGN 16} |
|||
{$ELSE} |
|||
{$APPTYPE CONSOLE} |
|||
{$ENDIF} |
|||
uses |
|||
sysutils,// IntToStr |
|||
strUtils;// Numb2USA aka commatize |
|||
const |
|||
starts : array [0..4] of Uint32 |
|||
= (100, 1000*1000, 10*1000*1000,1000*1000*1000, 7123); |
|||
counts : array [0..4] of Uint32 = (30, 15, 15, 10, 25);//74623687 |
|||
Base = 10; |
|||
var |
|||
countLmt : Uint32; |
|||
procedure OutHeader(i: NativeInt); |
|||
Begin |
|||
writeln('First ',counts[i],', gapful numbers starting at ', |
|||
Numb2USA(IntToStr(starts[i]))); |
|||
end; |
|||
procedure OutNum(n:NativeUint); |
|||
Begin |
|||
write(' ',n); |
|||
end; |
|||
procedure Main; |
|||
var |
|||
i,LowDgt,HiDgt,TestNum,LmtNextNewHiDgt,Pow10: Uint64; |
|||
Begin |
|||
for i := 0 to High(starts) do |
|||
Begin |
|||
OutHeader(i); |
|||
countLmt := counts[i]; |
|||
TestNum := starts[i]; |
|||
Pow10 := Base*Base; |
|||
LmtNextNewHiDgt := Base*Pow10; |
|||
while LmtNextNewHiDgt < TestNum do |
|||
Begin |
|||
Pow10 := LmtNextNewHiDgt; |
|||
LmtNextNewHiDgt *= Base; |
|||
end; |
|||
LowDgt := TestNum MOD 10; |
|||
HiDgt := TestNum DIV Pow10; |
|||
LmtNextNewHiDgt := (HiDgt+1)*Pow10; |
|||
HiDgt := Base*HiDgt; |
|||
//start the search |
|||
repeat |
|||
if TestNum MOD (HiDgt+LowDgt) = 0 then |
|||
Begin |
|||
OutNum(TestNum); |
|||
dec(countLmt); |
|||
// Test and BREAK only if something has changed |
|||
IF countLmt = 0 then |
|||
BREAK; |
|||
end; |
|||
inc(LowDgt); |
|||
IF LowDgt =Base then |
|||
LowDgt := LowDgt XOR LowDgt;//= 0 |
|||
inc(TestNum); |
|||
//next Hi Digit |
|||
if TestNum >= LmtNextNewHiDgt then |
|||
Begin |
|||
HiDgt +=Base; |
|||
LmtNextNewHiDgt += Pow10; |
|||
LowDgt := 0; |
|||
//next power of 10 |
|||
if HiDgt >= Base*Base then |
|||
Begin |
|||
Pow10 *= Base; |
|||
LmtNextNewHiDgt := 2*Pow10; |
|||
HiDgt := Base; |
|||
LowDgt := 0; |
|||
end; |
|||
end; |
|||
until false;// Jump to repeat |
|||
writeln(#13#10); |
|||
end; |
|||
end; |
|||
Begin |
|||
Main; |
|||
end.</lang> |
|||
{{out}} |
|||
<pre>First 30, gapful numbers starting at 100 |
|||
100 105 108 110 120 121 130 132 135 140 143 150 154 160 165 170 176 180 187 190 192 195 198 200 220 225 231 240 242 253 |
|||
First 15, gapful numbers starting at 1,000,000 |
|||
1000000 1000001 1000064 1000100 1000125 1000188 1000200 1000212 1000216 1000233 1000300 1000335 1000400 1000500 1000545 |
|||
First 15, gapful numbers starting at 10,000,000 |
|||
10000000 10000095 10000100 10000111 10000146 10000182 10000200 10000224 10000300 10000305 10000327 10000368 10000373 10000400 10000500 |
|||
First 10, gapful numbers starting at 1,000,000,000 |
|||
1000000000 1000000091 1000000100 1000000144 1000000155 1000000188 1000000200 1000000300 1000000323 1000000365 |
|||
First 25, gapful numbers starting at 7,123 |
|||
7125 7140 7171 7189 7210 7272 7275 7280 7296 7350 7373 7420 7425 7474 7488 7490 7560 7575 7630 7632 7676 7700 7725 7770 7777</pre> |
|||
=={{header|Perl}}== |
=={{header|Perl}}== |
Revision as of 18:34, 16 November 2019
Numbers (positive integers expressed in base ten) that are (evenly) divisible by the number formed by the first and last digit are known as gapful numbers.
All one─ and two─digit numbers have this property and are trivially excluded. Only numbers ≥ 100 will be considered for this Rosetta Code task.
- Example
187 is a gapful number because it is evenly divisible by the number 17 which is formed by the first and last decimal digits of 187.
- Task
-
- Generate and show all sets of numbers (below) on one line (horizontally) with a title, here on this page
- Show the first 30 gapful numbers
- Show the first 15 gapful numbers ≥ 1,000,000
- Show the first 10 gapful numbers ≥ 1,000,000,000
- Related task:
- Also see
-
- The OEIS entry: A108343 gapful numbers.
- numbersaplenty gapful numbers
Factor
<lang factor>USING: formatting kernel lists lists.lazy math math.functions math.text.utils sequences ;
- gapful? ( n -- ? )
dup 1 digit-groups [ first ] [ last 10 * + ] bi divisor? ;
30 100 15 1,000,000 10 1,000,000,000 [
2dup lfrom [ gapful? ] lfilter ltake list>array "%d gapful numbers starting at %d:\n%[%d, %]\n\n" printf
] 2tri@</lang>
- Output:
30 gapful numbers starting at 100: { 100, 105, 108, 110, 120, 121, 130, 132, 135, 140, 143, 150, 154, 160, 165, 170, 176, 180, 187, 190, 192, 195, 198, 200, 220, 225, 231, 240, 242, 253 } 15 gapful numbers starting at 1000000: { 1000000, 1000005, 1000008, 1000010, 1000016, 1000020, 1000021, 1000030, 1000032, 1000034, 1000035, 1000040, 1000050, 1000060, 1000065 } 10 gapful numbers starting at 1000000000: { 1000000000, 1000000001, 1000000005, 1000000008, 1000000010, 1000000016, 1000000020, 1000000027, 1000000030, 1000000032 }
Fōrmulæ
In this page you can see the solution of this task.
Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text (more info). Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for transportation effects more than visualization and edition.
The option to show Fōrmulæ programs and their results is showing images. Unfortunately images cannot be uploaded in Rosetta Code.
Go
<lang go>package main
import "fmt"
func commatize(n uint64) string {
s := fmt.Sprintf("%d", n) le := len(s) for i := le - 3; i >= 1; i -= 3 { s = s[0:i] + "," + s[i:] } return s
}
func main() {
starts := []uint64{1e2, 1e6, 1e7, 1e9, 7123} counts := []int{30, 15, 15, 10, 25} for i := 0; i < len(starts); i++ { count := 0 j := starts[i] pow := uint64(100) for { if j < pow*10 { break } pow *= 10 } fmt.Printf("First %d gapful numbers starting at %s:\n", counts[i], commatize(starts[i])) for count < counts[i] { fl := (j/pow)*10 + (j % 10) if j%fl == 0 { fmt.Printf("%d ", j) count++ } j++ if j >= 10*pow { pow *= 10 } } fmt.Println("\n") }
}</lang>
- Output:
First 30 gapful numbers starting at 100: 100 105 108 110 120 121 130 132 135 140 143 150 154 160 165 170 176 180 187 190 192 195 198 200 220 225 231 240 242 253 First 15 gapful numbers starting at 1,000,000: 1000000 1000005 1000008 1000010 1000016 1000020 1000021 1000030 1000032 1000034 1000035 1000040 1000050 1000060 1000065 First 15 gapful numbers starting at 10,000,000: 10000000 10000001 10000003 10000004 10000005 10000008 10000010 10000016 10000020 10000030 10000032 10000035 10000040 10000050 10000060 First 10 gapful numbers starting at 1,000,000,000: 1000000000 1000000001 1000000005 1000000008 1000000010 1000000016 1000000020 1000000027 1000000030 1000000032 First 25 gapful numbers starting at 7,123: 7125 7140 7171 7189 7210 7272 7275 7280 7296 7350 7373 7420 7425 7474 7488 7490 7560 7575 7630 7632 7676 7700 7725 7770 7777
Julia
<lang julia>using Lazy, Formatting
firstlast(a) = 10 * a[end] + a[1] isgapful(n) = (d = digits(n); length(d) < 3 || (m = firstlast(d)) != 0 && mod(n, m) == 0) gapfuls(start) = filter(isgapful, Lazy.range(start))
for (x, n) in [(100, 30), (1_000_000, 15), (1_000_000_000, 10)]
println("First $n gapful numbers starting at ", format(x, commas=true), ":\n", take(n, gapfuls(x)))
end
</lang>
- Output:
First 30 gapful numbers starting at 100: (100 105 108 110 120 121 130 132 135 140 143 150 154 160 165 170 176 180 187 190 192 195 198 200 220 225 231 240 242 253) First 15 gapful numbers starting at 1,000,000: (1000000 1000005 1000008 1000010 1000016 1000020 1000021 1000030 1000032 1000034 1000035 1000040 1000050 1000060 1000065) First 10 gapful numbers starting at 1,000,000,000: (1000000000 1000000001 1000000005 1000000008 1000000010 1000000016 1000000020 1000000027 1000000030 1000000032)
Pascal
Put write in procedures, to lower register pressure. Small improvement by memorizing upper and lower digit. Only recognizable for huge amounts of tests 100|74623687 ( up to 1 billion )-> takes 7,2s instead of 11.25s <lang pascal>program gapful; {$IFDEF FPC}
{$MODE DELPHI}{$OPTIMIZATION ON,ALL}{$CODEALIGN proc=16,loop=4}{$ALIGN 16}
{$ELSE}
{$APPTYPE CONSOLE}
{$ENDIF} uses
sysutils,// IntToStr strUtils;// Numb2USA aka commatize
const
starts : array [0..4] of Uint32 = (100, 1000*1000, 10*1000*1000,1000*1000*1000, 7123); counts : array [0..4] of Uint32 = (30, 15, 15, 10, 25);//74623687 Base = 10;
var
countLmt : Uint32;
procedure OutHeader(i: NativeInt); Begin
writeln('First ',counts[i],', gapful numbers starting at ', Numb2USA(IntToStr(starts[i])));
end; procedure OutNum(n:NativeUint); Begin
write(' ',n);
end; procedure Main; var
i,LowDgt,HiDgt,TestNum,LmtNextNewHiDgt,Pow10: Uint64;
Begin
for i := 0 to High(starts) do Begin OutHeader(i); countLmt := counts[i]; TestNum := starts[i];
Pow10 := Base*Base; LmtNextNewHiDgt := Base*Pow10; while LmtNextNewHiDgt < TestNum do Begin Pow10 := LmtNextNewHiDgt; LmtNextNewHiDgt *= Base; end; LowDgt := TestNum MOD 10; HiDgt := TestNum DIV Pow10; LmtNextNewHiDgt := (HiDgt+1)*Pow10; HiDgt := Base*HiDgt; //start the search repeat if TestNum MOD (HiDgt+LowDgt) = 0 then Begin OutNum(TestNum); dec(countLmt); // Test and BREAK only if something has changed IF countLmt = 0 then BREAK; end; inc(LowDgt); IF LowDgt =Base then LowDgt := LowDgt XOR LowDgt;//= 0 inc(TestNum); //next Hi Digit if TestNum >= LmtNextNewHiDgt then Begin HiDgt +=Base; LmtNextNewHiDgt += Pow10; LowDgt := 0; //next power of 10 if HiDgt >= Base*Base then Begin Pow10 *= Base; LmtNextNewHiDgt := 2*Pow10; HiDgt := Base; LowDgt := 0; end; end; until false;// Jump to repeat writeln(#13#10); end;
end;
Begin
Main;
end.</lang>
- Output:
First 30, gapful numbers starting at 100 100 105 108 110 120 121 130 132 135 140 143 150 154 160 165 170 176 180 187 190 192 195 198 200 220 225 231 240 242 253 First 15, gapful numbers starting at 1,000,000 1000000 1000001 1000064 1000100 1000125 1000188 1000200 1000212 1000216 1000233 1000300 1000335 1000400 1000500 1000545 First 15, gapful numbers starting at 10,000,000 10000000 10000095 10000100 10000111 10000146 10000182 10000200 10000224 10000300 10000305 10000327 10000368 10000373 10000400 10000500 First 10, gapful numbers starting at 1,000,000,000 1000000000 1000000091 1000000100 1000000144 1000000155 1000000188 1000000200 1000000300 1000000323 1000000365 First 25, gapful numbers starting at 7,123 7125 7140 7171 7189 7210 7272 7275 7280 7296 7350 7373 7420 7425 7474 7488 7490 7560 7575 7630 7632 7676 7700 7725 7770 7777
Perl
<lang perl>use strict; use warnings; use feature 'say';
sub comma { reverse ((reverse shift) =~ s/(.{3})/$1,/gr) =~ s/^,//r }
sub is_gapful { my $n = shift; 0 == $n % join(, (split //, $n)[0,-1]) }
use constant Inf => 1e10; for ([1e2, 30], [1e6, 15], [1e9, 10], [7123, 25]) {
my($start, $count) = @$_; printf "\nFirst $count gapful numbers starting at %s:\n", comma $start; my $n = 0; my $g = ; $g .= do { $n < $count ? (is_gapful($_) and ++$n and "$_ ") : last } for $start .. Inf; say $g;
}</lang>
- Output:
First 30 gapful numbers starting at 100: 100 105 108 110 120 121 130 132 135 140 143 150 154 160 165 170 176 180 187 190 192 195 198 200 220 225 231 240 242 253 First 15 gapful numbers starting at 1,000,000: 1000000 1000005 1000008 1000010 1000016 1000020 1000021 1000030 1000032 1000034 1000035 1000040 1000050 1000060 1000065 First 10 gapful numbers starting at 1,000,000,000: 1000000000 1000000001 1000000005 1000000008 1000000010 1000000016 1000000020 1000000027 1000000030 1000000032 First 25 gapful numbers starting at 7,123: 7125 7140 7171 7189 7210 7272 7275 7280 7296 7350 7373 7420 7425 7474 7488 7490 7560 7575 7630 7632 7676 7700 7725 7770 7777
Perl 6
Also test starting on a number that doesn't start with 1. Required to have titles, may as well make 'em noble. :-)
<lang perl6>use Lingua::EN::Numbers;
for (1e2, 30, 1e6, 15, 1e9, 10, 7123, 25)».Int -> $start, $count {
put "\nFirst $count gapful numbers starting at {comma $start}:\n" ~ <Sir Lord Duke King>.pick ~ ": ", ~ ($start..*).grep( { $_ %% .comb[0, *-1].join } )[^$count];
}</lang>
- Output:
First 30 gapful numbers starting at 100: Sir: 100 105 108 110 120 121 130 132 135 140 143 150 154 160 165 170 176 180 187 190 192 195 198 200 220 225 231 240 242 253 First 15 gapful numbers starting at 1,000,000: Duke: 1000000 1000005 1000008 1000010 1000016 1000020 1000021 1000030 1000032 1000034 1000035 1000040 1000050 1000060 1000065 First 10 gapful numbers starting at 1,000,000,000: King: 1000000000 1000000001 1000000005 1000000008 1000000010 1000000016 1000000020 1000000027 1000000030 1000000032 First 25 gapful numbers starting at 7,123: King: 7125 7140 7171 7189 7210 7272 7275 7280 7296 7350 7373 7420 7425 7474 7488 7490 7560 7575 7630 7632 7676 7700 7725 7770 7777
Python
<lang python>from itertools import islice, count for start, n in [(100, 30), (1_000_000, 15), (1_000_000_000, 10)]:
print(f"\nFirst {n} gapful numbers from {start:_}") print(list(islice(( x for x in count(start) if (x % (int(str(x)[0]) * 10 + (x % 10)) == 0) ) , n)))</lang>
- Output:
First 30 gapful numbers from 100 [100, 105, 108, 110, 120, 121, 130, 132, 135, 140, 143, 150, 154, 160, 165, 170, 176, 180, 187, 190, 192, 195, 198, 200, 220, 225, 231, 240, 242, 253] First 15 gapful numbers from 1_000_000 [1000000, 1000005, 1000008, 1000010, 1000016, 1000020, 1000021, 1000030, 1000032, 1000034, 1000035, 1000040, 1000050, 1000060, 1000065] First 10 gapful numbers from 1_000_000_000 [1000000000, 1000000001, 1000000005, 1000000008, 1000000010, 1000000016, 1000000020, 1000000027, 1000000030, 1000000032]
REXX
<lang rexx>/*REXX program computes and displays gapful numbers and also palindromic gapful numbers.*/ numeric digits 20 /*ensure enough decimal digits gapfuls.*/ parse arg gapfuls /*obtain optional arguments from the CL*/ if gapfuls= then gapfuls= 30 25@7123 15@1000000 10@1000000000 /*assume defaults. */
do until gapfuls=; parse var gapfuls stuff gapfuls; call gapful stuff end /*until*/
exit /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ gapful: procedure; parse arg n '@' sp; #= 0; if sp== then sp= 100
say center(' 'n " gapful numbers starting at: " sp' ', 125, "═") $= /*initialize $ list.*/ do j=sp until #==n /*SP: start point. */ parse var j a 2 -1 b /*get 1st & last dig*/ if j // (a||b) \== 0 then iterate /*perform ÷ into J.*/ #= # + 1; $= $ j /*bump #; append──►$*/ end /*j*/ say strip($); say; return</lang>
- output when using the default inputs:
(Shown at 5/6 size.)
═══════════════════════════════════════════ 30 gapful numbers starting at: 100 ════════════════════════════════════════════ 100 105 108 110 120 121 130 132 135 140 143 150 154 160 165 170 176 180 187 190 192 195 198 200 220 225 231 240 242 253 ═══════════════════════════════════════════ 25 gapful numbers starting at: 7123 ═══════════════════════════════════════════ 7125 7140 7171 7189 7210 7272 7275 7280 7296 7350 7373 7420 7425 7474 7488 7490 7560 7575 7630 7632 7676 7700 7725 7770 7777 ═════════════════════════════════════════ 15 gapful numbers starting at: 1000000 ══════════════════════════════════════════ 1000000 1000005 1000008 1000010 1000016 1000020 1000021 1000030 1000032 1000034 1000035 1000040 1000050 1000060 1000065 ════════════════════════════════════════ 10 gapful numbers starting at: 1000000000 ════════════════════════════════════════ 1000000000 1000000001 1000000005 1000000008 1000000010 1000000016 1000000020 1000000027 1000000030 1000000032
zkl
<lang zkl>fcn gapfulW(start){ //--> iterator
[start..].tweak( fcn(n){ if(n % (10*n.toString()[0] + n%10)) Void.Skip else n })
}</lang> <lang zkl>foreach n,z in
( T( T(100, 30), T(1_000_000, 15), T(1_000_000_000, 10), T(7_123,25) )){ println("First %d gapful numbers starting at %,d:".fmt(z,n)); gapfulW(n).walk(z).concat(", ").println("\n");
}</lang>
- Output:
First 30 gapful numbers starting at 100: 100, 105, 108, 110, 120, 121, 130, 132, 135, 140, 143, 150, 154, 160, 165, 170, 176, 180, 187, 190, 192, 195, 198, 200, 220, 225, 231, 240, 242, 253 First 15 gapful numbers starting at 1,000,000: 1000000, 1000005, 1000008, 1000010, 1000016, 1000020, 1000021, 1000030, 1000032, 1000034, 1000035, 1000040, 1000050, 1000060, 1000065 First 10 gapful numbers starting at 1,000,000,000: 1000000000, 1000000001, 1000000005, 1000000008, 1000000010, 1000000016, 1000000020, 1000000027, 1000000030, 1000000032 First 25 gapful numbers starting at 7,123: 7125, 7140, 7171, 7189, 7210, 7272, 7275, 7280, 7296, 7350, 7373, 7420, 7425, 7474, 7488, 7490, 7560, 7575, 7630, 7632, 7676, 7700, 7725, 7770, 7777