Согласно некоторой противоречивой истории , запах слов в мире не так уж и велик для Рэднига, так же, как и у первого, и другого, с оригинальным языком.

Итак, для интереса, что было бы самой короткой функцией для рандомизации буквенного порядка в слове при сохранении первой и последней буквы на месте?

Вот мой удар с помощью 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 всегда приветствуется.

• Изменить: добавлена ​​проверка длины. Функция не должна выходить из строя для коротких слов.

Хаскель, 4 персонажа

Предложенная функция trinithis фактически соответствует спецификации:

s=id

Он возвращает строку без изменений, сохраняя, таким образом, первый и последний символы и делая перестановку всех остальных символов.

Если кто-то недоволен распределением вероятностей перестановок, вот решение, дающее лучшее распределение. Это, очевидно, намного сложнее:

Haskell, 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}

Работает также для коротких слов, т.е. слова с одним, двумя или тремя символами возвращаются без изменений.

Изменить: Использование идеи массива-сплат 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;
}

Мораль: не строить то, что уже есть. Да, и проверки переполнения для wusses.

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)

Это мой первый опыт игры в гольф. После решения проблемы я решил посмотреть на ответы, и неудивительно, что мой ответ не уникален. Это было весело, хотя: о)

Я сделал одно изменение после просмотра других ответов, и это изменило мою инструкцию импорта, чтобы использовать псевдоним. Отличная идея. ; О)

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 нет встроенной функции swap или shuffle, поэтому мне пришлось делать это вручную :(

Пример программы с 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 на лямбда-функцию с def, чтобы сохранить 6 символов. Если предположить, что sample уже импортирован в пространство имен ( from random import sample), это может привести к снижению до ~ 60).

РЕДАКТИРОВАТЬ 3: от «len (w [1: -1])» (12 символов) до «len (w) -2» (8 символов) в соответствии с хорошим предложением гнибблера.

РЕДАКТИРОВАТЬ 4: JBernando сохранил один символ (считал from random import *и видел, что это было эквивалентно - не понимая пространство в import *ненужном) .; неизвестный пользователь добавил 19 символов w if len(w)<4 elseдля правильной обработки строк 0 и 1.

РЕДАКТИРОВАТЬ 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» (которую я считаю верной, поскольку другие исключают строки #include в своих программах на C), я могу сократить ее до 71 символа :

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

РЕДАКТИРОВАТЬ Было предложено, чтобы я попытался сделать это, реализуя метод @tobius '. Таким образом, я получил его до 84 символов или, удалив строку использования , 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, так что, вероятно, есть возможности для улучшения.

Ruby 1,9, 77 48 46 44 символов

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

Отказ от ответственности: я настроил это на основе ответа с наивысшим рейтингом - позже заметил тот же самый ответ. Вы можете проверить историю, в которой я придерживался своей первоначальной идеи, но изменил с ruby ​​1.8 на ruby ​​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* чтобы сохранить 1 символ, после другой подачи Python.

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}

питон

Это 90 89 112 символов Python!

Редактировать 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

Питон, 86 символов

Slnicig безопасен, так что нет ничего страшного. 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 символа

г = ш [0] + [* ш [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 из кратчайшего кода, чтобы создать недетерминированный вывод для идеи использования id (Object) .

Объяснение: Он создает список букв из входных данных, исключая первое и последнее, и многократно появляется из этого списка и добавляет новый, пока он не будет пустым. Индекс, из которого он появляется, - это id (7)% len (список, из которого мы выскакиваем). Поскольку id (7) является адресом памяти объекта 7, он является по существу случайным. Итак, теперь у нас есть список случайно зашифрованных букв из центра исходного ввода. Все, что мы делаем сейчас, это добавляем первые и последние буквы исходного вывода соответственно, и мы получаем желаемый результат: (первая буква) + (скремблированная середина) + (последняя буква).

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

Я все еще изучаю Erlang, поэтому любые советы по сокращению это приветствуются.

полный код (модуль 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шаблонов функций, изменил функцию shuffle, чтобы принимать только два параметра, изменил lists:deleteдля --[], обменял lists:reverseвызов наlists:last