Brouiller les mots tout en préservant leurs contours

44

Ceci est beaucoup plus avancé que Comment randomiser des lettres dans un mot et Cambridge Transposition en raison de la règle selon laquelle les lettres peuvent être échangées avec lesquelles. Une simple expression régulière ne suffira pas ici.


Il est bien connu qu’un texte peut toujours être lu alors que les entrailles de ses mots ont été brouillées, tant que leurs première et dernière lettres ainsi que leurs contours généraux restent constants. Avec un texte imprimable Ascii + Newline, brouillez chaque mot en respectant les règles suivantes:

  1. Le brouillage doit être (pseudo) aléatoire.

  2. Un mot est une séquence de caractères latins, de A à Z.

  3. Seules les lettres initiales seront jamais majuscules.

  4. Les premières et dernières lettres doivent rester intactes.

  5. Lors du brouillage, seules les lettres appartenant à l'un des groupes suivants peuvent échanger des lieux:

    1. acemnorsuvwxz

    2. bdfhkl

    3. gpqy

    4. it

    5. j (reste en place)

Exemple

Srcmable se prépare en gardant son oeiltnus

Il est bien connu qu’un txet peut toujours être lu alors que les commandes de ses mots ont été masquées, à condition que leurs première et dernière lettres plus leur nom ne puissent plus être écrits. Étant donné le contenu de cet article, vous pouvez écrire un mot comme suit:

  1. Smncrbliag doit être (pusedo) rondam.

  2. Un wrod est un seqencue du latin chreratacs, A thurogh Z.

  3. Seuls les participants initiaux seront tous reconnus.

  4. Les premières lettres et les lettres du tat doivent rester en place.

  5. Lorsque vous écrivez, seules les lettres d’un des corps de police peuvent échanger des cartes:

    1. aneusvrowxmcz

    2. bhkfdl

    3. gqpy

    4. it

    5. j (reste en plcae)

Emxaple

Adam
la source
test censé être plus court que hbien que beaucoup de gens ne l'écrivent pas ainsi.
Leaky Nun
@ LeakyNun Je sais, mais suggérez-vous de supprimer tdu groupe 2? Ou peut-être mettre tdans un groupe 4 avec i?
Adám
Ce dernier serait bien.
Leaky Nun
le temps d'exécution peut-il être théoriquement illimité? (comme au hasard, jusqu'à ce que quelque chose
aille
1
printable/ patnirlben'est pas tout à fait lisible. Je pense que le i/ téchange est à blâmer. Hmm ... paintrlbeNon, ça n'a pas aidé non plus. C'est probablement le pr/ paéchange, alors. Le contour est maintenu, mais je pense avoir lu "pr" et "pa" comme étant sémantiquement (?) 1 lettre. prtnialbeAh oui. Cela l'a fait. Pas sûr que je puisse offrir un correctif à l'algorithme cependant.
Draco18s

Réponses:

9

Gelée , 80 74 octets

-2 octets en passant de czar + vex + mow + sunà czar + vexes + unmown(les es et ns répétés ne posent pas de problème)
-1 octet utilisant Tịplutôt que ȦÐf
-1 octet utilisant Œle€Øaplutôt que i@€ØB>⁵
-2 octets en reconfigurant un peu la présentation

