Sfida:

Leggi l'input (all'interno dell'intervallo ASCII visibile) e l'output con alcune modifiche:

1. In ogni set di 10 caratteri dell'input in modo casuale (50/50):
   • sostituire un carattere * (con uno casuale ** compreso nell'intervallo ASCII visibile) (es. lumberjackdiventa lumbeZjack)
   • o rimuovi un carattere (es. lumberjackdiventa lmberjack)

^{* Se il set ha meno di 10 caratteri, non è necessario modificarlo, ma è possibile.
** Il personaggio può essere lo stesso di un input, purché sia ​​ancora casuale.}

Esempio:

Input: Go home cat! You're drunk!
Output: Go hom cat! YouLre drunk!
(solo un esempio, poiché l'output potrebbe essere casuale, non utilizzare come test case)

Regole:

• code-golf , vince il numero minimo di caratteri!

Pyth, 27 25 byte

VczTpXNOT?<JOr\ \ÞKC127JK

Suite di test disponibile qui.

Grazie a Maltysen per la rasatura di 2 byte.

Spiegazione

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

Come spesso accade, ritengo che questo sia un metodo un po 'ingenuo e potrebbe essere migliorato. Di solito trovo qualcosa di ovvio mentre scrivo la spiegazione, ma questa volta non è saltato fuori niente.

*> <> , 44 46 52 50 byte

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

Provalo qui!

Questo utilizza qualsiasi carattere ASCII vicino / sopra lo spazio per i caratteri casuali. Questo modifica sempre il sesto carattere, a meno che non sia la fine di una stringa e la lunghezza di quella stringa non sia un multiplo di 10. Ciò ha una probabilità del 50% di rimuovere il settimo carattere invece di modificare il sesto.

Ingresso

Lo standard IEEE per l'aritmetica in virgola mobile (IEEE 754) è uno standard tecnico per il calcolo in virgola mobile stabilito nel 1985 dall'Institute of Electrical and Electronics Engineers (IEEE). Lo standard ha affrontato molti problemi riscontrati nelle diverse implementazioni in virgola mobile che li hanno resi difficili da usare in modo affidabile e portabile. Molte unità hardware a virgola mobile ora utilizzano lo standard IEEE 754.

Produzione

Lo standard IEE per Float $ ng-Point Aithmetic (EEE 754) ia technicl standar! per floa! ing-point! computati # n istituito nel 1985 da Insitute of! lectrical # ed Electrnics Engi! eers (IEE%). Lo st! Ndard aggiunge! Essed man! problemi # trovati in! lui subacquei! fluttuazione di unguento fluttuante "quella folle # loro dif! icult per ue reliabl # e port! bly. Molti! unità hardware po # nt% che usano lo standard! IEEE 754".

Modifica: questa risposta probabilmente non è sempre nell'intervallo ASCII visibile, modifica ... Risolto.

Edit2: Non ho visto che ci doveva essere una possibilità 50/50 di rimuovere un personaggio, modificarlo di nuovo ... Credo che tutto sia in ordine ora :).

Perl 6 ,  78  67 byte

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

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

Provalo

Spiegazione:

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

smO,XdOTOr;\~.DdOTcQT

Provalo online qui .

Python 3 , 75 byte

Il 75 byte applica la trasformazione al primo carattere di ciascun gruppo e seleziona solo da 2 caratteri casuali, come nella risposta Jelly (che OP ha permesso):

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

Provalo online!

Questa è una funzione ricorsiva che, ad ogni iterazione, non precede nulla 'a', o 'b', e quindi si chiama con i primi 10 caratteri tagliati. L'iterazione finale va in cortocircuito su s and(una stringa vuota è falsa), evitando la ricorsione infinita.

Il risultato di tutte le chiamate separate viene quindi concatenato e restituito al contesto che ha chiamato la funzione.

120 byte

Certo, è un po 'come imbrogliare, quindi eccone uno completamente casuale:

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

Provalo online!

Gelatina , 15 14  13 byte 13 caratteri

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

TryItOnline!

Sostituisce o rimuove il primo di ogni dieci caratteri incluso quello dell'ultimo 1-9 se esiste un tale blocco. Scegli tra il sottogruppo di caratteri, certamente piccolo,: 1; 2.

Come?

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

Per scegliere tra tutte le ASCII stampabili anziché solo 1e 2(ancora sostituendo o rimuovendo il 1 ° carattere di ogni blocco) in 21 byte:

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

Per una versione completamente casuale (50/50 rimuovi / sostituisci, ASCII stampabile casuale uniforme e una posizione dei caratteri uniformemente casuale all'interno di ciascun blocco) ho 30 byte (probabilmente non ottimale):

95R+31ỌX;

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

Questo ruota ogni blocco lasciato di una quantità casuale, elimina l'ultimo carattere e quindi chiama uno casuale dei primi due collegamenti, uno dei quali è vuoto e l'altro che si concatena con un carattere ASCII stampabile casuale; quindi ruota di nuovo il blocco a destra.

Python3, 188 186 184 114 caratteri

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

Sembra troppo lungo Probabilmente potrebbe essere abbreviato molto con una lambda.

Apparentemente l'OP ha permesso di scegliere il carattere casuale da un elenco di due caratteri e l'indice del personaggio da sostituire può essere una costante. Dopo le modifiche, la mia risposta sarebbe stata esattamente la stessa della presentazione di @FlipTacks Python, quindi questo è il modulo con cui mi trovo.

@FlipTack ha salvato 5 byte!

Clojure, 135 139 byte

Modifica: ho dimenticato di usare partition-allinvece di 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))))

Man quei nomi di funzioni sono lunghi ... Comunque, divide l'input in partizioni di 10 caratteri, li divide in due punti in modo casuale, inietta casualmente una stringa vuota o un carattere casuale tra loro e scarta il primo carattere del 2 ° tempo.

Mathematica 133 byte (129 caratteri)

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

76 caratteri per scrivere i nomi di 8 funzioni: /

Usando ⌊..⌋invece di Floor[]salva 5 caratteri, 1 byte.

Python 3, 129 byte

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

Al fine di salvare alcuni byte, invece di importare il modulo casuale di Python, ho appena fatto alcune operazioni del modulo sull'ID della stringa, che dovrebbe essere ogni volta diversa. Ad esempio, il programma deciderà se rimuovere o meno un carattere o sostituirlo con un valore pari o meno id(string)//10(divido intero I per 10 poiché l'ultima cifra sarà sempre pari).