55

कुछ विवादास्पद कहानी के अनुसार , एक wod deos में ltteres के ओआरजीआर rannig के लिए बहुत अधिक mttaer नहीं होते हैं, जैसा कि frist और lsat lteter के रूप में lignog orignign wrod के साथ lnog है।

तो, मज़े के लिए, पहले और आखिरी अक्षर को सही जगह पर रखते हुए एक शब्द में पत्र क्रम को यादृच्छिक बनाने के लिए सबसे छोटा कार्य क्या होगा?

यहाँ जावास्क्रिप्ट के साथ मेरा छुरा है। सभी व्हाट्सएप ने इसे ~~124~~ 130 वर्णों पर हटा दिया ।

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

छोटा जावास्क्रिप्ट हमेशा स्वागत है।

संपादित करें: लंबाई की जाँच जोड़ी गई। छोटे शब्दों के लिए फ़ंक्शन विफल नहीं होना चाहिए।

code-golf string random

— Tomalak
स्रोत

3

हास्केल, 4 वर्ण r=id:।

— थॉमस एडिंग

2

हाँ। यह इनपुट के रूप में एक ही बात देता है। एक और नोट पर, हम विराम चिह्न के बारे में क्या करते हैं? क्या हम केवल अक्षरों से मिलकर बने शब्दों पर काम करते हैं?

— थॉमस ईडिंग

1

@trinithis यकीन नहीं है कि आप क्या बात कर रहे हैं, लेकिन idपहचान समारोह है। मैं अब भी 100 से भी कम पात्रों में इस समस्या का हलसेल देखना चाहूंगा।

— अर्ल

3

क्या परिणामों के एक समान वितरण की आवश्यकता के लिए विनिर्देश को अद्यतन किया जाना चाहिए? यह 4 वर्ण हास्केल समाधान को बाधित करेगा। यह आपके उदाहरण जावास्क्रिप्ट समाधान को भी समाप्त कर देगा (एक तरह से ऐसा करके फेरबदल करना जो एक समान नहीं है)।

— थॉमस एडिंग

2

पहले वाक्य के लिए +1: वास्तव में मुझे यह महसूस करने में कुछ सेकंड का समय लगा कि यह गलत XP है

— Nate Koppenhaver

21

हास्केल, 4 वर्ण

फ़ंक्शन ट्रिनिथिस वास्तव में विनिर्देश से मेल खाता है:

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

— Rotsor
स्रोत

18

"क्रमपरिवर्तन की संभाव्यता वितरण से असंतुष्ट" ने मुझे हँसाया। :)

— तोमलक

@Rotsor आप उस फ़ंक्शन को कैसे कहते हैं?

— Arlen

मैंने अपनी पोस्ट में एक उदाहरण जोड़ा है।

— Rotsor

fmap((a:t!!i:).tail)

— फूजएक्सएक्सएल

3

पहले समाधान को हटा दिया जाना चाहिए क्योंकि यह चुनौती के मानदंडों में फिट नहीं है। चुनौती का वर्णन "यादृच्छिक" करता है। मेटा के अनुसार, यादृच्छिक में हमेशा समान आउटपुट नहीं हो सकता है ।

— mbomb007 15

19

जे, २६ २४ २३ अक्षर

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

— एरिक
स्रोत

सामान्य कोड गोल्फ नियमों के अनुसार, आपको वाक्यांश को एक नाम से बांधने की आवश्यकता नहीं है।

— फ़ूजएक्सएक्सएल

#?#एक चार से कम है?~@#

— यादृच्छिक

15

रूबी, 44 अक्षर

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

छोटे शब्दों के लिए भी काम करता है, यानी एक, दो या तीन वर्णों वाले शब्द बिना लौटाए।

संपादित करें: वेंटरो के सरणी-स्पैट विचार का उपयोग करने से एक और चार्ट बचता है।

— हावर्ड
स्रोत

