บทนำ

สีเทารหัสเป็นทางเลือกแทน binary ซึ่งจำนวนจะเพิ่มขึ้นด้วยการสลับเพียงหนึ่งบิตมากกว่าตัวแปรจำนวนบิต นี่คือรหัสสีเทาบางส่วนพร้อมกับทศนิยมและเลขฐานสองของพวกเขา:

 decimal | binary | gray
-------------------------
       0 |      0 |    0
-------------------------
       1 |      1 |    1
-------------------------
       2 |     10 |   11
-------------------------
       3 |     11 |   10
-------------------------
       4 |    100 |  110
-------------------------
       5 |    101 |  111
-------------------------
       6 |    110 |  101
-------------------------
       7 |    111 |  100
-------------------------
       8 |   1000 | 1100
-------------------------
       9 |   1001 | 1101
-------------------------
      10 |   1010 | 1111
-------------------------
      11 |   1011 | 1110
-------------------------
      12 |   1100 | 1010
-------------------------
      13 |   1101 | 1011
-------------------------
      14 |   1110 | 1001
-------------------------
      15 |   1111 | 1000

ลวดลายบิตของรหัสสีเทา

บางครั้งเรียกว่า "reflection binary" คุณสมบัติของการเปลี่ยนเพียงครั้งละหนึ่งบิตสามารถทำได้อย่างง่ายดายด้วยรูปแบบวงจรแบบวงกลมสำหรับแต่ละคอลัมน์เริ่มต้นจากบิตที่มีนัยสำคัญน้อยที่สุด:

bit 0: 0110011001100110011001100110011001100110011001100110011001100110
bit 1: 0011110000111100001111000011110000111100001111000011110000111100
bit 2: 0000111111110000000011111111000000001111111100000000111111110000
bit 3: 0000000011111111111111110000000000000000111111111111111100000000
bit 4: 0000000000000000111111111111111111111111111111110000000000000000
bit 5: 0000000000000000000000000000000011111111111111111111111111111111

... และต่อไป

วัตถุประสงค์

กำหนดสตริงอินพุตแบบไม่มีการบุของโค้ดสีเทาให้เพิ่มโค้ดสีเทาโดยการสลับอักขระเดี่ยวในลำดับหรือการเตรียม a 1(เมื่อเพิ่มขึ้นเป็นกำลังถัดไปของ 2) จากนั้นเอาต์พุตผลลัพธ์เป็นโค้ดสีเทาแบบไม่มีเบาะ

คำเตือน

• ไม่ต้องกังวลกับการถ่าย0หรือสตริงว่างเปล่าเป็นอินพุต
• อินพุตต่ำสุดจะเป็น1และไม่มีขอบเขตบนของความยาวสตริงนอกเหนือจากข้อ จำกัด หน่วยความจำที่กำหนดโดยสภาพแวดล้อม
• โดยสตริงที่ไม่มีเบาะฉันหมายถึงจะไม่มีช่องว่างนำหน้าหรือต่อท้าย (นอกเหนือจากบรรทัดใหม่ที่เป็นทางเลือก) และไม่มีการนำหน้า0ในอินพุตหรือเอาต์พุต

รูปแบบ I / O

รูปแบบต่อไปนี้เป็นรูปแบบที่ได้รับการยอมรับสำหรับอินพุตและเอาต์พุต แต่สนับสนุนให้ใช้สตริงกับรูปแบบอื่น:

• "บิต" ที่สำคัญที่สุดก่อน
• อาร์เรย์อักขระหรือสตริงที่ไม่ใช่แบบเสริมของ ASCII '1's และ'0's
• อาร์เรย์จำนวนเต็มแบบไม่เพิ่มของ1s และ0s
• อาร์เรย์บูลีนที่ไม่มีเบาะ

ไม่อนุญาตอะไร:

• "บิต" ที่สำคัญน้อยที่สุดก่อน
• เลขฐานสิบ, เลขฐานสองหรือเลขจำนวนเต็ม
• โครงสร้างข้อมูลความยาวคงที่
• อาร์เรย์อักขระหรือสตริงของดัชนี ASCII ที่ไม่สามารถพิมพ์ได้1และ0

การทดสอบ

input -> output
1 -> 11
11 -> 10
111 -> 101
1011 -> 1001
1111 -> 1110
10111 -> 10110
101100 -> 100100
100000 -> 1100000

