Завдання

Враховуючи не порожній масив 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 - код асції "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\

Спробуйте в Інтернеті!

Пояснення

/.../
@...\

Це простий шаблон для лінійних програм, які повністю працюють в звичайному режимі. Початковий /відображає 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 байтів (і мені доведеться поголити два байти, щоб скоротити програму).

Пролог (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>

Луа, 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 байти збережено завдяки Мартіну Ендеру

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 (список вводу / виводу), 36 байт

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

Спробуйте в Інтернеті!

Рекурсивно приймає перший елемент, а потім видаляє решту, якщо перший був нульовим.

38 байт:

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

Спробуйте в режимі он-лайн. Це займає список Python і виводить список Python, здійснюючи заміну на його рядковому поданні. Рядок вводу / виводу дозволить більш пряме і коротше рішення, як-от

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

для '1001' формату.

APL (Dyalog), 9 bytes

'00'⎕R'0'

Try it online!

Perl 5, 7+1(-p flag)=8 bytes

<>if/0/

Takes input as newline separated numbers. Skips the next line if it sees a zero.

V, 4 bytes

òf0x

Try it online!

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

MATL, 5 bytes

FFOZt

Try it online!

Explanation

This is similar to Stewie Griffin's Octave answer:

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

8 bytes

vy~f2L)(

This avoids the string/array replacement builtin.

Try it online!

Explanation

Consider input [1,0,0,1,0,0,1] as an example:

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 bytes

ḅ{cẹ|ḍh}ᵐc

Try it online!

Not sure this is optimal yet…

Explanation

This exploits the bug that c on a list of integers that has leading zeroes will fail.

ḅ               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 bytes

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

Try it online!

It's neither clean nor short, but it works.

Takes input as a contiguous string of characters, outputs in the same format

Explanation:

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

Note

Yes I am aware this could simply be done using s.Replace("00","0"), my aim was to avoid using the obvious solution. After all, the whole point of PPCG is to have fun, right? ;)

Pyth, 8 bytes

:z"00"\0

Try-it link.

Explanation:

: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 bytes

First try doing anything with Awk so it might be possible to golf it more.

{gsub(00,0);print}

Usage: echo "1001001" | awk '{gsub(00,0);print}'

Batch, 24 bytes

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

Takes input on STDIN. Somewhat competitive for once.

Common Lisp, SBCL, 48 32 bytes

-16 bytes thanks to Julian Wolf

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

input:

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

output:

1001110

Explanation

We read input list. List is used in format function. We loop through it outputting 1 if element is 1 and outputting 0 and skipping next element of list for 0.

Mathematica, 24 bytes

StringReplace["00"->"0"]

A function that expects a string of "0"s and "1"s and returns a similar string. Self-explanatory syntax. Mathematica has lots of transformation builtins; the key is to use one that transforms every relevant subexpression (unlike /.) but only passes through the expression once (unlike //.).

Jelly, 10 bytes

Œg¹m2$S?€F

Try it online!

Explanation

Œ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.