텍스트를 썼지 만 너무 전문적으로 보입니다. 글을 쓸 때 정말 피곤한 것처럼 보이게 만들고 싶습니다. 오타를 삽입해야합니다.

당신의 도전은 임의의 한 줄의 텍스트를 취하고 오타를 추가하는 것입니다. 즉, 각 캐릭터마다 10 % 확률로 오타가 발생할 수 있습니다.

"typofied"의 정의는 다음 중 하나를 무작위로 선택해야한다는 것입니다.

• 캐릭터를 복제하십시오.
• 캐릭터를 삭제하십시오.

• 문자를 하나의 키보드 공간으로 이동하십시오. "키보드"는 다음과 같이 정의됩니다.

  qwertyuiop
  asdfghjkl
   zxcvbnm
  

  문자 이동의 경우 한 칸 위, 아래, 왼쪽 또는 오른쪽으로 이동해야합니다. 임의로 선택해야합니다. shift 옵션은 알파벳 문자에만 적용됩니다. 케이스는 보존해야합니다. m! 와 같은 모서리 케이스에주의하십시오 .

"무작위"의 정의는 이전 결과를보고 결과를 예측할 수 없어야한다는 것입니다. 예를 들어 10 번째 문자마다 오타를 입력 할 수 없습니다. 또한 임의성은 균일 한 분포를 가져야합니다. 예를 들어, 30 % 복제, 30 % 삭제 및 40 % 이동을 수행 할 수 없습니다. 각각에 대해 1/3 확률이어야합니다 (비 알파벳 문자 인 경우 각각 1/2).

입력 예 :

This is some correct text. It is too correct. Please un-correctify it.

출력 예 :

This iissome xorreect tex..  It is too coteect. Please jn-corretify it.

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 승리합니다.

GolfScript, 120 자

