Secondo una storia controversa , l'odore di lttere in un wrod deos non è molto alto per raednig, tanto quanto la frist e lsat lteter macth con l'originale wrod.

Quindi, per divertimento, quale sarebbe la funzione più breve per randomizzare l'ordine delle lettere in una parola mantenendo la prima e l'ultima lettera in atto?

Ecco la mia pugnalata con JavaScript. Tutto lo spazio bianco rimosso è di 124 130 caratteri.

function r(w) {
  var l=w.length-1;
  return l<3?w:w[0]+w.slice(1,l).split("").sort(function(){return Math.random()-.5}).join("")+w[l];
}

JavaScript più breve è sempre il benvenuto.

• Modifica: controllo lunghezza aggiunto. La funzione non dovrebbe fallire per parole brevi.

Haskell, 4 personaggi

La funzione trinitis proposta corrisponde effettivamente alla specifica:

s=id

Restituisce la stringa invariata, mantenendo in posizione il primo e l'ultimo carattere e facendo una permutazione di tutti gli altri caratteri.

Se qualcuno non è soddisfatto della distribuzione di probabilità delle permutazioni, ecco una soluzione che produce una migliore distribuzione. È ovviamente molto più complesso:

Haskell, 110 120 107 caratteri

import Random
s l=randomRIO(1,length l-2)>>=g.($l).splitAt
g(a:b,c:d)=fmap(a:).s$c:b++d
g(a,b)=return$a++b

Un esempio di un programma che utilizza questa funzione:

main = getLine >>= s >>= putStrLn

J, 26 24 23 caratteri

r=:{.,({~?~@#)&}.&}:,{:

Rubino, 44 ​​caratteri

r=->w{w[h=1..-2]=[*w[h].chars].shuffle*"";w}

Funziona anche per parole brevi, vale a dire le parole con uno, due o tre caratteri vengono restituite inalterate.

Modifica: l' uso dell'idea array-splat di Ventero salva un altro carattere.

Ruby 1.9, 46 caratteri

r=->w{w[0]+[*w[1..-2].chars].shuffle*""+w[-1]}

Golfscript

Come una "funzione" (denominata codeblock): 20 caratteri

{1/(\)\{;9rand}$\}:r

Quando si opera sull'elemento più in alto nello stack: 16 caratteri

1/(\)\{;9rand}$\

C ++, 79 caratteri ^{_{( con controllo della portata )}}

string f(string s){if(s.size()>3)random_shuffle(&s[1],&s.end()[-1]);return s;}

C ++, 8165 caratteri ^{_{( senza controllo della portata )}}

string f(string s){random_shuffle(&s[1],&s.end()[-1]);return s;}

L'uso del pass per riferimento invece di restituire il risultato fa radere altri 10 caratteri da entrambe le soluzioni.

Programma completo, leggere una stringa di parole e mescolarle convertendole:

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <ctime>
#include <string>

using namespace std;    
string f(string s){if(s.size()>3)random_shuffle(&s[1],&s.end()[-1]);return s;}

int main() {
    std::srand(std::time(0));
    std::string s;
    while(std::cin >> s)
        std::cout << f(s) << " ";
    std::cout << std::endl;
}

Morale: non costruire ciò che è già lì. Oh, e i controlli di overflow sono per i wuss.

Python, 86 caratteri

import random as r
def f(w):t=list(w[1:-1]);r.shuffle(t);return w[0]+''.join(t)+w[-1]

Ed ecco un esempio di come usarlo:

for x in ["ashley", "awesome", "apples"]:
    print f(x)

Questo è il mio primo esercizio di golf in codice. Dopo aver risolto il problema, ho deciso di esaminare le risposte e non è una sorpresa che la mia risposta non sia unica. Questo è stato divertente: o)

Ho fatto una modifica dopo aver visto le altre risposte e stava cambiando la mia dichiarazione di importazione per usare un alias. Grande idea. ; O)

C (K&R) - 88 86 87 caratteri

r(char*s){int m,j,l=strlen(s)-2,i=l;while(--i>0){j=rand()%l+1;m=s[j];s[j]=s[1];s[1]=m;}}

Non c'è swap incorporato o funzione shuffle in C, quindi ho dovuto farlo manualmente :(

Programma di esempio con Ungolfed r ():

#include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>

// -----------------------------------------------------------------------
r( char *s )
{
    int m, j, l=strlen(s)-2, i=l;

    while (--i>0)
    {
        j = rand() % l + 1;

        m = s[j];
        s[j] = s[1];
        s[1] = m;
    }

}
// -----------------------------------------------------------------------
int main()
{
    char s[] = "anticipated";

    srand( time(0) );
    r( s );
    puts( s );

    return 0;
}

EDIT : corretto il bug quando s consisteva in meno di 3 caratteri (grazie a user-unown per averlo notato!)

python, 87 79 75 93 92 caratteri (gestione stringhe di lunghezza 0,1)

from random import*
f=lambda w:w if 4>len(w)else w[0]+''.join(sample(w[1:-1],len(w)-2))+w[-1]

EDIT: Inizialmente pensava che avrebbe dovuto dividere le parole stringa (cosa che ha fatto a 128 caratteri; ora a 87 caratteri fa requisito). Argh, la mia cattiva comprensione della lettura.

EDIT 2: passa da def a lambda da def per salvare 6 caratteri. Supponendo che il campione sia già stato importato nello spazio dei nomi ( from random import sample), è possibile portarlo a ~ 60).

