বন্ধ থাকে। এই প্রশ্নটি অফ-টপিক । এটি বর্তমানে উত্তর গ্রহণ করছে না।

এই প্রশ্নটি উন্নত করতে চান? প্রশ্নটি আপডেট করুন যাতে এটি কোড গলফ স্ট্যাক এক্সচেঞ্জের বিষয়বস্তু ।

2 বছর আগে বন্ধ ।

এই ধাঁধাটির উদ্দেশ্য হ'ল 52 টি কার্ডের ডেক নেওয়া এবং এটিকে সাফল্য দেওয়া যাতে প্রতিটি কার্ড একটি এলোমেলো অবস্থায় থাকে।

প্রদত্ত:

deckকার্ডগুলির প্রতিনিধিত্ব করে 52 স্বতন্ত্র পূর্ণসংখ্যার একটি অ্যারে । আপনি যখন শুরু করেন, deckকোনও কোনও অজানা ক্রমে প্রতিটি কার্ডের মধ্যে একটি করে অন্তর্ভুক্ত থাকে।
একটি ক্রিয়াকলাপ, int rand(min, max)যা ইনট minএবং সমেতের মধ্যে একটি এলোমেলো পূর্ণসংখ্যা প্রদান করে max। আপনি ধরে নিতে পারেন যে এই ফাংশনটি সত্যই এলোমেলো।
একটি ফাংশন, void swap(x, y)যা ডেকে দুটি কার্ড অদলবদল করে। আপনি যদি কল করেন swap(x, y)তবে কার্ডগুলি পজিশনে রয়েছে xএবং yস্থানগুলি স্যুইচ করবে।

কখন:

প্রোগ্রাম কল করে shuffle()(বা shuffle(deck)বা deck.shuffle()তবে আপনার প্রয়োগটি চালানো পছন্দ করে),

তারপর:

deck নিখুঁতভাবে এলোমেলো ক্রমে প্রতিটি কার্ডের মধ্যে একটি করে থাকা উচিত।

ক্যাচ:

আপনি কোনও ভেরিয়েবল ঘোষণা করতে পারবেন না। কল করুন swapএবং randআপনার পছন্দ মতো, তবে আপনি নিজের কোনও ভেরিয়েবল ঘোষণা করতে পারবেন না। এর মধ্যে forলুপ কাউন্টার অন্তর্ভুক্ত রয়েছে - এমনকি এর মতো অন্তর্নিহিত বিষয়গুলিও foreach।

ব্যাখ্যা:

আপনি আপনার পছন্দসই ভাষার সাথে মানিয়ে নিতে ছোটখাটো বিশদ পরিবর্তন করতে পারেন। উদাহরণস্বরূপ, আপনি swapরেফারেন্স দ্বারা দুটি পূর্ণসংখ্যার পরিবর্তন করতে লিখতে পারেন। পরিবর্তনগুলি আপনার ভাষা দিয়ে তৈরি করা উচিত, ধাঁধাটি সহজ করার জন্য নয়।
deck গ্লোবাল ভেরিয়েবল হতে পারে বা আপনি এটি প্যারামিটার হিসাবে নিতে পারেন।
আপনি যে বিষয়বস্তুতে চান deckতা করতে পারেন তবে আপনি এর দৈর্ঘ্য পরিবর্তন করতে পারবেন না।
আপনার কার্ডগুলি 0-51, 1-52, বা আপনার পছন্দ মতো কিছুতে নম্বর দেওয়া যেতে পারে।
আপনি এটি যে কোনও ভাষায় লিখতে পারেন, তবে আপনার ভাষার অন্তর্নির্মিত shuffleকার্যের সাথে কোনও প্রতারণা নেই ।
হ্যাঁ, আপনি একই লাইনে 52 বার লিখতে পারেন। কেউ মুগ্ধ হবে না।
মৃত্যুদন্ড কার্যকর করার সময়টি কোনও ব্যাপার নয়, তবে সত্যিকারের এলোমেলো করে।
এটি আসলে কোড গল্ফ নয়, তবে আপনার কোডটি ছোট / নিঃসরণে নির্দ্বিধায়।

সম্পাদনা করুন: বয়লারপ্লেট কোড এবং ভিজ্যুয়ালাইজার

যদি আপনি। নেট বা জাভাস্ক্রিপ্ট ব্যবহার করেন তবে এখানে কয়েকটি পরীক্ষার কোড আপনাকে দরকারী মনে করতে পারেন:

javascript:

কফিস্ক্রিপ্ট উত্স সহ দ্রুত এবং নোংরা জাভাস্ক্রিপ্ট ভিজ্যুয়ালাইজার: https://gist.github.com/JustinMorgan/3989752bdfd579291cca
চলমান সংস্করণ (কেবল আপনার shuffle()ফাংশনে পেস্ট করুন ): http://jsfiddle.net/4zxjmy42/

সি #:

সি # কোডবিহাইড সহ এএসপি.নেট ভিজ্যুয়ালাইজার: https://gist.github.com/JustinMorgan/4b630446a43f28eb5559
কেবলমাত্র swapএবং randইউটিলিটি পদ্ধতি সহ স্টাব : https://gist.github.com/JustinMorgan/3bb4e6b058d70cc07d41

এই কোডটি ডেককে কয়েক হাজার বার সাজিয়ে তোলে এবং এলোমেলো করে তোলে এবং কিছু বুনিয়াদি পরীক্ষা করে তোলে: প্রতিটি শিফেলের জন্য এটি যাচাই করে যে ডেকের মধ্যে ঠিক 52 টি কার্ড নেই যার পুনরাবৃত্তি নেই। তারপরে ভিজ্যুয়ালাইজার একটি গ্রেস্কেল তাপের মানচিত্র প্রদর্শন করে ডেকের প্রতিটি জায়গায় শেষ হওয়া প্রতিটি কার্ডের ফ্রিকোয়েন্সি প্লট করে।

