Ich habe Text geschrieben, aber er sieht zu professionell aus. Ich möchte, dass es so aussieht, als wäre ich wirklich müde, als ich es geschrieben habe. Sie müssen einige Tippfehler einfügen.

Ihre Herausforderung besteht darin, eine beliebige einzelne Textzeile zu verwenden und Tippfehler hinzuzufügen. Dies bedeutet, dass für jeden Charakter eine 10% ige Chance besteht, dass er typisiert wird.

Die Definition von "typofied" ist, dass Sie (nach dem Zufallsprinzip) eine der folgenden Optionen auswählen müssen:

• Dupliziere das Zeichen.
• Löschen Sie den Charakter.

• Verschieben Sie das Zeichen um eine Stelle auf der Tastatur. Die "Tastatur" ist definiert als:

  qwertyuiop
  asdfghjkl
   zxcvbnm
  

  Für die Zeichenverschiebung müssen Sie ein Leerzeichen nach oben, unten, links oder rechts gehen. Dies muss zufällig ausgewählt werden. Die Umschaltoption gilt nur für alphabetische Zeichen. Koffer muss aufbewahrt werden. Seien Sie vorsichtig mit Edge-Cases, wie m!

Die Definition von "zufällig" ist, dass das Ergebnis nicht vorhersehbar sein darf (durch Betrachten früherer Ergebnisse). Beispielsweise können Sie nicht jedes zehnte Zeichen typofysieren. Außerdem muss die Zufälligkeit gleichmäßig verteilt sein. Sie können beispielsweise nicht 30% duplizieren, 30% löschen und 40% verschieben. es muss eine 1/3-Chance für jeden sein (1/2 für jeden, wenn es sich um einen nicht-alphabetischen Charakter handelt).

Beispiel Eingabe:

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

Beispielausgabe:

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

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes.

GolfScript, 120 Zeichen

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

Der Code kann hier getestet werden .

{                      # 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 Bytes

(Es gibt nur drei Codezeilen, aber aus Gründen der Lesbarkeit habe ich Zeile 3 getrennt.)

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

Das Array von Zeichenfolgen am Anfang listet die möglichen benachbarten Tasten für jeden Buchstaben des Alphabets auf. Ich musste das "O" (neben "P") verdoppeln, um Berechnungen random()%1bei der Auswahl eines verschobenen Zeichens zu vermeiden .

Testlauf:

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

Aktualisieren:

Hier ist eine erweiterte und kommentierte Version desselben Quellcodes:

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

Rubin, 168

Mit einer Array-Indizierungsstrategie etwas kürzer:

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

Ursprüngliche Version des regulären Ausdrucks (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())

Sehr einfache Nachschlagetechnik, für einen Moment hielt ich es für billiger, die Tastatur als ungerichtetes Diagramm zu kodieren, aber der Aufwand für die Erstellung eines solchen Typs in Python erwies sich als unerschwinglich. Da die zufälligen Funktionen von Python zu aussagekräftige Namen haben, benenne ich sie choice()ausschließlich in um w. Die 10% ige Fehlerwahrscheinlichkeit wird behandelt, indem sich w([z]*9+[...])die neun Kopien eines nicht getippten Zeichens in einer Liste mit einem Tippfehler befinden.

_{-16 Zeichen - danke grc, +2 Zeichen (und Richtigkeit, viel mehr als 2 Zeichen wert) - danke Dhara}

C #, 320 Bytes (360 Bytes mit Programmumbruch)

Beinhaltet Unterstützung für "verschobene" Großbuchstaben.

Als eine Funktion (320 Bytes):

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

Als Programm, das eine Textzeile (360 Bytes) liest:

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

Eingang ausgang probe:

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

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

Algorithmus für den Keyslip:

• Zeichen in Zeichenfolge (oder Großbuchstaben) suchen
• Addiere 11, -11, 1 oder -1 zum Index.
• Wenn es ungültig ist (0 oder null), rollen Sie erneut

Nicht Golf Version auf Anfrage:

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

Laufen Sie mit -p, dann 148 + 1 = 149 Bytes. Z.B:

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.

Nicht golfen, mehr oder weniger:

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

Zuerst dachte ich, dass das zufällige Auswählen eines Elements in einem Array (von 26 Elementen unterschiedlicher Länge) statistisch sauberer (dh zufällig) ist, aber vielleicht war es falsch. (Siehe vorherige Version.) Dieser letzte Versuch folgt den Führern :-), indem Sie eine Zeichenfolge mit -1,1, -11,11 (zufällig) entlanggehen und bis zum gültigen Schritt wiederholen.

