Ludic numbers: Difference between revisions

m
syntax highlighting fixup automation
(→‎{{header|Picat}}: Split into subsections. Added {{out}})
m (syntax highlighting fixup automation)
Line 45:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">F ludic(nmax = 100000)
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))</langsyntaxhighlight>
 
{{out}}
Line 86:
=={{header|360 Assembly}}==
{{trans|Fortran}}
<langsyntaxhighlight lang="360asm">* Ludic numbers 23/04/2016
LUDICN CSECT
USING LUDICN,R15 set base register
Line 207:
LUDIC DC 25000X'01' ludic(nmax)=true
YREGS
END LUDICN</langsyntaxhighlight>
{{out}}
<pre>
Line 231:
=={{header|ABAP}}==
Works with NW 7.40 SP8
<langsyntaxhighlight ABAPlang="abap">CLASS lcl_ludic DEFINITION CREATE PUBLIC.
 
PUBLIC SECTION.
Line 317:
ENDMETHOD.
 
ENDCLASS.</langsyntaxhighlight>
 
{{Output}}
Line 372:
=={{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.
<langsyntaxhighlight Actionlang="action!">DEFINE NOTLUDIC="0"
DEFINE LUDIC="1"
DEFINE UNKNOWN="2"
Line 468:
PrintE("Ludic triplets below 250")
PrintLudicTriplets(lud,249)
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Ludic_numbers.png Screenshot from Atari 8-bit computer]
Line 492:
 
=={{header|Ada}}==
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO;
with Ada.Containers.Vectors;
 
Line 591:
Last => 2005);
Find_Triplets (Limit => 250);
end Ludic_Numbers;</langsyntaxhighlight>
 
{{out}}
Line 610:
 
=={{header|ALGOL 68}}==
<langsyntaxhighlight lang="algol68"># find some Ludic numbers #
 
# sieve the Ludic numbers up to 30 000 #
Line 668:
print( ( " ", whole( n, -3 ), ", ", whole( n + 2, -3 ), ", ", whole( n + 6, -3 ), newline ) )
FI
OD</langsyntaxhighlight>
{{out}}
<pre>
Line 687:
=={{header|AppleScript}}==
 
<langsyntaxhighlight lang="applescript">-- Generate a list of the ludic numbers up to and including n.
on ludicsTo(n)
if (n < 1) then return {}
Line 748:
end doTask
 
return doTask()</langsyntaxhighlight>
 
{{output}}
<langsyntaxhighlight lang="applescript">"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.
Line 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}"</langsyntaxhighlight>
 
=={{header|Arturo}}==
 
<langsyntaxhighlight lang="rebol">ludicGen: function [nmax][
result: [1]
lst: new 2..nmax+1
Line 797:
contains? ludics x+6
]
] 't -> @[t, t+2, t+6]</langsyntaxhighlight>
 
