Sono sicuro che la maggior parte, se non tutti, di voi si sono imbattuti in questo in un punto o nell'altro:

In occasione di una ricerca presso Cmabrigde Uinervtisy, non è in alcun modo in grado di resistere agli altri in un mondo, l'olmo iprmoetnt tihng è il primo e il momento è alla destra. L'rset può essere un toatl ms e puoi farlo alzare da solo. Tihs è perché il huamn mnid deos non ha raccolto Ervey lteter da istlef, ma il wrod come un wlohe.

• Crea un programma che inserisca qualsiasi quantità di testo. A scopo di test, utilizzare la versione non decodificata del testo sopra riportato, disponibile di seguito.

• Il programma deve quindi trasporre casualmente le lettere di ogni parola con una lunghezza di 4 o più lettere, tranne la prima e l'ultima lettera di ogni parola.

• Tutte le altre formattazioni devono rimanere invariate (maiuscole e punteggiatura, ecc.).

Testo di prova:

Secondo un ricercatore dell'Università di Cambridge, non importa in quale ordine siano le lettere in una parola, l'unica cosa importante è che la prima e l'ultima lettera siano nel posto giusto. Il resto può essere un disastro totale e puoi ancora leggerlo senza problemi. Questo perché la mente umana non legge ogni lettera da sola ma la parola nel suo insieme.

Come al solito, questo è un codice-golf. Il codice più corto vince.

Rubino - 50 48 caratteri, più -pparametro della riga di comando.

gsub(/(?<=\w)\w+(?=\w)/){[*$&.chars].shuffle*''}

Grazie @primo per -2 caratteri.

Test

➜  codegolf git:(master) ruby -p 9261-cambridge-transposition.rb < 9261.in
Acdrcinog to a racreseher at Cagribmde Ursvetniiy, it dsoen't mttaer in waht odrer the leertts in a word are, the olny ionarpmtt tnhig is that the fsirt and last letetr be at the rghit pcale. The rset can be a taotl mses and you can slitl raed it wthiuot perlbom. Tihs is buaecse the hmuan mind does not raed ervey lteetr by ietlsf but the word as a wlhoe.

Python, 118

Python è terribilmente imbarazzante per cose come questa!

from random import*
for w in raw_input().split():l=len(w)-2;print l>0and w[0]+''.join((sample(w[1:-1],l)))+w[-1]or w,

indennità

Ho provato alcune altre cose che pensavo fossero intelligenti, ma devi importare ogni sorta di cose, e molti metodi non hanno valori di ritorno, ma devono essere chiamati separatamente come propria dichiarazione. Il peggio è quando è necessario convertire la stringa in un elenco e quindi joinreinserirla in una stringa.

Ad ogni modo, ecco alcune delle cose che ho provato:

import re,random
def f(x):a,b,c=x.group(1,2,3);return a+''.join(random.sample(b,len(b)))+c
print re.sub('(\w)(\w+)(\w)',f,raw_input())

import itertools as i,random as r
for w in raw_input().split():print''.join(r.choice([x for x in i.permutations(w)if w[0]+w[-1]==x[0]+x[-1]])),

from random import*
for w in raw_input().split():
 w=list(w)
 if len(w)>3:v=w[1:-1];shuffle(v);w[1:-1]=v
 print ''.join(w),

PHP 84 byte

<?for(;$s=fgets(STDIN);)echo preg_filter('/\w\K\w+(?=\w)/e','str_shuffle("\0")',$s);

Usare una regex per catturare parole lunghe almeno 4 3 lettere ^† e mescolare i caratteri interni. Questo codice può gestire anche l'input con più righe.