यह वास्तव में 44 अक्षर है। मैं अंत में अपने खुद के ट्यूनिंग द्वारा ठीक उसी उत्तर के साथ आया था - अब मुझे तुम्हारा पढ़ने के बाद कॉपी-कैट की तरह लग रहा है।

— अम्मी यर्थियाहो

@ user2316 बेशक आप सही हैं। धन्यवाद।

— हावर्ड

11

रूबी 1.9, 46 वर्ण

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

— Ventero
स्रोत

+1 सरणी-स्पैट के इस उपयोग ने मुझे एक चार बचाया। महान विचार।

— हावर्ड

मैं रूबी नहीं जानता - यह मेरे रूबी 1.8 पर विफल है, इसलिए मुझे लगता है कि मुझे कभी भी संस्करण की आवश्यकता नहीं है? क्या यह 'I' जैसे इनपुट के साथ काम करता है?

— उपयोगकर्ता अज्ञात

@user: यह "रूबी 1.9" कहते हैं। ;) - वेंटरो - समझदार आवश्यकताओं में से एक जिसे मैं उल्लेख करना भूल गया था कि यह शब्द की लंबाई 0 और 1. के लिए असफल नहीं होना चाहिए।

— तोमलक

11

Golfscript

"फ़ंक्शन" (कोडब्लॉक नाम दिया गया) के रूप में: 20 वर्ण

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

स्टैक पर सबसे ऊपरी तत्व पर काम करते समय: 16 अक्षर

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

— Ventero
स्रोत

यह बहुत अच्छा फेरबदल नहीं है, लेकिन शायद इस कार्य के लिए ठीक है। (यही है, यह "बहुत ही यादृच्छिक रूप से दिखेगा"।) फिर भी, दो और वर्णों की कीमत पर, आप के साथ प्रतिस्थापित करके बहुत बेहतर फेरबदल प्राप्त कर सकते हैं । 99.?

— इल्मरी करोनें

यह एकल-अक्षर शब्दों के लिए विफल रहता है, और मुझे यह भी नहीं लगता है कि फ़ंक्शन को स्ट्रिंग, स्ट्रिंग ऑफ़ स्ट्रिंग, स्ट्रिंग (एकल स्ट्रिंग के विपरीत) की अनुमति दी जानी चाहिए।

— मार्टिन एंडर

11

सी ++, 79 अक्षर ^{_{( रेंज जांच के साथ )}}

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

सी ++, 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;
}

मनोबल: जो पहले से है, उसका निर्माण न करें। ~~ओह, और ओवरफ्लो चेक वूस के लिए हैं।~~

— कोनराड रुडोल्फ
स्रोत

अच्छा, std::random_shuffleयह मेरे लिए एक नई बात है। btw मुझे लगता है कि आप #include<string>अपने पूर्ण कोड में भूल गए ।

— स्कॉट लोगन

1

कुछ ऐसा है जो मूल रूप से मेरे मन में था। दुर्भाग्य से जेएस में एक स्ट्रिंग इन-प्लेस को फेरबदल करने के लिए कोई अंतर्निहित नहीं है।

— टॉमालक

बहुत कम तारों के लिए विफल रहता है।

— यूजर अनजान

यह सच है, आपको एक लंबाई की जाँच याद आ रही है (मैंने किया, साथ ही)। BTW @ Arlen का जवाब भी देखने लायक है।

— तोमलक

1

@userunknown "मैं क्या मतलब है" अतिप्रवाह जाँच wusses के लिए कर रहे हैं। लेकिन निष्पक्ष होने के लिए, इसलिए लगभग सभी अन्य समाधान करें।

— कोनराड रुडोल्फ

8

पायथन, 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)

यह मेरा पहला कोड गोल्फ एक्सरे है। समस्या को हल करने के बाद मैंने उत्तरों को देखने का फैसला किया और यह कोई आश्चर्य की बात नहीं है कि मेरा उत्तर अद्वितीय नहीं है। हालांकि यह मजेदार था: ओ)

मैंने अन्य प्रतिक्रियाओं को देखने के बाद एक बदलाव किया और यह एक उपनाम का उपयोग करने के लिए अपने आयात विवरण को बदल रहा था। महान विचार। ; ओ)

