คุณมีเหรียญที่ผลิตหรือ0 1แต่คุณสงสัยว่าเหรียญอาจมีอคติหมายความว่าความน่าจะเป็นของ0(หรือ1) ไม่จำเป็นต้อง 1/2

ที่รู้จักกันดีขั้นตอนที่จะ "เปลี่ยน" เหรียญลำเอียงเป็นเหรียญที่เป็นธรรม (คือเพื่อให้ได้ผลเท่ากัน) ที่เสนอโดยฟอนนอยมันน์เป็นดังนี้ สร้างบล็อก (ไม่ทับซ้อนกัน) ของสองเหรียญโยนจนกว่าทั้งสองค่าของบล็อกจะแตกต่างกัน และส่งออกค่าแรกในบล็อกนั้น (ค่าที่สองจะทำเช่นกัน แต่สำหรับวัตถุประสงค์ของการท้าทายนี้เราเลือกแรก) โดยสังหรณ์ใจ1อาจมีแนวโน้มมากกว่า0แต่01และ10จะมีโอกาสเท่ากัน

ตัวอย่างเช่นอินพุต1110...จะยกเลิกบล็อกแรกจากนั้นสร้าง1บล็อกจากบล็อกที่สอง ...

ขั้นตอนนี้มีราคาแพงเนื่องจากมีการใช้การทอยเหรียญหลายครั้งเพื่อสร้างผลลัพธ์เดียว

ความท้าทาย

ใช้ลำดับเลขศูนย์และจำนวนเต็มแทนการโยนเหรียญเดิมและสร้างผลลัพธ์จำนวนสูงสุดตามขั้นตอนข้างต้นจนกว่าจะหมดการป้อนข้อมูลทั้งหมด

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

กฎระเบียบ

อินพุตสามารถมีจำนวนของค่าที่ไม่เป็นลบได้ไม่จำเป็นต้องเป็นค่าบวกหรือแม้แต่

รูปแบบอินพุตอาจเป็น:

• อาเรย์ของศูนย์และคน;
• สตริงของศูนย์และคนที่มีตัวคั่นตัวเลือก

รูปแบบผลลัพธ์อาจเป็น:

• สตริงของศูนย์และคนที่มีหรือไม่มีตัวคั่น;
• อาเรย์ของศูนย์และคน;
• สตริงที่มีศูนย์หรือหนึ่งเดียวคั่นด้วยขึ้นบรรทัดใหม่;
• รูปแบบที่สมเหตุสมผลและเหมาะสมกับภาษาของคุณ

รหัสกอล์ฟ ไบต์ที่น้อยที่สุดจะเป็นผู้ชนะ

กรณีทดสอบ

อินพุตและเอาต์พุตอยู่ที่นี่เพื่อถือว่าเป็นสตริง

Input         -->  Output

'1110'        -->  '1'
'11000110'    -->  '01'
'1100011'     -->  '0'
'00'          -->  ''
'1'           -->  ''
''            -->  ''
'1101001'     -->  '0'
'1011101010'  -->  '1111'

เยลลี่ 6 ไบต์

s2Q€Ṗ€

ลองออนไลน์!

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

s2Q€Ṗ€  Main link. Argument: S (string)

s2      Split the string into pairs of characters.
  Q€    Deduplicate each pair.
        This removes the second character iff it is equal to the first.
    Ṗ€  Pop each; remove the last character of each pair/singleton.

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

(.)\1|(.)?.
$2

ลองออนไลน์!

คำอธิบาย

มันค่อนข้างง่าย รหัสกำหนดการทดแทน regex เดียวแทนที่การจับคู่ทั้งหมด (ไม่ทับซ้อนกัน) (.)\1|(.)?.กับกลุ่มที่สองที่ถูกจับ กรณีนี้รวมสามกรณีที่แตกต่างกันเป็นหนึ่งเดียว:

(.)\1 --> <empty>

หากตัวเลขสองหลักซ้ำกันเราจะลบออกจากสตริง (เพราะกลุ่มที่ 2 ไม่ได้ใช้)

(.).  --> $2

