論争の的となっている話によると、原型のドローのltteresのオドラーは、元のドローでのリストとlsat lteter macthのようなlnogのように、raednigにあまり向いていません。

だから、楽しみのために、最初と最後の文字を所定の位置に保ちながら、単語内の文字の順序をランダム化する最短の機能は何でしょうか？

JavaScriptを使用してこれを確認します。すべての空白が削除され、124 130文字になりました。

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はいつでも歓迎します。

• 編集：長さチェックが追加されました。短い単語に対して関数が失敗することはありません。

Haskell、4文字

提案された関数trinithisは、実際に仕様に一致します。

s=id

文字列を変更せずに返します。したがって、最初と最後の文字をそのままにして、他のすべての文字の置換を行います。

順列の確率分布に不満がある場合、より良い分布をもたらすソリューションがあります。それは明らかにはるかに複雑です：

ハスケル、 110 120 107文字

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

この関数を使用するプログラムの例：

main = getLine >>= s >>= putStrLn

J、26 24 23文字

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

ルビー、44文字

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

短い単語でも機能します。つまり、1、2、または3文字の単語は変更されずに返されます。

編集： Venteroの配列スプラットのアイデアを使用すると、別の文字が保存されます。

Ruby 1.9、46文字

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

Golfscript

「関数」として（コードブロックと命名）：20文字

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

スタックの一番上の要素を操作する場合：16文字

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

C ++、79文字^{_{（範囲チェック付き）}}

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

C ++、 8165文字^{_{（範囲チェックなし）}}

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

結果を返す代わりに参照渡しを使用すると、いずれかのソリューションの別の10文字が削られます。

完全なプログラム、単語の文字列を読み取り、それらを変換するシャッフル：

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

士気：すでにそこにあるものを構築しないでください。 ああ、オーバーフローチェックは難解です。

Python、86文字

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

そして、これを使用する例を次に示します。

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

これは私の初めてのゴルフ練習です。問題を解決した後、私は答えを見ることにしました。それは私の答えがユニークではないことは驚きではありません。これは楽しかったです：o）

他の応答を見た後に1つの変更を行い、エイリアスを使用するようにimportステートメントを変更していました。いい案。; o）

C（K＆R）-88 86 87文字

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

Cには組み込みのスワップまたはシャッフル機能がないため、手動で行う必要がありました:(

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

編集：sが3文字未満で構成されている場合のバグを修正しました（気付いたことはユーザーに知られています！）

python、87 79 75 93 92文字（長さ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]

編集：元々は文字列の単語を分割するはずだと考えていました（128文字で行いました。現在87文字で必要です）。ああ、読解が下手です。

編集2：defから6文字を保存するためにdefからラムダ関数に変更します。サンプルが既にネームスペースにインポートされていると仮定すると（from random import sample）、これは約60に低下する可能性があります。

編集3：「len（w [1：-1]）」（12文字）から「len（w）-2」（8文字）は、ニブラーの良い提案ごとに。

編集4：JBernandoは1つの文字を保存しました（from random import *それが同等であると考えて見ました-のスペースimport *が不要であることに気付いていません）。ユーザー不明は、w if len(w)<4 else0文字と1文字の文字列を正しく処理するために19文字を追加しました。

編集5：ブースのコードゴルフトリックごとに別の文字を保存しました。 if len(w)<4 elseへif 4>len(w)else。

C ++、111 97文字

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

これをテストしたい人のための完全なプログラムは次のとおりです。

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

編集

両方のスワップインデックスをランダム化する必要はなく、変数といくつかの文字を保存する必要があることに気付きました。

php（68文字）

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

短い（60文字）

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

Perl- 96（または71）文字 84（または59）文字

これがPerlで思いついたものです。それを行うためにいくつかの異なる方法を試しましたが、これは私がこれまで考えていたものから最短で、97文字でした。

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

ただし、「use」行を切り取ると（他の人はCプログラムの#include行を除外しているため、これは有効だと思います）、さらに71文字に減らすことができます。

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

編集 @tobius 'メソッドを実装してこれを実行することをお勧めします。このように、私はそれを84文字まで、またはuse行を削除することで59文字にしました：

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