Se è richiesta una sola riga di input (come nell'esempio), questa può essere ridotta a 68 byte

<?=preg_filter('/\w\K\w+(?=\w)/e','str_shuffle("\0")',fgets(STDIN));

^† C'è solo una lettera nel mezzo, quindi non importa se la mescoli.

J (48)

''[1!:2&4('\w(\w+)\w';,1)({~?~@#)rxapply 1!:1[3

Spiegazione:

• 1!:1[3: leggi tutti gli input da stdin
• rxapply: applica la funzione data alle porzioni dell'input che corrispondono alla regex
• ({~?~@#): un treno di verbi che mescola il suo input: #conta la lunghezza, questo viene applicato ad entrambi i lati ?dando N numeri distinti da 0 a N, {quindi seleziona gli elementi in quegli indici dalla matrice di input.
• ('\w(\w+)\w';,1): usa quel regex ma usa solo il valore del primo gruppo
• [1!:2&4: invia output non formattato a stdout
• ''[: elimina l'output formattato. Ciò è necessario perché altrimenti emette solo quella parte dell'uscita che si adatta su una linea terminale e quindi termina con ....

Retina , 10 byte

?V`\B\w+\B

Provalo online!

Ehi, questa vecchia sfida è stata fatta per la nuova Retina!

Spiegazione

\B\w+\Bfa corrispondere gruppi di lettere tra non confini, ovvero gruppi di lettere che non iniziano né finiscono una parola. Poiché le regex sono avide, questo corrisponderà a tutte le lettere di una parola tranne la prima e l'ultima.

Vè la fase "inversa", che inverte l'ordine dei personaggi in ogni partita della regex. Con l' ?opzione invece li rimescola.

107 APL

Sfortunatamente il mio interprete APL non supporta regexs, quindi ecco una versione home roll in cui il testo da mescolare è memorizzato nella variabile t:

⎕av[((~z)\(∊y)[∊(+\0,¯1↓n)+¨n?¨n←⍴¨y←(~z←×(~x)+(x>¯1↓0,x)+x>1↓(x←~53≤(∊(⊂⍳26)+¨65 97)⍳v←⎕av⍳,t),0)⊂v])+z×v]

In sostanza, il codice suddivide il testo in parole basandosi solo sulle lettere dell'alfabeto e quindi nelle lettere tra la prima e l'ultima lettera di quelle parole. Queste lettere vengono quindi rimescolate e l'intera stringa di caratteri riassemblata.

APL, 58 49

Credo che funzioni in IBM APL2 (non ho IBM APL)

({⍵[⌽∪t,⌽∪1,?⍨t←⍴⍵]}¨x⊂⍨~b),.,x⊂⍨b←' ,.'∊⍨x←⍞,' '

In caso contrario, quindi in Dyalog APL, aggiungi in primo piano:

 ⎕ML←3⋄

che aggiunge 6 caratteri

Ciò presuppone che i soli caratteri non di parole siano spazio, virgola e punto.

VBA, 351 373 /409

Sub v(g)
m=1:Z=Split(g," "):j=UBound(Z)
For u=0 To j
t=Z(u):w=Len(t):l=Right(t,1):If Not l Like"[A-Za-z]" Then w=w-1:t=Left(t,w):e=l Else e=""
If w>3 Then
n=Left(t,1):p=w-1:s=Right(t,p):f=Right(t,1)
For p=1 To p-1
q=w-p:r=Int((q-1)*Rnd())+1:n=n & Mid(s,r,1):s=Left(s,r-1) & Right(s,q-r)
Next
Else
n=t:f=""
End If
d=d & n & f & e & " "
Next
g=d
End Sub

Metodo alternativo (più grande):

Sub v(g)
m=1:Z=Split(g," "):j=UBound(Z)
For u=0 To j
t=Split(StrConv(Z(u),64),Chr(0)):w=UBound(t)-1:l=Asc(t(w)):If l<64 Or (l>90 And l<97) Or l>122 Then e=t(w):w=w-1 Else e=""
If w>3 Then
n=t(0):p=w-1:s=""
For i=-p To -1
s=t(-i) & s
Next
f=t(w)
For p=1 To p-1
r=Int((w-p)*Rnd())+1:n=n & Mid(s,r,1):s=Left(s,r-1) & Right(s,w-p-r)
Next
n=n & s
Else
n=Z(u):f="":e=""
End If
d=d & n & f & e & " "
Next
g=d
End Sub

Entrambi questi metodi cambiano il valore della variabile passata a Sub. vale a dire

Sub Test()
strTestString = "This is a test."
v strTestString
Debug.Print strTestString
End Sub

produrrà qualcosa del genere:

"Tihs is a tset."

Inoltre, questo rende casuale la punteggiatura a metà parola, quindi potrebbe non adattarsi al 100% delle specifiche.

APL NARS 172 caratteri

r←g x;i;s;d;k
s←⎕AV[98..123]∪⎕A
i←1⋄v←''⋄r←''⋄k←⍴x
A:d←''⋄→C×⍳i>k⋄d←x[i]⋄→C×⍳∼d∊s⋄v←v,d⋄i+←1⋄→A
C:v←{t←¯2+⍴r←⍵⋄t≤1:r⋄r[1+t?t]←⍵[1+⍳t]⋄r}v
r←∊r,v,d
v←''⋄i+←1⋄→A×⍳i≤k
g x←⍞

+ 17 + 13 + 18 + 44 + 41 + 17 + 8 + 5 9 = 172; Questa funzione g () ha input come stringa; ha un output come stringa. Aggiungo il comando di input perché non so come inserire \ 'in una stringa tra virgolette. Commentate

∇r←g x;i;s;d;k
   ⍝ words are element of  a-zA-Z separed from all other
   s←⎕AV[98..123]∪⎕A ⍝a-zA-Z ascii ⎕IO = 1
   i←1⋄v←''⋄r←''⋄k←⍴x
A:   d←''⋄→C×⍳i>k⋄d←x[i]⋄→C×⍳∼d∊s⋄v←v,d⋄i+←1⋄→A
C:      v←{t←¯2+⍴r←⍵⋄t≤1:r⋄r[1+t?t]←⍵[1+⍳t]⋄r}v
        r←∊r,v,d
        v←''⋄i+←1⋄→A×⍳i≤k
∇

risultato

g x←⍞
According to a researcher at Cambridge University, it doesn't matter in what order the letters in a word are, the only important thing is that the first and last letter be at the right place. The rest can be a total mess and you can still read it without problem. This is because the human mind does not read every letter by itself but the word as a whole.
  Androiccg to a rhraeecser at Cgirbdmae Uirevtsiny, it deson't mtetar in waht oderr the ltrtees in a wrod are, the olny intro
  apmt tinhg is taht the frsit and lsat lteter be at the rghit pacle. The rset can be a ttaol mses and you can siltl rae
  d it wtuhoit poeblrm. Tihs is bcsauee the hmaun mnid deos not raed eervy lteter by isletf but the wrod as a wolhe.

PHP 7.1, non in competizione, 80 byte

for(;$w=$argv[++$i];)echo$w[3]?$w[0].str_shuffle(substr($w,1,-1)).$w[-1]:$w," ";

accetta input dagli argomenti della riga di comando. Corri con -nr. (ovviamente fallirà alla punteggiatura)

PHP, 94 + 1 byte

+1 per la -Rbandiera

<?=preg_replace_callback("/(?<=\w)\w+(?=\w)/",function($m){return str_shuffle($m[0]);},$argn);

Ingresso del tubo attraverso php -nR '<code>'.

Nota: preg_replace_callbackarrivato a PHP in 4.0.5; chiusure sono state introdotte in php 5.3;
quindi questo richiede PHP 5.3 o successivo.

Sfortunatamente, la corrispondenza viene sempre inviata come un array, anche se non ci sono sottotitoli,
quindi non posso usare solo str_shufflecome callback, che risparmierebbe 29 byte.

JavaScript, 76 67 byte

grazie ad Arnauld per -9 byte.

t=>t.replace(/\B\w+\B/g,m=>[...m].sort(_=>Math.random()-.5).join``)

Provalo online!

Ungolfed

t =>                  // function with a single argument
     t.replace(       // Replace ...
         /\B\w+\B/g,  // every match of the regex
         m => ...     // with the return value of the replacement function
     )

/       /g            // Match all occurences of
   \w+                // 1 or more word chars ...
 \B   \B              // ... that aren't on the beginning or end of the word

m =>                  // Replacement function
     [...m]           // convert matched string to a list of chars
       .sort(_ => Math.random()-.5) // sort with a random comparision function
       .join``        // join the list into a single string

R, 179

Usando la funzione che ho scritto per le lettere casuali in un problema di parola :

Ingresso:

s <- "According to a researcher at Cambridge University, it doesn't matter in what order the letters in a word are, the only important thing is that the first and last letter be at the right place. The rest can be a total mess and you can still read it without problem. This is because the human mind does not read every letter by itself but the word as a whole."

Soluzione:

f=function(w){l=length;s=strsplit(w,"")[[1]];ifelse(l(s)<3,w,paste(c(s[1],sample(s[2:(l(s)-1)]),s[l(s)]),collapse=""))}
g=Vectorize(f)
paste(g(strsplit(s," ")[[1]]), collapse=" ")

Risultato:

[1] "Arioccdng to a reehaecrsr at Cabrgimde Uveirisnyt, it des'not mttear in waht odrer the lttrees in a wrod are, the olny inpotmart thnig is that the fsrit and lsat letetr be at the right palce. The rset can be a toatl mses and you can stlil raed it wutioht pmrlebo. This is bsuceae the hmuan mnid deos not read ervey lteetr by iesltf but the word as a wleho."

Pyth, 23 byte

jdm?gld4++hd.<Ptd1eddcz

Non competitiva perché Pyth è stato realizzato dopo che questa sfida è stata pubblicata.

Provalo online

Japt , 32 byte

m@Xl ¨4?Xg0 +Xs1J ö(x) +XgJ:X}" 

Provalo online!

Java, 1557 834 byte Grazie a @JoKing per i suggerimenti.

Un po 'in ritardo per la competizione. Ho dimenticato che avevo iniziato con questo problema.

golfed

import java.util.*;public class s{ public static void main(String[] args){ Scanner s=new Scanner(System.in);String a=s.next();String[] q=a.split("\\s+");for (int i=0;i<q.length;i++) { q[i]=q[i].replaceAll("[^\\w]", ""); }String f="";for (String z:q) { f+=scramble(z);f+=" "; }System.out.print(f); }private static String scramble(String w){if(w.length()==1||w.length()==2){return w;}char[]l=w.toCharArray();char q=l[w.length()-1];String e=Character.toString(l[0]);char[]n=new char[l.length-2];for(int i=0;i<l.length-2;i++){n[i]=l[i+1];}HashMap<Integer,Character>s=new HashMap<>();int c=1;for(char p:n){s.put(c,p);c++;}HashMap<Integer,Integer>o=new HashMap<>();Random z=new Random();for(int i=0;i<w.length()-2;i++){int m=z.nextInt(n.length);while(o.getOrDefault(m,0) == 1){m=z.nextInt(n.length);}e+=s.get(m+1);o.put(m,1);}return e+=q;}}

Non-golfed

import java.util.HashMap;
import java.util.Random;

public class SentenceTransposition {
    public static void main(String[] args) {
        String input = "According to a researcher at Cambridge University, it doesn't matter in what order the letters in a word are, the only important thing is that the first and last letter be at the right place. The rest can be a total mess and you can still read it without problem. This is because the human mind does not read every letter by itself but the word as a whole.";
        String[] words = input.split("\\s+");
        for (int i = 0; i < words.length; i++) {
            words[i] = words[i].replaceAll("[^\\w]", "");
        }
        String finalsentence = "";
        for (String word : words) {
            finalsentence += scramble(word);
            finalsentence += " ";
        }
        System.out.println(finalsentence);
    }

    private static String scramble(String word) {
        if (word.length() == 1 || word.length() == 2) {
            return word;
        }
        char[] letters = word.toCharArray();
        char lletter = letters[word.length()-1];
        String endword = Character.toString(letters[0]);
        char[] nletters = new char[letters.length-2];
        for (int i = 0; i < letters.length-2; i++) {
            nletters[i] = letters[i+1];
        }
        HashMap<Integer, Character> set = new HashMap<>();
        int count = 1;
        for (char nletter : nletters) {
            set.put(count, nletter);
            count++;
        }
        HashMap<Integer, Integer> chosen = new HashMap<>();
        Random random = new Random();
        for (int i = 0; i < word.length()-2; i++) {
            int cur = random.nextInt(nletters.length);
            while (chosen.getOrDefault(cur,0) == 1) {
                cur = random.nextInt(nletters.length);
            }
            endword += set.get(cur+1);
            chosen.put(cur, 1);
        }
        return endword += lletter;
    }
}

Sidef , 89 85 byte

Blocco (richiamabile anonimo):

{.words.map{[_[0],(_.len-1?([_[1..^(_.len-1)]].shuffle...,_[1]):'')].join}.join(' ')}

Output, se utilizzato come { ... }('..'):

 I hvae nveer not ocne in my life slleepd nhedatarnel crtreolcy
 I have never not once in my lfie sepelld naetadenrhl ccrtloery

Abbastanza ungolfed

.words.map{
  [
    .first,
    (_.len-1
      ? (  [ _[1..^(_.len-1)] ].shuffle..., .last )
      : '')
  ].join
}.join(' ')