Ludic numbers: Difference between revisions

{{task|Sieves}}

 

:<code><span style="color:blue;font-weight:bold">2</span> 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ...</code>

(Loop)

::<code><span style="color:blue;font-weight:bold"><s>2</s></span> 3 <s>4</s> 5 <s>6</s> 7 <s>8</s> 9 <s>10</s> 11 <s>12</s> 13 <s>14</s> 15 <s>16</s> 17 <s>18</s> 19 <s>20</s> 21 <s>22</s> 23 <s>24</s> 25 <s>26</s> ...</code>

* (Unrolling a few loops...)

::<code><span style="color:blue;font-weight:bold"><s>3</s></span> 5 7 <s>9</s> 11 13 <s>15</s> 17 19 <s>21</s> 23 25 <s>27</s> 29 31 <s>33</s> 35 37 <s>39</s> 41 43 <s>45</s> 47 49 <s>51</s> ...</code>

::<code><span style="color:blue;font-weight:bold"><s>5</s></span> 7 11 13 17 <s>19</s> 23 25 29 31 <s>35</s> 37 41 43 47 <s>49</s> 53 55 59 61 <s>65</s> 67 71 73 77 ...</code>

::<code><span style="color:blue;font-weight:bold"><s>7</s></span> 11 13 17 23 25 29 <s>31</s> 37 41 43 47 53 55 <s>59</s> 61 67 71 73 77 83 <s>85</s> 89 91 97 ...</code>

 

;Task:

* Generate and show here the first 25 ludic numbers.

* How many ludic numbers are there less than or equal to 1000?

 

=={{header|ABAP}}==

Works with NW 7.40 SP8

 

PUBLIC SECTION.

ENDMETHOD.

 

 

{{Output}}

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>

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>

 

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

2000th through 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|D}}==

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

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

numbers(t, [h])

defp numbers(list, nums) when length(list) < hd(list), do: Enum.reverse(nums, list)

end

IO.puts "Below 1000: #{length(numbers(1000))}"

tuple = numbers(25000) |> List.to_tuple

ludic = numbers(250)

IO.puts "Triples below 250: #{inspect triple, char_lists: :as_lists}"

end

end

 

 

{{out}}

2000..2005th: [21475, 21481, 21487, 21493, 21503, 21511]

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>

 

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

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

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

 

import "fmt"

}

fmt.Println()

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

{{out}}

 

=={{header|Haskell}}==

 

ludic :: [Integer]

 

main :: IO ()

main = do

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

2000th - 2005th Ludics: [21475, 21481, 21487, 21493, 21503, 21511]

Triplets up to 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|Julia}}==

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

0 < n || throw(DomainError())

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

end

 

{{out}}

</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|Oforth}}==

 

| ludics l p |

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

 

while(l notEmpty) [

l removeFirst dup ludics add ->p

l size p / p * while(dup 1 > ) [ dup l removeAt drop p - ] drop

 

| l i |

ludic(22000) ->l

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

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

 

{{out}}

233, 235, 239

</pre>

 

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

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>

 

 

 

 

{{out}}

 

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

put skip;

i = 1;

do i = 1 by 1 while (L(i+2) <= 250);

if (L(i) = L(i+1) - 2) & (L(i) = L(i+2) - 6) then

call Ludic;

 

Output:

<pre>The first 25 Ludic numbers are:

21475 21481 21487 21493 21503 21511

Triples are:

( 173 175 179) ( 221 223 227) ( 233 235 239)</pre>

 

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

DECLARE

c_limit CONSTANT PLS_INTEGER := 25000;

END;

/

 

{{out}}

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

say

say

say

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

<br><br>

<pre>

The 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

 

 

 

From 1──►249, 8 triples found: ◄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|Ruby}}==

Enumerator.new do |y|

y << 1

ludics = ludic(250).to_a

puts "Ludic triples below 250:",

{{out}}

<pre>

[[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|Seed7}}==

 

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

end for;

writeln;

 

{{out}}

Ludic 2000 to 2005: 21475 21481 21487 21493 21503 21511

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>

2000-2005: 21475,21481,21487,21493,21503,21511

triplets: (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}}==

}

fcn ludic{ //-->Walker

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>