Tarea

Dado un conjunto no vacío de 0y 1, reducir a la mitad las longitudes de las ejecuciones de 0.

Entrada

Una serie de 0y 1. Formato aceptable:

• Matriz real en tu idioma
• Cadena separada por salto de línea de 0y1
• Cadena contigua de 0y1
• Cualquier otro formato razonable

Por ejemplo, las siguientes tres entradas son todas aceptables:

• [1, 0, 0, 1]
• "1\n0\n0\n1"(donde \nhay un salto de línea U + 000A)
• "1001"

Puede suponer que las carreras de 0tendrán una longitud uniforme .

Salida

Una serie de 0y 1, en los formatos aceptables anteriores.

Casos de prueba

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]

Puntuación

Este es el código de golf . La respuesta más corta en bytes gana.

Se aplican lagunas estándar .

Retina , 4 bytes

00
0

Pruébalo en línea!

05AB1E , 5 bytes

00¤.:

Pruébalo en línea!

Explicación

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

Pruébalo en línea! Uso: f[1,1,0,0,1,1,0,0,1]. Itera sobre la lista y reemplaza dos ceros consecutivos por un cero.

C (gcc) , 35 bytes

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

48 es el código ascii de '0'

mejor versión 43 bytes como lo sugiere Neil

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

otro de 40 bytes esta vez (nuevamente como lo sugirieron Neil y VisualMelon) :)

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

y luego 35 bytes gracias a Khaled.K

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

Pruébalo en línea!

sed , 8 bytes

s/00/0/g

Pruébalo en línea!

Octava, 22 bytes

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

Verifique todos los casos de prueba aquí.

Esta es una función anónima que toma una cadena en el formato '1001000011'como entrada y reemplaza dos ceros consecutivos con un solo cero.

Java, 50 bytes

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

Probar en línea

Haskell , 28 bytes

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

Pruébalo en línea!

Recursivamente toma el primer elemento, dejando caer el segundo si el primero es cero, hasta la lista de vacíos. Si la primera entrada es h, entonces las primeras 1-hse eliminan del resto.

Japt , 7 6 5 bytes

d'0²0

Pruébalo en línea!

Simplemente reemplaza cada ejecución de dos ceros en la entrada por un cero. Utiliza la entrada de cadena (es decir "1001001").

PHP, 26

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

simplemente reemplace todo 00por 0.

Alice , 13 bytes

/oe00/
@iS0e\

Pruébalo en línea!

Explicación

/.../
@...\

Esta es una plantilla simple para programas lineales que operan completamente en modo ordinal. La inicial /refleja la IP para moverse hacia el sureste y luego rebota diagonalmente hacia arriba y hacia abajo a través del código hasta los espejos al final. Esos simplemente compensan la posición en uno para que en el camino de regreso la IP atraviese las celdas restantes. Al leer el código de esta manera en zigzag se convierte en:

ie00e0So@

Esta es una simple sustitución de cadena:

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.

Hay algunas otras formas de insertar las dos cadenas, por ejemplo, '00'0o e000t, pero no he encontrado nada que supere los 5 bytes (y tendría que reducir dos bytes para poder acortar el programa).

Prólogo (SWI) , 42 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

JavaScript (ES6), 26 21 bytes

Toma la entrada como una cadena y devuelve una cadena.

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

Intentalo

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")))

Toma una cadena a través de la entrada y condensa los ceros dobles. Fácil.

Jalea , 8 bytes

ṣ1j1,1m2

Pruébalo en línea!

Posiblemente otras respuestas en idiomas sin un .replace() o similar podrían usar este truco.

Explicación

ṣ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 guardados gracias a Martin Ender

i.h%.7%$io

Pruébalo en línea!

Explicación

Este es un código 1-D que funciona en modo cardinal, por lo que es fácil seguir su flujo:

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 de E / S), 36 bytes

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

Pruébalo en línea!

Recursivamente toma el primer elemento, luego elimina el restante si el primero era cero.

38 bytes:

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

Pruébelo en línea Esto toma una lista de Python y genera una lista de Python al reemplazar su representación de cadena. La E / S de cadena permitiría una solución más directa y más corta, como

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

para el '1001' formato

APL (Dyalog) , 9 bytes

'00'⎕R'0'

Pruébalo en línea!

Perl 5, 7 + 1 (bandera -p) = 8 bytes

<>if/0/

Toma la entrada como números separados por nueva línea. Omite la siguiente línea si ve un cero.

V , 4 bytes

òf0x

Pruébalo en línea!

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

MATL , 5 bytes

FFOZt

Pruébalo en línea!

Explicación

Esto es similar a la respuesta Octave de Stewie Griffin :

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

8 bytes

vy~f2L)(

Esto evita el reemplazo de cadena / matriz incorporado.

Pruébalo en línea!

Explicación

Considere la entrada [1,0,0,1,0,0,1]como un ejemplo:

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

Pruébalo en línea!

No estoy seguro de que esto sea óptimo todavía ...

Explicación

Esto explota el error que cfallará en una lista de enteros que tiene ceros a la izquierda.

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

Pruébalo en línea!

No es ni limpio ni corto, pero funciona.

Toma la entrada como una cadena contigua de caracteres, las salidas en el mismo formato

Explicación:

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í, soy consciente de que esto podría hacerse simplemente usando s.Replace("00","0"), mi objetivo era evitar usar la solución obvia. Después de todo, el objetivo de PPCG es divertirse, ¿verdad? ;)

Pyth, 8 bytes

:z"00"\0

Enlace de prueba.

Explicación:

: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

Primero intente hacer algo con Awk para que sea posible jugar más al golf.

{gsub(00,0);print}

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

Lote, 24 bytes.

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

Toma entrada en STDIN. Algo competitivo por una vez.

Common Lisp, SBCL, 48 32 bytes

-16 bytes gracias a Julian Wolf

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

entrada:

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

salida:

1001110

Explicación

Leemos la lista de entrada. La lista se usa en la formatfunción. Lo recorremos generando 1si el elemento es 1y enviando 0y omitiendo el siguiente elemento de la lista 0.

Mathematica, 24 bytes

StringReplace["00"->"0"]

Una función que espera una cadena de "0"s y "1"s y devuelve una cadena similar. Sintaxis autoexplicativa. Mathematica tiene muchas transformaciones integradas; la clave es usar uno que transforme cada subexpresión relevante (diferente /.) pero que solo pase por la expresión una vez (diferente //.).

Jalea , 10 bytes

Œg¹m2$S?€F

Pruébalo en línea!

Explicación

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