งาน

ได้รับไม่ว่างเปล่าอาร์เรย์ของ0และ1, 0ลดลงครึ่งหนึ่งความยาวของการทำงานของ

อินพุต

อาร์เรย์ของและ0 1รูปแบบที่ยอมรับได้:

• อาร์เรย์จริงในภาษาของคุณ
• สตริงที่คั่นด้วย Linefeed ของ0และ1
• สตริงที่ต่อเนื่องกันของ0และ1
• รูปแบบที่เหมาะสมอื่น ๆ

ตัวอย่างเช่นสามอินพุตต่อไปนี้เป็นที่ยอมรับทั้งหมด:

• [1, 0, 0, 1]
• "1\n0\n0\n1"(ที่ไหน\nคือ linefeed U + 000A)
• "1001"

คุณอาจจะคิดว่าการทำงานของ0จะมีความยาวแม้กระทั่ง

เอาท์พุต

อาเรย์ของ0และ1ในรูปแบบที่ยอมรับได้ด้านบน

Testcases

input ↦ output
[1,0,0,1,0,0,1] ↦ [1,0,1,0,1]
[1,1,0,0,1,1,0,0,1] ↦ [1,1,0,1,1,0,1]
[1,1,0,0,1,1,1,0,0,1,1] ↦ [1,1,0,1,1,1,0,1,1]
[1,1,1] ↦ [1,1,1]
[0,0,1] ↦ [0,1]
[0,0] ↦ [0]
[1,1,1,0,0,0,0,1,1,1,1,0,0,1,0,0,1,1,0,0,1,1,1,1,0,0,1,0,0] ↦ [1,1,1,0,0,1,1,1,1,0,1,0,1,1,0,1,1,1,1,0,1,0]

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

นี่คือรหัสกอล์ฟ คำตอบที่สั้นที่สุดในการชนะไบต์

ช่องโหว่มาตรฐานใช้

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

00
0

ลองออนไลน์!

05AB1E , 5 ไบต์

00¤.:

ลองออนไลน์!

คำอธิบาย

00     # push 00
  ¤    # tail, pushes 0
   .:  # replace

Haskell , 33 ไบต์

f(0:0:r)=0:f r
f(x:r)=x:f r
f e=e

ลองออนไลน์! การใช้งาน: f[1,1,0,0,1,1,0,0,1]. ทำซ้ำในรายการและแทนที่สองศูนย์ติดต่อกันโดยหนึ่งศูนย์

C (gcc) , 35 ไบต์

f(char*s){while(*s)putchar(*s),*s++-48?:s++;}

48 คือรหัส ASCII ของ '0'

รุ่นที่ดีกว่า 43 ไบต์ตามที่ Neil แนะนำ

f(char*s){while(*s)putchar(*s),s+=2-*s%2;}

อีก 40 ไบต์ในครั้งนี้ (อีกครั้งตามที่ Neil & VisualMelon แนะนำ) :)

f(char*s){for(;*s;s+=50-*s)putchar(*s);}

แล้ว 35 ไบต์ขอขอบคุณ Khaled.K

f(char*s){*s&&f(s+50-putchar(*s));}

ลองออนไลน์!

sed , 8 ไบต์

s/00/0/g

ลองออนไลน์!

อ็อกเทฟ 22 ไบต์

@(s)strrep(s,'00','0')

ตรวจสอบกรณีทดสอบทั้งหมดที่นี่

นี่เป็นฟังก์ชั่นที่ไม่ระบุชื่อซึ่งรับสตริงบนรูปแบบ'1001000011'เป็นอินพุตและแทนที่ศูนย์สองศูนย์ติดต่อกันด้วยศูนย์เดียว

Java, 50 ไบต์

String f(String s){return s.replaceAll("00","0");}

ลองออนไลน์

Haskell , 28 ไบต์

f(h:t)=h:f(drop(1-h)t)
f e=e

