Tartışmalı bazı öykülere göre, bir değirmenin içindeki odun akıntısı, orkinal öbürle frist ve lsat litre macn gibi lnog, raednig için çok daha fazla değil.

Peki, eğlence için, ilk ve son harfi yerinde tutarken harf sırasını bir kelimede rastgele seçen en kısa işlev ne olurdu?

İşte JavaScript ile bıçaklarım. Tüm boşluklar kaldırıldı, 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];
}

Daha kısa JavaScript her zaman beklerim.

• Düzenleme: uzunluk kontrolü eklendi. İşlev kısa kelimeler için başarısız olmamalıdır.

Haskell, 4 karakter

Önerilen trinithis işlevi aslında özelliklerle eşleşiyor:

s=id

Böylece yerinde ilk ve son karakterlerini tutmak ve yaptığını, dize değişmeden döndüren bir permütasyon diğer tüm karakterlerin.

Birisi permütasyonların olasılık dağılımından memnun değilse, burada daha iyi bir dağıtım sağlayan bir çözüm var. Açıkçası çok daha karmaşık:

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

Bu işlevi kullanan bir program örneği:

main = getLine >>= s >>= putStrLn

J, 26 24 23 karakter

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

Yakut, 44 karakter

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

Kısa kelimeler için de çalışır, yani bir, iki veya üç karakterden oluşan kelimeler değiştirilmeden döndürülür.

Düzenleme: Ventero dizi uyarısı fikrini kullanarak başka bir karakter kaydeder.

Yakut 1.9, 46 karakter

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

Golfscript

Bir "işlev" olarak (adlandırılmış kod bloğu): 20 karakter

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

Yığındaki en üstteki eleman üzerinde çalışırken: 16 karakter

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

C ++, 79 karakter ^{_{( aralık kontrolü ile )}}

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

C ++ 8165 karakter ^{_{( aralık kontrolü olmadan )}}

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

Sonucu döndürmek yerine referansa göre geçmek, her iki çözümden de 10 karakter daha alır.

Tam program, bir kelime dizisi okumak ve bunları dönüştürmek için karıştırmak:

#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: zaten orada olanı yapma. Oh, ve taşma kontrolleri mazeretler içindir.

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]

Ve işte bunu kullanmanın bir örneği:

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

Bu benim ilk kod golf exerise. Problemi çözdükten sonra cevaplara bakmaya karar verdim ve bunun şaşırtıcı olması benim cevabımın benzersiz olmaması. Bu olsa da eğlenceliydi: o)

Diğer cevaplara baktıktan sonra bir değişiklik yaptım ve takma adı kullanmak için import ifademi değiştiriyordum. İyi fikir. ;Ö)

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

C yerleşik bir takas takma veya karıştırma işlevi yok, bu yüzden el ile yapmak zorundaydım :(

Ungolfed r () ile Örnek Program:

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

DÜZENLEME : s 3 karakterden az olduğunda hatayı düzeltti (fark etmesi için kullanıcı uknown sayesinde!)

python, 87 79 75 93 92 karakter (0,1 uzunlukta uzunluk telleri)

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: Başlangıçta sicim kelimeleri ayırması gerektiğini düşündü (128 karakterde; şimdi 87 karakterde şart). Argh, okuduğunu anlamadaki kötüyüm.

EDIT 2: def'den lambda fonksiyonuna, def'den 6 karaktere kadar tasarruf edin. Numunenin zaten ad alanına ( from random import sample) alındığını varsayarsak, bunu ~ 60'a indirebiliriz.

EDIT 3: gnibbler'ın hoş önerisi başına "len (w [1: -1])" (12 karakter) - "len (w) -2" (8 karakter).

DÜZENLEME 4: JBernando bir karakter kurtardı ( from random import *eşdeğer olduğunu düşündü ve gördü - içindeki boşluğun import *gereksiz olduğunu fark etmeden ) .; bilinmeyen kullanıcı, w if len(w)<4 else0 ve 1 karakter dizilerini doğru kullanmak için 19 karakter ekledi .

DÜZENLEME 5: Her kabinin kod golf hilesi başına başka bir karakter kurtardı. if len(w)<4 elseiçin 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;}

Test etmek isteyenler için tam bir program:

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

Düzenle

Değişken ve birkaç karakterden oluşan her iki takas endeksini de rasgele düzenlemeye gerek olmadığı fark edildi.

php (68 karakter)

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

daha kısa (60 karakter)

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

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

Perl’de bulduğum şey buydu. Bunu yapmak için birkaç farklı yoldan geçtim, ancak bu şu ana kadar 97 karakterde düşünebildiklerimden daha kısa görünüyordu.

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

Yine de, 'kullanım' satırını kestiyseniz (ki diğerleri geçerlidir, çünkü diğerleri C programlarına satırları eklemez) çünkü bunları 71 karakterden daha fazla kesebilirim :

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

EDIT Bu uygulamayı @tobius yöntemini yapmaya çalışmam önerildi. Bu şekilde onu 84 karaktere indirdim veya kullanım çizgisini kaldırarak 59 karaktere düşürdüm :

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

