फास्ट टॉपस्ॉप्स की गणना

Question

से AZSPCS :

मान लीजिए कि आपके पास एक डेक है जिसमें n कार्ड हैं। प्रत्येक कार्ड में 1 से n तक की संख्या होती है, और प्रत्येक संख्या बिल्कुल एक कार्ड पर दिखाई देती है। आप शीर्ष कार्ड पर संख्या को देखते हैं - मान लें कि यह k है - और फिर शीर्ष k कार्ड के क्रम को उल्टा करें। आप इस प्रक्रिया को जारी रखते हैं - शीर्ष संख्या को पढ़ते हैं और फिर कार्ड की संगत संख्या को उलट देते हैं - जब तक कि शीर्ष कार्ड 1 नहीं हो जाता।

किसी दिए गए डेक के लिए रिवर्सल की संख्या की गणना करने के लिए सबसे तेज़ प्रोग्राम लिखें। ध्यान दें कि यदि आप प्रतियोगिता में भाग ले रहे हैं तो आपको अपना कोड पोस्ट करने की अनुमति नहीं है (और इस तरह मैं अपना कोड अभी पोस्ट नहीं करूँगा)।

Comments

इनपुट / आउटपुट मॉडल क्या है? कोई भाषा प्रतिबंध? आप कैसे निर्धारित करेंगे कि प्रत्येक प्रविष्टि कितनी तेज़ है?

— आआआआआआआआआआ आआआआआ

वहाँ azspcs के लिए एक समर्पित स्टैटेक्सचेंज हो सकता है;)

— बारह

तो क्या हमें समाधान पोस्ट करने की अनुमति है या नहीं?

— एशेल्ली

हाँ। प्रतियोगिता समाप्त हो गई है।

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

Azspcs का लिंक उस पृष्ठ से लिंक होता है जो क्रम से बाहर है। और यह एक मेटा-टैग लगता है, जो पहेली का वर्णन नहीं करता है। टैग को, शायद, हटा दिया जाना चाहिए।

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

Answer 1

जावास्क्रिप्ट

function(d){for(t=0;x=(n=d[0])-1;t++)for(i=0;i<n/2;i++){m=d[x-i];d[x-i]=d[i];d[i]=m}return t}

आप इसे डेक पास करते हैं, जैसे:

f([3, 2, 1]) // 1
f([2, 3, 1]) // 2
f([1, 2, 3]) // 0

Comments

तो तुम विजेता हो! :)

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

Answer 2

स्काला: (यह गोल्फ नहीं है - क्या यह है?)

def transform (l: List[Int], sofar: Int = 0) : Int =
  if (l(0) == 1) sofar else transform (l.take (l(0)).reverse ::: l.drop (l(0)), sofar + 1)

डेक के फेरबदल सहित टेस्टकेस और स्टॉपवॉच के साथ पूरा आवेदन:

object DeckReverse extends Application {

  def transform (l: List[Int], sofar: Int = 0) : Int = 
    if (l(0) == 1) sofar else transform (l.take (l(0)).reverse ::: l.drop (l(0)), sofar + 1)

  def stopwatch (count: Int, size: Int) = {
    val li = (1 until size).toList 
    val r = util.Random 

    val start = System.currentTimeMillis ()
    (0 until count).foreach (_ => transform (r.shuffle (li)))
    val stop = System.currentTimeMillis ()

    println ("count: " + count + "\tsize: " + size + "\tduration: " + (stop - start) + " msecs") 
  }

  stopwatch (1000, 100)
}

गणना: 1000 आकार: 100 अवधि: 1614 मिसे मशीन: एकल पेंटियम एम 2 जीज़

Answer 3

पायथन, 84 चार्ट

वैसे भी गोल्फ ... मैं n-1 के माध्यम से संख्या 0 का उपयोग कर रहा हूं। मान लिया गया है कि सरणी को चर x में संग्रहीत किया गया है, यह मुझे अजगर के 84 वर्ण लेता है।

while x[0]:x[:x[0]+1]=x[x[0]::-1]

हालाँकि, मेमोरी के दुरुपयोग के कारण प्रदर्शन बहुत खराब है।

Answer 4

सी

int revno(int* deck, int n) {
  int k,j,r=0;
  for(;;) {
    k=*deck;
    if (k==1) {
      return r;
    }
    for (j=0; j<k/2; j++) {
      int tmp=deck[j];
      deck[j]=deck[k-j];
      deck[k-j]=tmp;
    }
    r++;
  }
}

deckएक पूर्णांक सरणी के लिए एक सूचक है जो डेक का प्रतिनिधित्व करता है। nकार्ड की संख्या है। स्पष्ट रूप से मेमोरी सुरक्षा कॉल करने वाले का कार्य है।

यह शायद हाल के कंप्यूटरों पर और एक उच्च-स्तरीय भाषा में सबसे तेज़ एल्गोरिथम के पास है। केवल एशम-स्तरीय ट्रिक्स के साथ इसे तेजी से बनाया जा सकता है, लेकिन इनके साथ भारी भी नहीं।

Answer 5

पर्ल 5 , 58 + 2 (-प) = 60 बाइट्स

++$\&&(@F[0..$F[0]-1]=reverse@F[0..$F[0]-1])while$F[0]-1}{

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