EDIT 3: "len (w [1: -1])" (12 caratteri) a "len (w) -2" (8 caratteri) per il bel suggerimento di gnibbler.

EDIT 4: JBernando ha salvato un carattere (aveva considerato from random import *e visto che era equivalente - non rendersi conto dello spazio in import *non è necessario) .; user unknown ha aggiunto 19 caratteri w if len(w)<4 elseper gestire correttamente le stringhe di caratteri 0 e 1.

EDIT 5: salvato un altro personaggio per il trucco di golf con codice boothby. if len(w)<4 elsea if 4>len(w)else.

C ++, 111 97 caratteri

std::string f(std::string s){for(int i=s.size()-1;i>1;std::swap(s[rand()%i+1],s[--i]));return s;}

Ecco un programma completo per coloro che desiderano testarlo:

#include<string>
#include<iostream>

std::string f(std::string s){for(int i=s.size()-1;i>1;std::swap(s[rand()%i+1],s[--i]));return s;}

int main(){
    for(int i = 0; i<100; ++i)
    std::cout<<f("letters")<<std::endl;
}

modificare

Realizzato non è necessario casualmente entrambi gli indici di scambio, salvato una variabile e qualche altro carattere.

php (68 caratteri)

$r=preg_replace('/^(\w)(\w+)(\w)$/e','$1.str_shuffle($2).$3',trim($w));

più breve (60 caratteri)

$r=preg_replace('/(.)(.+)(.)/e','$1.str_shuffle($2).$3',$w);

Perl - 96 (o 71) caratteri 84 (o 59) caratteri

Questo è quello che mi è venuto in mente in Perl. Sono passati in diversi modi per farlo, ma questo sembrava il più breve rispetto a quello che riesco a pensare finora, con 97 personaggi.