— एशले ग्रेनन
स्रोत

और फिर भी, आपके समाधान के आगे मेरा मतदान हो जाता है! : पी

— बूथबीज

छोटे तारों पर विफल; मेरे अजगर का उत्तर 75 वर्णों का होगा यदि यह छोटे तारों ( from random import*\nf=lambda w:w[0]+''.join(sample(w[1:-1]),len(w)-2)+w[-1]) पर विफल हो गया ।

— डॉ। जिम्बोब

7

सी (के एंड आर) - 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;
}

संपादित करें : जब बग 3 से कम वर्णों का होता है, तो इसे ठीक कर दिया जाता है (उपयोगकर्ता-uknown के लिए धन्यवाद!)

— हैरी के।
स्रोत

1

ग्लिबक में, एक गैर-मानक पुस्तकालय फ़ंक्शन है (है?) strfry।

— मैकेनिकल घोंघा

अजीब अनुभव है, अगर मैं इसे साथ फ़ीडchar s[] = "na"; // not anticipated

— उपयोगकर्ता अज्ञात

@user uknown: मैंने अभी कोड संपादित किया है और इसे ठीक किया है, बग को सूचित करने के लिए धन्यवाद! (मैं सिर्फ जोड़ा> जबकि लूप की स्थिति में, "मुझे लागत" दो और, लेकिन जरूरत है, आकर्षण :))

— हैरी के।

1

@ मेकेनिकल घोंघा: मुझे लगता है कि अभी भी अस्पष्ट है।

— हैरी के।

7

अजगर, 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 वर्णों की आवश्यकता है)। अर्ग, पढ़ने की मेरी बुरी समझ।

EDIT 2: 6 चार्ट्स को बचाने के लिए डिफ़ से लैम्ब्डा फ़ंक्शन को डिफ से बदलें। मान लिया गया है कि नमूना पहले से ही नामस्थान ( from random import sample) में आयात किया जा सकता है ( ~ 60 तक नीचे ला सकता है)।

EDIT 3: "len (w [1: -1])" (12 chars) से "len (w) -2" (8 chars) प्रति gnibbler का अच्छा सुझाव।

EDIT 4: JBernando ने एक चार को बचाया (माना from random import *और देखा था कि यह समतुल्य है - अंतरिक्ष को साकार करना import *अनावश्यक नहीं है) ;; उपयोगकर्ता अज्ञात ने w if len(w)<4 else0 और 1 चार तार को सही ढंग से संभालने के लिए 19 वर्ण जोड़े ।

EDIT 5: प्रति बूथबी के कोड गोल्फ ट्रिक में एक और चार्ट सहेजा गया। if len(w)<4 elseको if 4>len(w)else।

— dr jimbob
स्रोत

हालांकि, प्रश्न केवल इनपुट को एक शब्द के रूप में परिभाषित करता है, शब्दों का एक स्ट्रिंग नहीं। :)

— बेन रिचर्ड्स

1

@ sidran32: धन्यवाद, मेरा बुरा। मैंने सिर्फ (फिर से सोचने पर) ध्यान दिया था और फिर आपकी टिप्पणी देखी; हटाए गए - संपादित - और बिना हटाए गए।

— ड्रिंक जिंबोब

विचार - ऐसा करने से आप 3 वर्णों को ट्रिम कर सकते हैं .... डी एफ (डब्ल्यू): जे = डब्ल्यू [1: -1]; वापसी w [0] + ''। (r.sample (j, len (j))) + w [-1]

— arrdem

@rmckenzie: अच्छा विचार है। हालाँकि, सही होने से पहले मैंने आपकी टिप्पणी को ठीक से देखा था जब मैंने इसे लैम्बडा फंक्शन (6 वर्णों की बचत) के लिए ट्रिम किया था, इसलिए मैं अब इंटरमीडिएट वार्स को परिभाषित करने की आपकी विधि नहीं कर सकता।

— डॉम्ब जिंबाब

