Tarefa

Dada uma matriz não vazia de 0e 1, reduza pela metade os comprimentos das execuções de 0.

Entrada

Uma matriz de 0e 1. Formato aceitável:

• Matriz real no seu idioma
• Sequência separada por avanço de linha de 0e1
• Sequência contígua de 0e1
• Qualquer outro formato razoável

Por exemplo, as três entradas a seguir são aceitáveis:

• [1, 0, 0, 1]
• "1\n0\n0\n1"(onde \né um avanço de linha U + 000A)
• "1001"

Você pode supor que as execuções de 0terão duração uniforme .

Resultado

Uma matriz de 0e 1, nos formatos aceitáveis ​​acima.

Casos de teste

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]

Pontuação

Isso é código-golfe . A resposta mais curta em bytes vence.

Aplicam-se brechas padrão .

Retina , 4 bytes

00
0

Experimente online!

05AB1E , 5 bytes

00¤.:

Experimente online!

Explicação

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

Experimente online! Uso: f[1,1,0,0,1,1,0,0,1]. Repete a lista e substitui dois zeros consecutivos por um zero.

C (gcc) , 35 bytes

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

48 é o código ascii de '0'

versão melhorada de 43 bytes, conforme sugerido por Neil

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

outro de 40 bytes desta vez (novamente como sugerido por Neil & VisualMelon) :)

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

e, em seguida, 35 bytes, graças a Khaled.K

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

Experimente online!

sed , 8 bytes

s/00/0/g

Experimente online!

Oitava, 22 bytes

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

Verifique todos os casos de teste aqui.

Esta é uma função anônima que recebe uma string no formato '1001000011'como entrada e substitui dois zeros consecutivos por um único zero.

Java, 50 bytes

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

Experimente on-line

Haskell , 28 bytes

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

Experimente online!

Recursivamente leva o primeiro elemento, descartando o segundo se o primeiro for zero, até a lista de vazio. Se a primeira entrada for h, a primeira 1-hserá descartada do restante.

Japonês , 7 6 5 bytes

d'0²0

Experimente online!

Simplesmente substitui cada execução de dois zeros na entrada por um zero. Usa entrada de string (ou seja "1001001").

PHP, 26

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

simplesmente substitua tudo 00por 0.

Alice , 13 bytes

/oe00/
@iS0e\

Experimente online!

Explicação

/.../
@...\

Este é um modelo simples para programas lineares que operam inteiramente no modo Ordinal. A inicial /reflete o IP para se mover para o sudeste e, em seguida, salta na diagonal para cima e para baixo através do código até os espelhos no final. Eles simplesmente deslocam a posição em um para que, no caminho de volta, o IP atravesse as células restantes. Lendo o código dessa maneira em zigue-zague, ele se torna:

ie00e0So@

Esta é uma substituição simples de string:

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.

Existem algumas outras maneiras de enviar as duas strings, por exemplo, '00'0ou e000t, mas eu não encontrei nada que ultrapasse 5 bytes lá (e eu teria que cortar dois bytes para reduzir o programa).

Prolog (SWI) , 42 bytes

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

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

Experimente online!

JavaScript (ES6), 26 21 bytes

Pega a entrada como uma sequência e retorna uma sequência.

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

Tente

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 uma string via entrada e condensa zeros duplos. Fácil.

Gelatina , 8 bytes

ṣ1j1,1m2

Experimente online!

Possivelmente outras respostas em idiomas sem um .replace()ou similar podem usar esse truque.

Explicação

ṣ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 economizados graças a Martin Ender

i.h%.7%$io

Experimente online!

Explicação

Este é um código 1-D que opera no modo cardinal, por isso é fácil seguir seu fluxo:

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 (E / S da lista), 36 bytes

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

Experimente online!

Pega recursivamente o primeiro elemento e remove o restante se o primeiro for zero.

38 bytes:

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

Experimente on-line Isso pega uma lista de Python e gera uma lista de Python, substituindo sua representação de string. A E / S da string permitiria uma solução mais direta e mais curta, como

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

para o '1001' formato.

APL (Dyalog) , 9 bytes

'00'⎕R'0'

Experimente online!

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

<>if/0/

Recebe a entrada como números separados por nova linha. Pula a próxima linha se encontrar um zero.

V , 4 bytes

òf0x

Experimente 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

Experimente online!

Explicação

Isso é semelhante à resposta 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)(

Isso evita a substituição de string / array incorporada.

Experimente online!

Explicação

Considere a entrada [1,0,0,1,0,0,1]como um exemplo:

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]

Braquilog , 10 bytes

ḅ{cẹ|ḍh}ᵐc

Experimente online!

Ainda não tenho certeza de que isso é ótimo…

Explicação

Isso explora o erro que cem uma lista de números inteiros com zeros à esquerda irá falhar.

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

Experimente online!

Não é limpo nem curto, mas funciona.

Recebe entrada como uma sequência de caracteres contígua, produz no mesmo formato

Explicação:

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

Sim, eu sei que isso pode ser feito simplesmente usando s.Replace("00","0"), meu objetivo era evitar o uso da solução óbvia. Afinal, o objetivo do PPCG é se divertir, certo? ;)

Pitão, 8 bytes

:z"00"\0

Link Try-it.

Explicação:

: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

Primeiro, tente fazer qualquer coisa com o Awk, para que seja possível jogar mais.

{gsub(00,0);print}

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

Lote, 24 bytes

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

Recebe entrada em STDIN. Um pouco competitivo pela primeira vez.

Lisp comum, SBCL, 48 32 bytes

-16 bytes graças a Julian Wolf

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

entrada:

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

resultado:

1001110

Explicação

Lemos a lista de entrada. Lista é usada em formatfunção. Nós passamos por ele emitindo 1se o elemento estiver 1e emitindo 0e pulando o próximo elemento da lista para 0.

Mathematica, 24 bytes

StringReplace["00"->"0"]

Uma função que espera uma série de "0"s e "1"s e retorna uma string similar. Sintaxe auto-explicativa. O Mathematica possui muitas funções de transformação; a chave é usar uma que transforme cada subexpressão relevante (diferente /.), mas só passe pela expressão uma vez (diferente //.).

Gelatina , 10 bytes

Œg¹m2$S?€F

Experimente online!

Explicação

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