对于nandgame爱好者：请在逻辑门中也尝试DPD十进制！

背景

密集包装的十进制（DPD）是一种以二进制有效存储十进制数字的方法。它以10位存储三位十进制数字（000至999），这比朴素的BCD（以4位存储一位数字）的效率要高得多。

记号

• 小写字母ato i是复制到十进制表示形式的位。
• 0和1是输入或输出位模式中的确切位。
• x 转换中将忽略这些位。

换算表

以下是从10位DPD到三位十进制数字的转换表。每个十进制数字都表示为4位二进制（BCD）。双方都从最高位到最低位从左到右书写。

Bits                 =>  Decimal         (Digit range)
a b c d e f 0 g h i  =>  0abc 0def 0ghi  (0-7) (0-7) (0-7)
a b c d e f 1 0 0 i  =>  0abc 0def 100i  (0–7) (0–7) (8–9)
a b c g h f 1 0 1 i  =>  0abc 100f 0ghi  (0–7) (8–9) (0–7)
g h c d e f 1 1 0 i  =>  100c 0def 0ghi  (8–9) (0–7) (0–7)
g h c 0 0 f 1 1 1 i  =>  100c 100f 0ghi  (8–9) (8–9) (0–7)
d e c 0 1 f 1 1 1 i  =>  100c 0def 100i  (8–9) (0–7) (8–9)
a b c 1 0 f 1 1 1 i  =>  0abc 100f 100i  (0–7) (8–9) (8–9)
x x c 1 1 f 1 1 1 i  =>  100c 100f 100i  (8–9) (8–9) (8–9)

任务

将10位DPD转换为3位十进制数字。

测试用例

DPD           Decimal
0000000101    005
0001100011    063
0001111001    079
0000011010    090
0001011110    098
1010111010    592
0011001101    941
1100111111    879
1110001110    986
0011111111    999
1111111111    999  * Output is same regardless of the `x` bits

输入项

默认输入格式是10位的列表。这些位应遵循上面的确切顺序，或相反。您可以选择使用等效的字符串或整数表示。与其他挑战不同，不允许重新排序或使用嵌套结构。

对于input [1, 1, 0, 0, 0, 1, 0, 1, 0, 0]，允许以下格式：

• 位列表： [1, 1, 0, 0, 0, 1, 0, 1, 0, 0]
• 串： "1100010100"
• 二进制整数：788或0b1100010100
• 十进制整数： 1100010100
• 颠倒：[0, 0, 1, 0, 1, 0, 0, 0, 1, 1]并以上述任何其他格式颠倒

不允许以下格式：

• 任意重新排序位： [0, 0, 0, 0, 0, 1, 1, 1, 0, 1]
• 嵌套结构：[[1, 1, 0], [0, 0, 1], [0, 1, 0, 0]]或[0b110, 0b001, 0b0100]

输出量

默认输出格式是3个十进制数字的列表。每个数字应表示为0到9，可以是整数或字符。在输入中，您可以选择字符串或整数表示。如果选择整数表示，则可以省略前导零。

得分和获胜标准

适用标准代码高尔夫球规则。每种语言的最短程序或函数（以字节为单位）获胜。

JavaScript（ES6），112字节

此简短版本的所有功劳归于@nwellnhof。

将输入作为整数。返回三个十进制数字的数组。

n=>[(x=n>>4,y=x>>3,q=n/2&55,p=q%8)>5&&q-39?8|y&1:y,(p&5^5?x&6:q-23?8:y&6)|x&1,(p<5?p*2:p<6?x&6:p%q<7?y&6:8)|n&1]

在线尝试！

的JavaScript（ES6），118个 117字节

将输入作为整数。返回三个十进制数字的数组。

n=>[(x=n>>4&7,y=n>>7,p=n/2&7)>5&&p<7|x/2^2?8|y&1:y,(p<7?p-5?x:8:x/2^1?8:y&6)|x&1,(p<5?p*2:p<6?x&6:p<7|x<2?y&6:8)|n&1]

在线尝试！

怎么样？

