Theo một số câu chuyện gây tranh cãi , odrer của ltteres trong wrod deos không phải là mttaer nhiều cho raednig, như lnog như frist và lsat lteter macth với wrod orignial.

Vì vậy, để giải trí, chức năng ngắn nhất để ngẫu nhiên hóa thứ tự chữ cái trong một từ trong khi giữ chữ cái đầu tiên và chữ cái cuối cùng là gì?

Đây là cú đâm của tôi vào nó với JavaScript. Tất cả các khoảng trắng đã loại bỏ nó ở mức 124 130 ký tự.

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 ngắn hơn luôn được chào đón.

• Chỉnh sửa: kiểm tra độ dài thêm. Chức năng không nên thất bại cho các từ ngắn.

Haskell, 4 ký tự

Các chức năng được đề xuất thực sự phù hợp với đặc điểm kỹ thuật:

s=id

Nó trả về chuỗi không thay đổi, do đó giữ các ký tự đầu tiên và cuối cùng ở vị trí và thực hiện hoán vị của tất cả các ký tự khác.

Nếu ai đó không hài lòng với phân phối xác suất của hoán vị, đây là một giải pháp mang lại phân phối tốt hơn. Nó rõ ràng phức tạp hơn nhiều:

Haskell, 110 120 107 ký tự

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

Một ví dụ về chương trình sử dụng chức năng này:

main = getLine >>= s >>= putStrLn

J, 26 24 23 ký tự

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

Ruby, 44 ký tự

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

Hoạt động cũng cho các từ ngắn, tức là các từ có một, hai hoặc ba ký tự được trả về không thay đổi.

Chỉnh sửa: Sử dụng ý tưởng mảng-splat của Ventero lưu một char khác.

Ruby 1.9, 46 ký tự

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

Golf

Là một "hàm" (tên mã): 20 ký tự

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

Khi hoạt động trên phần tử trên cùng trên ngăn xếp: 16 ký tự

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

C ++, 79 ký tự ^{_{( có kiểm tra phạm vi )}}

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

C ++ 8165 ký tự ^{_{( không có kiểm tra phạm vi )}}

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

Sử dụng pass bằng tham chiếu thay vì trả về kết quả sẽ loại bỏ 10 ký tự khác từ một trong hai giải pháp.

Chương trình đầy đủ, đọc một chuỗi các từ và xáo trộn chuyển đổi chúng:

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

Tinh thần: không xây dựng những gì đã có. Oh, và kiểm tra tràn là cho wusses.

Con trăn, 86 ký tự

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

Và đây là một ví dụ về việc sử dụng nó:

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

Đây là mã golf đầu tiên của tôi. Sau khi giải quyết vấn đề, tôi quyết định xem xét các câu trả lời và không có gì ngạc nhiên khi câu trả lời của tôi không phải là duy nhất. Điều này thật thú vị: o)

Tôi đã thực hiện một thay đổi sau khi xem các phản hồi khác và đó là thay đổi tuyên bố nhập khẩu của tôi để sử dụng bí danh. Ý tưởng tuyệt vời. ; o)

C (K & R) - 88 86 87 ký tự

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

