Ho scritto del testo, ma sembra troppo professionale. Voglio far sembrare che ero davvero stanco quando l'ho scritto. Ho bisogno che tu inserisca alcuni errori di battitura.

La tua sfida è prendere una singola riga di testo arbitraria e aggiungere errori di battitura. Ciò significa che per ogni personaggio, ci sarà una probabilità del 10% che sia tipizzato.

La definizione di "typofied" è che devi scegliere (in modo casuale) una delle seguenti opzioni:

• Duplica il personaggio.
• Elimina il personaggio.

• Sposta il carattere di uno spazio sulla tastiera. La "tastiera" è definita come:

  qwertyuiop
  asdfghjkl
   zxcvbnm
  

  Per lo spostamento del personaggio, devi andare di uno spazio in alto, in basso, a sinistra o a destra. Questo deve essere scelto a caso. L'opzione shift si applica solo ai caratteri alfabetici. Il caso deve essere conservato. Fai attenzione ai casi limite, come m!

La definizione di "casuale" è che il risultato non deve essere prevedibile (guardando i risultati precedenti). Ad esempio, non è possibile digitare ogni decimo carattere. Inoltre, la casualità deve avere una distribuzione uniforme. Ad esempio, non è possibile eseguire il 30% di duplicati, il 30% di eliminazione e il 40% di spostamento; deve essere una probabilità 1/3 per ciascuno (1/2 per ciascuno se è un personaggio non alfabetico).

Esempio di input:

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

Esempio di output:

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

Questo è code-golf , quindi vincerà il codice più breve in byte.

GolfScript, 120 caratteri

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

Il codice può essere testato qui .

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

(Esistono solo tre righe di codice, ma ho interrotto la riga 3 per leggibilità)

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

La matrice di stringhe all'inizio elenca le possibili chiavi adiacenti per ogni lettera dell'alfabeto. Ho dovuto raddoppiare la "O" (adiacente alla "P") per evitare il calcolo random()%1quando si seleziona un personaggio spostato.

Prova:

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

Aggiornare:

Ecco una versione espansa e commentata dello stesso codice sorgente:

#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

Take leggermente più breve usando una strategia di indicizzazione dell'array:

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

Versione originale di espressioni regolari (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())

Tecnica di ricerca molto semplice, per un momento ho pensato che sarebbe stato più economico codificare la tastiera come un grafico non orientato, ma il sovraccarico per la creazione di un tale tipo in Python si è rivelato proibitivo. Poiché le funzioni casuali di Python hanno nomi troppo descrittivi che uso choice()esclusivamente, rinominandolo w. La probabilità di errore del 10% è gestita da w([z]*9+[...])dove le nove copie di un personaggio non scritto sono in un elenco con un errore di battitura.

_{-16 caratteri - grazie grc, +2 caratteri (e correttezza, vale molti più di 2 caratteri) - grazie Dhara}

C #, 320 byte (360 byte con wrapping del programma)

Include il supporto per lettere maiuscole "spostate".

Come funzione (320 byte):

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

Come programma che legge una riga di testo (360 byte):

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

Esempio di input output:

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 (correzione errori)

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

Algoritmo per il tastierino:

• trova carattere in stringa (o maiuscolo)
• aggiungi 11, -11, 1 o -1 all'indice.
• se non è valido (0 o null), ripetere il rollback

Versione non golfata per richiesta:

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

Esegui con -p, quindi 148 + 1 = 149 byte. Per esempio:

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.

Senza golf, più o meno:

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

All'inizio ho pensato che la scelta casuale dell'elemento in un array (di 26 di loro di lunghezze diverse) fosse statisticamente più "pulita" (cioè casuale), ma forse era sbagliato. (Vedi la versione precedente.) Quest'ultimo tentativo è, seguendo i leader :-), passare una stringa di -1,1, -11,11 (a caso) e ripetere fino al passaggio valido.

