Kolakoski sequence: Difference between revisions

{{trans|C++}}

 

[Int] seq

V i = 0

[1, 3, 2, 1]]

V kol = gen_kolakoski(s, I s.len > 2 {30} E 20)

 

{{out}}

=={{header|Arturo}}==

 

result: array.of: length 0

i: new 0

Lens: [20 20 30 30]

 

generated: kolakoski c\0 c\1

print ["First" c\1 "members of the sequence generated by" c\0 ":"]

print ["Possible Kolakoski sequence?" possibleKolakoski? generated]

print ""

 

{{out}}

=={{header|C}}==

{{trans|Kotlin}}

#include <stdlib.h>

 

}

return 0;

 

{{output}}

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

{{trans|Java}}

using System.Collections.Generic;

using System.Linq;

}

}

 

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

#include <vector>

 

}

return 0;

{{out}}

<pre>Starting with: [ 1, 2, ]:

=={{header|D}}==

{{trans|Kotlin}}

 

void repeat(int count, void delegate(int) action) {

writeln;

}

{{out}}

<pre>First 20 members of the sequence generated by [1, 2]:

=={{header|Go}}==

{{trans|Kotlin}}

 

import "fmt"

fmt.Println("Possible Kolakoski sequence?", poss, "\n")

}

 

{{out}}

 

=={{header|Haskell}}==

import Control.Monad (forM_)

 

print $ take n s

putStrLn $ "Possible Kolakoski sequence? " ++ show (sameAsRleUpTo n s)

 

{{output}}

 

=={{header|J}}==

NB. cyclic

 

 

test=: (({.~ #) -: ]) }:@:(#;.1~ (1 , 2&(~:/\)))

 

test cuts the data at a vector of frets where successive pairs are unequal. The groups are tallied, giving run length.

=={{header|Java}}==

{{trans|Kotlin}}

 

public class Kolakoski {

}

}

{{out}}

<pre>First 20 members of the sequence generated by [1, 2]:

Possible Kolakoski sequence? false</pre>

 

=={{header|Julia}}==

{{trans|C}}

seq = Vector{Int}()

k = 0

println("\t\tDoes this look like a Kolakoski sequence? ", iskolakoski(seq) ? "Yes" : "No")

end

Kolakoski from [1, 2]: first 20 numbers are [1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1].

Does this look like a Kolakoski sequence? Yes

 

=={{header|Kotlin}}==

 

fun IntArray.nextInCycle(index: Int) = this[index % this.size]

println("Possible Kolakoski sequence? ${if (p) "Yes" else "No"}\n")

}

 

{{output}}

=={{header|Lua}}==

{{trans|C}}

local pos = index % length

return c[pos]

 

print()

{{out}}

<pre>First 20 members of the sequence generated by [1, 2]:

[1, 3, 3, 3, 2, 2, 2, 1, 1, 1, 1, 1, 3, 3, 2, 2, 1, 1, 3, 2, 1, 1, 1, 1, 3, 3, 3, 2, 2, 1]

Possible Kolakoski sequence? False</pre>

 

=={{header|Nim}}==

{{trans|Kotlin}}

a[index mod a.len]

 

echo ($kol)[1..^1]

let s = if kol.possibleKolakoski(): "Yes" else: "No"

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

my($terms,@seed) = @_;

my @k;

$status = join('', @rle = rle(@kolakoski)) eq join('', @kolakoski[0..$#rle]) ? 'True' : 'False';

print "Looks like a Kolakoski sequence?: $status\n";

{{out}}

<pre>20 members of the series generated from [1 2] is:

=={{header|Phix}}==

{{trans|C}}

{{out}}

<pre>

Python 3.6+

 

 

def cycler(start_items):

print(f' {s}')

ans = 'YES' if is_series_eq_its_rle(s) else 'NO'

 

{{out}}

{{works with|Rakudo|2018.04.01}}

 

my $k = @seed[0] == 1 ?? 1 !! 0;

my @k = flat @seed[0] == 1 ?? (1, @seed[1] xx @seed[1]) !! @seed[0] xx @seed[0],

my @rle = rle @kolakoski;

say " Looks like a Kolakoski sequence?: ", @rle[*] eqv @kolakoski[^@rle];

{{out}}

<pre>## 20 members of the series generated from [1, 2] is:

 

=={{header|Ruby}}==

Enumerator.new do |y|

cycle = ar.cycle

p res = create_generator(ar).take(num)

puts "Possible Kolakoski sequence? #{res.join.start_with?(rle(res).join)}"

{{out}}

<pre>

 

=={{header|Rust}}==

use itertools::Itertools;

 

}

}

{{out}}

<pre>

=={{header|Sidef}}==

{{trans|Ruby}}

Enumerator({|f|

var s = []

var rle = res.run_length.map{.tail}

say "#{res}\nPossible Kolakoski sequence? #{res.first(rle.len) == rle}"

{{out}}

<pre>

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

{{trans|C#}}

Imports System.Text

 

End Sub

 

{{out}}

<pre>First 20 members of the sequence by [1, 2]:

[1, 3, 3, 3, 2, 2, 2, 1, 1, 1, 1, 1, 3, 3, 2, 2, 1, 1, 3, 2, 1, 1, 1, 1, 3, 3, 3, 2, 2, 1]

Possible Kolakoski sequence? False</pre>

 

=={{header|Wren}}==

{{trans|Go}}

var s = List.filled(slen, 0)

var i = 0

System.print("Possible Kolakoski sequence? %(poss)\n")

i = i + 1

 

{{out}}

=={{header|zkl}}==

{{trans|Python}}

Walker.tweak(fcn(s,rk,cw){ // infinite iterator

s.append( c_next:=cw() );

}.fp(List(), Ref(0), Walker.cycle(start_items).next) )

.walk(length); // iterate length times, return list

truncated_series.reduce(fcn(a,b,rm,s){ # if trailing singleton, it is ignored

if(a==b){ rm.inc(); return(b); }

rle:=_run_len_encoding(series);

series[0,rle.len()]==rle

L( L(1,3,1,2), 30), L( L(1,3,2,1), 30) )){

start_items, length := sl;

println(" (%s)".fmt(( s:=kolakoski(start_items, length) ).concat(",") ));

println(" Does it look like a Kolakoski sequence: ",is_series_eq_its_rle(s) )

{{out}}

<pre>