গ্রে কোডগুলি বাড়ানো হচ্ছে

36

ভূমিকা

একটি গ্রে কোড বাইনারি উপস্থাপনার একটি বিকল্প যেখানে কোনও সংখ্যা পরিবর্তনশীল বিটের পরিবর্তে কেবল একটি বিট টগল করে একটি সংখ্যা বৃদ্ধি করা হয়। দশমিক এবং বাইনারি সমতুল্য সহ কয়েকটি ধূসর কোড এখানে দেওয়া হল:

 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

একটি গ্রে কোডের চক্রীয় বিট প্যাটার্ন

কখনও কখনও "প্রতিবিম্বিত বাইনারি" নামে পরিচিত, একবারে কেবলমাত্র একটি বিট পরিবর্তনের সম্পত্তিটি প্রতিটি কলামের জন্য ন্যূনতম উল্লেখযোগ্য বিট থেকে শুরু করে চক্রীয় বিট নিদর্শনগুলির সাথে সহজেই অর্জিত হয়:

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

... ইত্যাদি।

উদ্দেশ্য

ধূসর কোডের একটি নন-প্যাডযুক্ত ইনপুট স্ট্রিং দেওয়া হয়েছে, ক্রমটিতে একটি একক অক্ষর পরিবর্তিত করে বা একটি 1(2 এর পরবর্তী পাওয়ারে বাড়ানোর সময়) প্রিপেন্ড করে ধূসর কোডটি বৃদ্ধি করুন , তারপরে ফলাফলটি একটি প্যাডযুক্ত ধূসর কোড হিসাবে আউটপুট দেয়।

আদেশ সহকারে

  • 0ইনপুট হিসাবে খালি স্ট্রিং নেওয়া বা নেওয়া সম্পর্কে চিন্তা করবেন না ।
  • সর্বনিম্ন ইনপুটটি হবে 1এবং পরিবেশের দ্বারা চাপানো মেমরির সীমাবদ্ধতা বাদে স্ট্রিং দৈর্ঘ্যের উপরের কোনও আবদ্ধ নেই।
  • নন-প্যাডড স্ট্রিংয়ের দ্বারা, আমি বোঝাতে চাইছি এখানে কোনও শীর্ষস্থানীয় বা চলমান শ্বেত স্পেস (optionচ্ছিক ট্রেলিং নিউলাইন ছাড়া অন্য) থাকবে না, এবং 0ইনপুট বা আউটপুটে কোনও শীর্ষস্থানীয় নেই ।

I / O ফর্ম্যাটগুলি

নিম্নলিখিত ফর্ম্যাটগুলি ইনপুট এবং আউটপুট জন্য স্বীকৃত ফর্ম হয়, তবে স্ট্রিংগুলি অন্য ফর্ম্যাটগুলির চেয়ে উত্সাহিত হয়:

  • সবচেয়ে গুরুত্বপূর্ণ "বিট" প্রথম
  • নন-প্যাডযুক্ত অক্ষর অ্যারে বা ASCII '1'গুলি এবং '0'এর স্ট্রিং
  • অ-প্যাডেড পূর্ণসংখ্যা অ্যারের 1s এবং 0গুলি
  • নন-প্যাডেড বুলিয়ান অ্যারে

কি অনুমোদিত নয়:

  • কমপক্ষে উল্লেখযোগ্য "বিট" প্রথমে
  • দশমিক, বাইনারি বা অ্যানারি পূর্ণসংখ্যা
  • নির্দিষ্ট দৈর্ঘ্যের ডেটা-কাঠামো
  • চরিত্র বিন্যাস বা মুদ্রণযোগ্য নয় এমন ASCII সূচকের স্ট্রিং 1এবং0

টেস্ট

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

অনুরোধের মাধ্যমে আরও পরীক্ষা যোগ করা যেতে পারে।

নির্ণায়ক

