Menurut beberapa kisah kontroversial , bau tak sedap dalam satu wrod deos tidak terlalu berpengaruh pada raednig, sama besarnya dengan para penganut dan pengajar yang macth dengan orignial wrod.

Jadi, untuk bersenang-senang, apa fungsi terpendek untuk mengacak urutan huruf dalam sebuah kata sambil mempertahankan huruf pertama dan terakhir?

Inilah tikaman saya dengan JavaScript. Semua spasi dihapus pada 124 130 karakter.

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 lebih pendek selalu diterima.

• Edit: pemeriksaan panjang ditambahkan. Fungsi tidak boleh gagal untuk kata-kata pendek.

Haskell, 4 karakter

Fungsi trinithis yang diusulkan sebenarnya sesuai dengan spesifikasi:

s=id

Ini mengembalikan string tidak berubah, sehingga menjaga karakter pertama dan terakhir tetap di tempatnya dan melakukan permutasi semua karakter lainnya.

Jika seseorang tidak puas dengan distribusi probabilitas permutasi, berikut adalah solusi yang menghasilkan distribusi yang lebih baik. Ini jelas jauh lebih kompleks:

Haskell, 110 120 107 karakter

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

Contoh program yang menggunakan fungsi ini:

main = getLine >>= s >>= putStrLn

J, 26 24 23 karakter

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

Ruby, 44 karakter

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

Juga berfungsi untuk kata-kata pendek, yaitu kata-kata dengan satu, dua atau tiga karakter dikembalikan tidak berubah.

Sunting: Menggunakan ide array-splat Ventero menyimpan char lain.

Ruby 1.9, 46 karakter

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

Naskah Golf

Sebagai "fungsi" (bernama kode kunci): 20 karakter

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

Saat beroperasi pada elemen paling atas di tumpukan: 16 karakter

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

C ++, 79 karakter ^{_{( dengan rentang periksa )}}

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

C ++, 8165 karakter ^{_{( tanpa rentang periksa )}}

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

Menggunakan referensi lewat alih-alih mengembalikan hasilnya mengurangi 10 karakter dari solusi mana pun.

Program lengkap, membaca serangkaian kata dan mengacaknya:

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

Semangat: jangan membangun apa yang sudah ada di sana. Oh, dan cek melimpah adalah untuk wusses.

Python, 86 karakter

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

Dan inilah contoh menggunakannya:

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

Ini adalah latihan golf kode pertama saya. Setelah menyelesaikan masalah saya memutuskan untuk melihat jawabannya dan tidak heran jawaban saya tidak unik. Ini menyenangkan: o)

Saya memang membuat satu perubahan setelah melihat tanggapan lain dan itu mengubah pernyataan impor saya untuk menggunakan alias. Ide yang hebat. ;Hai)

C (K&R) - 88 86 87 karakter

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

Tidak ada fungsi built-in swap atau shuffle di C, jadi saya harus melakukannya secara manual :(

Contoh Program dengan 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;
}

Sunting : perbaiki bug ketika s terdiri dari kurang dari 3 karakter (terima kasih kepada pengguna karena memperhatikannya!)

python, 87 79 75 93 92 karakter (menangani string dengan panjang 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: Awalnya pikir itu seharusnya membagi kata string (yang dilakukan pada 128 karakter; sekarang pada 87 karakter diperlukan). Argh, buruknya kemampuan membaca saya.

EDIT 2: Ubah dari fungsi def ke fungsi lambda dari def untuk menyimpan 6 karakter. Mengasumsikan sampel sudah diimpor ke namespace ( from random import sample) dapat membawa ini ke ~ 60).

EDIT 3: "len (w [1: -1])" (12 chars) menjadi "len (w) -2" (8 chars) per saran bagus gnibbler.

EDIT 4: JBernando menyelamatkan satu char (telah mempertimbangkan from random import *dan melihat itu setara - tidak menyadari ruang import *tidak diperlukan); pengguna tidak dikenal menambahkan 19 karakter w if len(w)<4 elseuntuk menangani 0 dan 1 string char dengan benar.

EDIT 5: Menyelamatkan trik golf kode char lain per booth. if len(w)<4 elseuntuk if 4>len(w)else.

C ++, 111 97 karakter

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

Ini adalah program lengkap untuk mereka yang ingin mengujinya:

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

Sunting

Sadar tidak perlu acak kedua indeks swap, menyimpan variabel dan beberapa karakter lagi.

php (68 karakter)

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

lebih pendek (60 karakter)

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

Perl - 96 (atau 71) karakter 84 (atau 59) karakter

Inilah yang saya temukan di Perl. Pergi melalui beberapa cara berbeda untuk melakukannya tetapi ini tampaknya terpendek dari apa yang dapat saya pikirkan sejauh ini, yaitu 97 karakter.

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

