Desafio:

Leia a entrada (dentro do intervalo ASCII visível) e a saída com algumas modificações:

1. Em cada conjunto de 10 caracteres da entrada aleatoriamente (50/50):
   • substitua um caractere * (por um aleatório ** dentro do intervalo ASCII visível) (por exemplo, lumberjacktorna-se lumbeZjack)
   • ou remover um caractere (por exemplo, lumberjacktorna-se lmberjack)

^{* Se o conjunto tiver menos de 10 caracteres, você não precisará modificá-lo, mas poderá.
** O caractere pode ser o mesmo que uma entrada, desde que ainda seja aleatório.}

Exemplo:

Entrada: Go home cat! You're drunk!
Saída: Go hom cat! YouLre drunk!
(apenas um exemplo, já que a saída pode ser aleatória, não use como caso de teste)

Regras:

• código-golfe , menos personagens ganha!

Pitão, 27 25 bytes

VczTpXNOT?<JOr\ \ÞKC127JK

Conjunto de testes disponível aqui.

Graças à Maltysen para raspar 2 bytes.

Explicação

VczTpXNOT?<JOr\ \ÞKC127JK    z autoinitalizes to input, T autoinitializes to 10 
 czT                         chop input into strings of length 10, returned as list of strings
V                            for each string N in this list:
            Or\ \Þ            randomly pick a char between ' ' (32) and 'Þ' (222)
           J                  and assign it to variable J
                  KC127       assign the DEL char to variable K
         ?<J      K           if J < K:
     XNOT              J       replace a random character in N with J
         ?<J      K           else:
     XNOT               K      replace a random character in N with K
    p                         print this string with no trailing newline

Como costuma ser o caso, acho que esse é um método um pouco ingênuo e que pode ser aprimorado. Normalmente, encontro algo óbvio enquanto digito a explicação, mas nada me ocorreu dessa vez.

*> <> , 44 46 52 50 bytes

