Einer umstrittenen Geschichte zufolge ist der Unterschied zwischen den Buchstaben in einem Schriftstück nicht viel für das Wort, ebenso wenig wie die ersten und letzten Buchstaben mit dem ursprünglichen Schriftstück.

Also, zum Spaß, was wäre die kürzeste Funktion, um die Buchstabenreihenfolge in einem Wort zufällig zu ordnen, während der erste und der letzte Buchstabe an Ort und Stelle bleiben?

Hier ist mein Versuch mit JavaScript. Alle Leerzeichen entfernt es ist bei 124 130 Zeichen.

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

Kürzere JavaScript immer willkommen.

• Bearbeiten: Längenprüfung hinzugefügt. Die Funktion sollte für kurze Wörter nicht fehlschlagen.

Haskell, 4 Zeichen

Der vorgeschlagene Funktions-Trinith stimmt tatsächlich mit der Spezifikation überein:

s=id

Es gibt die Zeichenfolge unverändert, so dass das erste und letztes Zeichen an Ort und Stelle zu halten und dabei eine Permutation aller anderen Zeichen.

Wenn jemand mit der Wahrscheinlichkeitsverteilung der Permutationen unzufrieden ist, ist hier eine Lösung, die eine bessere Verteilung ergibt. Es ist offensichtlich viel komplexer:

Haskell, 110 120 107 Zeichen

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

Ein Beispiel für ein Programm, das diese Funktion verwendet:

main = getLine >>= s >>= putStrLn

J, 26 24 23 Zeichen

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

Ruby, 44 Zeichen

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

Funktioniert auch für kurze Wörter, dh Wörter mit einem, zwei oder drei Zeichen werden unverändert zurückgegeben.

Bearbeiten: Mit der Array-Splat-Idee von Ventero wird ein weiteres Zeichen gespeichert.

Ruby 1.9, 46 Zeichen

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

Golfscript

Als "Funktion" (benannter Codeblock): 20 Zeichen

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

Wenn Sie mit dem obersten Element auf dem Stapel arbeiten: 16 Zeichen

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

C ++, 79 Zeichen ^{_{( mit Bereichsprüfung )}}

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

C ++, 8165 Zeichen ^{_{( ohne Bereichsprüfung )}}

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

Durch die Verwendung der Referenzübergabe anstelle der Rückgabe des Ergebnisses werden weitere 10 Zeichen aus beiden Lösungen entfernt.

Volles Programm, eine Reihe von Wörtern lesen und diese mischen:

#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: Bauen Sie nicht, was schon da ist. Oh, und Überlaufprüfungen sind für Probleme.

Python, 86 Zeichen

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

Und hier ist ein Beispiel für die Verwendung:

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

Dies ist meine erste Code-Golfübung. Nachdem ich das Problem gelöst hatte, beschloss ich, mir die Antworten anzuschauen, und es ist keine Überraschung, dass meine Antwort nicht eindeutig ist. Das hat Spaß gemacht: o)

Ich habe eine Änderung vorgenommen, nachdem ich mir die anderen Antworten angesehen hatte, und dabei wurde meine Importanweisung geändert, um einen Alias ​​zu verwenden. Großartige Idee. ;O)

C (K & R) - 88 86 87 Zeichen

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