ভিজ্যুয়ালাইজারের আউটপুটটি কোনও আপাত বিন্যাস ছাড়াই তুষারের মতো হওয়া উচিত। অবশ্যই এটি সত্য এলোমেলো প্রমাণ করতে পারে না, তবে এটি স্পট-চেক করার একটি দ্রুত এবং সহজ উপায়। আমি এটি বা এটির মতো আরও কিছু ব্যবহার করার পরামর্শ দিচ্ছি, কারণ বদলানো অ্যালগরিদমের কিছু ভুলের ফলে আউটপুটে খুব স্বীকৃতি পাওয়া যায়। দুটি বাস্তবায়ন থেকে প্রাপ্ত ফলাফলের একটি উদাহরণ এখানে রয়েছে, একটি সাধারণ ত্রুটিযুক্ত:

ভিজ্যুয়ালাইজার আউটপুট

ত্রুটিযুক্ত সংস্করণ আংশিকভাবে ডেকে বদল করে, তাই আপনি হাতের সাহায্যে অ্যারে পরীক্ষা করে নিলে সূক্ষ্ম দেখাতে পারে। ভিজ্যুয়ালাইজার কোনও প্যাটার্নটি লক্ষ্য করা সহজ করে তোলে।

— জাস্টিন মরগান
সূত্র

অনেকগুলি ভাষা মডেল অ্যারেগুলি কার্যকরভাবে অসীম হিসাবে কার্যকর করে, ফলে k ডেক [52] এবং এর পরে স্থানীয় ভেরিয়েবলের জায়গায় ব্যবহার করা যায়। সম্ভবত এটিও নিষিদ্ধ করা উচিত।

— টিমউই

2

ফাংশনগুলি পরিবর্তনশীল হিসাবে বিবেচিত হয়? ফাংশন পরামিতি ভেরিয়েবল বিবেচনা করা হয়?

— zzzzBov

1

@zzzzBov - আমার মনে যা ছিল তা হ'ল ফাংশন পরামিতিগুলি ভেরিয়েবল হিসাবে বিবেচিত হবে, তবে আমি @ মেল্লামবকের উত্তরের আগে তা নির্দিষ্ট করেছিলাম না। আমি জানি এটি deckনিজে ছাড়া অন্য কোনও পরামিতি ছাড়াই করা যায়।

— জাস্টিন মরগান

1

@ ই বিজনেস - এটাই আমার সমস্যা, প্রশ্ন নিজেই নয়। আমি উত্তর দিচ্ছিলাম কারণ উত্তরদাতাকে একটি ফাঁক খুঁজে পেয়েছিল।

— জাস্টিন মরগান

1

@ ব্যবহারকারী অজানা - আমি মনে করি আমি বুঝতে পেরেছি। উত্তরটি মূলত: আপনি swapযতটা বাস্তবায়ন পছন্দ করেন ততক্ষণ ধরে নিতে পারবেন , যতক্ষণ না এটি এর মূল উদ্দেশ্যটি পূরণ করে। আমার swapপ্রদত্ত হওয়ার কারণগুলির একটি অংশটি ছিল যাতে লোকেরা এটিকে 'যাদু' হিসাবে বিবেচনা করতে পারে এবং তাদের পছন্দের ভাষায় কাজ করার বিষয়ে চিন্তা না করেই মূল সমস্যাটিতে মনোনিবেশ করতে পারে। আপনি হয় তা করতে পারেন বা নিজের লিখতে পারেন swap, এটি আপনার উপর নির্ভর করে।

— জাস্টিন মরগান

9

জাভাস্ক্রিপ্ট

আমি বিশ্বাস করি এটি সমাধানের উদ্দেশ্যযুক্ত ফর্ম, আমি 0 অবস্থানটিতে কার্ডটি ব্যবহার করে অগ্রগতি অবলম্বন করতে থাকি, কেবল ইতিমধ্যে কাউন্টার হিসাবে ব্যবহৃত কার্ডগুলি বদলানো, এটি স্ট্যান্ডার্ড 52 অর্জন করে! একটি নিখুঁত সমান বন্টন সঙ্গে ক্রম। পদ্ধতিটি XOR অদলবদলের দ্বারা জটিল যে কোনও উপাদান নিজেই অদলবদলের অনুমতি দেয় না।

সম্পাদনা: আমি একটি বাছাই করে তৈরি করেছি যা প্রতিটি উপাদান ব্যবহৃত হওয়ার ঠিক আগে জায়গায় সাজিয়ে তোলে, সুতরাং এটি একটি অরসোর্টড অ্যারে দিয়ে কাজ করার অনুমতি দেয়। আমি কিছুক্ষণ লুপের পক্ষে পুনরাবৃত্ত কলিং বাদ দিলাম।

deck=[]
for(a=0;a<52;a++){
    deck[a]=a
}
function swap(a,b){
    deck[a]=deck[b]^deck[a]
    deck[b]=deck[b]^deck[a]
    deck[a]=deck[b]^deck[a]
}
function rand(a,b){
    return Math.floor(Math.random()*(1+b-a))+a
}
function shuffle(){
    while(deck[0]!=0){ //Sort 0 into element 0
        swap(0,deck[0])
    }
    while(deck[0]<51){ //Run 51 times
        while(deck[deck[0]+1]!=deck[0]+1){ //Sort element deck[0]+1 into position deck[0]+1
            swap(deck[deck[0]+1],deck[0]+1)
        }
        swap(0,deck[0]+1) //Swap element deck[0]+1 into position 0, thus increasing the value of deck[0] by 1
        if(rand(0,deck[0]-1)){ //Swap the element at position deck[0] to a random position in the range 1 to deck[0]
            swap(deck[0],rand(1,deck[0]-1))
        }
    }
    if(rand(0,51)){ //Swap the element at position 0 to a random position
        swap(0,rand(1,51))
    }
}
for(c=0;c<100;c++){
    shuffle()
    document.write(deck+"<br>")
}