มิฉะนั้นหากเราสามารถจับคู่อักขระสองตัวให้ลบตัวที่สองออกโดยแทนที่ทั้งสองด้วยตัวแรก หากไม่ใช่กรณีดังกล่าว?จะเป็นการละเว้นกลุ่ม:

.     --> <empty>

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

เขาวงกต , 21 12 ไบต์

"(. :
""*$,@

ตัวอย่างที่หายากของโปรแกรม Labyrinth ขนาดกะทัดรัดที่ไม่มีตัวเลือก |ในรุ่นก่อนหน้านี้ที่ไม่จำเป็นอย่างสมบูรณ์และถอดมันออกมาอย่างหนาแน่นลดขนาดของโปรแกรม ในความเป็นจริงแล็บเต้น Retina!

ลองออนไลน์!

ด้านล่างซ้าย"ยังสามารถเป็นช่องว่างได้ด้วย

คำอธิบาย

ภาพนี้ช่างยากขึ้นดังนั้นมันจึงมาพร้อมรูปภาพ แต่ก่อนอื่นไพรเมอร์ด่วน:

• เขาวงกตเป็นภาษา 2D ตามสแต็ค หน่วยความจำประกอบด้วยกองหลักและกองเสริม
• สแต็คของเขาวงกตนั้นเป็นส่วนลึกและเต็มไปด้วยเลขศูนย์ดังนั้นการดำเนินการกับสแต็กที่ว่างเปล่าจึงไม่ใช่ข้อผิดพลาด
• ที่แต่ละทางแยกที่มีสองเส้นทางหรือมากกว่าสำหรับตัวชี้คำสั่งที่จะไปด้านบนของสแต็กหลักจะถูกตรวจสอบเพื่อหาว่าจะไปที่ไหนต่อไป ลบคือเลี้ยวซ้ายศูนย์ตรงไปข้างหน้าและบวกคือเลี้ยวขวา หากการเลี้ยวล้มเหลวตัวชี้จะพยายามหมุนในทิศทางอื่น

ติดตั้ง

โปรแกรมเริ่มต้นที่ด้านบนซ้าย"ซึ่งเป็นแบบไม่มี op จากนั้นเราดำเนินการ:

(        Decrement a bottom zero to -1. Since -1 is negative we try to turn 
         left at this junction, fail, and turn right instead.
"        No-op junction, turn left
*        Multiply top of stack (-1) with a 0 at bottom of stack, giving 0.
         This makes us go straight ahead at this junction.
$        Bitwise xor (of 0 and 0)

ซึ่งปล่อยให้สแต็กมี 0 ตัวเดียวซึ่งดีพอสำหรับจุดประสงค์ของเขาวงกต

การอ่านอินพุตและการยกเลิก

,อ่านอักขระถ่านจากอินพุทส่งคืน 48 หรือ 49 สำหรับ0หรือ1ตามลำดับและ -1 บน EOF เนื่องจากนี่ไม่ใช่ศูนย์วิธีที่เราเปลี่ยนเป็น:ซึ่งทำซ้ำด้านบนของสแต็ก

:ที่สิ้นตายดังนั้นเราจึงหันไปรอบ ๆ และดำเนินการ,อีกครั้ง ตอนนี้ถ้าใส่ที่ผ่านมาเป็น EOF แล้วเราเลี้ยวซ้ายและยุติด้วย@, อื่นที่เราเลี้ยวขวากับสแต็คมองเช่น[a a b](ที่a, bเป็นสองตัวอักษร)

การตีความการโยนเหรียญ

หากเราไม่ยุติการย้ายครั้งต่อไปของเราคือการเรียกใช้$(bitwise xor) อีกครั้ง นี่จะให้ผลเป็น 0 ถ้าตัวอักษรอินพุตเหมือนกันหรือ 1 เป็นอย่างอื่น จากนั้นเราจะคูณaด้วยผลนี้ให้ 0 aหรือ เนื่องจาก*อยู่ที่จุดเชื่อมต่อค่าสแต็กด้านบนนี้จะกำหนดว่าจะเกิดอะไรขึ้นต่อไป

ในกรณีที่ 0 เราจะตรงไปข้างหน้าและดำเนินการสาม"ตัวเลือกก่อนที่จะทำการ(ลดลง เช่นเดียวกับการตั้งค่าสิ่งนี้ทำให้เราหันมาและดำเนินการ"*$ทำให้เราพร้อมที่จะอ่านตัวอักษรมากขึ้น

มิฉะนั้นในaกรณีเราเลี้ยวขวาที่ทางแยกเนื่องจากaเป็นบวก (48 หรือ 49) .ส่งออกถ่านโดยปล่อยให้สแต็กว่างเปล่าและ(ลดส่วนบนสุดของสแต็กเปลี่ยนเป็น 0 ถึง -1 อีกครั้งสิ่งนี้ทำให้เราเลี้ยวซ้ายดำเนินการ"*$เหมือนในการตั้งค่าทำให้เราพร้อมที่จะอ่านอินพุตเพิ่มเติม

CJam, 10 8 ไบต์

l2/{)-}%

ทดสอบที่นี่

คำอธิบาย

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

"0"  --> ""
"1"  --> ""
"00" --> ""
"01" --> "0"
"10" --> "1"
"11" --> ""

นี่เหลือเฉพาะตัวเลขที่เรากำลังมองหา นี่คือวิธีการคำนวณรหัสนี้:

l     e# Read input.
2/    e# Split into pairs. Odd inputs will yield a single-character string at the end.
{     e# Map this block over the pairs...
  )   e#   Pull the last character off the string.
  -   e#   Remove all occurrences of that character from the remainder (which is either
      e#   an empty string to begin with or a single-digit string).
}%

