Combinator Contraptions

[XKnight]

That is pretty easy.

Set up 2 memory cells, 1 with all signals, 1 with all negative signals (each * -1).

Each tick, use the ANY signal to pick one signal from each memory cell. Then feed it to the opposite memory cell to delete it. Also feed it to the opposite ANY combinator to avoid any delays.

Small problem... If you are using ANY signal you should specify output signal type, and without correct type you won't be able to sum signal with opposite memory cell. Am I missing something?

1.png (246.05 KiB) Viewed 31507 times

Getting it down to one tick between each output might be hard but not impossible.

That's why this is a challenge.

Also would the signals all be positive?

Yep.

[DaveMcW]

Doh, that is what I get for posting without testing.

[Dr. Walrus]

MY TASK 2

Input:
- ~150 different signals in input
- each signal has unique value (I don't know, maybe this information will help you)
- each value is less than 1M (this value may be reduced/increased by your demand; it is preferable to increase this value)

Expected output:
- each signal should be presented in output without others during 1 tick
- whole process should take exactly N ticks (where N is the amount of signals in input) + fixed amount of ticks (you may use any number here; it is preferable to decrease this value)
- output sequence doesn't matter, but each signal should be presented in output once
- gaps between output signals are forbidden

Main focus: reduce "fixed amount of ticks", amount of combinators

Example:
0 tick: input A 10, B 30, C 20, D 50, E 40, F 60
1 tick:
2 tick:
3 tick:
4 tick: output A 10
5 tick: output B 30
6 tick: output C 20
7 tick: output D 50
8 tick: output E 40
9 tick: output F 60

That is pretty easy.

Set up 2 memory cells, 1 with all signals, 1 with all negative signals (each * -1).

Each tick, use the ANY signal to pick one signal from each memory cell. Then feed it to the opposite memory cell to delete it. Also feed it to the opposite ANY combinator to avoid any delays.

I don't think it's quite so easy as that, because when you use a combinator with the ANY signal you are only getting the value of the signal you want. To get the actual type of signal and value you'll need to run it through another combinator to get the signal with the same value. And you can't erase the old signal from memory until you're done with the second combinator. So unless I'm missing something I'm pretty sure it will take 2 ticks. Please correct me if I'm wrong.

I've got a start to a solution that you might be able to work on. This one takes a 1 tick long signal of a bunch of items and outputs them in order every 2 ticks. It's limited to only positive or only negative numbers and all of their values must be different.

Picture

Code

Code: Select all

H4sIAAAAAAAA/9VZ246jOBD9lRaPuzDCBgyoh5X2+hOjVeSAk1gyFxnTM1GUf18gBEMSiHGS1uzkZVr4lMqnqo7L5SR/Y3mM2dsqOpBMUEFJGR0OGU5JZCQk
pgnhVpyna5phkXPDLPKyXpRn0eFHZAVfPHMfWfBoxnmWkbj5UMO/GcD4NzpwktSmWqv7FU0iz4wpjysqmj/A8Xg0vxnw1kJ4sdDcckKyeVutCwntPOg8jw4b
ykuxKuk2wyw6iH1Rb+uDclFhZpinXZ4+Wjjbix3NtkZrqRQ4E5Fd/zctMG+2Hhm/GWZeiaJSs2e3hor9Ks6rTKw2PE9XNKvRkbHBrCRG43NHNOZU7FIiaDzN
td9znVB+ojpylXgHQ67ggPfFtEo/lzBLcLwbs5oXpOa02YHx6yJST6YGzJUpZsxiOC0u6HI6ur54asmJxjs3B5/8S/4WBc5t3ACNGzJuUMmlULVewisHXxA1
CwzD9stjYbuvLA1rtg5r4L54wDFfpkqt3MmXJwiQPa080TK2PwgfaNlNCRK8WqxAnnZMvGnCnTH9ymeEP12vwPuMenimiqmwD7XZR6o5fRGLK9z/XlaAMofX
ogF8LTl+tTR8/RmkwdXOzWBaGVxVvt0ZObdnZOIlx6b9JI2wFyW2/nF5h4Q+Wad7YsU0Ohu4d5toW6UNZYLw5iaiwpXTcl47EDkmzRLyo420CtLtkW6HhIpI
r0d6HdJRRKIeiTqkq4j0e6TfIT1FZNAjgw6JFJFhjww7pK+I/L1H1lV4ggaK0D8kFHTQUBH6p4TCczLYiti/JLZPJNVM+ltiz6kEVHPpH4k9JxNQzaY1a8rs
DD9nFFBNqfack/hzXgFvUeWe7qbKd616c435ZUVeG5Fl7iKIwMJa3xPG8u+9DYhcGDqTVb9hFU3OFr7j2lFZ8D6cLPkRLOZVQqycMum47/Tg6xCNwDuCP/Yj
MArAdN2PsIxud2KEDfwgnKz8EbYggueMVKm1xaV0POi5uq7/Eb6s2KbidbOA65NDst38A5MyMPa+Wtf4OuHkzsP2NykFVJC0j1WeJySz4h0phZIWDMGU51dQ
T1bVdaoNwaUghF2gYQD9YFoPRvAUc3EBDwI/dKclYQhf47ImXXCclUVeG1oTJu2Ethd409owtLPBpZgygzzXBo9IBFCWCKghEYM+QL8RgC7QbgUggi7SbgcA
lKm2vCUAjoeQdlsAPAR6RV3eG0AHQe32AHpoWhnuNggOmNaFuy2C3f7AA42CJF2nVUDABw90C0ge2Fr9AgS+/2jHAIPgliLcnfD1HcPiAZ/yjOjeIOglrwTL
LuQzrwSXFyglRrUGzTOzb6B8C0czt/C5G/rzB6mf+JKzOEZQN0bXuaw0GYU3B+DXs6yHSe/meiVp7CygVXvIfZ4jPiUuQDUsN7icSfxAWak+dWa4LP1fODPU
03/ld7FPmPA9Mr62l74BuNri4c8IsHKShqpGfuYnl6NJ49alQ9e0mJMKUe+wuwiYcyHqlzndMpIWYm+tMeeEya/u5VCgX3E8vnMiKp69rd5JlvwHuju4LZMh
AAA=

The purple highlighted section just turns the output from the constant combinators into a 1 or 2 tick signal.
The red highlighted section converts negative number outputs into positive numbers and cleans up the signal.

The first signal in order is sent out from combinator 5, and it is erased from the combined signal by combining the wire with the output of combinator 2, which multiplied everything by negative 1. Therefore the second loop will use all negative numbers and the second signal will be output as negative, which is why the output needs to be hooked to a thing that turns negative signals into positive.

*EDIT* I posted this before I saw your guys latest posts. And I just now saw your requirement that the sequence doesn't matter. If that's ok then you can split the input by over/under average and then run both of those through parallel versions of my design, delay one of them by 1 tick, and then reconnect the outputs.

*EDIT 2* I realized that you'd have to split the input by exactly half. So to do that you would need the median, not the average, and I'm not really sure how to calculate the median.

[piriform]

I tried a number of configurations and No Joy. Best can output @2-3 ticks/signal.
DaveMcW's comment led me to investigate the following.

hmm2.jpg (38.49 KiB) Viewed 31474 times

Interesting, but probably a distraction. Although, if the signals have an upper limit and the signals are subtracted from that limit then inverted???

I'd like to know a bit more about the signal values
a) are values increasing (or can be made) monotonically or at least in some order?
b) Can the set (of signals) be partitioned and treated in parallel?

