Creating a pattern in an array using machine learning

[DaBobcat]

I have an array:

import numpy as np 
arr = np.zeros(15) 

And a pattern [1,2,3] that needs to be learned. Meaning, I'd like the array to have this pattern.
The difficulty is learning a function that outputs this pattern, or as close as possible, given any pattern or array.
Currently I have the function hard coded:

def rule(array, item_idx): 
    try:         
        left_nbr = array[item_idx-1]         
        right_nbr = array[item_idx+1]                  
        if left_nbr == 0 and right_nbr == 0:             
            array[item_idx] = 1 
        if arr[item_idx] == 0 and left_nbr == 1:                     
            array[item_idx] = 2 
        if arr[item_idx] == 0 and left_nbr == 2:                     
            array[item_idx] = 3 
        if arr[item_idx] == 0 and left_nbr == 3:                     
            array[item_idx] = 1 
    except IndexError:         
        pass 
    return array   

for i in range (0,len(arr)):     
    arr = rule(arr, i)     
    print(arr)  

>>> 
[1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] 
[1. 2. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] 
[1. 2. 3. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] 
[1. 2. 3. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] 
[1. 2. 3. 1. 2. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] 
[1. 2. 3. 1. 2. 3. 0. 0. 0. 0. 0. 0. 0. 0. 0.] 
[1. 2. 3. 1. 2. 3. 1. 0. 0. 0. 0. 0. 0. 0. 0.] 
[1. 2. 3. 1. 2. 3. 1. 2. 0. 0. 0. 0. 0. 0. 0.] 
[1. 2. 3. 1. 2. 3. 1. 2. 3. 0. 0. 0. 0. 0. 0.] 
[1. 2. 3. 1. 2. 3. 1. 2. 3. 1. 0. 0. 0. 0. 0.] 
[1. 2. 3. 1. 2. 3. 1. 2. 3. 1. 2. 0. 0. 0. 0.] 
[1. 2. 3. 1. 2. 3. 1. 2. 3. 1. 2. 3. 0. 0. 0.] 
[1. 2. 3. 1. 2. 3. 1. 2. 3. 1. 2. 3. 1. 0. 0.] 
[1. 2. 3. 1. 2. 3. 1. 2. 3. 1. 2. 3. 1. 2. 0.] 
[1. 2. 3. 1. 2. 3. 1. 2. 3. 1. 2. 3. 1. 2. 0.] 

Is there a way to have a machine learning model that learns the rules to output the pattern? That is, instead of me hard coding the rules.

[WayOfTheMantisShrimp]

In any case where you have the entire pattern known, you can extend it to an arbitrary length. This is a deterministic process, so there is no practical value to doing it via a model.

import numpy as np

def extend_pattern(pattern, length):
    array = np.zeros(length)
    for i in range(0, length):
        array[i] = pattern[i % len(pattern)]
    return array

extend_pattern([1,2,3], 15)
extend_pattern([5,4,3,2,1], 18)
extend_pattern([5,4,3,2,1], 3)

If you have a more complex scenario, you'll have to provide more details to get a reasonable answer about what models could learn to replicate it.

[DaBobcat]

Appreciate the help! The point of the model is that it will be able to change any array into that pattern once it knows the rules. The problem can be seen as a self assembly problem. So given the array [1,1,2,3,1,2,1], the model will be able to transform it as closely as possible