задача

Учитывая непустой массив 0и 1, пополам длины серий 0.

вход

Массив 0и 1. Приемлемый формат:

• Реальный массив на вашем языке
• Строка, разделенная строкой 0и1
• Смежные строки 0и1
• Любой другой разумный формат

Например, следующие три входа все приемлемы:

• [1, 0, 0, 1]
• "1\n0\n0\n1"(где \nперевод строки 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 байта, как предложил Нил

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 (Дьялог) , 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

Попробуйте онлайн!

объяснение

Это похоже на октавский ответ Стью Гриффин :

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]

Брахилог , 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 байт благодаря Джулиану Вольфу

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

вход:

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

выход:

1001110

объяснение

Читаем входной список. Список используется в formatфункции. Мы перебираем его, выводя, 1если элемент есть, 1и выводя 0и пропуская следующий элемент списка 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.