Intersecting number wheels: Difference between revisions

{{trans|Python}}

 

L

V nxt = w[name][0]

name = nxt

 

print("Intersecting Number Wheel group:\n "group)

[String = [String]] wheel

first = I first == ‘’ {name[0 .< (len)-1]} E first

V gen = (0.<20).map(i -> nextfrom(&@wheel, @first)).join(‘ ’)

 

{{out}}

 

=={{header|ALGOL 68}}==

# a number wheel element #

MODE NWELEMENT = UNION( CHAR # wheel name #, INT # wheel value # );

, NW( "B", LOC INT := 1, ( 3, 4 ) )

, NW( "C", LOC INT := 1, ( 5, "B" ) ) ) )

{{out}}

<pre>

 

</pre>

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

 

return 0;

{{out}}

<pre> 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2

 

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

using System.Collections.Generic;

using System.Linq;

 

static void Print(this IEnumerable<char> sequence) => Console.WriteLine(string.Join(" ", sequence));

{{out}}

<pre>

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

{{trans|D}}

#include <iostream>

#include <map>

 

return 0;

{{out}}

<pre> 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2

 

=={{header|D}}==

import std.range;

import std.stdio;

group3();

group4();

{{out}}

<pre>["1", "2", "3", "1", "2", "3", "1", "2", "3", "1", "2", "3", "1", "2", "3", "1", "2", "3", "1", "2"]

 

=={{header|F_Sharp|F#}}==

// Wheels within wheels. Nigel Galloway: September 30th., 2019.

let N(n)=fun()->n

for n in 0..20 do printf "%d " (A4())

printfn ""

{{out}}

<pre>

⁠— a dictionary-like structure that is transformed into a lazy list which yields the expected sequence elements.

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

math.parser multiline peg.ebnf prettyprint prettyprint.custom

sequences strings ;

 

: .take ( n group -- )

Now the interface defined above may be used:

rosetta-code.number-wheels ;

 

"Intersecting number wheel group:" print

[ . ] [ "Generates:" print 20 swap .take nl ] bi

{{out}}

<pre>

 

=={{header|Go}}==

 

import (

generate(wheels, "A", 20)

}

 

{{out}}

terminating at the first digit found, and printing a map-accumulation of that recursion over a list of given length but arbitrary content.

 

import Data.List (mapAccumL)

 

 

clockWorkTick = flip click 'A'

where

 

leftRotate :: [a] -> [a]

leftRotate = take . length <*> (tail . cycle)

 

main :: IO ()

main = do

let wheelSets =

]

putStrLn "State of each wheel-set after 20 clicks:\n"

mapM_ print $

fmap

wheelSets

putStrLn "\nInitial state of the wheel-sets:\n"

{{Out}}

<pre>State of each wheel-set after 20 clicks:

[('A',"1DD"),('D',"678")]

[('A',"1BC"),('B',"34"),('C',"5B")]</pre>

 

=={{header|Java}}==

package intersectingNumberWheels;

import java.util.ArrayList;

}

}

Output:

{A=[1, 2, 3]}

{{Trans|Haskell}}

{{Trans|Python}}

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>Series and state of each wheel-set after 20 clicks:

{"A":"1DD"},{"D":"678"}

{"A":"1BC"},{"B":"34"},{"C":"5B"}</pre>

 

=={{header|Julia}}==

const d2 = Dict("A" => [["1", "B", "2"], 1], "B" => [["3", "4"], 1])

const d3 = Dict("A" => [["1", "D", "D"], 1], "D" => [["6", "7", "8"], 1])

 

foreach(testwheels, [d1, d2, d3, d4])

<pre>

Number Wheels:

=={{header|Kotlin}}==

{{trans|Java}}

import java.util.stream.IntStream

 

endPosition = list.size - 1

}

{{out}}

<pre>{A=[1, 2, 3]}

=={{header|Maple}}==

 

with(ArrayTools):

 

 

seq(currentValue(A), 1..20);

 

{{out}}<pre>

 

=={{header|Nim}}==

 

type

{'A': "1 B 2", 'B': "3 4"}.generate(20)

{'A': "1 D D", 'D': "6 7 8"}.generate(20)

 

{{out}}

