EKG sequence convergence: Difference between revisions

# [[Greatest common divisor]]

# [[Sieve of Eratosthenes]]

<br>

;Reference:

* [https://www.youtube.com/watch?v=yd2jr30K2R4 The EKG Sequence and the Tree of Numbers]. (Video).

<br><br>

 

=={{header|C}}==

{{trans|Go}}

#include <stdlib.h>

 

printf("\nEKG5(5) and EKG(7) do not converge within %d terms\n", LIMIT);

return 0;

 

{{out}}

 

EKG(5) and EKG(7) converge at term 21

</pre>

 

===The Function===

This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_function Extensible Prime Generator (F#)]

// Generate EKG Sequences. Nigel Galloway: December 6th., 2018

let EKG n=seq{

yield! seq[1;n]; let g=fU n in yield! EKG g (fG g|>Seq.minBy snd)}

let EKGconv n g=Seq.zip(EKG n)(EKG g)|>Seq.skip 2|>Seq.scan(fun(n,i,g,e)(l,β)->(Set.add l n,Set.add β i,l,β))(set[1;n],set[1;g],0,0)|>Seq.takeWhile(fun(n,i,g,e)->g<>e||n<>i)

 

===The Task===

EKG 2 |> Seq.take 45 |> Seq.iter(printf "%2d, ")

EKG 3 |> Seq.take 45 |> Seq.iter(printf "%2d, ")

EKG 10 |> Seq.take 45 |> Seq.iter(printf "%2d, ")

printfn "%d" (let n,_,_,_=EKGconv 2 5|>Seq.last in ((Set.count n)+1)

{{out}}

<pre>

</pre>

===Extra Credit===

prıntfn "%d" (EKG 2|>Seq.takeWhile(fun n->n<>104729) ((Seq.length n)+1)

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2019-10-06}}

lists.lazy math math.statistics prettyprint sequences

sequences.generalizations ;

{ 2 5 7 9 10 } 20 show-ekgs nl

"EKG(5) and EKG(7) converge at term " write

{{out}}

<pre>

EKG(5) and EKG(7) converge at term 21

</pre>

 

=={{header|Go}}==

 

import (

}

fmt.Println("\nEKG5(5) and EKG(7) do not converge within", limit, "terms")

 

{{out}}

 

=={{header|Haskell}}==

import Data.Maybe (fromJust)

 

seqEKGRec :: Int -> Int -> [Int] -> [Int]

seqEKGRec _ 0 l = l

seqEKGRec k n [] = seqEKGRec k (n - 2) [k, 1]

seqEKGRec

k

 

seqEKG :: Int -> Int -> [Int]

seqEKG k n = reverse (seqEKGRec k n [])

 

main :: IO ()

main =

mapM_

{{out}}

<pre>EKG (2) is [1,2,4,6,3,9,12,8,10,5,15,18,14,7,21,24,16,20,22,11]

 

=={{header|J}}==

Until =: 2 :'u^:(0-:v)^:_' NB. unused but so fun

prime_factors_of_tail =: ~.@:q:@:{:

assert (,2) -: prime_factors_of_tail 6 8 NB. (nub of)

assert 3 4 5 -: numbers_not_in_list 1 2 6

Somewhat shorter is ekg2,

index_of_lowest =: [: {. _ ,~ [: I. 1 e."1 prime_factors_of_tail e."1 q:@:numbers_not_in_list

 

 

assert (ekg^:9&> -: ekg2^:9&>) 2 5 7 9 10

 

=={{header|Java}}==

import java.util.ArrayList;

import java.util.Collections;

}

{{out}}

<pre>

 

'''Preliminaries'''

# jq optimizes the recursive call of _gcd in the following:

def gcd(a;b):

def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;

 

'''The Task'''

def areSame($s; $t):

($s|length) == ($t|length) and ($s|sort) == ($t|sort);

;

 

{{out}}

<pre>

=={{header|Julia}}==

{{trans|Perl}}

 

function ekgsequence(n, limit)

[println(rpad("EKG($i): ", 9), join(ekgsequence(i, 30), " ")) for i in [2, 5, 7, 9, 10]]

println("EKGs of 5 & 7 converge at term ", convergeat(5, 7))

{{output}}<pre>

EKG(2): 1 2 4 6 3 9 12 8 10 5 15 18 14 7 21 24 16 20 22 11 33 27 30 25 35 28 26 13 39 36

=={{header|Kotlin}}==

{{trans|Go}}

 

fun gcd(a: Int, b: Int): Int {

}

println("\nEKG5(5) and EKG(7) do not converge within $LIMIT terms")

 

{{output}}

 

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

NextInSequence[seq_List] := Module[{last, new = 1, holes, max, sel, found, i},

last = Last[seq];

len = LengthWhile[s, Apply[Equal]];

s //= Reverse[Drop[#, len]] &;

{{out}}

<pre>1 2 4 6 3 9 12 8 10 5

 

21</pre>

 

=={{header|Nim}}==

 

#---------------------------------------------------------------------------------------------------

echo fmt"EKG(5) and EKG(7) converge at index {convIndex}."

else:

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

 

sub gcd { my ($u,$v) = @_; $v ? gcd($v, $u%$v) : abs($u) }

 

print "EKG($_): " . join(' ', EKG($_,10)) . "\n" for 2, 5, 7, 9, 10;

{{out}}

<pre>EKG(2): 1 2 4 6 3 9 12 8 10 5

=={{header|Phix}}==

{{trans|C}}

{{out}}

<pre>

If this alternate definition of function EKG_gen is used then the output would be the same as above.

Instead of keeping a cache of prime factors this calculates the gretest common divisor as needed.

from math import gcd

 

for start in 2, 5, 7, 9, 10:

print(f"EKG({start}):", str([n[0] for n in islice(EKG_gen(start), 10)])[1: -1])

 

{{out}}

Despite EKG(5) and EKG(7) seeming to converge earlier, as seen above; their hidden states differ.<br>

Here is those series out to 21 terms where you can see them diverge again before finally converging. The state is also shown.

from pprint import pprint as pp

 

for start in 5, 7:

print(f"EKG({start}):\n[(<next>, [<state>]), ...]")

 

'''Generates:'''

(formerly Perl 6)

{{works with|Rakudo Star|2018.04.1}}

 

sub next-EKG ( *@s ) {

for [5, 7], [2, 5, 7, 9, 10] -> @ints {

say "EKGs of (@ints[]) converge at term {$_+1}" with converge-at(@ints);

{{out}}

<pre>

 

=={{header|REXX}}==

parse arg nums start /*obtain optional arguments from the CL*/

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

if done then iterate

if wordpos(j, $)==0 then return j /*return an EKG integer.*/

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

<!-- (output is shown &nbsp; '''⁵/₆''' &nbsp; size.) !-->

 

(start 10): 1 10 4 6 3 9 12 8 14 7 21 15 5 20 16 18 22 11 33 24 26 13 39 27 30 25 35 28 32 34 17 51 36 38 19 57 42 40 44 46 23 69 45 48 50 52 54 56 49 63

</pre>

 

=={{header|Sidef}}==

{{trans|Raku}}

method next {

terms += callback(terms)

var c = converge_at(arr)

say "EKGs of #{arr} converge at term #{c}"

{{out}}

<pre>

EKGs of [5, 7] converge at term 21

EKGs of [2, 5, 7, 9, 10] converge at term 45

</pre>

 

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

 

var areSame = Fn.new { |s, t|

}

}

 

{{out}}

 

EKG(5) and EKG(7) converge at term 21.

</pre>

 

=={{header|zkl}}==

Using gcd hint from Go.

Walker.tweak(fcn(rp,buf,w){

foreach n in (w){

}

}.fp(Ref(N),List(),Walker.chain([2..N-1],[N+1..]))).push(1,N)

{{out}}

<pre>

EKG(10): 1,10,2,4,6,3,9,12,8,14

</pre>

ekgWs:=ns.apply(ekgW); ekgWs.apply2("next"); // pop initial 1

ekgNs:=List()*vm.numArgs; // ( (ekg(n1)), (ekg(n2)) ...)

}

convergeAt(5,7);

{{out}}

<pre>