Đối với người hâm mộ nandgame: Vui lòng thử DPD để thập phân trong các cổng logic !

Lý lịch

Mật độ thập phân dày đặc (DPD) là một cách hiệu quả để lưu trữ hiệu quả các chữ số thập phân ở dạng nhị phân. Nó lưu trữ ba chữ số thập phân (000 đến 999) trong 10 bit, hiệu quả hơn nhiều so với BCD ngây thơ (lưu trữ một chữ số trong 4 bit).

Ký hiệu

• Các chữ thường ađể ilà các bit được sao chép vào các đại diện thập phân.
• 0và 1là các bit chính xác trong các mẫu bit đầu vào hoặc đầu ra.
• x bit được bỏ qua trong chuyển đổi.

Bảng chuyển đổi

Sau đây là bảng chuyển đổi từ 10 bit DPD thành ba chữ số thập phân. Mỗi chữ số thập phân được biểu diễn dưới dạng nhị phân 4 bit (BCD). Cả hai bên được viết từ trái sang phải từ chữ số có nghĩa nhất đến ít nhất.

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)

Bài tập

Chuyển đổi 10 bit DPD thành 3 chữ số thập phân.

Các trường hợp thử nghiệm

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

Đầu vào

Định dạng đầu vào mặc định là danh sách 10 bit. Các bit nên theo thứ tự chính xác ở trên, hoặc ngược lại của nó. Bạn có thể chọn sử dụng một đại diện chuỗi hoặc số nguyên tương đương. Không giống như những thách thức khác của tôi, không được phép sắp xếp lại hoặc sử dụng các cấu trúc lồng nhau .

Đối với đầu vào [1, 1, 0, 0, 0, 1, 0, 1, 0, 0], các định dạng sau được cho phép:

• Danh sách các bit: [1, 1, 0, 0, 0, 1, 0, 1, 0, 0]
• Chuỗi: "1100010100"
• Số nguyên nhị phân: 788hoặc0b1100010100
• Số nguyên thập phân: 1100010100
• Đảo ngược: [0, 0, 1, 0, 1, 0, 0, 0, 1, 1]và đảo ngược ở bất kỳ định dạng nào khác ở trên

Các định dạng sau KHÔNG được phép:

• Sắp xếp lại tùy ý các bit: [0, 0, 0, 0, 0, 1, 1, 1, 0, 1]
• Cấu trúc lồng nhau: [[1, 1, 0], [0, 0, 1], [0, 1, 0, 0]]hoặc[0b110, 0b001, 0b0100]

Đầu ra

Định dạng đầu ra mặc định là danh sách gồm 3 chữ số thập phân. Mỗi chữ số phải được biểu diễn từ 0 đến 9, là số nguyên hoặc ký tự. Như trong đầu vào, bạn có thể chọn biểu diễn chuỗi hoặc số nguyên. Nếu bạn chọn biểu diễn số nguyên, các số 0 đứng đầu có thể được bỏ qua.

Ghi điểm & tiêu chí chiến thắng

Luật golf tiêu chuẩn được áp dụng. Chương trình hoặc hàm ngắn nhất tính theo byte cho mỗi ngôn ngữ sẽ thắng.

JavaScript (ES6), 112 byte

Tất cả tín dụng cho phiên bản ngắn hơn này được chuyển đến @nwellnhof.

Lấy đầu vào là một số nguyên. Trả về một mảng gồm ba chữ số thập phân.

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]

Hãy thử trực tuyến!

JavaScript (ES6), 118 117 byte

Lấy đầu vào là một số nguyên. Trả về một mảng gồm ba chữ số thập phân.

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]

Hãy thử trực tuyến!

Làm sao?

Thay vì cố gắng áp dụng thuật toán 'chính thức', mã này dựa trên một số loại kỹ thuật đảo ngược của các mẫu có thể tìm thấy trong các kết quả dự kiến.

Cho số nguyên đầu vào , chúng tôi tính toán:$n$

Ví dụ: chữ số đầu tiên (hàng trăm)

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

Thuật toán:

• Nếu , ta có$p<6$$d=y$
• Nếu , chúng ta có$p=6$$d=8+(y\bmod2)$
• Nếu , chúng ta có$p=7\text{ AND }(x<4\text{ OR }x>5)$$d=8+(y\bmod2)$
• Nếu , chúng ta có$p=7\text{ AND }(x=4\text{ OR }x=5)$$d=y$

Như mã JS:

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

Python 3 , 229 ... 97 96 byte

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

Hãy thử trực tuyến!