该代码不是尝试应用“官方”算法，而是基于对预期结果中可以找到的模式的某种反向工程。

给定输入整数，我们计算：$n$

示例：第一位数（百位）

x     | 0                | 1                | 2                | 3               
n & 1 | 0101010101010101 | 0101010101010101 | 0101010101010101 | 0101010101010101
p     | 0011223344556677 | 0011223344556677 | 0011223344556677 | 0011223344556677
------+------------------+------------------+------------------+-----------------
y = 0 | 0000000000008888 | 0000000000008888 | 0000000000008888 | 0000000000008888
y = 1 | 1111111111119999 | 1111111111119999 | 1111111111119999 | 1111111111119999
y = 2 | 2222222222228888 | 2222222222228888 | 2222222222228888 | 2222222222228888
y = 3 | 3333333333339999 | 3333333333339999 | 3333333333339999 | 3333333333339999
y = 4 | 4444444444448888 | 4444444444448888 | 4444444444448888 | 4444444444448888
y = 5 | 5555555555559999 | 5555555555559999 | 5555555555559999 | 5555555555559999
y = 6 | 6666666666668888 | 6666666666668888 | 6666666666668888 | 6666666666668888
y = 7 | 7777777777779999 | 7777777777779999 | 7777777777779999 | 7777777777779999

x     | 4                | 5                | 6                | 7               
n & 1 | 0101010101010101 | 0101010101010101 | 0101010101010101 | 0101010101010101
p     | 0011223344556677 | 0011223344556677 | 0011223344556677 | 0011223344556677
------+------------------+------------------+------------------+-----------------
y = 0 | 0000000000008800 | 0000000000008800 | 0000000000008888 | 0000000000008888
y = 1 | 1111111111119911 | 1111111111119911 | 1111111111119999 | 1111111111119999
y = 2 | 2222222222228822 | 2222222222228822 | 2222222222228888 | 2222222222228888
y = 3 | 3333333333339933 | 3333333333339933 | 3333333333339999 | 3333333333339999
y = 4 | 4444444444448844 | 4444444444448844 | 4444444444448888 | 4444444444448888
y = 5 | 5555555555559955 | 5555555555559955 | 5555555555559999 | 5555555555559999
y = 6 | 6666666666668866 | 6666666666668866 | 6666666666668888 | 6666666666668888
y = 7 | 7777777777779977 | 7777777777779977 | 7777777777779999 | 7777777777779999

算法：

• 如果，则$p<6$$d=y$
• 如果，则$p=6$$d=8+(y\bmod2)$
• 如果，则$p=7\text{ AND }(x<4\text{ OR }x>5)$$d=8+(y\bmod2)$
• 如果，则$p=7\text{ AND }(x=4\text{ OR }x=5)$$d=y$

作为JS代码：

p > 5 && p < 7 | x / 2 ^ 2 ? 8 | y & 1 : y

Python 3中，229 ... 97个 96字节

lambda a:[[a&6,a>>4&6,a>>7&6,8][b"  eW7B]Oys"[~a&8or~a&6or~6|a>>4]%x&3]|a>>x%9&1for x in[7,4,9]]

在线尝试！

@xnor -4字节

@nwellnhof -6个字节

格式：

h = lambda a:[
    [a&6, a>>4&6, a>>7&6, 8][              List to take high bits from
        b"  eW7B]Oys"[                     10 char string; where to get high bits for
                                             indicator values 1-8. 0th,1st chars not used.
            ~a&8 or ~a&6 or ~6|a>>4]       Compute indicator (by @nwellnhof)
        %x&3]                              High bits of each digit
    | a >> x%9 & 1                         bitwise OR with low bit of each digit
    for x in [7,4,9]]

说明

因为我最初想在Jelly中实现此功能，所以我与此处的大多数答案采用了不同的方法，该方法很简单，也许适合于高尔夫语言。尽管golfed函数采用整数，但让输入作为位列表为[a0,a1,...,a9]。然后我们可以从输入中得出三个值

