Ludic numbers: Difference between revisions
Added Easylang
(Added Easylang) |
|||
| (12 intermediate revisions by 9 users not shown) | |||
Line 45:
{{trans|Python}}
<
V r = [1]
V lst = Array(2..nmax)
Line 68:
x + 2 C :ludics &
x + 6 C :ludics).map(x -> (x, x + 2, x + 6))
print("\nThere are #. triplets less than #.:\n #.".format(triplets.len, n, triplets))</
{{out}}
Line 86:
=={{header|360 Assembly}}==
{{trans|Fortran}}
<
LUDICN CSECT
USING LUDICN,R15 set base register
Line 207:
LUDIC DC 25000X'01' ludic(nmax)=true
YREGS
END LUDICN</
{{out}}
<pre>
Line 231:
=={{header|ABAP}}==
Works with NW 7.40 SP8
<
PUBLIC SECTION.
Line 317:
ENDMETHOD.
ENDCLASS.</
{{Output}}
Line 368:
221 223 227
233 235 239
</pre>
=={{header|Action!}}==
Calculations on a real Atari 8-bit computer take quite long time. It is recommended to use an emulator capable with increasing speed of Atari CPU.
<syntaxhighlight lang="action!">DEFINE NOTLUDIC="0"
DEFINE LUDIC="1"
DEFINE UNKNOWN="2"
PROC LudicSieve(BYTE ARRAY a INT count)
INT i,j,k
SetBlock(a,count,UNKNOWN)
a(0)=NOTLUDIC
a(1)=LUDIC
i=2
WHILE i<count
DO
IF a(i)=UNKNOWN THEN
a(i)=LUDIC
j=i k=0
WHILE j<count
DO
IF a(j)=UNKNOWN THEN
k==+1
IF k=i THEN
a(j)=NOTLUDIC
k=0
FI
FI
j==+1
OD
FI
i==+1
Poke(77,0) ;turn off the attract mode
OD
RETURN
PROC PrintLudicNumbers(BYTE ARRAY a INT count,first,last)
INT i,j
i=1 j=0
WHILE i<count AND j<=last
DO
IF a(i)=LUDIC THEN
IF j>=first THEN
PrintI(i) Put(32)
FI
j==+1
FI
i==+1
OD
PutE() PutE()
RETURN
INT FUNC CountLudicNumbers(BYTE ARRAY a INT max)
INT i,res
res=0
FOR i=1 TO max
DO
IF a(i)=LUDIC THEN
res==+1
FI
OD
RETURN (res)
PROC PrintLudicTriplets(BYTE ARRAY a INT max)
INT i,j
j=0
FOR i=0 TO max-6
DO
IF a(i)=LUDIC AND a(i+2)=LUDIC AND a(i+6)=LUDIC THEN
j==+1
PrintF("%I. %I-%I-%I%E",j,i,i+2,i+6)
FI
OD
RETURN
PROC Main()
DEFINE COUNT="22000"
BYTE ARRAY lud(COUNT+1)
INT i,n
PrintE("Please wait...")
LudicSieve(lud,COUNT+1)
Put(125) PutE() ;clear the screen
PrintE("First 25 ludic numbers:")
PrintLudicNumbers(lud,COUNT+1,0,24)
n=CountLudicNumbers(lud,1000)
PrintF("There are %I ludic numbers <= 1000%E%E",n)
PrintE("2000'th..2005'th ludic numbers:")
PrintLudicNumbers(lud,COUNT+1,1999,2004)
PrintE("Ludic triplets below 250")
PrintLudicTriplets(lud,249)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Ludic_numbers.png Screenshot from Atari 8-bit computer]
<pre>
First 25 ludic numbers:
1 2 3 5 7 11 13 17 23 25 29 37 41 43 47 53 61 67 71 77 83 89 91 97 107
There are 142 ludic numbers <= 1000
2000'th..2005'th ludic numbers:
21475 21481 21487 21493 21503 21511
Ludic triplets below 250
1. 1-3-7
2. 5-7-11
3. 11-13-17
4. 23-25-29
5. 41-43-47
6. 173-175-179
7. 221-223-227
8. 233-235-239
</pre>
=={{header|Ada}}==
<
with Ada.Containers.Vectors;
Line 470 ⟶ 591:
Last => 2005);
Find_Triplets (Limit => 250);
end Ludic_Numbers;</
{{out}}
Line 489 ⟶ 610:
=={{header|ALGOL 68}}==
<
# sieve the Ludic numbers up to 30 000 #
Line 547 ⟶ 668:
print( ( " ", whole( n, -3 ), ", ", whole( n + 2, -3 ), ", ", whole( n + 6, -3 ), newline ) )
FI
OD</
{{out}}
<pre>
Line 566 ⟶ 687:
=={{header|AppleScript}}==
<
on ludicsTo(n)
if (n < 1) then return {}
Line 627 ⟶ 748:
end doTask
return doTask()</
{{output}}
<
1, 2, 3, 5, 7, 11, 13, 17, 23, 25, 29, 37, 41, 43, 47, 53, 61, 67, 71, 77, 83, 89, 91, 97, 107
There are 142 ludic numbers ≤ 1000.
Line 636 ⟶ 757:
21475, 21481, 21487, 21493, 21503, 21511
Triplets < 250:
{1, 3, 7}, {5, 7, 11}, {11, 13, 17}, {23, 25, 29}, {41, 43, 47}, {173, 175, 179}, {221, 223, 227}, {233, 235, 239}"</
=={{header|Arturo}}==
<
result: [1]
lst: new 2..nmax+1
Line 676 ⟶ 797:
contains? ludics x+6
]
] 't -> @[t, t+2, t+6]</
{{out}}
Line 692 ⟶ 813:
=={{header|AutoHotkey}}==
{{works with|AutoHotkey 1.1}}
<
SetBatchLines, -1
Ludic := LudicSieve(22000)
Line 736 ⟶ 857:
Ludic.Insert(Arr[1])
return Ludic
}</
{{Output}}
<pre>First 25: 1 2 3 5 7 11 13 17 23 25 29 37 41 43 47 53 61 67 71 77 83 89 91 97 107
Line 744 ⟶ 865:
=={{header|C}}==
<
#include <stdlib.h>
Line 814 ⟶ 935:
free(x);
return 0;
}</
{{out}}
<pre>
Line 824 ⟶ 945:
=={{header|C sharp}}==
<
using System.Linq;
using System.Collections.Generic;
Line 891 ⟶ 1,012:
public int Prev { get; set; }
public int Next { get; set; }
}</
{{out}}
<pre>
Line 917 ⟶ 1,038:
=={{header|C++}}==
<
#include <vector>
#include <iostream>
Line 999 ⟶ 1,120:
return system( "pause" );
}
</syntaxhighlight>
{{out}}
<pre>
Line 1,022 ⟶ 1,143:
=={{header|Clojure}}==
<
(cons n (lazy-seq (ints-from (inc n)))))
Line 1,046 ⟶ 1,167:
(print "Triplets < 250: ")
(println (filter (partial every? ludic?)
(for [i (range 250)] (list i (+ i 2) (+ i 6)))))</
{{output}}
<pre>First 25: (1 2 3 5 7 11 13 17 23 25 29 37 41 43 47 53 61 67 71 77 83 89 91 97 107)
Line 1,054 ⟶ 1,175:
=={{header|Common Lisp}}==
<
(loop with numbers = (make-array (1+ max) :element-type 'boolean :initial-element t)
for i from 2 to max
Line 1,083 ⟶ 1,204:
when (and (find (+ x 2) numbers)
(find (+ x 6) numbers))
do (format t "~3D ~3D ~3D~%" x (+ x 2) (+ x 6))))</
{{output}}
<pre>First 25 ludic numbers:
Line 1,112 ⟶ 1,233:
{{trans|Python}}
{{trans|Raku}}
<
int opApply(int delegate(in ref T) dg) {
int result;
Line 1,162 ⟶ 1,283:
writefln("\nThere are %d triplets less than %d:\n%s",
triplets.length, m, triplets);
}</
{{out}}
<pre>First 25 ludic primes:
Line 1,179 ⟶ 1,300:
===Range Version===
This is the same code modified to be a Range.
<
T[] rotor, taken = [T(1)];
T i;
Line 1,236 ⟶ 1,357:
writefln("\nThere are %d triplets less than %d:\n%s",
triplets.length, m, triplets);
}</
The output is the same. This version is slower, it takes about 3.3 seconds to generate 50_000 Ludic numbers with ldc2 compiler.
===Range Generator Version===
<
import std.stdio, std.range, std.algorithm, std.concurrency;
Line 1,281 ⟶ 1,402:
writefln("\nThere are %d triplets less than %d:\n%s",
triplets.length, m, triplets);
}</
The result is the same.
=={{header|Delphi}}==
See [https://rosettacode.org/wiki/Ludic_numbers#Pascal Pascal].
=={{header|EasyLang}}==
{{trans|Nim}}
<syntaxhighlight>
proc initLudicArray n . res[] .
len res[] n
res[1] = 1
for i = 2 to n
k = 0
for j = i - 1 downto 2
k = k * res[j] div (res[j] - 1) + 1
.
res[i] = k + 2
.
.
initLudicArray 2005 arr[]
for i = 1 to 25
write arr[i] & " "
.
print ""
print ""
i = 1
while arr[i] <= 1000
cnt += 1
i += 1
.
print cnt
print ""
for i = 2000 to 2005
write arr[i] & " "
.
</syntaxhighlight>
{{out}}
<pre>
1 2 3 5 7 11 13 17 23 25 29 37 41 43 47 53 61 67 71 77 83 89 91 97 107
142
21475 21481 21487 21493 21503 21511
</pre>
=={{header|Eiffel}}==
<syntaxhighlight lang="eiffel">
class
LUDIC_NUMBERS
Line 1,378 ⟶ 1,539:
end
</syntaxhighlight>
Test:
<syntaxhighlight lang="eiffel">
class
APPLICATION
Line 1,421 ⟶ 1,582:
end
</syntaxhighlight>
{{out}}
<pre>
Line 1,441 ⟶ 1,602:
=={{header|Elixir}}==
{{works with|Elixir|1.3.1}}
<
def numbers(n \\ 100000) do
[h|t] = Enum.to_list(1..n)
Line 1,463 ⟶ 1,624:
end
Ludic.task</
{{out}}
Line 1,474 ⟶ 1,635:
=={{header|Factor}}==
<
prettyprint.config sequences sequences.extras ;
IN: rosetta-code.ludic-numbers
Line 1,494 ⟶ 1,655:
"Ludic numbers 2000 to 2005:\n%u\n" [ printf ] tri@ ;
MAIN: ludic-demo</
{{out}}
<pre>
Line 1,509 ⟶ 1,670:
=={{header|Fortran}}==
{{works with|Fortran|95 and later}}
<
implicit none
Line 1,561 ⟶ 1,722:
end do
end program</
Output:
<pre>First 25 Ludic numbers: 1 2 3 5 7 11 13 17 23 25 29 37 41 43 47 53 61 67 71 77 83 89 91 97 107
Line 1,569 ⟶ 1,730:
=={{header|FreeBASIC}}==
<
' As it would be too expensive to actually remove elements from the array
Line 1,674 ⟶ 1,835:
Print "Press any key to quit"
Sleep </
{{out}}
Line 1,699 ⟶ 1,860:
=={{header|Go}}==
<
import "fmt"
Line 1,779 ⟶ 1,940:
}
fmt.Println()
}</
[http://play.golang.org/p/pj7UmJnqoE Run in Go Playground].
{{out}}
Line 1,788 ⟶ 1,949:
=={{header|Haskell}}==
<
ludic :: [Integer]
Line 1,800 ⟶ 1,961:
(print . length) $ takeWhile (<= 1000) ludic
print $ take 6 $ drop 1999 ludic
-- haven't done triplets task yet</
{{out}}
<pre>
Line 1,809 ⟶ 1,970:
The filter for dropping every n-th number can be delayed until it's needed, which speeds up the generator, more so when a longer sequence is taken.
<
f n (x:xs) yy@((i,y):ys)
| n == i = f n (dropEvery y xs) ys
Line 1,817 ⟶ 1,978:
(a,b) = splitAt (n-1) s
main = print $ ludic !! 10000</
=={{header|Icon}} and {{header|Unicon}}==
This is inefficient, but was fun to code as a cascade of filters. Works in both languages.
<
procedure main(A)
Line 1,856 ⟶ 2,017:
if (count +:= 1) > limit then lds@&main
put(lds, ludic)
end</
Output:
Line 1,869 ⟶ 2,030:
=={{header|J}}==
'''Solution''' (''naive'' / ''brute force''):<
'''Examples''':<
25
ludic 110 NB. First 25 Ludic numbers
Line 1,891 ⟶ 2,052:
173 175 179
221 223 227
233 235 239</
=={{header|Java}}==
{{works with|Java|1.5+}}
This example uses pre-calculated ranges for the first and third task items (noted in comments).
<
import java.util.List;
Line 1,940 ⟶ 2,101:
System.out.println("Triplets up to 250: " + getTriplets(ludicUpTo(250)));
}
}</
{{out}}
<pre>First 25 Ludics: [1, 2, 3, 5, 7, 11, 13, 17, 23, 25, 29, 37, 41, 43, 47, 53, 61, 67, 71, 77, 83, 89, 91, 97, 107]
Line 1,949 ⟶ 2,110:
=={{header|JavaScript}}==
===ES6===
<syntaxhighlight lang="javascript">/**
* Boilerplate to simply get an array filled between 2 numbers
* @param {!number} s Start here (inclusive)
Line 2,013 ⟶ 2,174:
console.log([e, e + 2, e + 6].join(', '));
}
});</
<pre>
Line 2,041 ⟶ 2,202:
That is, an adaptive approach is taken.
<
# Input: an array to be sieved.
# Output: if the array length is less then $n then empty, else the sieved array.
Line 2,100 ⟶ 2,261:
( [250 | triplets]
| "\nThere are \(length) triplets less than 250:",
.[] )</
{{out}}
<pre>
Line 2,124 ⟶ 2,285:
=={{header|Julia}}==
<syntaxhighlight lang="julia">
function ludic_filter{T<:Integer}(n::T)
0 < n || throw(DomainError())
Line 2,186 ⟶ 2,347:
println(" ", i, ", ", j, ", ", k)
end
</syntaxhighlight>
{{out}}
Line 2,218 ⟶ 2,379:
=={{header|Kotlin}}==
{{trans|FreeBASIC}}
<
/* Rather than remove elements from a MutableList which would be a relatively expensive operation
Line 2,300 ⟶ 2,461:
}
}
}</
{{out}}
Line 2,324 ⟶ 2,485:
=={{header|Lua}}==
<
function ludics (limit)
local ludList, numList, index = {1}, {}
Line 2,369 ⟶ 2,530:
print(under1k .. " are less than or equal to 1000\n")
show("2000th to 2005th:", inRange)
show("Triplets:", triplets)</
{{out}}
<pre>First 25: 1 2 3 5 7 11 13 17 23 25 29 37 41 43 47 53 61 67 71 77 83 89 91 97 107
Line 2,388 ⟶ 2,549:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
Ludic={1};
seq=Range[2,n];
Line 2,402 ⟶ 2,563:
LengthWhile[Ludic, # < 1000 &]
Ludic[[2000 ;; 2005]]
Select[Subsets[Select[Ludic, # < 250 &], {3}], Differences[#] == {2, 4} &]</
{{out}}
<pre>{1, 2, 3, 5, 7, 11, 13, 17, 23, 25, 29, 37, 41, 43, 47, 53, 61, 67, 71, 77, 83, 89, 91, 97, 107}
Line 2,412 ⟶ 2,573:
Ludic number generation is inspired by Python lazy streaming generator.
Note that to store the ludic numbers we have chosen to use an array rather than a sequence, which allows to use 1-based indexes.
<
type LudicArray[N: static int] = array[1..N, int]
Line 2,466 ⟶ 2,627:
if ludicArray.isLudic(n + 2, i + 1) and ludicArray.isLudic(n + 6, i + 2):
line.addSep(", ")
line.add "($1, $2, $3)".format(n, n + 2, n + 6)</
{{out}}
Line 2,480 ⟶ 2,641:
=={{header|Objeck}}==
{{trans|Java}}
<
class Ludic {
Line 2,547 ⟶ 2,708:
}
}
</syntaxhighlight>
{{output}}
Line 2,567 ⟶ 2,728:
=={{header|Oforth}}==
<
| ludics l p |
ListBuffer newSize(n) seqFrom(2, n) over addAll ->l
Line 2,589 ⟶ 2,750:
l include(i 6 +) ifFalse: [ continue ]
i print ", " print i 2 + print ", " print i 6 + println
] ;</
{{out}}
Line 2,611 ⟶ 2,772:
===Version #1. Creating vector of ludic numbers' flags, where the index of each flag=1 is the ludic number.===
<
\\ Creating Vlf - Vector of ludic numbers' flags,
\\ where the index of each flag=1 is the ludic number.
Line 2,643 ⟶ 2,804:
for(i=1,250, if(Vr[i]&&Vr[i+2]&&Vr[i+6], print1("(",i," ",i+2," ",i+6,") ")));
}
</
{{Output}}
<pre>
Line 2,661 ⟶ 2,822:
Upgraded script from [http://oeis.org/A003309 A003309] to meet task requirements.
<
\\ Creating Vl - Vector of ludic numbers.
\\ 2/28/16 aev
Line 2,687 ⟶ 2,848:
for(i=1,vrs, vi=Vr[i]; if(i==1,print1("(",vi," ",vi+2," ",vi+6,") "); next); if(vi+6<250,if(Vr[i+1]==vi+2&&Vr[i+2]==vi+6, print1("(",vi," ",vi+2," ",vi+6,") "))));
}
</
{{Output}}
Line 2,707 ⟶ 2,868:
Inspired by "rotors" of Raku.
Runtime nearly quadratic: maxLudicCnt = 10000 -> 0.03 s =>maxLudicCnt= 100000 -> 3 s
<
{$IFDEF FPC}
{$MODE objFPC} // useful for x64
Line 2,850 ⟶ 3,011:
LastLucid(LudicList,maxLudicCnt,5);
triples(LudicList,250);//all-> (LudicList,LudicList[High(LudicList)].dNum);
END.</
{{Output}}
<pre>
Line 2,869 ⟶ 3,030:
Using an array of byte, each containing the distance to the next ludic number. 64-Bit needs only ~ 60% runtime of 32-Bit.
Three times slower than the Version 1. Much space left for improvements, like memorizing the count of ludics of intervals of size 1024 or so, to do bigger steps.Something like skiplist.
<
{$IFDEF FPC}{$MODE DELPHI}{$ELSE}{$APPTYPE CONSOLE}{$ENDIF}
uses
Line 3,019 ⟶ 3,180:
Firsttwentyfive;CountBelowOneThousand;Show2000til2005;ShowTriplets ;
setlength(Ludiclst,0)
END.</
{{Out}}
<pre>2005 ludic numbers upto 21511
Line 3,054 ⟶ 3,215:
=={{header|Perl}}==
The "ludic" subroutine caches the longest generated sequence so far. It also generates the candidates only if no candidates remain.
<
use warnings;
use strict;
Line 3,113 ⟶ 3,274:
say 'triplets < 250: ', join ' ',
map { '(' . join(' ',$_, $_ + 2, $_ + 6) . ')' }
sort { $a <=> $b } @triplet;</
{{out}}
<pre>First 25: 1 2 3 5 7 11 13 17 23 25 29 37 41 43 47 53 61 67 71 77 83 89 91 97 107
Line 3,122 ⟶ 3,283:
=={{header|Phix}}==
{{trans|Fortran}}
<!--<
<span style="color: #008080;">constant</span> <span style="color: #000000;">LUMAX</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">25000</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">ludic</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">LUMAX</span><span style="color: #0000FF;">)</span>
Line 3,167 ⟶ 3,328:
<span style="color: #008080;">end</span> <span style="color: #008080;">for</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;">"There are %d Ludic triplets below 250: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)})</span>
<!--</
{{out}}
<pre>
Line 3,175 ⟶ 3,336:
There are 8 Ludic triplets below 250: {{1,3,7},{5,7,11},{11,13,17},{23,25,29},{41,43,47},{173,175,179},{221,223,227},{233,235,239}}
</pre>
=={{header|Picat}}==
===Recursion===
<syntaxhighlight lang="picat">ludic(N) = Ludic =>
ludic(2..N, [1], Ludic).
ludic([], Ludic0, Ludic) =>
Ludic = Ludic0.reverse().
ludic(T, Ludic0, Ludic) =>
T2 = ludic_keep(T),
ludic(T2,[T[1]|Ludic0],Ludic).
% which elements to keep
ludic_keep([]) = [].
ludic_keep([H|List]) = Ludic =>
ludic_keep(H,1,List,[],Ludic).
ludic_keep(_H,_C,[],Ludic0,Ludic) ?=>
Ludic = Ludic0.reverse().
ludic_keep(H,C,[H1|T],Ludic0,Ludic) =>
(
C mod H > 0 ->
ludic_keep(H,C+1,T,[H1|Ludic0],Ludic)
;
ludic_keep(H,C+1,T,Ludic0,Ludic)
).</syntaxhighlight>
===Imperative approach===
<syntaxhighlight lang="picat">ludic2(N) = Ludic =>
A = 1..N,
Ludic = [1],
A := delete(A, 1),
while(A.length > 0)
T = A[1],
Ludic := Ludic ++ [T],
A := delete(A,T),
A := [A[J] : J in 1..A.length, J mod T > 0]
end.</syntaxhighlight>
===Test===
The recursive variant is about 10 times faster than the imperative.
<syntaxhighlight lang="picat">go =>
time(check(ludic)),
time(check(ludic2)),
nl.
check(LudicFunc) =>
println(ludicFunc=LudicFunc),
Ludic1000 = apply(LudicFunc,1000),
% first 25
println(first_25=Ludic1000[1..25]),
% below 1000
println(num_below_1000=Ludic1000.length),
% 2000..2005
Ludic22000 = apply(LudicFunc,22000),
println(len_22000=Ludic22000.length),
println(ludic_2000_2005=[Ludic22000[I] : I in 2000..2005]),
% Triplets
Ludic2500 = apply(LudicFunc,2500),
Triplets=[[N,N+2,N+6] : N in 1..Ludic2500.length,
membchk(N,Ludic2500),
membchk(N+2,Ludic2500),
membchk(N+6,Ludic2500)],
foreach(Triplet in Triplets)
println(Triplet)
end,
nl.
</syntaxhighlight>
{{out}}
<pre>ludicFunc = ludic
first_25 = [1,2,3,5,7,11,13,17,23,25,29,37,41,43,47,53,61,67,71,77,83,89,91,97,107]
num_below_1000 = 142
len_22000 = 2042
ludic_2000_2005 = [21475,21481,21487,21493,21503,21511]
[1,3,7]
[5,7,11]
[11,13,17]
[23,25,29]
[41,43,47]
[173,175,179]
[221,223,227]
[233,235,239]
CPU time 0.288 seconds.
ludicFunc = ludic2
first_25 = [1,2,3,5,7,11,13,17,23,25,29,37,41,43,47,53,61,67,71,77,83,89,91,97,107]
num_below_1000 = 142
len_22000 = 2042
ludic_2000_2005 = [21475,21481,21487,21493,21503,21511]
[1,3,7]
[5,7,11]
[11,13,17]
[23,25,29]
[41,43,47]
[173,175,179]
[221,223,227]
[233,235,239]
CPU time 2.835 seconds.</pre>
=={{header|PicoLisp}}==
<
(let N (car Lst)
(make
Line 3,216 ⟶ 3,483:
(filter '((X) (< X 250)) L) ) ) ) )
(bye)</
{{out}}<pre>
(1 2 3 5 7 11 13 17 23 25 29 37 41 43 47 53 61 67 71 77 83 89 91 97 107)
Line 3,225 ⟶ 3,492:
=={{header|PL/I}}==
<
declare V(2:22000) fixed, L(2200) fixed;
declare (step, i, j, k, n) fixed binary;
Line 3,277 ⟶ 3,544:
call Ludic;
end Ludic_numbers;</
Output:
<pre>The first 25 Ludic numbers are:
Line 3,290 ⟶ 3,557:
=={{header|PL/SQL}}==
<
DECLARE
c_limit CONSTANT PLS_INTEGER := 25000;
Line 3,368 ⟶ 3,635:
END;
/
</syntaxhighlight>
{{out}}
Line 3,390 ⟶ 3,657:
=={{header|PowerShell}}==
{{works with|PowerShell|2}}
<syntaxhighlight lang="powershell">
# Start with a pool large enough to meet the requirements
$Pool = [System.Collections.ArrayList]( 2..22000 )
Line 3,409 ⟶ 3,676:
# Add the rest of the numbers in the pool to the list of Ludic numbers
$Ludic += $Pool.ToArray()
</syntaxhighlight>
<syntaxhighlight lang="powershell">
# Display the first 25 Ludic numbers
$Ludic[0..24] -join ", "
Line 3,426 ⟶ 3,693:
$TripletStart = $Ludic.Where{ $_ -lt 244 -and ( $_ + 2 ) -in $Ludic -and ( $_ + 6 ) -in $Ludic }
$TripletStart.ForEach{ $_, ( $_ + 2 ), ( $_ + 6 ) -join ", " }
</syntaxhighlight>
{{out}}
<pre>
Line 3,443 ⟶ 3,710:
221, 223, 227
233, 235, 239
</pre>
=={{header|Prolog}}==
Simple, straightforward implementation
<syntaxhighlight lang="prolog">
% John Devou: 26-Nov-2021
d(_,_,[],[]).
d(N,N,[_|Xs],Rs):- d(N,1,Xs,Rs).
d(N,M,[X|Xs],[X|Rs]):- M < N, M_ is M+1, d(N,M_,Xs,Rs).
l([],[]).
l([X|Xs],[X|Rs]):- d(X,1,Xs,Ys), l(Ys,Rs).
% g(N,L):- generate in L a list with Ludic numbers up to N
g(N,[1|X]):- numlist(2,N,L), l(L,X).
s(0,Xs,[],Xs).
s(N,[X|Xs],[X|Ls],Rs):- N > 0, M is N-1, s(M,Xs,Ls,Rs).
t([X,Y,Z|_],[X,Y,Z]):- Y =:= X+2, Z =:= X+6.
t([_,Y,Z|Xs],R):- t([Y,Z|Xs],R).
% tasks
t1:- g(500,L), s(25,L,X,_), write(X), !.
t2:- g(1000,L), length(L,X), write(X), !.
t3:- g(22000,L), s(1999,L,_,R), s(6,R,X,_), write(X), !.
t4:- g(249,L), findall(A, t(L,A), X), write(X), !.
</syntaxhighlight>
{{out}}
<pre>
?- t1.
[1,2,3,5,7,11,13,17,23,25,29,37,41,43,47,53,61,67,71,77,83,89,91,97,107]
true.
?- t2.
142
true.
?- t3.
[21475,21481,21487,21493,21503,21511]
true.
?- t4.
[[5,7,11],[11,13,17],[23,25,29],[41,43,47],[173,175,179],[221,223,227],[233,235,239]]
true.
</pre>
=={{header|PureBasic}}==
<
If Not OpenConsole() : End 1 : EndIf
Line 3,484 ⟶ 3,799:
PrintN("Ludic Triplets below 250: " +r4$)
Input()
End</
{{out}}
<pre>First 25 Ludic numbers: 1 2 3 5 7 11 13 17 23 25 29 37 41 43 47 53 61 67 71 77 83 89 91 97 107
Line 3,494 ⟶ 3,809:
=={{header|Python}}==
===Python: Fast===
<
yield 1
lst = list(range(2, nmax + 1))
Line 3,515 ⟶ 3,830:
if x+6 < n and x+2 in ludics and x+6 in ludics]
print('\nThere are %i triplets less than %i:\n %r'
% (len(triplets), n, triplets))</
{{out}}
Line 3,531 ⟶ 3,846:
===Python: No set maximum===
The following version of function ludic will return ludic numbers until reaching system limits. It is less efficient than the fast version as all lucid numbers so far are cached; on exhausting the current lst a new list of twice the size is created and the previous deletions applied before continuing.
<
yield 1
taken = []
Line 3,542 ⟶ 3,857:
taken.append(t)
yield t
del lst[::t]</
Output is the same as for the fast version.
Line 3,551 ⟶ 3,866:
<br>Based on the similar algorithm for lucky numbers at https://oeis.org/A000959/a000959.txt.
<br>Function triplets wraps ludic and uses a similar stream-filtering approach to find triplets.
<
yield 1
ludics = []
Line 3,586 ⟶ 3,901:
break
print(f'[{a}, {b}, {c}]')
</syntaxhighlight>
{{out}}
<pre>First 25 ludic numbers: [1, 2, 3, 5, 7, 11, 13, 17, 23, 25, 29, 37, 41, 43, 47, 53, 61, 67, 71, 77, 83, 89, 91, 97, 107]
Line 3,601 ⟶ 3,916:
[233, 235, 239]
</pre>
=={{header|Quackery}}==
<syntaxhighlight lang="Quackery"> [ 0 over of
swap times
[ i 1+ swap i poke ]
1 split
[ dup 0 peek
rot over join unrot
over size over > while
1 - temp put
[] swap
[ behead drop
temp share split
dip join
dup [] = until ]
drop temp release
again ]
drop behead drop join ] is ludic ( n --> [ )
999 ludic
say "First 25 ludic numbers: "
dup 25 split drop echo
cr cr
say "There are "
size echo
say " ludic numbers less than 1000."
cr cr
25000 ludic
say "Ludic numbers 2000 to 2005: "
1999 split nip 6 split drop echo</syntaxhighlight>
{{out}}
<pre>First 25 ludic numbers: [ 1 2 3 5 7 11 13 17 23 25 29 37 41 43 47 53 61 67 71 77 83 89 91 97 107 ]
There are 142 ludic numbers less than 1000.
Ludic numbers 2000 to 2005: [ 21475 21481 21487 21493 21503 21511 ]</pre>
=={{header|Racket}}==
<
(define lucid-sieve-size 25000) ; this should be enough to do me!
(define lucid?
Line 3,642 ⟶ 3,996:
EOS
(for/list ((x (in-range 250)) #:when (and (lucid? x) (lucid? (+ x 2)) (lucid? (+ x 6))))
(list x (+ x 2) (+ x 6))))</
{{out}}
Line 3,660 ⟶ 4,014:
{{works with|rakudo|2015-09-18}}
This implementation has no arbitrary upper limit, since it can keep adding new rotors on the fly. It just gets slower and slower instead... <tt>:-)</tt>
<syntaxhighlight lang="raku"
my @taken = take 1;
my @rotor;
Line 3,688 ⟶ 4,042:
my $c = $a + 6;
take "<$a $b $c>" if $b ∈ l250 and $c ∈ l250;
}</
{{out}}
<pre>(1 2 3 5 7 11 13 17 23 25 29 37 41 43 47 53 61 67 71 77 83 89 91 97 107)
Line 3,696 ⟶ 4,050:
=={{header|REXX}}==
<
parse arg N count bot top triples . /*obtain optional arguments from the CL*/
if N=='' | N=="," then N= 25 /*Not specified? Then use the default.*/
Line 3,736 ⟶ 4,090:
@= translate(@, , .) /*change dots to blanks; count numbers.*/
end /*while*/ /* [↑] done eliding ludic numbers. */
return subword($, 1, m) /*return a range of ludic numbers. */</
Some older REXXes don't have a '''changestr''' BIF, so one is included here ──► [[CHANGESTR.REX]].
<br><br>
Line 3,751 ⟶ 4,105:
=={{header|Ring}}==
<
# Project : Ludic numbers
Line 3,824 ⟶ 4,178:
see svect
see "]" + nl
</syntaxhighlight>
Output:
<pre>
Line 3,837 ⟶ 4,191:
=={{header|Ruby}}==
<
Enumerator.new do |y|
y << 1
Line 3,857 ⟶ 4,211:
ludics = ludic(250).to_a
puts "Ludic triples below 250:",
ludics.select{|x| ludics.include?(x+2) and ludics.include?(x+6)}.map{|x| [x, x+2, x+6]}.to_s</
{{out}}
<pre>
Line 3,871 ⟶ 4,225:
=={{header|Rust}}==
<
const ARRAY_MAX: usize = 25_000;
const LUDIC_MAX: usize = 2100;
Line 3,969 ⟶ 4,323:
}
}
</syntaxhighlight>
{{out}}
<pre>
Line 3,992 ⟶ 4,346:
In this example, we define a function to drop every n<sup>th</sup> element from a list and use it to build a lazily evaluated list of all Ludic numbers. We then generate a lazy list of triplets and filter for the triplets of Ludic numbers.
<
def main(args: Array[String]): Unit = {
println(
Line 4,004 ⟶ 4,358:
def ludic: LazyList[Int] = 1 #:: LazyList.unfold(LazyList.from(2)){case n +: ns => Some((n, dropByN(ns, n)))}
def triplets: LazyList[(Int, Int, Int)] = LazyList.from(1).map(n => (n, n + 2, n + 6)).filter{case (a, b, c) => Seq(a, b, c).forall(ludic.takeWhile(_ <= c).contains)}
}</
{{out}}
Line 4,013 ⟶ 4,367:
=={{header|Seed7}}==
<
const func set of integer: ludicNumbers (in integer: n) is func
Line 4,073 ⟶ 4,427:
end for;
writeln;
end func;</
{{out}}
Line 4,084 ⟶ 4,438:
=={{header|SequenceL}}==
<syntaxhighlight lang="sequencel">
import <Utilities/Set.sl>;
Line 4,111 ⟶ 4,465:
"\n\nLudic 2000 to 2005:\n" ++ toString(ludics[2000...2005]) ++
"\n\nTriples below 250:\n" ++ toString(triplets) ;
</syntaxhighlight>
{{out}}
<pre>
Line 4,129 ⟶ 4,483:
=={{header|Sidef}}==
{{trans|Ruby}}
<
Enumerator({ |collect|
collect(1)
Line 4,152 ⟶ 4,506:
say("Ludic triples below 250: ", a.grep{|x| a.contains_all([x+2, x+6]) } \
.map {|x| '(' + [x, x+2, x+6].join(' ') + ')' } \
.join(' '))</
{{out}}
<pre>
Line 4,162 ⟶ 4,516:
=={{header|Standard ML}}==
<syntaxhighlight lang="ocaml">
open List;
Line 4,183 ⟶ 4,537:
length (filter (fn e=> e <= 1000) ludics);
drop (take (ludics,2005),1999);
</syntaxhighlight>
output
<pre>
Line 4,194 ⟶ 4,548:
{{works with|Tcl|8.6}}
The limit on the number of values generated is the depth of stack; this can be set to arbitrarily deep to go as far as you want. Provided you are prepared to wait for the values to be generated.
<
proc ludic n {
Line 4,236 ⟶ 4,590:
}
}
puts "triplets: [join $l ,]"</
{{out}}
<pre>
Line 4,246 ⟶ 4,600:
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
Set list = CreateObject("System.Collections.Arraylist")
Set ludic = CreateObject("System.Collections.Arraylist")
Line 4,320 ⟶ 4,674:
Loop
WScript.StdOut.WriteLine triplets
</syntaxhighlight>
{{Out}}
Line 4,342 ⟶ 4,696:
221, 223, 227
233, 235, 239
</pre>
=={{header|V (Vlang)}}==
{{trans|Go}}
<syntaxhighlight lang="v (vlang)">const max_i32 = 1<<31 - 1 // i.e. math.MaxInt32
// ludic returns a slice of ludic numbers stopping after
// either n entries or when max is exceeded.
// Either argument may be <=0 to disable that limit.
fn ludic(nn int, m int) []u32 {
mut n := nn
mut max := m
if max > 0 && n < 0 {
n = max_i32
}
if n < 1 {
return []
}
if max < 0 {
max = max_i32
}
mut sieve := []u32{len: 10760} // XXX big enough for 2005 ludics
sieve[0] = 1
sieve[1] = 2
if n > 2 {
// We start with even numbers already removed
for i, j := 2, u32(3); i < sieve.len; i, j = i+1, j+2 {
sieve[i] = j
}
// We leave the ludic numbers in place,
// k is the index of the next ludic
for k := 2; k < n; k++ {
mut l := int(sieve[k])
if l >= max {
n = k
break
}
mut i := l
l--
// last is the last valid index
mut last := k + i - 1
for j := k + i + 1; j < sieve.len; i, j = i+1, j+1 {
last = k + i
sieve[last] = sieve[j]
if i%l == 0 {
j++
}
}
// Truncate down to only the valid entries
if last < sieve.len-1 {
sieve = sieve[..last+1]
}
}
}
if n > sieve.len {
panic("program error") // should never happen
}
return sieve[..n]
}
fn has(x []u32, v u32) bool {
for i := 0; i < x.len && x[i] <= v; i++ {
if x[i] == v {
return true
}
}
return false
}
fn main() {
// ludic() is so quick we just call it repeatedly
println("First 25: ${ludic(25, -1)}")
println("Numner of ludics below 1000: ${ludic(-1, 1000).len}")
println("ludic 2000 to 2005: ${ludic(2005, -1)[1999..]}")
print("Tripples below 250:")
x := ludic(-1, 250)
for i, v in x[..x.len-2] {
if has(x[i+1..], v+2) && has(x[i+2..], v+6) {
print(", ($v ${v+2} ${v+6})")
}
}
println('')
}</syntaxhighlight>
{{out}}
<pre>
First 25: [1, 2, 3, 5, 7, 11, 13, 17, 23, 25, 29, 37, 41, 43, 47, 53, 61, 67, 71, 77, 83, 89, 91, 97, 107]
Numner of ludics below 1000: 142
ludic 2000 to 2005: [21475, 21481, 21487, 21493, 21503, 21511]
Tripples below 250:, (1 3 7), (5 7 11), (11 13 17), (23 25 29), (41 43 47), (173 175 179), (221 223 227), (233 235 239)
</pre>
Line 4,347 ⟶ 4,791:
{{trans|Go}}
{{libheader|Wren-fmt}}
<
var ludic = Fn.new { |n, max|
Line 4,409 ⟶ 4,853:
i = i + 1
}
System.print(triples)</
{{out}}
Line 4,420 ⟶ 4,864:
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang "XPL0">def Size = 25000;
char Sieve(1+Size);
int I, Count, Ludic;
[\Make sieve for Ludic numbers
for I:= 1 to Size do Sieve(I):= true;
Ludic:= 2;
loop [I:= Ludic; Count:= Ludic;
loop [repeat I:= I+1;
if I > Size then quit;
until Sieve(I);
Count:= Count-1;
if Count = 0 then
[Sieve(I):= false;
Count:= Ludic;
];
];
repeat Ludic:= Ludic+1;
if Ludic > Size then quit;
until Sieve(Ludic);
];
\Show first 25 Ludic numbers
Count:= 0; I:= 1;
loop [if Sieve(I) then
[IntOut(0, I); ChOut(0, ^ );
Count:= Count+1;
if Count >= 25 then quit;
];
I:= I+1;
];
CrLf(0);
\Show how many Ludic numbers are <= 1000
Count:= 0;
for I:= 1 to 1000 do
if Sieve(I) then Count:= Count+1;
IntOut(0, Count);
CrLf(0);
\Show Ludic numbers from 2000 to 2005
Count:= 0; I:= 1;
loop [if Sieve(I) then
[Count:= Count+1;
if Count >= 2000 then
[IntOut(0, I); ChOut(0, ^ )];
if Count >= 2005 then quit;
];
I:= I+1;
];
CrLf(0);
\Show triplets of Ludic numbers < 250
for I:= 1 to 250-1-6 do
if Sieve(I) & Sieve(I+2) & Sieve(I+6) then
[ChOut(0, ^();
IntOut(0, I); ChOut(0, ^ );
IntOut(0, I+2); ChOut(0, ^ );
IntOut(0, I+6); Text(0, ") ");
];
CrLf(0);
]</syntaxhighlight>
{{out}}
<pre>
1 2 3 5 7 11 13 17 23 25 29 37 41 43 47 53 61 67 71 77 83 89 91 97 107
142
21475 21481 21487 21493 21503 21511
(1 3 7) (5 7 11) (11 13 17) (23 25 29) (41 43 47) (173 175 179) (221 223 227) (233 235 239)
</pre>
=={{header|zkl}}==
This solution builds an iterator with filters, one for each Ludic number, each extending the previous filter. A "master" iterator sits at the top and provides the interface. When the next Ludic number is requested, the next odd number sent down the list of filters and if it makes to the end, it is the next Ludic number. A new filter is then attached [to the iterator] with a starting index of 1 and which indexes to strike.
<
seq.tweak(fcn(n,skipper,idx){ if(0==idx.inc()%skipper) Void.Skip else n }
.fp1(n,Ref(1))) // skip every nth number of previous sequence
Line 4,431 ⟶ 4,940:
.fp(Ref([3..*,2]))) // odd numbers starting at 3
.push(1,2); // first two Ludic numbers
}</
<
ludic().reduce(fcn(sum,n){ if(n<1000) return(sum+1); return(Void.Stop,sum); },0).println();
ludic().drop(1999).walk(6).println(); // Ludic's between 2000 & 2005
ls:=ludic().filter(fcn(n){ (n<250) and True or Void.Stop }); // Ludic's < 250
ls.filter('wrap(n){ ls.holds(n+2) and ls.holds(n+6) }).apply(fcn(n){ T(n,n+2,n+6) }).println();</
{{out}}
<pre>
| |||