Không có chức năng trao đổi hoặc xáo trộn tích hợp trong C, vì vậy tôi phải thực hiện thủ công :(

Chương trình mẫu với 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ửa lỗi khi s bao gồm ít hơn 3 ký tự (cảm ơn người dùng đã nhận thấy nó!)

python, 87 79 75 93 92 chars (xử lý chuỗi có độ dài 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: Ban đầu nghĩ rằng nó được cho là để phân chia các từ chuỗi (mà nó đã làm ở 128 ký tự; bây giờ là 87 ký tự yêu cầu). Argh, xấu của tôi trong việc đọc hiểu.

EDIT 2: Thay đổi từ def thành hàm lambda từ def để lưu 6 ký tự. Giả sử mẫu đã được nhập vào không gian tên ( from random import sample) có thể giảm giá trị này xuống ~ 60).

EDIT 3: "len (w [1: -1])" (12 ký tự) thành "len (w) -2" (8 ký tự) cho mỗi đề xuất hay của gnibbler's.

EDIT 4: JBernando đã lưu một char (đã xem xét from random import *và thấy nó tương đương - không nhận ra không gian trong import *là không cần thiết).; người dùng không biết đã thêm 19 ký tự w if len(w)<4 elseđể xử lý chính xác chuỗi 0 và 1 char.

EDIT 5: Đã lưu một char khác cho mỗi cú đánh golf mã của boothby. if len(w)<4 elseđể if 4>len(w)else.

C ++, 111 97 ký tự

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

Đây là một chương trình đầy đủ cho những người muốn thử nghiệm nó:

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

Biên tập

Nhận ra rằng không cần phải ngẫu nhiên cả hai chỉ số trao đổi, lưu một biến và thêm một vài ký tự.

php (68 ký tự)

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

ngắn hơn (60 ký tự)

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

Perl - 96 (hoặc 71) ký tự 84 (hoặc 59) ký tự

Đây là những gì tôi đã đưa ra trong Perl. Đã đi qua một vài cách khác nhau để làm điều đó nhưng điều này dường như ngắn nhất so với những gì tôi có thể nghĩ cho đến nay, với 97 ký tự.

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

Mặc dù, nếu bạn cắt bỏ dòng 'sử dụng' (mà tôi đoán là hợp lệ, vì những dòng khác loại trừ các dòng #incoide trong các chương trình C của họ), tôi có thể cắt nó xuống còn 71 ký tự :

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

EDIT Tôi đã đề nghị tôi thử thực hiện phương pháp này @tobius '. Bằng cách này, tôi đã giảm xuống còn 84 ký tự hoặc bằng cách xóa dòng sử dụng , 59 ký tự :

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

Ruby, 77 75 ký tự

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

Giải pháp Scala của tôi trong một ngôn ngữ ít dài dòng hơn. Tôi không phải là chuyên gia về Ruby, vì vậy có lẽ cần phải cải thiện.

Ruby 1.9, 77 48 46 44 ký tự

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

Tuyên bố miễn trừ trách nhiệm: Tôi đã điều chỉnh câu hỏi này dựa trên câu trả lời được xếp hạng cao nhất - nhận thấy câu trả lời chính xác tương tự sau này. Bạn có thể kiểm tra lịch sử mà tôi đã giữ đúng với ý tưởng ban đầu của mình nhưng đã thay đổi từ ruby ​​1.8 thành ruby ​​1.9 cho lambdas ngắn và shuffle.

Nếu từ trống được phép thì 56 54 ký tự

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

Python 3, 94 93 91 ký tự

Sử dụng một kỹ thuật khác nhau. Cũng có thể hoạt động trong 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

Cung ... if x[0:-1] else xcấp xnếu chiều dài của nó là 1 (nếu không nó sẽ được nhân đôi). Hàm do đó hoạt động cho các chuỗi có độ dài 0 và 1.

Đây sample()là từ https://stackoverflow.com/questions/2668312/shuffle-opes-in-python/2668366#2668366 .

Kể từ khi nó là một biểu hiện, chúng ta có thể sử dụng một lambda(loại bỏ return, defvà một cặp ngoặc đơn).

Chỉnh sửa: from random import* để lưu 1 ký tự, sau khi gửi Python khác.

JavaScript - 118 122 ký tự

JavaScript ngắn hơn - 118 ký tự không có khoảng trắng. Sử dụng thuật toán xấp xỉ như OP, nhưng ít xích hơn. Tôi đã thử rất nhiều đệ quy, và tôi đã thử một số lần lặp, nhưng tất cả chúng đều có xu hướng bị sa lầy theo cách này hay cách khác.

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 ký tự

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

Được rồi, tôi đã gian lận với một mảng char bình thường thay vì một chuỗi thực (đó là char bất biến [] để không bị xáo trộn tại chỗ)

chỉnh sửa với kiểm tra độ dài cần thêm 14

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

php 5.3 (60 ký tự)

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

Cải thiện thành 56 ký tự và không còn yêu cầu phiên bản 5.3:

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

Perl - 111 ký tự (không sử dụng bất kỳ chức năng thư viện nào)

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}

Cách sử dụng :

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

Con trăn

Đó là 90 89 112 ký tự của trăn!

Chỉnh sửa 1: như một chức năng lần này!

Chỉnh sửa 2: bây giờ xử lý các từ ngắn

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 ký tự

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: đã xóa ': Chuỗi' (loại trả về có thể được suy ra)
-7: đã xóa 'return' (biểu thức cuối cùng là giá trị trả về)
-3: được tính s.size-2ra
-4: toCharArray->toArray

Python, 86 ký tự

Slnicig là an toàn, vì vậy không có bnouds ckhnceig là neeacrssy. Wkros trên tất cả các 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 ký tự

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

chương trình đầy đủ:

#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 ký tự

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

Chưa hoạt động đối với Chuỗi có độ dài 1 ký tự (sao chép ký tự đó) và không thành công cho Chuỗi trống.

Python - 76 ký tự

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

Sử dụng:

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"

hàm dưới hoạt động với các từ có độ dài nhỏ hơn 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"

Con trăn, 102 ký tự

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]

