এটিকে বাছাই করুন, দ্রুত!

Question

ঠিক আছে ... এখানে 59 টি (এখন 60) টি প্রশ্নযুক্ত বাছাই করা হয়েছে , তবে কোনও সরল কুইকোর্টস নেই।

এটি অবশ্যই স্থির করতে হবে।

কুইকোর্টের সাথে অপরিচিতদের জন্য , এখানে উইকিপিডিয়া সৌজন্যে একটি ব্রেকডাউন দেওয়া হয়েছে-

1. অ্যারে থেকে একটি উপাদান বেছে নিন, যাকে পিভট বলা হয় ।
2. অ্যারেরটি পুনঃক্রম করুন যাতে পিভটের চেয়ে কম মান সহ সমস্ত উপাদান পিভটের আগে উপস্থিত হয়, যখন পিভটের চেয়ে বড় মানের সমস্ত উপাদান তার পরে আসে (সমান মান উভয় পথে যেতে পারে)। এই বিভাজনের পরে, পিভটটি তার চূড়ান্ত অবস্থানে রয়েছে। একে পার্টিশন অপারেশন বলে।
3. উপরোক্ত পদক্ষেপগুলিকে ছোট মান সহ উপাদানগুলির উপ-অ্যারে এবং পুনরায় পৃথকভাবে বৃহত্তর মান সহ উপাদানগুলির সাব-অ্যারে প্রয়োগ করুন।

বিধি

নিয়মগুলি সহজ:

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

বোনাস # 1: দৈর্ঘ্যের তালিকাগুলি বা উপ-তালিকায় <= 5, কিছুটা গতি বাড়ানোর জন্য সন্নিবেশ সাজানোর ব্যবহার করুন use পুরষ্কার: -15%।

বোনাস # 2: যদি আপনার ভাষা সম্মতিতে সমর্থন করে তবে তালিকাটি সমান্তরালে বাছাই করুন। আপনি যদি সাব-তালিকাগুলিতে একটি সন্নিবেশ বাছাই করে থাকেন তবে চূড়ান্ত সারণি সমান্তরালে থাকা দরকার নেই। থ্রেড পুলগুলিতে নির্মিত / থ্রেড শিডিয়ুলিং অনুমোদিত। পুরষ্কার: -15%।

দ্রষ্টব্য: তিনজনের মাঝারি কিছু লোককে বিভ্রান্ত করছিল, সুতরাং এখানে উইকিপিডিয়া: সৌজন্যে একটি ব্যাখ্যা দেওয়া হল

পিভটের জন্য পার্টিশনের প্রথম, মধ্য এবং শেষ উপাদানটির মধ্যম বেছে নেওয়া

স্কোরিং

এটি কোড-গল্ফ । বেস স্কোর বাইট হয়। আপনি যদি একটি বোনাস পেয়ে থাকেন তবে 15% নাম্বারটি নিন। যদি আপনি উভয়ই পেয়ে থাকেন তবে 30% ছাড়ুন। এটি সত্যিই একটি বিক্রয় পিচের মতো শোনাচ্ছে।

এটি সামগ্রিকভাবে সংক্ষিপ্ত উত্তর অনুসন্ধানের বিষয়ে নয়, বরং প্রতিটি ভাষায় স্বল্পতম উত্তর।

এবং এখন, লিডারবোর্ড স্নিপেটের একটি নির্লজ্জ অনুলিপি।

লিডারবোর্ড

এই পোস্টের নীচে স্ট্যাক স্নিপেট উত্তরগুলি থেকে ক্যাটালগ তৈরি করে a) ভাষার প্রতি সংক্ষিপ্ত সমাধানের তালিকা হিসাবে এবং খ) সামগ্রিক লিডারবোর্ড হিসাবে।

আপনার উত্তরটি প্রদর্শিত হয়েছে তা নিশ্চিত করার জন্য, দয়া করে নীচের মার্কডাউন টেমপ্লেটটি ব্যবহার করে আপনার উত্তরটি শিরোনাম দিয়ে শুরু করুন:

## Language Name, N bytes

যেখানে এন আপনার জমা দেওয়ার আকার। আপনি যদি নিজের স্কোরটি উন্নত করেন তবে আপনি পুরানো স্কোরগুলি শিরোনামে রেখে দিতে পারেন। এই ক্ষেত্রে:

## Ruby, <s>104</s> <s>101</s> 96 bytes

যদি আপনি নিজের শিরোনামে একাধিক সংখ্যা অন্তর্ভুক্ত করতে চান (যেমন আপনার স্কোর দুটি ফাইলের সমষ্টি বা আপনি পৃথকভাবে দোভাষী পতাকা দণ্ডের তালিকা করতে চান), নিশ্চিত করুন যে আসল স্কোরটি শিরোনামের শেষ সংখ্যা:

## Perl, 43 + 2 (-p flag) = 45 bytes

আপনি ভাষাটির নামটিকে একটি লিঙ্কও তৈরি করতে পারেন যা স্নিপেটে প্রদর্শিত হবে:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

/* Configuration */

var QUESTION_ID = 62476; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 41505; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "http://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "http://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+(?:.\d+)?)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    else console.log(body);
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    lang = jQuery('<a>'+lang+'</a>').text();
    
    languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="language-list">
  <h2>Shortest Solution by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Comments

"পিভটটি এলোমেলোভাবে বা তিনজনের মধ্যম (প্রথম, শেষ এবং মধ্যবর্তী উপাদান) দিয়ে বাছাই করা উচিত" " এটার মানে কি? আপনি আগে বলেছিলেন যে কেবলমাত্র একটি উপাদান বেছে নেওয়া হয়েছে।

