Lucky and even lucky numbers: Difference between revisions

{{trans|Nim}}

 

 

F initLuckyNumbers(nelems, evenlucky, limit = -1)

print()

E

 

{{out}}

=={{header|C}}==

{{trans|C++}}

#include <stdio.h>

#include <stdlib.h>

 

return 0;

{{out}}

<pre>LuckyNumbers.exe -j=1 -k=20

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

{{trans|Go}}

#include <iostream>

#include <iterator>

 

return 0;

{{out}}

<pre>&gt;LuckyNumbers.exe -j=1 -k=20

 

=={{header|D}}==

import std.concurrency;

import std.conv;

lucky(evenLucky).drop(j-1).take(1).writeln;

}

 

{{out}}

=={{header|F_Sharp|F#}}==

===The functions===

// Odd and Even Lucky Numbers. Nigel Galloway: October 3rd., 2020

let rec fN i g e l=seq{yield! i|>Seq.skip g|>Seq.take(e-g-1)

let n=Seq.chunkBySize e i|>Seq.collect(Seq.take(e-1)) in yield! fN n (e-1) (Seq.item l n) (l+1)}

let oLuck,eLuck=let rec fG g=seq{yield g; yield! fG(g+2)} in (fN(fG 1) 0 3 2,fN(fG 2) 0 4 2)

 

===The task===

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

}

}

 

{{out}}

 

Haskell is a very nice language for this problem because it is a lazy language. Here regular expressions and data types are used.

import System.Environment

import Text.Regex.Posix

_ -> do

putStrLn "Invalid input, wrong number of arguments"

{{out}}

<pre>$ luckyNumbers 1 20

Implementation:

 

1 luckySeq y

:

)

 

 

Task:

 

1 3 7 9 13 15 21 25 31 33 37 43 49 51 63 67 69 73 75 79

program 1 20,evenLucky

6009 6019 6031 6049 6055 6061 6079 6093

program 6000,-6100,evenLucky

 

Note that I've used the J command line rather than a unix or windows command line. This is because J is portable to a wide variety of environments (including phones) and there's no reliably common command line that exists across all these environments. Therefore, J must provide its own, and J's command line requires some slight syntax changes from the suggestions implicit in this task.

 

=={{header|Java}}==

import java.util.ArrayList;

import java.util.Collections;

 

}

 

{{out}}

=={{header|JavaScript}}==

First: the function.

function luckyNumbers(opts={}) {

/**************************************************************************\

// showing the 10,000th even lucky number (extra credit)

console.log( luckyNumbers({even: true, nth: 10000}) );

{{out}}<pre>

> Array(276) [ 1, 3, 7, 9, 13, 15, 21, 25, 31, 33, … ]

We'll use an HTML-prompt here, because JavaScript actually doesn't have a command interface on it's own.

 

(function() {

document.write(`

}

})();

Using the task demonstrations again, the I/O part looks like:

{{out}}<pre>

Input: Evenlucky 10000

Result: 111842

</pre>

 

=={{header|Julia}}==

This iterator for lucky numbers is semi-lazy: it completes one pass of the filter each iteration.

 

struct Lucky

end

 

> julia luckymath.jl 1 20

[1, 3, 7, 9, 13, 15, 21, 25, 31, 33, 37, 43, 49, 51, 63, 67, 69, 73, 75, 79]

 

=={{header|Kotlin}}==

 

typealias IAE = IllegalArgumentException

printBetween(j, l, odd)

}

 

{{out}}

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Save the following code in the file script.wls and execute the wolframscript from the command line:

GetLuckies[max_] := Module[{luckies, f, i},

luckies = Range[1, max, 2];

]

]

{{out}}

<pre>wolframscript -file script.wls -args "1 20 lucky"

=={{header|Nim}}==

For the generation of lucky numbers, we use the second Python algorithm, modified to return a sequence.

 

type LuckyKind {.pure.} = enum Lucky = "lucky", EvenLucky = "evenlucky"

else:

# Print values in range j..(-k).

 

{{out}}

The module <code>Perl6::GatherTake</code> emulates the Raku gather/take syntax, and allows us to access values from what acts (mostly) like a lazy list.

{{trans|Raku}}

 

sub luck {

}

 

{{out}}

<pre>$ ./lucky

 

=={{header|Phix}}==

{{out}}

<pre>

Output when args are 1 20

 

=={{header|PicoLisp}}==

 

(de nn (Lst N)

(if (lt0 B)

(filter '((N) (<= A N (abs B))) *Lst)

{{out}}

<pre>$ pil ./lucky.l 1 20

=={{header|Python}}==

The generator

 

def lgen(even=False, nmax=1000000):

# drain

for i in lst[n:]:

 

The argument handler

import sys, re

 

 

if __name__ == '__main__':

 

{{out}}

The following streaming version of function lgen returns odd or even lucky numbers until reaching system limits. Instead of creating a bounded table and deleting elements, it uses the insight that after each iteration the <b>remaining</b> numbers are shuffled left, modifying their indices in a regular way. Reversing this process tracks the k'th lucky number in the final list back to its position in the initial list of integers, and hence determines its value without any need to build the table. The only storage requirement is for the list of numbers found so far.

<br>Based on the algorithm at https://oeis.org/A000959/a000959.txt.

def lgen(even=False):

lucky = []

lucky.append(2*k+1 + even)

yield 2*k+1 + even

 

=={{header|Raku}}==

(formerly Perl 6)

gather {

my @taken = take a;

multi MAIN (Int $min where * > 0, Int $neg-max where * < 0, Luck $howlucky = 'lucky') {

say grep * >= $min, (@::(lc $howlucky) ...^ * > abs $neg-max);

{{out}}

<pre>$ ./lucky

=={{header|REXX}}==

This REXX version does extra error checking for the arguments.

parse arg bot top func _ . /*obtain required & optional arguments.*/

if func=='' then func= 'lucky' /*Not specified? Then use the default.*/

do b=1 for @.0; _= _ @.b /*construct a list of integers.*/

end /*b*/

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 1 &nbsp; 20 &nbsp; lucky </tt>}}

