Bu, hangi harflerin hangi harflerle değiştirilebileceği konusundaki kural nedeniyle, bir kelimedeki harflerin nasıl randomize edileceği ve Cambridge Transpozisyonu'ndan çok daha ileridir . Basit bir regex burada yeterli olmayacak.

Bir metnin, ilk ve son harfleri artı genel anahatları sabit kaldığı sürece sözcüklerinin iç kısımları karıştırılmış durumdayken okunabileceği iyi bilinmektedir. Yazdırılabilir bir Ascii + Newline metni verildiğinde, her bir kelimeyi bu kurallara göre karıştırın:

1. Çırpma (rasgele) rastgele olmalıdır.

2. Bir kelime, Latin alfabesinin A'dan Z'ye bir dizisidir.

3. Sadece ilk harfler büyük harf olacak.

4. İlk ve son harflere dokunulmamalı.

5. Karıştırırken, yalnızca aşağıdaki gruplardan birindeki harfler yer değiştirebilir:

   1. acemnorsuvwxz

   2. bdfhkl

   3. gpqy

   4. it

   5. j (yerinde kalır)

Örnek

Srcmable wrods onların yüce psrrnveieg iken

Hammaddelerinin terazileri kaynaşmış halde iken, bir txet'in hala okunabildiği iyi bilinmektedir, mali mektubu ve son mektupları ile yumurtalık teneke kutularını doldurmadıkça. Bir patnirlbe Acsii + Nwnliee txet verildiğinde, samrclbe ecah kelimesini bu relus'a anoccdirg:

1. Smncrbliag (pusedo) rondam olmalı.

2. Bir wrod, Latin şarlatanların, A thurogh Z'nin bir sekansıdır.

3. Sadece iniital lrttees uppcsaere olacak.

4. İlk ve kalanlar, uctoenhud'da kalmalı.

5. Sarnclbimg, sadece fwllnoiog guorps'tan birindeki harfleri plaçları değiştirebilir:

   1. aneusvrowxmcz

   2. bhkfdl

   3. gqpy

   4. it

   5. j (plcae kalır)

Emxaple

Jöle , 80 74 bayt

-2 doğru hareket ederek bayt czar + vex + mow + suniçin czar + vexes + unmown(tekrar es ve ns bir sorun değildir)
-1 bayt kullanılarak Tịyerine ȦÐf
-1 bayt kullanılarak Œle€Øayerine i@€ØB>⁵
-2 küçük düzeni yeniden yapılandırarak bayt

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

Scrambling sonucunu yazdırır karakter listesi (veya Python formatlı dize) alarak tam bir program.

Çevrimiçi deneyin!

Jelly için burada çok büyük bir zorluk var gibi görünüyor (ya da bunun olduğu bilinen bir numarayı kaçırdım!) Bu, kesinlikle Retina (rastgele işlevsellik yok) ya da 05ab1e gibi daha iyi string manipülasyonu olan diller tarafından dövülecek .

Nasıl?

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

PHP, 278 Bayt

<?=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);

Çevrimiçi deneyin!

Expanded

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

fonksiyonlar

array_combine

array_filter

array_keys

ksort

preg_replace_callback

Karıştır

Pyth , 79 bayt

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

nerede ❤U + 0018.

Çevrimiçi deneyin!

Numune

İlk ve son kalanlar artı kalan süreleri devam ettiği sürece, kaynaklarının kenarları seraclbmd iken, bir metnin hala basılabileceği bir gerçektir. Bir metin verilmişse, her wrod acrncdiog relus thsee için sakmrble:

1. Dolandırıcılık (puesdo) rnadom olmalıdır.

2. Bir kelime, Latin chraectars, A thuorgh Z.

3. Sadece her şey bilenler yaşarlar.

4. İlk ve son kişi msut kalır.

5. Srancblimg olduğunda, follnwiog guorps'tan sadece bir tanesi boşuna olabilir:

   1. amsuvrcnoxewz

   2. bhfkdl

   3. gpqy

   4. it

   5. j (yerinde kalır)

