논란의 여지가있는 이야기 에 따르면 , 무 당장에있는 수달의 주인은 프리스트만큼이나 귀신으로 가득한 것과 같이 raednig에 대해서는 그다지 중요하지 않다.

따라서 재미를 위해 첫 번째와 마지막 문자를 그대로 유지하면서 단어의 문자 순서를 무작위로 만드는 가장 짧은 기능은 무엇입니까?

JavaScript로 내 찌르는 것입니다. 모든 공백은 124130 자입니다.

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 자

제안 된 trinithis 함수는 실제로 스펙과 일치합니다.

s=id

문자열을 변경하지 않고 반환하므로 첫 번째 문자와 마지막 문자를 그대로 유지 하고 다른 모든 문자를 순열 합니다.

순열의 확률 분포에 누군가 불만족하는 경우 더 나은 분포를 제공하는 솔루션이 있습니다. 분명히 훨씬 더 복잡합니다.

하스켈, 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}

짧은 단어, 즉 1, 2 또는 3 개의 문자가있는 단어에도 적용됩니다.

편집 : Ventero의 배열 표시 아이디어를 사용하면 다른 문자가 저장됩니다.

루비 1.9, 46 자

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

골프 스크립트

"함수"(이름이 codeblock) : 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)

다른 응답을 본 후 한 가지 변경 작업을 수행했으며 별칭을 사용하도록 import 문을 변경했습니다. 좋은 생각이야 ;영형)

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

편집 : 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]

편집 : 원래 문자열 단어를 분할해야한다고 생각했습니다 (128 자에서 했으므로 이제 87 자에서 요구합니다). 아아, 독해력이 나쁘다

편집 2 : 6자를 저장하려면 def에서 lambda 함수를 def에서 변경하십시오. 샘플을 네임 스페이스로 이미 가져 from random import sample온다고 가정하면 ( )이 값을 ~ 60으로 줄일 수 있습니다.

편집 3 : gnibbler의 좋은 제안에 따라 "len (w [1 : -1])"(12 자) ~ "len (w) -2"(8 자).

편집 4 : JBernando는 한 문자를 저장했습니다 ( from random import *공간을 인식하지 않아도되는 것으로 간주 하고 동등한 것으로 간주 했습니다 import *) .; 알 수없는 사용자 w if len(w)<4 else는 0과 1 개의 문자열을 올바르게 처리하기 위해 19 개의 문자 를 추가했습니다 .

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

비록 'use'줄을 잘라 내면 (다른 사람들이 C 프로그램에서 #include 줄을 제외했기 때문에 유효하다고 생각합니다) 71 자 까지 더 줄일 수 있습니다 .

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

편집 @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

약간 덜 장황한 언어로 된 스칼라 솔루션. 저는 루비 전문가가 아니므로 개선의 여지가있을 것입니다.

루비 1.9, 77 48 46 44 문자

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

면책 조항 : 나는 가장 높은 순위의 답변을 기반으로 이것을 조정했습니다. 나중에 똑같은 대답을 발견했습니다. 원래 아이디어에 충실했지만 짧은 람다 및 루비 1.8에서 루비 1.9로 변경된 기록을 확인할 수 있습니다 shuffle.

빈 단어가 허용되면 56 54 자

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

파이썬 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 문자를 저장합니다.

자바 스크립트 - (118 개) 122 문자

더 짧은 JavaScript-공백없이 118 자. OP와 거의 동일한 알고리즘을 사용하지만 체인은 적습니다. 나는 많은 재귀를 시도했지만 반복을 시도했지만 모두 어떤 식 으로든 쇠약 해지는 경향이 있습니다.

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 배열로 부정 행위를했다.

길이 확인으로 편집 하면 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는 안전하므로 bnouds ckhnceig는 neeacrssy가 없습니다. 모든 leghtns에 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]

제 104 화

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 자 이상의 단어에 적용됩니다. 이것은 첫 번째 골프 항목이며 id (Object) 사용 아이디어에 대한 비 결정적 출력을 생성하기 위해 BlueEyedBeast의 Shortest 코드 항목에서 영감을 얻었습니다 .

설명 : 입력에서 첫 번째와 마지막을 제외한 문자 목록을 작성하고이 목록에서 반복적으로 팝업되어 비어있을 때까지 새 문자를 추가합니다. 그것이 나오는 인덱스는 id (7) % len (팝업 한리스트)입니다. id (7)은 객체 7의 메모리 주소이므로 본질적으로 무작위입니다. 이제 우리는 원래 입력의 중심에서 무작위로 스크램블 된 문자 목록을 얻었습니다. 이제 우리가하는 일은 원래 출력의 첫 글자와 마지막 글자를 추가하는 것입니다. 우리는 원하는 결과를 얻었습니다 : (첫 글자) + (스크램블 된 가운데) + (마지막 글자).

아르 자형, 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의 지연 평가를 사용하여 a 및 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).

나는 여전히 Erlang을 배우고 있으므로 이것을 더 짧게 만드는 것에 대한 조언은 높이 평가됩니다.

전체 코드 (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).

편집하다

셔플 부분을 별도의 기능으로 사용하여 목록의 머리와 꼬리를 더 이상 전달할 필요가 없습니다.

편집 2

중 하나 제거하는 구조 조정 f기능의 패턴을 변경 두 개의 매개 변수를 허용하도록 셔플 기능을 변경 lists:delete하기위한을 --[]하는 교환 lists:reverseA의 전화를lists:last