[XKnight]

I'd like to know a bit more about the signal values
a) are values increasing (or can be made) monotonically or at least in some order?
b) Can the set (of signals) be partitioned and treated in parallel?

a) signals don't have any strict order
b) as you wish, but this will be your own implementation detail

[Dr. Walrus]

Posted a new contraption, the variable signal delayer. Check it out.

XKnight, did you ever come up with a solution for your challenge? If you split the signals by above and below the median you could do two of those things I posted in parallel, but you would have to know the median in advance, and you wouldn't have as much control over the order the signals came out.

[XKnight]

Posted a new contraption, the variable signal delayer. Check it out.

XKnight, did you ever come up with a solution for your challenge? If you split the signals by above and below the median you could do two of those things I posted in parallel, but you would have to know the median in advance, and you wouldn't have as much control over the order the signals came out.

In fact, I found the solution 2 days ago, but it has about 40 combinators (3 ticks first delay) which makes this build quite expensive.

[DaveMcW]

Here is a solution with 30 combinators, not counting the loader. Unfortunately it suffers from this bug, so the timing is a bit messed up. I'm sure it can be optimized further, but I am happy just to get it functional.

It uses my previous strategy, with the added feature of splitting the data set above and below the average. This gives 2 signals every 2 ticks. Since the average is 2 ticks behind, I inject the partial result from the ANYTHING signal directly into the AVERAGE calculation to keep it accurate.