• 低位[a2,a5,a9]：[d0,d1,d2]分别始终是低位。
• 高位[2*a0a1,2*a3a4,2*a7a8,8]：每个数字的高位将是其中之一。
• 指示位，[a3,a4,a5,a7,a8]确定如何获取每个数字的高位。我们计算指标（1到8之间），如下所示：
  • 如果a5 == 0，则指示符为8（最初为0，但是使用8则节省了一个字节）
  • 如果a3 nand a4，则指标为6-2 * a3a4
  • 否则，指标为2 * a7a8 + 1（实际上计算为负数）。

然后，可以high_bits[arr[indicator][n]] | low_bits[n]通过下表将n位数字优雅地计算出来，将其压缩为字符串。

arr = [
    [0,1,2],
    [3,1,2],
    [1,3,2],
    [2,1,3],
    [2,3,3],
    [3,2,3],
    [3,3,2],
    [3,3,3]
]

的JavaScript（Node.js的），126个 119 117 112 111字节

(a,b,c,d,e,f,g,h,i,j)=>[(g&h&i+(b+=a*4+b,e+=d*4+e)!=5?8:b)+c,(g&i?h+e-3?8:b:e)+f,(g?h<i?e:h>i*e?b:8:h*4+i*2)+j]

在线尝试！

-5个字节，感谢@tsh（还有2个我自己），因此l可以比我预期的付出更多的努力。

使用@tsh的技巧再增加-2个字节！

-5个字节，谢谢@Arnauld

-1字节@Neil

输入为10位列表（作为10个参数），输出为3位列表。

C（GCC） ，138个 129字节

f(w){int t=w/2&55,s=t%8,v=w/16,u=v/8;w=((s<6|t==39?u:8|u%2)*10+v%2+(s&5^5?v&6:t-23?8:u&6))*10+w%2+(s<5?s*2:s<6?v&6:s%t<7?u&6:8);}

在线尝试！

首先，将一些位提取到s和中t，以便可以通过以下方式识别转换表的八行：

1.  s < 4              u v w¹
2.  s = 4              u v 8¹
3.  s = 5              u 8 v
4.  s = 6              8 v u
5.  s = 7, t =  7      8 8 u
6.  s = 7, t = 23      8 u 8
7.  s = 7, t = 39      u 8 8
8.  s = 7, t = 55      8 8 8

¹ Can be computed with s*2

然后设置u并v进行除法（右移），使u，v和输入w在位置0-2处包含低三位BCD位。其余的取决于s和t。两个值得注意的技巧是：

s&5^5  // Rows 1, 2 and 4.
s%t<7  // Rows 1-5.

Shieru Asakoto的Javascript解决方案的端口只有124个字节：

f(a,b,c,d,e,f,g,h,i,j){a=(((g&h&i+(b+=a*4+b,e+=d*4+e)!=5?8:b)+c)*10+(g&i?h+e-3?8:b:e)+f)*10+(g?h-i|h&!e?h?b:e:8:h*4+i*2)+j;}

在线尝试！

Ruby，153 ... 119117字节

->n{n+=n&896;a,b,c=n&1536,n&96,n&14;"%x"%n+=c<9?0:2036+[b/16-b-1918,r=a>>8,[r+126,a/16-26,a-1978,38][b/32]-a][c/2-5]}

在线尝试！

怎么运行的：

->n{n+=n&896;

这是起点：向左移动3位以转换为BCD，这适用于大多数模式。

a,b,c=n&1536,n&96,n&14;

获取每个半字节的中间位（以及第三半字节的一个额外位，但掩盖最低有效位）。

"%x"%n+=c<9?0

如果第三个数字小于10（小于9，因为我们从来都不关心LSB），则设置为：这是纯BCD，我们可以输出十六进制而不更改任何内容

:2036+[b/16-b-1918,r=a>>8,[r+126,a/16-26,a-1978,38][b/32]-a][c/2-5]}

否则，通过移位并添加幻数来做一些黑魔法，直到获得所需的结果。

视网膜0.8.2，191个 181字节