ลองออนไลน์!

ใช้องค์ประกอบแรกซ้ำโดยปล่อยองค์ประกอบที่สองถ้าองค์ประกอบแรกเป็นศูนย์จนกระทั่งรายการว่างเปล่า หากรายการแรกคือรายการhแรก1-hจะถูกดร็อปจากส่วนที่เหลือ

Japt , 7 6 5 ไบต์

d'0²0

ลองออนไลน์!

เพียงแทนที่แต่ละศูนย์ของสองศูนย์ในอินพุตโดยหนึ่งศูนย์ ใช้อินพุตสตริง (เช่น"1001001" )

PHP, 26

<?=strtr($argn,["00"=>0]);

เพียงแทนที่ทั้งหมดโดย000

อลิซ 13 ไบต์

/oe00/
@iS0e\

ลองออนไลน์!

คำอธิบาย

/.../
@...\

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

ie00e0So@

นี่เป็นการทดแทนสตริงแบบง่าย:

i   Read all input.
e   Push an empty string.
00  Append two zeros to create the string "00".
e   Push an empty string.
0   Append a zero to create the string "0".
S   Substitute all occurrences of "00" in the input with "0".
o   Output the result.   
@   Terminate the program.

มีวิธีอื่นสองสามวิธีในการกดทั้งสองสตริงเช่น'00'0หรือe000tแต่ฉันไม่พบสิ่งใดที่มีขนาด 5 ไบต์ (และฉันต้องโกนสองไบต์เพื่อให้โปรแกรมสั้นลง)

Prolog (SWI) 42 ไบต์

[0,0|T]*[0|R]:-T*R.
[H|T]*[H|R]:-T*R.
H*H.

ลองออนไลน์!

Java , 131 123 ไบต์

int[]f(int[]a){int c=0,i=0,l=a.length;for(int x:a)c+=1-x;int[]r=new int[l-c/2];for(c=0;c<l;c+=2-a[c])r[i++]=a[c];return r;}

ลองออนไลน์!

JavaScript (ES6), 26 21 ไบต์

รับอินพุตเป็นสตริงและส่งคืนสตริง

s=>s.replace(/00/g,0)

ลองมัน

f=
s=>s.replace(/00/g,0)
i.addEventListener("input",_=>o.innerText=f(i.value))
console.log(f("1001001")) // "10101"
console.log(f("110011001")) // "1101101"
console.log(f("11001110011")) // "110111011"
console.log(f("111")) // "111"
console.log(f("001")) // "01"
console.log(f("00")) // "0"
console.log(f("11100001111001001100111100100")) // "1110011110101101111010"

<input id=i><pre id=o>

Lua 33 ไบต์

print((io.read():gsub("00","0")))

รับสตริงผ่านอินพุตและควบแน่นเป็นศูนย์คู่ ง่าย.

เยลลี่ขนาด 8 ไบต์

ṣ1j1,1m2

ลองออนไลน์!

อาจเป็นคำตอบอื่น ๆ ในภาษาที่ไม่มี.replace()หรือคล้ายกันสามารถใช้เคล็ดลับนี้

คำอธิบาย

ṣ1j1,1m2 - (duplicates the 1s, then halves all lengths)
ṣ1       - split by the element 1
  j1,1   - join the elements with the two-element list 1,1
      m2 - get every second element

อลิซ , 12 10 ไบต์

บันทึก 2 ไบต์ด้วยMartin Ender

i.h%.7%$io

ลองออนไลน์!

คำอธิบาย

นี่คือรหัส 1-D ที่ทำงานในโหมดที่สำคัญดังนั้นจึงง่ายต่อการติดตามการไหล:

