Eban numbers: Difference between revisions

:*   The MathWorld entry:   [http://mathworld.wolfram.com/EbanNumber.html eban numbers].

:*   The OEIS entry:   [http://oeis.org/A006933 A6933, eban numbers].

<br><br>

 

=={{header|AppleScript}}==

*)

end repeat

 

-- Task code:

set AppleScript's text item delimiters to ", "

set AppleScript's text item delimiters to linefeed

end runTask

 

 

{{output}}

2, 4, 6, 30, 32, 34, 36, 40, 42, 44, 46, 50, 52, 54, 56, 60, 62, 64, 66

2000, 2002, 2004, 2006, 2030, 2032, 2034, 2036, 2040, 2042, 2044, 2046, 2050, 2052, 2054, 2056, 2060, 2062, 2064, 2066, 4000

 

=={{header|AWK}}==

# syntax: GAWK -f EBAN_NUMBERS.AWK

# converted from FreeBASIC

return(n == 0 || n == 2 || n == 4 || n == 6)

}

{{out}}

<pre>

=={{header|C}}==

{{trans|D}}

#include "stdbool.h"

 

 

return 0;

{{out}}

<pre>eban numbers up to and including 1000:

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

{{trans|D}}

 

namespace EbanNumbers {

}

}

{{out}}

<pre>eban numbers up to and including 1000:

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

{{trans|D}}

 

struct Interval {

 

return 0;

{{out}}

<pre>eban numbers up to and including 1000:

eban numbers up to and including 1000000000:

count = 7999</pre>

 

=={{header|D}}==

{{trans|Kotlin}}

 

struct Interval {

writeln;

}

{{out}}

<pre>eban numbers up to an including 1000:

eban numbers up to an including 1000000000:

count = 7999</pre>

 

=={{header|Factor}}==

{{trans|Julia}}

math.order math.ranges prettyprint sequences ;

 

 

1 1000 1000 4000 [ .eban-range ] 2bi@

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

' Eban_numbers

' Un número eban es un número que no tiene la letra e cuando el número está escrito en inglés.

Print "Run time: " & (tiempo) & " seconds."

End

{{out}}

<pre>

=={{header|Fōrmulæ}}==

 

 

=={{header|Go}}==

 

import "fmt"

fmt.Println("count =", count, "\n")

}

 

{{out}}

count = 7999

</pre>

=={{header|Haskell}}==

{{trans|Julia}}

import Data.List (intercalate)

import Text.Printf (printf)

, 100_000_000

, 1_000_000_000 ]

{{out}}

<pre>

 

=={{header|J}}==

Filter =: (#~`)(`:6)

 

1e6 399

1e7 1599

 

=={{header|Java}}==

{{trans|Kotlin}}

 

public class Main {

}

}

{{out}}

<pre>eban numbers up to and including 1000

count = 7999</pre>

 

=={{header|Julia}}==

function iseban(n::Integer)

b, r = divrem(n, oftype(n, 10 ^ 9))

println("eban numbers up to and including 100000000: ", count(iseban, 1:100000000))

println("eban numbers up to and including 1000000000: ", count(iseban, 1:1000000000))

 

{{out}}

eban numbers up to and including 100000000: 7999

eban numbers up to and including 1000000000: 7999</pre>

 

=={{header|Kotlin}}==

{{trans|Go}}

 

typealias Range = Triple<Int, Int, Boolean>

println("count = $count\n")

}

 

{{output}}

=={{header|Lua}}==

{{trans|lang}}

return {start=s, end_=e, print_=p}

end

end

 

{{out}}

<pre>eban numbers up to and including 1000:

eban numbers up to and including 1000000000:

count = 7999</pre>

 

=={{header|Nim}}==

{{trans|Julia}}

 

proc iseban(n: int): bool =

if iseban(i):

inc count

 

{{out}}

 

Number of eban numbers up to and including 10000000: 1599

</pre>

 

===Exhaustive search===

A couple of 'e'-specific optimizations keep the running time reasonable.

use warnings;

use feature 'say';

my $n = + grep { $_ <= 10**$exp } @OK;

