पूर्णांक की स्थिति

Question

चुनौती:

इनपुट:

सकारात्मक पूर्णांकों की क्रमबद्ध सूची।

आउटपुट:

पूर्णांकों की मात्रा, जो अभी भी एक ही सूचकांक पर है, प्रत्येक पूर्णांक में अंकों को घुमाने के बाद अपनी अनुक्रमणिका राशि को बाईं ओर घुमाते हैं और फिर से संशोधित सूची को सॉर्ट करते हैं।

उदाहरण:

इनपुट: [8,49,73,102,259,762,2782,3383,9217,37846,89487,7471788]
आउटपुट (0-आधारित इंडेक्सिंग): 6
आउटपुट (1-आधारित इंडेक्सिंग):5

क्यों?

0-आधारित अनुक्रमण:

After rotating each: [8,94,73,102,592,276,8227,3338,9217,63784,89487,7887471]
Sorted again:        [8,73,94,102,276,592,3338,8227,9217,63784,89487,7887471]

Input indices:        0  1  2   3   4   5    6    7    8     9    10      11
Original input-list: [8,49,73,102,259,762,2782,3383,9217,37846,89487,7471788]
Modified list:       [8,73,94,102,276,592,3338,8227,9217,63784,89487,7887471]
Modified indices:     0  2  1   3   5   4    7    6    8     9    10      11
Equal indices:        ^         ^                      ^     ^     ^       ^

So the output is: 6

1-आधारित अनुक्रमण:

After rotating each: [8,49,37,021,925,762,2278,3383,2179,37846,94878,8874717]
Sorted again:        [8,(0)21,37,49,762,925,2179,2278,3383,37846,94878,8874717]

Input indices:        1  2  3   4   5   6    7    8    9    10    11      12
Original input-list: [8,49,73,102,259,762,2782,3383,9217,37846,89487,7471788]
Modified list:       [8,21,37,49,762,925,2179,2278,3383,37846,94878,8874717]
Modified indices:     1  4  3  2   6   5    9    7    8    10    11      12
Equal indices:        ^     ^                               ^     ^       ^

So the output is: 5

चुनौती नियम:

• इनपुट-सूची की गारंटी केवल सकारात्मक पूर्णांक समाहित करने के लिए है।
• इनपुट-सूची को न्यूनतम से उच्चतम तक क्रमबद्ध करने की गारंटी है।
• इनपुट-सूची में कम से कम दो आइटम होने की गारंटी है।
• जैसा कि आप ऊपर देख सकते हैं, दोनों 0-आधारित और 1-आधारित अनुक्रमण की अनुमति है। कृपया अपने उत्तर में बताएं कि दोनों में से आपने कौन सा प्रयोग किया है, क्योंकि आउटपुट तदनुसार भिन्न हो सकते हैं!
• 0घूर्णन के बाद अग्रणी s को नजरअंदाज कर दिया जाता है, जिसे ऊपर दिए गए 1-आधारित उदाहरण के साथ देखा जा सकता है, जहां पूर्णांक घूर्णन के बाद 102बन जाता है 021, और फिर इसे माना जाता है 21।
• इनपुट-सूची में इंटीग्रर्स की गारंटी अद्वितीय है, और घुमाव पूरा होने के बाद अद्वितीय बने रहने की गारंटी है।
• ध्यान दें कि हम इनपुट के पदों के साथ सहसंबंध में घुमाए गए पूर्णांकों के पदों को देखते हैं, इनपुट-सूची के मूल्यों के साथ नहीं। यह स्पष्ट करने के लिए कि मेरा क्या मतलब है: इनपुट-सूची [1234,3412]और 1-आधारित अनुक्रमण के साथ, सूची [2341,1234]प्रत्येक बार पूर्णांक के घूर्णन के बाद बन जाती है, जो कि सूचकांक की मात्रा है, और फिर जब छांटा जाता है [1234,2341]। यद्यपि दोनों मूल इनपुट-सूची और घुमाई गई सूची में 1234अग्रणी स्थिति में पूर्णांक शामिल हैं, वे समान नहीं हैं! पहले घुमाया 1234गया था 3412। इस इनपुट-सूची के लिए 1-अनुक्रमित आउटपुट इसलिए है 0, क्योंकि दो पूर्णांकों ने अपनी स्थिति बदली है।
• इनपुट लचीला है। पूर्णांक / स्ट्रिंग्स / अंक-सरणियों आदि की एक सूची / स्ट्रीम / सरणी हो सकती है, कृपया बताएं कि आपने क्या उपयोग किया है यदि आप इनपुट को पूर्णांक के रूप में नहीं लेते हैं।

