Складайте слова, зберігаючи їх контури


44

Це набагато досконаліше, ніж Як рандомізувати букви в слові та « Кембриджська транспозиція» через правило про те, якими літерами можна міняти місцями. Тут не вистачить простого регулярного виразка.


Добре відомо, що текст все ще можна прочитати, поки внутрішні його слова були скрембліровані до тих пір, поки їхні перші та останні букви плюс їх загальні контури залишаються постійними. З огляду на текст для друку Ascii + Newline, скремтуйте кожне слово відповідно до цих правил:

  1. Скремблінг повинен бути (псевдо) випадковим.

  2. Слово - це послідовність латинських символів, від А до Я.

  3. Лише початкові літери коли-небудь будуть великими літерами.

  4. Перша та остання букви повинні залишатися недоторканими.

  5. Під час кодування, лише листи в одній із наступних груп можуть обмінюватися місцями:

    1. acemnorsuvwxz

    2. bdfhkl

    3. gpqy

    4. it

    5. j (залишається на місці)

Приклад

Srcmable wrods, поки psrrnveieg їх oeiltnus

Добре відомо, що txet все ще можна прочитати, поки внутрішні частини його wrods були зруйновані, до тих пір, поки їх fisrt і останні букви плюс їх ovaerll ontliues raemin не можуть. Враховуючи patnirlbe Acsii + Nwnliee txet, слово samrclbe ecah anoccdirg до цих релюсів:

  1. Smncrbliag повинен бути (pusedo) rondam.

  2. Врод - це послідовність латинських креретів, A thurogh Z.

  3. Підвищуватимуться лише ті, що починаються з першокласників.

  4. Фіскальний та лісатський риси повинні залишатися непрограшними.

  5. Якщо sarnclbimg, лише літери, що знаходяться в одному з guorps fwllnoiog, можуть вимкнути плаценти:

    1. aneusvrowxmcz

    2. bhkfdl

    3. gqpy

    4. it

    5. j (залишається в plcae)

Emxaple


tповинна бути коротшою, hхоча багато людей так не пишуть.
Лина монашка

@LeakyNun Я знаю, але ви пропонуєте видалити tз групи 2? А може, ввести tв групу 4 с i?
Адам

Останнє було б добре.
Лина монашка

може теоретично невиконаний час виконання не обмежений? (як випадкові спроби, поки щось не в порядку)
Сардж Борщ

1
printable/ patnirlbeне зовсім читабельна. Я думаю i/ tвинна в / swap. Хм ... paintrlbeНі, це теж не допомогло. Це, мабуть, pr/ paswap. Контур підтримує, але я думаю , що я прочитав «PR» і «па» як семантичний (?) 1 лист. prtnialbeАга так. Це і вдалося. Не впевнений, що я можу запропонувати виправити алгоритм.
Draco18s

Відповіді:


9

Желе , 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), який друкує результат скремблювання.

Спробуйте в Інтернеті!

Здається, велика кількість труднощів для 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

Насправді важче, ніж я думав.
Лина монашка

@LeakyNun welp, мені знадобилося набагато більше часу, ніж 10 хвилин.
Джонатан Аллан

1
@JonathanAllan Так, це вже багато років, і, ймовірно, буде частиною наступного випуску, тому що це клопоче мене багато разів.
Мартін Ендер

1
czar + vex + mow + sun
Адам

3
@ Словник пошуку словника Адама формується 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

ksort

preg_replace_callback

перетасувати


Порада: Ви можете використовувати налаштування "відключити кеш-код виводу" на TIO, а не виконувати код кілька разів. Я просто запустив це з прикладом - Все добре!
Джонатан Аллан

@JonathanAllan Дякую за пораду з кешем. Досить важко було знайти спосіб вирішити це питання
Йорг Гюльсерманн

5

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 conntsat. З огляду на текст, перезаписуйте кожен wr acrncdiog, щоб побачити релюси:

  1. Скандалінг повинен бути (puesdo) rnadom.

  2. Слово - це підступ латинських chraectars, A thuorgh Z.

  3. Лише iaitinl Lettres буде підвищений.

  4. Перший і останній літери не залишаються розкритими.

  5. Коли виконується srancblimg, лише одні літери, що містять один з гурпів follnwiog, можуть збільшити плекас:

    1. amsuvrcnoxewz

    2. bhfkdl

    3. gpqy

    4. it

    5. j (залишається на місці)