JavaScript 176 bayt

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

Yöntem:

1. RegExp, /\B(\w+)\B/g1. yerine fn tuşunu kullanarak her kelimenin ( ) ortasını tekrar eder .

2. Fn'nin ilk yerine, her bir mektup grubu ( /[bdfkhl/g, /[gqpy]/g, etc..) için bir RegExp dizisi tekrarlanır .

3. Her yineleme, geçerli harf grubunda görünen geçici bir sözcük merkezi karakter dizisi oluşturur.

4. Her bir yineleme daha sonra fn yerine 2. bir harf kullanarak tüm kelime merkezini yinelemek için geçerli harf grubunun RegExp'ini kullanır.

5. Fn'nin 2. yerine rastgele temp dizisi eklenir, rastgele bir karakter kaldırılır ve döndürülür.

Demo:

JSFiddle'da çalıştırın: https://jsfiddle.net/CookieJon/bnpznb7r/

C, 453,356 369 bayt

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

yorumları ile ungolf

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

Python 3.6, 349 340 bayt

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)

Sekmeler ile girintili. İşlev adlandırılmıştır A. Kaba kuvvet kullanmıyor, OP'nin istediği gibi çalışma zamanı determinist.

Mathematica 232 Bayt

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"})]]]&

Temel fikir, 4 farklı karakter grubuna karşılık gelen alt kümelere izin vermektir. Muhtemelen iyileştirme için yer var.

C, 306 282 Bayt

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

Çevrimiçi deneyin

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

JavaScript (ES6), 380 327 311 294 Bayt

( 298 282 265 Bayt kuralları hariç)

Yararlı ipuçları için @Shaggy'e teşekkürler!

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

Fonksiyon f herhangi bir (tek kelime, birden fazla kelimeyi, içinde işaretleri ile birden fazla kelime - bu kelime-kırma olarak yorumlar) bir dizi alır ve bir dizi herhangi bir uzunlukta "kurallar" bir dizi virgülle ayrılmış.

Sorunuz durumunda, bu kurallar dizisi olacaktır. ["aneusvrowxmcz", "bhkfdl", "gqpy", "it"] "aneusvrowxmcz,bhkfdl,gqpy,it"

Bazı harfler, karıştırılsalar bile karışmazlar, çünkü sorunuzda harflerin “yer değiştirebileceğini” belirtmişsinizdir. Yanlış yorumladıysam, kodu her zaman kurallara uyan harfleri karıştırmak için değiştirebilirim.

Bunun çok büyük miktarda bayt olduğunu biliyorum ve golf dilleriyle rekabet edemeyecek, ama yine de denemek istedim, beğeneceğinizi umuyorum :)

İnsan tarafından okunabilen, genişletilmemiş kod:

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

Clojure, 326 322 324 bayt

Güncelleme 1: değiştirilmiştir (map(fn[[k v]]...)...)ile(for[[k v]...]...)

Güncelleme 2: vb \pLyerine kullanarak sabit regex\w

#(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+"%)))))

Daha kısa bir şey görmek için sabırsızlanıyorum. Birkaç örneklem ile eski sürüm sürüm:

(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"

Perl 6 , 241 195 bayt

-pKomut satırı anahtarı için +1 bayt içerir .

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

C #, 438 394 380 374 bayt

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

@ MartinEnder ♦ sayesinde 10 bayt kazanın.

Can sıkıcı bir şekilde, CaptureCollectionuygulama yapmazIEnumerable<T> ve bu yüzden .Cast<Capture>()gerekli. Umarım, Linq sorgusunu ve foreachdöngüyü birleştirebilirim .

Eminim golf oynayabilecek çok şey var, ama işe yarayacak kadar uzun sürdü ...

Çevrimiçi deneyin!

Biçimlendirilmiş / Tam sürüm:

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