सामान्य नियम:

• यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
  कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव कम उत्तर के साथ आने की कोशिश करें।
• डिफ़ॉल्ट I / O नियमों के साथ आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा फोन।
• डिफ़ॉल्ट ढीले निषिद्ध हैं।
• यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
• साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

परीक्षण के मामलों:

Input: [8, 49, 73, 102, 259, 762, 2782, 3383, 9217, 37846, 89487, 7471788]
0-based output: 6
1-based output: 5

Input: [1234, 3412]
0-based output: 2
1-based output: 0

Input: [2349, 2820, 17499, 21244, 29842, 31857, 46645, 56675, 61643, 61787]
0-based output: 3
1-based output: 0

Input: [4976, 11087, 18732, 22643, 52735]
0-based output: 2
1-based output: 3

Input: [4414, 5866, 7175, 8929, 14048, 16228, 16809, 19166, 24408, 25220, 29333, 44274, 47275, 47518, 53355]
0-based output: 4
1-based output: 4

Input: [11205, 16820, 63494]
0-based output: 1
1-based output: 3

इस बेपनाह 05AB1E कार्यक्रम के साथ (या प्रेरणा लेना) अधिक यादृच्छिक परीक्षण मामलों को उत्पन्न करने के लिए स्वतंत्र महसूस करें , जहां इनपुट यादृच्छिक सूची का आकार है (नोट: इस जनरेटर का उत्पादन नियम का पालन नहीं कर सकता है) इनपुट-सूची, और घुमाव पूरा होने के बाद अद्वितीय बने रहने की गारंटी है ", इसलिए इसका उपयोग करते समय ध्यान रखें)।

Comments

क्या हम मान सकते हैं कि इनपुट में कम से कम 2 तत्व हैं?

— रॉबिन राइडर

@RobinRyder हम्म, मेरा पहला विचार कोई नहीं होगा, लेकिन चूंकि मेरे पास एकल वस्तुओं के साथ कोई परीक्षण मामले नहीं हैं और यह चुनौती के लिए बहुत कुछ नहीं जोड़ेगा, क्यों नहीं। मैं एक नियम जोड़ूंगा कि इनपुट-सूची में कम से कम 2 आइटम शामिल होने की गारंटी है।

— केविन क्रूज़सेन

क्या हम इनपुट को स्ट्रिंग्स की सूची के रूप में स्वीकार कर सकते हैं?

— अज्ञानता का प्रतीक

@ शैगी मैंने उन उत्तरों को अधिसूचित किया है जिनके बारे में मुझे लगा कि इससे लाभ होगा। यदि आपको ऐसा कोई भी दिखाई देता है जो इससे लाभान्वित हो सकता है, तो बेझिझक उन्हें सूचित करें।

— केविन क्रूज़सेन

उदाहरण से ऐसा लगता है कि आउटपुट "पूर्णांक की मात्रा जो अभी भी उसी सूचकांक पर है, प्रत्येक पूर्णांक में अंकों को घुमाने के बाद अपनी अनुक्रमणिका राशि को बाईं ओर घुमाता है , और फिर से सरणी को सॉर्ट करता है "?

— क्वीर

Answer 1

आर , 114 107 बाइट्स

-5 बाइट्स ग्यूसेप के लिए धन्यवाद।

DigEmAll द्वारा बहिष्कृत।

function(l){for(j in seq(l))l[j]=rep(l[j]%/%(e=10^(b=nchar(l[j]):1-1))%%10,j+1)[j+0:b]%*%e
sum(sort(l)==l)}

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