এটি কোড-গল্ফ , তাই বাইটের মধ্যে সংক্ষিপ্ততম প্রোগ্রাম! পূর্ববর্তী সাবমিশনগুলির পক্ষে সমস্ত সম্পর্ক ছিন্ন হয়ে যাবে; স্ট্যান্ডার্ড লুফোলস প্রযোজ্য। সেরা জমা দেওয়া উত্তর 9 ই অক্টোবর, 2016 স্বীকৃত হবে এবং যখনই আরও ভাল উত্তর দেওয়া হবে আপডেট করা হবে।

code-golf  sequence  number-theory  binary  coding-theory 
— প্যাট্রিক রবার্টস
সূত্র
1
— মার্টিন ইন্ডার 21
আমরা কি সংখ্যা হিসাবে ইনপুট নিতে পারি?
— xnor
1
কম স্পষ্টতই, সম্পর্কিত ।
— মার্টিন ইন্ডার 21
1
আমি কি ইনপুট এবং আউটপুট উভয়ই 0011
— বিপরীতভাবে
1
@ টনহসপেল দুঃখিত, আমি বিপরীত আই / ও সম্পর্কে আপনার প্রশ্নটি দেখিনি। যেমনটি আমি 1000000000 বলেছি আমার উত্তরটি হ্যাঁ।
— প্যাট্রিক রবার্টস

উত্তর:

13

জেলি , 10 8 বাইট

2 বাইট সংরক্ষণের জন্য ডেনিসকে ধন্যবাদ।

^\Ḅ‘^H$B

ইনপুট এবং আউটপুট 0 এবং 1 এর তালিকা।

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

গ্রে কোডের বিপরীতটি A006068 দ্বারা দেওয়া হয়েছে । এটি ব্যবহার করে আমাদের ইনপুটটি দেখার জন্য বৃহত সংখ্যক গ্রে কোড উত্পন্ন করার দরকার নেই। ওইআইএস-এ দেওয়া এই ক্রমের একটি শ্রেণিবিন্যাস হ'ল:

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ম কলামে প্রথম nবিট রয়েছে । সুতরাং, এই সূত্রটি বাইনারি ইনপুটটিতে তীব্রভাবে গণনা করা যেতে পারে কারণ তালিকার উপরে এক্সওআর এর সংশ্লেষিত হ্রাস (যা মূলত তালিকার প্রতিটি উপসর্গের ক্ষেত্রে এক্সওর প্রয়োগ করে এবং ফলাফলের একটি তালিকা দেয়)।

এটি আমাদের গ্রে কোডটি উল্টানোর জন্য একটি সহজ উপায় দেয়। এরপরে, আমরা কেবল ফলাফলটি বাড়িয়ে এনে আবার গ্রে কোডে রূপান্তর করি। পরবর্তী পদক্ষেপের জন্য আমরা নিম্নলিখিত সংজ্ঞাটি ব্যবহার করি:

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

ধন্যবাদ, জেলি যখন XOR চেষ্টা করার সময় ইনপুটগুলি স্বয়ংক্রিয়ভাবে মেঝেতে দেখায়। যাইহোক, এখানে কোড:

^\          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.
— মার্টিন ইন্ডার
সূত্র
আপনার দরকার নেই Ḟ$; bitwise অপারেটরদের কাস্ট int- এ ।
— ডেনিস
@ ডেনিস ধন্যবাদ, লেখার সময় আমি এটি আবিষ্কার করেছি। :)
— মার্টিন ইন্ডার
@ মার্টিনএেন্ডারটি পূর্ণসংখ্যাটি কী এটি অভ্যন্তরীণভাবে একটি বড় পূর্ণসংখ্যায় রূপান্তর করে?
— প্যাট্রিক রবার্টস
@ পেট্রিক রবার্টস হ্যাঁ, যদি প্রয়োজন হয় - এটি হুডের নিচে পাইথন।
— জোনাথন অ্যালান
সুন্দর বিশ্লেষণ এবং ব্যাখ্যা।
— ওয়েইন কনরাড
8

