Mian-Chowla sequence: Difference between revisions

The [[wp:Mian–Chowla sequence|Mian–Chowla sequence]] is an integer sequence defined recursively.

 

The sequence starts with:

:* [[oeis:A005282|OEIS:A005282 Mian-Chowla sequence]]

 

 

=={{header|C#|CSharp}}==

{{trans|Go}}

using System.Linq;

 

static class Program {

static int[] MianChowla(int n) {

}

}

}

static void Main(string[] args)

{

}

{{out}}

<pre>The first 30 terms of the Mian-Chowla sequence are:

22526 23291 23564 23881 24596 24768 25631 26037 26255 27219

 

 

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

{{trans|Go}}

The '''sums''' array expands by "i" on each iteration from 1 to n, so the max array length can be pre-calculated to the nth triangular number (n * (n + 1) / 2).

 

#include <iostream>

 

#define n 100

 

bool Contains(int lst[], int item, int size) {

return false;

}

 

int main() {

cout << "The first 30 terms of the Mian-Chowla sequence are:\n";

for (int i = 0; i < 30; i++) { cout << mc[i] << ' '; }

cout << "\n\nTerms 91 to 100 of the Mian-Chowla sequence are:\n";

for (int i = 90; i < 100; i++) { cout << mc[i] << ' '; }

{{out}}

<pre>The first 30 terms of the Mian-Chowla sequence are:

 

Terms 91 to 100 of the Mian-Chowla sequence are:

 

=={{header|Go}}==

 

import "fmt"

fmt.Println("\nTerms 91 to 100 of the Mian-Chowla sequence are:")

fmt.Println(mc[90:100])

 

{{out}}

</pre>

<br>

 

import "fmt"

mc := make([]int, n)

mc[0] = 1

is[2] = true

var sum int

for i := 1; i < n; i++ {

isx = isx[:0]

for k := 0; k <= i; k++ {

sum = mc[k] + j

continue jloop

isx = append(isx, sum)

}

break

fmt.Println("\nTerms 91 to 100 of the Mian-Chowla sequence are:")

fmt.Println(mc[90:100])

 

=={{header|JavaScript}}==

'use strict';

 

const main = () => {

const genMianChowla = mianChowlas();

console.log([

'Mian-Chowla terms 1-30:',

 

'\nMian-Chowla terms 91-100:',

].join('\n') + '\n');

};

function* mianChowlas() {

let

sumSet = new Set([2]),

x = 1;

while (true) {

yield x;

}

}

 

// Set of sums -> Series up to n -> Next term in series

return [

),

];

};

 

// sumList :: [Int] -> Int -> [Int]

 

 

 

// drop :: Int -> [a] -> [a]

// drop :: Int -> Generator [a] -> Generator [a]

// drop :: Int -> String -> String

xs.slice(n)

 

 

// length :: [a] -> Int

const length = xs =>

xs.length

) : Infinity;

 

 

// take :: Int -> [a] -> [a]

// take :: Int -> String -> String

xs.slice(0, n)

) : [].concat.apply([], Array.from({

return x.done ? [] : [x.value];

}));

 

// until :: (a -> Bool) -> (a -> a) -> a -> a

 

// MAIN ---

return main();

{{Out}}

<pre>Mian-Chowla terms 1-30:

 

Mian-Chowla terms 91-100:

 

 

 

=={{header|Julia}}==

seq = ones(Int, n)

for i in 2:n

seq[i] = seq[i - 1] + 1

incrementing = true

while incrementing

for j in 1:i

tsum = seq[j] + seq[i]

seq[i] += 1

break

else

if j == i

incrementing = false

end

seq

end

function testmianchowla()

println("The first 30 terms of the Mian-Chowla sequence are $(mianchowla(30)).")

println("The 91st through 100th terms of the Mian-Chowla sequence are $(mianchowla(100)[91:100]).")

end

@time testmianchowla()

<pre>

The first 30 terms of the Mian-Chowla sequence are [1, 2, 4, 8, 13, 21, 31, 45, 66, 81, 97, 123, 148, 182, 204, 252, 290, 361, 401, 475, 565, 593, 662, 775, 822, 916, 970, 1016, 1159, 1312].

The 91st through 100th terms of the Mian-Chowla sequence are [22526, 23291, 23564, 23881, 24596, 24768, 25631, 26037, 26255, 27219].

</pre>

 

=={{header|Perl}}==

use warnings;

use feature 'say';

my @mian_chowla = generate_mc(100);

say "First 30 terms in the Mian–Chowla sequence:\n", join(' ', @mian_chowla[ 0..29]),

{{out}}

<pre>First 30 terms in the Mian–Chowla sequence:

22526 23291 23564 23881 24596 24768 25631 26037 26255 27219</pre>

 

{{out}}

 

=={{header|Python}}==

 

def mian_chowla():

yield mc[-1]

psums = set([2])

for trial in count(2):

for n in chain(mc, [trial]):

break

else:

mc.append(trial)

yield trial

 

 

{{out}}

 

 

 

from itertools import (islice)

 

 

def mianChowlas():

sumSet = set([2])

x = 1

while True:

yield x

 

 

 

 

 

'''Tests'''

 

genMianChowlas = mianChowlas()

print(

take(10)(genMianChowlas),

'\n'

)

 

 

# GENERIC -------------------------------------------------

 

# drop :: Int -> [a] -> [a]

# succ :: Int -> Int

def succ(x):

return 1 + x

 

 

if __name__ == '__main__':

{{Out}}

<pre>First 30 terms of the Mian-Chowla series:

[22526, 23291, 23564, 23881, 24596, 24768, 25631, 26037, 26255, 27219]

 

 

 

=={{header|REXX}}==

do j=i to t; ···

but the 1^st version is faster.

parse arg LO HI . /*obtain optional arguments from the CL*/

if LO=='' | LO=="," then LO= 1 /*Not specified? Then use the default.*/

if HI=='' | HI=="," then HI= 30 /* " " " " " " */

r.= 0 /*initialize the rejects stemmed array.*/

$= /*the Mian─Chowla sequence (so far). */

do i=1 for t; if r.i then iterate /*I already rejected? Then ignore it.*/

do j=i for t-i+1; if r.j then iterate /*J " " " " " */

_= i + j /*calculate the sum of I and J. */

end /*j*/

end /*i*/

#= # + 1 /*bump the counter of terms in the list*/

end /*t*/

say 'The Mian─Chowla sequence for terms ' LO "──►" HI ' (inclusive):'

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

<pre>

22526 23291 23564 23881 24596 24768 25631 26037 26255 27219

</pre>

 

=={{header|VBScript}}==

Const m = 100, mm=28000

ReDim r(mm), v(mm * 2)

wscript.echo "The Mian-Chowla sequence for elements 91 to 100:"

wscript.echo s2

{{out}}

<pre>

Execution time: 40 min

 

 

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

{{trans|Go}}

For j As Integer = mc(i - 1) + 1 To Integer.MaxValue

End Function

 

Sub Main(ByVal args As String())

End Sub

{{out}}

<pre>The first 30 terms of the Mian-Chowla sequence are:

22526 23291 23564 23881 24596 24768 25631 26037 26255 27219