3

len(w)-2के बजाय len(w[1:-1])?

— gnibbler

6

सी ++, 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;
}

संपादित करें

एहसास हुआ कि दोनों स्वैप इंडेक्स को यादृच्छिक करने की आवश्यकता नहीं है, एक चर और कुछ और पात्रों को बचाया।

— स्कॉट लोगन
स्रोत

अति उत्कृष्ट। अधिकांश समाधान बहुत छोटे इनपुट पर विफल होते हैं। तुम्हारा नहीं।

— यूजर अज्ञात

6

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

— tobius
स्रोत

+1 बहुत अच्छा। :) आप ट्रिम छोड़ सकते हैं (), वास्तव में, और रेगेक्स में आप एंकर को हटा सकते हैं और .इसके बजाय उपयोग कर सकते हैं \w।

— तोमलक

@Tomalak सुझाव मैं पर्ल में इस समाधान को फिर से लिखने की कोशिश करता हूं। उनके सुझावों को शामिल करते हुए, मुझे यह मिला: use List::Util 'shuffle';sub r{$_[0]=~m/(.)(.+)(.)/;$1.join('',shuffle split//,$2).$3;}यह 87 अक्षर हैं । उपयोग लाइन के बिना, यह 62 अक्षर है ।

— बेन रिचर्ड्स

क्या आप इस कार्य का डेमो प्रदान कर सकते हैं? क्योंकि मैं नहीं कर सकता ...

— स्टीव रॉबिन्स

6

पर्ल - 96 (या 71) वर्ण 84 (या 59) वर्ण

यह मैं पर्ल के साथ आया था। यह करने के लिए कुछ अलग तरीकों के माध्यम से चला गया, लेकिन यह मैं अब तक 97 पात्रों में से जो भी सोच सकता हूं, उससे सबसे छोटा लग रहा था।

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

हालाँकि, यदि आप 'यूज़' लाइन को काट देते हैं (जो मुझे लगता है कि वैध है, क्योंकि अन्य लोगों ने अपने सी प्रोग्राम्स में #include लाइनों को बाहर कर दिया है) मैं इसे 71 अक्षरों तक काट सकता हूं :

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

EDIT यह सुझाव दिया गया था कि मैं इसे लागू करने की कोशिश कर रहा हूं @tobius 'विधि। इस तरह मैंने इसे 84 वर्णों तक या उपयोग लाइन, 59 वर्णों को हटा दिया :

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

— बेन रिचर्ड्स
स्रोत

2

आपके संस्करण को 87 तक छोटा कर दिया:use List::Util 'shuffle';sub r{($b,@w)=split//,$_[0];$e=pop@w;join'',$b,(shuffle@w),$e}

— mbx

1

@ sidran32 क्या आप केवल तुलना के लिए पर्ल को @tobius के उत्तर का एक प्रकार लागू कर सकते हैं ?

— तोमलक

@Tomalak ज़रूर, मैं इसे आज़माऊँगा।

— बेन रिचर्ड्स

1

अपने regex संस्करण को 3 वर्णों से छोटा कर दिया:use List::Util 'shuffle';sub r{$_[0]=~m/(.)(.+)(.)/;$1.join'',shuffle split//,$2.$3}

— mbx

अच्छा लगा। मैं भी स्पष्टता के लिए कोष्ठक की मदद करने के लिए उपयोग कर रहा हूँ। बुरी आदत जब गोल्फ। : पी

— बेन रिचर्ड्स

5

रूबी, 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

मेरा स्कैला समाधान थोड़ी कम वाचाल भाषा में है। मैं किसी भी तरह से रूबी विशेषज्ञ नहीं हूं, इसलिए शायद सुधार की गुंजाइश है।

— गैरेथ
स्रोत

वाह। Solution मैं ’के साथ काम करता है, आपके स्कैला समाधान के रूप में।

— उपयोगकर्ता अज्ञात

5

रूबी 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}

— अलेक्सि य्रितिहो
स्रोत

कोई भी स्पेनिश 'आई' की उम्मीद नहीं करता है।

— यूजर अज्ञात

0 या 1 पत्रों के साथ मामलों को संभालने का प्रयास किया गया

— एलेक्सी यर्थियाहो

5

पायथन 3, 94 93 91 वर्ण

एक अलग तकनीक का उपयोग करना। अजगर 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 चरित्र को बचाने के लिए, अन्य पायथन जमा करने के बाद।

— यांत्रिक घोंघा
स्रोत

मुझे पता है कि मैं इतनी देर से यहाँ हूँ, लेकिन x[0:-1]बन सकता हूँ x[:-1]?

— ज़ाचरी

4

जावास्क्रिप्ट - 118 122 वर्ण

शॉर्टर जावास्क्रिप्ट - 118 अक्षर जिसमें कोई सफेद स्थान नहीं है। ओपी के रूप में लगभग एक ही एल्गोरिदम का उपयोग करता है, लेकिन कम अस्तर के साथ। मैंने बहुत पुनरावृत्ति की कोशिश की, और मैंने कुछ पुनरावृत्ति की कोशिश की, लेकिन वे सभी किसी न किसी तरह से टूट जाते हैं।

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

— रेयान किनल
स्रोत

Not आई-टेस्ट ’पास नहीं करता।

— उपयोगकर्ता अज्ञात

@ रियान return z?a+...+z:w;एक अंतर्निहित लंबाई की जांच के रूप में उपयोग करना क्रम में होगा। मौन धारणा यह थी कि फ़ंक्शन को केवल "मान्य" शब्द प्राप्त होंगे।

— तोमलाक

अच्छा बिंदु, सिवाय इसके कि डब्ल्यू संशोधित किया गया है, इसलिए मुझे टर्नरी aमें उपयोग करना होगा else। संपादित, और अप करने के लिए 122 chars।

— रायन काइल

@ रेयान: मेरा मानना है aकि दो-अक्षर वाले इनपुट के लिए गलत होगा। : - \ Damn अगली बार मैं आवश्यकताओं को और अधिक ध्यान से देखूंगा।

— तोमलक

मुझे नहीं लगता कि यह वास्तव में होगा। zयदि शब्द एक अक्षर (या कम) है तो केवल अपरिभाषित होगा।

— रयान काइल

4

डी, 62 चरस

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

ठीक है मैंने एक वास्तविक स्ट्रिंग के बजाय एक सामान्य चार सरणी के साथ धोखा दिया (जो अपरिवर्तनीय चार [] इसलिए कोई जगह में फेरबदल नहीं है)

लंबाई की जांच के साथ संपादित करें इसके लिए 14 और की आवश्यकता है

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

— शाफ़्ट सनकी
स्रोत

और यह 'आई' जैसे इनपुट के लिए क्या देता है?

— उपयोगकर्ता अज्ञात

परिणाम लौटाना उचित (= बेहतर तुलनीय) होगा।

— कोनराड रुडोल्फ

@us एक श्रेणी त्रुटि। @ कोनराड की आवश्यकता होगी return s;और चार [] वापसी प्रकार 11 और अधिक वर्ण

— शाफ़्ट सनकी

क्या आप पूरा कार्यक्रम पोस्ट कर सकते हैं? BTW, मुझे समझ नहीं आ रहा है कि आप क्यों गिन रहे हैं import std.random;, और केवल फ़ंक्शन नहीं।

— अरलेन

मैं अनुमान लगा रहा हूं कि आप अंतरिक्ष में char[] s(इसे बनाने के लिए char[]s) का उपयोग करके 1 बाइट बचा सकते हैं , लेकिन मैंने वर्षों में डी का उपयोग नहीं किया है।

— टिम Timस

4

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

— migimaru
स्रोत

अन्य PHP उत्तर के लिए +1 अच्छा विकल्प। छोटा नहीं है, लेकिन कोई रेगेक्स प्लस नहीं है।

— टॉमालक 17

एक छोटे समाधान के साथ अद्यतित होने की आवश्यकता नहीं है संस्करण 5.3

— मिगिमारू

पुराना संस्करण सही नहीं है: trueशॉर्ट स्ट्रिंग्स के लिए रिटर्न ।

— टाइटस

3

पर्ल - 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}

— MBX
स्रोत

3

अजगर

यह अजगर के 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]

— Andbdrew
स्रोत

इससे भी कम यदि आप कल्पना का पालन करते हैं और एक समारोह लिखते हैं :)

— gnibbler 23

आह, अफ़सोस की बात तार पर काम नहीं करता है

— gnibbler

1

रैंडम मॉड्यूल एक नाइट क्लब में मेरे जैसा है ... हम दोनों ही जगह में फेरबदल करते हैं! :)

