Zadanie

Biorąc pod uwagę niepustą tablicę 0i 1, o połowę długości serii 0.

Wejście

Tablica 0i 1. Dopuszczalny format:

• Prawdziwa tablica w twoim języku
• Ciąg znaków oddzielony od linii 0i1
• Ciągły ciąg 0i1
• Każdy inny rozsądny format

Na przykład następujące trzy dane wejściowe są dopuszczalne:

• [1, 0, 0, 1]
• "1\n0\n0\n1"(gdzie \njest wysuw linii U + 000A)
• "1001"

Możesz założyć, że przebiegi 0będą miały równą długość .

Wynik

Tablica 0i 1, w akceptowalnych formatach powyżej.

Przypadki testowe

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]

Punktacja

To jest golf golfowy . Najkrótsza odpowiedź w bajtach wygrywa.

Obowiązują standardowe luki .

Siatkówka , 4 bajty

00
0

Wypróbuj online!

05AB1E , 5 bajtów

00¤.:

Wypróbuj online!

Wyjaśnienie

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

Haskell , 33 bajty

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

Wypróbuj online! Zastosowanie: f[1,1,0,0,1,1,0,0,1]. Iteruje po liście i zastępuje dwa kolejne zera jednym zerem.

C (gcc) , 35 bajtów

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

48 to kod ascii „0”

lepsza wersja 43 bajtów, zgodnie z sugestią Neila

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

tym razem jeszcze 40 bajtów (znowu jak sugeruje Neil i VisualMelon) :)

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

a następnie 35 bajtów dzięki Khaled.K

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

Wypróbuj online!

sed , 8 bajtów

s/00/0/g

Wypróbuj online!

Oktawa, 22 bajty

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

Sprawdź tutaj wszystkie przypadki testowe.

Jest to anonimowa funkcja, która przyjmuje ciąg znaków w formacie '1001000011'jako dane wejściowe i zastępuje dwa kolejne zera pojedynczym zerem.

Java, 50 bajtów

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

Wypróbuj online

Haskell , 28 bajtów

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

Wypróbuj online!

Rekurencyjnie bierze pierwszy element, upuszczając drugi, jeśli pierwszy wynosi zero, aż do listy pustych. Jeśli pierwszym wpisem jest h, to pierwsze 1-hsą usuwane z reszty.

Japt , 7 6 5 bajtów

d'0²0

Wypróbuj online!

Po prostu zastępuje każdy przebieg dwóch zer na wejściu jednym zerem. Wykorzystuje ciąg znaków (tj "1001001".).

PHP, 26

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

po prostu zamień wszystko 00na 0.

Alice , 13 bajtów

/oe00/
@iS0e\

Wypróbuj online!

Wyjaśnienie

/.../
@...\

Jest to prosty szablon dla programów liniowych, które działają całkowicie w trybie porządkowym. Inicjał /odzwierciedla adres IP ruchu na południowy wschód, a następnie odbija się po przekątnej w górę i w dół przez kod, aż na końcu lustra. Po prostu kompensują pozycję o jeden, tak że w drodze powrotnej IP przemierza pozostałe komórki. Czytanie kodu w ten zygzakowaty sposób staje się:

ie00e0So@

To jest proste podstawienie łańcucha:

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.

Istnieje kilka innych sposobów na przesuwanie tych dwóch łańcuchów, np. '00'0Lub e000t, ale nie znalazłem niczego, co przekroczyłoby 5 bajtów (musiałbym zgolić dwa bajty, aby móc skrócić program).

Prolog (SWI) , 42 bajty

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

Wypróbuj online!

Java , 131 123 bajtów

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

Wypróbuj online!

JavaScript (ES6), 26 21 bajtów

Pobiera dane wejściowe jako ciąg znaków i zwraca ciąg znaków.

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

Spróbuj

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 bajty

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

Pobiera ciąg znaków przez wejście i kondensuje podwójne zera. Łatwo.

Galaretka , 8 bajtów

