ब्रेनएफ में सबसे तेज़ सॉर्ट ***


15

ब्रेनएफ *** में क्विकसॉर्ट लागू करने के बाद , मैंने महसूस किया कि यह शायद इतनी जल्दी नहीं था। सामान्य भाषाओं (जैसे एरे इंडेक्सिंग) में ओ (1) वाले ऑपरेशन बीएफ में काफी लंबे होते हैं। जब आप ट्यूरिंग टारपिट में कोडिंग कर रहे हों, तो एक कुशल सॉर्ट बनाने वाले अधिकांश नियम खिड़की से बाहर फेंक दिए जा सकते हैं

इसलिए यहां "फास्टेस्ट ब्रेनएफ *** सॉर्ट रूटीन एवर" को लागू करना एक चुनौती है। मैं नीचे दुभाषिया का उपयोग करके सभी प्रविष्टियों को समय दूंगा। इंट्रप्टर में अहस्ताक्षरित वर्णों के 16K टेप का उपयोग किया जाता है। टेप और कोशिकाएं तब लपेटती हैं जब उन्नत / बढ़ा हुआ सीमा से अधिक होता है। ईओएफ पढ़ना वर्तमान सेल में 0 डालता है। मापा समय में स्रोत फ़ाइल को पार्स करने का समय और सभी इनपुट फ़ाइलों को संसाधित करने का समय शामिल है। सबसे तेज कोड जीतता है।

परीक्षण वेक्टर असिसी फाइलों का एक सेट होगा, जिसमें छंटनी के किनारे के मामलों का परीक्षण किया जाएगा

  • पहले से ही क्रमबद्ध सूची: "आदेशित"

    &#33;"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
    
  • एक रिवर्स सॉर्ट की गई सूची: "रिवर्स"

    ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!
    
  • कुछ विशिष्ट मूल्यों की कई प्रतियों से मिलकर एक फाइल: "केवल"

    ibbkninbkrauickabcufrfckbfikfbbakninfaafafbikuccbariauaibiraacbfkfnbbibknkbfankbbunfruarrnrrrbrniaanfbruiicbuiniakuuiubbknanncbuanbcbcfifuiffbcbckikkfcufkkbbakankffikkkbnfnbncbacbfnaauurfrncuckkrfnufkribnfbcfbkbcrkriukncfrcnuirccbbcuaaifiannarcrnfrbarbiuk
    
  • एक पूरी तरह से यादृच्छिक ascii फ़ाइल: "यादृच्छिक"

    'fQ`0R0gssT)70O>tP[2{9' 0.HMyTjW7-!SyJQ3]gsccR'UDrnOEK~ca 'KnqrgA3i4dRR8g.'JbjR;D67sVOPllHe,&VG"HDY_'Wi"ra?n.5nWrQ6Mac;&}~T_AepeUk{:Fwl%0`FI8#h]J/Cty-;qluRwk|S U$^|mI|D0\^- csLp~`VM;cPgIT\m\(jOdRQu#a,aGI?TeyY^*"][E-/S"KdWEQ,P<)$:e[_.`V0:fpI zL"GMhao$C4?*x
    
  • 1..255 पर एक यादृच्छिक फ़ाइल: "व्होलरेंज"

    öè—@œ™S±ü¼ÓuǯŠf΀n‚ZÊ,ˆÖÄCítÚDý^öhfF†¬I÷xxÖ÷GààuÈ©ÈÑdàu.y×€ôã…ìcÑ–:*‰˜IP¥©9Ä¢¬]Š\3*\®ªZP!YFõ®ÊÖžáîÓ¹PŸ—wNì/S=Ìœ'g°Ì²¬½ÕQ¹ÀpbWÓ³
    »y  »ïløó„9k–ƒ~ÕfnšÂt|Srvì^%ÛÀâû¯WWDs‰sç2e£+PÆ@½ã”^$f˜¦Kí•òâ¨÷ žøÇÖ¼$NƒRMÉE‹G´QO¨©l¬k¦Ó 
    

प्रत्येक इनपुट फ़ाइल में अधिकतम 255 बाइट्स हैं।

यहाँ दुभाषिया है। यह कंसोल-मोड विंडोज के लिए लिखा गया है, लेकिन इसे पोर्ट करना आसान होना चाहिए: बस प्रतिस्थापित करें read_time()और sysTime_to_ms()प्लेटफॉर्म-विशिष्ट समकक्षों के साथ।
उपयोग: bftime program.bf infile1 [infile2 ...]

#include <windows.h>
#include <stdio.h>

#define MS_PER_SEC  1000.0f
#define MAXSIZE  (0x4000)
#define MAXMASK  (MAXSIZE-1)

typedef  __int64 sysTime_t;
typedef unsigned char Uint8;
typedef unsigned short Uint16;

typedef struct instruction_t {
   Uint8 inst;
   Uint16 pair;
} Instruction;

Instruction prog[MAXSIZE] = {0};
Uint8 data[MAXSIZE] = {0};
const Uint8 FEND = EOF;

sysTime_t read_time() {
    __int64 counts;
    QueryPerformanceCounter((LARGE_INTEGER*)&counts);
    return counts;
}

