J'ai écrit du texte, mais il a l'air trop professionnel. Je veux faire croire que j'étais vraiment fatigué quand je l'ai écrit. J'ai besoin que tu insères des fautes de frappe.

Votre défi consiste à prendre une ligne de texte arbitraire et à ajouter des fautes de frappe. Cela signifie que pour chaque personnage, il y aura 10% de chances qu'il soit typofié.

La définition de "typofied" est que vous devez choisir (au hasard) l'un des éléments suivants:

• Dupliquer le personnage.
• Supprimer le personnage.

• Décale le caractère d'un espace clavier. Le "clavier" est défini comme:

  qwertyuiop
  asdfghjkl
   zxcvbnm
  

  Pour le changement de personnage, vous devez aller d'un espace vers le haut, le bas, la gauche ou la droite. Cela doit être choisi au hasard. L'option shift ne s'applique qu'aux caractères alphabétiques. Le cas doit être préservé. Soyez prudent avec les cas de bord, comme m!

La définition de "aléatoire" est que le résultat ne doit pas être prévisible (en regardant les résultats précédents). Par exemple, vous ne pouvez pas écrire tous les dix caractères. De plus, le caractère aléatoire doit avoir une distribution égale. Par exemple, vous ne pouvez pas effectuer 30% de duplication, 30% de suppression et 40% de décalage; il doit y avoir 1/3 de chance pour chacun (1/2 pour chacun s'il s'agit d'un personnage non alphabétique).

Exemple d'entrée:

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

Exemple de sortie:

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

C'est du code-golf , donc le code le plus court en octets va gagner.

GolfScript, 120 caractères

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

Le code peut être testé ici .

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

(Il n'y a que trois lignes de code, mais j'ai cassé la ligne 3 pour la lisibilité)

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

Le tableau de chaînes au début répertorie les touches adjacentes possibles pour chaque lettre de l'alphabet. J'ai dû doubler le "O" (adjacent à "P") pour éviter de calculer random()%1lors de la sélection d'un caractère décalé.

Essai:

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

Mise à jour:

Voici une version développée et commentée du même code source:

#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

Prise légèrement plus courte à l'aide d'une stratégie d'indexation par tableau:

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

Version d'expression régulière originale (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())

Technique de recherche très simple, j'ai pensé pendant un moment qu'il serait peut-être moins coûteux de coder le clavier sous forme de graphe non orienté, mais le temps système nécessaire à la création d'un tel type en Python s'est révélé prohibitif. Comme les fonctions aléatoires de Python ont des noms trop descriptifs, j'utilise choice()exclusivement pour les renommer w. La probabilité d'erreur de 10% est gérée w([z]*9+[...])lorsque les neuf copies d'un caractère non typo sont dans une liste avec une seule frappe.

_{-16 caractères - merci grc, +2 caractères (et exactitude, valant bien plus que 2 caractères) - merci Dhara}

C #, 320 octets (360 octets avec le wrapping du programme)

Inclut la prise en charge des lettres majuscules "décalées".

En fonction (320 octets):

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

En tant que programme qui lit une ligne de texte (360 octets):

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

Exemple de sortie d'entrée:

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 (correction de bogue)

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

Algorithme pour le keyslip:

• trouver le caractère dans la chaîne (ou en majuscule)
• ajoutez 11, -11, 1 ou -1 à l'index.
• si elle est invalide (0 ou nulle), relancez

Version non-Golfée par demande:

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

Exécuter avec -p, puis 148 + 1 = 149 octets. Par exemple:

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.

Non-golfé, plus ou moins:

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

Au début, je pensais que choisir un élément de manière aléatoire dans un tableau (sur 26 d’entre elles de longueurs différentes) est statistiquement plus «net» (c'est-à-dire aléatoire), mais peut-être que c'était faux. (Voir la version précédente.) Cette dernière tentative suit, à la suite des meneurs :-), le long d’une chaîne soit de -1,1, -11,11 (au hasard) et se répète jusqu’à ce que l’étape soit valide.

Edit: Grâce à l' aide tobyink et à d'autres optimisations, nous avons réussi à réduire considérablement la taille du code.

La dernière approche utilise quelques astuces avec la recherche sur les expressions rationnelles pour trouver une étape valide le long de la chaîne de substitution, en éliminant les vérifications manuelles.

Une autre édition: 5 octets désactivés car nous n'avons pas besoin d'entiers pour les index de tableau + petit truc avec index de tableau illégal. J'ai essayé le même truc avec [-4+rand@-](c'est-à-dire des indices négatifs) et je me suis débarrassé d'un élément de la liste, '',mais cela n'a rien sauvé.

