Para fãs de nandgame: Por favor, experimente DPD para decimal em portas lógicas também!

fundo

O decimal densamente compactado (DPD) é uma maneira de armazenar com eficiência dígitos decimais em binário. Ele armazena três dígitos decimais (000 a 999) em 10 bits, o que é muito mais eficiente que o BCD ingênuo (que armazena um dígito em 4 bits).

Notações

• As letras minúsculas apara isão os bits que são copiados para a representação decimal.
• 0e 1são os bits exatos nos padrões de bits de entrada ou saída.
• x bits são ignorados na conversão.

Tabela de conversão

A seguir, a tabela de conversão de 10 bits do DPD para três dígitos decimais. Cada dígito decimal é representado como binário de 4 bits (BCD). Ambos os lados são escritos da esquerda para a direita, do dígito mais significativo ao mínimo.

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)

Tarefa

Converta 10 bits do DPD em 3 dígitos decimais.

Casos de teste

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

Entrada

O formato de entrada padrão é uma lista de 10 bits. Os bits devem seguir a ordem exata acima, ou o inverso. Você pode optar por usar uma sequência equivalente ou uma representação inteira. Ao contrário dos meus outros desafios, não é permitido reordenar ou usar estruturas aninhadas .

Para a entrada [1, 1, 0, 0, 0, 1, 0, 1, 0, 0], os seguintes formatos são permitidos:

• Lista de bits: [1, 1, 0, 0, 0, 1, 0, 1, 0, 0]
• Corda: "1100010100"
• Inteiro binário: 788ou0b1100010100
• Inteiro decimal: 1100010100
• Invertida: [0, 0, 1, 0, 1, 0, 0, 0, 1, 1]e invertida em qualquer outro formato acima

Os seguintes formatos NÃO são permitidos:

• Reordenação arbitrária de bits: [0, 0, 0, 0, 0, 1, 1, 1, 0, 1]
• Estruturas aninhadas: [[1, 1, 0], [0, 0, 1], [0, 1, 0, 0]]ou[0b110, 0b001, 0b0100]

Saída

O formato de saída padrão é uma lista de 3 dígitos decimais. Cada dígito deve ser representado como 0 a 9, um número inteiro ou um caractere. Como na entrada, você pode escolher uma representação de sequência ou número inteiro. Se você escolher representação inteira, os zeros à esquerda poderão ser omitidos.

Critério de pontuação e vitória

Aplicam-se as regras de código-golfe padrão . O programa ou função mais curto em bytes para cada idioma vence.

JavaScript (ES6), 112 bytes

Todo o crédito para esta versão mais curta vai para @nwellnhof.

Recebe a entrada como um número inteiro. Retorna uma matriz de três dígitos decimais.

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]

Experimente online!

JavaScript (ES6), 118 117 bytes

Recebe a entrada como um número inteiro. Retorna uma matriz de três dígitos decimais.

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]

Experimente online!

Quão?

Em vez de tentar aplicar o algoritmo 'oficial', esse código é baseado em algum tipo de engenharia reversa dos padrões que podem ser encontrados nos resultados esperados.

Dado o número inteiro de entrada , calculamos:$n$

Exemplo: primeiro dígito (centenas)

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

Algoritmo:

• Se , temos$p<6$$d=y$
• Se , temos$p=6$$d=8+(y\bmod2)$
• Se , temos$p=7\text{ AND }(x<4\text{ OR }x>5)$$d=8+(y\bmod2)$
• Se , temos$p=7\text{ AND }(x=4\text{ OR }x=5)$$d=y$

Como código JS:

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

Python 3 , 229 ... 97 96 bytes

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]]

Experimente online!

-4 bytes por @xnor

-6 bytes por @nwellnhof

Formatado:

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]]

Explicação

Como eu originalmente queria implementar isso no Jelly, adoto uma abordagem diferente da maioria das respostas aqui, que é simples e talvez adequada para uma linguagem de golfe. Embora a função golfed use um número inteiro, deixe a entrada como uma lista de bits [a0,a1,...,a9]. Então podemos derivar três valores da entrada

• Os bits baixos [a2,a5,a9]: sempre serão os bits baixos [d0,d1,d2]respectivamente.
• Os bits altos [2*a0a1,2*a3a4,2*a7a8,8]: os bits altos de cada dígito serão um deles.
• Os bits indicadores [a3,a4,a5,a7,a8], determinando como obter os bits altos de cada dígito. Calculamos o indicador (entre 1 e 8) da seguinte forma:
  • Se a5 == 0, o indicador é 8 (originalmente 0, mas usar 8 salva um byte)
  • Se a3 e a4, o indicador é 6 - 2 * a3a4
  • Caso contrário, o indicador é 2 * a7a8 + 1 (realmente calculado como um número negativo).

Em seguida, o enésimo dígito pode ser calculado com elegância, conforme high_bits[arr[indicator][n]] | low_bits[n]a tabela abaixo, que é compactada em uma string.

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 bytes

(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]

Experimente online!

-5 bytes obrigado @tsh (e 2 por mim) Portanto, lpodemos fazer mais esforço do que eu esperava.

-2 mais bytes usando a técnica de @ tsh!

-5 bytes obrigado @Arnauld

-1 byte obrigado @Neil

Entrada como uma lista de 10 bits (como 10 argumentos), saída como uma lista de 3 dígitos.