(...)(...)
:$1,$2;
..(.),11(.);111
100$1,100$2;100
(10|(..)(.,)01)(.);111
100$3$2$4;100
(..)(.),(00.);111
100$2,1$3;0$1
(..)((.{5});110|(.);101)
100$3$4;$1
1
01
+`10
011
.0+(1*)
$.1

在线尝试！链接包括测试用例。编辑：除非必要，否则不将数字填充到4位以节省10个字节。说明：

(...)(...)
:$1,$2;

插入分隔符，以便每个数字可以分别转换为十进制。这样可以有效地处理转换表中的前两种情况。

..(.),11(.);111
100$1,100$2;100

处理转换表中的最后一个（第八个）情况。

(10|(..)(.,)01)(.);111
100$3$2$4;100

处理转换表中的第六种和第七种情况。

(..)(.),(00.);111
100$2,1$3;0$1

处理转换表中的第五种情况。

(..)((.{5});110|(.);101)
100$3$4;$1

处理转换表中的第三和第四种情况。

1
01
+`10
011
.0+(1*)
$.1

执行二进制到十进制的转换。

果冻，51 48 40 39字节

&\‘f4;s3ɓạ4ḅ-œ?µ/Ḥ
“MY-€-Y¤©¡‘Dịs3Ḅç+ƭ/

在线尝试！

算法

^{除列表索引外，本节中的所有整数均以二进制形式编写。}

给定输入，我们首先构建数组，和。$\alpha\beta\gamma\delta\varepsilon\zeta\eta\theta\iota\kappa$$[\eta\eta, \theta\iota, \delta\varepsilon]$$[\alpha\beta, \delta\varepsilon, \theta\iota]$$[\gamma, \zeta, \kappa]$

1. 如果，则所有三个输出数字均为低（至）。$\eta\eta = 00$$0000$$0111$
2. 如果但，则恰好一个输出数字为高（或）。$\eta\eta = 11$$\theta\iota < 11$$1000$$1001$
3. 如果但，则恰好两个输出数字较高。$\eta\eta = \theta\iota = 11$$\delta\varepsilon < 11$
4. 如果，则所有三个输出数字均为高。$\eta\eta = \theta\iota = \delta\varepsilon = 11$

如果我们计算前导的，则创建一个匹配数字为的数组，并将其与，然后将结果分成长度为3的子数组，在每种情况下我们都得到以下结果。$11$$[\eta\eta, \theta\iota, \delta\varepsilon]$$100$$[\alpha\beta, \delta\varepsilon, \theta\iota]$

1. $[[\alpha\beta, \delta\varepsilon, \theta\iota]]$
2. $[[100, \alpha\beta, \delta\varepsilon], [\theta\iota]]$
3. $[[100, 100, \alpha\beta], [\delta\varepsilon, \theta\iota]] = [[100, 100, \alpha\beta], [\delta\varepsilon, 11]]$
4. $[[100, 100, 100], [\alpha\beta, \delta\varepsilon, \theta\iota]] = [[100, 100, 100], [\alpha\beta, 11, 11]]$

在第一种和最后一种情况下，我们只需要用压缩第一个数组，得到第一种情况是。$[\gamma, \zeta, \kappa]$$[\alpha\beta\gamma, \delta\varepsilon\zeta, \theta\iota\kappa]$$[100\gamma, 100\zeta, 100\kappa]$

其余两种情况相似，但是根据的值，数组和必须重新排序。可能还有。$[100, \alpha\beta, \delta\varepsilon]$$[100, 100, \alpha\beta]$$[\theta\iota]$$\delta\varepsilon$

在第二种情况下，的六个排列是，，，，和。$[100, \alpha\beta, \delta\varepsilon]$$[100, \alpha\beta, \delta\varepsilon]$$[100, \delta\varepsilon, \alpha\beta]$$[\alpha\beta, 100, \delta\varepsilon]$$[\alpha\beta, \delta\varepsilon, 100]$$[\delta\varepsilon, 100, \alpha\beta]$$[\delta\varepsilon, \alpha\beta, 100]$