জাভাস্ক্রিপ্ট (ES6), 58 বাইট

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

সরাসরি উপযুক্ত বিট টগল করে। ব্যাখ্যা: মার্টিন ইন্ডিয়ারের উত্তরে দেখানো হয়েছে, একটি ডিকোডেড গ্রে কোডের প্রতিটি বিট হ'ল নিজের এবং তার বামে বিটগুলি ক্রমযুক্ত এক্সওআর বা প্যারিটি। তারপরে আমাদের সেই সংখ্যাটি বাড়ানো দরকার যা একটি ক্যারি রিপল সৃষ্টি করে যা ডানদিকের 1 টি বিট 0 এবং তারপর পরবর্তী 0 বিট থেকে 1 টগল করে 1. কেবলমাত্র 0 টি বিট অবস্থান টগলড সহ একটি কোডে পুনরায় এনকোডিংয়ের ফলাফল। যদি 1 টি বিটের সমতা সমান হয় তবে ডানদিকের বিটটি 0 হয় এবং তাই আমরা কেবল সর্বশেষ বিটটি টগল করি। যদি সমস্ত 1 টি বিটের সমতাটি বিজোড় হয় তবে ডানদিকের বিটগুলি 1 হয় এবং আমাদের শেষ 1 বিটটি সন্ধান করতে হবে। এটি এখন বহন করা বিটের সর্বশেষতম, সুতরাং আমাদের যে বিটটি টগল করতে হবে তা হ'ল ডান দিক থেকে পরের বিট।

— নিল
সূত্র
খুব সুন্দর পদ্ধতি। প্রথম ?মধ্যে /.?(?=10*$)/সত্যিই প্রয়োজনীয়? ওহ কিছু মনে করো না. হ্যাঁ তাই হয়। :-)
— Arnauld
8

পার্ল, 27 25 বাইট

এর জন্য +1 অন্তর্ভুক্ত -p

STDIN এ ইনপুট স্ট্রিং দিন, যেমন

gray.pl <<< 1010

gray.pl:

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

পার্লের কোনও সস্তা অসীম-নির্ভুল পূর্ণসংখ্যা নেই। তাই ডান বিটটিতে সরাসরি টগল করুন যা সর্বশেষ বিজোড় সংখ্যাযুক্ত 1 হবে তার ঠিক আগে is

— টন হসপেল
সূত্র
1
বাহ, \Gআপনার পক্ষে জিনিসগুলি সহজ করে তোলে!
— নিল
1
অন্যদিকে, \Kজিনিসগুলি আপনার জন্য আরও সহজ করে তোলে।
— নীল
হাআআআআআআ ... এখন আমি \Gবাস্তবায়নটিও দেখতে চাই ।
— ম্যাজিক অক্টোপাস উরন
2
@ কারাসোকম্পিউটিং আপনি সম্পাদিত লিঙ্কটিতে ক্লিক করে জমা দেওয়ার পুরানো সংস্করণগুলি দেখতে পাবেন
— টন হসপেল
6

হাস্কেল, 118 115 108 বাইট

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

আইডিয়নে চেষ্টা করে দেখুন।
নিষ্পাপ পদ্ধতির: gদৈর্ঘ্য সহ সমস্ত ধূসর কোডের সেট তৈরি করে n(0-প্যাডিং সহ), fকল gকরে length(input)+1, যতক্ষণ না 0<inputstring>পাওয়া পর্যন্ত সমস্ত উপাদান সরিয়ে ফেলে এবং পরবর্তী উপাদানটি (সম্ভবত নেতৃত্বের কাটা কাটা 0) ফেরত দেয় ।

— Laikoni
সূত্র
1
ভাল উত্তর! আমি আশা করি শীঘ্রই আমরা আরও কিছু দক্ষ পেতে পারি।
— প্যাট্রিক রবার্টস
5