Es gibt keine eingebaute Swap- oder Shuffle-Funktion in C, daher musste ich es manuell machen :(

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

BEARBEITEN : Behebung des Fehlers, wenn s aus weniger als 3 Zeichen besteht (dank des Unbekannten, der es bemerkt hat!)

Python, 87 79 75 93 92 Zeichen (für Saiten mit einer Länge von 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: Ursprünglich dachte, es sollte Zeichenfolgenwörter aufteilen (was es bei 128 Zeichen tat; jetzt bei 87 Zeichen ist erforderlich). Argh, mein schlechtes Leseverständnis.

EDIT 2: Wechseln Sie von def zur Lambda-Funktion von def, um 6 Zeichen zu sparen. Angenommen, das Sample ist bereits in den Namespace importiert ( from random import sample), könnte dies auf ~ 60 reduzieren).

EDIT 3: "len (w [1: -1])" (12 Zeichen) bis "len (w) -2" (8 Zeichen) pro netter Vorschlag des Knabbers.

EDIT 4: JBernando speicherte ein Zeichen (hatte from random import *es als äquivalent angesehen - es ist nicht import *notwendig , den Platz in zu realisieren ); Unbekannter Benutzer hat 19 Zeichen hinzugefügt w if len(w)<4 else, um die Zeichenfolgen 0 und 1 korrekt zu behandeln.

EDIT 5: Ein weiterer Char per Boothby-Code-Golf-Trick wurde gespeichert. if len(w)<4 elsezu if 4>len(w)else.

C ++, 111 97 Zeichen

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

Hier ist ein vollständiges Programm für diejenigen, die es testen möchten:

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

Bearbeiten

Es wurde erkannt, dass es nicht notwendig ist, beide Auslagerungsindizes nach dem Zufallsprinzip zu vertauschen, eine Variable und einige weitere Zeichen zu speichern.

PHP (68 Zeichen)

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

kürzer (60 Zeichen)

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

Perl - 96 (oder 71) Zeichen 84 (oder 59) Zeichen

Das habe ich mir in Perl ausgedacht. Ich habe ein paar verschiedene Methoden durchlaufen, aber dies schien mir mit 97 Zeichen die kürzeste zu sein, von der ich bisher denken konnte.

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

Wenn Sie jedoch die 'use'-Zeile ausschneiden (was meiner Meinung nach gültig ist, da andere #include-Zeilen in ihren C-Programmen ausschließen), kann ich sie weiter auf 71 Zeichen reduzieren :

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

BEARBEITEN Es wurde vorgeschlagen, diese Methode von @tobius zu implementieren. Auf diese Weise habe ich es auf 84 Zeichen reduziert oder durch Entfernen der Verwendungszeile auf 59 Zeichen :

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

Ruby, 77 75 Zeichen

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

Meine Scala-Lösung in einer etwas weniger ausführlichen Sprache. Ich bin in keiner Weise ein Ruby-Experte, daher gibt es wahrscheinlich Raum für Verbesserungen.

Ruby 1,9, 77 48 46 44 Zeichen

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

Haftungsausschluss: Ich habe dies basierend auf der bestplatzierten Antwort abgestimmt - habe später genau dieselbe Antwort bemerkt. Sie können die Geschichte überprüfen, die ich meiner ursprünglichen Idee treu gehalten habe, aber für kurze Lambdas und von Ruby 1.8 auf Ruby 1.9 geändert habe shuffle.

Wenn leere Wörter erlaubt sind, dann 56 54 Zeichen

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

Python 3, 94 93 91 Zeichen

Mit einer anderen Technik. Funktioniert möglicherweise auch in 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

Das ... if x[0:-1] else xergibt, xwenn seine Länge 1 ist (sonst würde es dupliziert werden). Die Funktion funktioniert dabei für Strings der Länge 0 und 1.

Die sample()stammt von https://stackoverflow.com/questions/2668312/shuffle-string-in-python/2668366#2668366 .

Da es ein Ausdruck ist, können wir eine verwenden lambda(Beseitigung return, defund ein Paar von Klammern).

Bearbeiten: from random import* um 1 Zeichen nach der anderen Python-Übermittlung zu speichern.

JavaScript - 118 122 Zeichen

Kürzere JavaScript - 118 Zeichen ohne Leerzeichen. Verwendet ungefähr den gleichen Algorithmus wie das OP, jedoch mit weniger Verkettung. Ich habe eine Menge Rekursionen versucht, und ich habe einige Iterationen versucht, aber alle neigen dazu, auf die eine oder andere Weise festzusacken.

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 Zeichen

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

okay, ich habe mit einem normalen char-Array betrogen, anstatt mit einem echten String (der unveränderlich char [] ist, also kein direktes Mischen)

Mit einem Längencheck bearbeiten , es werden 14 weitere benötigt

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

PHP 5.3 (60 Zeichen)

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

Verbessert auf 56 Zeichen und benötigt keine Version 5.3 mehr:

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

Perl - 111 Zeichen (ohne Bibliotheksfunktion)

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}

Verwendung :

$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

Es ist 90 89 112 Zeichen von Python!

Edit 1: diesmal als Funktion!

Edit 2: Behandelt jetzt kurze Wörter

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 Zeichen

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: 'entfernt: String' (Rückgabetyp abgeleitet werden kann)
-7: entfernt 'Rückkehr' (letzter Ausdruck ist der Rückgabewert)
-3: einkalkuliert s.size-2out
-4: toCharArray->toArray

Python, 86 Zeichen

Slnicig ist sicher, also ist kein bnouds ckhnceig neeacrssy. Wkros auf allen Beinen.

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 Zeichen

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

Volles Programm:

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

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

Funktioniert noch nicht für Zeichenfolgen mit einer Zeichenlänge (dupliziert dieses Zeichen) und schlägt für leere Zeichenfolgen fehl.

Python - 76 Zeichen

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

Verwendungszweck:

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"

Die folgende Funktion funktioniert mit Wörtern mit einer Länge von weniger als 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 Zeichen

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]