Padahal, jika Anda memotong baris 'use' (yang saya kira valid, karena orang lain mengecualikan #include baris dalam program C mereka) saya dapat memotongnya lebih jauh menjadi 71 karakter :

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

EDIT Disarankan agar saya mencoba melakukan ini dengan menerapkan metode @tobius. Dengan cara ini saya menurunkannya menjadi 84 karakter , atau dengan menghapus baris penggunaan , 59 karakter :

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

Ruby, 77 75 karakter

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

Solusi Scala saya dalam bahasa yang sedikit kurang verbose. Saya bukan ahli Ruby, jadi mungkin ada ruang untuk perbaikan.

Ruby 1.9, 77 48 46 44 karakter

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

Penafian: Saya menyetel ini berdasarkan jawaban peringkat tertinggi - perhatikan jawaban yang sama persis di kemudian hari. Anda dapat memeriksa sejarah bahwa saya telah mempertahankan ide asli saya tetapi berubah dari ruby ​​1.8 ke ruby ​​1.9 untuk lambda pendek dan shuffle.

Jika kata-kata kosong diizinkan maka 56 54 karakter

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

Python 3, 94 93 91 karakter

Menggunakan teknik yang berbeda. Mungkin juga bekerja di 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

The ... if x[0:-1] else xmemberi xjika panjangnya adalah 1 (jika tidak akan diduplikasi). Fungsi dengan demikian bekerja untuk string dengan panjang 0 dan 1.

Ini sample()dari https://stackoverflow.com/questions/2668312/shuffle-string-in-python/2668366#2668366 .

Karena itu salah satu ekspresi, kita bisa menggunakan lambda(menghilangkan return, defdan sepasang kurung).

Edit: from random import* untuk menyimpan 1 karakter, setelah pengiriman Python lainnya.

JavaScript - 118 122 karakter

JavaScript lebih pendek - 118 karakter tanpa spasi. Menggunakan algoritma yang kira-kira sama dengan OP, tetapi dengan sedikit rantai. Saya mencoba banyak rekursi, dan saya mencoba beberapa iterasi, tetapi mereka semua cenderung macet dalam beberapa cara.

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 karakter

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

oke saya curang dengan array char normal alih-alih string nyata (yang tidak berubah char [] jadi tidak ada pengocokan di tempat)

sunting dengan panjang periksa itu membutuhkan 14 lebih

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

php 5.3 (60 karakter)

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

Ditingkatkan menjadi 56 karakter dan tidak lagi membutuhkan versi 5.3:

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

Perl - 111 karakter (tanpa menggunakan fungsi pustaka)

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}

Penggunaan :

$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

Ini 90 89 112 karakter python!

Sunting 1: sebagai fungsi kali ini!

Sunting 2: sekarang menangani kata-kata pendek

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 karakter

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: dihapus ': String' (tipe pengembalian dapat disimpulkan)
-7: dihapus 'kembali' (ekspresi terakhir adalah nilai balik)
-3: factored s.size-2out
-4: toCharArray->toArray

Python, 86 karakter

Slnicig aman, jadi tidak ada ckhnceig yang dapat dilakukan. Wkros di semua leghtn.

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 karakter

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

program lengkap:

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

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

Belum berfungsi untuk 1 string panjang karakter (menduplikasi karakter itu), dan gagal untuk String kosong.

Python - 76 karakter

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

Pemakaian:

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"

fungsi di bawah ini berfungsi dengan kata-kata dengan panjang kurang dari 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 karakter

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]

Tidak ada impor! Berfungsi untuk kata-kata 1 karakter ke atas. Ini adalah entri golf pertama saya dan saya terinspirasi oleh entri BlueEyedBeast dari kode terpendek untuk menghasilkan output non-deterministik untuk ide menggunakan id (Object) .

Penjelasan: Itu membuat daftar huruf dari input mengecualikan yang pertama dan terakhir, dan berulang kali muncul dari daftar ini dan menambahkan yang baru sampai kosong. Indeks tempat ia muncul adalah id (7)% len (daftar kami muncul dari). Karena id (7) adalah alamat memori objek 7, itu pada dasarnya acak. Jadi sekarang kami memiliki daftar surat acak yang diacak dari pusat input asli. Yang kita lakukan sekarang adalah menambahkan huruf pertama dan terakhir dari output asli yang sesuai dan kita mendapatkan output yang kita inginkan: (huruf pertama) + (tengah acak) + (huruf terakhir).

R, 95 92 91 karakter

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

Manfaatkan evaluasi malas R untuk menghitung a dan b sebagai parameter fungsi, menghemat ruang dengan digunakan kembali nanti. Juga tidak seperti jawaban R lainnya ini bekerja untuk semua kata> 1 karakter. Contoh di bawah ini:

> f("hippopotamus")
hpuoopaitmps

> f("dog")
dog

> f("az")
az

Sunting: Diganti unlist()dengan[[]] Digantikan [[1]] dengan el ()

D: 55 karakter

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

program lengkap:

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 karakter

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

Saya masih belajar Erlang sehingga tips untuk membuat ini lebih pendek dihargai.

kode lengkap (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).

Sunting

Mengambil bagian acak sebagai fungsi terpisah yang tidak lagi membutuhkan kepala dan ekor daftar untuk diedarkan.

Edit 2

Direstrukturisasi untuk menghapus salah satu fpola fungsi, mengubah fungsi acak untuk hanya menerima dua parameter, diubah lists:deleteuntuk --[], bertukar lists:reversepanggilan untuklists:last