)
}
}
)
(
}
{
)
)
(
)
(
(
{
}
)
(
)
}
)
)
{
(
(
)
)
}
)
(
}

### Other Gates from NAND

1. `const nand = ([a, b]) => +!(a & b)`
2. ` `
3. `const not = ([a]) => nand([a, a])`
4. ` `
5. `const and = ([a, b]) => nand([nand([a, b]), nand([a, b])])`
6. ` `
7. `const or = ([a, b]) => nand([nand([a, a]), nand([b, b])])`
8. ` `
9. `const nor = ([a, b]) => `
10. `  nand([ `
11. `    nand([nand([a, a]), nand([b, b])]), `
12. `    nand([nand([a, a]), nand([b, b])])`
13. `  ])`
14. ` `
15. `const xor = ([a, b]) =>`
16. `  nand([`
17. `    nand([a, nand([a, b])]),`
18. `    nand([b, nand([a, b])])`
19. `  ])`
20. ` `
21. `const xnor = ([a, b]) => `
22. `  nand([ `
23. `    nand([nand([a, a]), nand([b, b])]),`
24. `    nand([a, b])`
25. `  ])`
26. ` `
27. ` `
28. `const inputs = [`
29. `  [0, 0],`
30. `  [0, 1],`
31. `  [1, 0],`
32. `  [1, 1]`
33. `]`
34. ` `
35. `const testGate = ({ gate, truth, result }) => console.log(`
36. `  gate + ' matches truth? ', `
37. `  truth+'' === result+'' ? `
38. `    'yes :D' : `nope :( \${truth} \${result}``
39. `)`
40. ` `
41. `testGate({`
42. `  gate: 'NAND',`
43. `  truth: [1, 1, 1, 0],`
44. `  result: inputs.map(nand)`
45. `})`
46. ` `
47. `testGate({`
48. `  gate: 'NOT',`
49. `  truth: [0, 1],`
50. `  result: [[1], [0]].map(not)`
51. `})`
52. ` `
53. `testGate({`
54. `  gate: 'AND',`
55. `  truth: [0, 0, 0, 1],`
56. `  result: inputs.map(and)`
57. `})`
58. ` `
59. `testGate({`
60. `  gate: 'OR',`
61. `  truth: [0, 1, 1, 1],`
62. `  result: inputs.map(or)`
63. `})`
64. ` `
65. `testGate({`
66. `  gate: 'NOR',`
67. `  truth: [1, 0, 0, 0],`
68. `  result: inputs.map(nor)`
69. `})`
70. ` `
71. `testGate({`
72. `  gate: 'XOR',`
73. `  truth: [0, 1, 1, 0],`
74. `  result: inputs.map(xor)`
75. `})`
76. ` `
77. `testGate({`
78. `  gate: 'XNOR',`
79. `  truth: [1, 0, 0, 1],`
80. `  result: inputs.map(xnor)`
81. `})`

Use NAND to create a bunch of other gates ðŸ˜€ – I used this wikipedia article for reference

snippet.zone ~ 2021-24 /// {s/z}