-4 byte bởi @xnor

-6 byte bởi @nwellnhof

Định dạng:

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

Giải trình

Bởi vì ban đầu tôi muốn thực hiện điều này trong Jelly, tôi có một cách tiếp cận khác với hầu hết các câu trả lời ở đây, rất đơn giản và có lẽ phù hợp với ngôn ngữ chơi gôn. Mặc dù hàm golf có một số nguyên, hãy để đầu vào dưới dạng một danh sách bit [a0,a1,...,a9]. Sau đó, chúng ta có thể rút ra ba giá trị từ đầu vào

• Các bit thấp [a2,a5,a9]: Đây sẽ luôn là các bit thấp [d0,d1,d2]tương ứng.
• Các bit cao [2*a0a1,2*a3a4,2*a7a8,8]: Các bit cao của mỗi chữ số sẽ là một trong số đó.
• Các bit chỉ báo [a3,a4,a5,a7,a8], xác định cách lấy các bit cao của mỗi chữ số. Chúng tôi tính toán chỉ số (từ 1 đến 8) như sau:
  • Nếu a5 ​​== 0, chỉ báo là 8 (ban đầu là 0, nhưng sử dụng 8 thay vì tiết kiệm một byte)
  • Nếu a3 nand a4, chỉ báo là 6 - 2 * a3a4
  • Mặt khác, chỉ báo là 2 * a7a8 + 1 (thực tế được tính là số âm).

Sau đó, chữ số thứ n có thể được tính toán một cách tao nhã như high_bits[arr[indicator][n]] | low_bits[n]bảng bên dưới, được nén thành một chuỗi.

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 byte

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

Hãy thử trực tuyến!

-5 byte cảm ơn @tsh (và 2 mình) Vì vậy, lcó thể nỗ lực nhiều hơn tôi mong đợi.

Thêm 2 byte bằng kỹ thuật của @ tsh!

-5 byte cảm ơn @Arnauld

-1 byte cảm ơn @Neil

Nhập dưới dạng danh sách 10 bit (dưới dạng 10 đối số), xuất dưới dạng danh sách gồm 3 chữ số.

C (gcc) , 138 129 byte

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

Hãy thử trực tuyến!

Đầu tiên trích xuất một số bit thành các biến svà t, để tám hàng của bảng chuyển đổi có thể được xác định bởi:

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

Sau đó thiết lập uvà vvới các bộ phận (dịch chuyển bên phải), do đó u, vvà đầu vào wchứa ba bit BCD thấp hơn ở vị trí 0-2. Phần còn lại là một chút xáo trộn tùy thuộc svà t. Hai thủ thuật đáng chú ý là:

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

Một cổng của giải pháp Javascript của Shieru Asakoto chỉ có 124 byte :

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

Hãy thử trực tuyến!

Ruby , 153 ... 119 117 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động:

