Według niektórych kontrowersyjnych historii , odrer z wrod deos nie wiele za raednig, tak samo jak frist i lsat lteter macth z oryginalnym wrod.

Więc, dla zabawy, jaka byłaby najkrótsza funkcja do losowego uporządkowania liter w słowie, przy jednoczesnym zachowaniu pierwszej i ostatniej litery?

Oto mój cios w JavaScript. Cała spacja usunięta ma 124 130 znaków.

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

Krótszy JavaScript zawsze mile widziany.

• Edycja: dodano kontrolę długości. Funkcja nie powinna zawieść w przypadku krótkich słów.

Haskell, 4 znaki

Zaproponowana funkcja trinithis faktycznie odpowiada specyfikacji:

s=id

Zwraca ciąg znaków bez zmian, utrzymując w ten sposób pierwszy i ostatni znak na miejscu i dokonując permutacji wszystkich pozostałych znaków.

Jeśli ktoś jest niezadowolony z rozkładu prawdopodobieństwa permutacji, oto rozwiązanie zapewniające lepszy rozkład. Jest to oczywiście o wiele bardziej złożone:

Haskell, 110 120 107 znaków

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

Przykład programu używającego tej funkcji:

main = getLine >>= s >>= putStrLn

J, 26 24 23 znaków

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

Ruby, 44 znaki

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

Działa również w przypadku krótkich słów, tzn. Słowa zawierające jeden, dwa lub trzy znaki są zwracane w niezmienionej formie.

Edycja: Użycie pomysłu tablicowego Ventero oszczędza kolejny znak.

Ruby 1.9, 46 znaków

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

Golfscript

Jako „funkcja” (o nazwie blok kodu): 20 znaków

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

Podczas działania na najwyższym elemencie stosu: 16 znaków

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

C ++, 79 znaków ^{_{( z kontrolą zakresu )}}

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

C ++, 8165 znaków ^{_{( bez sprawdzania zasięgu )}}

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

Użycie pass by referencji zamiast zwracania wyniku usuwa kolejne 10 znaków z obu rozwiązań.

Pełny program, odczytując ciąg słów i przetasowując je:

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

Morale: nie buduj tego, co już tam jest. Och, a kontrole przelewu dotyczą wusów.

Python, 86 znaków

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

A oto przykład użycia:

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

To jest mój pierwszy trening golfowy. Po rozwiązaniu problemu postanowiłem spojrzeć na odpowiedzi i nic dziwnego, że moja odpowiedź nie jest wyjątkowa. To było zabawne: o)

Dokonałem jednej zmiany po spojrzeniu na inne odpowiedzi i zmieniłem moją instrukcję importu na użycie aliasu. Świetny pomysł. ; o)

C (K&R) - 88 86 87 znaków

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

W C nie ma wbudowanej funkcji zamiany ani odtwarzania losowego, więc musiałem to zrobić ręcznie :(

Przykładowy program z 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;
}

EDYCJA : naprawiono błąd, gdy s składa się z mniej niż 3 znaków (dzięki nieznanemu użytkownikowi za zauważenie go!)

python, 87 79 75 93 92 znaki (obsługa ciągów o długości 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]

EDYCJA: Początkowo myślał, że powinien dzielić słowa łańcuchowe (co robił przy 128 znakach; teraz przy 87 znakach wymaga). Argh, mój kiepski z czytania ze zrozumieniem.

EDYCJA 2: Zmień z funkcji def na lambda z def, aby zapisać 6 znaków. Zakładając, że próbka jest już zaimportowana do przestrzeni nazw ( from random import sample), może to obniżyć do ~ 60).

EDYCJA 3: „len (w [1: -1])” (12 znaków) do „len (w) -2” (8 znaków) za miłą sugestię gnibblera.

EDYCJA 4: JBernando uratował jeden znak (rozważył from random import *i zobaczył, że jest równoważny - nie uświadomienie sobie, że miejsce import *jest niepotrzebne) .; użytkownik nieznany dodał 19 znaków, w if len(w)<4 elseaby poprawnie obsługiwać ciągi znaków 0 i 1.

EDYCJA 5: Zapisałem kolejny kod na sztuczkę golfową dla boothby'ego. if len(w)<4 elsedo if 4>len(w)else.

C ++, 111 97 znaków

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

Oto pełny program dla tych, którzy chcą go przetestować:

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

Edytować

Uświadomiono sobie, że nie ma potrzeby losowania obu indeksów wymiany, zapisania zmiennej i kilku innych znaków.

php (68 znaków)

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

krótszy (60 znaków)

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

Perl - 96 (lub 71) znaków 84 (lub 59) znaków

To właśnie wymyśliłem w Perlu. Przeszedłem kilka różnych sposobów, aby to zrobić, ale wydawało się to najkrótsze z tego, co do tej pory myślę, przy 97 znakach.

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

