29

क्या सुडोकू को हल करना बहुत मुश्किल है? यहां तक कि जानवर बल संस्करण? यहाँ एक कोडिंग व्यायाम है जो थोड़ा आसान है। मुझे उम्मीद है। :-P

बोगोसॉर्ट को लागू करने के लिए सबसे छोटा फ़ंक्शन लिखें। विशिष्ट में, आपका कार्य होना चाहिए:

इनपुट के रूप में एक सरणी (या आपकी भाषा के समकक्ष) लें
जांचें कि क्या इसके तत्व क्रमबद्ध क्रम में हैं; यदि ऐसा है, तो सरणी वापस करें
यदि नहीं, तो तत्वों को फेरबदल करें, और फिर से शुरू करें

सबसे छोटी प्रविष्टि जीतती है। एक टाई के मामले में, एक फ़ंक्शन जो एक कस्टम तुलनित्र (और / या छद्म आयामी संख्या जनरेटर) का समर्थन करता है। किसी भी शेष संबंधों को पहले प्रस्तुत करने के पक्ष में हल किया जाता है।

स्पष्टता: आप किसी भी प्रकार के इच्छित तत्व का उपयोग कर सकते हैं, जब तक कि उन्हें ऑर्डर करने का कोई तरीका है, निश्चित रूप से। इसके अलावा, फेरबदल को एक समान होना चाहिए; इस में से कोई भी "मैं बस इसे तेज करूँगा और इसे फेरबदल कहूंगा" व्यापार। :-)

code-golf sorting

— क्रिस जस्टर-यंग
स्रोत

तत्व प्रकार क्या हैं? int या तार?

— अलेक्जेंड्रू

@ अलेक्सांद्रु: या तो ठीक है। आप चुनते हैं।

— क्रिस जस्टर-यंग

कस्टम तुलनित्र जोड़ने से कोड की लंबाई बढ़ जाएगी, इसलिए एक विजेता प्रविष्टि के पास एक कस्टम तुलनित्र नहीं होगा। मुझे लगता है कि टाई को तोड़ने का कोई मतलब नहीं है।

— अलेक्जेंड्रू

1

यह संभव है कि छद्म यादृच्छिक जनरेटर का उपयोग करते समय यह एल्गोरिथ्म विफल हो सकता है। उदाहरण के लिए जब सूची की लंबाई 2000 से अधिक है, तो 2000 हैं! सूची के लिए राज्य जो कि प्रिंग के इंटरल स्टेट्स की संख्या से अधिक हो सकते हैं।

— gnibbler

2

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

— gnibbler

8

APL (Dyalog), 20

{⍵≡⍵[⍋⍵]:⍵⋄∇⍵[?⍨⍴⍵]}

व्याख्या

⍵सही है (सही) तर्क
⍵≡⍵[⍋⍵]: यदि ⍵सॉर्ट किए गए चेक ⍵खुद बराबरी करते हैं
:⍵: यदि हां, तो वापस लौटें ⍵
∇⍵[?⍨⍴⍵]: एल्स, यादृच्छिक क्रम में 1 से ⍴⍵(लंबाई की ⍵) की एक सरणी उत्पन्न करते हैं, उसके ⍵अनुसार पुन: क्रमबद्ध करें ( ⍵[...]), और उस पर फ़ंक्शन लागू करें ( ∇)

अचानक इस समस्या पर फिर से विचार ...

एपीएल (डायलॉग), 19

{∧/2≤/⍵:⍵⋄∇⍵[?⍨⍴⍵]}

क्या केवल एक सरणी को चेक में छांटने के बारे में सोच रहा था, यह इस तरह की व्यर्थता है (यह नहीं कह रहा है कि बोगोसॉर्ट सार्थक है), एक अधिक सटीक कार्यान्वयन होगा ∧/2≤/⍵, और यह चार गिनती कम करने के लिए होता है।

— TwiNight
स्रोत

15

पर्ल 6: 23 चार्ट

@s.=pick(*)until[<=] @s

— मिंग-तांग
स्रोत

1

यह पर्ल में एक समारोह है? यह बहुत अच्छा लग रहा है :)

— आठवीं

1

