Napisałem jakiś tekst, ale wygląda zbyt profesjonalnie. Chcę, żeby wyglądało na to, że byłem naprawdę zmęczony, kiedy to napisałem. Musisz wstawić kilka literówek.

Twoim wyzwaniem jest pobranie dowolnej pojedynczej linii tekstu i dodanie literówek. Oznacza to, że dla każdej postaci będzie 10% szans na jej typof.

Definicja „typofied” polega na tym, że musisz (losowo) wybrać jedną z następujących opcji:

• Duplikuj znak.
• Usuń znak.

• Przesuń znak o jeden klawisz na klawiaturze. „Klawiatura” jest zdefiniowana jako:

  qwertyuiop
  asdfghjkl
   zxcvbnm
  

  Aby zmienić postać, musisz przejść o jedno pole w górę, w dół, w lewo lub w prawo. Należy to wybrać losowo. Opcja przesunięcia dotyczy tylko znaków alfabetycznych. Sprawa musi zostać zachowana. Zachowaj ostrożność przy takich przypadkach, jak m!

Definicja „losowy” jest taka, że ​​wynik nie może być przewidywalny (patrząc na poprzednie wyniki). Na przykład nie możesz typofy co dziesiątej postaci. Ponadto losowość musi mieć równomierny rozkład. Na przykład nie można wykonać 30% duplikatu, 30% usunięcia i 40% przesunięcia; musi to być 1/3 szansy dla każdego (1/2 dla każdego, jeśli jest to postać niealfabetyczna).

Przykładowe dane wejściowe:

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

Przykładowe dane wyjściowe:

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

To jest golf-golf , więc wygra najkrótszy kod w bajtach.

GolfScript, 120 znaków

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

Kod można przetestować tutaj .

{                      # 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 bajtów

(Są tylko trzy wiersze kodu, ale podzieliłem wiersz 3 dla czytelności)

#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));}}

Tablica ciągów na początku zawiera listę możliwych sąsiadujących klawiszy dla każdej litery alfabetu. Musiałem podwoić „O” (sąsiadujące z „P”), aby uniknąć obliczeń random()%1przy wyborze przesuniętej postaci.

Testowe uruchomienie:

$ 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..

Aktualizacja:

Oto rozszerzona i skomentowana wersja tego samego kodu źródłowego:

#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. */
  }
}

Ruby, 168

Nieco krótszy czas przy użyciu strategii indeksowania tablic:

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

Oryginalna wersja wyrażeń regularnych (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)}

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

Bardzo prosta technika wyszukiwania, przez chwilę myślałem, że taniej byłoby zakodować klawiaturę jako niekierowany wykres, ale narzut związany z tworzeniem takiego typu w Pythonie okazał się zaporowy. Ponieważ losowe funkcje Pythona mają zbyt opisowe nazwy, używam ich choice()wyłącznie, zmieniając ich nazwę na w. 10% szansy na błąd jest obsługiwane przez miejsce, w w([z]*9+[...])którym dziewięć kopii nietypowej postaci znajduje się na liście z jedną literówką.

_{-16 znaków - dzięki grc, +2 znaki (i poprawność, warte wiele więcej niż 2 znaków) - dzięki Dhara}

C #, 320 bajtów (360 bajtów z zawijaniem programu)

Obejmuje obsługę „przesuniętych” wielkich liter.

Jako funkcja (320 bajtów):

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;
}

Jako program, który czyta wiersz tekstu (360 bajtów):

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);
    }
}

Próbka wyjściowa wejściowa:

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 (naprawa błędów)

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

Algorytm dla klucza:

• znajdź znak w ciągu (lub wielkimi literami)
• dodaj 11, -11, 1 lub -1 do indeksu.
• jeśli jest niepoprawny (0 lub zero), przerzuć ponownie

Wersja bez gry w golfa na żądanie:

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
}

Perl, 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

Uruchom z -p, a następnie 148 + 1 = 149 bajtów. Na przykład:

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.

Bez golfa, mniej więcej:

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

Na początku myślałem, że losowy wybór elementu w tablicy (26 z nich o różnych długościach) jest bardziej statystycznie „czysty” (tj. Losowy), ale być może był zły. (Zobacz poprzednią wersję.) Ta ostatnia próba polega na podążaniu za liderami :-), przechodzeniu wzdłuż ciągu przez -1,1, -11,11 (losowo) i powtarzaniu do poprawnego kroku.