Chociaż, jeśli wytniesz linię „use” (co, jak sądzę, jest poprawna, ponieważ inni wykluczyli #include linii w swoich programach C), mogę ją zmniejszyć do 71 znaków :

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

EDYCJA Sugerowano, żebym spróbował wykonać tę metodę implementacji @tobiusa. W ten sposób zredukowałem go do 84 znaków , lub usuwając wiersz użycia , 59 znaków :

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

Ruby, 77 75 znaków

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

Moje rozwiązanie Scala w nieco mniej szczegółowym języku. W żadnym wypadku nie jestem ekspertem od Ruby, więc prawdopodobnie jest miejsce na ulepszenia.

Ruby 1.9, 77 48 46 44 znaków

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

Oświadczenie: Dostosowałem to na podstawie odpowiedzi najwyżej ocenionej - później zauważyłem dokładnie taką samą odpowiedź. Możesz sprawdzić historię, którą zachowałem zgodnie z moim oryginalnym pomysłem, ale zmieniłem z ruby ​​1.8 na ruby ​​1.9 w przypadku krótkich lambd i shuffle.

Jeśli dozwolone są puste słowa, to 56 54 znaków

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

Python 3, 94 93 91 znaków

Używanie innej techniki. Może także działać w Pythonie 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 xDaje xjeżeli jego długość wynosi 1 (inaczej byłoby powielany). Funkcja działa w ten sposób dla ciągów o długości 0 i 1.

To sample()pochodzi z https://stackoverflow.com/questions/2668312/shuffle-string-in-python/2668366#2668366 .

Ponieważ jest to jeden wyraz, możemy użyć lambda(eliminuje return, deforaz parę nawiasów).

Edycja: from random import* aby zapisać 1 znak po drugim przesłaniu Pythona.

JavaScript - 118 122 znaków

Krótszy JavaScript - 118 znaków bez spacji. Używa w przybliżeniu tego samego algorytmu co OP, ale z mniejszym łańcuchem. Próbowałem wiele rekurencji i próbowałem wykonać iterację, ale wszystkie one mają tendencję do zapadania się w taki czy inny sposób.

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 znaki

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

ok, oszukiwałem normalną tablicą znaków zamiast prawdziwego ciągu znaków (który jest niezmiennym char [], więc nie tasuje się w miejscu)

edycja z kontrolą długości wymaga 14 więcej

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

php 5.3 (60 znaków)

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

Ulepszony do 56 znaków i nie wymaga już wersji 5.3:

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

Perl - 111 znaków (bez użycia funkcji biblioteki)

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}

Zastosowanie :

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

Pyton

To 90 89 112 znaków python!

Edycja 1: tym razem jako funkcja!

Edycja 2: obsługuje teraz krótkie słowa

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 znaków

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: usunięto „ciąg” (typ zwrotny można wywnioskować)
-7: usunięte „powrotu” (ostatnie wyrażenie jest wartość powrotna)
-3: uwzględnione s.size-2na
-4: toCharArray->toArray

Python, 86 znaków

Slnicig jest bezpieczny, więc żadne bnouds ckhnceig nie jest neeacrssy. Wkros we wszystkich leghtns.

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 znaków

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

pełny program:

#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 znaki

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

Nie działa jeszcze dla Ciągów o długości 1 znaku (duplikuje ten znak), a dla pustych Ciągów kończy się niepowodzeniem.

Python - 76 znaków

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

Stosowanie:

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"

poniższa funkcja działa ze słowami o długości mniejszej niż 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 znaki

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]

Bez importu! Działa dla słów 1 i wyżej. To jest mój pierwszy wpis w golfa i zainspirował mnie wpis BlueEyedBeast z Shortest code w celu uzyskania niedeterministycznych danych wyjściowych dla pomysłu użycia id (Object) .

Objaśnienie: Tworzy listę liter na podstawie danych wejściowych z wyłączeniem pierwszej i ostatniej i wielokrotnie wyskakuje z tej listy i dołącza się do nowej, aż będzie pusta. Indeks, z którego wyskakuje, to id (7)% len (lista, z której wyskakujemy). Ponieważ id (7) jest adresem pamięci obiektu 7, jest on zasadniczo losowy. Mamy teraz listę losowo zaszyfrowanych liter ze środka oryginalnego tekstu. Wszystko, co teraz robimy, to odpowiednio dołączyć pierwszą i ostatnią literę oryginalnego wyjścia i otrzymaliśmy pożądany wynik: (pierwsza litera) + (zakodowany środek) + (ostatnia litera).

R, 95 92 91 znaków

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

Wykorzystuje leniwą ocenę R do obliczenia a i b jako parametrów funkcji, oszczędzając miejsce z ponownym użyciem później. Również w przeciwieństwie do innych odpowiedzi R działa to dla wszystkich słów o długości> 1 znak. Przykład poniżej:

> f("hippopotamus")
hpuoopaitmps

> f("dog")
dog

> f("az")
az

Edytować: zastąpione unlist()z[[]] Zamieniono [[1]] na el ()

D: 55 znaków

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

pełny program:

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 znaków

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

Wciąż uczę się Erlanga, więc wszelkie wskazówki dotyczące skrócenia tej wersji są mile widziane.

pełny kod (moduł 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).

Edytować

Wyodrębniono część losową jako osobną funkcję, która nie wymaga już omijania głowy i ogona listy.

Edytuj 2

Zrestrukturyzowano, aby usunąć jeden z fwzorców funkcji, zmieniono funkcję odtwarzania losowego, aby zaakceptować tylko dwa parametry, zmieniono lists:deletena --[], zamieniono lists:reversewywołanie nalists:last