— अंडब्रू

'I' जैसे इनपुट के लिए काम नहीं करता है; वापसी 'II'।

— उपयोगकर्ता अज्ञात

धन्यवाद! अब यह छोटे शब्दों को संभालता है, लेकिन थोड़ा लंबा होता है :)

— एंडब्रेड ड्रू

3

स्काला, 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

— गैरेथ
स्रोत

फैंसी पायथन पात्रों के बिना 'आई' और 'वेरवुफ़ेल' के साथ काम करता है। :) हालाँकि, 'शफल' का उपयोग करने वाला मेरा समाधान थोड़ा छोटा है।

— उपयोगकर्ता अज्ञात

@user अज्ञात संपादन के लिए धन्यवाद :-)

— गैरेथ

3

पायथन, 86 वर्ण

Slnicig सुरक्षित है, इसलिए कोई भी bnouds ckhnceig neeacrssy नहीं है। सभी लेग्कन पर Wkros।

from random import*
def f(x):x=list(x);t=x[1:-1];shuffle(t);x[1:-1]=t;return''.join(x)

— boothby
स्रोत

3

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

— Arlen
स्रोत

क्या इनपुट स्ट्रिंग में हार्ड कोडिंग कानूनी है?

— थॉमस एडिंग

@trinithis मुझे लगा कि हम केवल फ़ंक्शन के साथ ही चिंतित हैं। प्रोग्राम केवल दिखाता है कि फ़ंक्शन का उपयोग कैसे करें। भले ही, हार्ड कोडिंग नहीं इनपुट इस मामले में कोई फर्क नहीं पड़ता; बस जोड़ेंstring s; cin >> s;