Edit: Retour à la simplicité - le remplacement de la condition ~~rand 10par la rand>.1sauvegarde de 2 octets ...

PHP, fonction avec 368 octets

Voici ma tentative.

C'est un "code de frankenc", mais ça marche un peu .

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

Un code plus "lisible":

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

La seule différence entre les 2 codes est qu’il ya des tonnes d’onglets et de nouvelles lignes.

Il ne produit pas le même type exact d '"inexactitude", mais il supprime ou remplace un caractère à l'aide desdites conditions.

Vous pouvez l'essayer sur http://writecodeonline.com/php/ .

Copiez et collez ce 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;}
echo _('This is some correct text. It is too correct. Please un-correctify it.');

Après le test, dites-moi s’il s’agit d’une réponse valide.

C #, 581 octets

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

et dans un format plus lisible:

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 caractères

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

Et une version plus lisible et commentée:

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

On pourrait encore améliorer, je suppose.

-2, -3 grâce à Ismael Miguel

Java (475 octets)

Ceci est mon essai dans le langage prolixe Java. Obtenir des nombres aléatoires est assez long en Java et le mappage n'est pas vraiment efficace. Cela peut probablement être amélioré.

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

Usage:

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

Non compressé, distinctions ajoutées:

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 octets

L'entrée doit être donnée en tant que paramètre de ligne de commande, la sortie est donnée en tant que message d'erreur.

Version golfée

boucle, analyse, 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 =
si r (10)! = 10 {
h. = a
Continuez
}
pour x, y dans k
z: = y = a? x: z
si q = 1
h. = aa
si q = 3
{
Boucle{
t: = r (4), w: = z + (t = 1? 20: t = 2? -20: t = 3? 1: -1)
} jusqu'à k.HasKey (w)
h. = k [w]
}
}
lancer% h
r (n) {
Aléatoire, w, 1, n
retour w
}

Version non jouée et annotée (la différence est que cette version a plus d’espace blanc et que les affectations de variables sont sur des lignes séparées pour plus de lisibilité.)

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"}
boucle, analyse, 1
{
    a: = A_LoopField
    ; obtenez un nombre aléatoire de 1 à 10 et vérifiez s’il s’agit de 10
    ; si ce n'est pas sauter le reste de cette itération
    si r (10)! = 10
    {
        h. = a
        Continuez
    }

    ; vérifie si le caractère actuel est dans le k
    z =
    pour x, y dans k
        z: = y = a? x: z

    ; choisissez un nombre aléatoire pour décider de la faute de frappe
    q: = r (z? 3: 2)
    si q = 1
        h. = aa; dupliquer la clé
    si q = 3
    {
        ; le tableau de clavier est configuré de telle sorte qu'en ajoutant ou en soustrayant
        ; 20 de l'index que vous déplacez vers le haut ou le bas d'une ligne
        ; et en ajoutant ou en soustrayant 1 vous vous déplacez à droite ou à gauche
        ; alors il vous suffit de vérifier si l'indice ajusté
        ; est valable
        Boucle
        {
            t: = r (4)
            w: = z + (t = 1? 20: t = 2? -20: t = 3? 1: -1)
        } jusqu'à ce que si k.HasKey (w)
        h. = k [w]
    }
}
; affiche la chaîne sous forme de message d'erreur
lancer% h
r (n)
{
    Aléatoire, w, 1, n
    retour w
}