Verwirren Sie Wörter unter Beibehaltung ihrer Konturen

44

Dies ist weitaus fortgeschrittener als das zufällige Anordnen von Buchstaben in einem Wort und die Cambridge-Umsetzung, da festgelegt ist, welche Buchstaben mit welchen Buchstaben ausgetauscht werden dürfen. Ein einfacher regulärer Ausdruck wird hier nicht ausreichen.


Es ist bekannt, dass ein Text noch gelesen werden kann, während die Innereien seiner Wörter verwürfelt wurden, solange der erste und letzte Buchstabe sowie die Gesamtkonturen konstant bleiben. Verwürfle jedes Wort mit einem druckbaren ASCII + Newline-Text nach den folgenden Regeln:

  1. Das Scrambling muss (pseudo) zufällig sein.

  2. Ein Wort ist eine Folge der lateinischen Buchstaben A bis Z.

  3. Es werden immer nur Anfangsbuchstaben in Großbuchstaben geschrieben.

  4. Der erste und der letzte Buchstabe müssen unangetastet bleiben.

  5. Beim Verschlüsseln dürfen nur Buchstaben aus einer der folgenden Gruppen Plätze tauschen:

    1. acemnorsuvwxz

    2. bdfhkl

    3. gpqy

    4. it

    5. j (bleibt an Ort und Stelle)

Beispiel

Srcmable wrods während psrrnveieg ihre oeiltnus

Es ist allgemein bekannt, dass ein Text noch gelesen werden kann, während die Inrands seiner Wrods verschlüsselt wurden, solange ihre ersten und letzten Buchstaben sowie ihre übergeordneten Einträge nicht geändert werden können. Angesichts eines Patnirlbe Acsii + Nwnliee txet, samrclbe ecah Wort anoccdirg zu diesen relus:

  1. Smncrbliag muss (pusedo) rondam sein.

  2. Ein Wrod ist eine Rettung der lateinischen Chreratacs, A thurogh Z.

  3. Nur die ersten Teilnehmer werden höher sein.

  4. Die fisrt- und lsat-Lettres müssen uctoenhud bleiben.

  5. Beim Garnclbimg dürfen nur Buchstaben mit einem der fwllnoiog-Guorps die Plaeke tauschen:

    1. aneusvrowxmcz

    2. bhkfdl

    3. gqpy

    4. it

    5. j (bleibt in plcae)

Emxaple

Adam
quelle
tsoll kürzer sein als hobwohl viele leute es nicht so schreiben.
Undichte Nonne
@LeakyNun Ich weiß, aber schlagen Sie vor, taus Gruppe 2 zu entfernen ? Oder vielleicht tin einer Gruppe 4 mit setzen i?
Adám,
Letzteres wäre in Ordnung.
Undichte Nonne
Kann die Laufzeit theoretisch unbegrenzt sein? (wie zufällige Versuche, bis etwas stimmt)
Sarge Borsch
1
printable/ patnirlbeIst nicht gut lesbar. Ich denke der i/ tSwap ist schuld. Hmm ... paintrlbeNein, das hat auch nicht geholfen. Dann ist es wahrscheinlich der pr/ paswap. Die Gliederung bleibt erhalten, aber ich denke, dass ich "pr" und "pa" als semantisch (?) 1 Buchstaben gelesen habe. prtnialbeAh ja. Das hat es geschafft. Ich bin mir nicht sicher, ob ich eine Lösung für den Algorithmus anbieten kann .
Draco18s

Antworten:

9

Jelly , 80 74 Bytes

-2 Bytes durch Verschieben von czar + vex + mow + sunnach czar + vexes + unmown(das wiederholte es und ns ist kein Problem)
-1 Bytes Tịanstelle von ȦÐf
-1 Bytes Œle€Øaanstelle von i@€ØB>⁵
-2 Bytes durch ein wenig Umkonfigurieren des Layouts

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