— Arlen

3

रूबी 1.9, 43 वर्ण

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

अभी तक 1 वर्ण लंबाई स्ट्रिंग्स के लिए काम नहीं करता है (उस चरित्र को डुप्लिकेट करता है), और खाली स्ट्रिंग के लिए विफल रहता है।

— karatedog
स्रोत

3

पायथन - 76 वर्ण

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

— डोनाल्ड विल्सन
स्रोत

जॉर्ज के उपयोगकर्ता नाम को 85 अक्षरों पर रखा गया है।

— dmckee

3

आर, 104 (126)

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"

— पाओलो
स्रोत

कार्य का हिस्सा पहले और आखिरी अक्षरों को स्थानांतरित करना नहीं था।

— टॉमालक

@ तोमलक तय!

— पाओलो

क्या यह 3 की लंबाई के नीचे के शब्दों के साथ काम करता है?

— तोमलक

@ टोमलाक अब यह ठीक होना चाहिए! सुधार के लिए धन्यवाद!

— पाओलो

3

अजगर, 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 चरित्र और ऊपर। यह मेरी पहली गोल्फ प्रविष्टि है और मैं आईडी (ऑब्जेक्ट) का उपयोग करने के विचार के लिए गैर-निर्धारक उत्पादन का उत्पादन करने के लिए ब्लूस्टेडबीस्ट की सबसे छोटी कोड से प्रविष्टि से प्रेरित था ।