Ви не можете заощадити \pLзамість цього [A-Za-z]?
Адам

@ Adám Що таке \pL?
Leaky Nun

Будь-який символ з р roperty того , щоб бути л Etter.
Adám

Я не думаю, що це працює тут ...
Leaky Nun

не \wвистачило б?
Sarge Borsch

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) за допомогою 1-ї заміни fn.

  2. 1-а заміна fn ітератує масив RegExp для кожної групи літер ( /[bdfkhl/g, /[gqpy]/g, etc..).

  3. Кожна ітерація створює тимчасовий масив символів слова-центру, що відображаються в поточній групі листів.

  4. Кожна ітерація потім використовує поточну RegExp групу листів для ітерації по всьому словесному центру, використовуючи другий fn заміни.

  5. Друга заміна fn випадковим чином сплайсує тимчасовий масив, видаливши випадковий символ і повернувши його.

Демонстрація:

Запустити його в JSFiddle: https://jsfiddle.net/CookieJon/bnpznb7r/


Ласкаво просимо до PPCG. Дивовижна перша відповідь. Однак я думаю, що вам потрібно, \pL(\pL+)\pLа не \B(\w+)\Bвиключати цифри та підкреслення.
Адам

Ах, дякую! Потрібно визнати, що регулярний вираз не є моєю сумкою (я повинен шукати посилання кожен раз, коли я його використовую!) Я можу проковтнути 3 зайвих символи ... оновлю свою відповідь незабаром знову дякую. :-)
Bumpy

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). сплайс (нова дата% g.length, 1), g = b.match (d))), b))
Shaggy

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

1

Python 3.6, 349 340 байт

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. Він не використовує грубу силу, час виконання є детермінованим, як просив ОП.


1

Математика 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, і це, можливо, означає, що воно починає робити 999 можливих свопів за допомогою 1 + rand ()% -1, тому випадковим чином запишіть у 2 гіга пам'яті ... Але можливо я бачу це неправильно ....
RosLuP

На жаль, ніяких магій щодо використання 999 немає. Це всього на 1 байт менше 1000 :)
Йохан дю Тойт

У gcc здається, що rand ()% (- 1) return 0, перший раз, коли я його спробував. тому можливий жодний обмін випадковим 2гіга простором ...% int не є% непідписаних ...
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 повинні бути включені до підрахунку байтів. До травня я мав на увазі мати шанс .
Адам

1
Ласкаво просимо до PPCG :) Ви, безсумнівно, можете багато пограти .
Кудлатий

1
Я збирався спробувати пограти в гольф для вас, але, враховуючи, скільки можна зробити з цим, у мене закінчилося час, тому замість цього я вкажу вас тут і тут, щоб допомогти вам почати.
Кудлатий

1
Кілька швидких покажчиків, хоча: 01) Позбавтеся від всіх varS letс. 02) Якщо це не рекурсивна функція, не потрібно включати оголошення змінної ( f=) у свій байт. 03) Використовуйте currying, коли функція має 2 параметри ( b=>d=>замість (b,d)=>) та зателефонуйте за допомогою функції f(b)(d). 04) У вас є iпрапор, тому не потрібно включати його A-Zв регулярний вираз. 05) Ви можете використовувати indexOfабо searchна рядок, не розбиваючи його на масив.
Кудлатий

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+виключити цифри і підкреслення.
Адам

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)виключати цифри та підкреслення.
Адам

Насправді \pLвключає багато символів поза дозволеним діапазоном латинських літер AZ. Я оновив свій код, щоб точніше відобразити вимоги.
Шон

Які символи? Пам’ятайте, що введення обмежено для друку ASCII + Нові рядки.
Адам

Ах, я пропустив це. Хоча \pLнаписано <:L>в Perl 6.
Шон

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

Збережіть 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();
        }
    }
}
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.