Una semplice sfida di Manufactoria. Calcola l'input modulo 7. L'ingresso sarà in binario big-endian (blu = 1, rosso = 0). L'output dovrebbe essere nello stesso formato.

Casi di prova forniti. Vince il conteggio delle parti più piccolo.

http://pleasingfungus.com/Manufactoria/?ctm=Mod7;Input:_binary_number_big_endian._Output:_that_binary_number_mod_7;bbb:|brrr:b|brrrr:br|bb:bb|bbrrb:brr|brrrrb:brb|bbrb:bbr; 13; 3; 1 ;

(se l'ingresso mod 7 è 0, non viene emesso nulla.)

L'algoritmo è piuttosto semplice: calcola il modulo usando una macchina a stati (la parte più grande con otto rami - uno degli stati è duplicato per scopi logistici), quindi codifica e raccogli i risultati. Poiché quasi tutti i risultati contengono una cifra, viene utilizzata una fase di compressione aggiuntiva per ridurre la quantità di parti.

Progettato in yEd, quindi trascritto in Manufactoria.

Secondo me, usa troppi nastri trasportatori.

58 43 parti

http://pleasingfungus.com/Manufactoria/?lvl=33&code=c16:9f0;q15:9f3;q14:9f3;q13:9f3;c12:9f3;c16:10f1;r15:10f3;r14:10f3;b13:10f3 ; q12: 10f4; p11: 10f4; c16: 11f1; I15: 11f7; Q14: 11f7; q13: 11f7; Q12: 11f7; c11: 11f2; r15: 12f3; B14: 12f3; c12: 12f3; c15: 13f0; c14 : 13f0; c13: 13f0; r13: 12f3; y10: 3F3; c10: 4F2; g10: 5f1; Q10: 6f4; y11: 3F0; q11: 4F6, r11: 5f3; p11: 6f4; B11: 7F1; I12: 4f7 ; c12: 5f3; Q12: 6f0; g12: 2F3; c12: 3F3; p13: 4F6; Y13: 3F0; c13: 5f0; c12: 7f3; b12: 8f3; & MC = Mod7; ingresso: _binary_number_big_endian._Output: _that_binary_number_mod_7; bbb : | brrr: b | brrrr: br | bb: bb | bbrrb: brr | brrrrb: brb | bbrb: bbr; 13; 3; 1 ;

L'idea di Keith Randall di convertire prima l'input in unario era abbastanza buona, quindi l'ho rubato. ;-) Convenientemente, avevo appena trascorso un po 'di tempo a ottimizzare piccoli convertitori da binario a unario in Manufactoria , quindi ho appena scelto una delle mie soluzioni quasi funzionanti * da quella sfida e l'ho combinato con un contatore mod-7 rapidamente ottimizzato.

Questo design è ora nel punto in cui il solo spostamento dei robot dall'alto verso il basso sta iniziando a richiedere trasportatori extra altrimenti inutili. Eventuali ulteriori riduzioni significative delle parti verranno probabilmente dalla riprogettazione del layout per renderla più alta e più stretta.

(* Quella sfida richiedeva a) che il design si adattasse a una scheda 7 × 7 eb) che l'output unario fosse in marcatori rossi. Se guardi la parte del convertitore binario-unario della macchina sopra, noterai che, con una o due parti extra, può facilmente soddisfare entrambi i requisiti, ma purtroppo, non entrambi.)

Ecco la versione precedente di 58 parti:

http://pleasingfungus.com/Manufactoria/?lvl=32&code=g12:2f3;q13:13f5;c14:13f0;c15:12f3;c9:6f2;c9:7f1;c9:8f1;c9:9f1;c10:4f3 ; c10: 5f3; i10: 6f5; c10: 7f2; c10: 9f0; B11: 3f2; p11: 4F1; c11: 5f1; p11: 6F2; p11: 7f2; c11: 8f3; p11: 9f3; B11: 10F2; c12 : 3f2; c12: 4F2; c12: 5f0; R12: 6F3; c12: 7f3; I12: 8f1; I12: 9f5; Y12: 10F3; c13: 3f2; c13: 4F3; i13: 5f1; c13: 6F3; c13: 7f2 ; i13: 8f0; c13: 9f1; c14: 3F3; c14: 4F2; p14: 5f5; c14: 6F1; p14: 7f6; p14: 8f7; r14: 9f3; c15: 4F3; q15: 5f0; c15: 6F3; c15 : 7f3; I15: 8f6; c15: 9f3; q15: 10f7; c15: 11f3; R12: 12f2; p13: 12f7; B14: 12f0; B14: 11f3; b12: 11f3; Y14: 10F3; Y15: 13f0; & ctm = Mod7 ; Input: _binary_number_big_endian._Output: _that_binary_number_mod_7; bbb: | brrr: b | brrrr: br | bb: bb | bbrrb: brr | brrrrb: brb | bbrb: bbr; 13; 3; 1 ;

Come la soluzione di Jan Dvorak , anche questo si basa su un FSM a 7 stati. Ho etichettato le porte corrispondenti a ciascuno stato nello screenshot per facilitarne la lettura. La stessa macchina a stati, tuttavia, è davvero la parte facile; la parte difficile sta generando l'output finale con un numero minimo di gate.

Un trucco che ho trovato utile è stato il ciclo di copia finale che sposta il barilotto fino alla fine di tutto ciò che è stato scritto prima del marcatore giallo (mentre si toglieva anche il marcatore verde): questo mi ha permesso di utilizzare la ripetizione nei bit di output di ordine superiore di generare gli output come:

0:  Y   ->
1: BY   ->   B
2:  YBR ->  BR 
3:  YBB ->  BB
4: RYBR -> BRR
5: BYBR -> BRB
6: RYBB -> BBR

Questo mi consente principalmente di combinare i percorsi di uscita per le uscite 2, 4 e 5 (che iniziano tutte con BR) e 3 e 6 (che iniziano con BB).

60 parti

La mia soluzione è piuttosto diversa. Prima converte i binari in unari, quindi fa la mod 7. Non riesco a battere Ilmari.

In realtà non avevo idea di cosa stavo facendo, ma funziona e potrei essere il vincitore (se solo i casi di prova fossero sufficienti). : D

EDIT: ottimizzato 2 volte, un po 'più piccolo ora (spazzatura rimossa)