=={{header|Perl}}==

{{trans|Julia}}

use warnings;

use feature 'say';

{'A' => [['1', 'D', 'D'], 0], 'D' => [['6', '7', '8'], 0]},

{'A' => [['1', 'B', 'C'], 0], 'B' => [['3', '4'], 0], 'C' => [['5', 'B'], 0]},

{{out}}

<pre>A: 1, 2, 3

 

=={{header|Phix}}==

{{out}}

<pre>

=={{header|Python}}==

===Python: Original class and generator based===

 

class INW():

]:

w = INW(**group)

 

{{out}}

 

===Python: Simplified procedural===

while True:

nxt, w[name] = w[name][0], w[name][1:] + w[name][:1]

first = name[:-1] if first is None else first

gen = ' '.join(nextfrom(wheel, first) for i in range(20))

 

{{out}}

Input is just a list of Python dicts, and depends on c-python dicts being odered by key insertion order.

 

nxt, w[name] = w[name][0], w[name][1:] + w[name][:1]

return nxt if '0' <= nxt[0] <= '9' else nextfromr(w, nxt)

first = next(group.__iter__())

gen = ' '.join(nextfromr(group, first) for i in range(20))

 

{{out}}

{{Trans|Haskell}}

{{Works with|Python|3.7}}

 

from itertools import cycle, islice

 

 

insertDict(wheelName)(leftRotate(wheel))(wheels)

)(v)

return click(wheelMap)('A')

 

 

 

# main :: IO ()

def main():

 

 

 

# Tuple (,) :: a -> b -> (a, b)

# insertDict :: String -> a -> Dict -> Dict

def insertDict(k):

def go(v, dct):

return lambda v: lambda dct: go(v, dct)

 

# mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])

def mapAccumL(f):

with accumulation from left to right.

'''

tpl = f(a[0])(x)

 

 

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>New state of wheel sets, after 20 clicks of each:

{'A': '1DD', 'D': '678'}

{'A': '1BC', 'B': '34', 'C': '5B'}</pre>

 

=={{header|Raku}}==

(formerly Perl 6)

A succinct Raku example using a few additional language features. Wheels are implemented as infinite repeating sequences, allowing a single iterator to keep track of the current position. This means the code contains no position tracking whatsoever.

#| advance rotates a named wheel $n by consuming an item from an infinite sequence. It is called

#| from within a gather block and so can use take in order to construct an infinite, lazy sequence

#| state variables are only initialised once, and are kept between invocations.

==> map({ state $i = 1; say "Group {$i++}, First 20 values: $_[^20]" })

<pre>

Group 1, First 20 values: 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2

 

This REXX program uses &nbsp; ''numbers'' &nbsp; (any form), &nbsp; not &nbsp; ''digits'' &nbsp; (for the values on the wheels).

@.= /*initialize array to hold the wheels. */

parse arg lim @.1 /*obtain optional arguments from the CL*/

@.4= ' A: 1 B C, B: 3 4, C: 5 B '

end

end /*i*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

gear.n.0= z; if gear.n.z=='' then gear.n.0= 1

do forever; nn= xx

zz= gear.nn.0; xx= gear.nn.zz

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

<pre>

</pre>

 

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

{{trans|C#}}

 

Module Module1

End Sub

 

{{out}}

<pre>1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2

1 6 7 1 8 6 1 7 8 1 6 7 1 8 6 1 7 8 1 6

1 3 5 1 4 3 1 4 5 1 3 4 1 3 5 1 4 3 1 4</pre>

 

=={{header|zkl}}==

ws:=wheels.pump(Dictionary(),fcn([(k,v)]){ return(k,Walker.cycle(v)) }); // new Dictionary

Walker.zero().tweak(fcn(w,wheels){

}

}.fp("A",ws)) // assume wheel A exists and is always first

Dictionary("A",T(1,"B",2), "B",T(3,4)),

Dictionary("A",T(1,"D","D"), "D",T(6,7,8)),

ws.pump(String,fcn([(k,v)]){ " %s: %s\n".fmt(k,v.concat(" ")) }).print();

println("-->",intersectingNumberWheelsW(ws).walk(20).concat(" "));

{{out}}

<pre>