ルビー、77 75文字

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

少し冗長な言語での私のScalaソリューション。私は決してRubyの専門家ではないので、おそらく改善の余地があります。

ルビー1.9、77の 48 46 44文字

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

免責事項：私はこれを最高ランクの回答に基づいて調整しました-後でまったく同じ回答に気づきました。元のアイデアに忠実であったが、短いラムダとのルビー1.8からルビー1.9に変更した履歴を確認できshuffleます。

空の単語が許可されている場合、56 54文字

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

Python 3、94 93 91文字

別の手法を使用します。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

... if x[0:-1] else x与えx、その長さが1の場合は（それ以外の場合は、複製されます）。これにより、関数は長さ0および1の文字列に対して機能します。

これsample()はhttps://stackoverflow.com/questions/2668312/shuffle-string-in-python/2668366#2668366からです。

それは一つの式なので、我々は使用することができますlambda（排除return、defおよび括弧のペア）。

編集： from random import*他のPythonの送信後に1文字を保存します。

JavaScript- 118 122文字

JavaScriptの短縮-空白のない118文字。OPとほぼ同じアルゴリズムを使用しますが、連鎖は少なくなります。私は多くの再帰を試み、いくつかの反復を試みましたが、それらはすべて何らかの形で動けなくなる傾向があります。

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文字

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

大丈夫私は実際の文字列の代わりに通常のchar配列（これは不変のchar []であるため、インプレースシャッフルがありません）

長さをチェックして編集すると、さらに14が必要です

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

php 5.3（60文字）

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

56文字に改善され、バージョン5.3は不要になりました。

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

Perl-111文字（ライブラリ関数を使用せずに）

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}

使用法：

$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

Python の90 89 112文字です！

編集1：今回は関数として！

編集2：短い単語を処理するようになりました

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文字

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：除去「：文字列」（戻り型を推測することができる）
-7：取り除か「リターン」（最後の式が戻り値である）
-3：因数分解s.size-2アウト
-4：toCharArray- >toArray

Python、86文字

Slnicigは安全であるため、cknnceigが不要であることはありません。すべてのleghtnsのWkros。

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文字

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

完全なプログラム：

#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文字

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

1文字の文字列ではまだ機能せず（その文字を複製します）、空の文字列では失敗します。

Python-76文字

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

使用法：

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"

以下の関数は、長さが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文字

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]

インポートなし！1文字以上の単語に対して機能します。これは私の最初のゴルフエントリであり、私はBlueEyedBeastのShortestコードからのエントリに触発され、id（Object）を使用するというアイデアの非決定的な出力を生成しました。

説明：最初と最後を除く入力から文字のリストを作成し、このリストから繰り返しポップし、空になるまで新しいリストに追加します。ポップ元のインデックスはid（7）％len（ポップ元のリスト）です。id（7）はオブジェクト7のメモリアドレスであるため、本質的にランダムです。これで、元の入力の中心からランダムにスクランブルされた文字のリストができました。これで元の出力の最初と最後の文字がそれに応じて追加され、必要な出力が得られました：（最初の文字）+（スクランブルされた中央）+（最後の文字）。

R、 95 92 91文字

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

Rの遅延評価を使用して関数パラメーターとしてaとbを計算し、後で再利用してスペースを節約します。また、他のRの回答とは異なり、これは1文字以上のすべての単語に対して機能します。以下の例：

> f("hippopotamus")
hpuoopaitmps

> f("dog")
dog

> f("az")
az

編集： 交換しunlist()て[[]] [[1]]をel（）に置き換えました

D：55文字

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

完全なプログラム：

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

アーラン、188の 172 132文字

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

私はまだアーランを学んでいるので、これを短くするためのヒントはありがたいです。

完全なコード（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).

編集

シャッフルパーツを別の関数として取り出し、リストの先頭と末尾を渡す必要がなくなりました。

編集2

一つ取り除くために再構築f機能パターンを、変更2つのパラメータのみ、受け入れるようにシャッフル機能を変更するlists:deleteために--[]、スワップlists:reverseのための呼び出しをlists:last