通过计算，我们映射，，和至四个，三个和两个，选择置换，和。$100-\theta\iota$$00$$01$$10$$[\alpha\beta, \delta\varepsilon, 100]$$[\alpha\beta, 100, \delta\varepsilon]$$[100, \delta\varepsilon, \alpha\beta]$

用压缩结果后，我们得到，或。$[\gamma, \zeta, \kappa]$$[\alpha\beta\gamma, \delta\varepsilon\zeta, 100\kappa]$$[\alpha\beta\gamma, 100\zeta, \delta\varepsilon\kappa]$$[100\gamma, \delta\varepsilon\zeta, \alpha\beta\kappa]$

在第三种情况下，的排列（与一式两份）是，，，，和。$[100, 100, \alpha\beta]$$[100, 100, \alpha\beta]$$[100, \alpha\beta, 100 ]$$[100, 100, \alpha\beta]$$[100, \alpha\beta, 100 ]$$[\alpha\beta, 100, 100]$$[\alpha\beta, 100, 100]$

通过计算，我们映射，，和至三个，四个，和五个模六，选择排列，和。$(100 - \theta\iota) - (100 - \delta\varepsilon) = \delta\varepsilon - \theta\iota = \delta\varepsilon - 11$$00$$01$$10$$[100, 100, \alpha\beta]$$[100, \alpha\beta, 100 ]$$[\alpha\beta, 100, 100]$

用压缩结果后，我们得到，或。$[\gamma, \zeta, \kappa]$$[100\gamma, 100\zeta, \alpha\beta\kappa]$$[100\gamma, \alpha\beta\zeta, 100\kappa]$$[\alpha\beta\gamma, 100\zeta, 100\kappa]$

码

“MY-€-Y¤©¡‘Dịs3Ḅç+ƭ/  Main link. Argument: A (array of 10 bits)

“MY-€-Y¤©¡‘           Array literal; yield [77, 89, 45, 12, 45, 89, 3, 6, 0].
           D          Decimal; yield
                      [[7,7], [8,9], [4,5], [1,2], [4,5], [8,9], [3], [6], [0]].
            ị         Retrieve the elements of A at those indices.
                      Indexing is 1-based and modular, so 1 is the first index, while
                      0 is the last.
             s3       Split the results 2D array of bits into chunks of length 3.
               Ḅ      Convert the 9 arrays of bits from binary to integer.
                ç+ƭ/  Reduce the resulting array (length 3) once by the helper link,
                      then by addition.


&\‘f4;s3ɓạ4ḅ-œ?µ/Ḥ    Helper link. Arguments: B, C (arrays of three integers each)

&\                    Cumulatively reduce B by bitwise AND.
  ‘                   Increment the results by 1.
   f4                 Filter; keep only integers equal to 4.
     ;                Concatenate the result with C.
      s3              Split the result into (one or two) chunks of length 3.
        ɓ      µ/     Reduce the array of chunks by the following chain.
         ạ4               Take the absolute difference of the integers in the right
                          chunk and the integer 4.
           ḅ-             Convert the resulting array from base -1 to integer, i.e.,
                          map [x] to n = x and [x, y] to n = y - x.
             œ?           Take the n-th permutation of the left chunk.
                 Ḥ    Unhalve; multiply the resulting integers by 2.

Python 2，157字节

lambda a,b,c,d,e,f,g,h,i,j:[c+[a*4+b*2,8][g*h*~(d*~e*i)],f+[d*4+e*2,8,a*4+b*2][g*i+(d<e)*g*i*h],j+[h*4+i*2,[8,[a*4+b*2,d*4+e*2][h<i]][h^i or(h&i-(d|e))]][g]]

在线尝试！

干净，238个 ... 189个字节

-2字节归功于Neil

import StdEnv
$a b c d e f g h i j=100*(c+2*b+4*a)+10*(f+2*e+4*d)+j+2*i+4*h-2*(h*(99*b+198*a-394)+i*(9*e+18*d+h*(e+2*d-4+(b+2*a-4)*(1-10*e-100*d+110*e*d))-35)-4)*g+0^(e+d)*(2*b+4*a-8*i*h*g)

在线尝试！

以10个参数的形式获取一个10位的“列表”，并使用直接公式来计算结果。

