Help with expanding pattern

[Nilaus]

Hi crafty combinator programmers

I've been working on an expanding pattern to use for Solar Panels and for automatic biter clearing, but I am having a hard time making this work. I feel this is a basic programming task, but it has been 10 years ago since I did any (shitty) programming. I hope someone on the forum will easily see a solution and can share it with me, since I have pretty much given up on this and I am about to go for somethin less cool

Here is the challenge
* Only input is the iteration number
* Output is in X,Y coordinates
* The expansion pattern should be like either of the pictures below e.g. expand diagonally outwards:

Solar expansion.PNG (6.34 KiB) Viewed 4171 times

For reference then I have built another self-expanding pattern for solar panels, to show that I am not a complete noob
Imgur: http://imgur.com/a/C9n5h
YouTube: https://www.youtube.com/watch?v=Xly_55dQOnk

Initially I copied the pattern from the video above, but tried to have it "expand by 1 when it formed a square", but that didn't work. I've been considering just storing a string corresponding to the direction of the next square, but that doesn't really work either it only scales to the size I make the string.

Anyways, I hope someone can help me with this little trick, then I hook up the rest of the deployer blueprints to this one.

[DaveMcW]

* Only input is the iteration number

If you insist on this, the answer is a complicated math formula that uses square roots and lots of rounding down. Rounding down is easy with combinators, but square roots are hard.

I recommend you use 3 inputs: x, y, and a hidden variable to track the length of the side.

Code: Select all

10 11 12 13
 5  6  7 14
 2  3  8 15
 1  4  9 16

This uses three simple rules:

• If (X < L) then X = X + 1
• If (X == L and Y > 0) then Y = Y - 1
• if (Y == 0) then X = 0, Y = L + 1, L = L + 1

[The Eriksonn]

is it allowed to input a pulse instead and let it output the next x,y?

[Nilaus]

* Only input is the iteration number

If you insist on this, the answer is a complicated math formula that uses square roots and lots of rounding down. Rounding down is easy with combinators, but square roots are hard.

Perfect answer! I had a feeling I was making it more difficult for myself than it needed to be
What I meant what that I would like to start it and then it keeps track of which square to go to next. I can easily make the "one side is X wide and fill up in the other direction ad inifity", so this was without me specifying the height or width in advance.

I will give your intermediate L value a shot. I was working along those lines, but combinators are not as "crisp" as code, so it wasn't quite working as I intended i.e. didn't work at all

Thanks for the input.

is it allowed to input a pulse instead and let it output the next x,y?

Sure. I have not set up arbitrary rules for the sake of it, but just tried to say that the system should figure out the height/width dynamically.

[pieppiep]

I did it!

It's a mess, and my first combinator creation more complex than choosing accumulators over steam, so it's up to someone else to clean up.

Expander.png (1.46 MiB) Viewed 4061 times

blueprintstring