এমএটিএল , 18 বাইট

ZBtE:t2/kZ~tb=fQ)B

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

ব্যাখ্যা

যাক একটি ( এন ) গ্রে কোড (সংশ্লিষ্ট পূর্ণসংখ্যার ক্রম বোঝাতে OEIS A003188 )। প্রোগ্রামটি বৈশিষ্ট্যটি a ( n ) = n XOR মেঝে ( n / 2) ব্যবহার করে, যেখানে XOR বিট-ওয়াইজ।

মূলত, কোড পূর্ণসংখ্যা একটি ইনপুট পরিবর্তন করে একটি 0 , দেখে যে ক্রমানুসারে পূর্ণসংখ্যা, এবং তারপর পরবর্তী টার্ম নির্বাচন করে। এর জন্য ক্রম a ( n ) এর পর্যাপ্ত পরিমাণে শর্তাদি তৈরি করা দরকার । দেখা যাচ্ছে যে 2 · a 0 যথেষ্ট পরিমাণে বড়। বাস্তবে দেখা যায় যে গ্রে কোড থেকে ডালপালা একটি ( এন ) কখনই চেয়ে বেশি বাইনারি সংখ্যা আছে এন ।

'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
— লুইস মেন্ডো
সূত্র
আমি লক্ষ্য করেছি আউটপুটটি স্থান-সীমিত অক্ষর ... এটি কোনও ধরণের অ্যারে প্রিন্ট করছে?
— প্যাট্রিক রবার্টস
@ পেট্রিকরোবার্টস হ্যাঁ, ঠিক আছে। আমি ধরে নিয়েছি এটি গ্রহণযোগ্য, তাই না?
— লুইস মেন্ডো 23
আমি এটি যেমন আছে তেমন গ্রহণ করব। আমি ইতিমধ্যে I / O ফর্ম্যাটে আমার প্রয়োজনীয়তাগুলি শিথিল করেছি, সুতরাং এটি আরও কঠোর করে তোলার কোনও মানে নেই। সুন্দর কাজ.
— প্যাট্রিক রবার্টস
5

সিজেএম (19 বাইট)

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

অনলাইন ডেমো । এটি বিট অ্যারে থেকে বিট অ্যারেতে একটি বেনামে ব্লক (ফাংশন), যা ডেমো একটি লুপে কার্যকর করে।

এটি সরল নীতিতে কাজ করে যে সেট বিটের সংখ্যা যদি আমাদের হয় তবে আমাদের কমপক্ষে উল্লেখযোগ্য বিটটিও টগল করা উচিত এবং অন্যথায় আমাদের বিটটি সর্বনিম্ন উল্লেখযোগ্য সেট বিটের বামে টগল করা উচিত। প্রকৃতপক্ষে সেই বিটটি চিহ্নিত করা বিটগুলির তালিকা ব্যবহারের চেয়ে কোনও পূর্ণসংখ্যার বিট হ্যাক ব্যবহার করা আরও সহজ be

ব্যবচ্ছেদ

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

এটি গ্রে কোড থেকে সূচক, ইনক্রিমেন্টে রূপান্তর করে এবং গ্রে কোডে ফিরে রূপান্তর করে।

— পিটার টেলর
সূত্র
5

জাভাস্ক্রিপ্ট (ES6), 53 বাইট (প্রতিযোগী নয়)

একটি পুনরাবৃত্ত ফাংশন যা ইনপুট না পাওয়া পর্যন্ত সমস্ত ধূসর কোডগুলি তৈরি করে, তারপরে পরবর্তী পুনরাবৃত্তিতে থামে।

সর্বোচ্চ সম্ভাব্য ইনপুট ব্রাউজার পুনরাবৃত্তি সীমা (ফায়ারফক্সে প্রায় 13 বিট এবং ক্রোমে 15 বিট) উপর নির্ভর করে।

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
স্নিপেট প্রসারিত করুন