The blueprint is missing the red wire between the constant combinator and the electric pole; add that when the build is complete.

Blueprint

Code: Select all

H4sIAAAAAAAA/+1bbW+jSAz+KxUf7+geMwwhaI+T7vVPrE4RS6YtEoGIkNVGUf/7kQRCYGaMTcg1rfbTahU8GD+25/FLl/lDmsdR+rAI9zIrkzKRm3C/z6KV
DK2oSMqXlSyT+DHOV1+TLCrzwrLX+aZ6Ls/C/ffwkX3y7F31j/Nqx3mWyfjwS3XEF4tZ/4b7Qi6r444n7xbJMpzZcVLE26Q8/Ie/vr7aXyyue/Dw2/HIZVKf
2GoT7p+SYlMuNslzFqXhvtytK22/JUW5jVLLPil/+vFRRvGLdTxoU0ZZGTp2vpZFdNTf+tmy82253lKOOqhV22cll8l29SjT6quLykjrPJVd8ziNdT55OPuw
rn3si5/cvulaRZYyTpayMKPET3r4OCXE5ZtYRwnW18J+LqTMzBhD4gzE3zZppH+rMFvOUyzXcazaeiO8aiMP56AkvqZbefTD1ToqDgiFVjjC+6oD1rtFnG+z
cvFU5KtFklUHhFZZHI5vPQITui7JKdDIITxEdeUJIv1s4TrSH9llqP9EMvbpLKI9GcmeM6w9+ylz2J42lHDv3tSDycwh2dkDshEirbhmcR97lzHzGf3UpNHA
M4Pr933o4ye2Ie+gBeEccA4ENDMzNAFwsjH0SXfp/MetpsGfxnSUADIj4SOx/hA5lkYNmIN1dn0YEVCYm1HoavEjIGooBQnKAA/F+/P64Xqt4cTVP61Yo8xg
eeWiqzyFTL/aT0layuJQfGO+7QjH0VCVi1QEI8mW8vsJMCyNqm9KgVS5G2ycX0WdmMCy376lNO9RaNz1gR9lu/IlyZ5pwd+C0kb/ryNcdiou1DBlJMQcUbn1
PbfToEBXMQYcgTKGKw5zRxj/9oYY06KYIyoeMz0dYk+Dh/Uw1WTBu8H0LeOW0zKz37UqgnB1axugqu0F+Axwhj5zGHztnSXqWwbxIINwqQRCidHrCITggQhm
Pg88DZMYpk1iFGuqpZjpo1UH4s60n82Z8MXcnQl/DIGqQWPI1MsRARJAHfGBrumI6Kle0Z2NXFG3fJPFORSn4i+cZuFAa1SFqgI1jQLS9TZuPU5rZVraGWNl
yhQPaWig3u9f6p37A0EwOTABUwmDseOKKBs4g7G+qoAlXEanILyocn8huUTtX0TAnclzV/8ZsJdqBg6YPfKBBs9HBowYoJhqCxiYKvJmvAAmyQc61O8WL2T3
FAmW6+jjybgqMfTs/3Ft0cqjG11bRHoApRZgEOT253w6sKCz8ckPEbbc+6C31mC94NHLhfmNyoX5iHJBTJ7BuQ9VC9M3Rd+4WkAXlOhlKx0DpPlHY5JODS00
3oH1brzumjxwI903qyhNwanJKRFzfGRCNM9VaQO1482RNy9+pwlRuYjp25nq8uL40rGBWxtrT1G6oZXmjGRooDZQ4TaCwAHGOn3hPqXxae1C7F4pv+y34QYF
WMCMI3n4ySmn7pMwT5rXD2Y6l5zogAUeV52gE0cEWDSBIk1VwsgooE+52YrtJF4w8Vj1FErIi1pg9mGBtRahkBTcJaXnjC5U6Nxd2px2NZCTYEOs//VjpwMb
uoWi5NrBN2mmcncVbtPCVs9Z5kjcHAATRICoLM6Em9AMo+6nwpqY7nESBuSUB9r5pmsCb8Ct8f15pL29a8w3zZ9VXbGmp/xZFfL+xTojMFASQEWhhLfOiQny
tvFyAS8H4L5WmcE9JaAb9XxJ2MOBcZNOaj8wrllgJUcGLUsDAyABrG0JBF/pJx1Q3uz8AOtR+dV7d37cVAkLLpm+XhMqN7mCb1no45r1o2wNObuhcYi+DdTQ
uSenp0GAXsYPLrtc2F20gLaKdrpV2HG2ROuiM80Svo2S5G33vZbkSEn3LBnUki5SUrTazmpRgRT12jFYsyToIUVnrWgtOUNK+mfJZuTmIyXn7Zc2onOkaHAW
dRt9A6To72dRz2ncwUHK/tG+thHFutKf7cc2GjOsM/3VgnPegsS609+tC59Holh/+ucs65+XTr0RTXBmHAjDhIcBlcAxs1aqJPHxvH2tnm28PKqHPxey3BbZ
w+KzzJb/AaLXsLFXQwAA

