在保留字词轮廓的同时加扰


44

这比“ 如何随机化单词中的字母Cambridge Transposition”要先进得多因为有关哪些字母可以与哪个字母互换的规则。一个简单的正则表达式在这里是不够的。


众所周知,只要单词的内脏都被打乱,只要它们的首尾字母以及它们的整体轮廓保持不变,仍可以阅读文本。给定可打印的Ascii + Newline文本,请按照以下规则对每个单词进行加扰:

  1. 加扰必须是(伪)随机的。

  2. 单词是拉丁字符从A到Z的序列。

  3. 只有首字母大写。

  4. 首字母和尾字母必须保持原样。

  5. 加扰时,只有以下组之一中的字母可以交换位置:

    1. acemnorsuvwxz

    2. bdfhkl

    3. gpqy

    4. it

    5. j (留在原地)

易腐烂,而他们的油菜

众所周知,只要其首字和末尾字母加上ovaerll ontliues raemin不能被破坏,txet仍可被读入,但其残言已被扰乱。给定一个patnirlbe Acsii + Nwnliee txet,samrclbe ecah单词anoccdirg表示这些规则:

  1. Smncrbliag必须是(pusedo)rondam。

  2. 刺是拉丁舞曲A thurogh Z的续集。

  3. 只有最初的小提琴才会成为uppcsaere。

  4. 必须先保持调音,再保持调音。

  5. 当使用sarnclbimg时,只有字母fwllnoiog guorps之一可能会出现以下情况:

    1. aneusvrowxmcz

    2. bhkfdl

    3. gqpy

    4. it

    5. j (入住plcae)

皇帝


th许多人不写的短。
Leaky Nun

@LeakyNun我知道,但是您建议t从第2组中删除吗?或t与一起加入第4组i
阿达姆(Adám)'17

后者会很好。
Leaky Nun

从理论上讲,运行时可以不受限制吗?(例如随机尝试,直到出现正确的情况为止)
Sarge Borsch,

1
printable/ patnirlbe不太可读。我认为i/ t交换是罪魁祸首。嗯... paintrlbe不,那也没有帮助。那么,可能是pr/ pa交换。该大纲维持,但我认为我读“公关”和“PA”作为语义(?),1个字母。 prtnialbe是啊。做到了。不确定我能否提供该算法的修复程序
Draco18s '17

Answers:


9

果冻80 74 字节

通过从- czar + vex + mow + sun移到-2字节czar + vexes + unmown(重复的es和ns都不成问题),
使用-1字节Tị而不是ȦÐf
-1字节,Œle€Øa而不是i@€ØB>⁵
-2字节,只需稍微重新配置布局

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

包含字符列表(或Python格式的字符串)的完整程序,该程序将显示加扰的结果。

在线尝试!

Jelly在这里似乎遇到了很多困难(要么或者我错过了一个窍门,这已经众所周知!)肯定会被具有更好的字符串操作的语言(例如Retina(无随机功能)或05ab1e击败

怎么样?

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

实际上,这比我想的要难。
Leaky Nun

@LeakyNun痛哭了我花了超过10分钟的时间。
乔纳森·艾伦

1
@JonathanAllan是的,它已经存在了很长时间,并且可能会成为下一个版本的一部分,因为这困扰了我很多次。
马丁·恩德

1
czar + vex + mow + sun
亚当

3
@Adám字典查找形成acemnorsuvwxz。我也会在某个时候编写注释的代码。
乔纳森·艾伦

5

PHP,278字节

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

在线尝试!

展开式

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

职能

array_combine

array_filter

array_keys

排序

preg_replace_callback

洗牌


提示:您可以在TIO上使用“禁用输出缓存”设置,而不是多次运行代码。我只是用示例来运行-一切都很好!
乔纳森·艾伦

@JonathanAllan感谢您提供有关缓存的提示。这是够难找到一个方法来解决这个问题
约尔格Hülsermann

5

Pyth,79个字节

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

U + 0018 在哪里

在线尝试!

样品

众所周知,只要文本的首字母和末尾字母加上它们的字母和字母都可以被拉动,文本仍然可以被拉动。给定一个文本,每个人都会屈从于求助于relus:

  1. 骗局一定是(puesdo)骚扰。

  2. 单词是拉丁语chraectars的后缀,A thuorghZ。

  3. 只有iaitinl lettres才能升级。

  4. 第一个和最后一个字母保持不变。

  5. 当srancblimg时,只有字母follnwiog guorps之一可能会阻塞plecas:

    1. amsuvrcnoxewz

    2. bhfkdl

    3. gpqy

    4. it

    5. j (留在原地)


您不能用\pL代替[A-Za-z]吗?
2015年

@Adám是什么\pL
Leaky Nun

任何字符与p的是一个roperty 大号埃特。
阿达姆(Adám)'17年

我认为它在这里不起作用…
Leaky Nun

\w不够吗?
萨尔赫·博尔希

5

JavaScript 176字节

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

方法:

  1. RegExp /\B(\w+)\B/g使用第一个替换fn 遍历每个单词()的中心。

  2. 第一个替换fn为每个字母组(/[bdfkhl/g, /[gqpy]/g, etc..)迭代一个RegExp数组。

  3. 每次迭代都会构建一个出现在当前字母组中的单词中心字符的临时数组。

  4. 然后,每次迭代都使用第二个替换fn使用当前字母组的RegExp迭代整个单词中心。

  5. 2nd replace fn随机拼接临时数组,删除随机字符并返回它。

演示:

在JSFiddle中运行它:https ://jsfiddle.net/CookieJon/bnpznb7r/


欢迎来到PPCG。惊人的第一答案。但是,我认为您需要\pL(\pL+)\pL而不是\B(\w+)\B排除数字和下划线。
2015年

啊,谢谢!必须承认正则表达式不是我的包(我每次使用它时都必须查找参考!)我可以吞下3个多余的字符...稍后将再次更新我的答案。:-)
Bumpy's

1
难以置信的第一答案!:)为您提供一些快速改进,使您可以减少到155个字节,包括上面的@Adáms校正:t => t.replace(/ \ B [az] + \ B / gi,b =>([/ [acemnorsuvwxz ] / g,/ [[bdfhkl] / ‌g,/ [gpqy] / g,/ [it] / g] ‌.map(d => b = b.replace(‌ d,c => g。 splice(new Date%g.length,1),g = b.match(d)),b))
毛茸茸的

@Shaggy我认为b=>[...].map(...)&&b可以节省另一个字节。另外,我不确定您i是否必要。
尼尔

如果@Adám对其词的定义严格挑剔,则需要使用t.replace(/[A-Za-z]([a-z]+)(?=[a-z])/g,(w,b)=>...w[0]+b...)或类似方法。
尼尔

2

C,453、356369字节

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

带有评论的高尔夫

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

1

Python 3.6、349340字节

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)

缩进制表符。该函数名为A。正如OP所要求的,它不使用蛮力,运行时是确定性的。


1

Mathematica 232字节

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

基本思想是置换与4个不同字符组相对应的子集。可能还有改进的空间。


1

C,306个 282字节

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

在线尝试

取消高尔夫:

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

您为什么要一句话进行999交换?您是否知道一个字符的一个字具有l = -1,这可能意味着它开始使用1 + rand()%-1进行999个可能的交换,因此在2 GB的内存中随机写入...但是我可能看到了错了
...。– RosLuP

不幸的是,使用999没有神奇之处。它仅比1000小了1个字节:)
Johan du Toit

