Ludic numbers: Difference between revisions

{{task|Sieves}}

 

[https://oeis.org/wiki/Ludic_numbers Ludic numbers]   are related to prime numbers as they are generated by a sieve quite like the [[Sieve of Eratosthenes]] is used to generate prime numbers.

 

<br><br>

 

=={{header|360 Assembly}}==

{{trans|Fortran}}

LUDICN CSECT

USING LUDICN,R15 set base register

LUDIC DC 25000X'01' ludic(nmax)=true

YREGS

{{out}}

<pre>

=={{header|ABAP}}==

Works with NW 7.40 SP8

 

PUBLIC SECTION.

ENDMETHOD.

 

 

{{Output}}

233 235 239

</pre>

 

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

 

# sieve the Ludic numbers up to 30 000 #

print( ( " ", whole( n, -3 ), ", ", whole( n + 2, -3 ), ", ", whole( n + 6, -3 ), newline ) )

FI

{{out}}

<pre>

233, 235, 239

</pre>

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey 1.1}}

SetBatchLines, -1

Ludic := LudicSieve(22000)

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

 

=={{header|C}}==

#include <stdlib.h>

 

free(x);

return 0;

{{out}}

<pre>

 

=={{header|C sharp}}==

using System.Linq;

using System.Collections.Generic;

public int Prev { get; set; }

public int Next { get; set; }

{{out}}

<pre>

 

=={{header|C++}}==

#include <vector>

#include <iostream>

return system( "pause" );

}

{{out}}

<pre>

 

=={{header|Clojure}}==

(cons n (lazy-seq (ints-from (inc n)))))

 

(print "Triplets < 250: ")