{{out}}
Line 813:
=={{header|AutoHotkey}}==
{{works with|AutoHotkey 1.1}}
<langsyntaxhighlight AutoHotkeylang="autohotkey">#NoEnv
SetBatchLines, -1
Ludic := LudicSieve(22000)
Line 857:
Ludic.Insert(Arr[1])
return Ludic
}</langsyntaxhighlight>
{{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 865:
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
 
Line 935:
free(x);
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>
Line 945:
 
=={{header|C sharp}}==
<langsyntaxhighlight lang="csharp">using System;
using System.Linq;
using System.Collections.Generic;
Line 1,012:
public int Prev { get; set; }
public int Next { get; set; }
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,038:
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">
#include <vector>
#include <iostream>
Line 1,120:
return system( "pause" );
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,143:
 
=={{header|Clojure}}==
<langsyntaxhighlight lang="clojure">(defn ints-from [n]
(cons n (lazy-seq (ints-from (inc n)))))
 
Line 1,167:
(print "Triplets < 250: ")
(println (filter (partial every? ludic?)
(for [i (range 250)] (list i (+ i 2) (+ i 6)))))</langsyntaxhighlight>
{{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,175:
 
=={{header|Common Lisp}}==
<langsyntaxhighlight lang="lisp">(defun ludic-numbers (max &optional n)
(loop with numbers = (make-array (1+ max) :element-type 'boolean :initial-element t)
for i from 2 to max
Line 1,204:
when (and (find (+ x 2) numbers)
(find (+ x 6) numbers))
do (format t "~3D ~3D ~3D~%" x (+ x 2) (+ x 6))))</langsyntaxhighlight>
{{output}}
<pre>First 25 ludic numbers:
Line 1,233:
{{trans|Python}}
{{trans|Raku}}
<langsyntaxhighlight lang="d">struct Ludics(T) {
int opApply(int delegate(in ref T) dg) {
int result;
Line 1,283:
writefln("\nThere are %d triplets less than %d:\n%s",
triplets.length, m, triplets);
}</langsyntaxhighlight>
{{out}}
<pre>First 25 ludic primes:
Line 1,300:
===Range Version===
This is the same code modified to be a Range.
<langsyntaxhighlight lang="d">struct Ludics(T) {
T[] rotor, taken = [T(1)];
T i;
Line 1,357:
writefln("\nThere are %d triplets less than %d:\n%s",
triplets.length, m, triplets);
}</langsyntaxhighlight>
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===
<langsyntaxhighlight lang="d">void main() {
import std.stdio, std.range, std.algorithm, std.concurrency;
 
Line 1,402:
writefln("\nThere are %d triplets less than %d:\n%s",
triplets.length, m, triplets);
}</langsyntaxhighlight>
The result is the same.
 
Line 1,409:
 
=={{header|Eiffel}}==
<syntaxhighlight lang="eiffel">
<lang Eiffel>
class
LUDIC_NUMBERS
Line 1,499:
 
end
</syntaxhighlight>
</lang>
Test:
<syntaxhighlight lang="eiffel">
<lang Eiffel>
class
APPLICATION
Line 1,542:
 
end
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,562:
=={{header|Elixir}}==
{{works with|Elixir|1.3.1}}
<langsyntaxhighlight lang="elixir">defmodule Ludic do
def numbers(n \\ 100000) do
[h|t] = Enum.to_list(1..n)
Line 1,584:
end
 
Ludic.task</langsyntaxhighlight>
 
{{out}}
Line 1,595:
 
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">USING: formatting fry kernel make math math.ranges namespaces
prettyprint.config sequences sequences.extras ;
IN: rosetta-code.ludic-numbers
Line 1,615:
"Ludic numbers 2000 to 2005:\n%u\n" [ printf ] tri@ ;
 
MAIN: ludic-demo</langsyntaxhighlight>
{{out}}
<pre>
Line 1,630:
=={{header|Fortran}}==
{{works with|Fortran|95 and later}}
<langsyntaxhighlight lang="fortran">program ludic_numbers
implicit none
Line 1,682:
end do
 
end program</langsyntaxhighlight>
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,690:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">' FB 1.05.0 Win64
 
' As it would be too expensive to actually remove elements from the array
Line 1,795:
 
Print "Press any key to quit"
Sleep </langsyntaxhighlight>
 
{{out}}
Line 1,820:
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 1,900:
}
fmt.Println()
}</langsyntaxhighlight>
[http://play.golang.org/p/pj7UmJnqoE Run in Go Playground].
{{out}}
Line 1,909:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Data.List (unfoldr, genericSplitAt)
 
ludic :: [Integer]
Line 1,921:
(print . length) $ takeWhile (<= 1000) ludic
print $ take 6 $ drop 1999 ludic
-- haven't done triplets task yet</langsyntaxhighlight>
{{out}}
<pre>
Line 1,930:
 
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.
<langsyntaxhighlight lang="haskell">ludic = 1:2 : f 3 [3..] [(4,2)] where
f n (x:xs) yy@((i,y):ys)
| n == i = f n (dropEvery y xs) ys
Line 1,938:
(a,b) = splitAt (n-1) s
 
main = print $ ludic !! 10000</langsyntaxhighlight>
 
=={{header|Icon}} and {{header|Unicon}}==
 
This is inefficient, but was fun to code as a cascade of filters. Works in both languages.
<langsyntaxhighlight lang="unicon">global num, cascade, sieve, nfilter
 
procedure main(A)
Line 1,977:
if (count +:= 1) > limit then lds@&main
put(lds, ludic)
end</langsyntaxhighlight>
 
Output:
Line 1,990:
 
=={{header|J}}==
'''Solution''' (''naive'' / ''brute force''):<langsyntaxhighlight lang="j"> ludic =: _1 |.!.1 [: {."1 [: (#~ 0 ~: {. | i.@#)^:a: 2 + i.</langsyntaxhighlight>
'''Examples''':<langsyntaxhighlight lang="j"> # ludic 110 NB. 110 is sufficient to generate 25 Ludic numbers
25
ludic 110 NB. First 25 Ludic numbers
Line 2,012:
173 175 179
221 223 227
233 235 239</langsyntaxhighlight>
 
=={{header|Java}}==
{{works with|Java|1.5+}}
This example uses pre-calculated ranges for the first and third task items (noted in comments).
<langsyntaxhighlight lang="java5">import java.util.ArrayList;
import java.util.List;
 
Line 2,061:
System.out.println("Triplets up to 250: " + getTriplets(ludicUpTo(250)));
}
}</langsyntaxhighlight>
{{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 2,070:
=={{header|JavaScript}}==
===ES6===
<syntaxhighlight lang="javascript">/**
<lang JavaScript>/**
* Boilerplate to simply get an array filled between 2 numbers
* @param {!number} s Start here (inclusive)
Line 2,134:
console.log([e, e + 2, e + 6].join(', '));
}
});</langsyntaxhighlight>
 
<pre>
Line 2,162:
That is, an adaptive approach is taken.
 
<langsyntaxhighlight lang="jq"># This method for sieving turns out to be the fastest in jq.
# Input: an array to be sieved.
# Output: if the array length is less then $n then empty, else the sieved array.
Line 2,221:
( [250 | triplets]
| "\nThere are \(length) triplets less than 250:",
.[] )</langsyntaxhighlight>
{{out}}
<pre>
Line 2,245:
 
=={{header|Julia}}==
<syntaxhighlight lang="julia">
<lang Julia>
function ludic_filter{T<:Integer}(n::T)
0 < n || throw(DomainError())
Line 2,307:
println(" ", i, ", ", j, ", ", k)
end
</syntaxhighlight>
</lang>
 
{{out}}
Line 2,339:
=={{header|Kotlin}}==
{{trans|FreeBASIC}}
<langsyntaxhighlight lang="scala">// version 1.0.6
 
/* Rather than remove elements from a MutableList which would be a relatively expensive operation
Line 2,421:
}
}
}</langsyntaxhighlight>
 
{{out}}
Line 2,445:
 
=={{header|Lua}}==
<langsyntaxhighlight Lualang="lua">-- Return table of ludic numbers below limit
function ludics (limit)
local ludList, numList, index = {1}, {}
Line 2,490:
print(under1k .. " are less than or equal to 1000\n")
show("2000th to 2005th:", inRange)
show("Triplets:", triplets)</langsyntaxhighlight>
{{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,509:
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">n=10^5;
Ludic={1};
seq=Range[2,n];
Line 2,523:
LengthWhile[Ludic, # < 1000 &]
Ludic[[2000 ;; 2005]]
Select[Subsets[Select[Ludic, # < 250 &], {3}], Differences[#] == {2, 4} &]</langsyntaxhighlight>
{{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,533:
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.
<langsyntaxhighlight Nimlang="nim">import strutils
 
type LudicArray[N: static int] = array[1..N, int]
Line 2,587:
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)</langsyntaxhighlight>
 
{{out}}
Line 2,601:
=={{header|Objeck}}==
{{trans|Java}}
<langsyntaxhighlight lang="objeck">use Collection.Generic;
 
class Ludic {
Line 2,668:
}
}
</syntaxhighlight>
</lang>
 
{{output}}
Line 2,688:
=={{header|Oforth}}==
 
<langsyntaxhighlight Oforthlang="oforth">: ludic(n)
| ludics l p |
ListBuffer newSize(n) seqFrom(2, n) over addAll ->l
Line 2,710:
l include(i 6 +) ifFalse: [ continue ]
i print ", " print i 2 + print ", " print i 6 + println
] ;</langsyntaxhighlight>
 
{{out}}
Line 2,732:
===Version #1. Creating vector of ludic numbers' flags, where the index of each flag=1 is the ludic number.===
 
<langsyntaxhighlight lang="parigp">
\\ Creating Vlf - Vector of ludic numbers' flags,
\\ where the index of each flag=1 is the ludic number.
Line 2,764:
for(i=1,250, if(Vr[i]&&Vr[i+2]&&Vr[i+6], print1("(",i," ",i+2," ",i+6,") ")));
}
</langsyntaxhighlight>
{{Output}}
<pre>
Line 2,782:
Upgraded script from [http://oeis.org/A003309 A003309] to meet task requirements.
 
<langsyntaxhighlight lang="parigp">
\\ Creating Vl - Vector of ludic numbers.
\\ 2/28/16 aev
Line 2,808:
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,") "))));
}
</langsyntaxhighlight>
 
{{Output}}
Line 2,828:
Inspired by "rotors" of Raku.
Runtime nearly quadratic: maxLudicCnt = 10000 -> 0.03 s =>maxLudicCnt= 100000 -> 3 s
<langsyntaxhighlight lang="pascal">program lucid;
{$IFDEF FPC}
{$MODE objFPC} // useful for x64
Line 2,971:
LastLucid(LudicList,maxLudicCnt,5);
triples(LudicList,250);//all-> (LudicList,LudicList[High(LudicList)].dNum);
END.</langsyntaxhighlight>
{{Output}}
<pre>
Line 2,990:
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.
<langsyntaxhighlight lang="pascal">program ludic;
{$IFDEF FPC}{$MODE DELPHI}{$ELSE}{$APPTYPE CONSOLE}{$ENDIF}
uses
Line 3,140:
Firsttwentyfive;CountBelowOneThousand;Show2000til2005;ShowTriplets ;
setlength(Ludiclst,0)
END.</langsyntaxhighlight>
{{Out}}
<pre>2005 ludic numbers upto 21511
Line 3,175:
=={{header|Perl}}==
The "ludic" subroutine caches the longest generated sequence so far. It also generates the candidates only if no candidates remain.
<langsyntaxhighlight lang="perl">#!/usr/bin/perl
use warnings;
use strict;
Line 3,234:
say 'triplets < 250: ', join ' ',
map { '(' . join(' ',$_, $_ + 2, $_ + 6) . ')' }
sort { $a <=> $b } @triplet;</langsyntaxhighlight>
{{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,243:
=={{header|Phix}}==
{{trans|Fortran}}
<!--<langsyntaxhighlight Phixlang="phix">-->
<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,288:
<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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 3,299:
=={{header|Picat}}==
===Recursion===
<langsyntaxhighlight Picatlang="picat">ludic(N) = Ludic =>
ludic(2..N, [1], Ludic).
ludic([], Ludic0, Ludic) =>
Line 3,320:
;
ludic_keep(H,C+1,T,Ludic0,Ludic)
).</langsyntaxhighlight>
 
===Imperative approach===
<langsyntaxhighlight Picatlang="picat">ludic2(N) = Ludic =>
A = 1..N,
Ludic = [1],
Line 3,332:
A := delete(A,T),
A := [A[J] : J in 1..A.length, J mod T > 0]
end.</langsyntaxhighlight>
 
===Test===
The recursive variant is about 10 times faster than the imperative.
<langsyntaxhighlight Picatlang="picat">go =>
time(check(ludic)),
time(check(ludic2)),
Line 3,368:
nl.
 
</syntaxhighlight>
</lang>
 
{{out}}
Line 3,404:
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(de drop (Lst)
(let N (car Lst)
(make
Line 3,443:
(filter '((X) (< X 250)) L) ) ) ) )
(bye)</langsyntaxhighlight>
{{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,452:
=={{header|PL/I}}==
 
<langsyntaxhighlight PLlang="pl/Ii">Ludic_numbers: procedure options (main); /* 18 April 2014 */
declare V(2:22000) fixed, L(2200) fixed;
declare (step, i, j, k, n) fixed binary;
Line 3,504:
call Ludic;
 
end Ludic_numbers;</langsyntaxhighlight>
Output:
<pre>The first 25 Ludic numbers are:
Line 3,517:
 
=={{header|PL/SQL}}==
<langsyntaxhighlight lang="plsql">SET SERVEROUTPUT ON
DECLARE
c_limit CONSTANT PLS_INTEGER := 25000;
Line 3,595:
END;
/
</syntaxhighlight>
</lang>
 
{{out}}
Line 3,617:
=={{header|PowerShell}}==
{{works with|PowerShell|2}}
<syntaxhighlight lang="powershell">
<lang PowerShell>
# Start with a pool large enough to meet the requirements
$Pool = [System.Collections.ArrayList]( 2..22000 )
Line 3,636:
# Add the rest of the numbers in the pool to the list of Ludic numbers
$Ludic += $Pool.ToArray()
</syntaxhighlight>
</lang>
<syntaxhighlight lang="powershell">
<lang PowerShell>
# Display the first 25 Ludic numbers
$Ludic[0..24] -join ", "
Line 3,653:
$TripletStart = $Ludic.Where{ $_ -lt 244 -and ( $_ + 2 ) -in $Ludic -and ( $_ + 6 ) -in $Ludic }
$TripletStart.ForEach{ $_, ( $_ + 2 ), ( $_ + 6 ) -join ", " }
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 3,674:
=={{header|Prolog}}==
Simple, straightforward implementation
<langsyntaxhighlight lang="prolog">
% John Devou: 26-Nov-2021
 
Line 3,700:
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>
</lang>
{{out}}
<pre>
Line 3,721:
 
=={{header|PureBasic}}==
<langsyntaxhighlight PureBasiclang="purebasic">EnableExplicit
If Not OpenConsole() : End 1 : EndIf
 
Line 3,759:
PrintN("Ludic Triplets below 250: " +r4$)
Input()
End</langsyntaxhighlight>
{{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,769:
=={{header|Python}}==
===Python: Fast===
<langsyntaxhighlight lang="python">def ludic(nmax=100000):
yield 1
lst = list(range(2, nmax + 1))
Line 3,790:
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))</langsyntaxhighlight>
 
{{out}}
Line 3,806:
===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.
<langsyntaxhighlight lang="python">def ludic(nmax=64):
yield 1
taken = []
Line 3,817:
taken.append(t)
yield t
del lst[::t]</langsyntaxhighlight>
 
Output is the same as for the fast version.
Line 3,826:
<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.
<langsyntaxhighlight lang="python">def ludic():
yield 1
ludics = []
Line 3,861:
break
print(f'[{a}, {b}, {c}]')
</syntaxhighlight>
</lang>
{{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,878:
 
=={{header|Racket}}==
<langsyntaxhighlight lang="racket">#lang racket
(define lucid-sieve-size 25000) ; this should be enough to do me!
(define lucid?
Line 3,917:
EOS
(for/list ((x (in-range 250)) #:when (and (lucid? x) (lucid? (+ x 2)) (lucid? (+ x 6))))
(list x (+ x 2) (+ x 6))))</langsyntaxhighlight>
 
{{out}}
Line 3,935:
{{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" perl6line>constant @ludic = gather {
my @taken = take 1;
my @rotor;
Line 3,963:
my $c = $a + 6;
take "<$a $b $c>" if $b ∈ l250 and $c ∈ l250;
}</langsyntaxhighlight>
{{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,971:
 
=={{header|REXX}}==
<langsyntaxhighlight lang="rexx">/*REXX program gens/shows (a range of) ludic numbers, or a count when a range is used.*/
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 4,011:
@= translate(@, , .) /*change dots to blanks; count numbers.*/
end /*while*/ /* [↑] done eliding ludic numbers. */
return subword($, 1, m) /*return a range of ludic numbers. */</langsyntaxhighlight>
Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, &nbsp; so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].
<br><br>
Line 4,026:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
# Project : Ludic numbers
 
Line 4,099:
see svect
see "]" + nl
</syntaxhighlight>
</lang>
Output:
<pre>
Line 4,112:
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">def ludic(nmax=100000)
Enumerator.new do |y|
y << 1
Line 4,132:
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</langsyntaxhighlight>
{{out}}
<pre>
Line 4,146:
 
=={{header|Rust}}==
<langsyntaxhighlight lang="rust">
const ARRAY_MAX: usize = 25_000;
const LUDIC_MAX: usize = 2100;
Line 4,244:
}
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 4,267:
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.
 
<langsyntaxhighlight lang="scala">object Ludic {
def main(args: Array[String]): Unit = {
println(
Line 4,279:
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)}
}</langsyntaxhighlight>
 
{{out}}
Line 4,288:
 
=={{header|Seed7}}==
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
 
const func set of integer: ludicNumbers (in integer: n) is func
Line 4,348:
end for;
writeln;
end func;</langsyntaxhighlight>
 
{{out}}
Line 4,359:
 
=={{header|SequenceL}}==
<syntaxhighlight lang="sequencel">
<lang sequenceL>
import <Utilities/Set.sl>;
 
Line 4,386:
"\n\nLudic 2000 to 2005:\n" ++ toString(ludics[2000...2005]) ++
"\n\nTriples below 250:\n" ++ toString(triplets) ;
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 4,404:
=={{header|Sidef}}==
{{trans|Ruby}}
<langsyntaxhighlight lang="ruby">func ludics_upto(nmax=100000) {
Enumerator({ |collect|
collect(1)
Line 4,427:
say("Ludic triples below 250: ", a.grep{|x| a.contains_all([x+2, x+6]) } \
.map {|x| '(' + [x, x+2, x+6].join(' ') + ')' } \
.join(' '))</langsyntaxhighlight>
{{out}}
<pre>
Line 4,437:
 
=={{header|Standard ML}}==
<syntaxhighlight lang="ocaml">
<lang OCaml>
open List;
 
Line 4,458:
length (filter (fn e=> e <= 1000) ludics);
drop (take (ludics,2005),1999);
</syntaxhighlight>
</lang>
output
<pre>
Line 4,469:
{{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.
<langsyntaxhighlight lang="tcl">package require Tcl 8.6
 
proc ludic n {
Line 4,511:
}
}
puts "triplets: [join $l ,]"</langsyntaxhighlight>
{{out}}
<pre>
Line 4,521:
 
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
<lang vb>
Set list = CreateObject("System.Collections.Arraylist")
Set ludic = CreateObject("System.Collections.Arraylist")
Line 4,595:
Loop
WScript.StdOut.WriteLine triplets
</syntaxhighlight>
</lang>
 
{{Out}}
Line 4,621:
=={{header|Vlang}}==
{{trans|Go}}
<langsyntaxhighlight lang="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.
Line 4,699:
}
println('')
}</langsyntaxhighlight>
 
{{out}}
Line 4,712:
{{trans|Go}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight lang="ecmascript">import "/fmt" for Fmt
 
var ludic = Fn.new { |n, max|
Line 4,774:
i = i + 1
}
System.print(triples)</langsyntaxhighlight>
 
{{out}}
Line 4,788:
=={{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.
<langsyntaxhighlight lang="zkl">fcn dropNth(n,seq){
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,796:
.fp(Ref([3..*,2]))) // odd numbers starting at 3
.push(1,2); // first two Ludic numbers
}</langsyntaxhighlight>
<langsyntaxhighlight lang="zkl">ludic().walk(25).toString(*).println();
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();</langsyntaxhighlight>
{{out}}
<pre>
10,333

edits