_{การทดสอบเพิ่มเติมสามารถเพิ่มได้ตามคำขอ}

เกณฑ์

นี่คือรหัสกอล์ฟโปรแกรมที่สั้นที่สุดในหน่วยไบต์ชนะ! ความสัมพันธ์ทั้งหมดจะถูกทำลายโดยได้รับความนิยมก่อนหน้านี้; ช่องโหว่มาตรฐานใช้ คำตอบที่ส่งที่ดีที่สุดจะได้รับการยอมรับ 9 ตุลาคม 2016 และปรับปรุงเมื่อใดก็ตามที่คำตอบที่ดีกว่าจะได้รับ

เยลลี่ , 10 8 ไบต์

ขอบคุณเดนนิสที่ช่วยประหยัด 2 ไบต์

^\Ḅ‘^H$B

อินพุตและเอาต์พุตเป็นรายการของ 0s และ 1s

ลองออนไลน์!

คำอธิบาย

ผกผันของรหัสสีเทาจะได้รับโดยA006068 เมื่อใช้สิ่งนี้เราไม่จำเป็นต้องสร้างรหัสสีเทาจำนวนมากเพื่อค้นหาอินพุต การจำแนกประเภทหนึ่งของลำดับนี้ที่กำหนดใน OEIS คือ:

a(n) = n XOR [n/2] XOR [n/4] XOR [n/8] ...

ตำแหน่งที่[]เป็นพื้นยึด ลองพิจารณาตัวอย่างของการมีตัวแทนไบนารี44 101100การหารด้วย 2 และการปูพื้นเป็นเพียงการเปลี่ยนแปลงที่เหมาะสมตัดส่วนที่มีนัยสำคัญน้อยที่สุดออก ดังนั้นเราจึงพยายามที่จะ XOR ตัวเลขต่อไปนี้

1 0 1 1 0 0
  1 0 1 1 0
    1 0 1 1
      1 0 1
        1 0
          1

ขอให้สังเกตว่าnคอลัมน์ th มีnบิตแรก ดังนั้นสูตรนี้สามารถคำนวณได้เล็กน้อยบนอินพุตไบนารี่เนื่องจากเป็นการลดการสะสมของ XOR ในรายการ (ซึ่งโดยทั่วไปจะใช้ XOR กับคำนำหน้าของรายการแต่ละรายการ

วิธีนี้ทำให้เราสามารถสลับรหัสสีเทาได้ง่าย หลังจากนั้นเราก็เพิ่มผลลัพธ์และแปลงกลับเป็นรหัสสีเทา สำหรับขั้นตอนหลังเราใช้คำจำกัดความต่อไปนี้:

a(n) = n XOR floor(n/2)

โชคดีที่ Jelly ดูเหมือนจะปูพื้นอินพุตโดยอัตโนมัติเมื่อพยายามที่จะแฮคเกอร์พวกเขา อย่างไรก็ตามนี่คือรหัส:

^\          Cumulative reduce of XOR over the input.
  Ḅ         Convert binary list to integer.
   ‘        Increment.
    ^H$     XOR with half of itself.
       B    Convert integer to binary list.

JavaScript (ES6), 58 ไบต์

s=>s.replace(s.split`1`.length%2?/.$/:/.?(?=10*$)/,c=>1-c)

สลับบิตที่เหมาะสมโดยตรง คำอธิบาย: ดังแสดงในคำตอบของ MartinEnder ♦แต่ละบิตในโค้ดสีเทาที่ถอดรหัสคือ XOR หรือพาริตีสะสมของตัวเองและบิตทางด้านซ้าย จากนั้นเราจำเป็นต้องเพิ่มจำนวนซึ่งเป็นเหตุให้ระลอกการกระทำที่สลับ 1 บิตขวาสุดทั้งหมดเป็น 0 และจากนั้น 0 บิตต่อ 1 ถัดไปเป็น 1 การเข้ารหัสอีกครั้งส่งผลให้เกิดรหัสในรหัสที่มีตำแหน่ง 0 บิตเพียงหนึ่งสลับ หากความเท่าเทียมกันของ 1 บิตทั้งหมดเท่ากันบิตขวาสุดคือ 0 และเราก็แค่สลับบิตสุดท้าย หากความเท่าเทียมกันของ 1 บิตทั้งหมดเป็นเลขคี่บิตขวาสุดคือ 1 และเราต้องค้นหา 1 บิตสุดท้าย นี่คือตอนสุดท้ายของบิตที่ถูกยกดังนั้นบิตที่เราต้องสลับคือบิตถัดไปจากทางขวา

Perl, 27 25 ไบต์

รวม +1 สำหรับ -p

ให้สตริงที่ป้อนใน STDIN เช่น

gray.pl <<< 1010

gray.pl:

#!/usr/bin/perl -p
s%(10*\K1(\K0)*)*%1-$&%e

Perl ไม่มีจำนวนเต็มความแม่นยำไม่มีที่สิ้นสุดราคาถูก ดังนั้นสลับบิตที่ถูกต้องซึ่งเป็นอันที่ก่อนหน้านี้ซึ่งเลข 1 คี่สุดท้ายจะเป็น

Haskell, 118 115 108 bytes

g 0=[""]
g n|a<-g$n-1=map('0':)a++map('1':)(reverse a)
d=dropWhile
f s=d(=='0')$(d(/='0':s)$g$1+length s)!!1

ลองใช้กับ Ideone
วิธีการที่ไร้เดียงสา: gสร้างชุดของรหัสสีเทาทั้งหมดที่มีความยาวn(0-padding) fเรียกร้องgกับlength(input)+1เอาองค์ประกอบทั้งหมดจนกว่า0<inputstring>จะพบและผลตอบแทนองค์ประกอบถัดไป (ตัดทอนอาจนำ0)

MATL , 18 ไบต์

ZBtE:t2/kZ~tb=fQ)B

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย

ให้a ( n ) แสดงลำดับของจำนวนเต็มที่สอดคล้องกับรหัสสีเทา ( OEIS A003188 ) โปรแกรมใช้การจำแนกลักษณะa ( n ) = nชั้น XOR ( n / 2) โดยที่ XOR เป็นบิตที่ชาญฉลาด

โดยพื้นฐานแล้วโค้ดจะแปลงอินพุตเป็นจำนวนเต็มa ₀พบว่าจำนวนเต็มนั้นในลำดับและจากนั้นเลือกคำถัดไป สิ่งนี้ต้องสร้างข้อกำหนดจำนวนมากของลำดับa ( n ) ปรากฎว่า 2 · a ₀มีขนาดใหญ่พอสมควร นี้เกิดขึ้นจากความจริงที่ว่ารหัสสีเทา( n ) ไม่เคยมีตัวเลขไบนารีมากกว่าn

ลองทำ'101'ตัวอย่างเป็นตัวอย่าง

ZB      % Input string implicitly. Convert from binary string to integer
        %   STACK: 5
t       % Duplicate
        %   STACK: 5, 5
E       % Multiply by 2. This is the number of terms we'll generate from the sequence
        %   STACK: 5, 10
:       % Range
        %   STACK: 5, [1 2 3 4 5 6 7 8 9 10]
t       % Duplicate
        %   STACK: 5, [1 2 3 4 5 6 7 8 9 10], [1 2 3 4 5 6 7 8 9 10]
2/k     % Divide by 2 and round down, element-wise
        %   STACK: 5, [1 2 3 4 5 6 7 8 9 10], [0 1 1 2 2 3 3 4 4 5]
Z~      % Bit-wise XOR, element-wise
        %   STACK: 5, [1 3 2 6 7 5 4 12 13 15]
t       % Duplicate
        %   STACK: 5, [1 3 2 6 7 5 4 12 13 15], [1 3 2 6 7 5 4 12 13 15]
b       % Bubble up
        %   STACK: [1 3 2 6 7 5 4 12 13 15], [1 3 2 6 7 5 4 12 13 15], 5
=       % Equality test, element-wise
        %   STACK: [1 3 2 6 7 5 4 12 13 15], [0 0 0 0 0 1 0 0 0 0]
f       % Find: yield (1-based) index of nonzero values (here there's only one)
        %   STACK: [1 3 2 6 7 5 4 12 13 15], 6
Q       % Increase by 1
        %   STACK: [1 3 2 6 7 5 4 12 13 15], 7
)       % Apply as index
        %   STACK: 4
B       % Convert to binary array
        %   STACK: [1 0 0]
        % Implicitly display

CJam (19 ไบต์)

{_2b__(^@1b1&*)^2b}

