任务

给定一个非空数组0和1，将的游程长度减半0。

输入项

的阵列0和1。可接受的格式：

• 使用您的语言的真实数组
• 换行分隔的字符串0和1
• 连续的字符串0和1
• 任何其他合理的格式

例如，以下三个输入均可接受：

• [1, 0, 0, 1]
• "1\n0\n0\n1"（哪里\n有换行U + 000A）
• "1001"

您可以假设的游程长度0是偶数。

输出量

的阵列0和1，在上述可接受的格式。

测试用例

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字节

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

只需将全部替换00为0。

爱丽丝，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'0or e000t，但是我还没有找到能在其中跳出5个字节的东西（而且我必须削掉两个字节才能缩短程序）。

Prolog（SWI），42字节

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

在线尝试！

Java，131123字节

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字节

Martin Ender节省了2个字节

i.h%.7%$io

在线尝试！

说明

这是在基本模式下运行的一维代码，因此很容易遵循其流程：

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列表。字符串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的Octave答案：

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上输入。有点竞争一次。

通用Lisp，SBCL，48 32字节

-16个字节，感谢朱利安·沃尔夫（Julian Wolf）

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

输入：

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

输出：

1001110

说明

阅读输入清单。列表用于format功能。我们循环遍历输出，1如果元素为1，则输出0并跳过list的下一个元素0。

Mathematica，24个字节

StringReplace["00"->"0"]

该函数需要"0"s和"1"s 的字符串并返回相似的字符串。不言自明的语法。Mathematica具有许多转换内置函数；关键是要使用一个可以转换每个相关子表达式的（不同于/.），但是只能通过一次表达式（不同于//.）。

果冻，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.