Tị
TẊị⁹ż@œp
e€ç⁸F
W;“HọƊṘ€.`]HɲøƁḤ0ẉlfrøj⁷»Ḳ¤ç/
Ḣ,ṪjÇḟ0
Œle€Øað¬œpÇ€ÑżœpÑ¥

Un programme complet prenant une liste de caractères (ou une chaîne au format Python), qui affiche le résultat du brouillage.

Essayez-le en ligne!

Jelly semble avoir énormément de difficulté (que ce soit ou que j’ai raté un truc qui se produise!) Cela sera sûrement battu par les langages avec une meilleure manipulation des cordes comme Retina (aucune fonctionnalité aléatoire) ou 05ab1e .

Comment?

Tị - Link 1, get truthy items: list a
T  - truthy indexes of a
 ị - index into a

TẊị⁹ż@œp - Link 2, selective shuffle: list a, list b
T        - truthy indexes of a (those indexes that may be shuffled in b)
 Ẋ       - random shuffle
   ⁹     - link's right argument, b
  ị      - index into (gets the shuffled values)
      œp - partition b at truthy indexes of a
    ż@   - zip with reversed @rguments (place shuffled values - yields a list of lists)

e€ç⁸F - Link 3, value selective shuffle: list a, list b
e€    - c exists in b? for €ach c in a (1s where b has shuffle-able characters, else 0s)
   ⁸  - link's left argument, a
  ç   - call the last link (2) as a dyad
    F - flatten the result (from the yielded list of lists to one list)

W;“HọƊṘ€.`]HɲøƁḤ0ẉlfrøj⁷»Ḳ¤ç/ - Link 4, perform all shuffles on a word's innards: list x
W                             - wrap x in a list
                          ¤   - nilad followed by link(s) as a nilad:
  “HọƊṘ€.`]HɲøƁḤ0ẉlfrøj⁷»     -   compression of s(bdfhkl)+d( czar)+d(vexes)+d(unmown)+s( gpqy)+d( ti)
                              -     where d() looks up a word in Jelly's dictionary and s() adds a string to the compressed output.
                         Ḳ    -   split on spaces: ["bdfhkl","czarvexesunmown","gpqy","ti"]
                           ç/ - reduce by last link (3) as a dyad (shuffles by each in turn)

Ḣ,ṪjÇḟ0 - Link 5, shuffle a word: list w
Ḣ       - head w (yields the leftmost character and modifies w)
  Ṫ     - tail w (yields the rightmost character and modifies w)
 ,      - pair
        -   Note: head and tail yield 0 when w is empty, so ['a'] -> ["a",0] and [] -> [0,0]
    Ç   - call the last link (4) as a monad (with the modified w)
   j    - join
     ḟ0 - filter discard zeros (thus single or zero letter words pass through unchanged)

Œle€Øað¬œpÇ€ÑżœpÑ¥ - Main link: list s
Œl                 - convert s to lowercase, say t
    Øa             - lowercase alphabet, say a
  e€               - c exists in a? for €ach c in t
      ð            - dyadic chain separation (call that u)
       ¬           - not (vectorises across u), say v
        œp         - partition s at truthy indexes of v (extract words, plus empty lists from within strings of non-alphabetic characters)
          Ç€       - call the last link (5) as a monad for €ach (shuffle their innards)
            Ñ      - call the next link (1) as a monad (only keep the actual words)
                 ¥ - last two links as a dyad:
              œp   -   partition s at truthy indexes of u (get the non-words, plus empty lists from within strings of alphabetic characters)
                Ñ  -   call the next link (1) as a monad (only keep actual non-words)
             ż     - zip together
                   - implicit print
Jonathan Allan
la source
C'est en fait plus difficile que je pensais.
Leaky Nun
@ LeakyNun Welp, il m'a fallu beaucoup plus de temps que 10 minutes pour y faire face.
Jonathan Allan
1
@ JonathanAllan Ouais, ça existe depuis des lustres, et ça fera probablement partie de la prochaine version, parce que ça m'embêtait à plusieurs reprises.
Martin Ender
1
czar + vex + mow + sun
Adám
3
@ Dictionnaire Adám pour former acemnorsuvwxz. J'écrirai aussi du code commenté à un moment donné.
Jonathan Allan
5

PHP, 278 octets

<?=preg_replace_callback("#\pL\K(\pL+)(?=\pL)#",function($t){preg_match_all("#([^bdf-lpqty])|([bdfhkl])|([gpqy])|([it])|(j)#",$t[0],$p);foreach($p as$v){$k++?$c=array_keys($n=array_filter($v)):$o=[];!$n?:shuffle($n)&&$o+=array_combine($c,$n);}ksort($o);return join($o);},$argn);

Essayez-le en ligne!

Étendu

echo preg_replace_callback("#\pL\K(\pL+)(?=\pL)#" # patter \pL is shorter as [a-z]
,function($t){  # replacement function beginning
  preg_match_all("#([^bdf-lpqty])|([bdfhkl])|([gpqy])|([it])|(j)#",$t[0],$p); # makes groups with the regex. group 0 is the whole substring
  foreach($p as$v){ # loop through groups
    $k++?$c=array_keys($n=array_filter($v)):$o=[]; # group 0 make new empty replacement array in the other case filter the group remove empty values. 
    #You gain an array with the keys as position in the substring and the values
    #store the key array and the values array
    !$n?:shuffle($n)&&$o+=array_combine($c,$n); 
    #if values shuffle the values and make a new array with the keys and the shuffled values and merge the new array to the replacement array
  }
  ksort($o); # sort the replacement array ascending positions 
  return join($o); # return the replacement as string
},$argn);

les fonctions

tableau_combine

array_filter

array_keys

ksort

preg_replace_callback

mélanger

Jörg Hülsermann
la source
Conseil: Vous pouvez utiliser le paramètre "désactiver le cache de sortie" sur TIO, au lieu d'exécuter le code plusieurs fois. Je viens de l'exécuter avec l'exemple - Tout va bien!
Jonathan Allan
@ JonathanAllan Merci pour le tuyau avec le cache. Il était déjà assez difficile de trouver un moyen de résoudre ce problème
Jörg Hülsermann
5

Pyth , 79 octets

sm?td++hduuXNhTeTC,f@@GTHUG.S@HGG+-GJ."by❤jã~léܺ"cJ\jPtdedd:jb.z"([A-Za-z]+)"3

est U + 0018.

Essayez-le en ligne!

Échantillon

Il est bien connu qu’un texte peut toujours être téléchargé alors que les lettres de ses mots ont été séchées, tant que leurs lettres et leurs lettres plus leurs lettres plus grandes sont encore bien connues. Étant donné un texte, sacralisez chaque commentaire écrit:

  1. Scamrlbing doit être (puesdo) rnadom.

  2. Un mot est une suqencee du latin chraectars, A thuorgh Z.

  3. Seules les lettres écrites seront complètes.

  4. Les lettres premières et les dernières lettres doivent rester inchangées.

  5. Lorsque vous écrivez, seules les lettres d'un des suiveurs suivants peuvent être écrites:

    1. amsuvrcnoxewz

    2. bhfkdl

    3. gpqy

    4. it

    5. j (reste en place)

Fuite, nonne
la source
Ne pouvez-vous pas enregistrer avec \pLau lieu de [A-Za-z]?
Adám
@ Adám Qu'est-ce que c'est \pL?
Leaky Nun
Tout caractère à la p ropriété d'être L Etter.
Adám
Je ne pense pas que cela fonctionne ici ...
Leaky Nun
ne serait pas \wsuffisant?
Sarge Borsch
5

JavaScript 176 octets

t.replace(/\B(\w+)\B/g,b=>{return[/[acemnorsuvwxz]/g,/[bdfhkl]/g,/[gpqy]/g,/[it]/g].forEach(d=>{g=b.match(d),b=b.replace(d,c=>{return g.splice(Math.random()*g.length,1)})}),b})

Méthode:

  1. RegExp itère sur le centre de chaque mot ( /\B(\w+)\B/g) en utilisant 1st replace fn.

  2. 1st replace fn itère un tableau de RegExp pour chaque groupe de lettres ( /[bdfkhl/g, /[gqpy]/g, etc..).

  3. Chaque itération construit un tableau temporaire de caractères du centre de mots apparaissant dans le groupe de lettres actuel.

  4. Chaque itération utilise ensuite RegExp du groupe de lettres actuel pour parcourir l'ensemble du centre de mots, en utilisant un 2e remplacement fn.

  5. 2nd replace fn raccorde de manière aléatoire le tableau temporaire, en supprimant un caractère aléatoire et en le renvoyant.

Démo:

Exécutez-le dans JSFiddle: https://jsfiddle.net/CookieJon/bnpznb7r/

Cahoteux
la source
Bienvenue chez PPCG. Incroyable première réponse. Cependant, je pense que vous devez \pL(\pL+)\pLplutôt \B(\w+)\Bexclure les chiffres et les traits de soulignement.
Adám
Ah merci! Je dois admettre que l'expression régulière n'est pas mon sac (je dois rechercher la référence CHAQUE fois que je l'utilise!) Je peux avaler les 3 caractères supplémentaires ... mettrai à jour ma réponse sous peu, merci encore. :-)
Bumpy
1
Incroyable première réponse! :) Quelques améliorations rapides à apporter pour vous permettre de descendre à 155 octets, y compris la correction @ Adáms ci-dessus: t => t.replace (/ \ B [az] + \ B / gi, b => ([/ [acemnorsuvwxz ] / g, / [bdfhkl] / g, / [gpqy] / g, / [it] / g] map .map (d => b = b.replace (d, c => g. épissure (nouvelle date% g.length, 1), g = b.match (d))), b))
Shaggy
@Shaggy Je pense b=>[...].map(...)&&benregistre un autre octet. Aussi, je ne suis pas sûr que votre isoit nécessaire.
Neil
Si @ Adám doit être rigoureusement difficile avec sa définition de mot, vous devrez utiliser un t.replace(/[A-Za-z]([a-z]+)(?=[a-z])/g,(w,b)=>...w[0]+b...)ou plusieurs.
Neil
2

C, 453, 356 369 octets

#define F for
#define M rand()%s+1+q
char a[256],*b=" acemnorsuvwxz\1bdfhkl\1gpqy\1it\1j";g(c,t)char*c,*t;{static int i,j,k,w,v,n,q,s,r;r=-1;if(c&&t){strcpy(c,t);if(!k)F(j=i=k=1;b[i];++i)b[i]-1?(a[b[i]]=j):++j;F(r=i=0;c[i];){F(;isspace(c[i]);++i);F(q=i;!isspace(c[i])&&c[i];++i);F(s=v=i-q-2;--v>0;)if(a[c[j=M]]==a[c[w=M]]&&a[c[j]])n=c[j],c[j]=c[w],c[w]=n;}}return r;}

ungolf avec des commentaires

// Input in the arg "t" result in the arg "c"
// NB the memory pointed from c has to be >= memory pointed from t
//    the char is 8 bit
#define F for
#define M rand()%s+1+q
char a[256], *b=" acemnorsuvwxz\1bdfhkl\1gpqy\1it\1j";
   g(c,t)char*c,*t;
   {static int i,j,k,w,v,n,q,s,r;
    r=-1;
    if(c&&t)
      {strcpy(c,t);                         // copy the string in the result space
       if(!k)
         F(j=i=k=1;b[i];++i)
             b[i]-1?(a[b[i]]=j):++j;        // ini [possible because at start k=0]
       F(r=i=0;c[i];)
         {F(;isspace(c[i]);++i);            //skip spaces
                                            // the start q the end+1 i
          F(q=i;!isspace(c[i])&&c[i];++i);  //skip word
          F(s=v=i-q-2;--v>0;)               //loop for swap letters of the same set
            if(a[c[j=M]]==a[c[w=M]]&&a[c[j]])
                n=c[j],c[j]=c[w],c[w]=n;
         }
      }
   return r;
  }


#include <stdio.h>
#define G(x,y) if(x)goto y
main()
{char a[256],r[256];
l1:
 gets(a);// i would know the string lenght<256
 g(r,a);
 printf("%s\n",r);
 G(*a,l1);
}
RosLuP
la source
1

Python 3.6, 349 340 octets

from itertools import *
from random import *
import re
def S(s):
    C=lambda c:len(list(takewhile(lambda x:c not in x,('j','it','gqpy','bhkfdl'))));L=[];B=[[]for i in range(5)]
    for l in s:c=C(l);L+=[c];B[c]+=[l];shuffle(B[c])
    return''.join(B[n].pop()for n in L)
A=lambda t:re.sub('[A-Za-z]{3,}',lambda x:x[0][0]+S(x[0][1:][:-1])+x[0][-1],t)

En retrait avec des onglets. La fonction est nommée A. Il n’utilise pas de force brute, le temps d’exécution est déterministe, comme l’a demandé OP.

Sarge Borsch
la source
1

Mathematica 232 octets

StringReplace[#,x:Repeated[WordCharacter,{2,∞}]:>""<>(s=StringTake)[x,{i,i}~Table~{i,StringLength@x}/.Flatten[Thread[#->RandomSample@#]&/@(StringPosition[x~s~{2,-2},#]+1&/@Characters@{"acemnorsuvwxz","bdfhkl","gpqy","it","j"})]]]&

L'idée de base est de permuter les sous-ensembles correspondant aux 4 groupes de caractères distincts. Probablement place à l'amélioration.

Kelly Lowder
la source
1

C, 306 282 octets

c,o,d,e,g;l(char*f){char*s[]={"aneusvrowxmcz","bhkfdl","gqpy","it",0},**h,*i,*t;for(i=f;*i;){if(isalpha(*i)){t=i;while(*i&&isalpha(*i))i++;e=i-t-2;for(h=s;*h&&e;*h++){for(c=999;--c;){d=1+rand()%e,o=1+rand()%e;if(strchr(*h,t[d])&&strchr(*h,t[o]))g=t[d],t[d]=t[o],t[o]=g;}}}else++i;}}

Essayez-le en ligne

Ungolfed:

int func(char*p) 
{
    char *groups[] = {"aneusvrowxmcz","bhkfdl","gqpy","it",0}, **g, *s, *t;
    int n,r,i,l,o;

    for (s = p; *s;)
    {
        if (isalpha(*s))
        {
            t = s;
            while (*s && isalpha(*s))
                s++;
            // start scrambling
            l = s - t - 2;
            for(g=groups; *g && l; *g++)
            {
                for(n=999;--n;)
                {
                    i = 1 + rand() % l;
                    r = 1 + rand() % l;
                    if (strchr(*g, t[i]) && strchr(*g, t[r]))
                    {
                        o=t[i];
                        t[i]=t[r];
                        t[r]=o;
                    }
                }
            }
            // end scrambling
        }
        else 
            s++;
    }
}
Johan du Toit
la source
Pourquoi voudriez-vous faire 999 swap en un mot? Savez-vous qu'un mot d'un caractère a l = -1 et que cela signifie éventuellement qu'il commence à effectuer 999 échanges possibles en utilisant 1 + rand ()% -1 afin d'écrire de manière aléatoire dans 2 giga de mémoire ... Mais possible, je vois il a tort ....
RosLuP
Il n'y a malheureusement aucune magie quant à l'utilisation de 999. C'est juste 1 octet de moins que 1000 :)
Johan du Toit
Dans gcc, il semble que rand ()% (- 1) renvoie 0 les 2 premières fois que je l’ai essayé. si possible pas de permutation aléatoire d'espace 2giga ...% d'int n'est pas le% de non signé ...
RosLuP
@RosLup, je suis désolé mais je ne suis pas ce que vous dites.
Johan du Toit
1

JavaScript (ES6), 380 327 311 294 octets

( 298 282 265 octets à l'exclusion des règles)

Merci à @Shaggy pour les conseils utiles!

((b,d)=>b.replace(/\B[a-z]+\B/gi,f=>(g=>(g.map(j=>(h=d.slice(0,~(rind=d.indexOf(j))?rind:-1),~rind?h.split`,`.length-1:-1)).map((j,k,l,m=[])=>{l.map((n,o)=>n==j?m.push(o):0),sub=m[new Date%(m.length-1)]||k,tmp=g[sub],g[sub]=g[k],g[k]=tmp}),g.join``))([...f])))(s,"aneusvrowxmcz,bhkfdl,gqpy,it");

var f = ((b,d)=>b.replace(/\B[a-z]+\B/gi,f=>(g=>(g.map(j=>(h=d.slice(0,~(rind=d.indexOf(j))?rind:-1),~rind?h.split`,`.length-1:-1)).map((j,k,l,m=[])=>{l.map((n,o)=>n==j?m.push(o):0),sub=m[new Date%(m.length-1)]||k,tmp=g[sub],g[sub]=g[k],g[k]=tmp}),g.join``))([...f])))

var s="Let there be scrambling";
console.log(s);
console.log(f(s,"aneusvrowxmcz,bhkfdl,gqpy,it"))

s="It is well known that a text can still be read while the innards of its words have been scrambled, as long as their first and last letters plus their overall outlines remain constant. Given a printable Ascii+Newline text, scramble each word according to these rules";
console.log(s);
console.log(f(s,"aneusvrowxmcz,bhkfdl,gqpy,it"))

La fonction f prend une chaîne de tout type (un seul mot, plusieurs mots, plusieurs mots avec des signes qu’elle interprète comme un saut de mot) et un tableau une chaîne de "règles" de n'importe quelle longueur séparées par des virgules.

Ce tableau de règles, dans le cas de votre question, serait ["aneusvrowxmcz", "bhkfdl", "gqpy", "it"] "aneusvrowxmcz,bhkfdl,gqpy,it"

Certaines lettres ne sont pas mélangées même si elles le pouvaient, puisque vous avez indiqué dans votre question que les lettres "peuvent échanger des espaces". Si je l’interprète mal, je peux changer le code pour toujours brouiller les lettres qui correspondent aux règles.

Je sais que c'est une énorme quantité d'octets et qu'il ne pourra pas rivaliser avec les langues de golf, mais je voulais essayer quand même, j'espère que ça vous plaira :)

Code non lu non lisible par l'homme:

((txt,rules)=>txt.replace(/\B[a-z]+\B/gi,wo=>((w=>(w.map(c=>(h=rules.slice(0, ~(rind=rules.indexOf(c))?rind:-1),~rind?(h.split`,`.length-1):-1)).map((e,i,arr,a=[])=>{
    arr.map((x,i)=>(x==e)?a.push(i):0),
    sub=a[new Date%(a.length-1)]||i,
    tmp=w[sub],
    w[sub]=w[i],
    w[i]=tmp
}),w.join``))([...wo]))))(str, "aneusvrowxmcz,bhkfdl,gqpy,it")
Hankrecords
la source
1
Les règles OP doivent être incluses dans le nombre d'octets. En mai , je voulais dire avoir une chance de .
Adám
1
Bienvenue chez PPCG :) Vous pouvez certainement jouer beaucoup au golf .
Shaggy
1
J'allais essayer de jouer au golf pour vous mais, étant donné tout le travail que je peux faire avec ça, je n'ai plus de temps, alors je vais plutôt vous indiquer ici et ici pour vous aider à démarrer.
Shaggy
1
Quelques astuces rapides, cependant: 01) Débarrassez-vous de toutes les varchoses s et lets. 02) Sauf s'il s'agit d'une fonction récursive, il n'est pas nécessaire d'inclure la variable declaration ( f=) dans votre nombre d'octets. 03) Utilisez currying quand une fonction a 2 paramètres ( b=>d=>au lieu de (b,d)=>) et appelez votre fonction avec f(b)(d). 04) Vous avez le idrapeau donc pas besoin d'inclure A-Zdans votre regex. 05) Vous pouvez utiliser indexOfou searchsur une chaîne, sans la diviser en tableau.
Shaggy
1
Comment la suggestion 03 sauve-t-elle les personnages? Ils se ressemblent pour moi.
Steve Bennett
0

Clojure, 326 322 324 octets

Mise à jour 1: remplacé (map(fn[[k v]]...)...)par(for[[k v]...]...)

Mise à jour 2: regex fixe, utiliser à la \pLplace de \wetc.

#(let[G(zipmap"bdfhklgpqyitj""0000001111223")](apply str(flatten(interleave(for[v(re-seq #"\pL+"%)w[(rest(butlast v))]W[(into{}(for[[k v](group-by G w)][k(shuffle v)]))]R[(rest(reductions(fn[r i](merge-with + r{(G i)1})){}w))]][(first v)(map(fn[c r](nth(W(G c))(-(r(G c))1)))w R)(if(second v)(last v))])(re-seq #"\PL+"%)))))

J'ai hâte de voir quelque chose de plus court. La version antérieure non-golfée avec quelques exemples s'exécute:

(def f #(let[G(zipmap"bdfhklgpqyitj""0000001111223")] ; Create groups, the longest "acemnorsuvwxz" goes to an implicit group nil
          (apply str(flatten(interleave
                              (for[v (re-seq #"\w+"%)                                          ; Iterate over words
                                   w [(rest(butlast v))]                                       ; This holds the middle part
                                   W [(into{}(map(fn[[k v]][k(shuffle v)])(group-by G w)))]    ; Create shuffled groups
                                   R [(rest(reductions(fn[r i](merge-with + r{(G i)1})){}w))]] ; Calculate cumulative sum of group items, used to look-up nth value from shuffled values
                               [(first v)                                     ; First character
                                (map(fn[g r](nth(W g)(-(r g)1)))(map G w)R)   ; Shuffled middle part
                                (if(>(count v)1)(last v))])                   ; Last character, unless the word is just a single character
                              (re-seq #"\W+"%)))))) ; Interleave with spaces, commas, newline etc.

(f "It is well known that a text can still be read while the innards of its words have been scrambled, as long as their first and last letters plus their overall outlines remain constant.\n")
;  "It is well known that a txet can sitll be read wlihe the irnands of its wrods hvae been seacmlbrd, as lnog as their fisrt and lsat letters plus their oavrell ontlieus rmaein cnontast.\n"
;  "It is well kwonn that a text can sitll be raed wlihe the innards of its wrods hvae been seramlbcd, as long as their fisrt and lsat lettres plus their oravell ouiltnes rmeain cnsatont.\n"
;  "It is well konwn that a text can still be read while the iarnnds of its words have been sraemlbcd, as lnog as their first and lsat lrttees plus their oaevrll ontlieus remain canntsot.\n"
NikoNyrh
la source
Je pense que vous avez besoin \pL+et \PL+plutôt que d'exclure \w+et \W+d'exclure les chiffres et le soulignement.
Adám
0

Perl 6 , 241 195 octets

Inclut +1 octet pour le -pcommutateur de ligne de commande.

s:g/(<:L>)(<:L>+)(<:L>)/{$0}{[~]
$1.comb.pairs.classify({first
.value~~*,:k,/<[bdfhkl]>/,/<[gpqy]>/,/<[it]>/,/j/,!0}).values.map({$_».key
»=>«$_».value.pick(*)})».List.flat.sort».value}$2/;

Ungolfed:

s:g/(<:L>)(<:L>+)(<:L>)/{$0}{
    [~]
    $1.comb
    .pairs
    .classify({
        first .value ~~ *, :k,
            /<[bdfhkl]>/,
            /<[gpqy]>/,
            /<[it]>/,
            /j/,
            !0
    })
    .values
    .map({ $_».key »=>« $_».value.pick(*) })
    ».List
    .flat
    .sort
    ».value
}$2/;
Sean
la source
Je pense que vous avez besoin (\pL)(\pL+)(\pL)plutôt que (\w)(\w+)(\w)d'exclure les chiffres et le soulignement.
Adám
\pLComprend en fait beaucoup de caractères en dehors de la plage autorisée de lettres latines AZ. J'ai mis à jour mon code pour mieux refléter les exigences.
Sean
Quels personnages? Rappelez-vous que la saisie est limitée à ASCII + Newlines imprimables.
Adám
Ah, j'ai raté ça. \pLest orthographié <:L>en Perl 6 cependant.
Sean
0

C #, 438 394 380 374 octets

namespace System.Text.RegularExpressions{using Linq;s=>Regex.Replace(s,@"\p{L}(([gpqy])|(i|t)|(j)|([bdf-l])|([a-z]))*?[a-z]?\b",m=>{var a=m.Value.ToArray();for(int i=1,j;++i<7;){var c=m.Groups[i].Captures;var n=c.Cast<Capture>().Select(p=>p.Index-m.Index).ToList();foreach(Capture p in c){a[j=n[new Random().Next(n.Count)]]=p.Value[0];n.Remove(j);}}return new string(a);});}

Économisez 10 octets grâce à @ MartinEnder ♦.

De manière ennuyeuse, CaptureCollectionne met pas en œuvreIEnumerable<T> et c'est pourquoi le .Cast<Capture>()nécessaire. Si tout va bien, je peux cependant combiner la requête Linq et la foreachboucle.

Je suis sûr qu'il y a beaucoup de choses qui peuvent être jouées au golf, mais cela m'a pris assez de temps juste pour que ça fonctionne ...

Essayez-le en ligne!

Version formatée / complète:

namespace System.Text.RegularExpressions
{
    using Linq;

    class P
    {
        static void Main()
        {
            Func<string, string> f = s =>
                Regex.Replace(s, @"\p{L}(([gpqy])|(i|t)|(j)|([bdf-l])|([a-z]))*?[a-z]?\b", m =>
                {
                    var a = m.Value.ToArray();

                    for (int i = 1, j; ++i < 7;)
                    {
                        var c = m.Groups[i].Captures;

                        var n = c.Cast<Capture>().Select(p => p.Index - m.Index).ToList();

                        foreach(Capture p in c)
                        {
                            a[j = n[new Random().Next(n.Count)]] = p.Value[0];
                            n.Remove(j);
                        }
                    }

                    return new string(a);
                });

            Console.WriteLine(f("Scramble words while preserving their outlines"));
            Console.ReadLine();
        }
    }
}
TheLethalCoder
la source