Ein vollständiges Programm, das eine Zeichenliste (oder eine Python-formatierte Zeichenfolge) verwendet, die das Ergebnis der Verschlüsselung ausgibt.

Probieren Sie es online!

Eine Menge Schwierigkeiten für Jelly, wie es scheint (entweder das oder ich habe einen Trick verpasst, der bekanntermaßen passiert!). Dies wird sicherlich von Sprachen mit besserer String-Manipulation wie Retina (keine zufällige Funktionalität) oder 05ab1e übertroffen .

Wie?

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
Jonathan Allan
quelle
Es ist tatsächlich schwieriger als ich dachte.
Undichte Nonne
@LeakyNun welp es dauerte viel länger als 10 Minuten, um mich damit auseinanderzusetzen.
Jonathan Allan
1
@JonathanAllan Ja, es ist schon seit Ewigkeiten dort und wird wahrscheinlich Teil der nächsten Veröffentlichung sein, weil mich das schon oft nervt.
Martin Ender
1
czar + vex + mow + sun
Adám
3
@ Adám Wörterbuchsuchen zu bilden acemnorsuvwxz. Ich werde irgendwann auch kommentierten Code schreiben.
Jonathan Allan
5

PHP, 278 Bytes

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

Probieren Sie es online!

Erweitert

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

funktionen

array_combine

array_filter

array_keys

ksort

preg_replace_callback

Mischen

Jörg Hülsermann
quelle
Tipp: Sie können die Einstellung "Ausgabecache deaktivieren" in TIO verwenden, anstatt den Code einige Male auszuführen. Ich habe es nur mit dem Beispiel ausgeführt - Alles gut!
Jonathan Allan
@ JonathanAllan Danke für den Tipp mit dem Cache. Es war schon schwer genug, eine Lösung zu finden
Jörg Hülsermann,
5

Pyth , 79 Bytes

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

wo ist U + 0018.

Probieren Sie es online!

Stichprobe

Es ist wohlbekannt, dass ein Text immer noch geraubt werden kann, während die Irnanden seiner Wrods seraclbmd gewesen sind, solange ihre ersten und letzten Lettres plus ihre oaervll ontliues rmeain conntsat. Wenn Sie einen Text eingegeben haben, können Sie jeden Wrod-Acrncdiog wie folgt zusammenfassen:

  1. Scamrlbing muss (puesdo) rnadom sein.

  2. Ein Wort ist eine Abkürzung der lateinischen chraectars, A thuorgh Z.

  3. Nur iaitinl lettres werden upaersce sein.

  4. Der erste und der letzte Buchstabe bleiben unverändert.

  5. Wenn Sie schwimmen, dürfen nur Buchstaben mit einem der folgenden Guorps Plecas enthalten:

    1. amsuvrcnoxewz

    2. bhfkdl

    3. gpqy

    4. it

    5. j (bleibt an Ort und Stelle)

Undichte Nonne
quelle
Kannst du nicht mit \pLstatt sparen [A-Za-z]?
Adám,
@Adam Was ist \pL?
Undichte Nonne
Jedes Zeichen , mit dem p roperty des Seins ein L etter.
Adám,
Ich glaube nicht, dass es hier funktioniert ...
Undichte Nonne
wäre nicht \wgenug
Sarge Borsch
5

JavaScript 176 Bytes

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

Methode:

  1. RegExp iteriert über die Mitte jedes Wortes ( /\B(\w+)\B/g) mit 1st Replace Fn.

  2. 1. Ersetzen fn iteriert ein Array von RegExp's für jede Buchstabengruppe ( /[bdfkhl/g, /[gqpy]/g, etc..).

  3. Jede Iteration erstellt ein temporäres Array von Zeichen des Wortzentrums, die in der aktuellen Buchstabengruppe erscheinen.

  4. Jede Iteration verwendet dann RegExp der aktuellen Buchstabengruppe, um über die gesamte Wortmitte zu iterieren, wobei ein zweites Ersetzungs-Fn verwendet wird.

  5. 2nd replace fn spleißt das temporäre Array nach dem Zufallsprinzip, entfernt ein zufälliges Zeichen und gibt es zurück.

