De acuerdo con alguna historia controvertida , el que odia a los personajes en un mundo no se enamora mucho de la educación, como el hombre y el hombre que se relacionan con el mundo original.

Entonces, por diversión, ¿cuál sería la función más corta para aleatorizar el orden de las letras en una palabra mientras se mantiene la primera y la última letra en su lugar?

Aquí está mi puñalada con JavaScript. Todo el espacio en blanco eliminado está en 124 130 caracteres.

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

Un JavaScript más corto siempre es bienvenido.

• Editar: verificación de longitud añadida. La función no debe fallar para palabras cortas.

Haskell, 4 personajes

La función trinithis propuesta en realidad coincide con la especificación:

s=id

Devuelve la cadena sin cambios, manteniendo así el primer y último carácter en su lugar y haciendo una permutación de todos los demás caracteres.

Si alguien no está satisfecho con la distribución de probabilidad de las permutaciones, aquí hay una solución que produce una mejor distribución. Obviamente es mucho más complejo:

Haskell 110 120 107 caracteres

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 ejemplo de un programa que usa esta función:

main = getLine >>= s >>= putStrLn

J, 26 24 23 caracteres

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

Ruby, 44 caracteres.

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

Funciona también para palabras cortas, es decir, las palabras con uno, dos o tres caracteres se devuelven sin modificaciones.

Editar: Usar la idea de matriz-splat de Ventero ahorra otro personaje.

Ruby 1.9, 46 caracteres

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

Golfscript

Como una "función" (llamada codeblock): 20 caracteres

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

Cuando se opera en el elemento superior de la pila: 16 caracteres

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

C ++, 79 caracteres ^{_{( con verificación de rango )}}

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

C ++, 8165 caracteres ^{_{( sin verificación de rango )}}

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

El uso de pasar por referencia en lugar de devolver el resultado elimina otros 10 caracteres de cualquiera de las soluciones.

Programa completo, leyendo una cadena de palabras y barajando convirtiéndolas:

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

Moral: no construyas lo que ya está allí. Ah, y los controles de desbordamiento son para wusses.

Python, 86 caracteres

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

Y aquí hay un ejemplo de uso:

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

Este es mi primer código de ejercicio de golf. Después de resolver el problema, decidí mirar las respuestas y no sorprende que la respuesta mía no sea única. Sin embargo, esto fue divertido: o)

Realicé un cambio después de mirar las otras respuestas y estaba cambiando mi declaración de importación para usar un alias. Gran idea. ; o)

C (K&R) - 88 86 87 caracteres

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

No hay una función integrada de intercambio o aleatorio en C, así que tuve que hacerlo manualmente :(

Programa de muestra 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;
}

EDITAR : se corrigió el error cuando s consta de menos de 3 caracteres (¡gracias a un usuario desconocido por notarlo!)

pitón, 87 79 75 93 92 caracteres (manejo de cadenas de longitud 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]

EDITAR: Originalmente pensé que se suponía que debía dividir las palabras de cadena (lo que hizo en 128 caracteres; ahora en 87 caracteres sí se requiere). Argh, mi mala comprensión de lectura.

EDIT 2: Cambiar de def a la función lambda de def para guardar 6 caracteres. Suponiendo que la muestra ya se haya importado al espacio de nombres ( from random import sample) podría reducir esto a ~ 60).

EDITAR 3: "len (w [1: -1])" (12 caracteres) a "len (w) -2" (8 caracteres) según la sugerencia de gnibbler.

EDITAR 4: JBernando guardó un personaje (lo consideró from random import *y vio que era equivalente, sin darse cuenta de que el espacio import *es innecesario) .; El usuario desconocido agregó 19 caracteres w if len(w)<4 elsepara manejar las cadenas de caracteres 0 y 1 correctamente.

EDITAR 5: Guardado otro char por truco de golf de código de cabina. if len(w)<4 elsea if 4>len(w)else.

C ++, 111 97 caracteres

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

Aquí hay un programa completo para aquellos que deseen probarlo:

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

Editar

Se dio cuenta de que no es necesario aleatorizar ambos índices de intercambio, guardó una variable y algunos caracteres más.

php (68 caracteres)

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

más corto (60 caracteres)

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

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

Esto es lo que se me ocurrió en Perl. Pasé por varias formas diferentes de hacerlo, pero esto parecía más corto de lo que puedo pensar hasta ahora, con 97 caracteres.

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

