Mal orthographier un mot au hasard

16

Inspiré par cette question CR (veuillez ne pas me tuer pour avoir parcouru CR)

Spec

Les probabilités d'orthographe d'un mot sont les suivantes:

  • 1/3 du temps ne change pas la sortie
  • 1/3 du temps supprime un caractère aléatoire
  • 1/3 du temps dupliquer un caractère aléatoire

La possibilité de supprimer / dupliquer un caractère donné dans l'entrée doit être la même pour tous les caractères.

Si deux caractères consécutifs sont identiques (sensibles à la casse), la probabilité que l'un d'entre eux soit modifié doit être la même que s'il s'agit d'un seul caractère. C'est-à-dire que les sorties pour AA(qui sont AAou Aou AAA) devraient toutes avoir la même probabilité.


L'entrée ne contiendra que des lettres pour plus de simplicité.

Exemples

La première ligne est entrée, les lignes suivantes sont toutes des fautes d'orthographe possibles. Chaque ligne doit avoir la même probabilité d'être sortie, l'entrée est exclue dans les exemples mais elle doit toujours avoir une probabilité 1/3 de sortie.

foo

fo
oo
ffoo
fooo
PPCG

PPC
PPG
PCG
PPPCG
PPCCG
PPCGG
Downgoat
la source
C'est un beau défi, mais si chaque ligne a la même probabilité d'être sortie, cela ne signifie-t-il pas qu'il n'y a pas 1/3 de chance que le mot reste le même?
Value Ink
@ValueInk ok c'est un défaut avec les exemples. laissez-moi réparer
Downgoat
3
Attendez, si chaque ligne aurait la même probabilité d'être sortie, alors la distribution des caractères ne serait-elle pas uniforme? Comme avec foo: si vous supprimez un caractère, il pourrait devenir (-f) oo, f (-o) o et fo (-o). Cela fodevrait donc être deux fois plus probable oo, mais vous dites que chaque ligne a une probabilité égale.
Deusovi
2
@Deusovi il y a tout un paragraphe expliquant cela, je vais le copier ici juste au cas oùIf two consecutive characters are the same (case-sensitive), the probability of one of them being modified should be the same as if they are one character. I.e. the outputs for AA (which are AA or A or AAA) should all have the same probability.
edc65
1
@DJMcMayhem non, plusieurs caractères sont généralement mal orthographiés; _;
Downgoat

Réponses:

5

Pip , 38 27 octets

a@:`(.)\1*`YRR#aa@y@0X:RR3a

C'était amusant - j'ai pu utiliser les capacités de regex et de chaîne mutable de Pip, que je n'avais pas retirées depuis longtemps. Prend l'entrée via l'argument de ligne de commande.

Explication:

a@:`(.)\1*`                  Split a into runs of identical chars using regex match
           YRR#a             Yank randrange(len(a)) into y (randomly choosing one such run)
                a@y@0        Take the first character of that run
                     X:RR3   Modify in place, string-multiplying by randrange(3):
                               If RR3 is 0, character is deleted
                               If RR3 is 1, no change
                               If RR3 is 2, character is duplicated
                          a  Output the modified a

Essayez-le en ligne!

DLosc
la source
1
Wow, félicitations pour avoir une langue de golf laconique uniquement avec ASCII
Downgoat
3

Ruby, 64 55 + 1 ( pindicateur) = 56 octets

L'entrée est une ligne de STDIN canalisée sans retour à la ligne.

a=[]
gsub(/(.)\1*/){a<<$&}
a.sample[-1]*=rand 3
$_=a*''
Encre de valeur
la source
2

CJam (21 octets)