iterator.jpg (743.71 KiB) Viewed 31387 times

[XKnight]

And here is my solution:

- 18 combinators
- 3 ticks first delay (may be reduced to 2 ticks, but this is not so important)
- doesn't use negative mirror, as a result it doesn't suffer from this bug and any decision that will be made there
- input values should be in range 100...200 (may be increased by changing constant)

1.png (706.21 KiB) Viewed 31374 times

Blueprint

Code: Select all

H4sIAAAAAAAA/91b7W6rOBB9lYqfu+QKm2/dZaX9fImrVUTBbS0lEBHnaqMo776QECgG22NDbtPtr1ZwbDNzZjxz7Obl06bM0s3TOjmRglFGyT45nYp0SxJr
f3jes5TRsrDsXbmnzW/J6d9kFdjHZBWez3b7YlYW9YsFW2Xl9pkWKSsrDuF+8S+YL/7Zrt8uSNY8qqf6ZiHrn+T0WhFSv3ldw3FN88StR+//iu2MVtmBsuYP
fG5+wJPrz40HcweD6URGiTib5CSjOanEJsENwG8WldPquqYkAC7QH5rj/WqRw5vK/mbhZpiK5INBhm+i+kXFROhih3qFOW0X2H5kcnqh1Z6t9/S1SDfJiR13
tQW+04od0o1lt4a7PFylxZG90eLVOtt70ozFoSgj2xukfpxVhBGrmXW7S6vGjIn1q2WXB7Y78BMKobvjOisPBVu/VOV2TYsamlisOtRPNXgUXnnkm3I4HNkS
TBaEmpm9IVkwcBXBOw6Mn6JgcRc/bxrLTrt3GnFZFuflROBl6ZwCX7+km72es1fx1duuyNt8NMVjM77QDSNVk0+1vqBefIJsWuSkdny9Yj0DvkdjDYqtwu5z
VRTjPz2aTB2xJEeN0rkoR2GkzlGc5e1BIn8YOv+yIJ351AXba4x8y28nNnAX4v225C4knmgRf5M0e7vD7iSdbFFH4/mO5sIIiT2NXXC94UpmcNUskFFxvIqP
poFevOvRIK0oe9sSRjNxxWAe8bwrZMWDwuz9QqctL7TjdXdOVsgud6S6lNuJ9ZNW3adTXplHjSQyENYwJJaM4y1eoc3ktl5ptji3PbC71Ix9b2gX3jop+iIV
7xWGatnvvCf/zwY21wiB0DwEPHAxF0hsP4fkqjTizGHvd1J1HetC2zSakXDANsSTm2gIpvjd+sIPc4u66UPo2vU5jWv02jdk3LvhDom7vg2GdDuk2yJdINLr
kF6L9IBIv0P6LdIHIoMOGbTIAIgMO2TYIkMgMuqQUYuMgMi4Q8YtMgYif+uZ4Nyo4ACxv/fYjkZQHv3RY29EQlAm/dljb1RCUC791WNvZEJQNv3dY290Qr5R
yCKoUINmKzVowsHase4bx3poHOvYONaRebB3hNKPdhQZh3sXPvrxjswDPjKPd9c83LFjHu7eB0X7VLAr1Y2425u1y6ZoKBfwopOkNZPJi9GCzZigLNKTk3rl
EaaDA7qtq9WRkdVHqRas896loULOj2yprsekRoaTaOcY3qQqbPoJK3iY/mmUIbBEgeHVycEz+FkGrwdNtGe8jime6RF0oHtqnDBXm6UlmZwtFO1U4TUYhdeH
puRs8CoeQc6+56kGVM42i+uRVCeMT8l51lga/LxCt1HMSBPTSLsTmtiTjLK84PTAMrfKU565p3xwgSAj/JwDtUfTY8EqwjzdzzcWA7pWSl8NQObSH5qhByBz
PcAx1gPiD1D/QmMxIDAXA3xzMcAz1wJmKH94YSlAHbFRH7DAk7/xHVLNUB9esuoFPM2iFZnd+ZQ2KJKG0ZXUqS68OMLQUabPne7QvCxwk1TUwMy7SQqpwkC1
7MSNUvC9Kr7UmmxBlr9ZsIBTRPWAnlNGUhfEK6CCS01ucecg85g7unjzfy6Agdf2NRL8lP1ECV748ZctFMde7Ic47nZwzcLdqG53+ZuMEwHr6lyveDBpenFN
IIamUVXfY34J4vPd87lUIK5ZBcLv8zJxcpACR1YUUlhWx/D0nooPxb2sWV0rdpwfUDxATmQaH3pL+FDmJ1lcQCq+sdcfUjKT/pNbqH4vur52tml2+axTu2XY
wnish2w7B3s0dD3Q13qJh6p4Wn8lRf4fhN7fbqA3AAA=