Demo:

Führen Sie es in JSFiddle aus: https://jsfiddle.net/CookieJon/bnpznb7r/

Holperig
quelle
Willkommen bei PPCG. Erstaunliche erste Antwort. Aber ich glaube , Sie brauchen \pL(\pL+)\pLnicht \B(\w+)\Bzu Ziffern und Unterstreichungs auszuschließen.
Adám,
Ah danke! Ich muss zugeben, dass Regex nicht meine Tasche ist (ich muss die Referenz jedes Mal nachschlagen, wenn ich sie benutze!) Ich kann die 3 zusätzlichen Zeichen schlucken ... werde meine Antwort in Kürze aktualisieren, danke noch einmal. :-)
Holpriger
1
Unglaubliche erste Antwort! :) Ein paar schnelle Verbesserungen für Sie, um Sie auf 155 Bytes zu bringen, einschließlich der @ Adáms-Korrektur oben: t => t.replace (/ \ B [az] + \ B / gi, b => ([/ [acemnorsuvwxz ] / g, / [bdfhkl] / ‌ g, / [gpqy] / g, / [it] / g] .map (d => b = b.replace (‌ d, c => g. Spleiß (neues Datum% g.Länge, 1), g = b.Match (d))), b))
Shaggy
@ Shaggy Ich denke, b=>[...].map(...)&&bspart ein weiteres Byte. Ich bin mir auch nicht sicher, ob das inötig ist.
Neil
Wenn @ Adám mit seiner Wortdefinition streng pingelig sein wird, müssen Sie eine t.replace(/[A-Za-z]([a-z]+)(?=[a-z])/g,(w,b)=>...w[0]+b...)oder mehrere davon verwenden.
Neil
2

C, 453, 356, 369 Bytes

#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 mit kommentaren

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

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)

Mit Tabulatoren eingerückt. Die Funktion heißt A. Es wird keine rohe Gewalt angewendet, die Laufzeit ist gemäß OP deterministisch.

Sarge Borsch
quelle
1

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

Die Grundidee besteht darin, die Teilmengen zu permutieren, die den 4 verschiedenen Zeichengruppen entsprechen. Wahrscheinlich Raum für Verbesserungen.

Kelly Lowder
quelle
1

C 306 282 Bytes

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

Probieren Sie es online aus

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++;
    }
}
Johan du Toit
quelle
Warum möchten Sie mit einem Wort 999 tauschen? Weißt du, dass ein Wort eines Zeichens l = -1 hat und dies bedeutet möglicherweise, dass es anfängt, 999 möglichen Swap mit 1 + rand ()% -1 auszuführen, also schreibe zufällig in 2 Giga Speicher ... Aber ich verstehe es ist falsch ....
RosLuP
Es gibt leider keine Magie in Bezug auf die Verwendung von 999. Es ist nur 1 Byte weniger als 1000 :)
Johan du Toit
In gcc scheint rand ()% (- 1) beim ersten Versuch 0 zurückzugeben. so möglich kein Tausch von zufälligen 2giga-Leerzeichen ...% von int ist nicht das% von unsigned ...
RosLuP
@ RosLup, es tut mir leid, aber ich folge nicht, was Sie sagen ..
Johan du Toit
1

JavaScript (ES6), 380 327 311 294 Bytes

( 298 282 265 Bytes ohne die Regeln)

Vielen Dank an @Shaggy für die nützlichen Tipps!

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

Die Funktion f nimmt eine beliebige Zeichenfolge (ein einzelnes Wort, mehrere Wörter, mehrere Wörter mit Vorzeichen - was als Wortbruch interpretiert wird) und ein durch Kommas getrenntes Array von "Regeln" beliebiger Länge auf.

Bei Ihrer Frage wäre das eine Reihe von Regeln ["aneusvrowxmcz", "bhkfdl", "gqpy", "it"] "aneusvrowxmcz,bhkfdl,gqpy,it"