re`_,mr_2$=3mr(a.+te~

Démo en ligne

Dissection

r     e# Read a line of input from stdin
e`    e# Run-length encode it
_,mr  e# Select a random index in the RLE array
_     e# Hang on to a copy of that index
2$=   e# Copy the [run-length char] pair from that index
3mr(  e# Select a uniformly random integer from {-1, 0, 1}
a.+   e# Add it to the run-length
t     e# Replace the pair at that index
e~    e# Run-length decode
Peter Taylor
la source
2

JavaScript (ES6), 107

w=>(r=x=>Math.random()*x|0,a=w.match(/(.)\1*/g),a[p=r(a.length)]=[b=a[p],b+b[0],b.slice(1)][r(3)],a.join``)

Moins golfé

w=>(
  a = w.match(/(.)\1*/g),
  r = x => Math.random()*x | 0,
  p = r(a.length),
  b = a[p],
  a[p] = [b, b+b[0], b.slice(1)][r(3)],
  a.join``
)

Tester

f=w=>(r=x=>Math.random()*x|0,a=w.match(/(.)\1*/g),a[p=r(a.length)]=[b=a[p],b+b[0],b.slice(1)][r(3)],a.join``)

function update() { 
  O.innerHTML = Array(99)
  .fill(I.value)
  .map(x=>(
    r=f(x),
    r==x?r:r.length<x.length?'<b>'+r+'</b>':'<i>'+r+'</i>'
  
    )
  ).join` `
}

update()
#O { width:90%; overflow: auto; white-space: pre-wrap}
<input id=I oninput='update()' value='trolley'><pre id=O></pre>

edc65
la source
2

Java 7, 189 180 178 octets

import java.util.*;String c(String i){Random r=new Random();int x=r.nextInt(2),j=r.nextInt(i.length());return x<1?i:i.substring(0,j-(x%2^1))+(x<2?i.charAt(j):"")+i.substring(j);}

Cas non testés et testés:

Essayez-le ici.

import java.util.*;
class M{
  static String c(String i){
    Random r = new Random();
    int x = r.nextInt(2),
        j = r.nextInt(i.length());
    return x < 1
            ? i
            : i.substring(0, j - (x%2 ^ 1)) + (x<2?i.charAt(j):"") + i.substring(j);
  }

  public static void main(String[] a){
    for(int i = 0; i < 5; i++){
      System.out.println(c("foo"));
    }
    System.out.println();
    for(int i = 0; i < 5; i++){
      System.out.println(c("PPCG"));
    }
  }
}

Sortie possible:

foo
fooo
foo
foo
ffoo

PPCCG
PPCG
PPCCG
PPPCG
PPCG
Kevin Cruijssen
la source
1

Python 2, 134 octets

from random import*
def f(s):
 p=c=0;M,L=[],list(s)
 for t in L:
  if t!=p:M+=c,;p=t
  c+=1
 L[choice(M)]*=randint(0,2);return''.join(L)

Les espaces blancs dans la boucle sont des tabulations.

Essayez-le sur Ideone

Neorej
la source
1

Pyth - 17 octets

Celui-ci gère correctement les cas spéciaux avec des caractères consécutifs.

 XZOKrz8Or_1 2r9K

Suite de tests .

Maltysen
la source
C'est 16 octets? L'espace de tête est-il correct? Si ce n'est pas 15 octets?
Downgoat
@Downgoat non, l'espace de tête est correct. Je suis sûr que ses 17 octets.
Maltysen
1

APL, 21

{⍵/⍨3|1+(?3)×(⍳=?)⍴⍵}

Cela commence par créer un vecteur de zéros avec un 1 en position aléatoire. Multiplie ensuite par un nombre aléatoire entre 1 et 3. +1 et le mod 3 obtient un vecteur avec tous les 1 et un 0,1 ou 2 positionné au hasard.

Enfin, ⍵ / ⍨ dit que chaque lettre doit être écrite n fois, où n sont les nombres du vecteur.

Essayez-le sur tryapl.org

Moris Zucca
la source
0

Python 2, 123 octets

from random import*
R=randint
s=input()
m=n=R(0,len(s)-1)
c=R(0,2)
m=[m,1+[-len(s),m][m>0]][c==1]
n+=c==2
print s[:m]+s[n:]
Karl Napf
la source
0

JavaScript (ES6), 103

w=>{w=w.split(''),r=Math.random,x=r(),i=r()*w.length|0;w.splice(i,x<.6,x>.3?w[i]:'');alert(w.join(''))}
Slak
la source
0

APL, 27 octets

{⍵/⍨(?3)⌷1⍪2 0∘.|1+(⍳=?)⍴⍵}

Explication:

                        ⍴⍵  ⍝ length of ⍵
                   (⍳=?)    ⍝ bit vector with one random bit on 
                 1+         ⍝ add one to each value (duplicate one character)
           2 0∘.|           ⍝ mod by 2 and 0 (remove instead of duplicate)
         1⍪                 ⍝ add a line of just ones (do nothing)
    (?3)⌷                   ⍝ select a random line from that matrix
 ⍵/⍨                        ⍝ replicate characters in ⍵

Tester:

      {⍵/⍨(?3)⌷1⍪2 0∘.|1+(⍳=?)⍴⍵} ¨ 10/⊂'foo'
 fooo  foo  oo  foo  fo  fo  oo  fo  oo  fooo 
marinus
la source