สาธิตออนไลน์ นี่คือบล็อกที่ไม่ระบุชื่อ (ฟังก์ชัน) จากบิตอาเรย์ไปยังบิตอาเรย์ซึ่งการสาธิตดำเนินการในวง

มันทำงานบนหลักการง่าย ๆ ว่าถ้าจำนวนบิตที่ตั้งไว้เป็นจำนวนเท่าไหร่เราก็ควรสลับบิตที่มีนัยสำคัญน้อยที่สุดและมิฉะนั้นเราควรสลับบิตไปทางซ้ายของบิตเซ็ตที่สำคัญน้อยที่สุด การระบุบิตนั้นจะง่ายกว่าการใช้บิตแฮ็คในจำนวนเต็มกว่าการใช้รายการบิต

การผ่า

{         e# Declare a block:
  _2b     e#   Convert the bit array to a binary number
  __(^    e#   x ^ (x-1) gives 1s from the least significant set bit down
  @1b1&   e#   Get the parity of the number of set bits from the original array
  *       e#   Multiply: if we have an even number of set bits, we get 0;
          e#   otherwise we have 2**(lssb + 1) - 1
  )^      e#   Increment and xor by 1 or 2**(lssb + 1)
  2b      e#   Base convert back to a bit array
}

การทำงานกับบิตอาเรย์ แต่เพียงผู้เดียวฉันคิดว่ามันจำเป็นที่จะต้องย้อนกลับ: การทำงานกับแบ็กซ้ายสุด1นั้นง่ายกว่าที่ถูกต้องที่สุด สิ่งที่ดีที่สุดที่ฉันเคยพบคือ (24 ไบต์):

{W%_1b)1&1$+1#0a*1+.^W%}

วิธีการทางเลือก (19 ไบต์)

{[{1$^}*]2b)_2/^2b}

สิ่งนี้จะแปลงจากรหัสสีเทาเป็นดัชนีส่วนเพิ่มและแปลงกลับเป็นรหัสสีเทา

JavaScript (ES6), 53 ไบต์ (ไม่แข่งขัน)

ฟังก์ชันเรียกซ้ำที่สร้างรหัสสีเทาทั้งหมดจนกว่าจะพบอินพุตจากนั้นหยุดที่การวนซ้ำครั้งถัดไป

อินพุตที่เป็นไปได้สูงสุดนั้นขึ้นอยู่กับขีด จำกัด การเรียกซ้ำของเบราว์เซอร์ (ประมาณ 13 บิตใน Firefox และ 15 บิตใน Chrome)

f=(s,n=1)=>(b=(n^n/2).toString(2),s)?f(b!=s&&s,n+1):b

console.log(f("1"));      // -> 11
console.log(f("11"));     // -> 10
console.log(f("111"));    // -> 101
console.log(f("1011"));   // -> 1001
console.log(f("1111"));   // -> 1110
console.log(f("10111"));  // -> 10110
console.log(f("101100")); // -> 100100
console.log(f("100000")); // -> 1100000

เรติน่า 25 ไบต์

^(10*10*)*
$1:
1:
0
.?:
1

ฉันรู้สึกว่าควรมีวิธีที่ดีกว่าในการทำเช่นนี้ ...

05AB1E , 12 ไบต์

ใช้การเข้ารหัสCP-1252

CÐ<^¹SOÉ*>^b

ลองออนไลน์!

คำอธิบาย

ตัวอย่างสำหรับการป้อนข้อมูล1011

C              # convert to int (bigint if necessary)
               # STACK: 11
 Ð             # triplicate
               # STACK: 11, 11, 11
  <            # decrease by 1
               # STACK: 11, 11, 10
   ^           # XOR
               # STACK: 11, 1
    ¹          # push first input
               # STACK: 11, 1, 1011
     S         # split to list
               # STACK: 11, 1, [1,0,1,1]
      O        # sum
               # STACK: 11, 1, 3
       É       # mod 2
               # STACK: 11, 1, 1
        *      # multiply
               # STACK: 11, 1
         >     # increase by 1
               # STACK: 11, 2
          ^    # XOR
               # STACK: 9
           b   # convert to binary
               # STACK: 1001
               # implicitly print top of stack

Python 2.7, 68 ตัวอักษร

def f(s):i=long(s,2);print bin(i^(1,(i&-i)<<1)[s.count('1')&1])[2:]