— এমএস 210

@ ডানিরো স্নিপেট এখন ঠিক করা হয়েছে

— ড্যানিয়েল এম।

মিডিয়ান পছন্দ অ্যালগরিদম একটি হার্ড প্রয়োজন? এটি ভাষাগুলিতে অবৈধ (যেমন এটি পারফরম্যান্সকে টান দেয়) যেগুলি একটি লিঙ্কযুক্ত তালিকাকে তাদের প্রাথমিক অ্যারে টাইপ (হাস্কেল, এলআইএসপি) হিসাবে ব্যবহার করে এবং ইতিমধ্যে কমপক্ষে একটি উত্তর রয়েছে যা নিয়মটিকে উপেক্ষা করে।

— জন ডিভোরাক

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

— জন ডিভোরাক

এলোমেলো পিভট অন্য কারণে হ্যাসকেলে সমস্যাযুক্ত - একবার আপনি যখন ডাইস ঘূর্ণায়মান শুরু করেন, আপনি আর কোনও ফাংশন লিখবেন না। আপনি একটি আই / ও ক্রিয়া সংজ্ঞায়িত করছেন যা অ্যারে তৈরি করে। আপনি কোনও ফাংশনটি সংজ্ঞায়িত করতে পারেন যা কোনও আরএনজি রাষ্ট্রকে আর্গুমেন্ট হিসাবে গ্রহণ করে তবে এটি খুব বেশি দুর্দান্তও নয়।

— জন ডিভোরাক

Answer 1

সি ++, 440.3 405 388 বাইট

518 বাইট - সন্নিবেশ সাজানোর জন্য 15% বোনাস = 440.3 বাইট

477 বাইট - সন্নিবেশ সাজানোর জন্য 15% বোনাস = 405.45 বাইট

474 বাইট - সন্নিবেশ সাজানোর জন্য 15% বোনাস = 402.9 বাইট

456 bytes - 15% bonus for insertion sort = 387.6 bytes

3 লাইট (সত্যিই 2) সংরক্ষণ করার জন্য @ লুকাকে ধন্যবাদ।

18 (15 টি সত্যই) বাইট সংরক্ষণ করার জন্য @ দথোমাসকে ধন্যবাদ।

নোট করুন যে আমি এখানে নতুন এবং এটি আমার প্রথম পোস্ট।

এটি একটি .h(শিরোলেখ) ফাইল।

সংকুচিত কোড:

#include<iostream>
#include<ctime>
#include<cstdlib>
void s(int a[],int i,int j){int t=a[i];a[i]=a[j];a[j]=t;}int z(int a[],int b,int e){int p=a[(rand()%(e-b+1))+b];b--;while(b<e){do{b++;}while(a[b]<p);do{e--;}while(a[e]>p);if(b<e){s(a, b, e)}}return b;}void q(int a[],int b,int e){if(e-b<=5){for(int i=b;i<e;i++){for(int j=i;j>0;j--){if(a[j]<a[j-1]){s(a,j,j-1);}else{break;}}}return;}int x=z(a,b,e);q(a,b,x);q(a,x,e);}void q(int a[],int l){q(a,0,l);}

সম্পূর্ণ কোড:

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

void swapElements(int toSort[], int i, int j) {
    int temp = toSort[i];
    toSort[i] = toSort[j];
    toSort[j] = temp;
}

int partitionElements(int toSort[], int beginPtr, int endPtr)
{
    int pivot = toSort[(rand() % endPtr - beginPtr + 1) + beginPtr];
    beginPtr--;
    while (beginPtr < endPtr) {
        do {
            beginPtr++;
        } while (toSort[beginPtr] < pivot);
        do {
            endPtr--;
        } while (toSort[endPtr] > pivot);
        if (beginPtr < endPtr) {
            // Make sure they haven't crossed yet
            swapElements(toSort, beginPtr, endPtr);
        }
    }
    return beginPtr;
}

void quickSort(int toSort[], int beginPtr, int endPtr)
{
    if (endPtr - beginPtr <= 5) { // Less than 5: insertion sort
        for (int i = beginPtr; i < endPtr; i++) {
            for (int j = i; j > 0; j--) {
                if (toSort[j] < toSort[j - 1]) {
                    swapElements(toSort, j, j - 1);
                } else {
                    break;
                }
            }
        }
        return;
    }
    int splitIndex = partitionElements(toSort, beginPtr, endPtr);
    quickSort(toSort, beginPtr, splitIndex );
    quickSort(toSort, splitIndex, endPtr);
}

void quickSort(int toSort[], int length)
{
    quickSort(toSort, 0, length);
}

Comments

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

— edc65

আপনি একক তারকাচিহ্ন দ্বারা আর্গুমেন্টের বর্গাকার বন্ধনী প্রতিস্থাপন করে আরও 5 বাইট সংরক্ষণ করতে পারেন। আমার ধারণা, কিছু ম্যাক্রো ম্যাজিক আরও কিছু বাইট শেভ করতে পারে।

— ক্যাডানিলুক

আপনার আর কোনও জায়গার দরকার নেই #include।

— লুক

কলটি সরিয়ে 34 বাইট থেকে মুক্তি পান srand(time(NULL));আপনি এর থেকে ছদ্ম-এলোমেলো নম্বর পেয়ে যাবেন rand()।

— দথোমাহাস

Answer 2

এপিএল, 49 42 বাইট

{1≥⍴⍵:⍵⋄(∇⍵/⍨⍵<p),(⍵/⍨⍵=p),∇⍵/⍨⍵>p←⍵[?⍴⍵]}