ṣ1j1,1m2

Wypróbuj online!

Możliwe, że inne odpowiedzi w językach bez .replace()lub podobnych mogłyby skorzystać z tej sztuczki.

Wyjaśnienie

ṣ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

Alice , 12 10 bajtów

2 bajty zapisane dzięki Martinowi Enderowi

i.h%.7%$io

Wypróbuj online!

Wyjaśnienie

Jest to kod 1-D działający w trybie kardynalnym, więc łatwo jest śledzić jego przebieg:

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 (lista I / O), 36 bajtów

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

Wypróbuj online!

Rekurencyjnie bierze pierwszy element, a następnie usuwa pozostały, jeśli pierwszy miał zero.

38 bajtów:

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

Wypróbuj online To zajmuje listę Pythona i generuje listę Python, wykonując zamianę jej reprezentacji ciągu. Ciąg I / O pozwoliłby na bardziej bezpośrednie i krótsze rozwiązanie, takie jak

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

dla '1001' formatu.

APL (Dyalog) , 9 bajtów

'00'⎕R'0'

Wypróbuj online!

Perl 5, 7 + 1 (flaga -p) = 8 bajtów

<>if/0/

Pobiera dane wejściowe jako liczby oddzielone znakiem nowej linii. Pomija następny wiersz, jeśli widzi zero.

V , 4 bajty

òf0x

Wypróbuj online!

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

MATL , 5 bajtów

FFOZt

Wypróbuj online!

Wyjaśnienie

Jest to podobne do odpowiedzi Octave Stewiego Griffina :

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

8 bajtów

vy~f2L)(

Pozwala to uniknąć wbudowanego zastępowania łańcucha / tablicy.

Wypróbuj online!

Wyjaśnienie

Rozważ dane wejściowe [1,0,0,1,0,0,1]jako przykład:

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 bajtów

ḅ{cẹ|ḍh}ᵐc

Wypróbuj online!

Nie jestem pewien, czy jest to optymalne…

Wyjaśnienie

Wykorzystuje to błąd, który czawodzi na liście liczb całkowitych z zerami wiodącymi.

ḅ               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 bajtów

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

Wypróbuj online!

Nie jest ani czysty, ani krótki, ale działa.

Pobiera dane wejściowe jako ciąg ciąg znaków, dane wyjściowe w tym samym formacie

Wyjaśnienie:

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

Uwaga

Tak, wiem, że można tego po prostu zrobić s.Replace("00","0"), moim celem było uniknięcie zastosowania oczywistego rozwiązania. W końcu sednem PPCG jest dobra zabawa, prawda? ;)

Pyth, 8 bajtów

:z"00"\0

Link do wypróbowania.

Wyjaśnienie:

: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 bajtów

Najpierw spróbuj zrobić cokolwiek z Awk, aby móc bardziej zagrać w golfa.

{gsub(00,0);print}

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

Partia, 24 bajty

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

Pobiera dane wejściowe na STDIN. Raz nieco konkurencyjny.

Common Lisp, SBCL, 48 32 bajtów

-16 bajtów dzięki Julianowi Wolfowi

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

Wejście:

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

wynik:

1001110

Wyjaśnienie

Czytamy listę wejść. Lista jest używana w formatfunkcji. Przechodzimy przez niego, wypisując, 1czy element jest, 1i wypisując 0i pomijając następny element listy dla 0.

Mathematica, 24 bajty

StringReplace["00"->"0"]

Funkcja, która oczekuje ciągu "0"s i "1"s i zwraca podobny ciąg. Wyjaśnienie składni. Mathematica ma wiele wbudowanych transformacji; kluczem jest użycie takiego, który przekształca każde istotne podwyrażenie (w przeciwieństwie do /.), ale przechodzi przez wyrażenie tylko raz (w przeciwieństwie do //.).

Galaretka , 10 bajtów

Œg¹m2$S?€F

Wypróbuj online!

Wyjaśnienie

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