Desafío:

Lea la entrada (dentro del rango ASCII visible) y la salida con algunas modificaciones:

1. En cada conjunto de 10 caracteres de la entrada aleatoriamente (50/50):
   • reemplazar un carácter * (con uno aleatorio ** dentro del rango ASCII visible) (por ejemplo, se lumberjackconvierte en lumbeZjack)
   • o eliminar un personaje (ej. se lumberjackconvierte lmberjack)

^{* Si el conjunto tiene menos de 10 caracteres, no tiene que modificarlo, pero puede hacerlo.
** El carácter puede ser el mismo que el de una entrada, siempre que sea aleatorio.}

Ejemplo:

Entrada: Go home cat! You're drunk!
Salida: Go hom cat! YouLre drunk!
(solo un ejemplo, ya que la salida podría ser aleatoria, no la use como caso de prueba)

Reglas:

• código-golf , gana menos personajes!

Pyth, 27 25 bytes

VczTpXNOT?<JOr\ \ÞKC127JK

Conjunto de pruebas disponible aquí.

Gracias a Maltysen por reducir 2 bytes.

Explicación

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 suele ser el caso, creo que este es un método un poco ingenuo y puede mejorarse. Por lo general, encuentro algo obvio mientras escribo la explicación, pero nada me llamó la atención esta vez.

*> <> , 44 46 52 50 bytes

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

Pruébalo aquí!

Esto utiliza cualquier carácter ascii cerca / encima del espacio para los caracteres aleatorios. Esto siempre edita el sexto carácter, a menos que sea el final de una cadena y la longitud de esa cadena no sea múltiplo de 10. Esto tiene un 50% de posibilidades de eliminar el séptimo carácter en lugar de editar el sexto.

Entrada

El estándar IEEE para aritmética de punto flotante (IEEE 754) es un estándar técnico para el cálculo de punto flotante establecido en 1985 por el Instituto de Ingenieros Eléctricos y Electrónicos (IEEE). El estándar abordó muchos problemas encontrados en las diversas implementaciones de punto flotante que los hicieron difíciles de usar de manera confiable y portátil. Muchas unidades de punto flotante de hardware ahora usan el estándar IEEE 754.

Salida

¡El estándar IEE para Float $ ng-Point Aithmetic (EEE 754) es un estándar técnico! para la computación en punto flotante establecida en 1985 por el Instituto de Ingeniería Eléctrica y Electrónica (% IEE). ¡El hombre de st! Ndard add! Essed! problemas encontrados en! ¡buzos! Implicación de ungüento flotante "que los molesta por su fiabilidad y portabilidad. Muchas unidades de almacenamiento de hardware pueden utilizar el estándar IEEE 754".

Editar: esta respuesta probablemente no siempre está en el rango de ascii visible, edición ... Corregido.

Edit2: No vi que debe haber una posibilidad de 50/50 para eliminar un personaje, editando de nuevo ... Creo que todo está en orden ahora :).

Perl 6 ,  78  67 bytes

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

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

Intentalo

Explicación:

{
  [~]                  # 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

    }/

  }
}

Pyth - 21 bytes

smO,XdOTOr;\~.DdOTcQT

Pruébelo en línea aquí .

Python 3 , 75 bytes

El byte de 75 aplica la transformación al primer carácter de cada grupo, y solo elige entre 2 caracteres aleatorios, como en la respuesta Jelly (que OP permitió):

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

Pruébalo en línea!

Esta es una función recursiva que, cada iteración, no antepone nada 'a', o 'b', y luego se llama a sí misma con los primeros 10 caracteres cortados. La iteración final corta los circuitos en s and(una cadena vacía es falsa), evitando una recursión infinita.

El resultado de todas las llamadas separadas se concatena y se devuelve al contexto que llamó a la función.

120 bytes

Por supuesto, eso se siente un poco como hacer trampa, así que aquí hay uno que es completamente al azar:

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:])

Pruébalo en línea!

Gelatina , 15 14  13 bytes 13 caracteres

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

TryItOnline!

Reemplaza o elimina el primero de cada diez caracteres, incluido el de los últimos 1-9, si existe tal fragmento. Elige a partir de la, sin duda pequeña, subconjunto de caracteres: 1; 2.

¿Cómo?

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 elegir entre todos los ASCII imprimibles en lugar de solo 1y 2(aún reemplazando o eliminando el primer carácter de cada fragmento) en 21 bytes:

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

Para una versión completamente aleatoria (50/50 eliminar / reemplazar, ASCII imprimible aleatorio uniforme y una ubicación de caracteres uniformemente aleatoria dentro de cada fragmento) tengo 30 bytes (probablemente no óptimos):

95R+31ỌX;

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

Esto gira cada fragmento a la izquierda en una cantidad aleatoria, saca el último carácter y luego llama a uno aleatorio de los primeros dos enlaces, uno de los cuales está vacío y el otro que se concatena con un carácter ASCII imprimible aleatorio; luego gira el trozo hacia la derecha nuevamente.

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 demasiado largo Probablemente podría acortarse mucho con una lambda.

Aparentemente, el OP ha permitido elegir el carácter aleatorio de una lista de dos caracteres y el índice del carácter a reemplazar puede ser una constante. Después de las modificaciones, mi respuesta habría sido exactamente igual a @FlipTacks Python, por lo que este es el formulario con el que me quedo.

¡@FlipTack ahorró 5 bytes!

Clojure, 135 139 bytes

Editar: Olvidé usar en partition-alllugar 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)))))

Sin golf:

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

Hombre, esos nombres de funciones son largos ... De todos modos, divide la entrada en particiones de 10 caracteres, los divide en un punto aleatorio en dos mitades, inyecta aleatoriamente una cadena vacía o un carácter aleatorio entre ellos y descarta el primer carácter de la segunda mitad.

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 escribir los nombres de 8 funciones: /

Usando el en ⌊..⌋lugar de Floor[]ahorra 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 guardar algunos bytes, en lugar de importar el módulo aleatorio de Python, simplemente realicé algunas operaciones de módulo en la identificación de la cadena, que debería ser diferente cada vez. Por ejemplo, el programa decidirá si eliminar o no un carácter o reemplazar uno en función de si id(string)//10es par (o entero, dividir por 10 ya que el último dígito siempre será par).