i                   Read a byte from input (pushes -1 on EOF)
 .h                 Duplicate it and add 1 to the copy
   %                Compute n%(n+1). This will exit with an error on n==-1
                    and return n for any non-negative n.
    .7%             Duplicate the input again and compute its value modulo 7
                    This returns 6 for '0' (unicode value 48) and 0 for '1'
                    (unicode value 49)
       $i           If this last result was not 0, input another number.
                    This ignores every other '0' in the input
                    and moves to the following number (another '0')
         o          Output the last byte read

                    At the end, wrap back to the beginning of the line

Python (รายการ I / O) ขนาด 36 ไบต์

f=lambda l:l and l[:1]+f(l[2-l[0]:])

ลองออนไลน์!

ใช้องค์ประกอบแรกซ้ำแล้วลบองค์ประกอบที่เหลือถ้าองค์ประกอบแรกเป็นศูนย์

38 ไบต์:

lambda l:eval(`l`.replace('0, 0','0'))

ลองใช้งานออนไลน์การดำเนินการนี้จะใช้รายการ Python และส่งออกรายการ Python โดยทำการแทนที่การแสดงสตริง String I / O จะช่วยให้การแก้ปัญหาโดยตรงและสั้นลงเช่น

lambda s:s.replace('00','0')

สำหรับ'1001' รูปแบบ

APL (Dyalog)ขนาด 9 ไบต์

'00'⎕R'0'

ลองออนไลน์!

Perl 5, 7 + 1 (แฟล็ก -p) = 8 ไบต์

<>if/0/

รับอินพุตเป็นตัวเลขคั่นด้วยบรรทัดใหม่ ข้ามบรรทัดถัดไปหากเห็นศูนย์

V , 4 ไบต์

òf0x

ลองออนไลน์!

ò    ' Recursively (until we error)
 f0  ' Go to the next zero (errors when there are no zeros left)
   x ' Delete it

MATL , 5 ไบต์

FFOZt

ลองออนไลน์!

คำอธิบาย

สิ่งนี้คล้ายกับคำตอบอ็อกเทฟของ Stewie Griffin :

FF     % Push [0 0]
O      % Push 0
Zt     % Implicitly take input. Replace [0 0] by 0. Implicitly display

8 ไบต์

vy~f2L)(

ซึ่งจะเป็นการหลีกเลี่ยงการสร้างสตริง / อาร์เรย์แทน

ลองออนไลน์!

คำอธิบาย

พิจารณาอินพุต[1,0,0,1,0,0,1]เป็นตัวอย่าง:

v      % Concatenate stack (which is empty): pushes []
       % STACK: []
y      % Implicit input. Duplicate from below
       % STACK: [1,0,0,1,0,0,1], [], [1,0,0,1,0,0,1]
~f     % Negate, find: gives indices of zeros
       % STACK: [1,0,0,1,0,0,1], [], [2,3,5,6]
2L     % Push [2,2,1i]. As an index, this is interpreted as 2:2:end
       % STACK: [1,0,0,1,0,0,1], [], [2,3,5,6], [2,2,1i]
)      % Reference indexing. This selects the even-indexed entries
       % STACK: [1,0,0,1,0,0,1], [], [3,6]
