Início / unix / Perguntas / 562463
Accepted
Paulo Tomé
Asked: 2020-01-17 08:03:53 +0800 CST

Qual é a maneira mais rápida de substituir 0 por 1 e vice-versa em um fluxo?

  • 772

Dada uma string composta por 0s e 1s, meu objetivo é substituir 0 por 1 e vice-versa. Exemplo:

Entrada

111111100000000000000

Saída pretendida

000000011111111111111

Tentei, sem sucesso, o seguinte sedcomando

echo '111111100000000000000' | sed -e 's/0/1/g ; s/1/0/g'
000000000000000000000

o que estou perdendo?

text-processing sed

5 respostas

  1. Best Answer

    Você pode usar trpara isso, seu principal objetivo é a tradução de caracteres:

    echo 111111100000000000000 | tr 01 10

    Seu sedcomando substitui todos os 0s por 1s, resultando em uma string contendo apenas 1s (os 1s originais e todos os 0s substituídos) e, em seguida, substitui todos os 1s por 0s, resultando em uma string contendo apenas 0s.

    Em fluxos longos, tré mais rápido que sed; para um arquivo de 100MiB:

    $ time tr 10 01 < bigfileof01s > /dev/null
tr 10 01 < bigfileof01s > /dev/null  0.07s user 0.03s system 98% cpu 0.100 total

$ time sed y/10/01/ < bigfileof01s > /dev/null
sed y/10/01/ < bigfileof01s > /dev/null  3.91s user 0.11s system 99% cpu 4.036 total
    • 62

  2. Embora trseja a ferramenta certa para este trabalho , você pode fazê-lo sedusando o ycomando (transliteração) em vez do comando s(substituição):

    $ echo '111111100000000000000' | sed 'y/01/10/'
000000011111111111111

    yé basicamente seda implementação interna de tr- com toda a sobrecarga que isso implica.

    • 40

  3. Uma maneira éecho "111111100000000000000" | sed 's/1/2/g;s/0/1/g;s/2/0/g'

    • 13

  4. Provavelmente um método lento, mas faz isso de maneira binária, usando a aritmética interna do shell:

    echo '111111100000000000000' |
  while read -rn1 b; do
    printf '%1d' $((b^1))
  done

    Ou para lidar com o fluxo binário por pedaços de byte:

    #!/usr/bin/env bash

# Populate a byte to inverted binary string array
declare -a byte_binstring=()
for ((byte=0; byte<=255; byte++)); do
  for ((bit=0; bit<=7; bit++)); do
    printf -v byte_binstring[byte] '%1s' "$((!(byte>>bit&1)))${byte_binstring[byte]}"
  done
done

# Read input stream by chunks of 8 bits max
while read -rn8 bin_str; do
  # $((2#$bin_str)) converts the bit string into a byte value
  # using shell built-in base-2 arithmetic conversion
  # byte_binstring[$((2#$bin_str))] gets the string matching this byte value
  # ${#bin_str}} gives the number of bits read (string length)
  # extract the last n characters from string matching
  # number of byte read
  # ${byte_binstring[$((2#$bin_str))]: -${#bin_str}}
  # This prints the inverted binary representation from the read bits stream
  printf '%s' "${byte_binstring[$((2#$bin_str))]: -${#bin_str}}"
done
    • 1

  5. Se a sua string contiver apenas uma única linha e for composta apenas por 0s e 1s, você poderá usar isso

    echo "111111100000000000000" |
    perl -e 'while (read(STDIN, $b, 1)) { print chr(ord($b) ^ 1); } print "\n";'

    Se a string puder conter várias linhas, basta alterar e alterar perl -ea perl -nemaneira de ler os bytes (já que readprecisa de um identificador de arquivo)

    echo -e "111111100000000000000\n0001111010101" |
    perl -ne 'while (/(.)/g) { print chr(ord($1)^1) } print "\n"'

    No entanto, dessa forma, cada linha é dividida em uma string, portanto, pode não ser muito eficiente para arquivos grandes. Nesse caso, uma pequena verificação é necessária

    echo "122111111034000000000abc0000" | perl -e 'while (read(STDIN, $b, 1)) {
    print ($b eq '0' or $b eq '1' ? chr(ord($b) ^ 1) : $b) } print "\n";'

    Como você pode ver, desta forma também funciona para strings que contêm caracteres diferentes '0'e'1'

    • 1

relate perguntas