Perl 5，195个字节

sub f{$n=shift;@p=((map{($n>>$_&3)*2}(8,5,1)),8);for(16390,28935,29005,227791,29108,225788,226803,228863){return 2*$n&256|$n&17|$p[$_>>4&3]<<8|$p[$_/4&3]<<4|$p[$_&3]if($_>>12&$n/2)==($_>>6&63);}}

在线尝试

我知道195个字节对于这个竞赛来说实在太多了，但是我不知道如何进一步压缩Perl代码。有什么建议吗？

代码说明

在更具可读性的版本中，代码意图应该变得显而易见：

sub dpd {
  my $n = shift;
  my $v=2*($n&128)|$n&17;
  my @p=((map{($n>>$_&3)*2}(8,5,1)),8);
  for (16390,28935,29005,227791,29108,225788,226803,228863) {
    return $v |$p[$_>>4&3]<<8|$p[$_>>2&3]<<4|$p[$_&3]
      if(($_>>12&$n/2)==($_>>6&63));
  }
}

在DPD编码规则中，每行编码为18位值，分段为（6,6，（2,2,2））位。

• 前6位是输入的位1（= h）至6（= d）的适当位掩码（位4 = f是冗余的，但它简化了评估码使其包含在内）。
• 接下来的6位是该位掩码的值位。将在位掩码为1的所有位置检查这些值。
• 接下来的3 * 2位包含@p3位序列的数组索引，这些序列将被拼接为结果的11-9、7-5和3-1位。
• 该数组@p由输入的位9-8、6-5、3-2构成，该数字8作为第四位成员
• 输入的位置7,4和0的位直接转换为结果的位8,4和0。

例如，列表中的第一个数字16390（100000000000110作为位字段）包含以下信息：

000100 : bit mask says: only consider bit 3 of the input
000000 : bit values say: bit 3 should be 0
00     : use '0ab' as higher bits of first digit
01     : use '0de' as higher bits of second digit
10     : use '0gh' as higher bits of third digit

05AB1E，84个字节

KimOyhus港口对05AB1E的答复。

•4’7þ2Ô€iΘEuĆΣk4Ѐ:ΘΛs‡CaΔʒì₁3¶rdiMß¡þи иø-˜)Â∍DY—WûQ@—Mā}Γ¤ÒÙ]p•44в2ôvÐyèP≠«}4ôC3.£

在线尝试！

粗略解释：

•yadayada•44в2ô   # encoded list of nand gates
v                 # for each gate
 ÐyèP≠            # compute the output of the gate
      «           # append it to the input
       }          # end of the loop
4ô                # split the list of bits in groups of 4
  C               # convert each from binary to decimal
   3.£            # keep the last 3 numbers
                  # implicit output

05AB1E，104个 103 101 字节

•3γã•S£©4èUXтÌ‹XSPVY®2èDˆTQ*~i0®нëт}®1èY¯`*i0®нëY_Xт>Ê*i0¯`ëт]®3èY¯`_*X110Q~i0®нëXт›iYiтë0¯`ëX]®θJ4ôC

绝对不是用于这种挑战的正确语言，但是很好。.
输入为字符串，输出为三位数的列表。

在线尝试或验证所有测试用例。

说明：

我们有以下八种情况可供考虑：

     1st 2nd 3rd 4th 5th 6th                          1st digit    2nd digit    3rd digit
1.   ab  c   de  f   0gh i   →   0abc 0def 0ghi   →   '0'+1st 2nd  '0'+3rd 4th  5th     6th
2.   ab  c   de  f   100 i   →   0abc 0def 100i   →   '0'+1st 2nd  '0'+3rd 4th  5th     6th
3.   ab  c   gh  f   101 i   →   0abc 100f 0ghi   →   '0'+1st 2nd  '100'   4th  '0'+3rd 6th
4.   gh  c   de  f   110 i   →   100c 0def 0ghi   →   '100'   2nd  '0'+3rd 4th  '0'+1st 6th
5.   gh  c   00  f   111 i   →   100c 100f 0ghi   →   '100'   2nd  '100'   4th  '0'+1st 6th
6.   de  c   01  f   111 i   →   100c 0def 100i   →   '100'   2nd  '0'+1st 4th  '100'   6th
7.   ab  c   10  f   111 i   →   0abc 100f 100i   →   '0'+1st 2nd  '100'   4th  '100'   6th
8.   xx  c   11  f   111 i   →   100c 100f 100i   →   '100'   2nd  '100'   4th  '100'   6th