rl5(?voooo/!|Ou+1Ox:@=?~o~oooo!
ol5(?v" ":/
o;!?l<

Experimente aqui!

Isso usa qualquer caractere ascii próximo / acima do espaço para os caracteres aleatórios. Isso sempre edita o sexto caractere, a menos que seja o final de uma string e o comprimento dessa string não seja múltiplo de 10. Isso tem 50% de chance de remover o 7º caractere em vez de editar o sexto.

Entrada

O padrão IEEE para aritmética de ponto flutuante (IEEE 754) é um padrão técnico para computação de ponto flutuante estabelecido em 1985 pelo Instituto de Engenheiros Elétricos e Eletrônicos (IEEE). O padrão abordou muitos problemas encontrados nas diversas implementações de ponto flutuante que dificultavam o uso confiável e portável. Muitas unidades de ponto flutuante de hardware agora usam o padrão IEEE 754.

Resultado

O padrão IEE para a Aithmetic de ponto flutuante de $ ng (EEE 754) é um padrão técnico! para computadores de ponto de inflamação estabelecido em 1985 pelo Instituto de Engenharia Elétrica e Eletrônica (IEE%). O homem mais velho! problemas # encontrados em! ele mergulha! implementação de uniões flutuantes "que dificultam o uso e a portabilidade confiáveis. Muitas unidades de hardware que usam o #! IEEE 754".

Editar: Esta resposta provavelmente nem sempre está no intervalo ascii visível, editando ... Corrigido.

Edit2: Não viu, precisa haver uma chance de 50/50 para remover um personagem, editando novamente ... Eu acredito que tudo está em ordem agora :).

Perl 6 ,  78  67 bytes

{[~] map {~S/.**{(^.chars).pick}<(./{(' '..'~').pick x Bool.pick}/},.comb(10)}

{[~] .comb(10)».&{~S/.**{10.rand}<(./{(' '..'~').pick x 2.rand}/}}

Tente

Explicação:

{
  [~]                  # reduce with string concatenation operator

  .comb(10)\           # take input and break it into chunks of up-to 10 chars

  ».\                 # on each of them call the following

  &{
    ~                  # Stringify the following

    S/                 # substituted
      .                # any char
        **             # repeated
           { 10.rand } # a random number of times

      <(               # ignore all of that

      .                # the char to be removed/replaced
    /{

      ( ' ' .. '~' ).pick  # choose a character
      x                    # string repeated
      2.rand               # zero or one times

    }/

  }
}

Pitão - 21 bytes

smO,XdOTOr;\~.DdOTcQT

Experimente online aqui .

Python 3 , 75 bytes

O byte de 75 bytes aplica a transformação ao primeiro caractere de cada grupo e seleciona apenas dois caracteres aleatórios, como na resposta Jelly (que o OP permitiu):

from random import*
f=lambda s:s and choice(['','a','b'])+s[1:10]+f(s[10:])

Experimente online!

Essa é uma função recursiva que, a cada iteração, acrescenta nada 'a', ou 'b', e depois se autodenomina com os 10 primeiros caracteres cortados. A iteração final s andprovoca um curto-circuito em (uma string vazia é falsy), evitando a recursão infinita.

O resultado de todas as chamadas separadas é concatenado e retornado ao contexto que chamou a função.

120 bytes

Claro, isso parece um pouco de trapaça, então aqui está uma que é completamente aleatória:

from random import*;r=randint
def f(S):a=S[:10];R=r(0,len(a)-1);print(end=a[:R]+chr(r(32,126))*r(0,1)+a[R+1:]);f(S[10:])

Experimente online!

Jelly , 15 14  13 bytes 13 caracteres

2X
s⁵µ¢1¦ṫ¢µ€

TryItOnline!

Substitui ou remove o primeiro de cada dez caracteres, incluindo o dos últimos 1 a 9, se houver esse pedaço. Escolhe do, reconhecidamente pequeno, subconjunto de caracteres: 1; 2.

Quão?

2X         - Link 1, flip a coin: no arguments
 X         - random choice from
2          - 2 (treated as the integers [1,2])

s⁵µ¢1¦ṫ¢µ€ - Main link: string of printable ASCII
s⁵         - split (s) into chunks of size ten (⁵)
  µ     µ  - monadic chain separation 
         € - for each chunk
   ¢       -     last link as a nilad
    1¦     -     apply to index 1 (replace 1st of the 10 char chunk with the chosen integer)
       ¢   -     last link as a nilad
      ṫ    - tail - if it was 1 this has no effect (50%)
                  - if it was 2 this discards the replaced character (50%)
           - implicit print

Para escolher entre todos os ASCII imprimíveis em vez de apenas 1e 2(ainda substituindo ou removendo o primeiro caractere de cada bloco) em 21 bytes:

s⁵µ32r126¤ỌX¤1¦ṫ2X¤µ€

Para uma versão totalmente aleatória (50/50 remover / substituir, ASCII imprimível aleatório uniforme e um local de caracteres aleatoriamente uniforme em cada bloco), eu tenho 30 bytes (provavelmente não ideal):

95R+31ỌX;

s⁵µṙ⁵X¤©Ṗ2X¤Ŀṙ®C¤µ€

Isso gira cada pedaço deixado por uma quantidade aleatória, exibe o último caractere e chama um dos dois primeiros links aleatórios, um dos quais está vazio e o outro que concatena com um caractere ASCII imprimível aleatório; em seguida, gira o pedaço para a direita novamente.

Python3, 188 186 184 114 caracteres

from random import*
s=input()
for c in[s[i:i+10]for i in range(0,len(s),10)]:print(end=choice(["","x","y"])+c[1:])

Parece muito tempo. Provavelmente poderia ser muito reduzido com uma lambda.

Aparentemente, o OP permitiu escolher o caractere aleatório de uma lista de dois caracteres e o índice do caractere a ser substituído pode ser uma constante. Após as modificações, minha resposta teria exatamente a mesma aparência do envio do @FlipTacks Python, então esse é o formulário em que estou hospedado.

O @FlipTack salvou 5 bytes!

Clojure, 135 139 bytes

Edit: Esqueceu de usar em partition-allvez de partition.

(fn[i](apply str(flatten(map #(let[r rand-int [b e](split-at(r 9)%)][b(if(<(rand)0.5)""(char(+(r 25)97)))(rest e)])(partition-all 10 i)))))

Ungolfed:

(def f (fn[i]
         (->> i
              (partition-all 10)
              (map #(let [[begin end] (split-at (rand-int 9) %)]
                      [begin (if (< 0.5 (rand)) "" (char (+(rand-int 25)97))) (rest end)]))
              flatten
              (apply str))))

Cara, esses nomes de função são longos ... Enfim, ele divide a entrada em partições de 10 caracteres, as divide em pontos aleatórios em duas metades, injeta aleatoriamente uma string vazia ou um caracter aleatório entre elas e descarta o primeiro caractere da 2ª parte.

Mathematica 133 bytes (129 caracteres)

StringReplacePart[#,Table[If[(r=RandomInteger)[]<1,"",FromCharacterCode@r@128],c=⌊StringLength@#/10⌋],Array[{g=10#-9+r@9,g}&,c]]&

76 caracteres para escrever os nomes de 8 funções: /

Usar o em ⌊..⌋vez de Floor[]salva 5 caracteres, 1 byte.

Python 3, 129 bytes

def f(s):f=id(s)%9+1;print(''.join(j[0:f-1]+chr(33+id(s)%94)*(id(s)//10%2)+j[f:]for j in [s[i:i+10]for i in range(0,len(s),10)]))

Para economizar alguns bytes, em vez de importar o módulo aleatório do Python, eu apenas fiz algumas operações de módulo no id da string, que deveria ser diferente todas as vezes. Por exemplo, o programa decidirá se deve ou não remover um caractere ou substituir um com base em se id(string)//10é par ou não (divido o número inteiro por 10, pois o último dígito sempre será par).