Einige Buchstaben werden nicht gemischt, obwohl dies möglich ist, da Sie in Ihrer Frage angegeben haben, dass Buchstaben "Leerzeichen austauschen können". Wenn ich es falsch interpretiert habe, kann ich den Code so ändern, dass immer Buchstaben verschlüsselt werden, die den Regeln entsprechen.

Ich weiß, das ist eine enorme Menge an Bytes und es wird nicht mit Golfsprachen konkurrieren können, aber ich wollte es trotzdem versuchen, hoffe es gefällt dir :)

Vom Menschen lesbarer, nicht uglifizierter Code:

((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")
Hankrecords
quelle
1
Die OP-Regeln müssen in die Byteanzahl einbezogen werden. Durch Mai , bedeuten , dass ich auf eine Chance hat .
Adám,
1
Willkommen bei PPCG :) Davon können Sie definitiv viel Golf spielen .
Shaggy
1
Ich wollte versuchen, das hier für Sie abzuspielen, aber da mir die Zeit dafür ausgeht, werde ich Sie hierher und hierher führen , um Ihnen den Einstieg zu erleichtern.
Shaggy
1
Ein paar schnelle Hinweise: 01) Alle vars und lets loswerden . 02) Sofern es sich nicht um eine rekursive Funktion handelt, müssen Sie die Variablendeklaration ( f=) nicht in Ihre Byteanzahl aufnehmen. 03) Verwenden Sie currying, wenn eine Funktion 2 Parameter hat ( b=>d=>statt (b,d)=>) und rufen Sie Ihre Funktion mit auf f(b)(d). 04) Sie haben die iFlagge, müssen also nicht A-Zin Ihre Regex aufgenommen werden. 05) Sie können indexOfoder searchfür einen String verwenden, ohne ihn in ein Array aufzuteilen.
Shaggy
1
Wie speichert Vorschlag 03 Zeichen? Sie sehen für mich genauso aus.
Steve Bennett
0

Clojure, 326 322 324 Bytes

Update 1: ersetzt (map(fn[[k v]]...)...)durch(for[[k v]...]...)

Update 2: Regex korrigiert, \pLanstelle von \wetc.

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

Ich freue mich darauf, etwas kürzeres zu sehen. Frühere ungolfed Version mit ein paar Beispielläufen:

(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"
NikoNyrh
quelle
Ich denke, Sie brauchen \pL+und \PL+anstatt \w+und \W+um Ziffern und Unterstriche auszuschließen.
Adám
0

Perl 6 , 241 195 Bytes

Enthält +1 Byte für die -pBefehlszeilenoption.

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/;
Sean
quelle
Ich glaube , Sie brauchen , (\pL)(\pL+)(\pL)anstatt (\w)(\w+)(\w)Ziffern und Unterstreichungs auszuschließen.
Adám,
\pLEnthält tatsächlich viele Zeichen außerhalb des zulässigen Bereichs der lateinischen Buchstaben AZ. Ich habe meinen Code aktualisiert, um die Anforderungen genauer wiederzugeben.
Sean
Welche Charaktere? Denken Sie daran, dass die Eingabe auf druckbare ASCII- und Zeilenumbrüche beschränkt ist.
Adám,
Ah, das habe ich verpasst. \pList allerdings <:L>in Perl 6 geschrieben.
Sean
0

C #, 438 394 380 374 Bytes

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

Sparen Sie 10 Bytes dank @ MartinEnder ♦.

Ärgerlicherweise CaptureCollectionnicht umsetzbarIEnumerable<T> und deswegen .Cast<Capture>()wird das benötigt. Hoffentlich kann ich die Linq-Abfrage und die foreachSchleife kombinieren .

Ich bin mir sicher, dass es eine Menge gibt, auf die man Golf spielen kann, aber ich habe lange genug gebraucht, um es zum Laufen zu bringen ...

Probieren Sie es online!

Formatiert / Vollversion:

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