Разделить пополам

19

задача

Учитывая непустой массив 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]

счет

Это код-гольф . Кратчайший ответ в байтах побеждает.

Применяются стандартные лазейки .

code-golf  array-manipulation 
— Дрянная Монахиня
источник
В последнем тесте разве нули не имеют четной длины?
— OldBunny2800
@ OldBunny2800 Внимательно прочитайте контрольный пример; 0-серии имеют длины 4, 2, 2, 2, 2 и 2.
— HyperNeutrino
Можем ли мы взять trueи falseвместо 1и 0?
— Cyoce
@ Какой язык?
— Утренняя монахиня
@LeakyNun Ruby, который считает 0правдивым.
— Cyoce

Ответы:

11

05AB1E , 5 байтов

00¤.:

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

объяснение

00     # push 00
  ¤    # tail, pushes 0
   .:  # replace
— Emigna
источник
2
Это было легко; почему я не подумал об этом?
— Утренняя монахиня
00странное поведение ...
— Эрик Outgolfer
@EriktheOutgolfer: последовательные цифры объединяются, чтобы сформировать число, так 11что одиннадцать и нет 1,1. Побочным эффектом является то, что 00становится 00вместо 0,0:)
— Emigna
@ Emigna Я бы ожидал, что он станет 0или 0 0вместо этого, но что угодно.
— Эрик Outgolfer
7

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]. Перебирает список и заменяет два последовательных нуля на один ноль.

— Laikoni
источник
Я чувствую, что это может быть разветвлено Прологу
— Leaky Nun
7

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

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

— Alkano
источник
1
Будет s+=2-*s%2работать?
— Нил
1
Если я посчитал правильно, я думаю, что for(;*s;s+=2-*s%2)putchar(*s);сохраняет еще один байт.
— Нейл
1
Что было бы не так с s+=50-*s? Не делал C целую вечность и не хочу смущать себя, вызывая неопределенное поведение (исходящее из C # там, где его нет)
— VisualMelon
1
Глядя на putcharдокументы, вы можете сделать f(char*s){for(;*s;s+=50-putchar(*s));}?
— VisualMelon
3
Вы можете сэкономить 5 байтов, сделав его рекурсивнымf(char*s){*s&&f(s+50-putchar(*s));}
— Khaled.K
6

Java, 50 байт

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

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

— Khaled.K
источник
1
Очень хороший выбор входа! Кстати, если вы заинтересованы в переходе на Java 8+ решения можно использовать лямбда: s->s.replaceAll("00","0").
— Якоб
Еще лучше, используйте replaceвместо того, replaceAllчтобы сохранить 3 байта
— Бенджамин Уркхарт
@BenjaminUrquhart replaceзаменит только первое вхождение
— Khaled.K
@ Khaled.K в JavaScript, да. В Java это заменяет все вхождения
— Бенджамин Уркхарт
5

Haskell , 28 байт

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

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

Рекурсивно берет первый элемент, отбрасывая второй, если первый равен нулю, пока список пуст. Если первая запись h, то первая 1-hудаляется из остальных.

— XNOR
источник
5

Japt , 7 6 5 байт

d'0²0

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

Просто заменяет каждую серию из двух нулей на входе одним нулем. Использует ввод строки (то есть "1001001").

— Люк
источник
1
Ницца! Вам даже не нужно, 'я думаю
— ETHproductions
Ох, вы можете сохранить еще один байт, заменив его "00"на '0²:-)
— ETHproductions
Ну, это странно. Спасибо хоть!
— Лука
4

Алиса , 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 байт (и мне пришлось бы сбрить два байта, чтобы иметь возможность сократить программу).

— Мартин Эндер
источник
2
Похоже, вы недавно влюбились в Алису ...
— Дрянная Монахиня
6
@LeakyNun Пожалуйста, не говорите моей жене ...
— Мартин Эндер
@MartinEnder Я скажу это миссис Эндер!
— Эрик Outgolfer
3

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>
Развернуть фрагмент

— мохнатый
источник
3

Луа, 33 байта

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

Принимает строку через вход и конденсирует двойные нули. Легко.

— болтун
источник
3

Желе , 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
— fireflame241
источник
3

Алиса , 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
— Лео
источник
На самом деле вы можете сохранить еще два байта с помощьюi.h%...
— Martin Ender
@MartinEnder вы злой человек, ходите учить людей играть грязно ...: D
— Лев
2

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' формата.

— XNOR
источник
Первый ответ с указанным форматом, приятно.
— Утренняя монахиня
1
Строка ввод / вывод будет разрешен. lambda s:s.replace('00','0')все должно быть в порядке.
— Джонатан Аллан
2

Perl 5, 7 + 1 (флаг -p) = 8 байт

<>if/0/

Принимает ввод в виде разделенных новой строкой чисел Пропускает следующую строку, если видит ноль.

— Крис
источник
2

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]
— Луис Мендо
источник
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
— Fatalize
источник
Как это ошибка?
— Утренняя монахиня
@LeakyNun Мы должны быть в состоянии объединить [0,0,4,2]в 42. Ведущие нули делают его ошибочным прямо сейчас, потому что он здесь, чтобы предотвратить бесконечные ведущие нули, когда вход является переменной, но здесь вход полностью заземлен, так что ограничения не должно существовать.
— Роковая
Вы бы написали ответ Пролога?
— Утренняя монахиня
1

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 в том, чтобы повеселиться, верно? ;)

— Skidsdev
источник
@ Mr.Xcoder Это не правда. Это примерно как игра в гольф, которую вы можете получить без использования встроенного языка. Replace Я использую C #, так что я не заблуждаюсь о получении кратчайшего кода, особенно с такими языками, как Jelly, так что, возможно, стоит немного повеселиться в процессе.
— Скидсдев
конечно, веселье тоже важно. Я прошу прощения за комментарий выше, и я должен признать, что мне понравился ваш ответ сам (техника, которую вы использовали).
— г-н Xcoder
@ Mr.Xcoder - никаких неприятных ощущений, в конечном итоге мы все здесь, чтобы повеселиться и развить нашу бесполезную в противном случае способность сжимать код как можно больше;)
— Skidsdev
Вы можете сделать намного меньше, чем это без замены! string a(string s){var r="";for(int i=0;i<s.Length;i+=50-s[i])r+=s[i];return r;} (похоже, что это в основном ответ C)
— VisualMelon
1

Awk - 18 байт

Сначала попробуйте сделать что-нибудь с Awk, чтобы можно было больше играть в гольф.

{gsub(00,0);print}

Использование: echo "1001001" | awk '{gsub(00,0);print}'

— PsHegger
источник
1

Пакетный, 24 байта

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

Принимает участие в STDIN. Несколько конкурентоспособен на этот раз.

— Нил
источник
1

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.

Использование, ~[а не ~:[позволяет вам индексировать 0 и 1 напрямую, что должно сэкономить вам кучу байтов
— Julian Wolf
@JulianWolf Спасибо!
1

Mathematica, 24 байта

StringReplace["00"->"0"]

Функция, которая ожидает строку "0"s и "1"s и возвращает похожую строку. Самоочевидный синтаксис. Mathematica имеет много встроенных трансформаций; ключ должен использовать тот, который преобразует каждое соответствующее подвыражение (в отличие от /.), но проходит через выражение только один раз (в отличие от //.).

— Грег Мартин
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.