Sin embargo, si corta la línea de 'uso' (que supongo que es válida, ya que otros excluyeron #incluir líneas en sus programas en C), puedo reducirla a 71 caracteres :

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

EDITAR Se sugirió que intente hacer esto implementando el método @tobius. De esta forma lo reduje a 84 caracteres , o quitando la línea de uso , 59 caracteres :

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

Ruby, 77 75 caracteres

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

Mi solución Scala en un lenguaje un poco menos detallado. No soy un experto en Ruby de ninguna manera, por lo que probablemente haya margen de mejora.

Ruby 1.9, 77 48 46 44 caracteres

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

Descargo de responsabilidad: Ajusté esto en función de la respuesta mejor clasificada, noté la misma respuesta más adelante. Puede consultar el historial que he mantenido fiel a mi idea original pero que cambié de ruby ​​1.8 a ruby ​​1.9 para lambdas cortas yshuffle .

Si se permiten palabras vacías, 56 54 caracteres

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

Pitón 3, 94 93 91 caracteres

Usando una técnica diferente. También podría funcionar en 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

El ... if x[0:-1] else xdax si su longitud es 1 (de lo contrario se duplicaría). La función funciona para cadenas de longitud 0 y 1.

El sample()es de https://stackoverflow.com/questions/2668312/shuffle-string-in-python/2668366#2668366 .

Ya que es una expresión, se puede utilizar una lambda(eliminando return, defy un par de paréntesis).

Editar: from random import* para guardar 1 carácter, después del otro envío de Python.

JavaScript - 118 caracteres

JavaScript más corto: 118 caracteres sin espacios en blanco. Utiliza aproximadamente el mismo algoritmo que el OP, pero con menos encadenamiento. Intenté muchas recursiones e intenté algunas iteraciones, pero todas tienden a atascarse de una forma u otra.

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 caracteres

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

Está bien, hice trampa con una matriz de caracteres normal en lugar de una cadena real (que es un carácter inmutable char [], por lo que no hay barajado in situ)

editar con una verificación de longitud requiere 14 más

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

php 5.3 (60 caracteres)

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

Mejorado a 56 caracteres y ya no requiere la versión 5.3:

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

Perl - 111 caracteres (sin usar ninguna función de biblioteca)

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}

Uso :

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

Pitón

¡Son 90 89 112 caracteres de python!

Edición 1: ¡como una función esta vez!

Edición 2: ahora maneja palabras cortas

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 caracteres

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: eliminado ': String' (tipo de retorno puede inferir)
-7: eliminado 'retorno' (última expresión es el valor de retorno)
-3: factorizado s.size-2cabo
-4: toCharArray->toArray

Python, 86 caracteres

Slnicig es seguro, por lo que no hay ningún ckhnceig cercano. Wkros en todas las longitudes.

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 caracteres

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

programa 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 caracteres

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

Todavía no funciona para cadenas de 1 carácter (duplica ese carácter) y falla para una cadena vacía.

Python - 76 caracteres

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 siguiente función funciona con palabras con una longitud inferior 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 caracteres

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]

¡Sin importaciones! Funciona para palabras de 1 carácter y superiores. Esta es mi primera entrada de golf y me inspiró la entrada de BlueEyedBeast del código más corto para producir una salida no determinista para la idea de usar id (Object) .

Explicación: hace una lista de letras de la entrada, excluyendo la primera y la última, y ​​aparece repetidamente en esta lista y se agrega a una nueva hasta que esté vacía. El índice del que aparece es id (7)% len (lista de la que estamos emergiendo). Como id (7) es la dirección de memoria del objeto 7, es esencialmente aleatorio. Así que ahora tenemos una lista de letras aleatorizadas desde el centro de la entrada original. Todo lo que hacemos ahora es agregar la primera y la última letra del resultado original en consecuencia y obtenemos el resultado que queremos: (primera letra) + (codificado en el medio) + (última letra).

R 95 92 91 caracteres

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

Utiliza la evaluación perezosa de R para calcular ayb como parámetros de función, ahorrando espacio con la reutilización posterior. También, a diferencia de otras respuestas R, esto funciona para todas las palabras> 1 carácter largo. Ejemplo a continuación:

> f("hippopotamus")
hpuoopaitmps

> f("dog")
dog

> f("az")
az

Editar: Reemplazado unlist()con[[]] Reemplazado [[1]] con el ()

D: 55 caracteres

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

programa 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 caracteres

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

Todavía estoy aprendiendo Erlang, por lo que agradezco cualquier consejo para hacer esto más corto.

código completo (string_shuffle module):

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

Editar

Tomó la parte aleatoria como una función separada que ya no requiere que se pasen el encabezado y la cola de la lista.

Editar 2

Reestructurado para eliminar uno de los fpatrones de función, cambió la función aleatoria para aceptar solo dos parámetros, cambió lists:deletepor --[], cambió una lists:reversellamada por unlists:last