use List::Util 'shuffle';sub r{($b,@w)=split//,$_[0];$e=pop(@w);return$b.join('',shuffle@w).$e;}

Tuttavia, se tagli la linea "use" (che suppongo sia valida, dal momento che altri hanno escluso le righe #include nei loro programmi C) posso ridurla ulteriormente a 71 caratteri :

sub r{($b,@w)=split//,$_[0];$e=pop(@w);return$b.join('',shuffle@w).$e;}

EDIT Mi è stato suggerito di provare a implementare il metodo di @tobius. In questo modo sono arrivato a 84 caratteri , o rimuovendo la riga d' uso , 59 caratteri :

use List::Util 'shuffle';sub r{$_[0]=~m/(.)(.+)(.)/;$1.join'',shuffle split//,$2.$3}

Rubino, 77 75 caratteri

def r(s);f=s.size-2;1.upto(f){|i|x=rand(f)+1;t=s[i];s[i]=s[x];s[x]=t};s;end

La mia soluzione Scala in un linguaggio leggermente meno prolisso. Non sono affatto un esperto di Ruby, quindi probabilmente c'è spazio per miglioramenti.

Ruby 1.9, 77 48 46 44 caratteri

r=->w{w[h=1..-2]=[*w[h].chars].shuffle*"";w}

Disclaimer: l'ho sintonizzato sulla base della risposta con il punteggio più alto - più tardi ho notato la stessa risposta esatta. Puoi controllare la storia che ho mantenuto fedele alla mia idea originale, ma cambiata da ruby ​​1.8 a ruby ​​1.9 per lambda corte e shuffle.

Se sono consentite parole vuote, allora 56 54 caratteri

r=->w{w.empty?||w[h=1..-2]=[*w[h].chars].shuffle*"";w}

Python 3, 94 93 91 caratteri

Usando una tecnica diversa. Potrebbe funzionare anche in Python 2.

from random import*
s=lambda x:x[0]+''.join(sample(x[1:-1],len(x)-2))+x[-1]if x[0:-1]else x

Il ... if x[0:-1] else xdà xse la sua lunghezza è di 1 (altrimenti sarebbe essere duplicato). La funzione funziona quindi per stringhe di lunghezza 0 e 1.

Il sample()da https://stackoverflow.com/questions/2668312/shuffle-string-in-python/2668366#2668366 .

Dato che è un'espressione, possiamo usare un lambda(eliminando return, defe una coppia di parentesi).

Modifica: from random import* per salvare 1 carattere, dopo l'altro invio di Python.

JavaScript - 118 122 caratteri

JavaScript più breve: 118 caratteri senza spazi bianchi. Utilizza approssimativamente lo stesso algoritmo dell'OP, ma con meno concatenamenti. Ho provato molta ricorsione e ho provato qualche iterazione, ma tutti tendono a impantanarsi in un modo o nell'altro.

function s(w)
{
    w = w.split('');
    var a = w.shift(),
        z = w.pop();
    return z?a + (w.sort(function() { return Math.random() - .5}).join('')) + z:a;
}

D, 62 caratteri

import std.random;void s(char[] s){randomShuffle(s[1..$-1]);}

va bene ho imbrogliato con un normale array di caratteri invece di una stringa reale (che è un carattere immutabile [], quindi nessun rimescolamento sul posto)

modifica con un controllo di lunghezza ne richiede altri 14

import std.random;void s(char[] s){if(s.length>1)randomShuffle(s[1..$-1]);}

php 5.3 (60 caratteri)

$r=!$w[2]?:$w[0].str_shuffle(substr($w,1,-1)).substr($w,-1);

Migliorato a 56 caratteri e non richiede più la versione 5.3:

$r=substr_replace($w,str_shuffle(substr($w,1,-1)),1,-1);

Perl - 111 caratteri (senza utilizzare alcuna funzione di libreria)

sub r{($f,@w)=split//,shift;$l=pop@w;while(@w){if(rand(9)>1){push@w,shift@w}else{push@t,pop@w}}join'',$f,@t,$l}

Utilizzo :

$in="randomizethis";
$out = &r($in);
print "\nout: $out";
sub r{($f,@w)=split//,shift;$l=pop@w;while(@w){if(rand(9)>1){push@w,shift@w}else{push@t,pop@w}}join'',$f,@t,$l}

Pitone

Sono 90 89 112 caratteri di Python!

Modifica 1: come funzione questa volta!

Modifica 2: ora gestisce parole brevi

import random as r
def q(s):
 a=list(s)
 b=a[1:-1]
 r.shuffle(b)
 if len(s)<4:
  return s
 return a[0]+''.join(b)+a[-1]

Scala, 135 139 142 156 caratteri

def r(s:String)={var(x,o,t,f)=(0,s.toArray,' ',s.size-2)
for(i<-1 to f){t=o(i)
x=util.Random.nextInt(f)+1
o(i)=o(x)
o(x)=t}
o.mkString}

-7: rimosso ': String' (il tipo restituito può essere dedotto)
-7: rimosso 'ritorno' (l'ultima espressione è il valore restituito)
-3: fattorizzato s.size-2out
-4: toCharArray->toArray

Python, 86 caratteri

Slnicig è sicuro, quindi nessun bnouds ckhnceig è neeacrssy. Wkros su tutti i leghtns.

from random import*
def f(x):x=list(x);t=x[1:-1];shuffle(t);x[1:-1]=t;return''.join(x)

C ++ 11: - 68 66 caratteri

auto f=[&](){if(s.size()>2)random_shuffle(s.begin()+1,s.end()-1);};

programma completo:

#include <iostream>
#include <string>
#include <algorithm>

using namespace std;

int main(int argc, char* argv[]){

  string s = "SomestrinG";
  auto f=[&](){if(s.size()>2)random_shuffle(s.begin()+1,s.end()-1);};

  f();
  cout << s << endl;
  return 0;
}

Ruby 1.9, 43 caratteri

r = w [0] + [* w [1 ..- 2] .chars] .shuffle.join + w [-1]

Non funziona ancora per stringhe di 1 carattere (duplica quel carattere) e non funziona per String vuota.

Python - 76 caratteri

import random as r
def f(w):m=list(w)[1:-1];r.shuffle(m);return w[0]+''.join(m)+w[-1]

R, 104 (126)

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

Uso:

for (i in 1:10) print(f("parola"))
[1] "plraoa"
[1] "prolaa"
[1] "praola"
[1] "parloa"
[1] "plaora"
[1] "palroa"
[1] "porlaa"
[1] "ploraa"
[1] "porlaa"
[1] "ploraa"

la funzione seguente funziona con parole di lunghezza inferiore a 3:

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

f("pl")
[1] "pl"
f("a")
[1] "a"

Python, 102 caratteri

def f(x):t=list(x)[1:-1];k='';exec'k+=t.pop(id(7)%len(t));'*len(t);return[x[0],x[0]+k+x[-1]][len(x)>1]

Nessuna importazione! Funziona con parole di 1 carattere e oltre. Questa è la mia prima entrata nel golf e sono stato ispirato dall'entrata di BlueEyedBeast dal codice più breve per produrre un output non deterministico per l'idea di usare id (Object) .

Spiegazione: Crea un elenco di lettere dall'input escludendo il primo e l'ultimo, e si apre ripetutamente da questo elenco e si aggiunge a uno nuovo fino a quando non è vuoto. L'indice da cui viene visualizzato è id (7)% len (elenco da cui stiamo saltando fuori). Poiché id (7) è l'indirizzo di memoria dell'oggetto 7, è essenzialmente casuale. Quindi ora abbiamo un elenco di lettere casualmente criptate dal centro dell'input originale. Tutto ciò che facciamo ora è aggiungere la prima e l'ultima lettera dell'output originale di conseguenza e abbiamo ottenuto l'output che vogliamo: (prima lettera) + (mezzo criptato) + (ultima lettera).

R, 95 92 91 caratteri

f=function(w,a=el(strsplit(w,'')),b=length(a))cat(a[1],sample(a[c(1,b)],b-2),a[b],sep="")

Utilizza la valutazione pigra di R per calcolare aeb come parametri di funzione, risparmiando spazio con il riutilizzo in seguito. Inoltre, diversamente dalle altre risposte R, questo funziona per tutte le parole> 1 carattere lungo. Esempio sotto:

> f("hippopotamus")
hpuoopaitmps

> f("dog")
dog

> f("az")
az

Modificare: Sostituito unlist()con[[]] Sostituito [[1]] con el ()

D: 55 caratteri

void f(T)(T s){if(s.length>2)randomShuffle(s[1..$-1]);};

programma completo:

import std.stdio, std.random, std.conv;

void f(T)(T s){if(s.length>2)randomShuffle(s[1..$-1]);};

void main(){

  char[] s = to!(char[])("SomestrinG");

  f(s);
  writeln(s);
}

Erlang, 188 172 132 caratteri

f([H|C=[_|_]])->T=[lists:last(C)],[H|s(C--T,T)];f(X)->X. s([],N)->N;s(D,N)->E=[lists:nth(random:uniform(length(D)),D)],s(D--E,E++N).

Sto ancora imparando Erlang, quindi sono apprezzati tutti i suggerimenti per rendere questo più corto.

codice completo (modulo string_shuffle):

-module(string_shuffle).
-export([f/1]).

f([H|C=[_|_]])->
    T=[lists:last(C)],
    [H|s(C--T,T)];f(X)->X.
f(X)->X.

s([],N)->N;
s(D,N)->
    E=[lists:nth(random:uniform(length(D)),D)],
    s(D--E,E++N).

modificare

Ha preso la parte shuffle come una funzione separata che non richiede più il passaggio della testa e della coda della lista.

Modifica 2

Ristrutturato per rimuovere uno dei fmodelli di funzione, modificato la funzione shuffle per accettare solo due parametri, modificato lists:deleteper --[], scambiato una lists:reversechiamata per unlists:last