นี่คือขั้นสูงกว่าวิธีการสุ่มตัวอักษรในคำและการขนย้าย Cambridgeเนื่องจากกฎเกี่ยวกับตัวอักษรที่อาจสลับกับที่ regex ง่าย ๆ จะไม่เพียงพอที่นี่

เป็นที่ทราบกันดีว่าข้อความยังคงสามารถอ่านได้ในขณะที่คำในประโยคถูกกวนใจตราบใดที่ตัวอักษรตัวแรกและตัวสุดท้ายรวมถึงโครงร่างโดยรวมยังคงไม่เปลี่ยนแปลง รับ Ascii + Newline text ที่พิมพ์ได้, แย่งแต่ละคำตามกฎเหล่านี้:

1. Scrambling ต้องสุ่ม (หลอก)

2. คำคือลำดับของอักขระละติน A ถึง Z

3. ตัวอักษรเริ่มต้นเท่านั้นที่จะเป็นตัวพิมพ์ใหญ่

4. ตัวอักษรตัวแรกและตัวสุดท้ายจะต้องไม่ถูกแตะต้อง

5. เมื่อมีการทะเลาะกันมีเพียงตัวอักษรภายในกลุ่มใดกลุ่มหนึ่งต่อไปนี้เท่านั้นที่สามารถแลกเปลี่ยนสถานที่:

   1. acemnorsuvwxz

   2. bdfhkl

   3. gpqy

   4. it

   5. j (อยู่ในสถานที่)

ตัวอย่าง

Srcmable wrods ในขณะที่ psrrnveieg oeiltnus

เป็นที่ทราบกันดีว่า txet ยังคงสามารถอ่านได้ในขณะที่ inrands ของ wrods ของมันถูก srcambled ตราบใดที่ fisrt และตัวอักษรสุดท้ายของพวกเขารวมทั้ง ovaerll ontliues raemin canstnot ได้รับ patnirlbe Acsii + Nwnliee txet, samrclbe ecah คำ anoccdirg กับ relus เหล่านี้:

1. Smncrbliag ต้องเป็น (pusedo) rondam

2. Wrod เป็นสิ่งที่ต้องจดจำของละติน chreratacs, A thurogh Z.

3. เฉพาะ lrttees iniital เท่านั้นที่จะเป็น uppcsaere

4. ตัวอักษร fisrt และ lsat จะต้องอยู่ในช่วง uctoenhud

5. เมื่อ sarnclbimg มีเพียงตัวอักษร wihtin หนึ่งใน guws fwllnoiog guorps ที่อาจรวมตัวกัน:

   1. aneusvrowxmcz

   2. bhkfdl

   3. gqpy

   4. it

   5. j (อยู่ใน plcae)

Emxaple

เยลลี่ , 80 74 ไบต์

-2 ไบต์โดยการย้ายจากczar + vex + mow + sunไปยัง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) ซึ่งพิมพ์ผลลัพธ์ของการแปลง

ลองออนไลน์!

จำนวนมากของความยากลำบากสำหรับวุ้นนี่มันดูเหมือนว่า (ทั้งที่หรือฉันได้พลาดเคล็ดลับซึ่งได้รับการรู้จักที่จะเกิดขึ้น!) นี้ก็จะได้รับการตีโดยภาษาที่มีการจัดการที่ดีกว่าสายเช่นจอประสาทตา (ไม่มีฟังก์ชันสุ่ม) หรือ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

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

ksort

preg_replace_callback

สับเปลี่ยน

Pyth , 79 ไบต์

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

อยู่ที่ไหน❤U + 0018

ลองออนไลน์!

ตัวอย่าง

เป็นที่รู้กันดีว่าข้อความยังคงสามารถถูกยกขึ้นได้ในขณะที่ผืนน้ำใน wrods ของมันได้รับ seraclbmd ตราบใดที่ยังมีตัวอักษรตัวแรกและตัวสุดท้ายรวมถึง oaervll ontliues rmeain รับข้อความ, sacmrble แต่ละ wrod acrncdiog เพื่อ thsee relus:

1. Scamrlbing จะต้อง (puesdo) rnadom

2. คำพูดคือ suqencee ของ chraectars ละติน, thuorgh Z.

3. เฉพาะตัวอักษร iaitinl เท่านั้นที่จะเป็น uppaersce

4. ครั้งแรกและครั้งสุดท้ายที่ msut อยู่ uotcnuhed

5. เมื่อ srancblimg เพียงคนเดียวที่มีหนึ่งใน guolls follnwiog อาจ enxhcage plecas:

   1. amsuvrcnoxewz

   2. bhfkdl

   3. gpqy

   4. it

   5. j (อยู่ในสถานที่)

จาวาสคริปต์ 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) โดยใช้ 1st แทนที่ fn

2. 1st แทนที่ fn วนซ้ำแถวลำดับของ RegExp สำหรับแต่ละกลุ่มตัวอักษร ( /[bdfkhl/g, /[gqpy]/g, etc..)

3. การวนซ้ำแต่ละครั้งจะสร้างอาร์เรย์ชั่วคราวของตัวละครของ word-centre ที่ปรากฏในกลุ่มจดหมายปัจจุบัน

4. การวนซ้ำแต่ละครั้งจะใช้ RegExp ของกลุ่มจดหมายปัจจุบันเพื่อย้ำไปทั่วทั้งศูนย์คำโดยใช้การแทนที่ที่ 2 fn

5. 2nd แทน fn สุ่ม splices อาร์เรย์ temp เอาอักขระสุ่มแล้วส่งคืน

การสาธิต:

เปิดใช้ใน JSFiddle: https://jsfiddle.net/CookieJon/bnpznb7r/

C, 453, 356 369 ไบต์

#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 ด้วยความคิดเห็น

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

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 ถาม

Mathematica 232 Bytes

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 กลุ่มที่แตกต่างกัน อาจเป็นห้องสำหรับการปรับปรุง

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

ลองออนไลน์

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 Bytes

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

Clojure, 326 322 324 ไบต์

อัปเดต 1: แทนที่(map(fn[[k v]]...)...)ด้วย(for[[k v]...]...)

อัปเดต 2: แก้ไข regex ใช้\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"

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

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 ไบต์

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

บันทึก 10 ไบต์ด้วย @ MartinEnder ♦

น่ารำคาญ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();
        }
    }
}