Selon une histoire controversée , le titre de rapporteur dans une lettre ne serait pas très utile au raid, comme le premier et le dernier journaliste avec le mot original.

Donc, pour le plaisir, quelle serait la fonction la plus courte pour randomiser l’ordre des lettres dans un mot tout en maintenant la première et la dernière lettre en place?

Voici mon coup de couteau avec JavaScript. Tous les espaces sont supprimés: 124 130 caractères.

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 plus court toujours la bienvenue.

• Edit: vérification de la longueur ajoutée. La fonction ne devrait pas échouer pour les mots courts.

Haskell, 4 personnages

La fonction trinithis proposée correspond effectivement à la spécification:

s=id

Il retourne la chaîne inchangée, gardant ainsi les premier et dernier caractères en place et permettant une permutation de tous les autres caractères.

Si quelqu'un n'est pas satisfait de la distribution de probabilité des permutations, voici une solution permettant d'obtenir une meilleure distribution. C'est évidemment beaucoup plus complexe:

Haskell, 110 120 107 caractères

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 exemple de programme utilisant cette fonction:

main = getLine >>= s >>= putStrLn

J, 26 24 23 caractères

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

Ruby, 44 personnages

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

Fonctionne également pour les mots courts, c’est-à-dire que les mots contenant un, deux ou trois caractères sont renvoyés sans modification.

Edit: Utiliser l’idée de array-splat de Ventero enregistre un autre caractère.

Ruby 1.9, 46 caractères

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

Golfscript

En tant que "fonction" (nommé codeblock): 20 caractères

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

En opérant sur le premier élément de la pile: 16 caractères

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

C ++, 79 caractères ^{_{( avec contrôle de plage )}}

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

C ++, 8165 caractères ^{_{( sans vérification de la plage )}}

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

Utiliser passe par référence au lieu de renvoyer le résultat supprime 10 autres caractères de l'une ou l'autre solution.

Programme complet, lisant une chaîne de mots et les mélangeant en les convertissant:

#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: ne construisez pas ce qui existe déjà. Oh, et les contrôles de débordement sont pour des wusses.

Python, 86 caractères

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

Et voici un exemple d'utilisation:

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

Ceci est mon premier exercice de golf de code. Après avoir résolu le problème, j'ai décidé d'examiner les réponses et il n'est pas surprenant que ma réponse ne soit pas unique. C'était amusant cependant: o)

J'ai fait un changement après avoir examiné les autres réponses et cela modifiait mon instruction d'importation pour utiliser un alias. Bonne idée. ; o)

C (K & R) - 88 86 87 caractères

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

Il n'y a pas de fonction swap ou shuffle intégrée en C, je devais donc le faire manuellement :(

Exemple de programme avec 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 : correction du bug quand s est composé de moins de 3 caractères (merci à l'utilisateur de l'avoir remarqué!)

python, 87 79 75 93 92 caractères (manipulation de chaînes de longueur 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: À l’origine, on pensait qu’il était supposé diviser les mots de chaîne (ce qui était le cas pour 128 caractères; maintenant, l’exigence de 87 caractères). Argh, ma mauvaise compréhension en lecture.

EDIT 2: Change de def en fonction lambda de def pour sauvegarder 6 caractères. En supposant qu'un échantillon est déjà importé dans l'espace de noms ( from random import sample), cela pourrait ramener le nombre à ~ 60).

EDIT 3: "len (w [1: -1])" (12 caractères) à "len (w) -2" (8 caractères) par suggestion agréable du gnibbler.

EDIT 4: JBernando a sauvegardé un caractère (il avait considéré from random import *et vu que c’était équivalent - ne pas se rendre compte que la place en import *était inutile) .; utilisateur inconnu a ajouté 19 caractères w if len(w)<4 elsepour gérer correctement les chaînes de caractères 0 et 1.

EDIT 5: enregistré un autre personnage par tour de golf code astuce. if len(w)<4 elseà if 4>len(w)else.

C ++, 111 97 caractères

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

Voici un programme complet pour ceux qui souhaitent le tester:

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

Modifier

Réalisé, il n’est pas nécessaire d’aléatoire des deux index de swap, d’une variable enregistrée et de quelques caractères supplémentaires.

php (68 caractères)

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

plus court (60 caractères)

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

Perl - 96 (ou 71 caractères) 84 (ou 59 caractères)

C’est ce que j’ai trouvé en Perl. Je suis passé par différentes manières de le faire, mais cela semblait le plus court de ce que je peux penser à ce jour, à 97 personnages.

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