यदि आप नहीं जानते हैं, [<=]तो जाँच करें कि क्या कोई सूची क्रमबद्ध है: [<=] (1, 2, 3,) == (1 <= 2 <= 3) == (1 <= 2) and (2 <= 3)और .pick(n)सूची से n यादृच्छिक तत्वों को चुनता है, और .pick(*)पर्ल को सभी तत्वों को चुनने देता है। use.perl.org/~masak/journal/40459

— मिंग-तांग

यह पर्ल होना चाहिए 6. मैंने पहले कभी pickइस्तेमाल नहीं किया है, अकेले चलो [<=]। प्रलेखन में वे कहाँ हैं?

— श्री लामा

@ गीगावाट यह पर्ल 6 है (पर्ल 5 नहीं)। []ऑपरेटर को कम करता है जो वर्ग कोष्ठक के बीच ऑपरेटर लेता है। उदाहरण के लिए, [<=] 1, 2, 3है 1 <= 2 <= 3(और हाँ, आप पर्ल 6 में इस तरह पर्वतमाला करते हैं)। इस मामले में, यह निर्धारित करने के लिए उपयोग किया जाता है कि क्या तत्व क्रम में हैं। .pick(*)विधि सूची में फेरबदल करती है ( सूची से तत्वों को pick(N)चुनती है N)। .=कॉल विधि, और चर को परिणाम असाइन करता है। प्रलेखन के लिए - ठीक है, अभी के लिए केवल पर्ल 6 विनिर्देश मौजूद हैं - feather.perl6.nl/syn , लेकिन यह मौजूद है।

— कोनराड बोरोस्की

7

एपीएल (22)

{(⍳X←⍴⍵)≡⍋⍵:⍵⋄∇⍵[X?X]}

उपयोग:

    {(⍳X←⍴⍵)≡⍋⍵:⍵⋄∇⍵[X?X]} 3 2 1
1 2 3

स्पष्टीकरण:

⍋⍵: वस्तुओं के अनुक्रमित को क्रमबद्ध क्रम में ⍋30 10 20देता है , इसलिए देता है2 1 3
(⍳X←⍴⍵)≡⍋⍵:⍵एक्स में इनपुट सूची की लंबाई को स्टोर करें। यदि रेंज [1..X]सॉर्ट किए गए इंडेक्स ऑर्डर के बराबर है, तो सूची को क्रमबद्ध किया गया है, इसलिए इसे वापस लौटाएं।
⋄∇⍵[X?X]: यदि यह मामला नहीं है, तो फेरबदल सरणी के साथ पुनरावृत्ति।

— मारीनस
स्रोत

7

रूबी - 33 अक्षर

g=->l{l.shuffle!!=l.sort ?redo:l}

— Nemo157
स्रोत

1 g=proc{|l|0until l.sort==l.shuffle!}

— चेर