0 अनुक्रमित।

Ungolfed संस्करण:

function(l) {
  n = length(l)                         # size of input
  for (j in 1:n) {  
    b = nchar(l[j]) -1                  # number of digits in l[j] -1
    e = 10 ^ (b:0) 
    d = l[j] %/% e %% 10                # convert to vector of digits
    l[j] = rep(d, j + 1)[j + 0:b] %*% e # rotate digits and convert back to an integer
  }
  sum(sort(l) == l)                     # number of integers which are in the same position
}

bकिसी पूर्णांक के अंकों को jपदों द्वारा घुमाने के लिए , कोड कई बार अंकों को दोहराता है, फिर अंकों को पदों पर ले j+1जाता है j+b। उदाहरण के लिए, 1024 बार घूमने के लिए, x(5 से 7 तक स्थित) मानों को रखें :

102102102102
    xxx

तो परिणाम है 021।

Comments

111 बाइट्स

— ग्यूसेप

@Giuseppe धन्यवाद! मुझे याद रखने की जरूरत है seq(a=...)। मुझे उम्मीद है कि Mapप्रदर्शन करने के लिए कुछ जादू है, लेकिन मेरे प्रयासों ने बाइट की गिनती को सर्वश्रेष्ठ पर अपरिवर्तित छोड़ दिया।

— रॉबिन राइडर

Mapfunctionबॉयलरप्लेट कम से कम 9 बाइट्स के बाद से थोड़ा महंगा हो सकता है , लेकिन यदि आप 0-इंडेक्सिंग पर जाते हैं, तो हम 109 बाइट्स

— Giuseppe

अच्छा खोजो! कि साकार द्वारा नीचे 107 करने के लिए seq(a=l)किया जा सकता है seq(l)जब तक कि इनपुट कम से कम 2 तत्वों (मैंने पूछा कि क्या यह ठीक है) है।

— रॉबिन राइडर

चलो दृष्टिकोण बदलते हैं: डी

— डाइजेक्ले

Answer 2

05AB1E , 9 बाइट्स

ΣN._ï}-_O

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

0-आधारित अनुक्रमण का उपयोग करता है।

स्पष्टीकरण:

Σ    }       # sort the input by
 N._         # each number rotated its index to the left
    ï        # then cast to int (otherwise the sort is alphabetic)
      -      # subtract the input from the result
       _O    # then count the 0s

Answer 3

जाप -x , 10 9 बाइट्स

0-आधारित

í¶UñÈséYn

कोशिश करो

í¶UñÈséYn     :Implicit input of integer array U
í             :Interleave with
  Uñ          :U sorted by
    È         :Passing each integer at 0-based index Y through the following function
     s        :  Convert to string
      é       :  Rotate right by
       Yn     :    Y negated
 ¶            :Reduce each pair by testing for equality
              :Implicit output of sum of resulting array

Answer 4

जेली , 9 बाइट्स

Dṙ"JḌỤ=JS

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

मोनाडिक लिंक जो पूर्णांकों की एक सूची लेता है और पूर्णांक की संख्या को दर्शाता है जो पूर्णांक की संख्या को दर्शाता है जो 1-इंडेक्सिंग का उपयोग करके रोटेशन को निष्पादित करने के बाद जगह में रहता है।

व्याख्या

D         | Convert to decimal digits
 ṙ"J      | Rotate left by index
    Ḍ     | Convert back to integer
     Ụ    | Index in sorted list
      =J  | Check if equal to index in original list
        S | Sum

Answer 5

पायथन 2 , 104 100 97 93 बाइट्स

b=[int((s*-~i)[i:i+len(s)])for i,s in enumerate(input())]
print map(cmp,b,sorted(b)).count(0)

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

0-आधारित अनुक्रमण।

पहले प्रत्येक संख्या को घुमाता है, और फिर परिणाम के साथ परिणाम की तुलना करता है, लेकिन क्रमबद्ध।

---

बचाया:

• -3 बाइट्स, एग्री द आउटग्राफर को धन्यवाद
• -4 बाइट्स, केविन क्रूज़सेन (और उनके नियम-परिवर्तन) के लिए धन्यवाद