H4sIAAAAAAAA/81cUW/bNhD+K4EeNzsTSZG20WlAku5hQIEW8B5aFIOh2MoqQJYMWS4SGP7vk2ynMamIOR5Frm9tFFL6vjsev7sjsyqv8nKZ5FeLeJ8WdVZn
6Tbe74tkncbBsiy2dVLU42W5vs+KpC6rYLQpt81vlUW8f4zHhIye4vHkMFplVbo8/piOmmF1VeaL+/Rb8j0rq3j/kOV1WrUTb7N/iySP9/XTpnnB96yqd0ke
jE7vOz0c/xUcmjl2RR2TUVas0seYHA7tj4ri9I5moq8BCf6J91W6aiY9fvjTIlu1L8+q5S6r2/+0o5pxZzCrdJmt0qofy/Sag8CcJ1o0T1bZ+XMesmpbL+Dg
TrzGImz+vd4kVfs5cfB7MCp39WZnMtPmaXHkavFQletFVjSj47rapRjCaEPWy6Mj6V8DCuBZGsb6bbBdJ3k+zpP1Rub+hxt12X6e6wfbJmS/vyS7/bALsuMA
SJGQ4QkYotADIiQgLgOaGQCaugUU4QBFEiCggYgHPAQJSLYQgwGiHjyOIl1uJgGiIQwR87GGkIhIKEMCBjrqweso0usmclwwMZJjRAyJSHa7KQxQ5CPQIQER
aoDB8cqJsCtH1gs0Qsk0cSnThFuZRhSgw6i0hyTfImVavzBrdxxbBcw9KmDK/28FLDNGNVrWhHdpFt5vk6TK6m/rtM6W/WYRQLO8zDWM05ebtDFL+7bgV1O7
IMnvJ5hNsWmFcKzxKC4MMtlHJgaIuGNEaryDGlPOlBhQt4Y+ICERyQKCAXff0IPbIb2OTCVEEQwQ9QEIiUhWrRTodMwDIoZEJJuIAp2OeVhGDLmOqLwhMhO3
cwyJYiHJ+R/jBsLcsd9F2Nggix9qAsmxlSKsleTSEJNrQxDxFZ3EF3Muvj7J0f1CfP1mJL4+gMVXFELFF530q9vIXNBSX5x+6OX0FyNO/wZzSgWYU42ghZAY
+nTMbdqOhXJ1SfTYiOiPcKIn/Wkb3LFZqHFs3v+Ma9JsgPGYL9vNLxdAiM/oPoPtwmcGdBvSJnzR9tnM5T/KLm8WW+DUyhFD2axnYJcnUJenpvaZ+bTPS24X
4sl/DyafhZp4M1Hdupd83UCT7DJyq7dCnNySfUuppQHL78QDPILERyYo0c88QGJISJTqFLI+NXMMiWK9kKFKApEHSBEWUqRNzXb3zfTtDOrxnLPQINfcvA1A
3XZYbs322FNtGtspuB2kC0N4f3hjM/Ae0NmqzW1D3Nrmxs42fxjZ5mYQ26j9AUmtE1yXQbYwtxOvz5UE4qWNY2C9G5uE7RM8MQD3MOUcWukWa7LmdbrKdutx
mjefUjWW2JR5qgbEc2DDpPKScGMaEa3JDfsidfhKnIbnkdRvIcUij/wCL07pQqiamuPSb/crcSja4DminjYxRPrt3tu+eEy/4R6pS78j8EEBbR7ZKR5i7OPe
rX/O8kikOcjBwecM1BKINIudfWY+18/r5zicVUcIWP12tNjbuyOJcNvj+FgraUddMB65YPzmkvGxBeVzuJ7qyNE+ynmnHG7G4swTibcDuS2cQzUVk4IxOKGL
NLMIzY0UCPeThvvw+tXu6rBOa3Hc6wbus516JyxJVtK5TiZheJ7OIaeGVY1bm63xFs77FMq7mir3t9VkX372I03Tt2V92Itid/iLYpYNvHP39U081v50ZyW1
XDVfOdMk5Vp1pUntuV12wjxZZKiWKjzx0LZULVkTnlj7OVM6NS2Q3LHTC4U5tfl+1O7xzNF+NDfjfW7DO1wHCDC3vJNYmO/1LrkdQj/B93ED3jS6E1gnZcCy
iE6paY7QdLGYqAnShq03b0R4kxNC46Zv9nTI6Tyc42s3d9LFc4te2t0Qt26ERmeKUOPYKtPSQM3Vc1CiC7OD76B8ZxOUsQUFqmFWF3gEt18JwuNKsLnb52Ql
aKi1+esWJ9+euO0bK9oYH2PmgzAL3i2FnYg+KjjhQ2VY5BvwQKDy1l/PUp6Bzz6rQULSDJqz5lzT5BeaG5h8htwLpn7TST+VYwFuhrwWzA+jbHmcXdFUWZ2u
nz/pdYIPL6rq/Ht/Pm6S5kfNo3dVWu+q4mrxLi1W/wFO2m4slUgAAA==

The order I'm expanding is,

Code: Select all

17 19 21 23 25
10 12 14 16 24
 5  7  9 15 22
 2  4  8 13 20
 1  3  6 11 18

The arithmetic combinator most south facing up is set to output S = S+0, just a simple memory cell.
This is feeding the A = S*S and B = S+1 which will feed A = A+1 and B = B*B
This will give S*S+1 and (S+1)*(S+1), the starting and ending number for each step further away from 0,0.
S = 0 give A = 1, B = 1
S = 1 give A = 2, B = 4
S = 2 give A = 5, B = 9
etc.
At the top signal I for Input is generated, in this case a simple counter from 1 till 25 with each second the next number.
When A > I the signal A = 1 is given to the left part to signal A and B are to high.
When B < I the signal B = 1 is given to the left part to signal A and B are to low.
This A and B value are translated to A * -1 and B * 1 to S
If this value is added directly to the internal state S, the new A and B values aren't calculated fast enough, so at the most left is a clock generated that pulses each 6 cycles which is multiplied by the S correction signal so that signal doesn't reach the state to often.
This part will find the correct A and B values for the start for the row and column we need to generate.
Next P = I - A, this is to calculate the position between A and B we need.
P is divided by 2 to calculate L to see how far we are on the row/column and multiplied by 2 and then substracted from P to know if we need to be on a row or column.
Now we can use S and L for the row and column, depending on O which on is the row and which one the column.
The final 2 combinators and 25 lamps are just use to see if it works.