(      % Assignment indexing. This deletes the specified entries
       % (assigns them the empty array). Implicitly display
       % STACK: [1,0,1,0,1]

Brachylogขนาด 10 ไบต์

ḅ{cẹ|ḍh}ᵐc

ลองออนไลน์!

ไม่แน่ใจว่านี่เป็นสิ่งที่ดีที่สุด ...

คำอธิบาย

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

ḅ               Blocks; group consecutive equal elements together
 {     }ᵐ       Map on each block:
  c               It is possible to concatenate the block into an int (i.e. it contains 1s)
   ẹ              Split it again into a list of 1s
    |             Else
     ḍh           Dichotomize and take the head
         c      Concatenate the blocks into a single list

C #, 191 ไบต์

string a(string s){var l=(s+'1').ToCharArray();s="";int b=0;for(int i=0;i<l.Length;i++){if(l[i]=='1'){if(b>0){s+=new string('0',b/2);b=0;}s+=l[i];}else b++;}return s.Substring(0,s.Length-1);}

ลองออนไลน์!

ไม่สะอาดหรือสั้น แต่ใช้งานได้

รับอินพุตเป็นสตริงของอักขระที่ต่อเนื่องกันเอาต์พุตในรูปแบบเดียวกัน

คำอธิบาย:

string a(string s){                  //Define method a that takes input string s and returns a string
  var l=(s+'1').ToCharArray();       //Add a 1 to the end of s and split into char array l
  s="";                              //Empty s
  int b=0;                           //Initialize int b with value 0
  for(int i=0;i<l.Length;i++){       //Loop through l
    if(l[i]=='1'){                   //If current char is 1
      if(b>0){                       //If b is not 0
        s+=new string('0',b/2);      //Add half the amount of 0s we've counted to s
        b=0;                         //Reset b
      }                              //End if b is not 0
      s+=l[i];                       //Add current char to s
    }                                //End if current char is 1
    else b++;                        //If current char is not 1, increment b
  }                                  //End loop
  return s.Substring(0,s.Length-1);  //Return string minus last char
}                                    //End method

บันทึก

ใช่ฉันรู้ว่าสิ่งนี้สามารถทำได้โดยใช้s.Replace("00","0")เป้าหมายของฉันคือหลีกเลี่ยงการใช้โซลูชันที่ชัดเจน ท้ายที่สุดแล้วประเด็นทั้งหมดของ PPCG คือการได้สนุกใช่มั้ย ;)

Pyth, 8 ไบต์

:z"00"\0

ลิงก์ลองใช้

คำอธิบาย:

:z"00"\0 Takes unquoted contiguous 1-line input.
 z       Initialized to unevaluated first input line (Q won't be any shorter)
  "00"   Matching regex pattern /00/g
      \0 Substitution string "0"
:        Regex find-and-replace

Awk - 18 ไบต์

ก่อนอื่นให้ลองทำอะไรกับ Awk เพื่อให้สามารถเล่นกอล์ฟได้มากขึ้น

{gsub(00,0);print}

การใช้งาน: echo "1001001" | awk '{gsub(00,0);print}'

แบตช์ 24 ไบต์

@set/ps=
@echo %s:00=0%

ใช้อินพุตบน STDIN ค่อนข้างแข่งขันสักครั้ง

Common LISP, SBCL, 48 32 ไบต์

-16 ไบต์ขอบคุณ Julian Wolf

(format t"~{~[0~*~;1~]~}"(read))

การป้อนข้อมูล:

(1 0 0 0 0 1 1 1 0 0)

เอาท์พุท:

1001110

คำอธิบาย

เราอ่านรายการอินพุต รายการใช้ในformatฟังก์ชั่น วงเราผ่านมัน outputting 1ถ้าองค์ประกอบ1และการแสดงผลและการกระโดดข้ามองค์ประกอบต่อไปของรายการ00

Mathematica ขนาด 24 ไบต์

StringReplace["00"->"0"]

ฟังก์ชันที่ต้องการสตริงของ"0"s และ"1"s และส่งคืนสตริงที่คล้ายกัน ไวยากรณ์ที่อธิบายตนเอง Mathematica มีตัวแปลงมากมาย กุญแจสำคัญคือการใช้อย่างใดอย่างหนึ่งที่แปลงทุก subexpression ที่เกี่ยวข้อง (ไม่เหมือน/.) แต่เพียงผ่านการแสดงออกครั้งเดียว (ไม่เหมือน//.)

เยลลี่ 10 ไบต์

Œg¹m2$S?€F

ลองออนไลน์!

คำอธิบาย

Œg¹m2$S?€F
Œg          - Group runs of equal elements
        €   - To each run...
      S?    - If sum is truthy,
  ¹         -   return the run as it is
   m2$      - Else return every second element of the run.