Modifica: grazie alla guida tobyink e ad altre ottimizzazioni, siamo riusciti a ridurre considerevolmente le dimensioni del codice.

L'ultimo approccio utilizza alcuni trucchi con la ricerca regexp per trovare un passo valido lungo la stringa di sostituzione, eliminando i controlli manuali.

Un'altra modifica: 5 byte di sconto perché non abbiamo bisogno di numeri interi per gli indici di array + piccolo trucco con indice di array illegale. Ho provato lo stesso trucco con [-4+rand@-](cioè gli indici negativi) e mi sono sbarazzato di un elemento della lista, '',ma non ha salvato nulla.

Modifica: ritorno alla semplicità - sostituzione della condizione ~~rand 10con rand>.1salvataggio di 2 byte ...

PHP, funzione con 368 byte

Ecco il mio tentativo.

E 'un po' di "frankencode", ma è un po funziona.

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 codice più "leggibile":

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

L'unica differenza tra i 2 codici è che uno ha tonnellate di schede e nuove righe.

Non produce lo stesso tipo esatto di "inesattezza", ma elimina o sostituisce un carattere usando le condizioni suddette.

Puoi provarlo su http://writecodeonline.com/php/ .

Copia e incolla questo codice:

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

Dopo il test, per favore, dimmi se è una risposta valida.

C #, 581 byte

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

e in un formato più leggibile:

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 caratteri

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

E una versione più leggibile e commentata:

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

Potrei ancora essere migliorato, suppongo.

-2, -3 grazie a Ismael Miguel

Java (475 byte)

Questo è il mio tentativo nel linguaggio dettagliato che è Java. Ottenere numeri casuali è piuttosto lungo in Java e la mappatura non è davvero efficiente. Probabilmente può essere migliorato.

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

Uso:

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

Non compresso, riconoscimenti aggiunti:

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

Tasto di scelta automatica 441 byte

L'input deve essere indicato come parametro della riga di comando, l'output viene fornito come messaggio di errore.

Versione golfizzata

loop, analisi, 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"}, un: = A_LoopField, q: = r (? z 3: 2), z =
if r (10)! = 10 {
h. = a
Continua
}
per x, y in k
z: = y = a x: z
se q = 1
h. = aa
se q = 3
{
Ciclo continuo{
t: = r (4), w: = z + (t = 1 20: t = 2 -20: t = 3 1: -1)
} fino a quando k.HasKey (w)
h. = k [w]
}
}
gettare% h
r (n) {
Casuale, w, 1, n
ritorno w
}

Versione non golfata e annotata (la differenza è che questa versione ha più spazio bianco e le assegnazioni delle variabili sono su righe separate per la leggibilità).

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, analisi, 1
{
    un: = A_LoopField
    ; ottieni un numero casuale da 1-10 e controlla se è 10
    ; se non lo è, salta il resto di questa iterazione
    se r (10)! = 10
    {
        h. = a
        Continua
    }

    ; controlla se il carattere corrente è in k
    z =
    per x, y in k
        z: = y = a x: z

    ; scegli un numero casuale per decidere quale errore fare
    q: = r (z 3: 2)
    se q = 1
        h. = aa; duplica la chiave
    se q = 3
    {
        ; l'array della tastiera è impostato in modo tale da aggiungere o sottrarre
        ; 20 dall'indice che si sta spostando verso l'alto o verso il basso di una riga
        ; e aggiungendo o sottraendo 1 si sposta a destra o a sinistra
        ; allora devi solo controllare se l'indice rettificato
        ; è valido
        Ciclo continuo
        {
            t: = r (4)
            w: = z + (t = 1 20: t = 2 -20: t = 3 1: -1)
        } fino a quando k.HasKey (w)
        h. = k [w]
    }
}
; visualizza la stringa come messaggio di errore
gettare% h
r (n)
{
    Casuale, w, 1, n
    ritorno w
}