এটি একটি নামবিহীন পুনরাবৃত্ত মোনাডিক ফাংশন তৈরি করে যা ডানদিকে একটি অ্যারে গ্রহণ করে। এটি বোনাসের জন্য যোগ্যতা অর্জন করে না।

ব্যাখ্যা:

{1≥⍴⍵:⍵⋄                                     ⍝ If length(⍵) ≤ 1, return ⍵
                                  p←⍵[?⍴⍵]}  ⍝ Choose a random pivot
                           ∇⍵/⍨⍵>            ⍝ Recurse on >p
                  (⍵/⍨⍵=p),                  ⍝ Concatenate with =p
        (∇⍵/⍨⍵<p),                           ⍝ Recurse on <p

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

মেরিনাসের জন্য একটি ইস্যু স্থির করে (8 বাইটের মূল্যে) এবং টমাস কোয়ার জন্য 7 বাইট সংরক্ষণ করে!

Comments

প্রশ্নটি উল্লেখ করে কোনও সদৃশ থাকবে না। (কীভাবে আমাকে দেখতে এতটা সময় লেগেছে তা জানেন না ...)

— lirtosiast

Answer 3

সি ++ 17, 254 199 195 বাইট

#include<vector>
#include<cstdlib>
#define P push_back(y)
using V=std::vector<int>;V q(V a){int p=a.size();if(p<2)return a;p=rand()%p;V l,r;for(y:a)(y<a[p]?l:r).P;l=q(l);for(y:q(r))l.P;return l;}

সাদা স্থান সহ:

V q(V a) {
    int p = a.size();

    if (p < 2)
        return a;

    p = rand() % p;
    V l,r;

    for (y : a)
        (y < a[p] ? l : r).P;

    l=q(l);

    for (y : q(r))
        l.P;

    return l;
}

Comments

শ্রেন্ডের দরকার নেই (সময় (এনওএলএল))। মুছে ফেলার দরকার নেই, কেবল মানটি ভাগ হয়ে যাক, তারপরে 'if (a.empty ())' থেকে 'if (a.size () <2)' এ পরিবর্তন করুন এবং 'lP (x)' সরান।

— ক্রিস জেফারসন

মুছে ফেলার কাজটি আমাকে প্রচুর বাইট সংরক্ষণ করতে দেয় । ধন্যবাদ!

— লিন

অন্য একটি ছোট্ট একটি: 'r = q (r)' বরাদ্দ করার দরকার নেই, কেবল 'y (q: r (r))' এর জন্য ব্যবহার করুন, তবে এটাই আমি দেখতে পাচ্ছি!

— ক্রিস জেফারসন

কৌতূহলের বাইরে: বিশেষত এখানে C ++ 17 কোথায় ব্যবহৃত হয়?

— kirbyfan64sos

for (y : a)অন্যথায় হতে হবে for (auto y : a)বা for (int y : a)। (আসলে, clang++এটিকে C ++ 1z এক্সটেনশন বলে , তবে এটি আসলে C ++ 17 বলে মনে হয় না? আমি জানি না এবং এটি সন্ধান করতে রাতের খুব বেশি দেরি হয়ে গেছে।)

— লিন

Answer 4

পাইথ, 25 বাইট

L?tbsyMa_,]JObf<TJbf>TJbb

এটি একটি ফাংশন সংজ্ঞায়িত করে y, যা ইনপুট হিসাবে সংখ্যার একটি তালিকা নেয়।

অনলাইনে চেষ্টা করুন: বিক্ষোভ

ব্যাখ্যা

L?tbsyMa_,]JObf<TJbf>TJbb
L                          define function y(b), that returns: 
 ?tb                         if t[1:] (if the list has more than one element):
            Ob                 choose a random element of b
           J                   save it in J
          ]                    put J in a list
         ,    f<TJb            create a pair, that contains ^ and a list of 
                               all numbers smaller than J: [[J], [smaller than J]] 
        _                      reverse this list: [[smaller than J], [J]]
       a           f>TJb       append a list with all elements bigger than J: 
                               [[smaller than J], [J], [bigger than J]]
     yM                        call y recursively for each sublist
    s                          combine the results and return it
                        b    else: simply return b

পাইথ, 21 বাইট (সম্ভবত অবৈধ)

আমি "গ্রুপ-বাই" পদ্ধতিটি ব্যবহার করি, যা অভ্যন্তরীণভাবে একটি বাছাই করে। আমি আসল তালিকাকে তিনটি সাবলিস্টে বিভক্ত করতে ব্যবহার করি (সমস্ত উপাদান পিভট, পিভট এবং পিভটের চেয়ে বড় সমস্ত উপাদান)। "গ্রুপ-বাই" অনুসারে বাছাই না করে, এই 3 টি তালিকাকে অন্য ক্রমে ফিরিয়ে দিতে পারে।

যেমনটি বলা হয়েছে, এটি সম্ভবত অবৈধ। তবুও আমি এটি এখানে রাখব, কারণ এটি একটি আকর্ষণীয় সমাধান।

L?tb&]JObsyM.g._-kJbb

অনলাইনে চেষ্টা করুন: বিক্ষোভ

ব্যাখ্যা

L?tb&]JObsyM.g._-kJbb
L                      def y(b): return
 ?tb                     if t[1:] (if the list has more than one element):
       Ob                  choose a random element of b
      J                    save it in J
    &]                     put it in an array and call "and" 
                           (hack which allows to call 2 functions in one statement)

            .g     b       group the elements in b by:
              ._-kJ           the sign of (k - J)
                           this generates three lists
                             - all the elements smaller than J
                             - J
                             - all the elements bigger than J
          yM               call y recursively for all three lists
         s                 and combine them
                    b    else: return b