@ वैसे, आपका संस्करण काम नहीं करता है। मेरा संस्करण (5 f=->l{l.sort!=l.shuffle!?redo:l}

— चार्ट

क्या कोई मुझे समझा सकता है कि मैं शास्त्रीय पद्धति से क्यों नहीं redoकाम करता हूं ? मैंने सोचा कि केवल छोरों के साथ काम करता है? procdef...endredo

— पैट्रिक ऑस्सिटी

1

ठीक है, कोई बात नहीं, मुझे 'द रूबी प्रोग्रामिंग लैंग्वेज' पुस्तक में कुछ मिला: " redo[...] स्थानान्तरण नियंत्रण की शुरुआत में खरीद या लैम्ब्डा के लिए"। यह बस ऐसा ही है।

— पैट्रिक ऑस्सिटी

6

गणितज्ञ , ४० ३ 40

NestWhile[RandomSample,#,Sort@#!=#&]&

व्हॉट्सएप के साथ:

NestWhile[RandomSample, #, Sort@# != # &] &

— Mr.Wizard
स्रोत

आप त्रुटियों को अनदेखा हैं, तो आप के साथ तीन बाइट्स बचा सकता है#//.l_/;Sort@l!=l:>RandomSample@l&

— मार्टिन Ender

Mthmca में 13 बाइट्स।

— माइकल स्टर्न

5

जम्मू - 34 27

f=:({~?~@#)^:(1-(-:/:~))^:_

उदाहरण के लिए:

f 5 4 1 3 2
1 2 3 4 5

f 'hello'
ehllo

? {~ ~ @ # हिस्सा इनपुट shuffles:

({~ ?~@#) 1 9 8 4
4 8 9 1
({~ ?~@#) 'abcd'
bdca

— Eelvex
स्रोत

3

अजगर 61

जगह-जगह हो रहे हैं।

import random
def f(l):
 while l!=sorted(l):random.shuffle(l)

— एलेक्ज़ेंड्रु
स्रोत

आपका फ़ंक्शन सफलता पर सरणी वापस नहीं करता है।

— हॉल्वैबो

जगह-जगह हो रहे हैं। पारित सरणी को संशोधित किया गया है।

— अलेक्जेंड्रू

सवाल यह कहता है कि फ़ंक्शन को सरणी वापस करना है - भले ही परिणाम प्राप्त करने के लिए तकनीकी रूप से आवश्यक नहीं है।

— जोनाथन एम डेविस

1

from random import*एक चार बचा सकता है।

— बदसूरत

1

यह हमेशा काम नहीं कर सकता है: (अजगर यादृच्छिक मॉड्यूल प्रलेखन से): "ध्यान दें कि यहां तक कि छोटे लेन (एक्स) के लिए, एक्स के क्रमपरिवर्तन की संख्या सबसे यादृच्छिक संख्या जनरेटर की अवधि से बड़ी है; इसका तात्पर्य यह है कि सभी क्रमबद्धताएं; एक लंबा अनुक्रम कभी उत्पन्न नहीं किया जा सकता है। "

— मैट

3

पायथन 94

from itertools import*
def f(a):return [x for x in permutations(a) if x==tuple(sorted(a))][0]

अन्य अजगर जवाब यादृच्छिक का उपयोग करते हैं। शफल ()। अजगर यादृच्छिक मॉड्यूल राज्यों के प्रलेखन:

ध्यान दें कि यहां तक कि छोटे लेन (एक्स) के लिए, एक्स के क्रमपरिवर्तन की कुल संख्या सबसे यादृच्छिक संख्या जनरेटर की अवधि से बड़ी है; इसका तात्पर्य है कि एक लंबे अनुक्रम के अधिकांश क्रमपरिवर्तन कभी उत्पन्न नहीं हो सकते।

— मैट
स्रोत

इसके बजाय एक मेमना करो; मुझे लगता है कि यह कम होगा। यह भी ध्यान दें कि आप return[x...विरोध के रूप में कर सकते हैं return [x...। साथ ही permutations(a) if- यह हो सकता है permutations(a)if।

— 0WJYxW9FMN

lambda a: [x for x in __import__("itertools").permutations(a) if x==tuple(sorted(a))][0]है 88 बाइट्स

— 18:16

3

के, ३१ २५

~~{while[~x~x@<x;x:x@(-#x)?#x];x}~~

{x@(-#x)?#x}/[{~x~x@<x};]

।

k){x@(-#x)?#x}/[{~x~x@<x};] 3 9 5 6 7 9 1
`s#1 3 5 6 7 9 9

।

k){x@(-#x)?#x}/[{~x~x@<x};] "ascsasd"
`s#"aacdsss"

— tmartin
स्रोत

2

अजगर (69 वर्ण)

from random import*
def f(a):
 while a>sorted(a):shuffle(a)
 return a

संख्यात्मक क्रम को बढ़ाने में पूर्णांक बनाता है। ध्यान दें कि पुनरावर्ती समाधान, जैसे

from random import*;f=lambda a:a>sorted(a)and(shuffle(a)or f(a))or a

यहां तक कि छोटे इनपुट्स के लिए स्टैक ओवरफ्लो के कारण विफल हो जाएगा (एन> 5), क्योंकि पायथन टेल-कॉल ऑप्टिमाइज़ेशन नहीं करता है।

— hallvabo
स्रोत

2

डी बिना कस्टम तुलनित्र: 59 वर्ण

R f(R)(R r){while(!isSorted(r))r.randomShuffle();return r;}

अधिक कानूनी रूप से:

R f(R)(R r)
{
    while(!r.isSorted)
        r.randomShuffle();

    return r;
}

डी कस्टम तुलनित्र के साथ: 69 वर्ण

R f(alias p,R)(R r){while(!isSorted!p(r))r.randomShuffle();return r;}

अधिक कानूनी रूप से:

R f(alias p, R)(R r)
{
    while(!isSorted!p(r))
        r.randomShuffle();

    return r;
}

— जोनाथन एम डेविस
स्रोत

2

स्केल 73:

def s(l:Seq[Int]):Seq[Int]=if(l==l.sorted)l else s(util.Random.shuffle l)

स्काला में, हम जांच सकते हैं कि कंपाइलर ने टेल-कॉल ऑप्टिमाइज़ेशन किया था या नहीं:

@annotation.tailrec
def s(l:Seq[Int]):Seq[Int]=if(l==l.sorted)l else s(util.Random shuffle l)

और हाँ, यह किया है। हालाँकि, 100 मानों की एक छोटी सूची के लिए:

val rList = (1 to 100).map(x=>r.nextInt (500))
s(rList)

पूरा होने में लगभग 4 महीने लग गए। ;)

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

2

C # (184 वर्ण)

T[]S<T>(T[]i)where T:IComparable<T>{T l=default(T);while(!i.All(e=>{var r=e.CompareTo(l)>=0;l=e;return r;})){i=i.OrderBy(a=>Guid.NewGuid()).ToArray();l=default(T);}return i.ToArray();}

C # में ऐसा करना वास्तव में अच्छा नहीं है। आपको मूल्य और संदर्भ प्रकार दोनों का समर्थन करने के लिए जेनरिक का समर्थन करना होगा। यदि कोई चीज़ छांटी जाती है, तो जाँचने के लिए कोई भी फेरबदल फ़ंक्शन या फ़ंक्शन नहीं है।

क्या किसी को भी इसे बेहतर बनाने के लिए कोई सुझाव मिला है?

संस्करण संपादित करें जो केवल int (134 वर्ण) को क्रमबद्ध करता है:

int[]S(int[]i){var l=0;while(!i.All(e=>{var r=e>=l;l=e;return r;})){i=i.OrderBy(a=>Guid.NewGuid()).ToArray();l=0;}return i.ToArray();}

— JJoos
स्रोत

2

GNU / BASH 65

b(){ IFS=$'\n';echo "$*"|sort -C&&echo "$*"||b $(shuf -e "$@");}

— Kojiro
स्रोत

हम्म, क्या मैं एश नियम को रिटर्न के लिए एक विशेष अपवाद प्राप्त कर सकता हूं क्योंकि बैश फ़ंक्शन केवल शाब्दिक बाइट वापस कर सकता है?

— कोजिरो

2

सी ++ 11, 150 वर्ण

#include<deque>
#include<algorithm>
void B(std::deque &A){while(!std::is_sorted(A.begin(),A.end())std::random_shuffle(myvector.begin(),myvector.end());}

बस .. मनोरंजन के लिए बनाया गया।

1

std :: random_shuffle एक समान नहीं है। स्पष्टीकरण में यह कहा गया है: "इसके अलावा, फेरबदल को एक समान होना है"

— STDQ

ठीक है ... मुझे नहीं पता था कि यह एक समान नहीं था।

यह रैंड () पर निर्भर करता है जो एक समान नहीं है - open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3924.pdf देखें । ऐसा नहीं है कि कई अन्य लोगों को लगता है कि मुझे लगता है कि यह एक बड़ी बात नहीं है।

— STDQ

इसलिए अगर मैं एक पूरी तरह से यादृच्छिक का उपयोग करता हूं जैसे कि सर्ंड (समय (0)) का उपयोग करना है तो क्या यह गणना करता है?

समस्या यह है कि रैंड की गारंटी नहीं है कि रैंडम नंबर की अच्छी गुणवत्ता हो, अकेले एकरूपता दें, कुछ गैर-यादृच्छिक कम-ऑर्डर बिट्स का उत्पादन करते हैं। मुझे लगता है कि यह न तो अंत में मायने रखता है और न ही होना चाहिए। मुझे केवल 8 अधिक बाइट्स मिलीं, जिसमें std :: shuffle और इसके साथ एक समान वितरक का उपयोग किया गया, जो मेरे लिए काफी अच्छा है।

— STDQ

2

पायथन - 61 वर्ण

पुनरावर्ती

from random import*;f=lambda l:l==sorted(l)or shuffle(l)>f(l)

— gnibbler
स्रोत

आपका फ़ंक्शन सही या गलत लौटाता है, सरणी नहीं।

— हॉल्वैबो

2

यह भी ध्यान दें कि पुनरावर्ती समाधान छोटे इनपुट के लिए भी विफलता के लिए बर्बाद हैं।

— हॉलवाबो 14

1

@ हलावाबो: मैं वास्तव में स्कीम में एक पूंछ-पुनरावर्ती समाधान लिखना चाहता हूं, जो आपके स्टैक को निश्चित रूप से ख़राब नहीं करेगा।

— क्रिस जस्टर-यंग

@hallvabo, अलेक्जेंड्रू ने पहले ही स्पष्ट पायथन समाधान किया था, इसलिए मैं यहां कुछ अलग करने जा रहा था। बेशक पुनरावर्ती समाधान केवल मनोरंजन के लिए है न कि एक गंभीर दावेदार के लिए

— gnibbler

from random import*कम हो सकता है।

— 0WJYxW9FMN

2

पॉवरशेल , 85 82 56 55 52 बाइट्स

^{-26 बाइट्स mazzy के सुझावों}
^{के लिए धन्यवाद -1 बाइट धन्यवाद mmzy के लिए AdmBorkBork}
^{-3 बाइट्स के लिए धन्यवाद}

for($l=$args;"$l"-ne($l|sort)){$l=$l|sort{random}}$l

इसे ऑनलाइन आज़माएं!

पावरशेल में स्ट्रिंग्स को तुलना करके और तुलना करते हुए अपेक्षाकृत सस्ती सरणी होती है।

— Veskah
स्रोत

2

एक बाइट को बचाने के लिए paramअपने forइनिशियलाइज़ेशन को मूव करेंfor($l=$args;

— AdmBorkBork

1

अच्छा। -neदाएं ऑपरेटर को बाएं ऑपरेटर के एक स्केलर प्रकार में डाल देता है। इसलिए, आप कुछ बाइट्स बचा सकते हैं: इसे ऑनलाइन आज़माएं!

— माज़ी

1

जावास्क्रिप्ट 291 अक्षर

मिनट

function f(e){var t=[].concat(e).sort();t.e=function(e){var n=true;t.forEach(function(t,r){if(t!=e[r])n=false});return n};while(!t.e(e.sort(function(){return Math.floor(Math.random()*2)?1:-1}))){console.log(e)}return e}

अन-मिनट

function f(a) {
var b = [].concat(a).sort();
b.e = function (z) {
    var l = true;
    b.forEach(function (v, i) {
        if (v != z[i]) l = false;
    });
    return l
};
while (!b.e(a.sort(function () {
    return Math.floor(Math.random() * 2) ? 1 : -1;
}))) {
    console.log(a);
}
return a;
}

— प्रोफेसर ऑलमैन
स्रोत

मुझे लग रहा है कि मैंने यह पहले कहा है, लेकिन आप सभी को हटा सकते हैं var। बस उन्हें सभी निहित ग्लोबल्स बनाएं, यह कोड को यथासंभव छोटा बनाने के बारे में है।

— gcampbell

1

मतलाब, 59 बाइट्स

अपेक्षाकृत सीधे आगे का दृष्टिकोण:

x=input('');while~issorted(x);x=x(randperm(numel(x)));end;x

— flawr
स्रोत

1

जे, 22 बाइट्स

$:@({~?~@#)`]@.(-:/:~)

यह एक एजेंडा का उपयोग करते हुए एक पुनरावर्ती, मौन मोनाड है। यहां देखिए यह कैसे काम करता है:

चलो yहमारी सूची हो। सबसे पहले, एजेंडा के अधिकार पर क्रिया है -:/:~। यह एक क्रिया है जो लीक नन द्वारा प्रदान की गई है । यह मेल करता है ( -:) इनपुट या सॉर्ट किया गया है या नहीं ( /:~) एक मोनडिक हुक का उपयोग करके। ( (f g) y = y f (g y)) यह तदनुसार एक या एक शून्य देता है। एजेंडे का बायां हाथ दो क्रियाओं का एक प्रकार है: दाईं ओर पहचान क्रिया है ], और बाईं ओर जहां पुनरावृत्ति होती है। एजेंडा चयन या तो स्थिति में क्रिया पहचान 1करता है, तो सूची है क्रमित और क्रिया अब स्थिति में 0यदि सूची नहीं है छाँटे गए।

$:@({~?~@#)कॉल $:का परिणाम के ऊपर (सबसे लंबे समय तक क्रिया यह में निहित है) {~?~@#पर y। यह सूची में फेरबदल करता है, जैसा ?~@#कि yयादृच्छिक रूप से छांटे गए सूचकांकों की लंबाई की क्रमपरिवर्तन लेता है y। {~एक मौद्रिक हुक में, एक सूची लौटाता है yजिसके सूचकांक सही arg हैं। इस फेरबदल सूची को फिर से एजेंडे के साथ बुलाया जाता है, और तब तक दोहराता है जब तक कि इसे हल नहीं किया जाता है।

— कोनोर ओ ब्रायन
स्रोत

1

सी ++ 14, 158 बाइट्स

#include <algorithm>
#include <random>
[](int*a,int s){std::random_device r;for(std::knuth_b g(r());!std::is_sorted(a,a+s);std::shuffle(a,a+s,g));return a;};

— STDQ
स्रोत

1

जेली , 6 बाइट्स, भाषा चुनौती देती है

ẊŒ¿’$¿

इसे ऑनलाइन आज़माएं!

व्याख्या

ẊŒ¿’$¿
     ¿  While
 Œ¿’$     the input is not in its earliest possible permutation (i.e. sorted)
Ẋ       shuffle it

Œ¿एक सूची के प्रत्येक क्रमपरिवर्तन के लिए एक नंबर प्रदान करता है; 1 को क्रमबद्ध किया गया है, 2 में अंतिम दो तत्वों का आदान-प्रदान किया गया है, आदि, सूची की लंबाई के तथ्य तक (जो कि रिवर्स ऑर्डर में सूची है)। तो एक क्रमबद्ध सूची के लिए, इसका मूल्य 1 है, और हम इसे ’"क्रमबद्ध" परीक्षण का उत्पादन करने के लिए उपयोग कर इसे घटा सकते हैं जो कि लूप की स्थिति में बूलियन के रूप में प्रयोग करने योग्य है। $एक समूह के रूप पार्स करने के लिए शर्त कारण है।

1

सी ++, 166 बाइट्स

भावहीन।

#import<algorithm>
#import<random>
#define r b.begin(),b.end()
template<class v>
v f(v b){auto a=std::mt19937();while(!std::is_sorted(r))std::shuffle(r,a);return b;}

यह उन सभी एसटीएल कंटेनरों पर काम करना चाहिए जिनके पास है begin()और end()।

Ungolfed:

#include <algorithm>
#include <random>
template <class v>
v f(v b) {
    auto a = std::mt19937();
    while (!std::is_sorted(b.begin(),b.end()))
        std::shuffle(b.begin(),b.end(),a);

    return b;
}

— qookie
स्रोत

1

एपीएल (डायलाग एक्सटेंडेड) , 15 बाइट्स

(?⍨∘≢⊇⊢)⍣{⍺≡∧⍺}

इसे ऑनलाइन आज़माएं!

— voidhawk
स्रोत

14 बाइट्स?⍨∘≢⍛⊇⍨⍣{⍺≡∧⍺}

— एडम

1

ब्रेकीलॉग , 5 बाइट्स

∈&ṣ≤₁

इसे ऑनलाइन आज़माएं!

जब मैंने पहली बार ais523 का ब्रेकीलॉग उत्तर देखा (जैसा कि उनके जेली उत्तर के विपरीत था, क्योंकि अगर मैं गलत नहीं हूँ user62131 भी वह था), तो मैंने सोचा, क्या होगा यदि यह पुनरावृत्ति के बजाय बैकट्रैकिंग का उपयोग करता है? इसलिए सबसे पहले, मैंने कोशिश की ṣ≤₁। बाहर निकलता है, क्योंकि यादृच्छिक पर कुछ चुनने से कई आउटपुट उत्पन्न नहीं होते हैं, क्योंकि यह सिर्फ एक आउटपुट का उत्पादन करता है nondeterministically, फेरबदल विधेयकों ṣको पीछे नहीं छोड़ा जा सकता है, इसलिए चल रहा है कि बस विफल हो जाएगा जब तक कि आप इसे सही करने के लिए पर्याप्त भाग्यशाली न हों पहली कोशिश पर। उसके बाद, मैंने कोशिश की pṣ≤₁, जिसने अधिकांश समय काम किया, लेकिन चूंकि एक लंबी सूची में बहुत अधिक क्रमपरिवर्तन हैं, यह अभी भी यादृच्छिक रूप से कभी-कभी विफल रहा। लंबाई में कमी हासिल करने के लक्ष्य को छोड़ने के बाद, मैं आखिरकार इसके साथ आया:

         The input
∈        is an element of
         an unused implicit variable,
 &       and the input
  ṣ      shuffled randomly
   ≤₁    which is increasing
         is the output.

(यादृच्छिकता का प्रदर्शन)

हालांकि यह वास्तव में थोड़ा कम हो सकता है अगर हम I / O के साथ कुछ स्वतंत्रताएं लेते हैं ...

ब्रेकीलॉग , 4 बाइट्स

⊆ṣ≤₁

इसे ऑनलाइन आज़माएं!

आउटपुट उपयोगी होने के लिए, इनपुट में कोई डुप्लिकेट तत्व नहीं होना चाहिए, क्योंकि इनपुट को सॉर्ट करने के अलावा, यह बोगोसॉर्ट डुप्लिकेट तत्वों और जीरो की एक यादृच्छिक संख्या में जोड़ता है। (हाइपोथेटिक रूप से, यह किसी भी चीज़ में जोड़ सकता है, लेकिन यह केवल एक तरह का नहीं है।) आमतौर पर मैं सही ढंग से काम करने से अभी तक कुछ का उल्लेख नहीं करता, लेकिन मुझे लगता है कि यह चुनौती की भावना में है।

⊆        An ordered superset of the input
 ṣ       shuffled randomly
  ≤₁     which is increasing
         is the output.

— असंबंधित स्ट्रिंग
स्रोत

1

पर्ल 6 , 28 बाइट्स

{({.pick(*)}...~.sort).tail}

इसे ऑनलाइन आज़माएं!

बेनामी कोड ब्लॉक जो सूची को तब तक फेरबदल करता है जब तक कि वह हल न हो जाए। ध्यान दें कि यह सूची को कम से कम एक बार क्रमबद्ध करता है, जिसकी अनुमति है। और नहीं, के {.pick(*)}साथ प्रतिस्थापित नहीं किया जा सकता है*.pick(*)

— मजाक कर रहा है
स्रोत

1

अजगर , 11 बाइट्स

Wn=Q.SQSQ;Q

इससे बहुत खुश, शायद थोड़ा और गोल्फ हो सकता है

व्याख्या


Wn=Q.SQSQ;Q
W    While
  =Q.SQ    Variable Q (input variable) shuffled 
 n  Does not equal
       SQ    Variable Q sorted
             ;  Do nothing (loop ends)
              Q    And output variable Q

इसे ऑनलाइन आज़माएं!

— EdgyNerd
स्रोत

आप छोटा कर सकते हैं =Q.SQकरने के लिए =.SQके लिए -1 बाइट (भी जैसे अन्य ऑपरेटरों के साथ काम करता है, =QhQ-> =hQ)

— ar4093

1

जाप , 11 9 बाइट्स

_eZñ}a@öx

कोशिश करो

_eZñ}a@öx     :Implicit input of array U
_             :Function taking an array as argument via parameter Z
 e            :  Test Z for equality with
  Zñ          :  Z sorted
    }         :End function
     a        :Repeat and return the first result that returns true
      @       :Run this function each time and pass the result to the first function
       öx     :  Random permutation of U

— झबरा
स्रोत

1

ब्रेकीलॉग (v2), 5 बाइट्स

≤₁|ṣ↰

इसे ऑनलाइन आज़माएं!

कार्य प्रस्तुत करना। (TIO लिंक कमांड-लाइन तर्क का उपयोग करता है जो स्वचालित रूप से किसी फ़ंक्शन को पूर्ण प्रोग्राम में लपेटता है।)

व्याख्या

≤₁|ṣ↰
≤₁      Assert that {the input} is (nonstrictly) sorted in ascending order
  |     Output it
  |     Exception handler: if an assertion fails:
   ṣ      Randomly shuffle {the input}
    ↰     and run this function recursively on it, {outputting its output}

प्रोलॉग (जिस भाषा में Brachylog संकलन करता है) पूंछ-पुनरावर्ती है, इसलिए यह फ़ंक्शन एक तंग लूप में संकलित किया जा रहा है।

— ais523
स्रोत

0

सी (203 वर्ण, कोई इनपुट लूप: केवल दुर्गंध)

#include <stdio.h>
#define P (int*a,int n){
#define F for(i=0;i<n;i++){
int i,j,v;s P F if(a[i]>a[i+1])return 0;}return 1;}void h P F v=a[i];a[i]=a[j=rand()%n];a[j]=v;}}void b P while(!s(a,n-1))h(a,n);}

यह निम्नलिखित के समान है, जहां हम स्टड से सरणी को भी पढ़ते हैं और सॉर्ट किए गए सरणी को लिखते हैं। चूँकि Q ने फंक्शन के लिए कहा था न कि पूरा प्रोग्राम ...

सी (296 वर्ण)

#include <stdio.h>
#define P (int*a,int n){
#define F for(i=0;i<n;i++){
int i,j,n,v,x[999];s P F if(a[i]>a[i+1])return 0;}return 1;}void h P F j=rand()%n;v=a[i];a[i]=a[j];a[j]=v;}}void b P while(!s(a,n-1))h(a,n);}main(){while(scanf("%d",&v)==1)x[n++]=v;if(!s(x,n))b(x,n);F printf("%d\n",x[i]);}}

संकलन चेतावनी (अंतर्निहित घोषणाएं) दे सकता है। 999 तत्वों की हार्डकोडेड ऐरे आकार सीमा। नाजुक।

यदि सरणी को क्रमबद्ध करने के लिए पूर्व-जांच की आवश्यकता नहीं है, तो यह 284 में किया जा सकता है।

सी (251 वर्ण, 284 था)

#include <stdio.h>
#define F for(i=0;i<n;i++){
int i,j,n,v,a[999];s(int n){F if(a[i]>a[i+1])return 0;}return 1;}void h(){F v=a[i];a[i]=a[j=rand()%n];a[j]=v;}}void b(){while(!s(n-1))h();}main(){while(scanf("%d",&a[n++])>0);b();F printf("%d\n",a[i]);}}

(फ़ंक्शन आर्ग के बजाय ग्लोबल्स का उपयोग करना)।

— ShinTakezou
स्रोत

बोगोसॉर्ट को लागू करें

APL (Dyalog), 20

एपीएल (डायलॉग), 19

पर्ल 6: 23 चार्ट

एपीएल (22)

रूबी - 33 अक्षर

गणितज्ञ , ४० ३ 40

जम्मू - 34 27

अजगर 61

पायथन 94

के, ३१ २५

अजगर (69 वर्ण)

डी बिना कस्टम तुलनित्र: 59 वर्ण

डी कस्टम तुलनित्र के साथ: 69 वर्ण

स्केल 73:

GNU / BASH 65

सी ++ 11, 150 वर्ण

पायथन - 61 वर्ण

पॉवरशेल , 85 82 56 55 52 बाइट्स

जावास्क्रिप्ट 291 अक्षर

मतलाब, 59 बाइट्स

जे, 22 बाइट्स

सी ++ 14, 158 बाइट्स

जेली , 6 बाइट्स, भाषा चुनौती देती है

व्याख्या

सी ++, 166 बाइट्स

एपीएल (डायलाग एक्सटेंडेड) , 15 बाइट्स

ब्रेकीलॉग , 5 बाइट्स

ब्रेकीलॉग , 4 बाइट्स

पर्ल 6 , 28 बाइट्स

अजगर , 11 बाइट्स

व्याख्या

जाप , 11 9 बाइट्स

ब्रेकीलॉग (v2), 5 बाइट्स

व्याख्या

सी (203 वर्ण, कोई इनपुट लूप: केवल दुर्गंध)

सी (296 वर्ण)

सी (251 वर्ण, 284 था)