Compito

Dato un array non vuoto di 0e 1, dimezzare le lunghezze delle corse di 0.

Ingresso

Una matrice di 0e 1. Formato accettabile:

• Matrice reale nella tua lingua
• Stringa di 0e separata da avanzamento riga1
• Stringa contigua di 0e1
• Qualsiasi altro formato ragionevole

Ad esempio, i seguenti tre ingressi sono tutti accettabili:

• [1, 0, 0, 1]
• "1\n0\n0\n1"(dove \nè un avanzamento di riga U + 000A)
• "1001"

Si può presumere che le corse di 0avranno una lunghezza pari .

Produzione

Un array di 0e 1, nei formati accettabili sopra.

Casi test

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]

punteggio

Questo è code-golf . Vince la risposta più breve in byte.

Si applicano scappatoie standard .

Retina , 4 byte

00
0

Provalo online!

05AB1E , 5 byte

00¤.:

Provalo online!

Spiegazione

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

Haskell , 33 byte

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

Provalo online! Uso: f[1,1,0,0,1,1,0,0,1]. Scorre l'elenco e sostituisce due zeri consecutivi con uno zero.

C (gcc) , 35 byte

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

48 è il codice ascii di '0'

migliore versione 43 byte come suggerito da Neil

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

un'altra volta 40 byte questa volta (sempre come suggerito da Neil & VisualMelon) :)

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

e poi 35 byte grazie a Khaled.K

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

Provalo online!

sed , 8 byte

s/00/0/g

Provalo online!

Ottava, 22 byte

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

Verifica qui tutti i casi di test.

Questa è una funzione anonima che accetta una stringa sul formato '1001000011'come input e sostituisce due zeri consecutivi con un singolo zero.

Java, 50 byte

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

Prova online

Haskell , 28 byte

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

Provalo online!

Prende ricorsivamente il primo elemento, rilasciando il secondo se il primo è zero, fino all'elenco di vuoto. Se la prima voce è h, la prima 1-hviene eliminata dal resto.

Japt , 7 6 5 byte

d'0²0

Provalo online!

Sostituisce semplicemente ogni serie di due zero nell'input con uno zero. Utilizza l'input di stringa (ovvero "1001001").

PHP, 26

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

sostituisci semplicemente tutto 00con 0.

Alice , 13 byte

/oe00/
@iS0e\

Provalo online!

Spiegazione

/.../
@...\

Questo è un semplice modello per programmi lineari che funzionano interamente in modalità Ordinale. L'iniziale /riflette l'IP per spostarsi a sud-est e poi rimbalza in diagonale su e giù attraverso il codice fino alla fine dei mirror. Questi semplicemente spostano la posizione di uno in modo tale che al ritorno l'IP attraversi le celle rimanenti. Leggendo il codice in questo modo a zigzag diventa:

ie00e0So@

Questa è una semplice sostituzione di stringa:

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.

Esistono altri modi per spingere le due stringhe, ad esempio '00'0o e000t, ma non ho trovato nulla che superi i 5 byte lì (e dovrei radere due byte per accorciare il programma).

Prolog (SWI) , 42 byte

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

Provalo online!

Java , 131 123 byte

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

Provalo online!

JavaScript (ES6), 26 21 byte

Prende l'input come stringa e restituisce una stringa.

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

Provalo

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 byte

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

Accetta una stringa tramite input e condensa i doppi zeri. Facile.

Gelatina , 8 byte

ṣ1j1,1m2

Provalo online!

Forse altre risposte in lingue senza .replace()o simili potrebbero usare questo trucco.

Spiegazione

ṣ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 anni 10 byte

2 byte salvati grazie a Martin Ender

i.h%.7%$io

Provalo online!

Spiegazione

Questo è un codice 1-D che funziona in modalità cardinale, quindi è facile seguirne il flusso:

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 (elenco I / O), 36 byte

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

Provalo online!

Prende ricorsivamente il primo elemento, quindi rimuove quello rimanente se il primo era zero.

38 byte:

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

Provalo online Questo prende un elenco Python e genera un elenco Python sostituendo la sua rappresentazione di stringa. L'I / O di stringa consentirebbe una soluzione più diretta e più breve, come ad esempio

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

per il '1001' formato.

APL (Dyalog) , 9 byte

'00'⎕R'0'

Provalo online!

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

<>if/0/

Accetta input come numeri separati da nuova riga. Salta la riga successiva se vede uno zero.

V , 4 byte

òf0x

Provalo online!

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

MATL , 5 byte

FFOZt

Provalo online!

Spiegazione

Questo è simile alla risposta Octave di Stewie Griffin :

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

8 byte

vy~f2L)(

Questo evita la sostituzione di stringa / array integrata.

Provalo online!

Spiegazione

Considera l'input [1,0,0,1,0,0,1]come esempio:

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 byte

ḅ{cẹ|ḍh}ᵐc

Provalo online!

Non sono sicuro che sia ottimale ancora ...

Spiegazione

Questo sfrutta il bug che csu un elenco di numeri interi con zero iniziali non riuscirà.

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

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

Provalo online!

Non è né pulito né corto, ma funziona.

Accetta input come una stringa contigua di caratteri, output nello stesso formato

Spiegazione:

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

Nota

Sì, sono consapevole che questo potrebbe essere fatto semplicemente usando s.Replace("00","0"), il mio obiettivo era quello di evitare di usare la soluzione ovvia. Dopotutto, il punto centrale di PPCG è divertirsi, giusto? ;)

Pyth, 8 byte

:z"00"\0

Link di prova.

Spiegazione:

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

Prima prova a fare qualsiasi cosa con Awk, quindi potrebbe essere possibile giocare a golf di più.

{gsub(00,0);print}

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

Lotto, 24 byte

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