Comments

-3 एक पूर्ण कार्यक्रम के रूप में ।

— आउटगॉल्फ को एरिक

@eriktheoutgolfer धन्यवाद, मैं बहुत व्यस्त था मेमने बनाने की कोशिश में, कि मैं भूल गया input():)

— TFeld

इसलिए मैं पहली बार एक पूर्ण कार्यक्रम बनाने की कोशिश करता हूं ...: डी गंभीरता से, यदि आप पहली बार एक पूर्ण कार्यक्रम बनाने की कोशिश करते हैं, तो आप स्पष्ट रूप से देखेंगे कि यह लंबोदर को बदलने के लायक है या नहीं। defसही से शुरू न करें (वे पायथन 2 में बहुत बेकार हैं, पायथन 3 के विपरीत)।

— द एग्री द आउटग्राफर

मैंने इनपुट-सूची को स्ट्रिंग्स के रूप में अनुमति दी है, इसलिए आप आसपास के गंभीर लहजे को हटाकर 4 बाइट छोड़ सकते हैंs ।

— केविन क्रूज़सेन

Answer 6

आर , 90 88 85 बाइट्स

function(x)sum(rank(as.double(substr(strrep(x,L<-sum(x|1)),y<-1:L,y+nchar(x)-1)))==y)

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

• 0-अनुक्रमित रोटेशन
• रोटेशन रणनीति @ RobinRyder के उत्तर से प्रेरित है
• -5 बाइट्स @Giuseppe के लिए धन्यवाद

स्पष्टीकरण के साथ अनियंत्रित कोड:

function(x){
    L=sum(x|1)                         # store the length of x

    R=strrep(x,L)                      # repeat each string of vector x L times

    S=substring(R,1:L,1:L+nchar(x)-1)) # for each string of R, extract a substring of the same 
                                       # length of the original number starting from index 1 
                                       # for the 1st element, index 2 for the 2nd and so on
                                       # (this basically rotates the strings )

    Y=as.double(S)                     # convert the strings to numbers

    sum(rank(Y)==1:L)                  # return the number of times the ranks of Y
                                       # match with their original positions
}

Answer 7

जे , 28 26 बाइट्स

-2 बाइट्स जोनाह को धन्यवाद

1#.i.@#=[:/:#\".@|.&>":&.>

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

Comments

अच्छा लगा। ऐसा लगता है कि आप इसे खो सकते हैं "0( इसे ऑनलाइन आज़माएं! ) लेकिन इसके अलावा मुझे आगे गोल्फ का रास्ता नहीं दिखा।

— जोनाह

@ जॉन धन्यवाद! मुझे नहीं पता कि मैंने इसके बिना कोशिश क्यों नहीं की।

— गैलेन इवानोव

Answer 8

स्टैक्स , 11 10 बाइट्स

ìát'óJ♣á◄·

इसे चलाएं और डीबग करें

यह प्रोग्राम 0-आधारित इंडेक्सिंग का उपयोग करता है और स्ट्रिंग के एक सरणी के रूप में इनपुट लेता है। मैंने नए इनपुट क्लीयरसैप्टिनोस का अवसर लेकर एक बाइट को बचाया।

Answer 9

पर्ल 5 -pa , 80 बाइट्स