Không có hàng nhập khẩu! Hoạt động cho các từ 1 ký tự trở lên. Đây là mục nhập gôn đầu tiên của tôi và tôi đã được truyền cảm hứng từ mục nhập của BlueEyedBeast từ mã ngắn nhất để tạo đầu ra không xác định cho ý tưởng sử dụng id (Object) .

Giải thích: Nó tạo một danh sách các chữ cái từ đầu vào không bao gồm đầu tiên và cuối cùng, và liên tục bật ra từ danh sách này và nối thêm một chữ cái mới cho đến khi trống. Chỉ số mà nó bật ra là id (7)% len (danh sách chúng tôi xuất hiện từ đó). Vì id (7) là địa chỉ bộ nhớ của đối tượng 7, nên về cơ bản là ngẫu nhiên. Vì vậy, bây giờ chúng tôi có một danh sách các chữ cái được xáo trộn ngẫu nhiên từ trung tâm của đầu vào ban đầu. Tất cả những gì chúng ta làm bây giờ là nối các chữ cái đầu tiên và cuối cùng của đầu ra ban đầu tương ứng và chúng ta đã nhận được đầu ra mà chúng ta muốn: (chữ cái đầu tiên) + (chữ giữa được xáo trộn) + (chữ cái cuối cùng).

R 95 92 91 ký tự

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

Làm cho việc sử dụng đánh giá lười biếng của R để tính a và b làm tham số hàm, tiết kiệm không gian với việc sử dụng lại sau này. Ngoài ra, không giống như các câu trả lời R khác, nó hoạt động với tất cả các từ> 1 char dài. Ví dụ dưới đây:

> f("hippopotamus")
hpuoopaitmps

> f("dog")
dog

> f("az")
az

Biên tập: Thay thế unlist()bằng[[]] Đã thay thế [[1]] bằng el ()

D: 55 ký tự

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

chương trình đầy đủ:

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 ký tự

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

Tôi vẫn đang học Erlang vì vậy mọi lời khuyên về việc rút ngắn này đều được đánh giá cao.

mã đầy đủ (mô-đun 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).

Biên tập

Lấy phần xáo trộn ra như một chức năng riêng biệt không còn yêu cầu phần đầu và đuôi của danh sách được truyền qua.

Chỉnh sửa 2

Cơ cấu lại để loại bỏ một trong những fmô hình chức năng, thay đổi chức năng ngẫu nhiên để chỉ chấp nhận hai tham số, thay đổi lists:deletecho --[], hoán đổi một lists:reversecuộc gọi cho mộtlists:last