## Monday, July 26, 2021

### A small programming exercise in APL #1

This post shows a possible solution written in APL for the following programming problem:
Given an array, determine if a value `'number'` is found in every consecutive segment of `'size'` elements.

For example, given this array:

``````
1,2,1,3,4,1
``````

This predicate is true for `number = 1` and `size = 2`. Because '1' is found in (1,2), (1,3) and (4,1).

## A possible APL solution

This is a possible solution to this problem (using my limited APL knowledge).
``````
∇ z←array arraysegments args
number ← args
size ← args
z ← ∧/ ({number∊⍵} ⍤1) (((⍴ array) ÷ size) , size) ⍴ array
∇
``````

This function is called `arraysegments` and is a dyadic function. It receives the array to validate as the left argument and on the right argument a two-value array with the value ('number') to find inside the array segment and the length of the segments.

An example of using this function

``````
1 2 1 3 4 1 arraysegments 1 2
1
1 2 1 3 4 1 arraysegments 2 2
0
1 2 1 3 4 1 arraysegments 1 3
1
300 200 300 300 400 500 arraysegments 300 3
1
300 200 300 300 400 500 arraysegments 400 3
0
``````

To see how this function works I'm going to start by defining some sample data:

``````
array ← 1 2 1 3 4 1
number ← 1
size ← 3
``````

1. First, start by reshaping the input array into a matrix with each row being

``````
(((⍴ array) ÷ size) , size)
2 3
(((⍴ array) ÷ size) , size) ⍴ array
1 2 1
3 4 1
``````

2. Now that we have the 'groups' as the rows of the new matrix, we apply the membership operation to each element of the matrix. To do this, we use the rank operator in conjunction with an inline function to test the membership:

``````
({number∊⍵} ⍤1) (((⍴ array) ÷ size) , size) ⍴ array
1 1
``````

As a final step we apply the reduce operator '/' with the And operator to see if the input number exists in every group:

``````
∧/ ({number∊⍵} ⍤1) (((⍴ array) ÷ size) , size) ⍴ array
1
``````

There are some problem with this solution. For example if the array cannot be splitted in groups of the specified size you get a runtime error.