float sysTime_to_ms(sysTime_t timeIn) {
    __int64 countsPerSec;
    QueryPerformanceFrequency((LARGE_INTEGER*)&countsPerSec);
    return (float)timeIn * MS_PER_SEC / (float)countsPerSec;
}

int main(int argc, char* argv[])
{
   FILE* fp;
   Uint8 c;
   Uint16 i = 0;
   Uint16 stack = 0;
   sysTime_t start_time;
   sysTime_t elapsed=0,delta;

   if (argc<3) exit(printf("Error: Not Enough Arguments\n"));
   fp = fopen(argv[1],"r");
   if (!fp) exit(printf("Error: Can't Open program File %s\n",argv[1]));

   start_time=read_time();
   while (FEND != (c = fgetc(fp)) && i <MAXSIZE) {
      switch (c)  {
      case '+': case '-': case ',': case '.': case '>': case '<':
         prog[++i].inst = c;
         break;
      case '[': 
         prog[++i].inst = c;
         prog[i].pair=stack;
         stack = i;
         break;
      case ']': 
         if (!stack) exit(printf("Unbalanced ']' at %d\n",i));
         prog[++i].inst = c;
         prog[i].pair=stack;
         stack = prog[stack].pair;
         prog[prog[i].pair].pair=i;
         break;
      }
   }
   if (stack) exit(printf("Unbalanced '[' at %d\n",stack));
   elapsed = delta = read_time()-start_time;
   printf("Parse Time: %f ms\n", sysTime_to_ms(delta));

   for (stack=2;stack<argc;stack++) {
      Instruction *ip = prog;
      fp = fopen(argv[stack],"r");
      if (!fp) exit(printf("Can't Open input File %s\n",argv[stack]));
      printf("Processing %s:\n", argv[stack]);
      memset(data,i=0,sizeof(data));

      start_time=read_time();
      //Run the program
      while (delta) {
         switch ((++ip)->inst) {
         case '+': data[i]++; break;
         case '-': data[i]--; break;
         case ',': c=getc(fp);data[i]=(FEND==c)?0:c; break;
         case '.': putchar(data[i]);  break;
         case '>': i=(i+1)&MAXMASK;   break;
         case '<': i=(i-1)&MAXMASK;   break;
         case '[': if (!data[i]) ip = prog+ip->pair; break;
         case ']': if (data[i])  ip = prog+ip->pair;  break;
         case 0: delta=0; break;
         }
      }
      delta = read_time()-start_time;
      elapsed+=delta;
      printf("\nProcessing Time: %f ms\n", sysTime_to_ms(delta));
   }
   printf("\nTotal Time for %d files: %f ms\n", argc-2, sysTime_to_ms(elapsed));
}

परिणाम तो बहुत दूर

यहाँ वैक्टर के पूरे सेट के 5 रन का औसत समय है:

 Author    Program      Average Time    Best Set          Worst Set
 AShelly   Quicksort    3224.4 ms       reverse (158.6)   onlynine (1622.4) 
 K.Randall Counting     3162.9 ms       reverse (320.6)   onlynine  (920.1)
 AShelly   Coinsort      517.6 ms       reverse  (54.0)   onlynine  (178.5) 
 K.Randall CountingV2    267.8 ms       reverse  (41.6)   random     (70.5)
 AShelly   Strandsort    242.3 ms       reverse  (35.2)   random     (81.0)

इनपुट तत्वों की सीमा क्या है?
कीथ रान्डेल

यह कोशिकाओं की सीमा है, 0: 1-255 को छोड़कर।
AShelly

आपको मेरा पीछा करना चाहिए, मैंने इसे काफी तेज कर दिया।
कीथ रान्डेल

यह मेरी सबसे हालिया की तुलना में 2x से अधिक तेज प्रतीत होता है - मैं आधिकारिक समय पर करूंगा जब मैं मशीन पर वापस आऊंगा जो मैंने दूसरों के लिए उपयोग किया था।
एएसहेल्ली

जवाबों:


9

यहां एक प्रकार है जो मेरे क्विकॉर्ट से कम से कम 6x तेज है। यह एक एल्गोरिथ्म है जो पारंपरिक भाषा में बहुत कम समझ में आता है, क्योंकि यह O (N * m) है जहाँ m अधिकतम इनपुट मान है। इनपुट एकत्र करने के बाद, यह सरणी से होकर गुजरता है, कोशिकाओं की गिनती करता है> 0 और फिर प्रत्येक को घटाता है। यह countपरिणाम वेक्टर में पहली कोशिकाओं में 1 जोड़ता है । जब तक गिनती 0.
बीएफ है तब तक यह दोहराता है :

Get Input
>,[>>+>,]   
Count values GT 0 and decrement each
<[<[<<<+>>>-]<[-<<+>>>]>[<]<<]
While count: add 1 to results
<[[[<<+>>-]<+<-]
Seek back to end of input
>[>>]>>>[>>>]
Repeat counting step
<<<[<[<<<+>>>-]<[-<<+>>>]>[<]<<]<]
Seek to far end of results and print in reverse order 
<[<<]>>[.>>]

