受此CR问题的启发 ^{（请不要因为浏览CR而杀死我）}

规格

拼错单词的可能性为：

1/3的时间不改变输出
1/3的时间删除随机字符
1/3的时间重复一个随机字符

对于所有字符，在输入中删除/复制给定字符的机会应相同。

如果两个连续的字符相同（区分大小写），则其中一个被修改的概率应与一个字符相同。即AA（AA或A或AAA）的输出都应具有相同的概率。

为了简单起见，输入将仅包含字母。

例子

输入第一行，随后几行都是可能的拼写错误。每行应具有相同的输出概率，示例中将输入排除在外，但仍应有1/3的输出概率。

foo

fo
oo
ffoo
fooo

PPCG

PPC
PPG
PCG
PPPCG
PPCCG
PPCGG

code-golf string random

— 下山羊
source

这是一个很好的挑战，但是如果每行的输出概率相同，这是否意味着单词保持不变的可能性不是1/3？

— 价值墨水

@ValueInk好的，这是示例的缺陷。让我修复

— Downgoat

3

等一下，如果每行输出的可能性相同，那么字符分布会不均匀吗？就像，使用foo：一起删除一个字符可能会变成（-f）oo，f（-o）o和fo（-o）。所以fo应该是的两倍oo，但是您说每一行都有相等的概率。

— Deusovi '16

2

@ Deusovi有整段说明，我将在这里复制以防万一

If two consecutive characters are the same (case-sensitive), the probability of one of them being modified should be the same as if they are one character. I.e. the outputs for AA (which are AA or A or AAA) should all have the same probability.

— edc65 '16

1

@DJMcMayhem不，通常会误输入多个字符；

— Downgoat '16

5

点，38 27字节

a@:`(.)\1*`YRR#aa@y@0X:RR3a

这很有趣-不能使用Pip的正则表达式和可变字符串功能，而我有一段时间没有退出。通过命令行参数获取输入。

说明：

a@:`(.)\1*`                  Split a into runs of identical chars using regex match
           YRR#a             Yank randrange(len(a)) into y (randomly choosing one such run)
                a@y@0        Take the first character of that run
                     X:RR3   Modify in place, string-multiplying by randrange(3):
                               If RR3 is 0, character is deleted
                               If RR3 is 1, no change
                               If RR3 is 2, character is duplicated
                          a  Output the modified a

在线尝试！

— DLosc
source

1

哇，

— 恭喜

3

Ruby，64 55 +1（`p`标志）= 56字节

输入是通过管道插入的STDIN行，没有尾随换行符。

a=[]
gsub(/(.)\1*/){a<<$&}
a.sample[-1]*=rand 3
$_=a*''

— 价值墨水
source

2

CJam（21字节）