在gcc中,rand()%(-1)在我尝试的前2次中似乎返回0。因此可能不会交换随机的2giga空间... int的百分比不是unsigned的百分比...
RosLuP

@RosLup,我很抱歉,但我不明白你在说什么..
约翰·杜伊特

1

JavaScript的(ES6),380 327 311 294字节

298 282 265字节不包括规则)

感谢@Shaggy提供有用的提示!

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

函数f接收任何类型的字符串(单个单词,多个单词,多个带有符号的单词-它将其解释为断字符)和一个数组该数组包含任意长度的“规则”字符串,这些规则由逗号分隔。

对于您的问题,这一系列规则将是 ["aneusvrowxmcz", "bhkfdl", "gqpy", "it"] "aneusvrowxmcz,bhkfdl,gqpy,it"

有些字母即使可以混合也不会混在一起,因为您在问题中说字母“可以交换空格”。如果我误解了它,我可以将代码更改为始终对符合规则的字母进行加扰。

我知道这是一个很大的字节,它无法与高尔夫语言竞争,但是我还是想尝试一下,希望您喜欢:)

易读的非丑化代码:

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

1
OP规则必须包含在字节数中。到五月,我的意思是有机会去
2015年

1
欢迎来到PPCG :)您绝对可以在这里打很多球。
毛茸茸的

1
我要去尝试高尔夫下来给你,但给多少可以用它做,我跑出来的时间,所以不是我点你这里,并在这里,以帮助您开始。
毛茸茸的

1
几个简单的指针,但:01)摆脱所有var秒的let秒。02)除非它是递归函数,否则不需要f=在字节数中包含变量声明()。03)当函数具有2个参数(b=>d=>而不是)时使用currying,(b,d)=>并使用调用函数f(b)(d)。04)您具有i标志,因此无需将其包含A-Z在正则表达式中。05)您可以在字符串上使用indexOfsearch,而无需将其拆分为数组。
毛茸茸的

1
建议03如何保存字符?他们对我来说看起来一样。
史蒂夫·贝内特

0

Clojure,326 322 324字节

更新1:替换(map(fn[[k v]]...)...)(for[[k v]...]...)

更新2:固定正则表达式,使用\pL代替\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+"%)))))

我期待看到更短的内容。较早的非高尔夫版本带有一些示例运行:

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

我想你需要\pL+\PL+而不是\w+\W+排除数字和下划线。
2015年

0

Perl 6的241个 195字节

包括+1字节的-p命令行开关。

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

取消高尔夫:

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

我认为您需要(\pL)(\pL+)(\pL)而不是(\w)(\w+)(\w)排除数字和下划线。
2015年

实际上\pL包含许多超出拉丁字母AZ允许范围的字符。我已经更新了代码以更准确地反映需求。
肖恩

哪个字符?请记住,输入仅限于可打印的ASCII +换行符。
阿达姆(Adám)'17年

啊,我错过了。 虽然在Perl 6中\pL是拼写的<:L>
肖恩

0

C#,438个 394 380 374字节

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♦节省了10个字节。

令人讨厌的是,CaptureCollection它没有实现IEnumerable<T>,这就是为什么.Cast<Capture>()需要的原因。希望我可以结合使用Linq查询和foreach循环。

我敢肯定有很多可以打高尔夫球的东西,但是花了我足够长的时间才使它起作用。

在线尝试!

格式化/完整版本:

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();
        }
    }
}
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.