Python 3, 68 ตัวอักษร

def f(s):i=int(s,2);print(bin(i^(1,(i&-i)<<1)[s.count('1')&1])[2:])

ฟังก์ชั่นนี้จะแปลงสตริงไบนารี่ที่ได้รับให้เป็นจำนวนเต็มจากนั้น xor บิตสุดท้ายหากจำนวนบิตตั้งค่าในสตริงเดิมเป็นเลขคู่หรือแลกเปลี่ยนบิตไปทางซ้ายของบิตเซ็ตขวาสุดหากจำนวนบิตตั้งในต้นฉบับ สตริงคี่ จากนั้นจะแปลงผลลัพธ์เป็นสตริงไบนารีและลบ0bคำนำหน้าบูลีน

C ++, 205 ไบต์

#include <string>
std::string g(std::string s){int i,z;if(s=="1")return"11";for(i=z=0;i<s.length();i++)if(s[i]=='1')z++;i--;if(z%2){char c=s[i];s.erase(i);s=g(s);s+=c;}else{s[i]=s[i]==49?48:49;}return s;}

คำอธิบาย: แม้ตัวเลขมีจำนวนคู่ ตัวแปรzนับคน ถ้าzเป็นเลขคู่ ( z mod 2 = z%2 = 0- สาขาอื่น) ให้เปลี่ยนบิตสุดท้าย ถ้าzเป็นเลขคี่ให้เรียกใช้ฟังก์ชันนี้อีกครั้งโดยไม่มีอักขระตัวสุดท้ายและคำนวณค่าใหม่จากนั้นผนวกอักขระตัวสุดท้ายต่อจากนั้น

คลิกที่นี่เพื่อลองสำหรับกรณีทดสอบ

แบตช์199 197 ไบต์

@echo off
set/ps=
set r=
set t=%s:0=%
if 1%t:11=%==1 goto g
:l
set b=%s:~-1%
set s=%s:~,-1%
set r=%b%%r%
if %b%==0 goto l
if 0%s%==0 set s=0
:g
set/ab=1-%s:~-1%
echo %s:~,-1%%b%%r%

อ่านข้อมูลจาก STDIN sลงในตัวแปร ลบ 0s และทำการตรวจสอบพาริตี้บน 1s และหากมีจำนวนคี่มันจะตัดแถบ 0s ขวาสุดในลูปให้หยุดเมื่อมันsดึงแถบ 1 ดังนั้นจึงมีคำนำหน้าคู่เสมอและrส่วนที่เหลือของสตริง sถูกตั้งค่าเป็นศูนย์ถ้ามันว่างเปล่าเพื่อให้สามารถสลับหลักสุดท้ายได้จากนั้นทุกอย่างจะถูกต่อกัน

จริงแล้ว20 19 13 ไบต์

ตามคำตอบของเยลลี่มาร์ตินเอนเดอร์กับเวอร์ชั่นของตัวเอง "สะสมลด XOR มากกว่าการป้อนข้อมูล" ยินดีต้อนรับคำแนะนำการเล่นกอล์ฟ ลองออนไลน์!

σ1♀&2@¿u;½≈^├

Ungolfing

      Implicit input a as a list, such as [1,0,1,1,0,0].
σ     Get the cumulative sums of a.
1♀&   Map x&1 (equivalent to x%2) over every member of the cumulative sum.
2@¿   Convert from binary to decimal.
u     Increment x.
;½≈   Duplicate and integer divide by 2.
^     XOR x and x//2.
├     Convert to binary to obtain our incremented Gray code.
      Implicit return as a string, such as "100100".

J, 38 ไบต์

[:#:@(22 b.<.@-:)@>:@#.[:22 b./[:#:#.\

ลองออนไลน์!

นี่คืออัลกอริธึมของ Martin ใน J

โปรดทราบว่า22 b.เป็น XOR

                                    [: #: #.\   Creates the prefixes of the input
                                                converts to a number, then converts
                                                back to binary.  Needed to get the
                                                padding on the left.

                          [: 22 b./             Reduce the rows of the resulting 
                                                matrix with XOR, giving us the 
                                                normal binary
                      @#.                       Convert to int and...
                   @>:                          Increment and...
      (22 b. <.@-:)                             XOR that with its own floored half
[: #:@                                          And turn the result back to binary