Cependant, si vous supprimez la ligne 'use' (ce qui, je suppose, est valide, car d'autres personnes ont exclu les lignes #include dans leurs programmes C), je peux la réduire davantage à 71 caractères :

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

EDIT Il a été suggéré que j'essaie de faire ceci en implémentant la méthode de @tobius. De cette façon, je l'ai réduit à 84 caractères , ou en supprimant la ligne d' utilisation , 59 caractères :

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

Ruby, 77 75 caractères

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

Ma solution Scala dans une langue légèrement moins commentée. Je ne suis absolument pas un expert de Ruby, alors il y a probablement place à amélioration.

Ruby 1.9, 77 48 46 44 caractères

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

Avertissement: J'ai réglé ceci en fonction de la réponse la mieux classée - j'ai remarqué la même réponse plus tard. Vous pouvez vérifier l’historique que j’ai gardé fidèle à mon idée d’origine, mais qui est passé de ruby ​​1.8 à ruby ​​1.9 pour les lambdas courts et shuffle.

Si les mots vides sont autorisés, alors 56 54 caractères

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

Python 3, 94 93 91 caractères

Utiliser une technique différente. Peut aussi fonctionner 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

Le ... if x[0:-1] else xdonne xsi sa longueur est 1 (sinon, il serait dupliqué). La fonction fonctionne donc pour les chaînes de longueur 0 et 1.

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

Comme il est une expression, on peut utiliser un lambda(éliminant return, defet une paire de parenthèses).

Éditer: from random import* pour sauvegarder un caractère après l'autre soumission Python.

JavaScript - 118 122 caractères

JavaScript plus court - 118 caractères sans espace. Utilise approximativement le même algorithme que l'OP, mais avec moins de chaînage. J'ai essayé beaucoup de récursion, et j'ai essayé quelques itérations, mais ils ont tous tendance à s'enliser d'une manière ou d'une autre.

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 caractères

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

d'accord j'ai triché avec un tableau de caractères normal au lieu d'une chaîne réelle (qui est un caractère immuable [], donc pas de brassage sur place)

éditer avec une vérification de longueur, il en faut 14 de plus

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

php 5.3 (60 caractères)

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

Amélioré à 56 caractères et ne nécessite plus la version 5.3:

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

Perl - 111 caractères (sans utiliser aucune fonction de bibliothèque)

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}

Utilisation :

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

Python

C'est 90 89 112 caractères de python!

Edit 1: comme une fonction cette fois!

Edit 2: gère maintenant les mots courts

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 caractères

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: enlevé ': String' (le type de retour peut être inféré)
-7: enlevé 'retour' (la dernière expression est la valeur de retour)
-3: factored s.size-2out
-4: toCharArray->toArray

Python, 86 caractères

Slnicig est sûr, donc pas de problème, ckhnceig n’est nécessaire. Wkros à tous points de vue.

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 caractères

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

programme complet:

#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 caractères

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

Ne fonctionne pas encore pour les chaînes de 1 caractère (duplique ce caractère) et échoue pour les chaînes vides.

Python - 76 caractères

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

Usage:

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 fonction ci-dessous fonctionne avec des mots de longueur inférieure à 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 caractères

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]

Aucune importation! Fonctionne pour les mots 1 caractère et plus. C’est ma première participation au golf et j’ai été inspiré par l’entrée de Blueesty Code dans Shortest pour produire une sortie non déterministe sur l’idée d’utiliser id (Object) .

Explanation: Il crée une liste de lettres à partir de l'entrée, en excluant les première et dernière, puis disparaît de manière répétée dans cette liste et en ajoute une nouvelle jusqu'à ce qu'elle soit vide. L'index dont il provient est id (7)% len (la liste d'où nous venons). Puisque id (7) est l'adresse mémoire de l'objet 7, il est essentiellement aléatoire. Nous avons maintenant une liste de lettres brouillées de manière aléatoire à partir du centre de l’entrée initiale. Tout ce que nous faisons maintenant est d’ajouter les première et dernière lettres de la sortie originale en conséquence et nous obtenons la sortie souhaitée: (première lettre) + (brouillé au milieu) + (dernière lettre).

R, 95 92 91 caractères

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

Utilise l’évaluation paresseuse de R pour calculer a et b en tant que paramètres de fonction, économisant ainsi de la place lors de la réutilisation ultérieure. De plus, contrairement aux autres réponses R, cela fonctionne pour tous les mots> 1 caractère. Exemple ci-dessous:

> f("hippopotamus")
hpuoopaitmps

> f("dog")
dog

> f("az")
az

Modifier: Remplacé unlist()par[[]] Remplacé [[1]] par el ()

D: 55 caractères

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

programme complet:

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 caractères

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

J'apprends toujours Erlang, donc tous les conseils pour raccourcir cette étape sont appréciés.

code complet (module 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).

Modifier

La partie aléatoire a été retirée en tant que fonction distincte qui n'exige plus que la tête et la queue de la liste soient diffusées.

Modifier 2

Restructuré pour supprimer l'un des fmodèles de fonction, modification de la fonction de lecture aléatoire afin qu'elle n'accepte que deux paramètres, modification lists:deletede --[], échange d'un lists:reverseappel contre unlists:last