Défi:

Lire l'entrée (dans la plage ASCII visible) et la sortie avec quelques modifications:

1. Dans chaque ensemble de 10 caractères de l'entrée au hasard (50/50):
   • remplacer un caractère * (par un ** aléatoire dans la plage ASCII visible) (ex. lumberjackdevient lumbeZjack)
   • ou supprimez un caractère (ex. lumberjackdevient lmberjack)

^{* Si l'ensemble est de moins de 10 caractères, vous n'avez pas à le modifier, mais vous pouvez.
** Le caractère peut être le même que celui entré, tant qu'il est encore aléatoire.}

Exemple:

Entrée: Go home cat! You're drunk!
Sortie: Go hom cat! YouLre drunk!
(juste un exemple, car la sortie peut être aléatoire, ne pas utiliser comme cas de test)

Règles:

• code-golf , le moins de personnages gagne!

Pyth, 27 25 octets

VczTpXNOT?<JOr\ \ÞKC127JK

Suite de tests disponible ici.

Merci à Maltysen d' avoir rasé 2 octets.

Explication

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

Comme c'est souvent le cas, je pense que c'est un peu une méthode naïve et peut être améliorée. Habituellement, je trouve quelque chose d'évident en tapant l'explication, mais rien ne m'a sauté dessus cette fois.

*> <> , 44 46 52 50 octets

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

Essayez-le ici!

Cela utilise n'importe quel caractère ascii près / au-dessus de l'espace pour les caractères aléatoires. Cela modifie toujours le 6ème caractère, sauf si c'est la fin d'une chaîne et que la longueur de cette chaîne n'est pas un multiple de 10. Cela a 50% de chances de supprimer le 7ème caractère au lieu de modifier le 6ème.

Contribution

La norme IEEE pour l'arithmétique en virgule flottante (IEEE 754) est une norme technique pour le calcul en virgule flottante établie en 1985 par l'Institut des ingénieurs électriciens et électroniciens (IEEE). La norme répondait à de nombreux problèmes rencontrés dans les diverses implémentations en virgule flottante qui les rendaient difficiles à utiliser de manière fiable et portable. De nombreuses unités matérielles à virgule flottante utilisent désormais la norme IEEE 754.

Production

La norme IEE pour l'aithmétique à points flottants (EEE 754) est un standard technique! for floa! ing-point! computati # n créé en 1985 par l'Institut des ingénieurs! lectriques et électrotechniques (IEE%). Le st! Ndard ajoute! Essed man! problèmes # trouvés dans! les plongeurs! implémentation flottante de l'ongle "qui les rend dif! iciles à utiliser en toute fiabilité # et port! bly. De nombreux! unités de poaturation de matériel #% utilisent le standard! IEEE 754".

Edit: Cette réponse n'est probablement pas toujours dans la gamme ascii visible, édition ... Fixe.

Edit2: Je n'ai pas vu qu'il devait y avoir une chance à 50/50 de supprimer un personnage, de modifier à nouveau ... Je crois que tout est en ordre maintenant :).

Perl 6 ,  78  67 octets

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

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

Essayez-le

Explication:

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

smO,XdOTOr;\~.DdOTcQT

Essayez-le en ligne ici .

Python 3 , 75 octets

Le 75 octets applique la transformation au premier caractère de chaque groupe, et ne choisit que parmi 2 caractères aléatoires, comme dans la réponse Jelly (que OP a permis):

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

Essayez-le en ligne!

Il s'agit d'une fonction récursive qui, à chaque itération, n'ajoute rien 'a', ou 'b', et s'appelle ensuite avec les 10 premiers caractères coupés. L'itération finale court-circuite à s and(une chaîne vide est fausse), évitant une récursion infinie.

Le résultat de tous les appels séparés est ensuite concaténé et renvoyé au contexte qui a appelé la fonction.

120 octets

Bien sûr, cela ressemble un peu à de la triche, alors en voici une qui est complètement aléatoire:

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

Essayez-le en ligne!

Gelée , 15 14  13 octets 13 caractères

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

TryItOnline!

Remplace ou supprime le premier des dix caractères, y compris celui des 1 à 9 derniers, s'il existe un tel morceau. Choisit parmi le sous-ensemble, certes petit, de caractères 1:; 2.

Comment?

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

Pour choisir parmi tous les ASCII imprimables plutôt que juste 1et 2(toujours en remplaçant ou supprimant le 1er caractère de chaque bloc) en 21 octets:

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

Pour une version entièrement aléatoire (suppression / remplacement 50/50, ASCII imprimable aléatoire uniforme et emplacement de caractère uniformément aléatoire dans chaque bloc), j'ai 30 octets (probablement non optimaux):

95R+31ỌX;

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

Cela fait tourner chaque morceau laissé par une quantité aléatoire, fait sauter le dernier caractère et appelle ensuite un aléatoire parmi les deux premiers liens, dont l'un est vide et l'autre qui concatène avec un caractère ASCII imprimable aléatoire; il fait ensuite tourner à nouveau le morceau vers la droite.

Python3, 188 186 184 114 caractères

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

Semble trop long. Pourrait probablement être raccourci beaucoup avec un lambda.

Apparemment, l'OP a permis de choisir le caractère aléatoire dans une liste de deux caractères et l'index du caractère à remplacer peut être une constante. Après les modifications, ma réponse aurait ressemblé exactement à la soumission @FlipTacks Python, c'est donc le formulaire avec lequel je reste.

@FlipTack a enregistré 5 octets!

Clojure, 135 139 octets

Modifier: J'ai oublié d'utiliser à la partition-allplace 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)))))

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

Man ces noms de fonctions sont longs ... Quoi qu'il en soit, il divise l'entrée en partitions de 10 caractères, les divise au point aléatoire en deux moitiés, injecte au hasard une chaîne vide ou un caractère aléatoire entre eux et supprime le premier caractère de la 2e moitié.

Mathematica 133 octets (129 caractères)

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

76 caractères pour écrire les noms de 8 fonctions: /

L'utilisation de la ⌊..⌋place de Floor[]sauvegarde 5 caractères, 1 octet.

Python 3, 129 octets

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

Afin d'économiser quelques octets, au lieu d'importer le module aléatoire de Python, je viens de faire quelques opérations modulo sur l'id de la chaîne, qui devrait être différente à chaque fois. Par exemple, le programme décidera de supprimer ou non un caractère ou de le remplacer selon qu'il id(string)//10est pair ou non (je divise l'entier par 10 car le dernier chiffre sera toujours pair).