(println (filter (partial every? 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)

 

=={{header|Common Lisp}}==

(loop with numbers = (make-array (1+ max) :element-type 'boolean :initial-element t)

for i from 2 to max

when (and (find (+ x 2) numbers)

(find (+ x 6) numbers))

{{output}}

<pre>First 25 ludic numbers:

===opApply Version===

{{trans|Python}}

int opApply(int delegate(in ref T) dg) {

int result;

writefln("\nThere are %d triplets less than %d:\n%s",

triplets.length, m, triplets);

{{out}}

<pre>First 25 ludic primes:

===Range Version===

This is the same code modified to be a Range.

T[] rotor, taken = [T(1)];

T i;

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;

 

writefln("\nThere are %d triplets less than %d:\n%s",

triplets.length, m, triplets);

The result is the same.

 

=={{header|Eiffel}}==

class

LUDIC_NUMBERS

 

end

Test:

class

APPLICATION

 

end

{{out}}

<pre>

=={{header|Elixir}}==

{{works with|Elixir|1.3.1}}

def numbers(n \\ 100000) do

[h|t] = Enum.to_list(1..n)

end

 

 

{{out}}

 

=={{header|Factor}}==

prettyprint.config sequences sequences.extras ;

IN: rosetta-code.ludic-numbers

"Ludic numbers 2000 to 2005:\n%u\n" [ printf ] tri@ ;

 

{{out}}

<pre>

=={{header|Fortran}}==

{{works with|Fortran|95 and later}}

implicit none

end do

 

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

 

=={{header|FreeBASIC}}==

 

' As it would be too expensive to actually remove elements from the array

 

Print "Press any key to quit"

 

{{out}}

 

=={{header|Go}}==

 

import "fmt"

}

fmt.Println()

[http://play.golang.org/p/pj7UmJnqoE Run in Go Playground].

{{out}}

 

=={{header|Haskell}}==

 

ludic :: [Integer]

(print . length) $ takeWhile (<= 1000) ludic

print $ take 6 $ drop 1999 ludic

{{out}}

<pre>

 

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

(a,b) = splitAt (n-1) s

 

 

=={{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)

if (count +:= 1) > limit then lds@&main

put(lds, ludic)

 

Output:

 

=={{header|J}}==

25

ludic 110 NB. First 25 Ludic numbers

173 175 179

221 223 227

 

=={{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;

 

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]

=={{header|JavaScript}}==

===ES6===

* Boilerplate to simply get an array filled between 2 numbers

* @param {!number} s Start here (inclusive)

console.log([e, e + 2, e + 6].join(', '));

}

 

<pre>

233, 235, 239

</pre>

 

=={{header|Julia}}==

function ludic_filter{T<:Integer}(n::T)

0 < n || throw(DomainError())

println(" ", i, ", ", j, ", ", k)

end

 

{{out}}

=={{header|Kotlin}}==

{{trans|FreeBASIC}}

 

/* Rather than remove elements from a MutableList which would be a relatively expensive operation

}

}

 

{{out}}

 

=={{header|Lua}}==

function ludics (limit)

local ludList, numList, index = {1}, {}

print(under1k .. " are less than or equal to 1000\n")

show("2000th to 2005th:", inRange)

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

{233,235,239}</pre>

 

Ludic={1};

seq=Range[2,n];

out

]

LengthWhile[Ludic, # < 1000 &]

Ludic[[2000 ;; 2005]]

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|Objeck}}==

{{trans|Java}}

 

class Ludic {

}

}

 

{{output}}

=={{header|Oforth}}==

 

| ludics l p |

ListBuffer newSize(n) seqFrom(2, n) over addAll ->l

l include(i 6 +) ifFalse: [ continue ]

i print ", " print i 2 + print ", " print i 6 + println

 

{{out}}

===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.

for(i=1,250, if(Vr[i]&&Vr[i+2]&&Vr[i+6], print1("(",i," ",i+2," ",i+6,") ")));

}

{{Output}}

<pre>

Upgraded script from [http://oeis.org/A003309 A003309] to meet task requirements.

 

\\ Creating Vl - Vector of ludic numbers.

\\ 2/28/16 aev

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

=={{header|Pascal}}==

=== ===

Runtime nearly quadratic: maxLudicCnt = 10000 -> 0.03 s =>maxLudicCnt= 100000 -> 3 s

{$IFDEF FPC}

{$MODE objFPC} // useful for x64

LastLucid(LudicList,maxLudicCnt,5);

triples(LudicList,250);//all-> (LudicList,LudicList[High(LudicList)].dNum);

{{Output}}

<pre>

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

Firsttwentyfive;CountBelowOneThousand;Show2000til2005;ShowTriplets ;

setlength(Ludiclst,0)

{{Out}}

<pre>2005 ludic numbers upto 21511

=={{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;

say 'triplets < 250: ', join ' ',

map { '(' . join(' ',$_, $_ + 2, $_ + 6) . ')' }

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

2000..2005th: 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)</pre>

 

=={{header|Phix}}==

{{trans|Fortran}}

{{out}}

<pre>

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|PicoLisp}}==

(let N (car Lst)

(make

(filter '((X) (< X 250)) L) ) ) ) )

{{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)

=={{header|PL/I}}==

 

declare V(2:22000) fixed, L(2200) fixed;

declare (step, i, j, k, n) fixed binary;

call Ludic;

 

Output:

<pre>The first 25 Ludic numbers are:

 

=={{header|PL/SQL}}==

DECLARE

c_limit CONSTANT PLS_INTEGER := 25000;

END;

/

 

{{out}}

=={{header|PowerShell}}==

{{works with|PowerShell|2}}

# Start with a pool large enough to meet the requirements

$Pool = [System.Collections.ArrayList]( 2..22000 )

# Add the rest of the numbers in the pool to the list of Ludic numbers

$Ludic += $Pool.ToArray()

# Display the first 25 Ludic numbers

$Ludic[0..24] -join ", "

$TripletStart = $Ludic.Where{ $_ -lt 244 -and ( $_ + 2 ) -in $Ludic -and ( $_ + 6 ) -in $Ludic }

$TripletStart.ForEach{ $_, ( $_ + 2 ), ( $_ + 6 ) -join ", " }

{{out}}

<pre>

221, 223, 227

233, 235, 239

</pre>

 

=={{header|Python}}==

===Python: Fast===

yield 1

lst = list(range(2, nmax + 1))

if x+6 < n and x+2 in ludics and x+6 in ludics]

print('\nThere are %i triplets less than %i:\n %r'

 

{{out}}

===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 = []

taken.append(t)

yield t

 

Output is the same as for the fast version.

 

=={{header|Racket}}==

(define lucid-sieve-size 25000) ; this should be enough to do me!

(define lucid?

EOS

(for/list ((x (in-range 250)) #:when (and (lucid? x) (lucid? (+ x 2)) (lucid? (+ x 6))))

 

{{out}}

((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: 18753 real time: 18766 gc time: 80</pre>

 

=={{header|REXX}}==

parse arg N count bot top triples . /*obtain optional arguments from the CL*/

say

say

say "The " bot '───►' top ' (inclusive) ludic numbers are: ' subword($, bot)

if _>=triples then leave /*only process up to a specific number.*/

say

if @=='' then say 'From 1──►'triples", no triples found."

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

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

Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, &nbsp; so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].

<br><br>

 

=={{header|Ring}}==

# Project : Ludic numbers

 

see svect

see "]" + nl

Output:

<pre>

 

=={{header|Ruby}}==

Enumerator.new do |y|

y << 1

ludics = ludic(250).to_a

puts "Ludic triples below 250:",

{{out}}

<pre>

Ludic triples 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>

 

In this example, we define a function to drop every n^th 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(

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

 

=={{header|Seed7}}==

 

const func set of integer: ludicNumbers (in integer: n) is func

end for;

writeln;

 

{{out}}

 

=={{header|SequenceL}}==

import <Utilities/Set.sl>;

 

"\n\nLudic 2000 to 2005:\n" ++ toString(ludics[2000...2005]) ++

"\n\nTriples below 250:\n" ++ toString(triplets) ;

{{out}}

<pre>

=={{header|Sidef}}==

{{trans|Ruby}}

Enumerator({ |collect|

collect(1)

say("Ludic triples below 250: ", a.grep{|x| a.contains_all([x+2, x+6]) } \

.map {|x| '(' + [x, x+2, x+6].join(' ') + ')' } \

{{out}}

<pre>

Ludic numbers 2000 to 2005: 21475 21481 21487 21493 21503 21511

Ludic triples 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>

 

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

}

}

{{out}}

<pre>

 

=={{header|VBScript}}==

Set list = CreateObject("System.Collections.Arraylist")

Set ludic = CreateObject("System.Collections.Arraylist")

Loop

WScript.StdOut.WriteLine triplets

 

{{Out}}

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

.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

{{out}}

<pre>