स्पष्टीकरण: यह पहले और आखिरी को छोड़कर इनपुट से पत्रों की एक सूची बनाता है, और बार-बार इस सूची से पॉप होता है और खाली होने तक एक नए के लिए अपील करता है। यह जिस इंडेक्स से पॉप होता है, वह आईडी (7)% लेन है (जिस सूची से हम पॉपिंग कर रहे हैं)। चूँकि id (7) ऑब्जेक्ट 7 का मेमोरी एड्रेस है, यह अनिवार्य रूप से यादृच्छिक है। तो अब हमारे पास मूल इनपुट के केंद्र से यादृच्छिक रूप से तले हुए पत्रों की एक सूची है। अब हम करते हैं कि मूल आउटपुट के पहले और आखिरी अक्षरों को उसी के अनुसार जोड़ दिया जाता है और हमें जो आउटपुट चाहिए वह मिलता है: (पहला अक्षर) + (तले हुए मध्य) + (अंतिम अक्षर)।

— जिराफ़
स्रोत

3

आर, 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 उत्तर के विपरीत यह सभी शब्दों के लिए काम करता है> 1 char लंबा। नीचे उदाहरण:

> f("hippopotamus")
hpuoopaitmps

> f("dog")
dog

> f("az")
az

संपादित करें: ~~के unlist()साथ बदला गया[[]]~~ बदला हुआ [[1]] एल के साथ ()

— एंड्रयू हेन्स
स्रोत

2

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

— Arlen
स्रोत

मुझे लगता है कि वह else sहिस्सा गायब है?

— तोमलक

1

@ टोमलाक नहीं, यह नहीं है, क्योंकि इसकी कोई आवश्यकता नहीं है। यदि स्ट्रिंग लंबाई 2 या उससे कम है, तो हम इसे अकेले छोड़ देते हैं। इसके अलावा, randomShuffle()जगह में है।

— Arlen

वाह, डी प्रतिस्पर्धी हो रहा है। मुझे लगता है कि IIRC randomShuffle(s[1..$-1])हो सकता है s[1..$-1].randomShuffle(जब तक कि इस पोस्ट से पुराने डी संस्करण में नहीं है)

— जकार्इ

2

एर्लैंग, 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).

मैं अभी भी एर्लैंग सीख रहा हूं इसलिए इसे छोटा बनाने के किसी भी सुझाव की सराहना की जाती है।

पूर्ण कोड (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:reverseएक के लिए कॉलlists:last

— स्कॉट लोगन
स्रोत

एक शब्द में अक्षरों को यादृच्छिक कैसे करें

हास्केल, 4 वर्ण

हास्केल, 110 120 107 अक्षर

जे, २६ २४ २३ अक्षर

रूबी, 44 अक्षर

रूबी 1.9, 46 वर्ण

Golfscript

सी ++, 79 अक्षर ( रेंज जांच के साथ )

सी ++, 8165 अक्षर ( बिना रेंज चेक के )

सी (के एंड आर) - 88 86 87 चार्ट

अजगर, 87 79 75 93 92 वर्ण (लंबाई 0,1 के तारों को संभालते हुए)

सी ++, 111 97 चार्ट

संपादित करें

php (68 अक्षर)

छोटा (60 अक्षर)

पर्ल - 96 (या 71) वर्ण 84 (या 59) वर्ण

रूबी, 77 75 वर्ण

पायथन 3, 94 93 91 वर्ण

जावास्क्रिप्ट - 118 122 वर्ण

डी, 62 चरस

php 5.3 (60 वर्ण)

अजगर

संपादित 1: इस बार एक समारोह के रूप में!

संपादन 2: अब छोटे शब्दों को संभालता है

स्काला, 135 139 142 156 वर्ण

C ++ 11: - 68 66 वर्ण

रूबी 1.9, 43 वर्ण

पायथन - 76 वर्ण

आर, 104 (126)

अजगर, 102 वर्ण

आर, 95 92 91 वर्ण

D: 55 वर्ण

एर्लैंग, 188 172 132 चार

संपादित करें

संपादित करें 2

सी ++, 79 अक्षर ^{_{( रेंज जांच के साथ )}}

सी ++, 8165 अक्षर ^{_{( बिना रेंज चेक के )}}