map$d{$_.substr$_,0,$b%y///c,''}=$b++,@F;$\+=$d{$_}==$r++for sort{$a-$b}keys%d}{

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

एसटीडीआईएन पर अंतरिक्ष से अलग संख्या के रूप में इनपुट लेता है; 1-आधारित परिणाम देता है।

Answer 10

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

sqVSJ.ev.<`bkQJ

इसे ऑनलाइन आज़माएं! 0-आधारित अनुक्रमण का उपयोग करता है।

sqVSJ.ev.<`bkQJ   Implicit: Q=eval(input())
     .e      Q    Map elements of Q, as b and with index k, using:
          `b        Convert b to string
        .<  k       Rotate the above left k places
       v            Convert back to integer
    J             Store the above as J
   S              Sort the above
 qV           J   Vectorised equality check with the unsorted list
s                 Sum, implicit output

Comments

@FryAmTheEggman अब मैंने इनपुट के रूप में स्ट्रिंग्स की एक सूची की अनुमति दी है, इसलिए अब यह मान्य है।

— केविन क्रूज़सेन

@FryAmTheEggman आप शायद सही हैं, मैंने लेक्सोग्राफिक सॉर्टिंग को पूर्णांक सॉर्टिंग के रूप में नहीं माना होगा जब sकोड को छोड़ते हुए - कोड का मूल संस्करण vउसी प्रभाव के लिए था । मैं इसे वापस संपादित करता हूँ

— सोक

आह, साथ ही केविन बताते हैं कि अब आप बैकलिट को छोड़ सकते हैं और एक बाइट को बचाने के लिए इनपुट को स्ट्रिंग्स की सूची के रूप में ले सकते हैं।

— फ्राइअमईएग्गमैन

Answer 11

एपीएल + विन, 23, 21 19 बाइट्स

2 बाइट्स वर्णों के नेस्टेड वेक्टर के रूप में पूर्णांक इनपुट करके सहेजे गए

+/i=⍋⍎¨(i←⍳⍴v)⌽¨v←⎕

1 अनुक्रमित।

v←⎕ prompt for input. 

(i←⍳⍴v)⌽¨ rotate each set of characters by input indices.

⍋⍎¨ convert characters to integers and get sorted indices.

+/i= sum where original and sorted indices are the same.

इसे ऑनलाइन आज़माएं! दरोगल क्लासिक के सौजन्य से

Comments

सुनिश्चित नहीं है कि यह किसी भी बाइट को बचाएगा, लेकिन मैंने इनपुट को स्ट्रिंग की सूची या अंक-सूची की सूची के रूप में अनुमति दी है।

— केविन क्रूज़सेन

@KevinCruijssen कि बाहर इशारा करने के लिए धन्यवाद। तार के एक नेस्टेड वेक्टर को इनपुट करने से 2 बाइट्स बचते हैं

— ग्राहम

Answer 12

जावास्क्रिप्ट (Node.js) , 107 99 95 बाइट्स

इसके बजाय स्ट्रिंग की सरणी को स्वीकार करने के लिए -8 बाइट्स धन्यवाद @ शगुन। इसके आगे 4 बाइट्स वाली गोल्फ है। इस बार मेमोरी त्रुटि को ट्रिगर नहीं करेगा।

a=>[...b=a.map(F=(x,i)=>i--?F(x.slice(1)+x[c=0],i):x)].sort((p,q)=>q-p).map(x=>c+=x==b.pop())|c

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

जावास्क्रिप्ट (Node.js) , 111 107 बाइट्स

-4 बाइट्स थैंक्स @Arnauld!

a=>[...b=a.map((x,i)=>"".padEnd(x+i,x+=c='').substr(i,x.length))].sort((p,q)=>q-p).map(x=>c-=x==b.pop())|-c

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

जावास्क्रिप्ट (Node.js) , 113 111 बाइट्स

a=>[...b=a.map((x,i)=>"".padEnd(x+i,x).substr(i,`${x}`.length))].sort((p,q)=>p-q).map((x,i)=>x-b[i]||c++,c=0)|c

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

0 अनुक्रमित। बहुत बड़ी प्रविष्टियों के लिए मेमोरी त्रुटि को ट्रिगर कर सकते हैं।

Comments

99 बाइट्स , पूर्णांक स्ट्रिंग्स के एक सरणी के रूप में इनपुट लेते हैं।

— झबरा

@ शागी धन्यवाद, और यह अब 95 बाइट्स है;)

— शायरु असकोटो

Answer 13

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

{sum ^$_ Z==sort {+[~] rotate .[$^i].comb,$i},^$_}

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

0-आधारित अनुक्रमण। साथ ही एक राकोडो बग भी उजागर किया ।

व्याख्या

{                                                }  # Anonymous block
            sort                              ^$_   # Sort indices 0..n
                 {                          },  # by
                              .[$^i]            # element at index i
                                    .comb       # split into chars
                       rotate            ,$i    # rotated i times
                   [~]  # joined
                  +     # converted to number
     ^$_ Z==  # Pairwise equal to original indices 0..n
 sum   # Sum of equal indices

Answer 14

PHP ,159 141 134 130 बाइट्स

function($a){foreach($a as$x){for($j=$i;$j--;$x=substr($x,1).$x[0]);$b[$x]=$i++;}ksort($b);foreach($b as$z)$y+=++$j==$z;return$y;}

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

शून्य-आधारित अनुक्रमण।

Ungolfed:

function( $a ) { 
    // iterate through digits
    foreach( $a as $x ) {
        // rotate the digits the number of times based on their index
        for( $j = $i; $j--; ) {
            // move first digit to last digit
            $x = substr( $x, 1 ) . $x[0];
        }
        // the new number is used as key for sort, value is the original index
        $b[ $x ] = $i++;
    }
    // sort by the new numbers
    ksort( $b );
    // iterate sorted array
    foreach( $b as $z ) {
        // if new index matches original index, increment count ($y)
        if ( ++$j == $z ) {
            $y++;
        }
    }
    return $y;
}

• -4 बाइट्स को इनपुट ऑफ स्ट्रिंग्स के रूप में लिया जाता है, जिसे इंगित करने के लिए @KevinCruijssen को thx करें।

Comments

मैं PHP को बहुत अच्छी तरह से नहीं जानता, लेकिन मैं अब पूर्णांक के बजाय तार की एक सूची की अनुमति देता हूं, इसलिए मुझे लगता है कि आप इसे हटा सकते हैं .=''?

— केविन क्रूज़सेन

@ केविनक्रूजसेन आप सही हैं। स्ट्रिंग्स की एक सरणी के रूप में लेने से यह आवश्यक होने से दूर हो जाएगा। मैं उसी हिसाब से अपडेट करूंगा।

— 640KB

Answer 15

के (कोना) , 25 21bytes

-4 बाइट धन्यवाद ngn करने के लिए!

{+/t=<.:'(t:!#x)!'$x}

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

Comments

{.:y!x}'[$x;t:!#x]->.:'(t:!#x)!'$x

— ngn

@ngn धन्यवाद, यह अब बेहतर है!

— गैलेन इवानोव

Answer 16

टी-SQL क्वेरी, 99 बाइट्स

Sql की कोई घूर्णन विधि नहीं है, इसलिए मुझे अपना सिंटैक्स लागू करना पड़ा, क्योंकि यह एक क्वेरी है, इसे बिना लूपिंग के किया जाना था।

0-आधारित अनुक्रमण।

इनपुट के रूप में एक टेबल चर का उपयोग करना।

SELECT-sum(1/~(z*3))FROM(SELECT~i+rank()over(order by
substring(n+n,i%len(n)+1,len(n))*1)z FROM @)c

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

Answer 17

आइकन , 141 बाइट्स

procedure f(l)
n:=0
b:=[]
t:=l[k:=1to*l]&m:=k%*t&t:=t[m+1:0]||t[1:m+1]&put(b,[+t,l[k]])&\x
l[i:=1to*l]=sortf(b,1)[i,2]&n+:=1&\x 
return n
end

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

1-आधारित अनुक्रमण

Answer 18

पर्ल 5 , 104 बाइट्स

sub f{my$i;grep/\d+$/&&$i++==$&,sort{$a<=>$b}map{my$n=shift;map$n=~s/(.)(.+)/$2$1/,1..$_;"$n.$_"}0..$#_}

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

0-पर्ल में अनुक्रमण आधारित है। असंबद्ध और टिप्पणी:

sub f {
  my $i;                            #index counter
  grep /\d+$/ && $i++==$&,          #keep/return elems where $i matches original index stored as decimals
  sort { $a<=>$b }                  #sort rotated elems numerically (<=> is the numerical comparison op
  map {                             #loop through input
    my $n = shift;                  #shift(@_) got elem from input array @_
    map $n=~s/(.)(.+)/$2$1/, 1..$_; #rotate left times current index 
    "$n.$_"                         #use rotated number with original index number as decimals (to dont affect sort)
  }
  0..$#_
}

Answer 19

रूबी -ap , 77 बाइट्स

1 अनुक्रमित। क्या पहले टेम्प को हटा दिया गया था क्योंकि मैं कल्पना का हिस्सा नहीं रह गया था।

-pSTDIN की एक पंक्ति पढ़ता है, और $_अंत में आउटपुट करता है। -aस्प्लिट्स जो रिक्त स्थान द्वारा लाइन पढ़ता है और इसे सहेजता है $F।

i=0
$_=$F.zip($F.sort_by{|s|s.chars.rotate(i+=1).join.to_i}).count{|a,b|a==b}

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

Comments

आप की जगह 2 बाइट्स बचा सकता है [...].join.to_iके साथeval [...]*''

— दरवाज़े

@Doorknob दुर्भाग्य से नहीं ... ऐसे किनारे मामले हैं जहां अगर किसी संख्या को एक अग्रणी शून्य होने के लिए घुमाया जाता है, तो evalइसे आधार -8 नंबर के रूप में व्याख्या किया जाएगा, जो हमारे मायने रखता है ...

— मूल्य इंक

Answer 20

वोल्फ्राम भाषा (गणितज्ञ) , 65 बाइट्स

o=Ordering
g=Count[o@MapIndexed[FromDigits@*RotateLeft,#]-o@#,0]&

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

1 के आधार पर। हम इनपुट को अंकों की सूची की सूची के रूप में लेते हैं, जो काम करता है क्योंकि गणितज्ञ लंबाई द्वारा सूचियों का आदेश देता है, फिर लेक्सिकोग्राफ़िक रूप से, यानी मूल संख्याओं की तरह।

Answer 21

बैश , 204 201 बाइट्स

यहाँ केवल दिलचस्प बात (संभवतः) का उपयोग है eval। एल्गोरिथ्म इस मायने में भी क्लिंकी है कि यह एक क्रमबद्ध सूची बनाता है, फिर बदले हुए सूचकांक / सूचकांकों को निर्धारित करने के लिए इसे पढ़ता है।

1-आधारित समाधान। मददगार रोटेशन एल्गोरिथ्म के लिए @RobinRyder को मेरा धन्यवाद।

for((i=1;i<$#+1;i++));do eval s=\${$i};for((j=0;j<i;j++));do eval s=${s}\${$i};done;eval n=\${s:$i:\${#$i}};echo $n $i;done|sort -nk1,1|{ i=1;c=0;while read d j;do((i==j))&&((c++));((i++));done;echo $c; }

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

केविन की टिप्पणियों के बाद संशोधित कोड; इसे ऑनलाइन आज़माएं!

Comments

मैं बैश को भी अच्छी तरह से नहीं जानता, लेकिन मुझे लगता है कि आप बीच में आखिरी जगह निकाल सकते हैं ;}। इसके अलावा, आप अपने पहले लूप को बदल सकते हैं for((i=0;++i<=$#;));।

— केविन क्रूज़सेन

@ केविनक्रूजसेन - आमतौर पर मुझे बैश मिला है और दोस्तों को कमांड लाइन को पार्स करने के लिए उस स्थान की आवश्यकता है। इस अवसर पर आप सही हैं इसे हटाया जा सकता है। फिर से आधार और पूर्व-वृद्धि के लिए अच्छा विचार है। 202 बाइट्स।

— PJF

Answer 22

स्काला , 200 160 बाइट्स

def f(a:Seq[String])=
  a.zipWithIndex
   .map(x=>{val r=x._2%x._1.size;x._1.drop(r)+x._1.take(r)->x._2})
   .sortBy(_._1.toInt)
   .zipWithIndex
   .filter(x=>x._1._2==x._2)
   .size

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

0 अनुक्रमित। इंडेंटेशन और न्यूलाइन्स हटाने के बाद 160 चार्ज। यह प्रिंट 6:

println( f(Seq("8","49","73","102","259","762","2782","3383","9217","37846","89487","7471788")) )