C समतुल्य एल्गोरिदम:

 uchar A[MAX]={0}; uchar R[MAX]={0}; int count,i,n=0;
 while (A[n++]=getchar()) ;
 do { 
   count = 0;
   for (i=0; i<n; i++) count += (A[i]) ? (A[i]-->0) : 0;
   for (i=0; i<count; i++) R[i]++; 
 } while (count>0);
 for (i=0; R[i]; i++) ;
 for (i--; i>=0; i--) putchar(R[i]);

यहां एक है जो 2x जितना तेज है। यह "स्पेगेटी सॉर्ट" पर शिथिल आधारित है : यह प्रत्येक इनपुट के रूप में 1 एस के एक स्ट्रिंग को नीचे देता है। प्रत्येक सेल में मान कम से कम उस लंबे समय तक किस्में की संख्या का प्रतिनिधित्व करता है। (तो - 3,2,1,2] बन जाता है |4|0|3|0|1|0|0|)। फिर यह स्ट्रैंड्स को 'मापना' शुरू कर देता है और हर बार एक के सिरे को ढूंढते हुए लंबाई को प्रिंट करता है।

>,[ [-[>>+<<-]>+>] <[<<]>,]   build strand of 1s for each input
+>[>+<-]>[                    while there are strands
  >[>+<<->-]                  do any strands end here?
  <[<<.>>-]                   print length of all that do  
  <<[>>+<<-]>>+>>]            shift right 1; inc length 

कच्चा:

>,[[-[>>+<<-]>+>]<[<<]>,]+>[>+<-]>[>[>+<<->-]<[<<.>>-]<<[>>+<<-]>>+>>]

मत गिनना मत! यह मेरा पसंदीदा प्रकार है, मुझे एक बार मिली भारी जीत के कारण: यदि मी को छोटा जाना जाता है, तो आप अन्यथा "तेज" एल्गोरिदम पर भारी गति प्राप्त कर सकते हैं। इसी तरह, बबल सॉर्ट ज्यादातर सॉर्ट किए गए डेटा पर क्विकॉर्ट धड़कता है। कोई भी ___ एल्गोरिदम हर संदर्भ के लिए सबसे अच्छा है।
बूथबाई

मुझे नहीं लगता कि यह वास्तव में एक गिनती की तरह है। आपकी टिप्पणी ने मुझे कुछ और शोध करने के लिए मजबूर किया। मुझे लगता है कि यह बीड की तरह है । लेकिन मुझे यकीन भी नहीं है कि यह सही है।
ऐशली

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

4
भौतिक सादृश्य यह है कि आपके पास विभिन्न आकारों के सिक्कों के एन ढेर हैं। एक और एन ढेर के लिए अलग जगह सेट करें। आप प्रत्येक स्टैक के शीर्ष पर एक सिक्का लेते हैं जिसमें सिक्के होते हैं, और फिर नए सेट में प्रत्येक स्टैक को दाईं से बाईं ओर तब तक जोड़ते हैं जब तक कि आपका हाथ खाली न हो। तब तक दोहराएं जब तक सभी मूल ढेर खाली न हो जाएं। अब नया सेट बाएं से दाएं की ओर चढ़ता है।
एएसएचली

7
>>+>,[->+>,]<[<[<<]<[.<[<<]<]>>[+>->]<<]

मुझे याद नहीं है कि यह आइडिया किसका था। शायद बर्ट्रम फेलगेनह्यूअर? यह एक दशक पहले ब्रेनफॉक गोल्फ प्रतियोगिता # 2 के आसपास चर्चा से आया था।

यह नमूना आदानों पर अभी तक का सबसे तेज है।

यह लंबाई <256 के इनपुट तक सीमित नहीं है, लेकिन मनमाने ढंग से लंबे इनपुट को संभाल सकता है।

ये दोनों बातें नीचे, अल्बर्ट के उत्तरों के बारे में भी सच थीं। इस एक के बारे में अच्छी बात यह है कि इनपुट लंबाई में चलने का समय ओ (एन) है। हां, यह बात वास्तव में रैखिक समय में चलती है। यह पहले से ही नाश्ते के रूप में 255 का एक निरंतर कारक खाया।


3

एक सरल गणना प्रकार कार्यान्वयन। प्रत्येक बाल्टी 3 कोशिकाएं विस्तृत होती हैं, जिसमें वर्तमान इनपुट, एक मार्कर होता है, और इनपुट में काउंटर की संख्या की संख्या दिखाई देती है।

process input
,[

while input is not zero
[

decrement input
-

copy input over to next bucket
[->>>+<<<]

mark next bucket as not the first
>>>>+<

repeat until input is zero
]

increment count for this bucket
>>+

rewind using markers
<[-<<<]<

process next input
,]

generate output
>+[>[<-.+>-]<[->>>+<<<]>>>+]

बिना टिप्पणी के:

,[[-[->>>+<<<]>>>>+<]>>+<[-<<<]<,]>+[>[<-.+>-]<[->>>+<<<]>>>+]


हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.