เมื่อรายการถูกพิมพ์อัตโนมัติในตอนท้ายของโปรแกรมสตริงที่ว่างเปล่าจะถูกละเว้น

Perl, 19 18 17 ไบต์

@Martin Büttner Retina เป็นแรงบันดาลใจในการได้รับ 2 ไบต์

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

เรียกใช้ด้วยอินพุตบน STDIN เช่น perl -p fair.pl <<< 11000110

fair.pl:

s/(.)\1|.?\K.//g

ไม่มากที่จะอธิบายที่นี่เนื่องจากเป็นการแปล (ทางอ้อม) ของข้อกำหนด:

• (.)\1 หากตัวเลข 2 ตัวแรกเหมือนกันให้วางลง
• .\K. มิฉะนั้นตัวเลขสองหลักแรกจะแตกต่างกัน Keep ( \K) อันแรก
• .?\K.ยกเว้นว่าอันแรก.เป็นทางเลือก การทำเช่นนี้ช่วยให้สามารถจับคู่เดี่ยวที่ส่วนท้ายของสตริงซึ่งจะถูกละทิ้งเนื่องจากส่วนที่เก็บไว้ว่างเปล่า

Mathematica, 36 38ไบต์

-2 หลังจากขโมยฟังก์ชันของ @ LegionMammal978 เพื่อพิจารณาว่ารายการ 2 องค์ประกอบคือ {0,1} หรือ {1,0}

#&@@@Select[#~Partition~2,Tr@#==1&]&

อาร์กิวเมนต์คาดว่าจะเป็นรายการจำนวนเต็ม

Hexagony , 23 21 ไบต์