— Arnauld
সূত্র
আমি ভয় করি যে এই জমাটি যোগ্যতা অর্জন করবে না, যেহেতু পদ্ধতিটি সীমাহীন স্ট্রিং দৈর্ঘ্যের জন্য কাজ করে না। আপনি যদি এই উত্তরটি এখানে রাখতে চান তবে দয়া করে অ-প্রতিযোগিতামূলক হয়ে যান।
— প্যাট্রিক রবার্টস
@ পেট্রিকরোবার্টস - অবশ্যই এটা বোধগম্য.
— আর্নল্ড
@ পেট্রিকরবার্টস আসলেই? "পরিবেশের দ্বারা চাপানো স্মৃতি সীমাবদ্ধতার" আওতায় কীভাবে পুনরাবৃত্তি সীমাবদ্ধতা আসে না?
— সান্চাইজস
@ সানচাইজস আমি হিপ মেমোরিটির কথা উল্লেখ করছিলাম, তবে আরও মূল বিষয় হল, এই প্রোগ্রামটি পরীক্ষা করা হওয়া পর্যন্ত প্রতিটি সম্ভাব্য ধূসর কোডের জন্য পুনরাবৃত্তি করে, যা অত্যন্ত অদক্ষ fficient প্রযুক্তিগতভাবে এটি "নোড.জেএস .5.৫" হিসাবে জমা দেওয়া যেতে পারে এবং --harmonyলেজ-কল পুনরাবৃত্তি অপ্টিমাইজেশানের অ্যাক্সেস পেতে পেনাল্টি বাইটস যুক্ত করেছে, যা এখানে সম্ভব বলে মনে হয়।
— প্যাট্রিক রবার্টস
@ সানচাইজস আমার জবাব খোঁজেন, এটি ছিল একটি দুর্বল যুক্তি। মূল বিষয়টি হ'ল পরিবেশের দ্বারা সীমাবদ্ধতা চাপানো হয়নি, এটি অ্যালগরিদম দ্বারা চাপানো হয়েছে। অন্যান্য উত্তর রয়েছে যা প্রতিটি বর্ধমান মানের চেয়ে প্রতিটি বিটের জন্য পুনরাবৃত্তি করে এবং আমি সেগুলিকে আরও গ্রহণযোগ্য বলে মনে করি যেহেতু এটি অনেক বিস্তৃত মানগুলির জন্য কাজ করে।
— প্যাট্রিক রবার্টস
2

রেটিনা, 25 বাইট

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

আমি নিশ্চিত যে এটি করার আরও ভাল উপায় থাকা উচিত ...

— নিল
সূত্র
আপনার আসলে কি দরকার ^?
— টন হসপেল
@ টনহোপেল রেজেক্স এটি ছাড়াই সর্বত্র মিলানোর চেষ্টা করেছিল। (মোড ডিফল্টগুলি একটি বিশ্বব্যাপী প্রতিস্থাপনে প্রতিস্থাপন করুন))
— নীল
2

05 এ বি 1 ই , 12 বাইট

ব্যবহার সিপি-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
— Emigna
সূত্র
2

পাইথন 2.7, 68 টি অক্ষর

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

পাইথন 3, 68 টি অক্ষর

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

এই ফাংশন প্রদত্ত বাইনারি স্ট্রিংটিকে একটি পূর্ণসংখ্যার সাথে রূপান্তর করে তারপরে মূল স্ট্রিংয়ে সেট বিটের সংখ্যাটি সমান হলে শেষ বিটটি জোর করে বা মূলটিতে সেট বিটের সংখ্যাটি যদি তার ডানদিকের সেট বিটের বামে কিছুটা অদলবদল করে স্ট্রিং বিজোড়। তারপরে এটি ফলাফলকে বাইনারি স্ট্রিংয়ে রূপান্তর করে এবং 0bবুলিয়ান উপসর্গটি সরিয়ে দেয় ।