re`_,mr_2$=3mr(a.+te~

在线演示

解剖

r     e# Read a line of input from stdin
e`    e# Run-length encode it
_,mr  e# Select a random index in the RLE array
_     e# Hang on to a copy of that index
2$=   e# Copy the [run-length char] pair from that index
3mr(  e# Select a uniformly random integer from {-1, 0, 1}
a.+   e# Add it to the run-length
t     e# Replace the pair at that index
e~    e# Run-length decode

— 彼得·泰勒
source

2

JavaScript（ES6），107

w=>(r=x=>Math.random()*x|0,a=w.match(/(.)\1*/g),a[p=r(a.length)]=[b=a[p],b+b[0],b.slice(1)][r(3)],a.join``)

少打高尔夫球

w=>(
  a = w.match(/(.)\1*/g),
  r = x => Math.random()*x | 0,
  p = r(a.length),
  b = a[p],
  a[p] = [b, b+b[0], b.slice(1)][r(3)],
  a.join``
)

测试

f=w=>(r=x=>Math.random()*x|0,a=w.match(/(.)\1*/g),a[p=r(a.length)]=[b=a[p],b+b[0],b.slice(1)][r(3)],a.join``)

function update() { 
  O.innerHTML = Array(99)
  .fill(I.value)
  .map(x=>(
    r=f(x),
    r==x?r:r.length<x.length?'<b>'+r+'</b>':'<i>'+r+'</i>'
  
    )
  ).join` `
}

update()

#O { width:90%; overflow: auto; white-space: pre-wrap}

<input id=I oninput='update()' value='trolley'><pre id=O></pre>

展开摘要

— edc65
source

2

Java 7中，189个 180 178字节

import java.util.*;String c(String i){Random r=new Random();int x=r.nextInt(2),j=r.nextInt(i.length());return x<1?i:i.substring(0,j-(x%2^1))+(x<2?i.charAt(j):"")+i.substring(j);}

非高尔夫球和测试用例：

在这里尝试。

import java.util.*;
class M{
  static String c(String i){
    Random r = new Random();
    int x = r.nextInt(2),
        j = r.nextInt(i.length());
    return x < 1
            ? i
            : i.substring(0, j - (x%2 ^ 1)) + (x<2?i.charAt(j):"") + i.substring(j);
  }

  public static void main(String[] a){
    for(int i = 0; i < 5; i++){
      System.out.println(c("foo"));
    }
    System.out.println();
    for(int i = 0; i < 5; i++){
      System.out.println(c("PPCG"));
    }
  }
}

可能的输出：

foo
fooo
foo
foo
ffoo

PPCCG
PPCG
PPCCG
PPPCG
PPCG

— 凯文·克鲁伊森
source

1

Python 2，134字节

from random import*
def f(s):
 p=c=0;M,L=[],list(s)
 for t in L:
  if t!=p:M+=c,;p=t
  c+=1
 L[choice(M)]*=randint(0,2);return''.join(L)

for循环中的空格是制表符。

在Ideone上尝试

— Neorej
source

1

Pyth-17个字节

这实际上可以正确处理带有连续字符的特殊情况。

 XZOKrz8Or_1 2r9K

测试套件。

— 马尔蒂森
source

这是16个字节？前导空间正确吗？如果不是15个字节？

— Downgoat

@Downgoat不，前导空间正确。我很确定它的17个字节。

— Maltysen '16

1

APL，21

{⍵/⍨3|1+(?3)×(⍳=?)⍴⍵}

首先创建一个随机位置为1的零向量。然后将其乘以1到3之间的一个随机数。+1和mod 3获得一个全为1且一个随机位于0,1或2的向量。

最后，⍵/⍨表示每个字母应被写入n次，其中n是向量中的数字。

在tryapl.org上尝试

— 莫里斯·祖卡（Moris Zucca）
source

0

Python 2，123字节

from random import*
R=randint
s=input()
m=n=R(0,len(s)-1)
c=R(0,2)
m=[m,1+[-len(s),m][m>0]][c==1]
n+=c==2
print s[:m]+s[n:]

— 卡尔·纳普夫
source

0

JavaScript（ES6），103

w=>{w=w.split(''),r=Math.random,x=r(),i=r()*w.length|0;w.splice(i,x<.6,x>.3?w[i]:'');alert(w.join(''))}

— 斯拉克
source

0

APL，27个字节

{⍵/⍨(?3)⌷1⍪2 0∘.|1+(⍳=?)⍴⍵}

说明：

                        ⍴⍵  ⍝ length of ⍵
                   (⍳=?)    ⍝ bit vector with one random bit on 
                 1+         ⍝ add one to each value (duplicate one character)
           2 0∘.|           ⍝ mod by 2 and 0 (remove instead of duplicate)
         1⍪                 ⍝ add a line of just ones (do nothing)
    (?3)⌷                   ⍝ select a random line from that matrix
 ⍵/⍨                        ⍝ replicate characters in ⍵

测试：

      {⍵/⍨(?3)⌷1⍪2 0∘.|1+(⍳=?)⍴⍵} ¨ 10/⊂'foo'
 fooo  foo  oo  foo  fo  fo  oo  fo  oo  fooo

— 马里纳斯
source

随机拼错一个词

规格

例子