<pre>

 

=={{header|Ring}}==

# Project : Lucky and even lucky numbers

 

see svect

see "]" + nl

Output:

<pre>

[6018, 6020, 6022, 6026, 6036, 6038, 6050, 6058, 6074, 6090, 6092]

</pre>

 

=={{header|Ruby}}==

{{trans|Python}}

start = even ? 2 : 1

Enumerator.new do |y|

if __FILE__ == $0

lucky(ARGV)

 

{{out}}

The lucky numbers sequence:

 

let even: Bool

let through: Int

return nil

}

 

The main file:

 

guard let sj = args.first, let j = Int(sj), j > 0, j <= 10_000 else {

case _:

fatalError()

 

{{out}}

{{works with|Tcl|8.6}}

{{trans|Python}}

package require Tcl 8.6

 

} else {

puts "$from'th to $to'th $evenOdd numbers: [join [collectIndices $l [incr from -1] [incr to -1]] ,]"

{{out}}

<pre>

=={{header|Wren}}==

{{trans|Kotlin}}

{{libheader|Wren-str}}

 

var luckyOdd = List.filled(1e5, 0)

if (j > l) Fiber.abort("The second argument can't be less in absolute value than first")

printBetween.call(j, l, odd)

 

{{out}}

<pre>

Lucky numbers 1 to 20 are:

[1, 3, 7, 9, 13, 15, 21, 25, 31, 33, 37, 43, 49, 51, 63, 67, 69, 73, 75, 79]

 

Lucky even numbers 1 to 20 are:

[2, 4, 6, 10, 12, 18, 20, 22, 26, 34, 36, 42, 44, 50, 52, 54, 58, 68, 70, 76]

 

Lucky numbers between 6000 and 6100 are:

[6009, 6019, 6031, 6049, 6055, 6061, 6079, 6093]

 

Lucky even numbers between 6000 and 6100 are:

[6018, 6020, 6022, 6026, 6036, 6038, 6050, 6058, 6074, 6090, 6092]

 

Lucky number 10000 = 115591

 

Lucky even number 10000 = 111842

</pre>

=={{header|zkl}}==

The lucky number generator works by chaining filters to a even or odd infinite sequence. So it acts like a sieve as each starting number percolates through the filters. It also means there are lots and lots of filters, which doesn't scale well but works for the examples.

ns,idx:=[a..*,2],2;

vm.yield(ns.next());

}

}

The command line is a bit funky (by Unix standards) so we just hard code it and use exceptions (such as trying to convert "foo" to int) to show the options.

try{

j=cmdLineArgs[0].toInt();

}

}

{{out}}

<pre>