Keine Importe! Funktioniert für Wörter ab 1 Zeichen. Dies ist mein erster Golfeintrag und ich wurde von BlueEyedBeasts Eintrag aus Shortest Code inspiriert , um eine nicht deterministische Ausgabe für die Idee der Verwendung von id (Object) zu erzeugen .

Erläuterung: Es wird eine Liste von Buchstaben aus der Eingabe erstellt, wobei der erste und der letzte Buchstabe ausgenommen sind. Diese Liste wird wiederholt aufgerufen und an einen neuen angehängt, bis sie leer ist. Der Index, aus dem es herausspringt, ist id (7)% len (Liste, aus der wir herausspringen). Da id (7) die Speicheradresse des Objekts 7 ist, ist es im Wesentlichen zufällig. Jetzt haben wir eine Liste von zufällig verschlüsselten Buchstaben aus der Mitte der ursprünglichen Eingabe. Jetzt müssen wir nur noch den ersten und den letzten Buchstaben der Originalausgabe anhängen und haben die gewünschte Ausgabe: (erster Buchstabe) + (durcheinandergemischte Mitte) + (letzter Buchstabe).

R, 95 92 91 Zeichen

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

Nutzt die verzögerte Auswertung von R, um a und b als Funktionsparameter zu berechnen, und spart Platz bei der späteren Wiederverwendung. Auch im Gegensatz zu anderen R-Antworten funktioniert dies für alle Wörter> 1 Zeichen lang. Beispiel unten:

> f("hippopotamus")
hpuoopaitmps

> f("dog")
dog

> f("az")
az

Bearbeiten: Ersetzt unlist()durch[[]] Ersetzt [[1]] durch el ()

D: 55 Zeichen

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

Volles Programm:

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 Zeichen

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

Ich lerne immer noch Erlang, daher sind alle Tipps zur Verkürzung willkommen.

vollständiger Code (Modul 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).

Bearbeiten

Nahm den Shuffle-Teil als separate Funktion heraus, die nicht länger erfordert, dass der Kopf und der Schwanz der Liste herumgereicht werden.

Bearbeiten 2

Umstrukturiert einen der entfernen fFunktion Muster änderten die Shuffle - Funktion nur zwei Parameter zu akzeptieren, geändert lists:deletefür --[]einen tauschte lists:reverseAnruf für einlists:last