Điều này tiên tiến hơn nhiều so với Cách ngẫu nhiên các chữ cái trong một từ và Chuyển vị Cambridge vì quy tắc về các chữ cái có thể được hoán đổi với từ nào. Một regex đơn giản sẽ không đủ ở đây.

Người ta biết rằng một văn bản vẫn có thể được đọc trong khi các từ bên trong của nó đã bị xáo trộn, miễn là các chữ cái đầu tiên và cuối cùng của họ cộng với các phác thảo tổng thể của chúng không đổi. Đưa ra một văn bản Ascii + Newline có thể in, xáo trộn từng từ theo các quy tắc sau:

1. Việc tranh giành phải là (giả) ngẫu nhiên.

2. Một từ là một chuỗi các ký tự Latin, từ A đến Z.

3. Chỉ các chữ cái đầu tiên sẽ được viết hoa.

4. Các chữ cái đầu tiên và cuối cùng phải được giữ nguyên.

5. Khi xáo trộn, chỉ các chữ cái trong một trong các nhóm sau có thể trao đổi địa điểm:

   1. acemnorsuvwxz

   2. bdfhkl

   3. gpqy

   4. it

   5. j (giữ nguyên vị trí)

Thí dụ

Wrods Srcmable trong khi psrrnveieg oeiltnus của họ

Người ta biết rằng một txet vẫn có thể được đọc trong khi các nội dung của wrods của nó đã bị srcambled, miễn là fisrt của họ và các chữ cái cuối cùng của họ ontliues raemin canstnot. Cho một patnirlbe Acsii + Nwnliee txet, samrclbe ecah từ anoccdirg cho các relus này:

1. Smncrbliag phải là (puseo) rondam.

2. Một wrod là một seqencue của chreratacs Latin, A thurogh Z.

3. Chỉ có lrttees vô sinh mới eevr sẽ được up.

4. Các lettres fisrt và lsat phải ở lại uctoenhud.

5. Khi sarnclbimg, chỉ các chữ cái có một trong các guorps fwllnoiog có thể ecxhange plaecs:

   1. aneusvrowxmcz

   2. bhkfdl

   3. gqpy

   4. it

   5. j (ở lại plcae)

Emxaple

Thạch , 80 74 byte

-2 byte bằng cách di chuyển từ czar + vex + mow + sunđến czar + vexes + unmown(lặp đi lặp lại es và ns không phải là một vấn đề)
-1 byte sử dụng Tịchứ không phải là ȦÐf
-1 byte sử dụng Œle€Øachứ không phải là i@€ØB>⁵
-2 byte bằng cách cấu hình lại cách bố trí một chút

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

Một chương trình đầy đủ lấy danh sách ký tự (hoặc chuỗi định dạng Python), in ra kết quả của sự xáo trộn.

Hãy thử trực tuyến!

Có vẻ như rất khó khăn cho Jelly ở đây (hoặc là tôi đã bỏ lỡ một mẹo, điều đã được biết là xảy ra!) Điều này chắc chắn sẽ bị đánh bại bởi các ngôn ngữ có thao tác chuỗi tốt hơn như Retina (không có chức năng ngẫu nhiên) hoặc 05ab1e .

Làm sao?

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 byte

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

Hãy thử trực tuyến!

Mở rộng

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

chức năng

mảng_combine

mảng_filter

mảng_key

ksort

preg numplace_callback

xáo trộn

Bình thường , 79 byte

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

nơi ❤là U + 0018.

Hãy thử trực tuyến!

Mẫu vật

Thật tốt khi một văn bản vẫn có thể được đưa ra trong khi các bản in của wrods của nó là seraclbmd, miễn là những chiếc xà lách đầu tiên và cuối cùng của họ cộng với oaervll ontliues rmeain conntsat. Đưa ra một văn bản, sacmrble mỗi wrod acrncdiog để thsee relus:

1. Scamrlbing phải là (puesdo) rnadom.

2. Một từ là một suqencee của các tác phẩm Latin, A thuorgh Z.

3. Chỉ có iaitinl lettres sẽ eevr được nâng cấp.

4. Những người cho thuê đầu tiên và cuối cùng vẫn ở lại uotcnuhed.