[XKnight]

Here is a solution with 30 combinators, not counting the loader. Unfortunately it suffers from this bug, so the timing is a bit messed up. I'm sure it can be optimized further, but I am happy just to get it functional.

It uses my previous strategy, with the added feature of splitting the data set above and below the average. This gives 2 signals every 2 ticks. Since the average is 2 ticks behind, I inject the partial result from the ANYTHING signal directly into the AVERAGE calculation to keep it accurate.

The blueprint is missing the red wire between the constant combinator and the electric pole; add that when the build is complete.

I found several problems in your build:
Input: your test case;

Ouput per tick

1: 1 "1"
2: 25 "5"
3: empty
4: 32 "9", 4 "2" <-- in this case 3 signals should be present in output, becase 3, 4, 5 ticks were used.
5: empty
6: 50 "A"
7: 9 "3"
8: 27 "D"
9: empty
10: 48 "E", 16 "4" <-- the same problem as above
11: empty
12: 75 "F"
13: 2 "6"
14: 18 "8"
15: empty <-- unknown issue
16: 3 "B"
17: 8 "7"
18: empty <-- unknown issue
19: 12 "C"

Also, you loader has a little bit complex mechanic... it sends reduced number of signals each tick, which (in my opinion) is not the same as "send 15 different signals each 15th tick". But it is your decision whether or not to count loader as a part of solver.