— aaaaaaaaaaaa
সূত্র

এটাই আমার মনে ছিল। এটি পরীক্ষা করার সাথে সাথেই আমি উড়ে যাব এবং সম্ভবত গ্রহণ করব।

— জাস্টিন মরগান

সূক্ষ্মভাবে কাজ করে বলে মনে হচ্ছে, যদিও কাছাকাছি পরিদর্শনে এটি আমার মতো ঠিক নয়। স্বীকৃত, এবং আমি শীঘ্রই আমার নিজের উত্তর পোস্ট করব।

— জাস্টিন মরগান

এটি নুথ শাফল অ্যালগরিদম ( en.wikedia.org/wiki/Fisher%E2%80%93 ইয়েস_শ্যাফল ) নামেও পরিচিত ।

— বব

14

Haskell,

এখানে একটি বিন্দু মুক্ত বাস্তবায়ন। কোনও ভেরিয়েবল, আনুষ্ঠানিক পরামিতি বা স্পষ্ট পুনরাবৃত্তি নয়। আমি ব্যবহৃত lambdabot এর @pl( "অর্থহীন") refactoring বৈশিষ্ট্য বেশ একটু।

import Data.List
import Control.Applicative
import Control.Monad
import System.Random

shuffle :: [a] -> IO [a]
shuffle = liftM2 (<$>) ((fst .) . foldl' (uncurry ((. flip splitAt) . (.) .
          (`ap` snd) . (. fst) . flip flip tail . (ap .) . flip flip head .
          ((.) .) . (. (++)) . flip . (((.) . (,)) .) . flip (:))) . (,) [])
          (sequence . map (randomRIO . (,) 0 . subtract 1) . reverse .
          enumFromTo 1 . length)

main = print =<< shuffle [1..52]

নম্বরগুলি সমানভাবে বিতরণ করা হয়েছে তা নিশ্চিত করার জন্য এখানে আমার পরীক্ষার পদ্ধতিটি রয়েছে:

main = print . foldl' (zipWith (+)) (replicate 52 0)
       =<< replicateM 1000 (shuffle [1..52])

এখানে মূল অ্যালগরিদম রয়েছে:

shuffle :: [a] -> IO [a]
shuffle xs = shuffleWith xs <$>
             sequence [randomRIO (0, i - 1) | i <- reverse [1..length xs]]

shuffleWith :: [a] -> [Int] -> [a]
shuffleWith xs ns = fst $ foldl' f ([], xs) ns where
    f (a,b) n = (x:a, xs++ys) where
        (xs, x:ys) = splitAt n b

— জোয়ে অ্যাডামস
সূত্র

হাস্কেলের পক্ষে +1। এখন আমাকে হাসেলকে শিখতে হবে যাতে আমি এটি পড়তে পারি। : পি

— জাস্টিন মরগান

অগ্রগতি কিভাবে সংরক্ষণ করা হয়?

— aaaaaaaaaaaa

8

আমি কারও সন্দেহ করি তবে হাস্কেল প্রোগ্রামাররা বলবেন যে তাদের কোড অর্থহীন এবং এতে গর্বিত।

— aaaaaaaaaaaa

4

এটি ((.) .) . (. (++))এবং এটি (((.) . (,)) .)আমার প্রিয়। বাহ ল্যাম্বডাবোট। এইমাত্র.

— ড্যান বার্টন

2

@ ই বিজনেস "পয়েন্ট ফ্রি" মোটেও "অর্থহীন" এর মতো নয়।

— ফ্রেডওভারফ্লো

6

জে

সেই ডেককে উপেক্ষা করা একটি পরিবর্তনশীল, স্পষ্টতই ...

52 ? 52

অবশ্যই, যদি আপনি সত্যিই কোনও ফাংশন চান তবে এটি এখানে রয়েছে যা আপনি জোকারদের অপসারণ করতে ভুলে গেলেও (বা কার্ড ছাড়া অন্য কিছু বদলে দেওয়ার চেষ্টা করুন) কাজ করবে।

