Aufgabe

Bei einem nicht leeren Array von 0und 1halbieren Sie die Länge der Läufe von 0.

Eingang

Eine Reihe von 0und 1. Akzeptables Format:

• Reales Array in Ihrer Sprache
• Durch Zeilenvorschub getrennte Zeichenfolge von 0und1
• Fortlaufende Zeichenfolge von 0und1
• Jedes andere vernünftige Format

Beispielsweise sind die folgenden drei Eingaben zulässig:

• [1, 0, 0, 1]
• "1\n0\n0\n1"(wo \nist ein Zeilenvorschub U + 000A)
• "1001"

Sie können davon ausgehen , dass die Läufe 0haben sogar Länge .

Ausgabe

Ein Array von 0und 1in den oben angegebenen akzeptablen Formaten.

Testfälle

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]

Wertung

Das ist Code-Golf . Kürzeste Antwort in Bytes gewinnt.

Es gelten Standardlücken .

Retina , 4 Bytes

00
0

Probieren Sie es online!

05AB1E , 5 Bytes

00¤.:

Probieren Sie es online!

Erläuterung

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

Haskell , 33 Bytes

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

Probieren Sie es online! Verbrauch: f[1,1,0,0,1,1,0,0,1]. Durchläuft die Liste und ersetzt zwei aufeinanderfolgende Nullen durch eine Null.

C (gcc) , 35 Bytes

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

48 ist der ASCII-Code von '0'

bessere Version 43 Bytes, wie von Neil vorgeschlagen

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

ein weiteres 40 Byte dieses Mal (wieder wie von Neil & VisualMelon vorgeschlagen) :)

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

und dann 35 Bytes dank Khaled.K

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

Probieren Sie es online!

sed , 8 bytes

s/00/0/g

Probieren Sie es online!

Oktave, 22 Bytes

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

Überprüfen Sie hier alle Testfälle.

Dies ist eine anonyme Funktion, die eine Zeichenfolge für das Format '1001000011'als Eingabe verwendet und zwei aufeinanderfolgende Nullen durch eine einzige Null ersetzt.

Java, 50 Bytes

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

Versuchen Sie es online

Haskell , 28 Bytes

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

Probieren Sie es online!

Nimmt rekursiv das erste Element und löscht das zweite, wenn das erste Null ist, bis die Liste leer ist. Wenn der erste Eintrag ist h, werden die ersten 1-haus dem Rest gelöscht.

Japt , 7 6 5 Bytes

d'0²0

Probieren Sie es online!

Ersetzt einfach jeden Lauf mit zwei Nullen in der Eingabe durch eine Null. Verwendet die Zeichenketteneingabe (dh "1001001").

PHP, 26

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

Ersetzen Sie einfach alle 00durch 0.

Alice , 13 Bytes

/oe00/
@iS0e\

Probieren Sie es online!

Erläuterung

/.../
@...\

Dies ist eine einfache Vorlage für lineare Programme, die vollständig im Ordinalmodus arbeiten. Die Initiale /spiegelt die IP wider, die sich nach Südosten bewegt, und springt dann diagonal durch den Code auf und ab, bis die Spiegel am Ende sind. Diese versetzen die Position einfach um eins, so dass die IP auf dem Rückweg die verbleibenden Zellen durchquert. Das Lesen des Codes in dieser Zick-Zack-Weise wird zu:

ie00e0So@

Dies ist eine einfache Zeichenfolgensubstitution:

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.

Es gibt ein paar andere Möglichkeiten, die beiden Zeichenfolgen zu verschieben, z. B. '00'0oder e000t, aber ich habe dort nichts gefunden, das 5 Byte überschreitet (und ich müsste zwei Byte abschneiden, um das Programm kürzen zu können).

Prolog (SWI) , 42 Bytes

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

Probieren Sie es online!

Java , 131 123 Bytes

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

Probieren Sie es online!

JavaScript (ES6), 26 21 Bytes

Nimmt die Eingabe als Zeichenfolge und gibt eine Zeichenfolge zurück.

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

Versuch es

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 Bytes

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