By the way, here is my output on your test:

Ouput per tick

1: 1 "1"
2: 4 "2"
3: 9 "3"
4: 2 "6"
5: 16 "4"
6: 25 "5"
7: 8 "7"
8: 18 "8"
9: 32 "9"
10: 3 "B"
11: 50 "A"
12: 75 "F"
13: 12 "C"
14: 27 "D"
15: 48 "E"

[DaveMcW]

Yes, the bug makes the output incorrect. It is designed for Factorio 0.12.27.

Edit: Still not fixed. Maybe Factorio 0.12.28...

[piriform]

The following is NOT a solution that was asked for, but may be of use to some as it deals with a similar type of a problem. Specifically, how to quickly time sort many signals into relatively few time slots. There are 5 time slots In the diagram, although the circuit can be extended indefinitely provided one is willing to pay for 2 deciders per additional slot.

sts.jpg (41.09 KiB) Viewed 10511 times

How it works. The signals value correspond to the desired time slot. All the signals are dumped into the sorter in a pulse 1 tick wide. The deciders on the left select all the signals that belong in the desired time slot and inject them into the delay line formed by the deciders on the right.

[Amegatron]

This one is a little more specific. It inputs the rising edge of a signal, and outputs it later after being delayed by a custom number of ticks. The tick length of the delay is set by the value of the blue signal in the top-right constant combinator. For this contraption to work properly It has to receive a signal with at least 1 positive number and It can't contain any blue signals. The minimum delay is 5 ticks, and the maximum is 99,999,999 in case you want to input a signal and have it output once you finish college.

Damn, this is what I was looking for. But still I cannot understand how does it work :/ I've already started a topic nearby about delayed pulse generator. Seems your solution could help me. Could you please explain or maybe just post this layout more spaced so I could clearly see all wires?

[XKnight]

This one is a little more specific. It inputs the rising edge of a signal, and outputs it later after being delayed by a custom number of ticks. The tick length of the delay is set by the value of the blue signal in the top-right constant combinator. For this contraption to work properly It has to receive a signal with at least 1 positive number and It can't contain any blue signals. The minimum delay is 5 ticks, and the maximum is 99,999,999 in case you want to input a signal and have it output once you finish college.

Damn, this is what I was looking for. But still I cannot understand how does it work :/ I've already started a topic nearby about delayed pulse generator. Seems your solution could help me. Could you please explain or maybe just post this layout more spaced so I could clearly see all wires?

Your task gave me an idea of interesting challenge:

Signal delayer challenge

Task: delay input signal for X ticks (X may be set by user)

Expected result: the same as X series-connected arithmetic combinators (input: Each + 0; output: Each)

Example of delay 3
Tick: Input signal/Output signal
1: 10/empty
2: 20/empty
3: 30/empty
4: 40/10
5: 50/20
6: 60/30
7: 70/40
8: empty/50
9: empty/60
10: empty/70

Main focus: amount of combinators

[Dr. Walrus]

Quotes