{~ (# ? #)

যাতে ...

shuffle =: {~ (# ? #)
deck =: i. 52
shuffle deck

এটি সম্ভবত প্রশ্নের অভিপ্রায় ছাড়াই, যা র্যান্ড ( ?) থেকে নিজেকে বদলাতে হবে । আমি পরে কাজ করব যখন আমার কাজ করার কথা নয় not

ব্যাখ্যা

এর ব্যাখ্যা 52 ? 52:

x ? y y থেকে এক্স এলোমেলো অনন্য আইটেম।

কাঁটাচামচ এবং হুকগুলির{~ (# ? #) কারণে ব্যাখ্যাটি আরও শক্ত । মূলত, এটি একই , যার একটি অন্তর্নিহিত যুক্তি রয়েছে ( )।shuffle =: 3 : '((# y) ? (# y)) { y'y

# y y এর দৈর্ঘ্য দেয়
এই 52 দেয়? 52 এর আগের মত, যা 0..51 এর এলোমেলো অনুচ্ছেদে
x { y x এর ইনডেক্সে y এর আইটেম বা (এই ক্ষেত্রে) x এর সূচকগুলিতে আইটেম।
এটি আপনাকে কেবল পূর্ণসংখ্যার মধ্যে নয়, যা যা পাস হয় তা বদলাতে দেয়।

অপারেটরগুলির বিশদের জন্য জে ভোকাবুলারিটি দেখুন , যদিও র‌্যাঙ্ক এবং সারণী প্রোগ্রামিংয়ের কারণে বাক্য গঠন এবং শব্দার্থবিজ্ঞান বেশ কিছুটা জটিল।

— জেসি মিলিকান
সূত্র

+1: কোড-গল্ফে কাজ করার কথা যখন মনে করা হয় .. আমিও হব: পি

— মেল্লামোকব

1

এটি জে-প্রতিবন্ধীদের জন্য কি করে তা ব্যাখ্যা করতে পারেন? আমি সম্প্রতি শুনেছি এটি একটি ইমোটিকন কারখানায় ( কোডগলফ.স্ট্যাকেক্সেঞ্জার / কোয়েশনস / १२৯৪ / এনগ্রাম-কোড-গল্ফ / )) বিস্ফোরণ হিসাবে বর্ণিত , যা সঠিক সম্পর্কে শোনাচ্ছে।

— জাস্টিন মরগান 23

@ জাস্টিন: ব্যাখ্যা যুক্ত হয়েছে।

— জেসি মিলিকান

এটি এপিএলেও কাজ করে। বাক্য গঠনটি একই, তাই আমি একটি নতুন উত্তর যুক্ত করতে বিরক্ত করব না ( {52?⍵}এটি একটি বেনাম ফাংশন যা তার যুক্তি থেকে 52 এলোমেলো আইটেম গ্রহণ করে, যা এখানে 52 পূর্ণসংখ্যার একটি তালিকা হবে)

— আর্ক 676

4

পাইথন

import random
def rand(x, y):
 return random.randrange(x, y+1)

def swap(deck, x, y):
 deck[x] ^= deck[y]
 deck[y] ^= deck[x]
 deck[x] ^= deck[y]

def shuffle(deck):
 if len(deck)>1:
  deck[1:]=shuffle(deck[1:])
  if rand(0,len(deck)-1)>0:swap(deck, 0, rand(1, len(deck)-1))
 return deck

print shuffle(range(52))

— কিথ র্যান্ডাল
সূত্র

কী [1:]মানে? এটি কি সাব-অ্যারেতে পুনরাবৃত্তি হয় deck?

— জাস্টিন মরগান

হ্যাঁ, [1:] অর্থ সূচী 1 থেকে অ্যারের শেষ পর্যন্ত সাববারে। সুতরাং এটি পুনরুক্তরূপে প্রথম উপাদান ব্যতীত সমস্ত কিছুকে বদল করে, মূল অ্যারেতে একই জায়গায় এটি পুনরায় নির্ধারণ করে (অনুলিপিগুলি) দেয়, পরে এলোমেলোভাবে প্রথম উপাদানটিকে কোথাও রাখে।

— কিথ র্যান্ডাল

খুব চালাক. আমি মনে করি এটি এখানে অন্যতম সুন্দর সমাধান এবং এটি ফিশার-ইয়েটস অ্যালগরিদমকে সঠিকভাবে ব্যবহার করে। +1 টি। আমি যে ভাষার সাথে পরিচিত নই তার সৌন্দর্য দেখার এটি আমার পক্ষে একটি দুর্দান্ত উপায় ছিল।

— জাস্টিন মরগান

2

আপনি a, b = b, aকৌশলটি পছন্দ করতে পারেন ।

— রায়

3

বাস্তব উপস্থাপনা ব্যবহার করা

ইন factoradic উপস্থাপনা একটি বিন্যাস একটি উপাদান আমি 0 থেকে এন মান সময় লাগে। সুতরাং একটি এলোমেলো ক্রমাঙ্কন কেবল rand(0,i)প্রতিটি নি জন্য।

জে:

? |.>:i.52
2 39 20 26 ... 2 0 1 0 0 0

যেখানে ? xহয় rand(0,x-1)এবং |.>:i.52হয়52 51 ... 1

তারপর, যদি aith factoradic মান, আমরা swap 'র একটি করুন: swap(deck[i], deck[i+a])। অদলবদল করার জন্য জোড়গুলির তালিকাটি হ'ল:

(,. i.52) ,. (,. ((?|.>:i.52)+i.52))
0 33
1 20
2  3
...
49 50
50 50
51 51

আমরা যে অদলবদলটি ব্যবহার করব তা এইভাবে কাজ করে:

deck
24 51 14 18 ...
deck =: 0 1 swap deck
51 24 14 18 ...

এটি সত্যই "রেফারেন্স দ্বারা" নয় তবে জেতে কোনও আসল ফাংশন নেই

#deckধ্রুবক ব্যবহার এড়াতে আমরা ডেকের দৈর্ঘ্য ( ) ব্যবহার করব ।

জেতে সম্পূর্ণ প্রোগ্রাম:

deck =: 52 ? 52                           NB. Initial random deck
swap =: 4 : 'deck =: (x { y) (|.x) } y'   NB. Given swap "function"
f =: 3 : 0                                NB. function that calls the swap for a pair
({.y) swap deck
}.y
)
f^:(#deck) (,.,.[:,.]+[:?[:|.>:) i.#deck

— Eelvex
সূত্র

3

সি শার্প

ফিশার-ইয়েটস অ্যালগরিদমের উপর ভিত্তি করে আমার নিজের উত্তর এখানে । যদি আপনার এলোমেলো নম্বর জেনারেটর যথেষ্ট ভাল হয় তবে আপনাকে একটি নিখুঁত পরিবর্তন করতে হবে।

ইংরেজি সংস্করণ:

বারবার কার্ড অদলবদল deck[0]এ এক সঙ্গে deck[v], যেখানে vকার্ড মুখে মান deck[0]। পর্যন্ত পুনরাবৃত্তিv == 0 । এটি আংশিকভাবে ডেকে বাছাই করবে, তবে তাতে কিছু আসে যায় না। আপনি এখন জানেন যে কার্ড 0 ডেকের সামনের দিকে রয়েছে যার অর্থ আপনি অ্যারেতে সেই স্থানটি চুরি করতে পারেন এবং এটি লুপ কাউন্টার হিসাবে ব্যবহার করতে পারেন। স্থানীয় ভেরিয়েবলগুলির সমস্যার জন্য এটিই "চিট"।
অবস্থান 1 থেকে শুরু (ডেকের দ্বিতীয় কার্ড), কার্ডটি iএকটিতে থাকা সাথে অদলবদল করুন rand(i, 51)। নোট করুন যে আপনার প্রয়োজন rand(i, 51), না rand(1, 51) । এটি প্রতিটি কার্ড এলোমেলোভাবে নিশ্চিত করে না।
সেট deck[0]0. ফিরে এখন পুরো ডেক প্রথম কার্ড ছাড়া এলোমেলো হয়, তাই সোয়াপ deck[0]সঙ্গে deck[rand(0, 51)]এবং আপনার কাজ সম্পন্ন হয়।

সি # সংস্করণ:

public static void shuffle(int[] deck)
{
    while (deck[0] > 0)
        swap(ref deck[0], ref deck[deck[0]]);

    for (deck[0] = 1; deck[0] < 52; deck[0]++)
        swap(ref deck[deck[0]], ref deck[rand(deck[0], 51)]);

    deck[0] = 0;
    swap(ref deck[0], ref deck[rand(0, 51)]);
}

জাভাস্ক্রিপ্ট সংস্করণ:

while (deck[0] > 0)
    swap(0, deck[0]);

for (deck[0] = 1; deck[0] < 52; deck[0]++)
    swap(deck[0], rand(deck[0], 52));

deck[0] = 0;
swap(0, rand(0, 52));

... যেখানে swap(a, b)অদলবদল deck[a]সঙ্গে deck[b]।

— জাস্টিন মরগান
সূত্র

2

রুবি, এক লাইন

এটি কি প্রতারণা বলে বিবেচিত? এটি যতটা এলোমেলো হওয়া উচিত।

deck=(0..51).to_a # fill the deck
deck[0..51] = (0..51).map{deck.delete_at(rand deck.length)}

(রুবির randপদ্ধতিতে কেবল একটি আর্গুমেন্ট লাগে এবং তার পরে 0 <= সংখ্যা <টি আর্গুমেন্ট a

অতিরিক্ত হিসাবে - সোগার্টের পার্ল সমাধানের অনুরূপ, তবে যতদূর আমি জানি এটি সমস্যাটি ভোগ করে না:

deck = deck.sort_by{rand}

রুবির সাজ্ট_বি বাছাইয়ের চেয়ে আলাদা - এটি প্রথমে অ্যারে বাছাই করার জন্য মানগুলির তালিকা তৈরি করে এবং কেবল তারপরেই এটি সাজায়। অন্য যে কোনও ক্ষেত্রে আমরা যে ধরণের সম্পত্তি বাছাই করছি তা খুঁজে পাওয়া যখন ব্যয়বহুল তখন তত দ্রুত। এটি কোড গল্ফেও কার্যকর: পি

— মাতমা রেক্স
সূত্র

আমি এটিকে প্রতারণামূলক বলব না, তবে deck[0..51]ভাষার কোনও বৈশিষ্ট্য ব্যবহার করে কিছু "ভেরিয়েবল" নিয়ম স্কার্ট করি না। এটি ন্যায্য, আমি কেবল মনে করি এটি চ্যালেঞ্জের কিছু হারিয়েছে। :) আমি রুবিকে চিনি না; আপনি (0..51).map{deck.delete_at(rand deck.length)}অংশ ব্যাখ্যা করতে পারেন ? এটি কি কার্ডগুলি মুছে দেয় deck?

— জাস্টিন মরগান

@ জাস্টিনমোরগান হ্যাঁ, 52 বার এটি এলোমেলো কার্ড মুছে ফেলা হয় deckএবং এটি mapজমা হওয়ার ফলাফলের অভ্যন্তরীণ তালিকায় যুক্ত করে । তারপর যখন কিছুই মধ্যে বাকি ফলাফলের অনুলিপি পরার । মূলত একটি অস্থায়ী আছে, তবে এটি স্পষ্টত deckmapdeck

— পরিবর্তকের

deck.sort_by!{rand}খাটো হয়।

— এরিক ডুমিনিল

1

জাভাস্ক্রিপ্ট

দ্রষ্টব্য: এই সমাধানটি প্রযুক্তিগতভাবে সঠিক নয় কারণ এটি একটি দ্বিতীয় প্যারামিটার ব্যবহার iকরে, কলটিতে shuffle, যা বাহ্যিক ভেরিয়েবল হিসাবে গণনা করা হয়।

function shuffle(deck, i) {
    if (i <= 0)
        return;
    else {
        swap(deck[rand(0,i-1)], deck[i-1]);
        shuffle(deck, i - 1);
    }
}

সাথে কল shuffle(deck,52)

একটি কার্যকারী উদাহরণ ( swapজাভাস্ক্রিপ্টে ইনটগুলির কোনও পাস-বাই-রেফারেন্স নেই বলে কিছুটা সংশোধন করতে হয়েছিল):

function rand(min, max) { return Math.floor(Math.random()*(max-min+1)+min); }
function swap(deck, i, j) {
    var t=deck[i];
    deck[i] = deck[j];
    deck[j] = t;
}

function shuffle(deck, i) {
    if (i <= 0)
        return;
    else {
        swap(deck, rand(0,i-1), i-1);
        shuffle(deck, i - 1);
    }
}

// create deck
var deck=[];
for(i=0;i<52;i++)deck[i]=i;
document.writeln(deck);
shuffle(deck,52);
document.writeln(deck);

— mellamokb
সূত্র

সাবাশ. আমার মনে যা ছিল তা shuffleভেরিয়েবল হিসাবে পরামিতিগুলি বিবেচনা করছিল , তবে আমি এটি +1 নির্দিষ্ট করিনি। পুনরাবৃত্তির খুব ভাল ব্যবহার।

— জাস্টিন মরগান

-1, সমস্ত অনুমান উত্পন্ন করে না, এটি সুস্পষ্ট কারণ 51 টির মূল জায়গাটি কখনই দখল করবে না, এবং আপনি কেবল 51 জেনারেটের জন্য পর্যাপ্ত র্যান্ড বলছেন! সম্ভাব্য 52 টির বাইরে অনুমতি!

— aaaaaaaaaaaa

2

@ ই বিজনেস: মূল বৈশিষ্ট্যে, ডেকটি নির্বিচারে আদেশ করা হয়, 1-52 অর্ডে অগত্যা নয়। আমি এটি ব্যবহার করেছি কারণ এটি ছিল সবচেয়ে সহজ।

— মেল্লামোকব

1

@ ই বিজনেস: deck[rand(0,i-1)]পরিবর্তে ব্যবহার করে উপাদানটিকে একই জায়গায় রেখে যাওয়ার সম্ভাবনা আমি সংশোধন করেছি deck[rand(0,i-2)]। i=0থামার পরিবর্তে সমস্ত পথে অদলবদল করুন i=1। এটা কি সাহায্য করে?

— মেল্লামব্যাক

হ্যাঁ, এটি করা উচিত, আপনি এখন XOR অদলবদলের স্পেসিফিকেশনটি ভঙ্গ করেন।

— আআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআ

1

সি ++

#include <cstdlib>
#include <ctime>
#include <iostream>

int deck[52];

void swap(int a, int b) {
    deck[a] ^= deck[b];
    deck[b] ^= deck[a];
    deck[a] ^= deck[b];
}

int r(int a, int b) {
    return a + (rand() % (b - a + 1));
}

void s(int *deck) {
    swap(1, r(2, 51));
    deck[0] *= 100;

    for(deck[0] += 2; (deck[0] % 100) < 51; deck[0]++) {
        swap(deck[0] % 100,
          r(0, 1) ? r(1, (deck[0] % 100) - 1) : r((deck[0] % 100) + 1, 51));
    }
    swap(51, r(1, 50)); 

    deck[0] = (deck[0] - 51) / 100;
    swap(r(1, 51), 0);
}

int main(int a, char** c)
{
    srand(time(0));

    for (int i = 0; i < 52; i++)
        deck[i] = i;

    s(deck);
    s(deck);

    for (int i = 0; i < 52; i++)
        std::cout << deck[i] << " ";
}

উপাদানগুলি নিজের সাথে অদলবদল এড়ায়, তাই এলোমেলো হতে দু'বার কল করতে হবে।

— ম্যাথু পড়ুন
সূত্র

swap(deck[rand(1, 51)], (deck[0] - 51) / 100);swapদ্বিতীয় মান কোথায় রাখবেন তা কীভাবে জানবে? এছাড়াও আপনি একটি দিতে ভুলে গেছেন )।

— জাস্টিন মরগান

উফ, ধন্যবাদ আমি সেই অংশটি একটি সংশোধনকালে চলতে শুরু করেছি এবং এটি শেষ করার আগে অবশ্যই বিভ্রান্ত হয়ে পড়েছে: পি

— ম্যাথু পড়ুন

ডাউনভোট আমার কাছ থেকে ছিল না, বিটিডাব্লু। আমি যখন পরীক্ষা করতে পারি।

— জাস্টিন মরগান 21

ঠিক আছে. আমি একটি সম্পূর্ণ প্রোগ্রাম সরবরাহ করে পরীক্ষা করা আরও সহজ করে দিয়েছি।

— ম্যাথু

1

খুব চালাক. আমার নিজের সমাধানটি ব্যবহার হয়েছে deck[0], তবে আপনার মতো নয়।

— জাস্টিন মরগান

1

ডি

shuffle(int[] d){
    while(d.length){
        if([rand(0,d.length-1)!=0)swap(d[0],d[rand(1,d.length-1)]);
        d=d[1..$];
    }
}

— র‌্যাচেট ফ্রিক
সূত্র

1

আরেকটি পার্ল সমাধান, যা আসলে অভিন্ন বিতরণ করা আউটপুট উত্পাদন করে:

sub shuffle_integers {
    map int, sort {$a-int $a <=> $b-int $b} map $_+rand, @_;
}

say join " ", shuffle_integers 1 .. 52;

এই সমাধান পার্ল এর ব্যবহার rand, যা ফেরৎ একটি র্যান্ডম সংখ্যা এক্স পরিসর 0 ≤ এক্স <1 It ।

(আমি বিশেষ ভেরিয়েবল ব্যবহার বিশ্বাস $_, $aএবং $bচ্যালেঞ্জ আত্মা মধ্যে বৃক্ষের পতন হয়, যেহেতু ঐ কিভাবে Perl ইনপুট পাসের হয়map এবং sort, এবং তারা কোডে অন্য কোন উদ্দেশ্যে ব্যবহার করা না। যাই হোক, আমি বিশ্বাস করি এগুলি প্রকৃতপক্ষে ইনপুট মানগুলির জন্য বিকল্প, স্বতন্ত্র অনুলিপি নয় This এটি বাস্তবে কোনও স্থান পরিবর্তন নয়, যদিও উভয়ই mapএবং sortস্ট্যাকের ইনপুটটির অনুলিপি তৈরি করে create)

— ইলমারি করোনেন
সূত্র

1

জাভা

আমি অবাক হয়েছি কেউই স্পষ্ট করে বলেননি: (আমি ধরে নেব যে অদলবদল (এক্স, এক্স) কিছুই করে না।

    static void shuffle(){
        swap(1,rand(0,1));
        swap(2,rand(0,2));
        swap(3,rand(0,3));
        swap(4,rand(0,4));
        swap(5,rand(0,5));
        swap(6,rand(0,6));
        swap(7,rand(0,7));
        swap(8,rand(0,8));
        swap(9,rand(0,9));
        swap(10,rand(0,10));
        swap(11,rand(0,11));
        swap(12,rand(0,12));
        swap(13,rand(0,13));
        swap(14,rand(0,14));
        swap(15,rand(0,15));
        swap(16,rand(0,16));
        swap(17,rand(0,17));
        swap(18,rand(0,18));
        swap(19,rand(0,19));
        swap(20,rand(0,20));
        swap(21,rand(0,21));
        swap(22,rand(0,22));
        swap(23,rand(0,23));
        swap(24,rand(0,24));
        swap(25,rand(0,25));
        swap(26,rand(0,26));
        swap(27,rand(0,27));
        swap(28,rand(0,28));
        swap(29,rand(0,29));
        swap(30,rand(0,30));
        swap(31,rand(0,31));
        swap(32,rand(0,32));
        swap(33,rand(0,33));
        swap(34,rand(0,34));
        swap(35,rand(0,35));
        swap(36,rand(0,36));
        swap(37,rand(0,37));
        swap(38,rand(0,38));
        swap(39,rand(0,39));
        swap(40,rand(0,40));
        swap(41,rand(0,41));
        swap(42,rand(0,42));
        swap(43,rand(0,43));
        swap(44,rand(0,44));
        swap(45,rand(0,45));
        swap(46,rand(0,46));
        swap(47,rand(0,47));
        swap(48,rand(0,48));
        swap(49,rand(0,49));
        swap(50,rand(0,50));
        swap(51,rand(0,51));
    }

ঠিক আছে, ঠিক আছে, এটি আরও খাটো হতে পারে:

package stackexchange;

import java.util.Arrays;

public class ShuffleDry1
{
    static int[] deck = new int[52];

    static void swap(int i, int j){
        if( deck[i]!=deck[j] ){
            deck[i] ^= deck[j];
            deck[j] ^= deck[i];
            deck[i] ^= deck[j];
        }
    }

    static int rand(int min, int max){
        return (int)Math.floor(Math.random()*(max-min+1))+min;
    }

    static void initialize(){
        for( int i=0 ; i<deck.length ; i++ ){
            deck[i] = i;
            swap(i,rand(0,i));
        }
    }

    static void shuffle(){
        while( deck[0]!=0 ) swap(0,deck[0]);
        for( deck[0]=52; deck[0]-->1 ; ) swap(deck[0],rand(deck[0],51));
        swap(0,rand(0,51));
    }

    public static void main(String[] args) {
        initialize();
        System.out.println("init: " + Arrays.toString(deck));
        shuffle();
        System.out.println("rand: " + Arrays.toString(deck));
    }

}

— ফ্লোরিয়ান এফ
সূত্র

1

প্যারডি

আপনি আসলে যা চেয়েছেন তা হল পূর্ণসংখ্যার তালিকার একটি এলোমেলো অনুচ্ছেদ? r@আমাদের সমস্ত অনুমতি দেবে, এবং আমরা কেবল একটি এলোমেলো নির্বাচন করি।

blsq ) {1 2 3}r@sp
1 2 3
2 1 3
3 2 1
2 3 1
3 1 2
1 3 2
blsq ) {1 2 3}r@3!!BS
2 3 1

যেহেতু আমাদের সত্যিকারের এলোমেলো প্রয়োজন, বার্লস্কে কিছু করতে সক্ষম হয় না কারণ বার্লস্কের কোনও I / O কার্যকারিতা নেই যা আপনাকে STDIN এর মাধ্যমে এলোমেলোতার কোনও উত্স সরবরাহ করতে হবে।

এটি সম্ভবত এমন কিছু যা আমি পরবর্তী সংস্করণে স্থির করব (অর্থাত্ প্রারম্ভকালে এলোমেলো বীজ উত্পন্ন করে এটিকে গৌণ স্ট্যাক বা এর মতো কিছুতে চাপ দেবে, তবে বার্লেস্ক ইন্টারপ্রেটারের নিজেই কোনও আই / ও নেই)।

— mroman
সূত্র

0

জাভাস্ক্রিপ্ট

আমি এটি "প্রতারণা" করছি কিনা তা নিশ্চিত নই তবে আমার সমাধানটি কোনও ফাংশনের আর্গুমেন্টের স্থানীয় স্থানীয় অ্যারে ব্যবহার করে। আমি আমার স্ব-তৈরি ফাংশনগুলি অন্তর্ভুক্ত করেছি rand() swap()এবং filldeck()। আকর্ষণীয় দ্রষ্টব্য, এটি কোনও আকারের ডেকের সাথে কাজ করা উচিত।

    var deck = [];

    function shuffle(){
        main(deck.length);
    }

    function main(){
        arguments[0] && swap( arguments[0]-=1, rand(0, deck.length-1) ), main(arguments[0]);
    }

        function rand(min, max){
            return Math.floor( Math.random()*(max-min+1) )+min;
        }

        function swap(x, y){
            var _x = deck[x], _y = deck[y];
            deck[x] = _y, deck[y] = _x;
        }


        function filldeck(dL){
            for(var i=0; i<dL; i++){
                var ran = rand(1,dL);
                while( deck.indexOf(ran) >= 0 ){
                    ran = rand(1,dL);
                }
                deck[i] = ran;
            }
        }

    filldeck(52);
    shuffle();

— path411
সূত্র

এটা প্রতারণা, আমি মনে করি। তবে এটি খুব চালাক প্রতারণা, তাই খুব সুন্দর কাজ।

— জাস্টিন মরগান 19

0

TCL , 32 বাইট

আপত্তিজনক timeফাংশন যা স্ক্রিপ্টটি চালাচ্ছে তার কতটা সময় ব্যয় করা হবে তা পরিমাপ করতে পরিবেশন করে তবে কোনও ভেরিয়েবল ঘোষণা না করে লুপিং প্রক্রিয়া হিসাবেও কাজ করতে পারে।

time {lswap $D [rand] [rand]} 52

এটি অনলাইন চেষ্টা করুন!

— sergiol
সূত্র

আমি কি ঠিক করছি যে এটি কেবল 52 টি এলোমেলো অদলবদল করে? এটি সত্যিকারের বদলে যাওয়ার পক্ষে যথেষ্ট নয়। আমি এটি একটি কয়েক বার দৌড়ে এবং তাদের শুরু অবস্থানকে 8 কার্ড এখনও গড়ে, গণনা করে একটি সত্য এলোমেলো সঙ্গে যে সম্ভাবনা 9x10 ^ -6 সম্পর্কে ।

— জাস্টিন মরগান 16

@ জাস্টিনমোরগান: আপনি কি আমাকে সম্ভাব্যতার গণনা আরও ভাল করে ব্যাখ্যা করতে পারবেন?

— sergiol

-1

পার্ল - মন্তব্যগুলিতে বর্ণিত হিসাবে এটি কোনও যথাযথ পরিবর্তন নয়!

my @deck = (0..51);
@deck = sort {rand() <=> rand()} @deck;
print join("\n",@deck);

আমি মনে করি যে অদলবদল ইত্যাদি হিসাবে আমি কিছুই ব্যবহার করিনি এটাই কি সমস্যার অংশ হিসাবে প্রয়োজন ছিল?

— sogart
সূত্র

4

এটি কাজ করবে যদি কোনও র্যান্ডম ফাংশন অনুসারে বাছাই করা কোনও এলোমেলো বিতরণ উত্পাদন করার একটি উপায় ছিল। তবে তা হয় না। -1

— আআআআআআআআআআআআআআআআআআআআআআআআআআআআআ

এবং কেন হয় না? আপনি কি আমাকে একটি লিঙ্ক দিতে পারেন ???

— সোগার্ট

2

বাছাইয়ের অ্যালগরিদমের উপর নির্ভর করে ফলাফলের গুণগত মান অনেকাংশে পৃথক হবে তবে প্রায় সব ক্ষেত্রেই ফলাফল সমান বন্টন এলোমেলো কার্য থেকে খুব দূরে থাকবে। এখানে বিষয় উপর একটি নিবন্ধ sroucheray.org/blog/2009/11/...

— aaaaaaaaaaaa

-1

জাভাস্ক্রিপ্ট 4 লাইন

function shuffle() {
  while(deck[0]!=0)swap(deck[0],rand(1,51))
  while(deck[0]++!=104)swap(deck[0]%51+1,rand(1,51))
  deck[0]=0
  swap(0,rand(0,51))
}

আসল উত্তর যা যথেষ্ট এলোমেলো ছিল না। অদলবদল ডেকে প্রতিটি আইটেম স্পর্শ গ্যারান্টিযুক্ত ছিল না।

// shuffle without locals
function shuffle() {
  deck.map(function(){swap(deck[rand(0,51)],deck[rand(0,51)])});
}

— wolfhammer
সূত্র

একটি সত্যিকারের এলোমেলো শ্যাফেল উত্পাদন করে না। এখানে একটি ভিজ্যুয়ালাইজার পরীক্ষা: jsfiddle.net/muk1bthm । shuffleআমার swapপ্রয়োগের সাথে মেলে আমি আপনার কোডটি কিছুটা পরিবর্তন করেছি , তবে এখানে এটি ভার্চুয়াম: jsfiddle.net/m7km4u6g

— জাস্টিন মরগান

পরিষ্কার করতে, উপরের মন্তব্যটি নতুন সংস্করণে প্রযোজ্য, যা এখনও এলোমেলো নয়।

— জাস্টিন মরগান 16

স্থানীয় ভেরিয়েবলগুলি ব্যতীত একটি ডেকে সাফ করুন [বন্ধ]

প্রদত্ত:

কখন:

তারপর:

ক্যাচ:

ব্যাখ্যা:

সম্পাদনা করুন: বয়লারপ্লেট কোড এবং ভিজ্যুয়ালাইজার

javascript:

সি #:

জাভাস্ক্রিপ্ট

Haskell,

জে

ব্যাখ্যা

পাইথন

বাস্তব উপস্থাপনা ব্যবহার করা

জেতে সম্পূর্ণ প্রোগ্রাম:

সি শার্প

রুবি, এক লাইন

জাভাস্ক্রিপ্ট

সি ++

ডি

জাভা

প্যারডি

জাভাস্ক্রিপ্ট

TCL , 32 বাইট

জাভাস্ক্রিপ্ট 4 লাইন