Bearbeiten: Dank der Hilfe von tobyink und anderer Optimierungen ist es uns gelungen, die Codegröße erheblich zu reduzieren.

Der letzte Ansatz verwendet einige Tricks bei der Suche nach regulären Ausdrücken, um einen gültigen Schritt entlang der Ersetzungszeichenfolge zu finden und manuelle Überprüfungen zu vermeiden.

Eine weitere Änderung: 5 Bytes aus, weil wir keine Ganzzahlen für Array-Indizes + kleiner Trick mit unzulässigem Array-Index benötigen. Ich habe den gleichen Trick mit [-4+rand@-](dh negativen Indizes) versucht und ein Listenelement entfernt, '',aber es hat nichts gespeichert.

Bearbeiten: Zurück zur Einfachheit - Ersetzen der Bedingung ~~rand 10durch rand>.1Spart 2 Bytes ...

PHP, Funktion mit 368 Bytes

Hier ist mein Versuch.

Es ist ein bisschen "Frankencode", aber es funktioniert irgendwie .

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

Ein "lesbarer" Code:

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

Der einzige Unterschied zwischen den beiden Codes besteht darin, dass man Tonnen von Tabulatoren und Zeilenumbrüchen hat.

Es erzeugt nicht genau die gleiche Art von "Falschheit", löscht oder ersetzt jedoch ein Zeichen unter den genannten Bedingungen.

Sie können es unter http://writecodeonline.com/php/ ausprobieren .

Kopieren Sie diesen Code und fügen Sie ihn ein:

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

Bitte sagen Sie mir nach dem Testen, ob es sich um eine gültige Antwort handelt.

C #, 581 Bytes

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

und in einem besser lesbaren Format:

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 Zeichen

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

Und eine besser lesbare und kommentierte Version:

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

Könnte noch verbessert werden, nehme ich an.

-2, -3 dank Ismael Miguel

Java (475 Byte)

Dies ist mein Versuch in der ausführlichen Sprache, die Java ist. Das Abrufen von Zufallszahlen ist in Java ziemlich lang und das Mapping ist nicht wirklich effizient. Es kann wahrscheinlich verbessert werden.

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

Verwendungszweck:

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

Unkomprimiert, Auszeichnungen hinzugefügt:

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 Bytes

Die Eingabe muss als Kommandozeilenparameter angegeben werden, die Ausgabe als Fehlermeldung.

Golf Version

loop, parse, 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 & le; 3: 2), z =
wenn r (10)! = 10 {
h. = a
fortsetzen
}
für x, y in k
z: = y = a? x: z
wenn q = 1
h. = aa
wenn q = 3
{
Schleife{
t: = r (4), w: = z + (t = 1 - 20: t = 2 - 20: t = 3 - 1: -1)
} bis k.HasKey (w)
h. = k [w]
}
}
wirf% h
r (n) {
Zufällig, w, 1, n
Rückkehr w
}

Ungolfing und kommentierte Version (der Unterschied besteht darin, dass diese Version mehr Leerzeichen enthält und die Variablenzuweisungen aus Gründen der Lesbarkeit in separaten Zeilen stehen.)

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"}
loop, parse, 1
{
    a: = A_LoopField
    ; Erhalte eine Zufallszahl von 1-10 und überprüfe, ob es 10 ist
    ; Wenn dies nicht der Fall ist, überspringen Sie den Rest dieser Iteration
    wenn r (10)! = 10
    {
        h. = a
        fortsetzen
    }

    ; Überprüfen Sie, ob sich das aktuelle Zeichen im k befindet
    z =
    für x, y in k
        z: = y = a? x: z

    Wählen Sie eine Zufallszahl, um zu entscheiden, was für ein Tippfehler gemacht werden soll
    q: = r (z & le; 3: 2)
    wenn q = 1
        h. = aa; dupliziere den Schlüssel
    wenn q = 3
    {
        ; das Keyboard-Array wird so eingerichtet, dass durch Addieren oder Subtrahieren
        ; 20 Vom Index aus bewegen Sie sich eine Zeile nach oben oder unten
        ; und durch Addieren oder Subtrahieren von 1 bewegen Sie sich nach rechts oder links
        ; dann müssen Sie nur noch prüfen, ob der Index angepasst wurde
        ; ist gültig
        Schleife
        {
            t: = r (4)
            w: = z + (t = 1 - 20: t = 2 - 20: t = 3 - 1: -1)
        } bis wenn k.HasKey (w)
        h. = k [w]
    }
}
; Den String als Fehlermeldung anzeigen
wirf% h
r (n)
{
    Zufällig, w, 1, n
    Rückkehr w
}