Nimmt einen String über die Eingabe und verdichtet die Doppel-Nullen. Einfach.

Gelee , 8 Bytes

ṣ1j1,1m2

Probieren Sie es online!

Möglicherweise können andere Antworten in Sprachen ohne .replace()oder mit ähnlichem diesen Trick verwenden.

Erläuterung

ṣ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 Bytes

2 Bytes gespart dank Martin Ender

i.h%.7%$io

Probieren Sie es online!

Erläuterung

Dies ist ein 1-D-Code, der im Kardinalmodus ausgeführt wird, sodass der Ablauf leicht zu verfolgen ist:

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 (Listen-E / A), 36 Byte

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

Probieren Sie es online!

Nimmt rekursiv das erste Element und entfernt dann das verbleibende, wenn das erste Null war.

38 Bytes:

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

Online testen Hiermit wird eine Python-Liste erstellt und eine Python-Liste ausgegeben, indem die Zeichenfolgendarstellung ersetzt wird. String I / O würde eine direktere und kürzere Lösung ermöglichen, wie z

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

für das '1001' Format.

APL (Dyalog) , 9 Bytes

'00'⎕R'0'

Probieren Sie es online!

Perl 5, 7 + 1 (-p Flag) = 8 Bytes

<>if/0/

Nimmt die Eingabe als durch Zeilenumbrüche getrennte Zahlen vor. Überspringt die nächste Zeile, wenn eine Null angezeigt wird.

V , 4 Bytes

òf0x

Probieren Sie es 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

Probieren Sie es online!

Erläuterung

Dies ist vergleichbar mit Stewie Griffin Octave Antwort :

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

8 Bytes

vy~f2L)(

Dies vermeidet das eingebaute Ersetzen von Strings / Arrays.

Probieren Sie es online!

Erläuterung

Betrachten Sie die Eingabe [1,0,0,1,0,0,1]als Beispiel:

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

Probieren Sie es online!

Ich bin mir nicht sicher, ob das noch optimal ist ...

Erläuterung

Dies nutzt den Fehler aus, der cbei einer Liste von Ganzzahlen mit führenden Nullen fehlschlägt.

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

Probieren Sie es online!

Es ist weder sauber noch kurz, aber es funktioniert.

Nimmt Eingaben als zusammenhängende Zeichenfolge an und gibt sie im gleichen Format aus

Erläuterung:

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

Hinweis

Ja, ich bin mir bewusst, dass dies einfach mit getan werden s.Replace("00","0")kann. Mein Ziel war es, die offensichtliche Lösung zu vermeiden. Schließlich geht es bei PPCG darum, Spaß zu haben, oder? ;)

Pyth, 8 Bytes

:z"00"\0

Try-it-Link.

Erläuterung:

: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

Versuchen Sie zuerst, etwas mit Awk zu tun, damit Sie möglicherweise mehr Golf spielen können.

{gsub(00,0);print}

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

Batch, 24 Bytes

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

Übernimmt die Eingabe für STDIN. Einmal etwas konkurrenzfähig.

Common Lisp, SBCL, 48 32 Bytes

-16 Bytes dank Julian Wolf

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

Eingang:

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

Ausgabe:

1001110

Erläuterung

Wir lesen die Eingabeliste. Liste wird in formatFunktion verwendet. Wir durchlaufen die Ausgabe, 1wenn das Element ist, 1und geben das 0nächste Element der Liste für aus und überspringen es 0.

Mathematica, 24 Bytes

StringReplace["00"->"0"]

Eine Funktion, die eine Zeichenfolge von "0"s und "1"s erwartet und eine ähnliche Zeichenfolge zurückgibt. Selbsterklärende Syntax. Mathematica verfügt über viele Transformationsfunktionen. Der Schlüssel ist, einen zu verwenden, der alle relevanten Unterausdrücke transformiert (anders als /.), den Ausdruck jedoch nur einmal durchläuft (anders als //.).

Gelee , 10 Bytes

Œg¹m2$S?€F

Probieren Sie es online!

Erläuterung

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