Scala çözümüm biraz daha ayrıntılı bir dilde. Ben hiçbir şekilde bir Ruby uzmanı değilim, bu yüzden muhtemelen iyileştirmeye yer var.

Ruby 1.9, 77 48 46 44 karakter

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

Feragatname: Bunu en yüksek dereceli cevaba göre ayarladım - aynı cevabı daha sonra farkettim. Özgün fikrime sadık kaldığım, ancak kısa lambdalar için yakut 1.8'den yakut 1.9'a değiştirdiğim tarihi kontrol edebilirsiniz shuffle.

Boş kelimelere izin verilirse, 56 karakter

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

Python 3, 94 93 91 karakterler

Farklı bir teknik kullanmak. Python 2'de de çalışabilir.

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 xVerir xuzunluğu 1 ise (aksi takdirde çoğaltılabilir olurdu). Böylece işlev, 0 ve 1 uzunlukta diziler için çalışır.

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

O bir ifade olduğundan, bunu bir kullanabilir lambda(ortadan kaldırarak return, defparantez ve bir çift).

Düzenleme: from random import* Diğer Python gönderiminden sonra 1 karakter kaydetmek için.

JavaScript - 118 122 karakter

Daha kısa JavaScript - beyaz boşluksuz 118 karakter. OP ile yaklaşık olarak aynı algoritmayı kullanır, ancak daha az zincirleme ile kullanır. Çok fazla özyinelemeyi denedim ve bazı yinelemeleri denedim, ancak hepsi bir şekilde ya da başka şekilde tıkanmaya meyilli.

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

tamam ben gerçek bir dize yerine normal bir karakter dizisi ile aldattı (ki değişmez karakter [] yani yerinde karıştırma yok)

düzenlemek o 14 fazlasını gerektirir kontrol uzunluğunda

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

56 karaktere geliştirildi ve artık sürüm 5.3 gerektirmiyor:

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

Perl - 111 karakter (hiçbir kütüphane işlevini kullanmadan)

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}

Kullanım :

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

piton

Bu var 90 89 pitonun 112 karakter!

Düzenleme 1: bu sefer bir işlev olarak!

Düzenleme 2: şimdi kısa kelimeleri ele alıyor

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: Sökülmüş ': Dize' (dönüş türü çıkarılabilir)
-7: Sökülmüş 'dönüş' (son ifade dönüş değeridir)
-3: faktörlü s.size-2çıkış
-4: toCharArray->toArray

Python, 86 karakter

Slnicig güvende, bu yüzden hiçbir kimse ckhnceig neeacrssy değil. Bütün kızlara 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 karakter

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

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

Yakut 1.9, 43 karakter

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

Henüz 1 karakter uzunluğu için çalışmaz Dizeler (bu karakteri çoğaltır) ve boş Dize için başarısız olur.

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

Kullanımı:

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"

Aşağıdaki işlev, uzunluğu 3'ten küçük sözcüklerle çalışır:

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]

İthalat yok! 1 karakter ve üzeri kelimeler için çalışır. Bu benim ilk golf girişim ve BlueEyedBeast'in en kısa koddan girişinden ilham aldım ve id (Object) kullanma fikri için deterministik olmayan bir çıktı elde ettim .

Açıklama: İlk ve son hariç tutulan girişten gelen harflerin bir listesini yapar ve tekrar tekrar bu listeden çıkar ve boş olana kadar yenisine eklenir. Açtığı dizin id (7)% len (haşhaş yaptığımız liste). İd (7) nesnenin 7 hafıza adresi olduğundan, esasen rastgeledir. Şimdi, orijinal girişin ortasından rastgele karıştırılmış harflerin bir listesi var. Şimdi tek yaptığımız, orijinal çıktının ilk ve son harflerini buna göre eklemek ve istediğimiz çıktıyı aldık: (ilk harf) + (orta şifreli) + (son harf).

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

A ve b'yi fonksiyon parametreleri olarak hesaplamak için R'nin tembel değerlendirmesini kullanır ve daha sonra yeniden kullanımla yer kazanmasını sağlar. Ayrıca diğer R cevaplarından farklı olarak, bu> 1 char uzunluğundaki tüm kelimeler için işe yarar. Aşağıdaki örnek:

> f("hippopotamus")
hpuoopaitmps

> f("dog")
dog

> f("az")
az

Düzenle: Değiştirilen unlist()ile[[]] [(1]] yerine el () kullanılır

D: 55 karakter

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

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

Ben hala Erlang'ı öğreniyorum, bu yüzden bu kısaltmanın ipuçlarını takdir ediyorum.

tam kod (string_shuffle modülü):

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

Düzenle

Karıştırma parçasını, artık listenin başının ve kuyruğunun etrafa geçirilmesini gerektirmeyen ayrı bir işlev olarak çıkardı.

Düzenle 2

fİşlev modellerinden birini kaldırmak için yeniden yapılandırıldı , yalnızca iki parametreyi kabul etmek üzere karışık işlevini değiştirdi, lists:deleteiçin değiştirildi --[], bir lists:reverseçağrıyı değiştirdi.lists:last