,){,/;(_\/'%<\{)/>~$>

กางออก:

    , ) { ,
   / ; ( _ \
  / ' % < \ {
 ) / > ~ $ > .
  . . . . . .
   . . . . .
    . . . .

สิ่งนี้สิ้นสุดลงด้วยข้อผิดพลาด แต่ข้อความผิดพลาดไปที่ STDERR

ลองออนไลน์!

เมื่อพิจารณาจากจำนวนกระจกมันอาจเป็นไปได้ที่จะปรับเข้ากับความยาวด้าน 3 แต่ฉันไม่เคยโชคดีมาก่อน

คำอธิบาย

นี่คือแผนภาพปกติที่สร้างด้วย HexagonyColorer ของTimwi :

โปรแกรมใช้ขอบหน่วยความจำเพียงสามขอบเท่านั้นระบุว่าA , BและCที่นี่ (แผนภาพแสดงความเอื้อเฟื้อโดยEsotericIDEของ Timwi ):

การดำเนินการเริ่มต้นบนเส้นทางสีน้ำเงิน /มีกระจกเพียงว่าการเปลี่ยนเส้นทางการเรียนการสอนชี้ (IP) ที่เกิดขึ้นจริงคือรหัส:

,   Read character from STDIN into memory edge A.
)   Increment.
{   Move to memory edge B.
,   Read character from STDIN into memory edge B.
)   Increment.
'   Move to memory edge C.
%   Compute A mod B in memory edge C.

การ,ตั้งค่าจะเป็นขอบ-1แทนที่จะเป็นรหัสอักขระหากเรากด EOF เนื่องจากเรากำลังที่เพิ่มขึ้นทั้งปัจจัยการผลิตที่ไม่เปลี่ยนแปลงไม่ว่าพวกเขามีค่าเท่ากันหรือไม่ 0แต่ก็จะเปิดเข้าไปใน

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

ตอนนี้<ความแตกต่างเป็นศูนย์จากผลลัพธ์ในเชิงบวก แบบง่ายแรก: หากอักขระมีค่าเท่ากัน IP จะพา ธ สีแดง _เป็นมิรเรอร์\เป็นมิรเรอร์ แต่ถูกเพิกเฉยและ>เบี่ยงเบน IP ซึ่งมันล้อมรอบขอบและเริ่มจากด้านบนอีกครั้ง อย่างไรก็ตามในการทำซ้ำนี้บทบาทของA , BและCจะถูกสลับสับเปลี่ยน cyclically ( ตอนนี้Cใช้บทบาทของAและอื่น ๆ )

หากอักขระแตกต่างกันพา ธ สีเขียวจะถูกนำมาใช้แทน อันนี้ยุ่งหน่อย มันกระโดดข้ามไม่มีตัวเลือกด้วย$แล้วล้อมรอบไปที่/ขอบด้านซ้ายแล้วข้ามแถวที่สองไปยังแถวสุดท้ายจากขวาไปซ้ายและในที่สุดก็เข้าส่วนที่น่าสนใจของซอร์สโค้ด{อีกครั้ง มีโค้ดเชิงเส้นอยู่เล็กน้อยที่ฉันจะอธิบายในหนึ่งวินาทีก่อนที่$จะทำให้ IP กระโดดข้าม>เพื่อรวมสองเส้นทางอีกครั้ง

นี่คือโค้ดเชิงเส้น:

{    Move to memory edge A.
(    Decrement to recover the actual character we read.
;    Print the character back to STDOUT.
'    Move to memory edge B.
~    Multiply the value there by -1, making it negative. This is
     necessary to ensure that the path correctly wraps back to the top.

โปรดทราบว่าในกรณีนี้บทบาทของขอบสำหรับการวนซ้ำครั้งถัดไปนั้นจะสลับสลับกันไปเรื่อย ๆ แต่ด้วยB ที่รับบทบาทเป็น Aและอื่น ๆ

Haskell, 71 44 29 ไบต์

p(a:b:r)=[a|a/=b]++p r
p _=[]

การเล่นกอล์ฟที่มากที่สุดโดยNimi

> <> , 11 ไบต์

i:i:0(?;-?o

> <> เหมาะกับความท้าทายในการอ่านแบบตัวต่อเวลาเช่นนี้ :) ลองออนไลน์!

i:            Read char and duplicate
i             Read char
:0(?;         Halt if last char was EOF
-             Subtract
?o            Output first char if the subtraction was non-zero (i.e. not equal)

ทั้งหมดนี้เกิดขึ้นในลูปเนื่องจากตัวชี้คำแนะนำล้อมรอบเมื่อถึงจุดสิ้นสุดของบรรทัด

Python ขนาด 42 ไบต์

f=lambda L:L[1:]and L[:L[0]^L[1]]+f(L[2:])

สนุกกับการเรียกซ้ำและ xor ค่าบิต ทำรายการ 1s และ 0s เป็นอินพุต

JavaScript (ES6), 33 ไบต์

s=>s.filter((c,i)=>++i%2&c!=s[i])

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

s=>s                // Take the input array.
.filter((c,i)=>   ) // Filter to only the chars that are both:
++i%2&              //  on an even index, and
c!=s[i]             //  not equal to the one after them.

โหมโรง 12 ไบต์

11(-(#!)?^?)

สิ่งนี้จะถือว่าล่ามที่อ่านและพิมพ์ตัวอักษร คุณสามารถลองออนไลน์ได้ แต่ล่ามนั้นจะพิมพ์จำนวนเต็มดังนั้นสำหรับแต่ละคน0คุณจะได้รับ48และสำหรับแต่ละคน1คุณจะได้รับ49แทน (และตัวป้อนบรรทัด)

คำอธิบาย

เป็นเรื่องยากมากที่คุณสามารถเขียนโปรแกรมที่ไม่น่าสนใจบนบรรทัดเดียวใน Prelude (เนื่องจาก Prelude ต้องการมากกว่าหนึ่งบรรทัดในการทำให้ทัวริงสมบูรณ์)

11      Push two 1s. We need something non-zero on the stack to enter the loop, and by
        pushing the same value twice, we make sure that the loop doesn't print anything
        on the first iteration.
(       Main loop...
  -       Subtract the last two values. This will be zero for equal values, and non-zero
          otherwise...
  (       This "loop" is simply used as a conditional: if the last two values were
          were equal, skip the code inside...
    #       Discard the conditional.
    !       Print the value below.
  )       The loop is exited because the value below is always zero.
  ?       Read the first character of the next pair from STDIN.
  ^       Duplicate it, so the lower copy can be printed.
  ?       Read the second character of the pair. This returns 0 at EOF, which
          terminates the loop.
)

Perl, 27 21 ไบต์

say grep$_-chop,/../g

ไบต์เพิ่มสำหรับ-nธง

                /../g  match groups of two chars
    grep       ,       select/filter on...
           chop        remove the last character, mutating the string
        $_-            is it different than the remaining char?
                         (subtract it, empty string is falsy)
say                    output if so

ทดสอบ:

llama@llama:~$ perl -nE 'say grep$_-chop,/../g'
1110
1
11000110
01
1100011
0
00

1



1101001
0
1011101010
1111

ขอบคุณ@TonHospel เป็นเวลา 6 ไบต์!

Befunge 93 , 16 ไบต์

~:~:0`!#@_->#,_$

ซับในหนึ่งเดียวสำหรับความกะทัดรัด ทดสอบโดยใช้ล่ามออนไลน์นี้

~:                     Read input char a and dup
  ~                    Read input char b (-1 on EOF)
   :0`!                Push 1 if b <= 0, 0 otherwise
       #@_             Halt if b <= 0 (i.e. EOF)
          -            Subtract to check whether a != b
           >#,_$       Output a if so

ทำให้ส่วนสุดท้ายใช้ความจริงที่ว่าpopping จากที่ว่างเปล่า Befunge-93 อัตราผลตอบแทนสแต็ค 0

ถ้าa != bเราทำ

>                      Move rightward
#                      Bridge: skip next
_                      Horizontal if - go right if 0, else left. But a != b, so we go left
,                      Output a
#                      Bridge: skip next
-                      Subtract (0 - 0 = 0)
_                      If: go right since 0 is popped
>#                     Go right and skip next
_                      If: go right since 0 is popped
$                      Pop top of stack, stack is now empty

มิฉะนั้นถ้าa == bเราดำเนินการ:

>                      Move rightward
#                      Bridge: skip next
_                      If: go right since a == b (i.e. a-b is 0)
$                      Pop top of stack and discard, keeping stack empty

Pyth, 10 9 ไบต์

jkPM{Mcz2

อัลกอริทึมลงคอขโมยมาจากเดนนิสคำตอบของวุ้น

       z    input
      c 2   chunks of 2
    {M      dedup each chunk
  PM        all-but-last element of each chunk
jk          join on empty string; can't use `s' because that gives `0' for []

Python 2, 48 ไบต์

lambda n:[s for s,t in zip(*[iter(n)]*2)if s!=t]

ลองออนไลน์

ขอบคุณเดนนิสและห้องนิรภัยที่ชี้ให้เห็นสิ่งที่ฉันพลาดไป

Mathematica, 41 39 ไบต์

Select[#~Partition~2,Tr@#==1&][[1]]&

ซับซ้อนน้อยกว่าและสั้นกว่าคำตอบอื่น ๆ กล่องดังกล่าวเป็นอักขระที่เปลี่ยนตำแหน่ง

JavaScript (ES6), 33 ไบต์

s=>s.replace(/(.)\1|(.)?./g,"$2")

พอร์ตที่น่าเบื่อของคำตอบที่จอประสาทตา

sed, 34 33 ไบต์

s/../& /g;s/00\|11//g;s/.\b\| //g

ทดสอบ:

llama@llama:~$ sed 's/../& /g;s/00\|11//g;s/.\b\| //g'             
1110
1
11000110
01
1100011
0
00

1



1101001
0
1011101010
1111

เขาวงกต 31 ไบต์

ไม่สั้นและเรียบร้อยเหมือนโซลูชันของ Sp3000 แต่ฉันคิดว่าฉันโพสต์สิ่งนี้ด้วยวิธีการอื่น:

"" @
,, :{"
)  { $;
*"})";.
 ""

คำอธิบาย

วงแรกนั้นเรียบง่าย

""
,,

ซึ่งอ่านด้วยอักขระสองตัวพร้อมกัน ( "ไม่มีคำสั่ง) หลังจาก EOF ,จะกลับมา-1แต่ตรวจสอบ EOF ทุกตัวละครที่สองเท่านั้น ซึ่งหมายความว่าในกรณีใด ๆ ด้านบนของสแต็คจะเป็น-1และค่าด้านล่างเป็นอย่างใดอย่างหนึ่ง-1หรือรหัสตัวอักษรบางอย่างที่เราไม่สนใจเพราะมันเป็นเหรียญโยน unpaired

จากนั้น)*เปลี่ยนค่า-1และค่าด้านล่างเป็นค่าเดียว0ซึ่งเราต้องการ a) เพื่อกำจัดค่าทั้งสองและ b) เพื่อป้อนลูปถัดไปอย่างถูกต้อง นั่นคือวงถัดไป

"}
""

ซึ่งเลื่อนค่าทั้งหมดไปที่สแต็กเสริม สิ่งนี้จำเป็นเพราะเราต้องการเริ่มการประมวลผลคู่ที่เราอ่านก่อน ตอนนี้ลูปสุดท้าย:

:{"
{ $;
)";.

)เพียงเพิ่มขึ้นบางค่าหุ่นเพื่อให้มั่นใจว่ามันเป็นบวกและทางทิศเหนือคำแนะนำและตัวชี้เปลี่ยน {ดึงตัวเลขหลักแรกของคู่ถัดไปและ:ทำซ้ำ ตอนนี้เมื่อเราประมวลผลเสร็จแล้วนี่จะเป็น0จากด้านล่างของกองซ้อนเสริม มิฉะนั้นจะเป็นอย่างใดอย่างหนึ่งหรือ48 49ในกรณีที่มีศูนย์เราออกจากลูปและยุติ@มิฉะนั้น IP จะหันไปทางทิศตะวันออก

{ดึงมากกว่าตัวเลขอื่น ๆ ของคู่ปัจจุบัน $ใช้ XOR ระหว่างพวกเขา หากนั่นคือ 0 นั่นคือทั้งสองมีค่าเท่ากัน IP จะดำเนินต่อไปทางทิศใต้;ยกเลิกศูนย์และ IP เปลี่ยนเป็นทิศตะวันตกในการทำซ้ำครั้งถัดไป ถ้าแฮคเกอร์ก็1คือพวกเขามีความแตกต่างกัน IP หันทิศตะวันตกเหลือใช้1ด้วยและพิมพ์หลักแรกด้วย;.

MATL , 11 9 8 ไบต์

`-?6MD]T

อินพุตและเอาต์พุตเป็นตัวเลขที่คั่นด้วยบรรทัดใหม่ จบลงด้วยข้อผิดพลาด (อนุญาตโดยค่าเริ่มต้น) เมื่ออินพุตทั้งหมดได้รับการบริโภค

ลองออนไลน์!

`         % do...while loop
  -       %   take two inputs implicitly. Compute difference
  ?       %   if nonzero
    6M    %     push first of the two most recent inputs again
    D     %     display (and remove from stack)
  ]       %   end if
  T       %   true. Used as loop condition, so the loop is infinite
          % end loop implicitly

วิธีเก่า 11 ไบต์

2YCd9L)Xz0<

อินพุตเป็นสตริง ผลลัพธ์คือตัวเลขคั่นด้วยการขึ้นบรรทัดใหม่

ลองออนไลน์!

2YC      % implicitly take input as a string. Generate 2D array of length-2
         % overlapping blocks as columns, padding with a zero if needed.
d        % difference of the two values in each column of that array
9L       % predefined literal [1 2 0]. This corresponds to "1:2:end" indexing
)        % keep only values at indices 1, 3, 5, ... This reduces the set of blocks
         % to non-overlapping, and discards the last (padded) block if the input had
         % odd length
Xz       % keep only nonzero entries, corresponding to blocks that had different values
0<       % 1 if negative, 0 if possitive. Implicitly display

ทับทิมขนาด 46 ไบต์

แยกนี้l[0], l[1]และl[2..{end}]เป็นa, และb cจากนั้นมันจะสร้างสตริงด้วยaif a!=bหรือ''อย่างอื่นและf[c]ถ้าc[0]มีอยู่หรือเป็น''อย่างอื่น

f=->l{a,b,*c=l;"#{a!=b ?a:''}#{c[0]?f[c]:''}"}

Ungolfed:

def f(l)
  a = l[0]
  b = l[1]
  c = l[2..l.length]
  s = ''
  if a!=b
    s += a.to_s
  end
  if c[0]       # equivalent to !c.empty?
    s += f[c]   # no .to_s because the output will be a string
  end
  puts s
end

brainfuck, 33 ไบต์

,>,[<[->->+<<]>[[-]>.<]>[-]<<,>,]

เมื่อเทียบกับ Java แล้วมันมีขนาดเล็กมาก แต่ฉันกลัวผู้ตอบคำถามที่สมอง - นักกอล์ฟ และอย่าลังเลที่จะพูดถึงว่ามีข้อบกพร่อง สมมติว่า EOF เป็น 0 อินพุตไม่ได้มีการป้อนข้อมูลที่ไม่ถูกต้องเซลล์เริ่มต้นที่ศูนย์และช่วงค่าของเซลล์นั้นมี จำกัด และเป็นวงจร ไม่มีข้อสันนิษฐานอื่น ๆ

คำอธิบาย:

แผนที่เซลล์หน่วยความจำ

+---------+---------+-----------------+
|1st input|2nd input|copy of 1st input|
+---------+---------+-----------------+

คำแนะนำ

,>,                               read two instruction at once | first to first cell |
                                  second to second cell
   [                              Until the input is EOF
    <                             look at first cell
     [->->+<<]                    move the first cell to additional cells while
                                  subtracting the second cell with this at same
                                  time
              >[                  if the second cell is nonzero (it means that first cell and
                                  the second cell is the same)
                [-]>.<            Print the copied first input
                      ]
                       >[-]       clear the first input to prevent it polluting next input
                           <<,>,  continue with next two input
                                ]

Mathematica, 41 ไบต์

Cases[#~Partition~2,a_/;Tr@a==1:>a[[1]]]&

ฟังก์ชั่นไม่ระบุชื่อที่อินพุตและเอาต์พุตรายการของศูนย์และรายการ

Pyth, 10 ไบต์

hMf!qFTcz2

ชุดทดสอบ

C, 66 ไบต์

main(char*p,char**x){for(p=x[1];*p&p[1];p+=2)write(1,p,*p^p[1]);}

ทะลึ่ง sizeof(int) == sizeof(char *)

วิธีการแก้ปัญหา "ฉลาด" - 84 81 ไบต์

main(int c,short**x){while(!((c=*x[1]++-12336)&~511))c>>8^c&1&&putchar(48|c&1);}

ทำงานบนเครื่องเล็ก ๆ น้อย ๆ โดยสมมติว่าshortมี 2 ​​ไบต์ อินพุตถูกส่งเป็นอาร์กิวเมนต์ โปรแกรมวนซ้ำตัวอักษรคู่และพิมพ์ 0 สำหรับ 0x3130 และ 1 สำหรับ 0x3031 สำหรับ big-endian ผลลัพธ์จะถูกกลับรายการ (แทนที่48|c&1ด้วย49^c&1เพื่อแก้ไขปัญหานี้)

C, 57 ไบต์

f(char*p,char*r){for(;*p*p[1];)*r=*p++,r+=*r!=*p++;*r=0;}

เราคัดลอกอักขระจากอินพุตpไปยังผลลัพธ์อย่างไม่แน่นอนrแต่จะเลื่อนrตัวชี้ไปเท่านั้นหากอักขระนั้นแตกต่างจากอักขระถัดไป ถ้าไม่เช่นนั้นเราจะเขียนทับมันในคู่ถัดไปที่ไม่ตรงกันหรือด้วยNULท้าย

โปรแกรมทดสอบ:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char **argv) {
    while (*++argv) {
        char *result = malloc(1+strlen(*argv));
        f(*argv, result);
        printf("%s => %s\n", *argv, result);
        free(result);
    }
    return EXIT_SUCCESS;
}

ผลการทดสอบ:

$ ./74864 1110 11000110 1100011 00 1 "" 1101001 1011101010
1110 => 1
11000110 => 01
1100011 => 0
00 => 
1 => 
 => 
1101001 => 0
1011101010 => 1111

Befunge-93 , 40 bytes

v  ,-1<
      | -<
>~1+:~1+:|
^     <  @

คุณสามารถทดลองใช้งานได้ที่นี่ วางรหัสในช่องว่างใต้ปุ่ม "แสดง" กด "แสดง" กำหนดอินพุตกด "เรียกใช้" เราใช้ปุ่ม "ขั้นตอน" เพื่อดูว่าโปรแกรมทำงานอย่างไร

ชุด DOS / Windows, 201 162 ไบต์

@echo off
set/pi=
:a
for /f "tokens=2" %%a in ("%i%") do goto l
exit/b
:l
for /f "tokens=1,2" %%a in ("%i:~0,4%") do if %%a neq %%b echo %%a
set "i=%i:~4%"
goto a

1 0 0 1 1การป้อนข้อมูลเป็นสตริงพื้นที่แยกตัวอย่างเช่น เริ่มต้นจาก cmd มิฉะนั้นหน้าจอจะออกจากทันที

ขี้ผึ้ง ,45 35 ไบต์

ฉันสามารถตีมันลงได้ 10 ไบต์ - ไม่เลวร้ายเกินไป

pgy~1z;L?gAF1<<?V_
>&?@yg&?~@ KQd{b

ฉันอ่านวิธีการโยนเหรียญเต็มรูปแบบซึ่งทำให้โปรแกรมมีขนาดใหญ่มาก เพียงแค่อ่านจำนวนเต็มทีละตัวจะทำให้โปรแกรมเล็กลง - อาจประมาณ 22 ไบต์หรือมากกว่านั้น - แต่ก็ไม่สะดวกที่จะใช้

ตัวอย่าง:

julia> beeswax("FairCoin.bswx")
s1110
1
Program finished!

julia> beeswax("FairCoin.bswx")
s11000110
01
Program finished!

julia> beeswax("FairCoin.bswx")
s1100011
0
Program finished!

julia> beeswax("FairCoin.bswx")
s00

Program finished!

julia> beeswax("FairCoin.bswx")
s10101001010111111100000010011001110100010110101110100001011
1110001010000111100
Program finished!

ที่เก็บขี้ผึ้ง GitHub ของฉัน

ตัวอย่างขี้ผึ้งของฉันในรหัส Rosetta