5. Khi srancblimg, chỉ những người cho phép một trong những guorps của follnwiog mới có thể enxhcage plecas:

   1. amsuvrcnoxewz

   2. bhfkdl

   3. gpqy

   4. it

   5. j (giữ nguyên vị trí)

JavaScript 176 byte

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

Phương pháp:

1. RegExp lặp lại qua trung tâm của mỗi từ ( /\B(\w+)\B/g) bằng cách sử dụng thay thế fn đầu tiên.

2. Lần đầu tiên thay thế fn lặp lại một mảng RegExp cho mỗi nhóm chữ cái ( /[bdfkhl/g, /[gqpy]/g, etc..).

3. Mỗi lần lặp lại xây dựng một mảng tạm thời các ký tự từ trung tâm xuất hiện trong nhóm chữ cái hiện tại.

4. Mỗi lần lặp sau đó sử dụng RegExp của nhóm chữ cái hiện tại để lặp lại trên toàn bộ trung tâm từ, sử dụng fn thay thế thứ 2.

5. Lần thứ 2 thay thế fn chia ngẫu nhiên mảng tạm thời, loại bỏ một ký tự ngẫu nhiên và trả lại nó.

Bản giới thiệu:

Chạy nó trong JSFiddle: https://jsfiddle.net/CookieJon/bnpznb7r/

C, 453, 356 369 byte

#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 với ý kiến

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

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)

Thụt lề với các tab. Hàm được đặt tên A. Nó không sử dụng vũ lực, thời gian chạy là xác định, như OP yêu cầu.

Toán học 232 byte

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

Ý tưởng cơ bản là hoán vị các tập con tương ứng với 4 nhóm ký tự riêng biệt. Có lẽ là phòng để cải thiện.

C, 306 282 byte

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

Dùng thử trực tuyến

Ung dung:

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 byte

( 298 282 265 byte không bao gồm các quy tắc)

Cảm ơn @Shaggy vì những lời khuyên hữu ích!

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

Chức năng f mất trong một chuỗi của bất kỳ loại (từ đơn, từ phức tạp, nhiều từ có dấu hiệu trong nó - mà nó diễn giải như word-breaking) và một mảng một chuỗi các "quy tắc" của bất kỳ chiều dài phân cách bằng dấu phẩy.

Mảng quy tắc đó, trong trường hợp câu hỏi của bạn, sẽ là ["aneusvrowxmcz", "bhkfdl", "gqpy", "it"] "aneusvrowxmcz,bhkfdl,gqpy,it"

Một số chữ cái không bị lẫn lộn mặc dù chúng có thể, vì bạn đã nêu trong câu hỏi của mình rằng các chữ cái "có thể trao đổi không gian". Nếu tôi giải thích sai, tôi có thể thay đổi mã để luôn xáo trộn các chữ cái phù hợp với quy tắc.

Tôi biết đây là một số lượng lớn byte và nó sẽ không thể cạnh tranh với các ngôn ngữ chơi gôn, nhưng dù sao tôi cũng muốn thử, hy vọng bạn thích nó :)

Mã không thể đọc được của con người:

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

Cập nhật 1: thay thế (map(fn[[k v]]...)...)bằng(for[[k v]...]...)

Cập nhật 2: regex cố định, sử dụng \pLthay vì \wvv

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

Tôi mong muốn được nhìn thấy một cái gì đó ngắn hơn. Phiên bản chưa được phát hành trước đó với một vài ví dụ chạy:

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

Bao gồm +1 byte cho -pchuyển đổi dòng lệnh.

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

Ung dung:

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 byte

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

Tiết kiệm 10 byte nhờ @ MartinEnder ♦.

Khó chịu, CaptureCollectionkhông thực hiệnIEnumerable<T> và đó là lý do tại sao .Cast<Capture>()cần thiết. Hy vọng rằng, tôi có thể kết hợp truy vấn Linq và foreachvòng lặp mặc dù.

Tôi chắc chắn có rất nhiều thứ có thể chơi gôn nhưng tôi đã mất đủ thời gian chỉ để nó hoạt động ...

Hãy thử trực tuyến!

Định dạng / Phiên bản đầy đủ:

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