挑战：

读取输入（在可见的ASCII范围内）和进行一些修改的输出：

1. 在每组10个字符的输入中随机（50/50）：
   • 替换一个字符*（在可见的ASCII范围内替换为一个随机的**）（例如lumberjack成为lumbeZjack）
   • 或删除一个字符（例如lumberjack成为lmberjack）

^{*如果集合少于10个字符，则不必修改它，但是可以。
**字符可以与一个输入相同，只要它仍然是随机的即可。}

例：

输入：Go home cat! You're drunk!
输出：（Go hom cat! YouLre drunk!
仅作为示例，由于输出可能是随机的，因此请勿用作测试用例）

规则：

• 代码高尔夫球，最少字符获胜！

Pyth，27 25字节

VczTpXNOT?<JOr\ \ÞKC127JK

测试套件在这里可用。

感谢Maltysen削减了2个字节。

说明

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

通常，我觉得这有点天真，可以改进。通常我在输入解释时会发现一些明显的东西，但是这次我什么也没跳出来。

*> <>，44 46 52 50字节

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

在这里尝试！

这将在随机空间的附近/上方使用任意ascii字符。这将始终编辑第6个字符，除非它是字符串的结尾，并且该字符串的长度不是10的倍数。这有50％的机会删除第7个字符而不是编辑第6个字符。

输入值

IEEE浮点算法标准（IEEE 754）是由电气和电子工程师协会（IEEE）于1985年建立的浮点计算技术标准。该标准解决了在各种浮点实现中发现的许多问题，这些问题使它们难以可靠且便携地使用。现在，许多硬件浮点单元都使用IEEE 754标准。

输出量

浮点数算术的IEE标准（EEE 754）是技术标准！1985年由电气工程师学会（IEE％）建立的浮点计算技术。标准添加的男人！问题＃发现于他的潜水员！浮点实现”，这使它们难以可靠地进行移植和移植。许多硬件起泡点单位现在都使用“ IEEE 754”标准。

编辑：这个答案可能并不总是在可见的ascii范围内，正在编辑...已修复。

Edit2：没必要有50/50的机会删除一个字符，再次编辑...我相信现在一切都井然有序:)。

Perl 6的， 78  67个字节

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

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

尝试一下

说明：

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

smO,XdOTOr;\~.DdOTcQT

在这里在线尝试。

Python 3，75个字节

75字节将转换应用于每个组的第一个字符，并且仅从2个随机字符中进行选择，例如Jelly答案（允许使用OP）：

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

在线尝试！

这是一个递归函数，每次迭代时，都没有添加'a'，或'b'，然后以被分割的前10个字符进行调用。最终迭代在处短路s and（一个空字符串是虚假的），避免了无限递归。

然后将所有单独调用的结果连接起来，并返回到调用该函数的上下文中。

120字节

当然，这有点像作弊，所以这是完全随机的：

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

在线尝试！

果冻，15 14  13 字节 13个字符

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

TryItOnline！

如果有这样的块，则替换或删除每十个字符中的第一个，包括最后一个1-9个字符。从选，诚然小，字符的子集：1; 2。

怎么样？

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

要从21个字节中选择所有可打印的ASCII而不是just 1和2（仍替换或删除每个块的第一个字符），请执行以下操作：

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

对于完全随机的版本（50/50删除/替换，统一的随机可打印ASCII以及每个块内的统一的随机字符位置），我有30个字节（可能不是最佳）：

95R+31ỌX;

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

这会将每个块向左旋转一个随机量，弹出最后一个字符，然后调用前两个链接中的一个随机链接，其中两个链接为空，另一个链接为可打印的随机ASCII字符；然后，它再次向右旋转该块。

Python3，188 186 184 114个字符

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

似乎太长了。使用lambda可能会大大缩短。

显然，OP允许从两个字符的列表中选择随机字符，并且要替换的字符的索引可以是常数。修改后，我的答案与@FlipTacks看起来完全一样 Python提交，所以这是我要使用的形式。

@FlipTack保存了5个字节！

Clojure中，135个 139字节

编辑：忘记使用partition-all而不是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)))))

取消高尔夫：

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

这些函数的名称很长……无论如何，它将输入分成10个字符的分区，在随机点将它们分成两半，在它们之间随机注入一个空字符串或一个随机字符，并丢弃第二个一半的第一个字符。

Mathematica 133字节（129个字符）

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

76个字符写出8个函数的名称：/

使用⌊..⌋代替Floor[]可以节省5个字符，即1个字节。

Python 3，129个字节

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

为了节省一些字节，我没有导入Python的random模块，而是对字符串的id进行了一些模运算，每次都应该有所不同。例如，程序将根据是否id(string)//10为偶数来决定是否删除一个字符或替换一个字符（我将整数除以10作为最后一位将始终是偶数）。