This one is a little more specific. It inputs the rising edge of a signal, and outputs it later after being delayed by a custom number of ticks. The tick length of the delay is set by the value of the blue signal in the top-right constant combinator. For this contraption to work properly It has to receive a signal with at least 1 positive number and It can't contain any blue signals. The minimum delay is 5 ticks, and the maximum is 99,999,999 in case you want to input a signal and have it output once you finish college.

Damn, this is what I was looking for. But still I cannot understand how does it work :/ I've already started a topic nearby about delayed pulse generator. Seems your solution could help me. Could you please explain or maybe just post this layout more spaced so I could clearly see all wires?

I've been a bit busy with work lately and I'm away from my factorio computer so I'll give you a quick rundown on how it works. IF you are still confused I'll post a complete breakdown in a few days.

The input signal is run through a 1 tick limiter that only outputs the first tick of a signal. It is then run through a memory cell, which is connected to the output. When the input signal passes through the 1 tick limiter it then gets stored in the memory cell and simultaneously starts a clock that goes up by 1 every tick. The clock keeps going up until it hits the user specified value of how many ticks you want to delay the signal. When this happens, simultaneously the memory cell is told to output its contents and clear its memory (which generates a 1 tick pulse for the output) and the clock gets reset.

It's a fairly kludgy design and there's probably better ways to set up the internal logic to reduce the number of combinators.

Your task gave me an idea of interesting challenge:

That's quite an interesting challenge again XKnight. In your example, it seems like you would need at least 7 memory cells, one to save the value of each individual tick in the input signal. Waiting a variable amount of time wouldn't be too hard, just affix a blue signal of the value of the input tick to each input and then output when a clock = that signal + user selected delay. However if you wanted to use less memory cells than the number of individual ticks, that would be tricky. You would have to encode your signals somehow so multiple signals could fit on the same combinator. hmmmm... Once again you've given me another idea for my next combinator contraption, but an elegant solution to your challenge eludes me.

[XKnight]

You would have to encode your signals somehow so multiple signals could fit on the same combinator. hmmmm... Once again you've given me another idea for my next combinator contraption, but an elegant solution to your challenge eludes me.

Right direction, keep going!

[Dr. Walrus]

I've just posted a new contraption, The Basic Encoder. It takes any individual signal under 10M and changes it into a single blue signal that contains both the type and value of the signal. This one could be the starting point of a device that allows you to store multiple signals of the same or of different types in one memory cell if you have those signals encode as different item depending on their order.

[piriform]

I could not load blue print due to error: Unknown entity basic-pressure-plate. In the meantime my WAG is that you are using a form of Godelization .

[Dr. Walrus]

I could not load blue print due to error: Unknown entity basic-pressure-plate. In the meantime my WAG is that you are using a form of Godelization .

Oops! Good catch. It's fixed now.
And yes it does use Godel numbering, but only in the most primitive sense of the concept. The amount of the input signal is just converted to blue, and the type of the signal is converted into a number where wooden chest = 1, iron chest = 2, etc. and then multiplied by 10M. When added together the amount of the blue signal contains both the type and amount of the signal without going over the game's 32 bit signed integer limit. Using the true Godel numbering system with the product of a series of primes raised to the numbers you wish to encode would be huge, slow and really cool but would probably go over the integer limit really quickly. And the decoder would require me to build a contraption that calculates the nth root [ x^(1/n)] which is too big of an undertaking for me.

*Edit to avoid double posting*
Since I accidentally included pressure plates in my last contraption, the next contraption is all about pressure plates. The pressure plate stopwatch, for when you want to play factorio at 6:00 but you've got a track meet at 4:30.

[Black Ice]

This is my first attempt at a computer in factorio. It's 256, 5 by 7 displays arranged in a 16 by 16 grid and it can type, by placing copper plates in the "keyboard", do very basic maths and algebra and has some basic memory. Was hoping to put in a game next (chess??) and any advice would be appreciated.

Computer in Factroio.png (6.82 MiB) Viewed 10206 times