->n{n+=n&896;

Đây là điểm bắt đầu: chuyển đổi sang BCD bằng cách dịch chuyển 3 bit sang trái, hoạt động cho hầu hết các mẫu.

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

Lấy các bit giữa của mỗi nibble (và thêm một bit của nibble thứ ba, nhưng che dấu bit đáng kể nhất).

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

Nếu chữ số thứ ba nhỏ hơn 10 (nhỏ hơn 9 vì chúng tôi chưa bao giờ quan tâm đến LSB), chúng tôi đã đặt: đây là BCD đơn giản, chúng tôi có thể xuất hex mà không thay đổi bất cứ điều gì

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

Mặt khác, thực hiện một số phép thuật đen bằng cách dịch chuyển các bit xung quanh và thêm số ma thuật cho đến khi chúng ta nhận được kết quả mà chúng ta muốn.

Võng mạc 0.8.2 , 191 181 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Chỉnh sửa: Đã lưu 10 byte bằng cách không đệm các chữ số thành 4 bit trừ khi cần thiết. Giải trình:

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

Chèn dấu phân cách sao cho mỗi chữ số có thể được chuyển đổi thành số thập phân riêng. Điều này có hiệu quả xử lý hai trường hợp đầu tiên trong bảng chuyển đổi.

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

Xử lý trường hợp (thứ tám) cuối cùng trong bảng chuyển đổi.

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

Xử lý các trường hợp thứ sáu và thứ bảy trong bảng chuyển đổi.

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

Xử lý trường hợp thứ năm trong bảng chuyển đổi.

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

Xử lý các trường hợp thứ ba và thứ tư trong bảng chuyển đổi.

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

Thực hiện chuyển đổi nhị phân sang thập phân.

Thạch , 51 48 40 39 byte

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

Hãy thử trực tuyến!

Thuật toán

^{Ngoại trừ các chỉ mục danh sách, tất cả các số nguyên trong phần này được viết dưới dạng nhị phân.}

Đầu vào cho $\alpha\beta\gamma\delta\varepsilon\zeta\eta\theta\iota\kappa$ , trước tiên chúng ta xây dựng các mảng $[\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$

Nếu chúng ta đếm số hàng đầu $11$ 's$[\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]]$

Trong trường hợp đầu tiên và cuối cùng, chúng ta chỉ cần nén mảng đầu tiên bằng $[\gamma, \zeta, \kappa]$ , mang lại$[\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]$

Mã

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

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

Hãy thử trực tuyến!

Sạch , 238 ... 189 byte

-2 byte nhờ 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)

Hãy thử trực tuyến!

Lấy một 'danh sách' gồm 10 bit dưới dạng 10 đối số, sử dụng công thức trực tiếp để tính kết quả.

Perl 5, 195 byte

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

Dùng thử trực tuyến

Tôi biết 195 byte là quá nhiều cho cuộc thi này, nhưng tôi không biết làm thế nào để nén thêm mã Perl. Gợi ý?

Giải thích về mã

Trong phiên bản dễ đọc hơn, ý định mã sẽ trở nên rõ ràng:

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

Trong quy tắc mã hóa DPD, mỗi dòng được mã hóa thành giá trị 18 bit, phân đoạn thành các bit (6,6, (2,2,2)).

• 6 bit đầu tiên là mặt nạ bit thích hợp cho các bit 1 (= h) đến 6 (= d) của đầu vào (bit 4 = f là dự phòng, nhưng nó đơn giản hóa mã đánh giá để bao gồm nó).
• 6 bit tiếp theo là các bit giá trị cho mặt nạ bit này. Các giá trị được kiểm tra trên tất cả các vị trí mà mặt nạ bit có giá trị 1.
• Các bit 3 * 2 sau đây chứa các chỉ số cho mảng @pcho chuỗi 3 bit được chia thành các bit 11-9, 7-5 và 3-1 của kết quả.
• Mảng @pđược xây dựng từ các bit 9-8, 6-5, 3-2 của đầu vào và số 8là thành viên thứ tư
• Các bit ở vị trí 7,4 và 0 của đầu vào được chuyển trực tiếp vào các bit 8.4 và 0 của kết quả.

Ví dụ, số đầu tiên trong danh sách, 16390mà là 100000000000110như một lĩnh vực bit, mang các thông tin sau:

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 byte

Câu trả lời của cảng KimOyhus cho 05AB1E.

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

Hãy thử trực tuyến!

Giải thích sơ bộ:

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

•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

Chắc chắn không phải là ngôn ngữ phù hợp cho loại thách thức này, nhưng ah tốt ..
Nhập dưới dạng chuỗi, đầu ra dưới dạng danh sách ba chữ số.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

Chúng tôi có tám kịch bản sau đây để xem xét:

     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

Trước tiên tôi chia đầu vào (ẩn) thành các khối có kích thước [2,1,2,1,3,1]và lưu danh sách đó vào sổ đăng ký:

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

Xem 05AB1E mẹo này của tôi (phần Làm thế nào để nén các số nguyên lớn? ) Để hiểu tại sao •3γã•là212131

Bây giờ đầu tiên chúng ta sẽ xây dựng 0 và 1 cho chữ số đầu tiên của đầu ra. Kịch bản 1,2,3,7 sử dụng '0'+1st+2nd; và kịch bản 4,5,6,8 sử dụng '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

Sau đó, chúng tôi sẽ xây dựng 0 và 1 cho chữ số thứ hai của đầu ra. Kịch bản 1,2,4 sử dụng '0'+3rd+4th; kịch bản sử dụng 3,5,7,8 '100'+4th; và kịch bản 6 sử dụng '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

Sau đó, chúng tôi sẽ xây dựng 0 và 1 cho chữ số thứ ba của đầu ra. Kịch bản 1,2 sử dụng 5th+6th; kịch bản 3 sử dụng '0'+3rd+6th; kịch bản 4,5 sử dụng '0'+1st+6th; và kịch bản 6,7,8 sử dụng '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

Bây giờ chúng ta có tất cả 0 và 1 trên ngăn xếp, vì vậy chúng ta có thể chuyển đổi nó thành ba chữ số đầu ra:

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)