สำหรับแฟน ๆ เกม nandgame: โปรดลองDPD เป็นทศนิยมในประตูตรรกะด้วย!

พื้นหลัง

ทศนิยมที่อัดแน่น (DPD)คือวิธีในการจัดเก็บทศนิยมอย่างมีประสิทธิภาพในไบนารี มันเก็บทศนิยมสามหลัก (000 ถึง 999) ใน 10 บิตซึ่งมีประสิทธิภาพมากขึ้นกว่าไร้เดียงสา BCD (ซึ่งเก็บหนึ่งหลักใน 4 บิต)

ข้อความ

ตัวอักษรตัวพิมพ์เล็กaจะ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)

งาน

แปลง 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 ตัว แต่ละหลักควรแสดงเป็น 0 ถึง 9 ไม่ว่าจะเป็นจำนวนเต็มหรืออักขระ ในอินพุตคุณสามารถเลือกการแทนสตริงหรือจำนวนเต็ม หากคุณเลือกการแสดงจำนวนเต็มศูนย์จะไม่สามารถนำศูนย์

เกณฑ์การให้คะแนนและการชนะ

ใช้กฎมาตรฐานของกอล์ฟ โปรแกรมหรือฟังก์ชันที่สั้นที่สุดในหน่วยไบต์สำหรับแต่ละภาษาที่ชนะ

code-golf binary conversion

— bubbler
แหล่งที่มา

12

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$

\begin{aligned} x = ⌊ \frac{n}{16} ⌋ mod 8 \\ y = ⌊ \frac{n}{128} ⌋ \\ p = ⌊ \frac{n}{2} ⌋ mod 8 \end{aligned}

$\begin{align}&x=\left\lfloor\frac{n}{16}\right\rfloor \bmod 8\\ &y=\left\lfloor\frac{n}{128}\right\rfloor\\ &p=\left\lfloor\frac{n}{2}\right\rfloor \bmod 8\end{align}$

ตัวอย่าง: ตัวเลขตัวแรก (หลักร้อย)

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

— Arnauld
แหล่งที่มา

1

วิธีการของคุณคล้ายกับคำตอบ C ของฉันซึ่งใช้ตัวแปรชั่วคราวอื่น หลังจากการเล่นกอล์ฟวิธีการแก้ปัญหาของฉัน C เริ่มต้นอีกเล็กน้อยพอร์ตไปยังผลงาน JavaScript ใน112 ไบต์

— nwellnhof

10

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

ลองออนไลน์!

-4 ไบต์โดย @xnor

-6 ไบต์โดย @nwellnhof

จัดรูปแบบ:

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

คำอธิบาย

เนื่องจากเดิมทีฉันต้องการนำเจลลี่มาใช้ฉันจึงใช้แนวทางที่แตกต่างจากคำตอบส่วนใหญ่ที่นี่ซึ่งเรียบง่ายและอาจเหมาะสมกับภาษากอล์ฟ [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 และ a4 ตัวบ่งชี้คือ 6 - 2 * a3a4
- มิฉะนั้นตัวบ่งชี้คือ 2 * a7a8 + 1 (คำนวณจริงว่าเป็นจำนวนลบ)

จากนั้นตัวเลข nth สามารถคำนวณได้อย่างหรูหรา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]
]

— lirtosiast
แหล่งที่มา

1

คุณสามารถใช้ bytestring ที่จะเปลี่ยนแปลงกับb"..." ord

— xnor

@nwellnhof ฮ่าฉันเพิ่งพบสิ่งเดียวกัน! จะให้เครดิตคุณอยู่ดี

— lirtosiast

b"$>6;-/'?"[a&8and(~a&6or a>>4&6|1)]บันทึกอีกสี่ไบต์

— nwellnhof

@nwellnhof ฉันคิดว่า modulo chain เป็นวิธีที่จะไปที่นี่ แต่ถ้าไม่ใช่ของคุณก็คงใช้ได้

— lirtosiast

9

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สามารถใช้ความพยายามมากกว่าที่ฉันคาดไว้

-2 ไบต์เพิ่มเติมโดยใช้เทคนิค @ tsh!

-5 ไบต์ขอบคุณ @Arnauld

-1 ไบต์ขอบคุณ @Neil

อินพุตเป็นรายการ 10 บิต (เป็นอาร์กิวเมนต์ 10 ตัว) เอาต์พุตเป็นรายการ 3 หลัก

— Shieru Asakoto
แหล่งที่มา

1

(!i|!d|e)-> i+l!=5; (d|e|!h)->h+l!=1

— tsh

1

(g?h-i|h&!e?h?b:e:8:h*4+i*2)-> (g?h<i?e:h>i*e?b:8:h*4+i*2)บันทึกอีกหนึ่งไบต์ (ฉันตรวจสอบเวลานี้ ... )

— Neil

8

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มีต่ำกว่าสามบิต BCD ในตำแหน่ง 0-2 ส่วนที่เหลือจะบิตสับขึ้นอยู่กับและs tสองเทคนิคเด่นคือ:

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

พอร์ตของโซลูชัน Javascript ของ Shieru Asakotoมีขนาด 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;}

ลองออนไลน์!

— nwellnhof
แหล่งที่มา

ฉันคิดว่ามันสั้นลงไปอีก:

f(b){int a=b/2%8,e=b&110,c=b/16,d=c/8;b=10*(10*(d%2|(6>a|78==e?d:8))+c%2+(3<a&a%2?e-46?8:d&6:c&6))+b%2+(4>a?b&6:a-5?a-6&&e-14?8:d&6:c&6)};

— MCCCS

@MCCCS รหัสของคุณน่าจะเป็น 138 ไบต์เช่นกัน

— nwellnhof

5

ทับทิม , 153 ... 119 117 ไบต์

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

นี่คือจุดเริ่มต้น: แปลงเป็น BCD โดยเลื่อนบิตไปทางซ้าย 3 บิตซึ่งใช้ได้กับรูปแบบส่วนใหญ่

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

ไม่อย่างนั้นทำเวทย์มนตร์ดำโดยขยับบิตไปรอบ ๆ และเพิ่มหมายเลขเวทย์มนตร์จนกว่าเราจะได้ผลลัพธ์ตามที่เราต้องการ

— GB
แหล่งที่มา

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

ลองออนไลน์! ลิงค์มีกรณีทดสอบ แก้ไข: บันทึก 10 ไบต์โดยไม่เพิ่มจำนวนหลักเป็น 4 บิตยกเว้นในกรณีที่จำเป็น คำอธิบาย:

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

ทำการแปลงแบบไบนารีเป็นทศนิยม

— นีล
แหล่งที่มา

5

เยลลี่ , 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]$

ถ้าตัวเลขเอาต์พุตทั้งสามหลักอยู่ในระดับต่ำ (ถึง ) $\eta\eta = 00$ $0000$ $0111$
หากแต่หลักที่แน่นอนหนึ่งเอาต์พุตจะสูง (หรือ ) $\eta\eta = 11$ $\theta\iota < 11$ $1000$ $1001$
หากแต่ตัวเลขเอาต์พุตสองหลักนั้นแน่นอน $\eta\eta = \theta\iota = 11$ $\delta\varepsilon < 11$
หากตัวเลขเอาต์พุตทั้งสามหลักนั้นสูง $\eta\eta = \theta\iota = \delta\varepsilon = 11$

ถ้าเรานับจำนวนของชั้นนำ 's , สร้างอาร์เรย์ของจำนวนการจับคู่ของ ' s, concatenate ด้วยและแยกผลลัพธ์ออกเป็น subarrays ที่มีความยาวสามเราจะได้ผลลัพธ์ต่อไปนี้ในแต่ละกรณี $11$ $[\eta\eta, \theta\iota, \delta\varepsilon]$ $100$ $[\alpha\beta, \delta\varepsilon, \theta\iota]$

$[[\alpha\beta, \delta\varepsilon, \theta\iota]]$
$[[100, \alpha\beta, \delta\varepsilon], [\theta\iota]]$
$[[100, 100, \alpha\beta], [\delta\varepsilon, \theta\iota]] = [[100, 100, \alpha\beta], [\delta\varepsilon, 11]]$
$[[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] $[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]$

โดยการคำนวณเราทำแผนที่ , , และถึงสี่, สามและสอง, เลือกการเรียงสับเปลี่ยน ,และbeta] $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, 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] $(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

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

ลองออนไลน์!

— TFeld
แหล่งที่มา

2

ทำความสะอาด , 238 ... 189 ไบต์

-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 อาร์กิวเมนต์โดยใช้สูตรโดยตรงเพื่อคำนวณผลลัพธ์

— Οurous
แหล่งที่มา

ในi*(9*e+19*d+i*...)วินาทีนั้นi*ดูไม่จำเป็น

— Neil

@ Neil คุณพูดถูกแล้วขอบคุณ

— Οurous

1

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 ต่อไปนี้มีดัชนีสำหรับอาร์เรย์@pสำหรับลำดับ3 บิตซึ่งจะทำการต่อเชื่อมเป็นบิต 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

— rplantiko
แหล่งที่มา

1

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

— Grimmy
แหล่งที่มา

0

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

ตอนนี้เรากำลังจะสร้าง 0s และ 1s สำหรับหลักแรกของเอาต์พุต สถานการณ์ 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

ตอนนี้เรามี 0s และ 1s ทั้งหมดบนสแต็กดังนั้นเราจึงสามารถแปลงมันเป็นสามหลักเอาท์พุท:

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)

— Kevin Cruijssen
แหล่งที่มา

ทศนิยมที่อัดแน่น (DPD) เป็นทศนิยม

พื้นหลัง

ข้อความ

ตารางการแปลง

งาน

กรณีทดสอบ

อินพุต

เอาท์พุต

เกณฑ์การให้คะแนนและการชนะ

JavaScript (ES6), 112 ไบต์

JavaScript (ES6), 118 117 ไบต์

อย่างไร?

ตัวอย่าง: ตัวเลขตัวแรก (หลักร้อย)

Python 3 , 229 ... 97 96 ไบต์

คำอธิบาย

JavaScript (Node.js) , 126 119 117 112 111 ไบต์

C (gcc) , 138 129 ไบต์

ทับทิม , 153 ... 119 117 ไบต์

มันทำงานอย่างไร:

เรติน่า 0.8.2 , 191 181 ไบต์

เยลลี่ , 51 48 40 39 ไบต์

ขั้นตอนวิธี

รหัส

Python 2 , 157 ไบต์

ทำความสะอาด , 238 ... 189 ไบต์

Perl 5, 195 ไบต์

คำอธิบายของรหัส

05AB1E , 84 ไบต์

05AB1E , 104 103 101 ไบต์