printf "Number of eban numbers and %10s: %d\n", comma(10**$exp), $n;

{{out}}

<pre>eban numbers up to and including 1000:

Alternately, a partial translation of Raku. Does not need to actually generate the e-ban numbers to count them. Display counts up to 10**21.

 

use warnings;

use bigint;

printf "Up to and including %23s: %s\n", lc(num2word(10**$exp)), comma($nu);

}

<pre>============= e-ban: =============

e-ban numbers up to 1000: 19

=={{header|Phix}}==

Why count when you can calculate?

{{out}}

<pre>

 

count_eban(10^0) : 0

count_eban(10^20) : 1,279,999,999

count_eban(10^21) : 1,279,999,999

</pre>

 

=={{header|PicoLisp}}==

(let

(B (/ N 1000000000)

(prinl)

(prinl "eban numbers up to an including 10000000:")

{{out}}

<pre>

 

=={{header|Python}}==

# Use inflect

 

print(" ")

print("Run time in seconds: "+str(after - before))

 

Output:

Run time in seconds: 1134.289519125

</pre>

 

=={{header|Raku}}==

Considering numbers up to <strong>10²¹</strong>, as the task directions suggest.

 

 

sub nban ($seq, $n = 'e') { ($seq).map: { next if .&cardinal.contains(any($n.lc.comb)); $_ } }

printf "Up to and including %{$s}s: %s\n", cardinal(10**($c+1)), comma(@counts[$c]);

}

{{out}}

<pre>============= e-ban: =============

=={{header|REXX}}==

Programming note: &nbsp; REXX has no shortcuts for &nbsp; '''if''' &nbsp; statements, so the multiple &nbsp; '''if''' &nbsp; statements weren't combined into one.

numeric digits 20 /*support some gihugic numbers for pgm.*/

parse arg $ /*obtain optional arguments from the cL*/

if hun\==' ' then return 1 /*any hundrEd (not zero) has an "e". */

end /*k*/ /*A "period" is a group of 3 dec. digs */

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

1599 eban numbers found for: 1 -10000000

═════════════════════════════════════════════════════════════════════════════════════════════════════════

</pre>

 

=={{header|Ruby}}==

{{trans|C#}}

intervals = [

[2, 1000, true],

end

 

{{out}}

<pre>eban numbers up to and including 1000:

=={{header|Scala}}==

{{trans|Java}}

 

class ERange(s: Int, e: Int, p: Boolean) {

}

}

{{out}}

<pre>eban numbers up to an including 1000

 

=={{header|Tailspin}}==

templates isEban

def number: $;

'$;' -> \(<'([246]|[3456][0246])(0[03456][0246])*'> $ !\) -> $number !

end isEban

 

Alternatively, if regex is not your thing, we can do it numerically, which actually runs faster

templates isEban

def number: $;

when <?($ mod 1000 <=0|=2|=4|=6|30..66?($ mod 10 <=0|=2|=4|=6>)>)> do $ ~/ 1000 -> #

end isEban

 

Either version is called by the following code

def small: [1..1000 -> isEban];

$small -> !OUT::write

 

' -> !OUT::write

{{out}}

<pre>

</pre>

 

=={{header|Visual Basic .NET}}==

{{trans|D}}

 

Structure Interval

End Sub

 

{{out}}

<pre>eban numbers up to and including 1000:

eban numbers up to and including 1000000000:

count = 7999</pre>

 

=={{header|Wren}}==

{{trans|Go}}

[2, 1000, true],

[1000, 4000, true],

if (rg[2]) System.print()

System.print("count = %(count)\n")

 

{{out}}

count = 7999

 

eban numbers up to and including 1000000000

count = 7999

=={{header|Yabasic}}==

{{trans|Go}}

data 1000, 4000, true

data 2, 1e4, false

if printable Print

Print "count = ", count, "\n"

 

=={{header|zkl}}==

{{trans|Go}}

T(1_000, 4_000, True),

T(2, 1e4, False), T(2, 1e5, False), T(2, 1e6, False), T(2, 1e7, False),

println("count = %,d\n".fmt(count));

}

{{out}}

<pre style="height:35ex">