Metade dos falsos

19

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 .

code-golf  array-manipulation 
— Freira Furada
fonte
No último caso de teste, as execuções de zeros não têm tamanho uniforme?
— OldBunny2800
@ OldBunny2800 Leia o caso de teste com atenção; Os 0-funcionamentos têm comprimentos 4, 2, 2, 2, 2, e 2.
— HyperNeutrino
Podemos pegar truee em falsevez de 1e 0?
— Cyoce 3/17/17
@Cyoce qual idioma?
— Leaky Nun
@LeakyNun Ruby, que considera 0ser verdade.
— Cyoce 3/17/17

Respostas:

11

05AB1E , 5 bytes

00¤.:

Experimente online!

Explicação

00     # push 00
  ¤    # tail, pushes 0
   .:  # replace
— Emigna
fonte
2
Essa foi fácil; por que não pensei nisso?
— Leaky Nun
00é um comportamento estranho ...
— Erik o Outgolfer
@EriktheOutgolfer: dígitos sequenciais são concatenados para formar um número, assim 11como onze e não 1,1. Um efeito colateral que é que 00se torna 00, em vez de 0,0:)
— Emigna
@ Emigna, eu esperava que se tornasse 0ou melhor 0 0, mas tanto faz.
— Erik the Outgolfer
7

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!

— Alkano
fonte
11
Funcionaria s+=2-*s%2?
— Neil
11
Se contei corretamente, acho que for(;*s;s+=2-*s%2)putchar(*s);salva outro byte.
— Neil
11
O que haveria de errado s+=50-*s? Não Realizado C para idades e não quero me envergonhar invocando um comportamento indefinido (vindo do C #, onde não há nenhum)
— VisualMelon
11
Olhando para os putchardocumentos, você pode fazer f(char*s){for(;*s;s+=50-putchar(*s));}?
— VisualMelon 3/17/17
3
Você pode salvar 5 bytes, tornando-recursivaf(char*s){*s&&f(s+50-putchar(*s));}
— Khaled.K
6

Java, 50 bytes

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

Experimente on-line

— Khaled.K
fonte
11
Uma ótima opção de entrada! By the way, se você estiver interessado em mudar para solução de um Java 8+, você poderia usar um lambda: s->s.replaceAll("00","0").
— Jakob
Ainda melhor, use em replacevez de replaceAllsalvar 3 bytes
— Benjamin Urquhart
@BenjaminUrquhart replacesubstituirá apenas a primeira ocorrência
— Khaled.K
@ Khaled.K em javascript, sim. No java, ele substitui todas as ocorrências
— Benjamin Urquhart
5

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.

— xnor
fonte
5

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

— Lucas
fonte
11
Agradável! Você nem precisa do que 'eu penso
— ETHproductions
Ooh, você pode salvar outro byte, substituindo "00"com '0²:-)
— ETHproductions
Bem, isso é estranho. Obrigado embora!
— Luke
4

PHP, 26

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

simplesmente substitua tudo 00por 0.

— Christoph
fonte
4

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

— Martin Ender
fonte
2
Parece que você se apaixonou por Alice recentemente ...
— Leaky Nun
6
@LeakyNun Por favor não diga a minha mulher ...
— Martin Ender
@MartinEnder Vou contar isso para a Sra. Ender!
— Erik the Outgolfer
3

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>
Expandir snippet

— Shaggy
fonte
3

Lua, 33 bytes

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

Toma uma string via entrada e condensa zeros duplos. Fácil.

— Blab
fonte
3

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
— fireflame241
fonte
3

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
— Leo
fonte
Você pode realmente salvar mais dois bytes comi.h%...
— Martin Ender
@MartinEnder você é uma pessoa má, indo em torno de ensinar as pessoas a jogar sujo ...: D
— Leo
2

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.

— xnor
fonte
A primeira resposta com o formato especificado, legal.
— Leaky Nun
11
E / S de sequência é permitida. lambda s:s.replace('00','0')deve ficar bem.
— Jonathan Allan
2

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.

— Chris
fonte
2

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]
— Luis Mendo
fonte
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
— Fatalizar
fonte
Como isso é um bug?
— Leaky Nun
@LeakyNun Devemos ser capazes de concatenar [0,0,4,2]em 42. Zeros à esquerda fazem com que falhe agora, porque está aqui para evitar zeros à esquerda infinitos quando a Entrada é uma variável, mas aqui a Entrada é totalmente aterrada para que a limitação não exista.
— Fatalize
Você escreveria uma resposta do Prolog?
— Freira vazando
1

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

— Skidsdev
fonte
@ Mr.Xcoder Isso não é verdade. Isso é o máximo que você pode obter sem usar o built-in do idioma. Replace Estou usando C #; portanto, não tenho ilusões em obter o código mais curto possível, especialmente em idiomas como o Jelly, por isso é muito divertido. no processo.
— Skidsdev 3/05
é claro que a diversão também é importante. Peço desculpas pelo comentário acima e devo admitir que gostei da sua resposta (a técnica que você usou).
— Sr. Xcoder
@ Mr.Xcoder sem ressentimentos, afinal estamos todos aqui para nos divertir e flexibilizar nossa capacidade inútil de comprimir o código o máximo possível;) #
— Skidsdev
Você pode fazer muito mais curto que isso sem substituir! string a(string s){var r="";for(int i=0;i<s.Length;i+=50-s[i])r+=s[i];return r;} (parece que este é, basicamente, a resposta C)
— VisualMelon
1

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
— Erik, o Outgolfer
fonte
1

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

— PsHegger
fonte
1

Lote, 24 bytes

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

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

— Neil
fonte
1

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.

Usando ~[ao invés de ~:[deixa-o índice com 0 e 1 diretamente, o que deve poupar um monte de bytes
— Julian Lobo
@JulianWolf Thank you!
1

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 //.).

— Greg Martin
fonte
1

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.
— fireflame241
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.