{10{rand}:R~!{[{.}{;}{Z\?[.(.10-@).10+]{Z=}%' '-.,R=}]'QWERTYUIOP ASDFGHJKL  ZXCVBNM'' '22*11/*.{32|}%+:Z 2$?0>2+R=~}*}%

코드는 여기에서 테스트 할 수 있습니다 .

{                      # loop over all characters
  10{rand}:R~!         # take random number [0..9] and negate (i.e. 10% chance of true)
  {                    # {...}* is the if-block
    [                  # Three possible operations (code blocks) in the arry
      {.}              # a) duplicate
      {;}              # b) delete
      {                # c) shift
        Z              #      Z is the keyboard layout (see below)
        \?             #      Find the index of the current letter
        [.(.10-@).10+] #      Calculate index of letter left, right, above, below
        {Z=}%          #      Extract the corresponding letters for indices
        ' '-           #      Remove any spaces
        .,R=           #      Take random item
      }
    ]
                       # Z is the keyboard layout (upper and lower case)
                       # with enough spaces around
    'QWERTYUIOP ASDFGHJKL  ZXCVBNM'' '22*11/*.{32|}%+:Z
    2$?0>              # Is the current letter contained in Z and not a space?
    2+                 # Add 2 (i.e. 3 for letters, 2 for any other char)
    R=                 # Take a random code block from above
    ~                  # Execute the block
  }*
}%

C, 358 바이트

(코드는 3 줄 밖에 없지만 가독성을 위해 3 줄을 나누었습니다.)

#define x putchar
#define y random()
c,n;main(){char*s[26]={"QS","HNV","FVX","EFSX","DRW","CDGR","FHTV","BGJY","KOU","HKNU",
"IJLM","KO","KN","BJM","ILP","OO","AW","EFT","ADWZ","GRY","IJY","BCG","ESQ","CDZ","HTU",
"SX"};while((c=getchar())>0){if(y%10>0&&x(c))continue;if(isalpha(c)&&y%3<1){n=(c&31)-1;
x(s[n][y%strlen(s[n])]|(c&32));continue;}if (y&1)x(x(c));}}

시작 부분의 문자열 배열은 알파벳의 각 문자에 대해 가능한 인접 키를 나열합니다. random()%1이동 문자를 선택할 때 계산을 피하기 위해 "O"( "P"에 인접)를 두 배로 늘려야했습니다.

시운전 :

$ echo "This is some correct text. It is too correct. Please un-correctify it." |./a.out
This is some  cofrect teext. It is too correct.. Plleaase un-correctify it..

최신 정보:

다음은 동일한 소스 코드의 확장 및 주석 처리 된 버전입니다.

#include <stdio.h>
#include <string.h>
/* ^^ These should be included, but the code compiles without them */

int c,n;

void main() {

  /* Adjacent keys for each letter of the alphabet (A, B, C, ..., Z): */
  char *s[26] = { "QS","HNV","FVX","EFSX","DRW","CDGR","FHTV","BGJY","KOU","HKNU",
                  "IJLM","KO","KN","BJM","ILP","OO","AW","EFT","ADWZ","GRY","IJY",
                  "BCG","ESQ","CDZ","HTU","SX" };

  /* Fetch input until null character or EOF reached */
  while ((c=getchar())>0) {

    /* For 90% of the time, just echo the character unchanged */
    if (random()%10>0 && putchar(c)) continue;

    /* If it's a letter of the alphabet, shift with 33% probability */
    if (isalpha(c) && random()%3<1) {
      /* Calculate offset to adjacent keys data */
      n=(c&31)-1;
      /* Choose a random adjacent key, and change to lower case if needed */
      putchar(s[n][random()%strlen(s[n])]|(c&32));
      continue;
    }

    /* If we reach this point, either we didn't fetch an alphabet character, or   */
    /* we did but chose not to shift it. Either way, we now need to either repeat */
    /* the character or delete it, with 50% probability for each. */

    /* This repeats the character by printing the return value from putchar() */
    if (random()&1) putchar(putchar(c));

    /* To delete the character, we don't have to do anything. */
  }
}

루비, 168

배열 인덱싱 전략을 사용하면 약간 더 짧습니다.

z='qwertyuiop.asdfghjkl...zxcvbnm'+?.*11
gets.chars{|c|$_=z[c]?z:z.upcase
h=[1,-1,11,-11].map{|d|$_[d+~/#{c}/]}-[?.]rescue[]
$><<(rand<0.9?c:[c*2,'',*h.sample].sample)}

원래 정규식 버전 (184) :

s='.qwertyuiop.asdfghjkl...zxcvbnm.'
gets.chars{|c|c=~/\w/&&(s[c]?s: s.upcase)=~/((\w).{9})?((\w)|.)#{c}((\w)|.)(.{9}(\w))?/
$><<(rand<0.9?c:[c*2,'',*[*$2,*$4,*$6,*$8].sample].sample)}

파이썬, 251

from random import*
w=choice
o=ord
print"".join(w([z]*9+[w(["",z*2]+[chr(o(w("DGRC FHTV GJYB UOK HKUN JLIM KO NK BMJ IPL O WA ETF ADWZ RYG YIJ CBG QES ZCD TUH XS SQ VNH XVF SFEX WRD".split()[(o(z)&31)-6]))|o(z)&32)]*z.isalpha())])for z in raw_input())

매우 간단한 조회 기술, 잠시 동안 키보드를 무 방향 그래프로 인코딩하는 것이 더 저렴할 것이라고 생각했지만 파이썬에서 이러한 유형을 만드는 오버 헤드는 엄청났습니다. 파이썬의 임의 함수에는 너무 설명적인 이름이 있으므로 choice()독점적으로 사용하여 이름을로 바꿉니다 w. w([z]*9+[...])오타가없는 문자의 9 개 사본이 오타가 하나 인 목록 에 있는 경우 10 %의 오류 확률이 처리됩니다 .

_{-16 자 --grc 감사, +2 자 (정확도, 2 자 이상 가능)-Dhara에게 감사합니다}

C #, 320 바이트 (프로그램 랩핑이있는 360 바이트)

"shifted"대문자 지원을 포함합니다.

함수 (320 바이트) :

string T(string s){
    string t="",z="      ",k=z+z+"qwertyuiop asdfghjkl   zxcvbnm";
    k+=k.ToUpper()+z+z;
    int[]m={-11,-1,1,11};
    var r=new System.Random();
    foreach(var c in s){
        if(r.Next(10)>0)
            t+=c;
        else{
            int i=r.Next(k.IndexOf(c)>0?3:2);
            if(i>1){
                while(' '==k[i=k.IndexOf(c)+m[r.Next(4)]]);
                t+=k[i];
            }
            else if(i>0)
                t=(t+c)+c;
        }
    }
    return t;
}

한 줄의 텍스트 (360 바이트)를 읽는 프로그램으로 :

using System;
class P{
    static void Main(){
        string t="",z="      ",k=z+z+"qwertyuiop asdfghjkl   zxcvbnm";
        k+=k.ToUpper()+z+z;
        int[]m={-11,-1,1,11};
        var r=new Random();
        foreach(var c in Console.ReadLine()){
            if(r.Next(10)>0)
                t+=c;
            else{
                int i=r.Next(k.IndexOf(c)>0?3:2);
                if(i>1){
                    while(' '==k[i=k.IndexOf(c)+m[r.Next(4)]]);
                    t+=k[i];
                }
                else if(i>0)
                    t=(t+c)+c;
            }
        }
        Console.Write(t);
    }
}

입력 출력 샘플 :

This is some correct text. It is too correct. Please un-correctify it.
This  is some corrrect texy. Ut is too correct. Pease un-coorrectify it.

TYPO RAGE CAPS TEXT!
TYPPORAGE CAOS TEX!

JS, 303 , 288 , 275 , 273 , 274 (버그 수정)

function z(s){return s.split('').map(function(d){if((r=Math.random)(b='qwertyuiop0asdfghjkl000zxcvbnm')>.1)return d
if((c=r(x=(d>'`'?b:(b=b.toUpperCase())).indexOf(d))*(/[a-z]/i.test(d)+2))<2)return c>1?d+d:''
for(a=0;!a;)a=b[x+[11,-11,1,-1][~~(r()*4)]]
return a}).join('')}

키 슬립 알고리즘 :

• 문자열에서 문자를 찾습니다 (또는 대문자).
• 인덱스에 11, -11, 1 또는 -1을 더하십시오.
• 유효하지 않은 경우 (0 또는 null) 다시 롤

요청 당 비 골프 버전 :

function z (s) {
  return s.split('') // split input string into characters.
          .map( // and then for each character...
    function (d) {
      r = Math.random; // set up a shortened form of Math.random
      // declare keyboard here because we have parens and we can save a delimeter.
      b = 'qwertyuiop0asdfghjkl000zxcvbnm';  
      if (r() > .1) {  // normal case
        return d;
      }
      numOptions = /[a-z]/i.test(d) + 2; // if it's a character, 1+2, else 0+2 options

      // test here because we have parens. x might be -1
      if (d > '`') { 
        x = b.search(d);  // x marks the spot
      } else {
        b = b.toUpperCase();
        x = b.search(d);
      }

      c = r() * numOptions; // chars can be 0-3, non-chars: 0-2
      if (c < 2) {                // this case is simple, so it comes first
        return c>1 ? d + d : ''; // double or omit.
      }

      // we must be in keyslip mode.

      // in the golfed code, this while loop become for loops, 
      // but it's really a while.
      a = 0;
      while (!a) { // that is, a != null && a != 0
        v = ~~(r() * 4); // 0, 1, 2, or 3
        newX = x + [11, -11, 1, -1][v]; // choose one
        a = b[newX];  // slip the key
      }
      return a;
    }
  ) // end the map function
  .join('') // and then reassemble the string
}

펄 278 239 197 169 162 156 151 149

s#((\pL)|.)#rand>.1?$&:($&x2,'',do{1until/^.{@{[(2,-10,12)[rand 4]-1+index$_=QWERTYUIOP0ASDFGHJKL000ZXCVBNM,uc($,=$&)]}}(\D)/;$,&' '|$1})[rand@-]#ge

로 실행 한 -p다음 148 + 1 = 149 바이트로 실행하십시오 . 예 :

perl -p typos.pl
Your challenge is to take an arbitrary single line of text, and add typos.
You challenge is to tale an  arbitrary singe lind of text, and add yposs.
This is some correct text. It is too correct. Please un-correctify it.
This iis some correct text. It s too coorrect.Pleqse un-correctify it.

언 골프, 다소 :

s#((\pL)|.)#rand>.1
    ? $&
    : ($&x2,'',
        do{
            1until/^.{@{[(2,-10,12)[rand 4]-1
                +index$_=QWERTYUIOP0ASDFGHJKL000ZXCVBNM,uc($,=$&)]}}(\D)/;
            $,&' '|$1
        }
    )[rand@-]
#ge

처음에는 배열에서 무작위로 요소를 선택하는 것이 (길이가 다른 26 개) 더 통계적으로 '깨끗'하다고 생각했지만 잘못되었을 수 있습니다. (이전 버전을 참조하십시오.)이 마지막 시도는 다음과 같이 지시합니다 :-), 문자열을 따라 -1,1, -11,11 (임의로) 씩 밟고 유효한 단계까지 반복합니다.

편집 : tobyink 도움말 및 기타 최적화 덕분에 코드 크기를 크게 줄일 수있었습니다.

마지막 접근법은 regexp 검색과 함께 몇 가지 트릭을 사용하여 대체 문자열을 따라 유효한 단계를 찾아 수동 검사를 제거합니다.

또 다른 편집 : 배열 인덱스에는 정수가 필요하지 않기 때문에 5 바이트가 꺼짐 + 잘못된 배열 인덱스가있는 작은 트릭. [-4+rand@-]음수 인덱스 와 동일한 트릭을 시도 하고 하나의 목록 요소를 제거 '',했지만 아무것도 저장하지 않았습니다.

편집 : 단순으로 돌아 가기-조건 ~~rand 10을 rand>.12 바이트 절약으로 대체 ...

PHP, 368 바이트 기능

여기 내 시도가 있습니다.

"frankencode"이지만 약간 작동합니다.

function _($m){$q=array(array('qwertyuiop','asdfghjkl',' zxcvbnm'),'!.-,;?+/');$r='mt_rand';foreach(str_split($m)as$k=>$c)if(!$r(0,9)&&$c!=' ')foreach($q[0]as$x=>$y)if(($z=strpos($y,$c))!==!1){switch($t=$r(-3,2-($z>>3)-($x>>1))){case 2:++$z;break;case 1:++$x;break;case -1:--$x;break;case -2:--$z;break;case -3:$z=8;break;}$m[$k]=$t?$q[0][$x][$z]:$q[1][$z];}return$m;}

보다 "읽기 쉬운"코드 :

function _($m)
{
    $q=array(array('qwertyuiop','asdfghjkl',' zxcvbnm'),'!.-,;?+/');
    $r='mt_rand';
    foreach(str_split($m)as$k=>$c)
        if(!$r(0,9)&&$c!=' ')
            foreach($q[0]as$x=>$y)
                if(($z=strpos($y,$c))!==!1)
                {
                    switch($t=$r(-3,2-($z>>3)-($x>>1)))
                    {
                        case 2:
                            ++$z;break;
                        case 1:
                            ++$x;break;
                        case -1:
                            --$x;break;
                        case -2:
                            --$z;break;
                        case -3:
                            $z=8;break;
                    }
                    $m[$k]=$t?$q[0][$x][$z]:$q[1][$z];
                }
    return$m;
}

두 코드의 유일한 차이점은 하나의 탭과 줄 바꿈이 있다는 것입니다.

동일한 유형의 "잘못된"유형을 생성하지는 않지만 해당 조건을 사용하여 문자를 삭제하거나 대체합니다.

http://writecodeonline.com/php/ 에서 시도해보십시오 .

이 코드를 복사하여 붙여 넣습니다.

function _($m){$q=array(array('qwertyuiop','asdfghjkl',' zxcvbnm'),'!.-,;?+/');$r='mt_rand';foreach(str_split($m)as$k=>$c)if(!$r(0,9)&&$c!=' ')foreach($q[0]as$x=>$y)if(($z=strpos($y,$c))!==!1){switch($t=$r(-3,2-($z>>3)-($x>>1))){case 2:++$z;break;case 1:++$x;break;case -1:--$x;break;case -2:--$z;break;case -3:$z=8;break;}$m[$k]=$t?$q[0][$x][$z]:$q[1][$z];}return$m;}
echo _('This is some correct text. It is too correct. Please un-correctify it.');

테스트 후 올바른 답변인지 알려주세요.

C #, 581 바이트

using System;class B{static void Main(){var z=Console.ReadLine();var r=new Random();foreach(char C in z){String o;if(r.Next(10)==0){int w=r.Next(3);o=w==0?C+""+C:w==1?"":f(C,r);}else{o=C+"";}Console.Write(o);}Console.ReadLine();}static string f(char C,Random r){string[]k={"00000000000","0qwertyuiop0","0asdfghjkl0","00zxcvbnm0","000000000"};char L=char.ToLower(C);char h='0';for(int i=1;i<4;i++){var d=k[i].IndexOf(L);if(d!=-1){while(h=='0'){int n=r.Next(4);h=n==0?k[i][d-1]:n==1?k[i][d+1]:n==2?k[i-1][d]:k[i+1][d];}h=char.IsUpper(C)?char.ToUpper(h):h;return h+"";}}return C+"";}}

더 읽기 쉬운 형식으로 :

using System;

class A
{
    static void Main()
    {
        var z = Console.ReadLine();
        var r = new Random();

        foreach (char C in z)
        {
            String o;

            if (r.Next(10) == 0)
            {
                int w = r.Next(3);
                o = w == 0 ? C + "" + C :
                    w == 1 ? "" :
                             f(C, r);
            }
            else
            {
                o = C + "";
            }

            Console.Write(o);
        }
    }

    static string f(char C, Random r)
    {
        string[] k = {
                            "00000000000", 
                            "0qwertyuiop0", 
                            "0asdfghjkl0", 
                            "00zxcvbnm0", 
                            "000000000"};  
        char L = char.ToLower(C);
        char h = '0';

        for (int i = 1; i < 4; i++)
        {
            var d = k[i].IndexOf(L);

            if (d != -1)
            {
                while (h == '0')
                {
                    int n = r.Next(4);

                    h = n == 0 ? k[i][d - 1] :
                        n == 1 ? k[i][d + 1] :
                        n == 2 ? k[i - 1][d] :
                                 k[i + 1][d];
                }
                h = char.IsUpper(C) ? char.ToUpper(h) : h;
                return h + "";
            }
        }
        return C + "";
    }
}

PHP, 326 개 320 318 315 문자

$h=array(qs,vhn,vxf,sefx,wrd,drgc,fthv,gyjb,uko,hukn,jilm,ok,nk,bjm,ilp,o,aw,etf,awdz,rgy,yji,cgb,qse,zdc,thu,sx);$a=x.$argv[1];for(;$d=$a[++$b];)echo!rand(0,9)&&($c=ord($d)-65)?(!($g=rand(0,($e=($c>-1&&$c<26)or$c>31&&$c<58)+1))?$d.$d:($g<2?"":(($j=$i[rand(0,strlen($i=$h[$c-!$e*32]))])&&$e?strtoupper($j):$j))):$d;

더 읽기 쉽고 주석이 달린 버전 :

// $a   input
// $b   char iterator
// $c   current char ascii value
// $d   current char
// $e   is uppercase
// $g   rand() output
// $h   char displacement
// $i   current character in $h
// $j   temporary var for uppercasing

// the neighbouring characters of a-z, in alphabetical (and ASCII) order
$h=array(qs,vhn,vxf,sefx,wrd,
    drgc,fthv,gyjb,uko,hukn,
    jilm,ok,nk,bjm,ilp,
    o,aw,etf,awdz,rgy,
    yji,cgb,qse,zdc,thu,
    sx);
// input from argument
$a=x.$argv[1];

for(;$d=$a[++$b];)
    echo!rand(0,9)&&($c=ord($d)-65)? /* 10% chance, read char ASCII value - 65 into $c */
        (!($g=rand(0,($e=($c>-1&&$c<26)or$c>31&&$c<58)+1))?
          /* random number from 0 to 2 (if alphabetic) or 0 to 1 stored in $g */
            $d.$d: /* double char if $g = 0 */
            ($g<2?
                "": /* omit char if $g = 1*/
                (($j=$i[rand(0,strlen($i=$h[$c-!$e*32]))])&&$e?
                  /* $j = random neighbour of the current char */
                    strtoupper($j): /* uppercase $j */
                    $j)))
        :$d; /* keep char */

여전히 향상 될 수 있다고 생각합니다.

Ismael Miguel 덕분에 -2, -3

자바 (475 바이트)

이것은 Java 인 장황한 언어로 시도한 것입니다. Java에서 난수를 얻는 것은 꽤 길며 매핑은 실제로 효율적이지 않습니다. 아마 향상 될 수 있습니다.

import static java.lang.Math.*;public class T{public static void main(String[]a){String z="",v;for(char c:a[0].toCharArray()){double g=random()*60;if(g>=6)z+=c;else{boolean u='A'<=c&c<='Z',l='a'<=c&c<='z';if(g<(l|u?2:3))z+=""+c+c;else if((l|u)&g<4){v="qs,hnv,fvx,efsx,drw,cdgr,fhtv,kou,bgjy,hknu,ijlm,ko,kn,bjm,ilp,o,aw,eft,adwz,gry,ijy,bcg,eqs,cdz,htu,sx".split(",")[u?c-'A':c-'a'];c=v.charAt((int)(random()*v.length()));z+=u?(char)(c-'a'+'A'):c;}}}System.out.println(z);}}

용법:

java T "This is some correct text. It is too correct. Please un-correctify it."

압축되지 않은 칭찬이 추가되었습니다.

import static java.lang.Math.*; // Need random()

public class T {
    public static void main(String[] a) {
        String z = "", v;
        for (char c : a[0].toCharArray()) {
            double g = random() * 60; // Compute random only once for two cases.
            if (g >= 6) {
                // 90% must be correct (accolades are stripped)
                // so we just copy the character.
                z += c;
            } else {
                // These tests come often.
                boolean u = 'A' <= c & c <= 'Z', l = 'a' <= c & c <= 'z';

                // reuse the random. g is [0,6[.
                if (g < (l | u ? 2 : 3)) { 
                    // If c is an ascii letter (l|u) then g must be [0,2[ ; if not, then g must be [0,3[.
                    // If those conditions are met, we duplicate the character
                    z += "" + c + c;
                } else if ((l | u) & g < 4) {
                    // if c is letter and g [2,4[ then we perform the wrong key event.
                    // I could not compress it using the keyboard mapping shorter in Java than expanding it like it is now.
                    v = "qs,hnv,fvx,efsx,drw,cdgr,fhtv,kou,bgjy,hknu,ijlm,ko,kn,bjm,ilp,o,aw,eft,adwz,gry,ijy,bcg,eqs,cdz,htu,sx".split(",")[u ? c - 'A' : c - 'a'];
                    // get a random character from the string.
                    c = v.charAt((int) (random() * v.length()));

                    // Keep the case of the character.
                    z += u ? (char) (c - 'a' + 'A') : c;
                } else { // if c is not an ascii letter or if g is [4,6[
                    // Do nothing. This else is stripped.
                }
            }
        }
        System.out.println(z);
    }
}

오토 핫키 441 바이트

입력은 명령 행 매개 변수로 제공되어야하며 출력은 오류 메시지로 제공됩니다.

골프 버전

루프, 구문 분석, 1
{
k : = {1 : "q", 2 : "w", 3 : "e", 4 : "r", 5 : "t", 6 : "y", 7 : "u", 8 : "i ", 9 :"o ", 10 :"p ", 21 :"a ", 22 :"s ", 23 :"d ", 24 :"f ", 25 :"g ", 26 :"h ", 27 : "j", 28 : "k", 29 : "l", 42 : "z", 43 : "x", 44 : "c", 45 : "v", 46 : "b", 47 : "n", 48 : "m"}, a : = A_LoopField, q : = r (z? 3 : 2), z =
만약 r (10)! = 10 {
h. = a
계속하다
}
k의 x, y
z : = y = a? x : z
q가 1 인 경우
h. = aa
q = 3 인 경우
{
고리{
t : = r (4), w : = z + (t = 1? 20 : t = 2? -20 : t = 3? 1 : -1)
} k.HasKey (w)까지
h. = k [w]
}
}
% h 던지기
r (n) {
랜덤, w, 1, n
w를 반환
}

ungolfed 및 주석이 달린 버전 (이 버전은 더 많은 공백이 있고 변수 할당이 가독성을 위해 별도의 행에 있다는 점이 다릅니다.)

k : = {1 : "q", 2 : "w", 3 : "e", 4 : "r", 5 : "t", 6 : "y", 7 : "u", 8 : "i ", 9 :"o ", 10 :"p ", 21 :"a ", 22 :"s ", 23 :"d ", 24 :"f ", 25 :"g ", 26 :"h ", 27 : "j", 28 : "k", 29 : "l", 42 : "z", 43 : "x", 44 : "c", 45 : "v", 46 : "b", 47 : "n", 48 : "m"}
루프, 구문 분석, 1
{
    a : = A_LoopField
    ; 1-10에서 난수를 얻고 10인지 확인하십시오.
    ; 이 반복의 나머지 부분을 건너 뛰지 않으면
    r (10)! = 10이면
    {
        h. = a
        계속하다
    }

    ; 현재 문자가 k에 있는지 확인하십시오
    z =
    k의 x, y
        z : = y = a? x : z

    ; 오타를 결정하기 위해 난수를 선택하십시오.
    q : = r (z? 3 : 2)
    q가 1 인 경우
        h. = aa; 키 복제
    q = 3 인 경우
    {
        ; 키보드 배열은 더하거나 빼서 설정됩니다
        ; 위 또는 아래로 이동하는 색인에서 20
        ; 1을 더하거나 빼면 오른쪽이나 왼쪽으로 움직입니다.
        ; 그런 다음 조정 된 색인이 있는지 확인하면됩니다.
        ; 유효하다
        고리
        {
            t : = r (4)
            w : = z + (t = 1? 20 : t = 2? -20 : t = 3? 1 : -1)
        } k.HasKey (w)까지
        h. = k [w]
    }
}
; 문자열을 오류 메시지로 표시
% h 던지기
r (n)
{
    랜덤, w, 1, n
    w를 반환
}