Згідно з деякою суперечливою історією , одрер ltteres у wrod deos не значить багато для raednig, настільки lnog, як frist та lsat lteter macth з оригінальним wrod.

Отже, для розваги, яка найкоротша функція рандомізувати порядок букв у слові, зберігаючи першу та останню букви на місці?

Ось мій удар по ньому з 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 символи

Пропонована функція триніта фактично відповідає специфікації:

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, зберігається ще одна діаграма.

Рубін 1,9, 46 символів

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

Гольфскрипт

Як "функція" (названа кодовим блоком): 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;
}

Мораль: не будуйте того, що вже є. Ох, і перевірка на переповнення призначена для жінок.

Пітон, 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)

Я зробив одну зміну після перегляду інших відповідей, і це міняло мою заяву про імпорт, щоб використовувати псевдонім. Чудова ідея. ; 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;
}

EDIT : виправлено помилку, коли s складається з менш ніж 3 символів (завдяки невідомому користувачеві, який помітив це!)

пітон, 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]

EDIT: Спочатку думав, що він повинен був розділити рядкові слова (що це робилося на 128 символів; зараз це вимагає 87 символів). Аргу, моє погане розуміння читання.

EDIT 2: Перехід від def до функції лямбда з def, щоб зберегти 6 символів. Якщо припустити, що зразок вже імпортований у простір імен ( from random import sample), це може звести до ~ 60).

EDIT 3: "len (w [1: -1])" (12 chars) to "len (w) -2" (8 chars) за приємну пропозицію gnibbler.

EDIT 4: JBernando врятував одну таблицю (вважав from random import *і бачив, що це рівнозначно - не усвідомлювати простір у import *зайвому); Користувач невідомо додав 19 символів, w if len(w)<4 elseщоб правильно обробляти 0 та 1 рядок символів.

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

Хоча, якщо ви вирізаєте рядок "використання" (який, мабуть, є дійсним, оскільки інші виключають #include рядки у своїх програмах C), я можу скоротити його далі до 71 символу :

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

EDIT Було запропоновано спробувати виконати метод реалізації @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 трохи меншою мовою. Я ніяким чином не є експертом Рубі, тому, мабуть, є можливість для вдосконалення.

Рубін 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 символів без пробілу. Використовує приблизно той же алгоритм, що і ОП, але з меншою ланцюжком. Я спробував багато рекурсії, і я спробував певну ітерацію, але всі вони, як-то чи інше, зациклюються.

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 символів пітона!

Редагувати 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]

Скала, 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 є безпечним, тому жоден смик ckhnceig не є кривдним. 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;
}

Рубін 1,9, 43 символи

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

Поки що не працює для рядків довжиною 1 символу (дублікатів цього символу) і не вдається для порожнього рядка

Пітон - 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"

Пітон, 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, він по суті є випадковим. Отже, тепер у нас є список випадково скрембованих літер від центру вихідного вводу. Все, що ми робимо зараз, - додавати відповідно першу та останню літери вихідного виводу, і ми отримали потрібний вихід: (перша літера) + (скремблирована середина) + (остання літера).

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 для обчислення а і 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):

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