我首先将（隐式）输入分成大小块[2,1,2,1,3,1]并将该列表存储在寄存器中：

•3γã•     # Push compressed integer 212131
     S    # Convert it to a list of digits
      £   # Split the (implicit) input in chunks of that size
       ©  # Store it in the register (without popping)

看到这个05AB1E尖矿（部分如何压缩大整数？）理解为什么•3γã•是212131

现在，我们首先为输出的第一位构建0和1。场景1,2,3,7使用'0'+1st+2nd; 和方案4,5,6,8使用'100'+2nd：

4è                  # Take the 5th item of the list
  U                 # Pop and store it in variable `X`
XтÌ‹                #  Check if `X` is below 102
                ~   # OR
   XSP              #  `X` is equal to 111
      VY            #  And store that result in variable `Y`
               *    #  and
        ®2è         #  Get the 3rd item from the list of the register
           Dˆ       #  Push it to the global array
             TQ     #  And check if it's equal to 10
i                   # If the combined check above is truthy (exactly 1):
 0                  #  Push 0 to the stack
 ®н                 #  Push the 1st item of the list to the stack
ë                   # Else:
 т                  #  Push 100 to the stack
}                   # Close the if-else
®1è                 # And push the 2nd item of the list to the stack

然后，我们将为输出的第二个数字构建0和1。场景1,2,4使用'0'+3rd+4th; 场景3,5,7,8使用'100'+4th; 场景6使用'0'+1st+4th：

Y                # Push `Y` (check if `X` equals 111)
   *             # and
 ¯`              # Push the item from the global array (3rd item of the list)
i                # If both checks above are truthy (exactly 1):
 0               #  Push 0 to the stack
 ®н              #  Push the 1st item of the list to the stack
ë                # Else:
 Y_              #  Push inverted `Y` (check if `X` does NOT equal 111)
       *         #  and
   Xт>Ê          #  Check if `X` (5th item of the list) does NOT equal 101
 i               #  If both checks above are truthy (exactly 1):
  0              #   Push 0 to the stack
  ¯`             #   Push the item from the global array (3rd item of the list)
 ë               #  Else:
  т              #   Push 100 to the stack
]                # Close both if-else cases
®3è              # And push the 4th item of the list to the stack

然后，我们将为输出的第三位数构建0和1。场景1,2使用5th+6th; 方案3的使用'0'+3rd+6th; 场景4,5使用'0'+1st+6th; 和场景6,7,8使用'100'+6th：

Y           #  Push `Y` (check if `X` equals 111)
    *       #  and
 ¯`_        #  Check if the item from the global array (3rd item of the list) is exactly 0
         ~  # OR
    X110Q   #  Check if `X` (5th item of the list) equals 110
i           # If the combined check above is truthy (exactly 1):
 0          #  Push 0 to the stack
 ®н         #  Push the 1st item of the list to the stack
ë           # Else:
 Xт›i       #  If `X` (5th item of the list) is larger than 100 (so 101/110/111):
     Yi     #   If `Y` (if `X` equals 111):
       т    #    Push 100 to the stack
      ë     #   Else:
       0    #    Push 0 to the stack
       ¯`   #    Push the item from the global array (3rd item of the list)
    ë       #  Else:
     X      #   Push `X` (5th item of the list) to the stack
]           # Close all if-else cases
®θ          # And push the last (6th) item of the list to the stack

现在我们在堆栈上具有全0和1，因此我们可以将其转换为三个输出数字：

J     # Join the entire stack together
 4ô   # Split it into parts of size 4
   C  # Convert each part from binary to an integer (and output implicitly)