Edycja: Dzięki pomocy tobyink i innym optymalizacjom udało nam się znacznie zmniejszyć rozmiar kodu.

Ostatnie podejście wykorzystuje kilka sztuczek z wyszukiwaniem wyrażenia regularnego, aby znaleźć prawidłowy krok wzdłuż łańcucha podstawienia, eliminując ręczne sprawdzanie.

Kolejna edycja: 5 bajtów wyłączone, ponieważ nie potrzebujemy liczb całkowitych do indeksów tablic + mała sztuczka z niedozwolonym indeksem tablic. Próbowałem tej samej sztuczki z [-4+rand@-](tj. Indeksami ujemnymi) i pozbyłem się jednego elementu listy, '',ale niczego nie zapisałem.

Edit: Powrót do prostoty - zastępując warunek ~~rand 10z rand>.1oszczędza 2 bajty ...

PHP, funkcja z 368 bajtami

Oto moja próba.

To trochę „frankencode”, ale to trochę działa.

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;}

Bardziej „czytelny” kod:

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;
}

Jedyną różnicą między 2 kodami jest to, że ma się mnóstwo zakładek i znaków nowej linii.

Nie wywołuje dokładnie tego samego rodzaju „nieprawidłowości”, ale usuwa lub zastępuje znak przy użyciu tych warunków.

Możesz spróbować na http://writecodeonline.com/php/ .

Skopiuj i wklej ten kod:

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.');

Po przetestowaniu proszę powiedzieć, czy jest to poprawna odpowiedź.

C #, 581 bajtów

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+"";}}

i w bardziej czytelnym formacie:

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 znaków

$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;

I bardziej czytelna i skomentowana wersja:

// $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 */

Przypuszczam, że wciąż można to poprawić.

-2, -3 dzięki Ismael Miguel

Java (475 bajtów)

To jest moja próba w pełnym języku, jakim jest Java. Pobieranie liczb losowych w Javie jest dość długie, a mapowanie nie jest tak naprawdę wydajne. Prawdopodobnie można to poprawić.

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);}}

Stosowanie:

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

Nieskompresowane, dodano wyróżnienia:

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);
    }
}

AutoHotkey 441 bajtów

Dane wejściowe należy podać jako parametr wiersza polecenia, dane wyjściowe podano jako komunikat o błędzie.

Wersja golfowa

pętla, parsowanie, 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 =
jeśli r (10)! = 10 {
h. = a
dalej
}
dla x, yw k
z: = y = a? x: z
jeśli q = 1
h. = aa
jeśli q = 3
{
Pętla{
t: = r (4), w: = z + (t = 1? 20: t = 2 a -20: t = 3 a 1: -1)
} do k.HasKey (w)
h. = k [w]
}
}
rzuć% h
r (n) {
Losowo, w, 1, n
powrót w
}

Wersja bez gry w golfa i z adnotacjami (różnica polega na tym, że ta wersja ma więcej białych znaków i przypisania zmiennych znajdują się w osobnych wierszach w celu zapewnienia czytelności).

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”}
pętla, parsowanie, 1
{
    a: = A_LoopField
    ; zdobądź losową liczbę od 1 do 10 i sprawdź, czy jest to 10
    ; jeśli nie pominie reszty tej iteracji
    jeśli r (10)! = 10
    {
        h. = a
        dalej
    }

    ; sprawdź, czy obecny znak jest w k
    z =
    dla x, yw k
        z: = y = a? x: z

    ; wybierz liczbę losową, aby zdecydować, jaką literówkę zrobić
    q: = r (z? 3: 2)
    jeśli q = 1
        h. = aa; zduplikuj klucz
    jeśli q = 3
    {
        ; tablica klawiatury jest skonfigurowana tak, aby dodawać lub odejmować
        ; 20 od indeksu przesuwasz się w górę lub w dół o rząd
        ; a dodając lub odejmując 1, przesuwasz się w prawo lub w lewo
        ; musisz tylko sprawdzić, czy skorygowany indeks
        ; jest ważna
        Pętla
        {
            t: = r (4)
            w: = z + (t = 1? 20: t = 2 a -20: t = 3? 1: -1)
        } dopóki if k.HasKey (w)
        h. = k [w]
    }
}
; wyświetl ciąg jako komunikat o błędzie
rzuć% h
r (n)
{
    Losowo, w, 1, n
    powrót w
}