Answer 5

> <> (ফিশ), 313 309 বাইট

!;00l[l2-[b1.
>:0)?v~$:@&vl2,$:&${:}$
^-1@{< ]]. >055[3[5b.
?v~~@~ v:}@:}@:}:}@:}@}}}(}(}({{:@=
.>=$~?$>~]]
.001-}}d6.{$}1+}d6
?v:{:}@{(?v08.}:01-=
 >{$~~{09.>95.v-1@{<   v-1}$<
.:@}:@{=${::&@>:0)?^~}&>:0)?^~+}d6
 1-:0a.{{$&l&1+-: >:0)?v~:1)?!v62fb.
>:0)?v~:}:1)?v~69.^@{-1<>.!]]~<
^@{-1<:}@@73.>69@@:3+[{[b1.

এটি আমাকে লিখতে খুব দীর্ঘ সময় নিয়েছে। আপনি এখানে এটি চেষ্টা করে দেখতে পারেন , প্রোগ্রামটি চালানোর আগে কমা দিয়ে আলাদা করা প্রাথমিক স্ট্যাকের মধ্যে যে তালিকাটি বাছাই করতে হবে কেবল সেই তালিকাটি রেখে দিন।

কিভাবে এটা কাজ করে

প্রোগ্রামটি প্রাথমিক স্ট্যাকের প্রথম, মধ্য এবং শেষ উপাদানটি ধরে এবং এই তিনটির মধ্যম গণনা করে।
এরপরে এটি স্ট্যাকটি এতে পরিবর্তন করে:

[তালিকা 1] উপাদান [তালিকা 2]

যেখানে তালিকার 1-এ থাকা সমস্ত কিছু উপাদানগুলির চেয়ে ছোট বা সমান এবং 2 তালিকার সমস্ত কিছুই বড়।
এটি তালিকাটি 1 এ পুনরাবৃত্তভাবে পুনরাবৃত্তি করে এবং সম্পূর্ণ তালিকা অনুসারে বাছাই করে 2 তালিকা তৈরি করে।

Answer 6

সিজেম, 40 বাইট

{_1>{_mR:P-PaL@{_P<{+}{@\+\}?}/J\J+}&}:J

এটি একটি নামযুক্ত ফাংশন যা স্ট্যাকের একটি অ্যারের প্রত্যাশা করে এবং বিনিময়ে একটিকে ধাক্কা দেয়।

সিজেএম ইন্টারপ্রেটারে এটি অনলাইনে চেষ্টা করুন ।

উপরের কোডটি অনুমিত হিসাবে যথাসম্ভব ঘনিষ্ঠভাবে অনুসরণ করে। যদি এটির প্রয়োজন না হয় তবে 12 বাইট সংরক্ষণ করা যায়:

{_1>{_mR:P;_{P<},J_@^J+}&}:J

Answer 7

পাইথন 3, 123 , 122।

হারুনকে ধন্যবাদ 1 বাইট সংরক্ষিত

এই প্রথম আমি আসলে বাছাই করা অ্যালগরিদম লিখতে বিরক্ত করেছি। এটি আসলে আমার চেয়ে অনেক সহজ ছিল a

from random import*
def q(s):
 if len(s)<2:return s
 p=choice(s);return q([d for d in s if d<=p])+q([d for d in s if d>p])

Ungolfed:

from random import choice
def quick_sort(seq):
    if len(seq) < 2:
        return seq
    low = []
    high = []
    pivot = choice(seq)
    for digit in seq:
        if digit > pivot:
            high += [digit]
        else:
            low += [digit]
    return quick_sort(low) + quick_sort(high)

Comments

দেখে মনে হচ্ছে এটি <=তুলনামূলকভাবে কাজ করে না - এটি গ্যারান্টি দেয় না যে pএটি সঠিক জায়গায় রয়েছে, আপনার সম্ভবত সম্ভবত এটি একটি একচেটিয়া বৈষম্যতে পরিবর্তন করা দরকার, এবং pমাঝখানে স্বাধীনভাবে যুক্ত করা দরকার (আমি পরীক্ষিত / পারি না কোডটি পরীক্ষা করবেন না)।

— ভিজ্যুমেলন

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

— মরগান থ্র্যাপ

আমি ভেবেছিলাম যে [2, 1, 3]এটি সময়ের 1/3 অংশটি ভেঙে ফেলবে, যখন এটি পিভটটিকে 2 হিসাবে বেছে নেবে, এটির নীচের তালিকাটি থাকবে [2, 1]- আমি দুঃখিত আমি এই মুহূর্তে নিজেকে পরীক্ষা করতে পারছি না।

— ভিজুয়েলমেলন

@ ভিজুয়ালমেলন ভাল, নিশ্চিত, তবে এটি পুনরাবৃত্তভাবে আবার বাছাই করে।

— মরগান থ্র্যাপ

আহ, দুঃখিত, সম্পূর্ণরূপে মিস করেছি, আমি কীভাবে কোনও

— কুইকোর্টের

Answer 8

জাভাস্ক্রিপ্ট (ES2015), 112

q=l=>{let p=l[(Math.random()*l.length)|0];return l.length<2?l:q(l.filter(x=>x<=p)).concat(q(l.filter(x=>x>p)));}

ব্যাখ্যা

//Define lambda function q for quicksort
q=l=>{

    //Evaluate the pivot
    let p=l[(Math.random()*l.length)|0];

    //return the list if the length is less than 2
    return l.length < 2 ? l:

    //else return the sorted list of the elements less or equal than 
      the pivot concatenated with the sorted list of the elements 
      greater than the pivot
    q(l.filter(x=>x<=p)).concat(q(l.filter(x=>x>p)));
}

Comments

ES6 সম্ভবত এটি সংক্ষিপ্ত করতে পারে।

— নিসা

Answer 9

রুবি, 87 60 বাইট

q=->a,p=a.sample{a[1]?(l,r=a.partition{|e|e<p};q[l]+q[r]):a}

Ungolfed:

def quicksort(a, pivot=a.sample)
  if a.size > 1
    l,r = a.partition { |e| e < pivot}
    quicksort(l) + quicksort(r)
  else
    a
  end
end

টেস্ট:

q[[9, 18, 8, 5, 13, 20, 7, 14, 16, 15, 10, 11, 2, 4, 3, 1, 12, 17, 6, 19]]
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

Answer 10

অক্টাভা, 76 75 বাইট

function u=q(u)n=numel(u);if n>1 k=u(randi(n));u=[q(u(u<k)),q(u(u>=k))];end

মাল্টি-লাইন সংস্করণ:

function u=q(u) 
   n=numel(u);
   if n>1 
      k=u(randi(n));
      u=[q(u(u<k)),q(u(u>=k))];
   end

Answer 11

জুলিয়া, 83 বাইট

Q(x)=endof(x)<2?x:(p=rand(x);[Q((f=filter)(i->i<p,x));f(i->i==p,x);Q(f(i->i>p,x))])

এটি একটি পুনরাবৃত্ত ফাংশন তৈরি করে Qযা একটি অ্যারে গ্রহণ করে এবং একটি অ্যারে প্রদান করে। এটি শর্তসাপেক্ষে সন্নিবেশ সাজানোর ব্যবহার করে না, সুতরাং কোনও বোনাস প্রযোজ্য নয়।

Ungolfed:

function Q(x::AbstractArray)
    if endof(x) ≤ 1
        # Return on empty or 1-element arrays
        x
    else
        # Select a random pivot
        p = rand(x)

        # Return the function applied to the elements less than
        # the pivot concatenated with those equal to the pivot
        # and the function applied to those greater than the pivot
        [Q(filter(i -> i < p, x));
         filter(i -> i == p, x);
         Q(filter(i -> i > p, x))]
    end
end

একটি সমস্যা স্থির করে এবং গ্লেন ওকে ধন্যবাদ কিছু বাইট সংরক্ষণ করেছে!

Comments

পুনরাবৃত্তি উপাদানগুলির ক্ষতি (যা ইতিমধ্যে আপনার কোডে বিদ্যমান) এর ক্ষতির সম্ভাব্য সমস্যাগুলি, fআপনি প্রথমটি ব্যবহার করার সময় অ্যাসাইন filterকরে এবং এর endofপরিবর্তে ব্যবহার করে আপনি এখানে কয়েকটি বাইট সংরক্ষণ করতে পারেন length। Q(x)=endof(x)<2?x:(p=rand(x);[Q((f=filter)(i->i<p,x));p;Q(f(i->i>p,x))])

— গ্লেন ও

@ গ্লেনো পরামর্শ দেওয়ার জন্য ধন্যবাদ। আমি এটি বাস্তবায়ন করেছি এবং বারবার উপাদানগুলির সাথে সমস্যাটি স্থির করেছি।

— অ্যালেক্স এ 0

আমি বলেছিলাম এটি একটি সমস্যা হতে পারে, তবে আমি স্পষ্টকরণের জন্য প্রশ্ন পোস্টারটি জিজ্ঞাসা করেছি এবং "ইনপুটটিতে দশমিক এবং নেতিবাচক মান থাকতে পারে However তবে কোনও নকল থাকবে না"

— গ্লেন ও

Answer 12

আর, 78 বাইট

Q=function(x)if(length(x)>1)c(Q(x[x<(p=sample(x,1))]),x[x==p],Q(x[x>p]))else x

এটি একটি পুনরাবৃত্ত ফাংশন তৈরি করে Qযা ভেক্টরকে গ্রহণ করে এবং একটি ভেক্টরকে ফেরত দেয়। এটি শর্তসাপেক্ষে সন্নিবেশ সাজানোর প্রয়োগ করে না, সুতরাং কোনও বোনাস নেই।

Ungolfed:

Q <- function(x) {
    # Check length
    if (length(x) > 1) {
        # Select a random pivot
        p <- sample(x, 1)

        # Recurse on the subarrays consisting of
        # elements greater than and less than p,
        # concatenate with those equal to p
        c(Q(x[x < p]), x[x == p], Q(x[x > p]))
    } else {
        x
    }
}

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

ফ্লাডেল ধন্যবাদ 4 বাইট সংরক্ষণ করা!

Comments

দৈর্ঘ্যের তুলনা থেকে "> 1" বাদ দিয়ে আপনি কয়েকটি বাইট অফ করে দিতে পারেন। এটি সুস্পষ্টভাবে এটি 0 এর সাথে তুলনা করে, তবে পুনরাবৃত্তির একটি অতিরিক্ত স্তর কোনও সমস্যা নয়

— মিফ

@ মিফ আপনার ইনপুটটির জন্য ধন্যবাদ তবে আমি এটি চেষ্টা করেছিলাম এবং এটি আমার জন্য প্রত্যাশিত ফলাফল দেয় না।

— অ্যালেক্স এ।

Answer 13

কে, 41 বাইট

s:{$[#x;(s@x@&x<p),p,s@x@&x>p:x@*1?#x;x]}

গ্রহণ করুন, এপিএল !!! কোনও বোনাস দেয় না।

Answer 14

Haskell,, 137136 বাইট

f=filter
m a b c=max(min a b)(min(max a b)c)
q[]=[]
q l=let{n=m(head l)(head$drop(length l`div`2)l)(last l)}in(q$f(<n)l)++(n:(q$f(>n)l))

প্রসারিত সংস্করণটি এখানে রয়েছে, প্রসারিত ভেরিয়েবল এবং ফাংশন নাম এবং কিছু মধ্যবর্তী ফলাফল যুক্ত:

median a b c = max (min a b) (min (max a b) c)
quicksort [] = []
quicksort l = let mid = median (head l) (middle l) (last l)
                  lesser = filter (< mid) l
                  greater = filter (> mid) l
                  middle l = head $ drop (length l `div` 2) l
              in (quicksort lesser) ++ (mid : (quicksort greater))

আমি এই সত্যটির সদ্ব্যবহার করছি যে দুটি কঠোর তুলনা ব্যবহারের জন্য কোনও সদৃশ নেই। আমি Data.List.partitionযদিও জিনিসগুলি ছোট না করে তা খতিয়ে দেখতে হবে, এমনকি আমদানি বিবৃতি যুক্ত করতে হবে তা বিবেচনা করেই। আমি সন্নিবেশ বাছাইয়ের বোনাস নিচ্ছি না কারণ আমি Data.List.insertবাছাই-সম্পর্কিত ফাংশন হিসাবে বিবেচনা করি - এইভাবে নিষিদ্ধ - এবং যদি এটি ব্যবহার না করে, সন্নিবেশ সারণিটি কোডটিকে 246 বাইট, 209.1 এ বোনাসের সাথে ঠেলা দেয়, সুতরাং এটি মূল্যবান নয়।

সম্পাদনা করুন: রবআউকে একটি উপনাম ব্যবহারের পরামর্শ দেওয়ার জন্য তাদের পরামর্শের জন্য ধন্যবাদ f=filter। এটি কেবলমাত্র একটি বাইট সংরক্ষণ করতে পারে তবে সবকিছুই সহায়তা করে।

Comments

f=filterকিছু বাইট শেভ হতে পারে।

— রবউউ

দুটি অপ্রয়োজনীয় q$f(>n)lএবং q$f(<n)lকলগুলি পরিচালনা করতে আপনি কোনও ফাংশন তৈরি করে কয়েক বাইট শেভ করতে পারেন ?

— সাইওস

Answer 15

Tcl, 138 বাইট

proc q v {if {$v eq {}} return
lassign {} a b
foreach x [lassign $v p] {if {$x<$p} {lappend a $x} {lappend b $x}}
concat [q $a] $p [q $b]}

এটি একটি অত্যন্ত মানক কোয়ারকোর্ট।

পিভট হ'ল প্রতিটি সুবারে প্রথম উপাদান (আমি দাবি করি যে এটি একটি এলোমেলো সংখ্যা htt https://xkcd.com/221/ )

এটি মেমরির ব্যবহারের ক্ষেত্রে বিশেষভাবে দক্ষ নয়, যদিও এটি tailcallদ্বিতীয় পুনরাবৃত্তি এবং এন <1 উপাদানগুলির একটি বেস কেস সহ কিছুটা উন্নত করা যেতে পারে ।

এখানে পাঠযোগ্য সংস্করণ:

proc quicksort xs {
  if {![llength $xs]} return
  set lhs [list]
  set rhs [list]
  foreach x [lassign $xs pivot] {
    if {$x < $pivot} \
      then {lappend lhs $x} \
      else {lappend rhs $x}
  }
  concat [quicksort $lhs] $pivot [quicksort $rhs]
}

সমস্ত ইনপুট এবং ডুপ্লিকেট অনুমতি দেয়। ওহ, এটিও স্থিতিশীল । আপনি এটি সাধারণ কিছু দিয়ে পরীক্ষা করতে পারেন, যেমন:

while 1 {
  puts -nonewline {xs? }
  flush stdout
  gets stdin xs
  if {$xs eq {}} exit
  puts [q $xs]    ;# or [quicksort $xs]
  puts {}
}

উপভোগ করুন! হে)

Comments

আপনি এর foreachমাধ্যমে প্রতিস্থাপন বাইটগুলি সংরক্ষণ করতে পারেনlmap

— sergiol

Answer 16

জাভাস্ক্রিপ্ট (ES6), 191

Q=(a,l=0,h=a.length-1)=>l<h&&(p=((a,i,j,p=a[i+(0|Math.random()*(j-i))])=>{for(--i,++j;;[a[i],a[j]]=[a[j],a[i]]){while(a[--j]>p);while(a[++i]<p);if(i>=j)return j}})(a,l,h),Q(a,l,p),Q(a,p+1,h))

// More readable
U=(a,l=0,h=a.length-1)=>l<h && 
  (p=( // start of partition function
    (a,i,j,p=a[i+(0|Math.random()*(j-i))])=>
    {
      for(--i,++j;;[a[i],a[j]]=[a[j],a[i]])
      {
        while(a[--j]>p);
        while(a[++i]<p);
        if(i>=j)return j
      }
    } // end of partition function
  )(a,l,h),U(a,l,p),U(a,p+1,h))

// This is the shortest insertion sort that I could code, it's 72 bytes
// The bonus is worth  ~30 bytes - so no bonus
I=a=>{for(i=0;++i<a.length;a[j]=x)for(x=a[j=i];j&&a[j-1]>x;)a[j]=a[--j]}


// TEST
z=Array(10000).fill().map(_=>Math.random()*10000|0)

Q(z)

O.innerHTML=z.join(' ')

<div id=O></div>

Answer 17

সিলোন (কেবলমাত্র জেভিএম), 183 170

কোনও বোনাস প্রযোজ্য নয়।

import ceylon.math.float{r=random}{Float*}q({Float*}l)=>if(exists p=l.getFromFirst((r()*l.size).integer))then q(l.filter((e)=>e<p)).chain{p,*q(l.filter((e)=>p<e))}else[];

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

এটি এমন একটি ফাংশন সংজ্ঞায়িত করে যা পুনরাবৃত্তিযোগ্য ফ্লোট নেয় এবং এর সাজানো সংস্করণ দেয় returns

import ceylon.math.float {
    r=random
}

{Float*} q({Float*} l) {
    if (exists p = l.getFromFirst((r() * l.size).integer)) {
        return q(l.filter((e) => e < p)).chain { p, *q(l.filter((e) => p < e)) };
    } else {
        return [];
    }
}

যদি (নির্দিষ্টকরণের বিপরীতে) সদৃশ এন্ট্রি পাস করা হয় তবে সেগুলি ফিল্টার করে দেওয়া হবে।

এটি 183 বাইট: import ceylon.math.float{r=random}{Float*}q({Float*}l){if(exists p=l.getFromFirst((r()*l.size).integer)){return q(l.filter((e)=>e<p)).chain{p,*q(l.filter((e)=>p<e))};}else{return[];}}

আমরা নতুন (সিলন 1.2) ifএক্সপ্রেশনটি ব্যবহার করে কিছুটা উন্নতি করতে পারি :

import ceylon.math.float {
    r=random
}

{Float*} q({Float*} l) =>
        if (exists p = l.getFromFirst((r() * l.size).integer))
        then q(l.filter((e) => e < p)).chain { p, *q(l.filter((e) => p < e)) }
        else [];

এটি 170 বাইট: import ceylon.math.float{r=random}{Float*}q({Float*}l)=>if(exists p=l.getFromFirst((r()*l.size).integer))then q(l.filter((e)=>e<p)).chain{p,*q(l.filter((e)=>p<e))}else[];

---

এখানে একটি অ-র্যান্ডম সংস্করণ রয়েছে:

{Float*} r({Float*} l) =>
        if (exists p = l.first)
        then r(l.filter((e) => e < p)).chain { p, *r(l.filter((e) => p < e)) }
        else [];

স্পেস ছাড়াই এটি 107 বাইট হবে: {Float*}r({Float*}l)=>if(exists p=l.first)then r(l.filter((e)=>e<p)).chain{p,*r(l.filter((e)=>p<e))}else[];

Answer 18

অটোআইটি , 320.45 304.3 বাইট

এটি প্রচুর দ্রুত (যাইহোক AutoIt এর জন্য)। সন্নিবেশ সাজানোর বোনাসের জন্য যোগ্যতা অর্জন করে। চূড়ান্ত গল্ফিংয়ের পরে ব্যাখ্যা যুক্ত করবে।

ইনপুট হয় q(Array, StartingElement, EndingElement)।

Func q(ByRef $1,$2,$3)
$5=$3
$L=$2
$6=$1[($2+$3)/2]
If $3-$2<6 Then
For $i=$2+1 To $3
$4=$1[$i]
For $j=$i-1 To $2 Step -1
$5=$1[$j]
ExitLoop $4>=$5
$1[$j+1]=$5
Next
$1[$j+1]=$4
Next
Else
Do
While $1[$L]<$6
$L+=1
WEnd
While $1[$5]>$6
$5-=1
WEnd
ContinueLoop $L>$5
$4=$1[$L]
$1[$L]=$1[$5]
$1[$5]=$4
$L+=1
$5-=1
Until $L>$5
q($1,$2,$5)
q($1,$L,$3)
EndIf
EndFunc

এলোমেলো ইনপুট + আউটপুট:

862, 543, 765, 577, 325, 664, 503, 524, 192, 904, 143, 483, 146, 794, 201, 511, 199, 876, 918, 416
143, 146, 192, 199, 201, 325, 416, 483, 503, 511, 524, 543, 577, 664, 765, 794, 862, 876, 904, 918

Comments

আকর্ষণীয়, এর আগে অটোআইটির আগে কখনও শুনিনি

— ড্যানিয়েল এম।

Answer 19

জাভা, 346 বাইট

407 bytes - 15% bonus for insertion sort = 345.95 bytes

সংকুচিত কোড:

class z{Random r=new Random();void q(int[] a){q(a,0,a.length);}void q(int[] a,int b,int e){if(e-b<6){for(int i=b;i<e;i++){for(int j=i;j>0&a[j]<a[j-1];j--){s(a,j,j-1);}}return;}int s=p(a,b,e);q(a,b,s);q(a,s,e);}int p(int[] a,int b,int e){int p=a[r.nextInt(e-b)+b--];while(b<e){do{b++;}while(a[b]<p);do{e--;}while(a[e]>p);if(b<e){s(a,b,e);}}return b;}void s(int[] a,int b,int e){int t=a[b];a[b]=a[e];a[e]=t;}}

সম্পূর্ণ কোড:

public class QuickSort {

    private static final Random RANDOM = new Random();

    public static void quickSort(int[] array) {
        quickSort(array, 0, array.length);
    }

    private static void quickSort(int[] array, int begin, int end) {
        if (end - begin <= 5) {
            for (int i = begin; i < end; i++) {
                for (int j = i; j > 0 && array[j] < array[j - 1]; j--) {
                    swap(array, j, j - 1);
                }
            }
            return;
        }
        int splitIndex = partition(array, begin, end);
        quickSort(array, begin, splitIndex);
        quickSort(array, splitIndex, end);
    }

    private static int partition(int[] array, int begin, int end) {
        int pivot = array[RANDOM.nextInt(end - begin) + begin];
        begin--;
        while (begin < end) {
            do {
                begin++;
            } while (array[begin] < pivot);
            do {
                end--;
            } while (array[end] > pivot);
            if (begin < end) {
                // Make sure they haven't crossed yet
                swap(array, begin, end);
            }
        }
        return begin;
    }

    private static void swap(int[] array, int begin, int end) {
        int temp = array[begin];
        array[begin] = array[end];
        array[end] = temp;
    }

}

Comments

দম্পতির উন্নতি: 1. মেথড শিরোনামের ইন [] এবং এর মধ্যে থাকা ফাঁকা স্থানগুলি থেকে মুক্তি পান। ২. লুপের জন্য শেষ স্থানে কোনও পরিবর্তনশীল অ্যাক্সেসযোগ্যভাবে বৃদ্ধি বা হ্রাস করুন। ৩. নতুন কোন int এর পরিবর্তে বাইটগুলি ব্যবহার করে সংরক্ষণ করতে ক্লাসের ইনট (বা একটি দম্পতি) তৈরি করুন। ৪. ম্যাথ.র্যান্ডম () ব্যবহার করা এবং কাস্টিং কোনও র্যান্ডম অবজেক্ট তৈরির চেয়ে কম হতে পারে।

— নীল

Answer 20

গণিত, 93 90 বাইট

If[Length@#>1,pv=RandomChoice@#;Join[qs2[#~Select~(#<pv&)],{pv},qs2[#~Select~(#>pv&)]],#]&

কোনও বোনাস নেই, সন্নিবেশ সাজানোর কোনও ন্যূনতম উপায় এখনও পান নি। যখন আমি সম্প্রতি সি ++ শিখছিলাম, আমি এখানে বিভিন্ন বাছাই করা অ্যালগরিদমের তুলনা করেছি ।

Answer 21

পাইথন 2, 120 বাইট

def p(a):
 if[]==a[1:]:return a
 b,c,m=[],[],__import__("random").choice(a)
 for x in a:[b,c][x>m]+=[x];return p(b)+p(c)

if[]==a[1:]ঠিক যতক্ষণ লম্বা if len(a)>2তবে আরও গল্ফ লাগছে।

Answer 22

লুয়া, 242 বাইট

function f(t,p)if(#t>0)then local P,l,r,i=math.random(#t),{},{},table.insert p=t[P]for k,v in ipairs(t)do if(k~=P)then i(v<p and l or r,v)end end t={}for k,v in pairs(f(l))do i(t,v)end i(t,p)for k,v in pairs(f(r))do i(t,v)end end return t end

অবহেলিত এবং এক্সপ্লিনেশন

function f(t,p)                                             # Assign 'p' here, which saves two bytes, because we can't assign it to t[P] IN the local group.
    if(#t>0)then                                            # Just return 0 length lists...
        local P,l,r,i=math.random(#t),{},{},table.insert    # Using local here actually makes the a,b=1,2 method more efficient here. Which is unnormal for Lua
        p = t[P]                                            # P is the index of the pivot, p is the value of the pivot, l and r are the sub-lists around the pivot, and i is table.insert to save bytes.
        for k,v in ipairs(t) do                             # We use a completely random pivot, because it's cheaper on the bytes.
            if(k~=P)then                                    # Avoid 'sorting' the pivot.
                i(v<p and l or r,v)                         # If the value is less than the pivot value, push it to the left list, otherwise, push it to the right list.
            end                                             #
        end                                                 #
        t = {}                                              # We can re-use t here, because we don't need it anymore, and it's already a local value. Saving bytes!
        for k,v in pairs(f(l)) do                           # Quick sort the left list, then append it to the new output list.
            i(t,v)                                          #
        end                                                 #
        i(t,p)                                              # Append the pivot value.
        for k,v in pairs(f(r)) do                           # Ditto the right list.
            i(t,v)                                          #
        end                                                 #
    end                                                     #
    return t                                                # Return...
end                                                         #

Answer 23

র‌্যাকেট 121 বাইট

(λ(l)(if(null? l)l(let((h(car l))(t(cdr l)))(append(qs (filter(λ(x)(< x h))t))(list h)(qs (filter(λ(x)(>= x h))t))))))

অবহেলিত (l = তালিকা, এইচ = মাথা (প্রথম উপাদান), টি = লেজ (বিশ্রাম বা অবশিষ্ট উপাদান)):

(define qs
  (λ(l)
    (if (null? l) l
        (let ((h (first l))
              (t (rest  l)))
          (append (qs (filter (λ(x) (< x h) ) t))
                  (list h) 
                  (qs (filter (λ(x) (>= x h)) t))  )))))

পরীক্ষামূলক:

(qs (list 5 8 6 8 9 1 2 4 9 3 5 7 2 5))

আউটপুট:

'(1 2 2 3 4 5 5 5 6 7 8 8 9 9)

Answer 24

জাপট , 23 বাইট

মোট স্কোর পরিশোধের জন্য প্রতিটি বোনাসের তিন বাইট বা তার কম হওয়া দরকার, তাই আমি কোনও বোনাস নিইনি।

Z=Uö;Ê<2?U:ßUf<Z)cßUf¨Z
Z=Uö;                   // Take a random element from the input for partitioning.
     Ê<2                // If the input is shorter than two elements,
        ?U              // return it.
          :             // Otherwise
           ß      ß     // recursively run again
            Uf<Z        // with both items that are smaller than the partition
                   Uf¨Z // and those that are larger or equal,
                )c      // returning the combined result.

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

Comments

20 বাইট

— শেগি