This design isn't perfect, the output isn't immediately and there are some intermediate outputs. Those can probably be easiely solved by the same trick I used to only let 1/6 from the correction signal to the state S combinator.
But for placing solar panels this design is probably good enough.

I've tested it with really big input values for I and it seems to work correctly.
When going from 1 to 1000 for the A value it takes over a minute and a half, but in the case for the solar panels that won't happen.

[Nilaus]

I did it!

Wow!
That is so cool. I agree that it can probably be cleaned up a bit, but at least when the functionality is there it is easier to optimise it.
I wanted to get back to this problem, but I've been creating a few Angels Mods tutorials in the mean time so this got put on the backburner.
I'll give it a shot ingame and see what I can make of it.
Thank you

[pieppiep]

Another way to calculate square root, viewtopic.php?f=193&t=40747

[Megatron]

This is as compact as I could get it.

Blueprint

0eNrlWl1v2jAU/S9+nMIWfyRQpE2atJe+7LnVVKEQ3NVaSJBxqlVV/vvswCBASHxC127aS9UQ59o+99x7jgPPZJ6VcqVVbsj0mai0yNdk+u2ZrNX3PMncZ+ZpJcmUKCOXJCB5snRXiVbmYSmNSkdpsZyrPDGFJlVAVL6QP8mUVncBkblRRslNwPriaZaXy7nUdsAu1EKmaiF1M05AVsXaPlrkbgE23Ii9jwLy5P6xcyyUlunmLguIXbLRRTaby4fkUdmn7SPbmDN7b1HHWbtP75Vem9nJzh6VNqX9ZLeizYjRtdvPWroY/g/NsyT94R6021klut7OlHyy44rSrEpgei0XmzirJ7uPMjeze10sZyq3Ucj0PsnWsqrv5/kGjXqP1P1xjzYwV/aK25FKp6Uy9SWtgoPb0fFtm77vWsr8OM74cCCr7uwamJu0dTg7iVtVjal/s4H1EOuUECFGiH3YyzixTQrKiu1jxUpaRtTrJO8GUGJLLiDt4ijPNPRNND1O9GGgCcYD7scDjvKAvg0NLmsNTRqMBtBggzBCA+qbdXY2rS1Rr/ySKnbrd+piktx0lzavMxoeJjRuT+i9yozUZySrt7OWTvVoQ7QCIMpNawwGxbhtjcGhGFs27OKM9oEEFMg5gWYcRsVYTHgsxruAUc0HT9IxX9JF3do07r5NhR8NI1hjdqaD/v3NpUVhPgw1HZc0lk6VoH0icpRZ7ssg0SM/Ez+KxGCnYm2dir1gp7pprcfJwI5121PdDKlu37IbD7Z2fgrwvzq7UwN2tjaCPtXuKh3ql+bJcAdP38LB/y7wer7X7prRQGXstmOojHp6QNp/hGhlxNVgL/+6hGj4pxekBO7RuW9Bj88WcFubjvyy5bI6LF3hq2ZLJunDG/bpzfTVHzDBE6TUaUtjaM0qBR1NXKeU/jlHc93wIKxpZBDrcXa7+/dIS7lQ5XIkMxtPWyaviky27Ffs9us7N+03qe1r44PPH29w/Nj3QnpYNJ+/fhlkb9zR8hKFDE4Z0FEent6UCuwtdAgl5EVeQg/td/vDfOM19MfBHe/F3kNT3n3mi33OeJfoXDRU5+g/oXM7N/PqSnfVc5gXkMCFPdHic/mNQQngsAK0aq9lrVHZ9ruudlUd8aqpxqmWxpXo2eEMG06h4SE0Govtu/AIgyXCYIkwWCIIlgiCJYJgERgsAoNFYLAICBYBwSIgWDgGC8dg4RgsHIKFQ7BwCBaGwcIwWBgGC4NgYRAsDIKFYrBQDBaKwUIhWCgEC0VgCSFUQgiUEMIkRCAJEURCBBCMJhhLMJJAHIEoAjEEaydYN8GaCdRLoFYCdRJMdjDVwUQH0hxIciDFwewJ5k4wcwJ5E8iaQM4Es7GYi8VMLORhIQvb4WDtyaf+beC08VPCgDxKvd58bScEE1chi6O4qn4B6B+Alg==

Coordinates are sorted by distance from (1,1)



Input is on the left, signal , starting with value 1.
Output is on the right, signals [X] and [Y] starting with coordinate (1,1) for index 1.

It has some limitations though.
The output is not stable, you would have to wait a few ticks (worst case for about 50) until the correct result is set.
Additional to [X] and [Y] some temporary signals are set on the ouput.
If the index has illegal values (smaller than 1 or bigger than 2,147,441,939) the output is undefined.
The input has to be set until the calculation is finished.