C (gcc) , 138 129 bytes

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);}

Experimente online!

Primeiro extrai alguns bits em variáveis se t, para que as oito linhas da tabela de conversão possam ser identificadas por:

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

Em seguida, ajusta-se ue vcom divisões (deslocamentos para a direita), para que u, ve a entrada de wconter os mais baixos três BCD bits em posições 0-2. O resto é um pouco aleatório, dependendo de se t. Dois truques notáveis ​​são:

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

Uma porta da solução Javascript de Shieru Asakoto tem apenas 124 bytes :

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;}

Experimente online!

Ruby , 153 ... 119 117 bytes

->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]}

Experimente online!

Como funciona:

->n{n+=n&896;

Este é o ponto de partida: converta para BCD deslocando 3 bits para a esquerda, o que funciona para a maioria dos padrões.

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

Obtenha os bits do meio de cada petisco (e um bit extra do terceiro petisco, mas oculte o bit menos significativo).

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

Se o terceiro dígito for menor que 10 (menor que 9, porque nunca cuidamos do LSB de qualquer maneira), estamos definidos: este é o BCD simples, podemos gerar o hex sem alterar nada

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

Caso contrário, faça alguma magia negra mudando os bits e adicionando números mágicos até obter o resultado desejado.

Retina 0.8.2 , 191 181 bytes

(...)(...)
:$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

Experimente online! O link inclui casos de teste. Editar: economizou 10 bytes por não preencher dígitos de 4 bits, exceto onde necessário. Explicação:

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

Insira separadores para que cada dígito possa ser convertido em decimal separadamente. Isso efetivamente lida com os dois primeiros casos na tabela de conversão.

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

Manipule o último (oitavo) caso na tabela de conversão.

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

Manipule os sexto e sétimo casos na tabela de conversão.

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

Manipule o quinto caso na tabela de conversão.

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

Manipule o terceiro e o quarto casos na tabela de conversão.

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

Realize a conversão de binário em decimal.

Geléia , 51 48 40 39 bytes

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

Experimente online!

Algoritmo

^{Com exceção dos índices da lista, todos os números inteiros nesta seção são gravados em binário.}

$\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$

$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]$

No terceiro caso, as permutações (com duplicatas) de $[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]$

Código

“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 bytes

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]]

Experimente online!

Limpo , 238 ... 189 bytes

-2 bytes graças a 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)

Experimente online!

Leva uma 'lista' de 10 bits na forma de 10 argumentos, usando uma fórmula direta para calcular o resultado.

Perl 5, 195 bytes

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);}}

Experimente online

Eu sei que 195 bytes é demais para este concurso, mas eu não tinha idéia de como compactar ainda mais o código Perl. Sugestões?

Explicação do código

Em uma versão mais legível, a intenção do código deve se tornar aparente:

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));
  }
}

Nas regras para codificação DPD, cada linha é codificada em um valor de 18 bits, segmentação em bits (6,6, (2,2,2)).

• Os primeiros 6 bits são uma máscara de bits apropriada para os bits 1 (= h) a 6 (= d) da entrada (o bit 4 = f é redundante, mas simplifica o código de avaliação para incluí-lo).
• Os próximos 6 bits são os bits de valor para essa máscara de bit. Os valores são verificados em todos os locais em que a máscara de bits tem um valor 1.
• Os seguintes 3 * 2 bits contêm os índices da matriz @ppara as sequências de 3 bits que devem ser unidas nos bits 11-9, 7-5 e 3-1 do resultado.
• A matriz @pé construída a partir dos bits 9-8, 6-5, 3-2 da entrada e o número 8como quarto membro
• Os bits nas posições 7,4 e 0 da entrada são transferidos diretamente para os bits 8,4 e 0 do resultado.

Por exemplo, o primeiro número da lista 16390, que é 100000000000110um campo de bits, carrega as seguintes informações:

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 bytes

Resposta do porto de KimOyhus para 05AB1E.

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

Experimente online!

Explicação aproximada:

•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 bytes

•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

Definitivamente, não é o idioma certo para esse tipo de desafio, mas sim.
Entrada como string, saída como lista de três dígitos.

Experimente online ou verifique todos os casos de teste .

Explicação:

Temos os seguintes oito cenários a serem considerados:

     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

Primeiro, divido a entrada (implícita) em pedaços de tamanho [2,1,2,1,3,1]e armazeno essa lista no registro:

•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)

Veja este 05AB1E ponta do meu (seção Como comprimir grandes inteiros? ) Para entender por que •3γã•é212131

Agora vamos construir os 0s e 1s para o primeiro dígito da saída. Cenários 1,2,3,7 usam'0'+1st+2nd ; e os cenários 4,5,6,8 usam '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

Então, vamos construir os 0s e 1s para o segundo dígito da saída. Cenários 1,2,4 usam'0'+3rd+4th ; cenários 3,5,7,8 uso '100'+4th; e o cenário 6 usa '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

Então, vamos construir os 0s e 1s para o terceiro dígito da saída. Cenários 1,2 de uso 5th+6th; cenário 3 usa'0'+3rd+6th ; cenários 4,5 uso '0'+1st+6th; e cenários 6,7,8 usam '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

Agora temos todos os 0 e 1 na pilha, para que possamos convertê-lo nos três dígitos da saída:

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)