— Morwenn
সূত্র
1
আপনি স্থানটি বাদ দিয়ে 1 টি বাইট সংরক্ষণ করতে পারেন def f(s):এবং এর printপরিবর্তে আরেকটি (পাইথন 2 ধরে ধরে) ব্যবহার করে return।
— এলপেড্রো
@ এলপেড্রো ধন্যবাদ, আমি একটি শর্তের কৌশলও প্রয়োগ করেছি এবং কয়েকটি অতিরিক্ত অক্ষর সংরক্ষণের জন্য
— জোরের
সবেমাত্র দেখেছি। উত্তম উত্তর :-)
— এলপিড্রো
উম .. পাইথন ডকুমেন্টেশন পরীক্ষা করে দেখে মনে হচ্ছে int()32 বিট পূর্ণসংখ্যার উত্পন্ন হয়, যদিও আমার যে কোনও দৈর্ঘ্যের স্ট্রিং বাড়ানোর জন্য আমার প্রয়োজন। আমি নিশ্চিত নই যে এটি বৈধ জমা হিসাবে যোগ্যতা অর্জন করেছে
— প্যাট্রিক রবার্টস
1
@ পেট্রিকরোবার্টস আমি পরে পরীক্ষা করব। longপরিবর্তে intসমস্যা সমাধান হতে পারে।
— মরওভেন
2

সি ++, 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বিজোড় হয় তবে শেষ অক্ষরটি ছাড়াই এই ফাংশনটিকে আবার কল করুন এবং নতুন মান গণনা করুন, তারপরে শেষ চরিত্রটি যুক্ত করুন।

পরীক্ষার ক্ষেত্রে এটি চেষ্টা করতে এখানে ক্লিক করুন।

— AlexRacer
সূত্র
আপনার জমা করার জন্য ধন্যবাদ. যদি আপনি আপনার পদ্ধতির একটি সংক্ষিপ্ত বিবরণ এবং ডেমো হিসাবে এটির একটি অনলাইন সংকলনের একটি লিঙ্ক সরবরাহ করতে পারেন, আমি সত্যিই এটির প্রশংসা করব।
— প্যাট্রিক রবার্টস
1
@ পেট্রিকরোবার্টস আপনার অনুরোধ অনুসারে লিঙ্ক এবং বিবরণ যুক্ত করলেন।
— অ্যালেক্সরেসার
2

ব্যাচ, 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। 0 গুলি সরিয়ে দেয় এবং 1 সেকেন্ডে একটি প্যারিটি চেক করে এবং যদি কোনও বিজোড় সংখ্যা থাকে তবে এটি লুপের মধ্যে ডানদিকের 0 টি স্ট্রিপ করে, যখন এটি 1 টি স্ট্রপ করে বন্ধ করে দেয় sতাই সমতা উপসর্গ এবং rবাকী স্ট্রিং রয়েছে। sশূন্যতে সেট করা থাকে যদি এটি ফাঁকা থাকে যাতে এর শেষ অঙ্কটি টগল করা যায় এবং তারপরে সমস্ত কিছু সংক্ষেপিত হয়।

— নিল
সূত্র
1

আসলে, 20 19 13 বাইট

"ইনপুট থেকে এক্সওর এর ক্রমহ্রাসমান হ্রাস" এর নিজস্ব সংস্করণ মার্টিন ইন্ডারের জেলি উত্তরের উপর ভিত্তি করে । গল্ফিং পরামর্শ স্বাগত জানাই। এটি অনলাইন চেষ্টা করুন!

σ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".
— Sherlock9
সূত্র
1

জে, 38 বাইট

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

এটি অনলাইন চেষ্টা করুন!

এটি মূলত জেতে মার্টিনের অ্যালগরিদম is

নোট এটি 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
— দুর্ভাগ্যআনয়নকারী
সূত্র
ভাল কাজ, বন্ধু!
— প্যাট্রিক রবার্টস
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.