EKG sequence convergence: Difference between revisions

{{trans|Nim}}

 

Set[Int] values

assert(n >= 2)

convIndex = i

L.break

 

{{out}}

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

 

BYTE FUNC Contains(BYTE ARRAY a BYTE len,b)

PrintF("converge at index %B",conv)

FI

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/EKG_sequence_convergence.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

{{trans|Go}}

with Ada.Containers.Generic_Array_Sort;

 

end if;

end;

{{out}}

<pre>

=={{header|C}}==

{{trans|Go}}

#include <stdlib.h>

 

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

return 0;

 

{{out}}

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

 

=={{header|Go}}==

 

import (

}

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

 

{{out}}

 

=={{header|Haskell}}==

import Data.Maybe (fromJust)

 

)

)

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

 

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

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">LIMIT</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">100</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\nEKG5(5) and EKG(7) %s\n"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">msg</span><span style="color: #0000FF;">)</span>

{{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.) !-->

=={{header|Sidef}}==

{{trans|Raku}}

method next {

terms += callback(terms)

var c = converge_at(arr)

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

{{out}}

<pre>

=={{header|Vlang}==

{{trans|Go}}

mut a,mut b:=aa,bb

for a != b {

}

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

 

{{out}}

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

import "/math" for Int

import "/fmt" for Fmt

}

}

 

{{out}}

=={{header|XPL0}}==

As can be seen, EKG(5) and EKG(7) converge at N = 21.

 

func Used; int M; \Return 'true' if M is in array A

[Tbl:= [2, 5, 7, 9, 10];

for I:= 0 to 4 do EKG(Tbl(I));

 

{{out}}

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