낸드 게임 팬의 경우 : 논리 게이트에서 DPD를 10 진수로 시도하십시오 !

배경

밀도가 높은 10 진수 (DPD) 는 10 진수를 이진수로 효율적으로 저장하는 방법입니다. 10 비트에 3 개의 10 진수 (000 ~ 999)를 저장하는데, 이는 1 비트를 4 비트에 저장하는 순진 BCD보다 훨씬 효율적입니다.

표기법

• 소문자 문자 a로는 i소수점 표현에 복사되는 비트입니다.
• 0및 1상기 입력 또는 출력 비트 패턴의 정확한 비트이다.
• x 비트는 변환에서 무시됩니다.

변환 표

다음은 DPD의 10 비트에서 10 진수로의 변환 표입니다. 각 10 진수는 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)

태스크

DPD 10 비트를 소수점 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 비트 목록입니다. 비트는 위의 정확한 순서 또는 그 반대 순서를 따라야합니다. 대신 동등한 문자열 또는 정수 표현을 사용하도록 선택할 수 있습니다. 다른 과제와 달리 중첩 구조를 재정렬하거나 사용하는 것은 허용되지 않습니다 .

입력 [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 자리 10 진수 목록입니다. 각 숫자는 0에서 9까지의 정수 또는 문자로 표시되어야합니다. 입력에서와 같이 문자열 또는 정수 표현을 선택할 수 있습니다. 정수 표현을 선택하면 선행 0을 생략 할 수 있습니다.

득점 및 당첨 기준

표준 코드 골프 규칙이 적용됩니다. 각 언어마다 가장 짧은 프로그램이나 함수가 바이트 단위로 표시됩니다.

자바 스크립트 (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]

온라인으로 사용해보십시오!

자바 스크립트 (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

파이썬 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입니다 (실제로 음수로 계산 됨).

그런 다음 n 번째 숫자는 high_bits[arr[indicator][n]] | low_bits[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]
]

자바 스크립트 (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 바이트 더!

@Arnauld 덕분에 -5 바이트

-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, 변환 테이블의 8 개 행을 식별 할 수 있도록한다는 :

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

온라인으로 사용해보십시오!

루비 , 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보다 작 으면 (어쨌든 LSB를 신경 쓰지 않았기 때문에 9보다 작습니다), 우리는 설정됩니다 : 이것은 평범한 BCD이며, 아무것도 변경하지 않고 16 진수를 출력 할 수 있습니다

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

각 숫자를 개별적으로 10 진수로 변환 할 수 있도록 구분 기호를 삽입하십시오. 이것은 변환 표에서 처음 두 가지 경우를 효과적으로 처리합니다.

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

변환 표에서 마지막 (8 번째) 사례를 처리하십시오.

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

변환 표에서 6 번째와 7 번째 경우를 처리하십시오.

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

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

파이썬 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 바이트

Neil 덕분에 -2 바이트

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 비트의 '목록'을 가져와 결과를 계산합니다.

펄 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 비트 @p는 결과의 비트 11-9, 7-5 및 3-1로 스 플라이 싱 될 3 비트 시퀀스 의 배열에 대한 인덱스를 포함합니다 .
• 배열 @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

확실히 이런 종류의 도전에 적합한 언어는 아니지만 아 ..
문자열로 입력하고 세 자리수 목록으로 출력하십시오.

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

고려해야 할 다음 8 가지 시나리오가 있습니다.

     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이 모두 있으므로 3 개의 출력 자릿수로 변환 할 수 있습니다.

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)