कुल स्लॉट की गणना

17

नौकरियों की एक सूची दी गई है, जो क्रम में किया जाना चाहिए, प्रत्येक करने के लिए एक स्लॉट लेने के साथ, यह कितना समय लगेगा अगर सभी काम करने के बाद एक ही काम अगले दो स्लॉट के लिए नहीं किया जा सकता है (स्लॉट्स को ठंडा करना) )? हालांकि, इस कूलिंग ऑफ स्लॉट में एक अलग काम सौंपा जा सकता है।

उदाहरण के लिए,

[9,10,9,8] => output: 5

क्योंकि नौकरियों के रूप में आवंटित किया जाएगा [9 10 _ 9 8]।
1. सबसे पहले, 9 को दो कूलिंग ऑफ स्पॉट _ _ की जरूरत है। तो हम शुरुआत करते हैं 9 _ _।
2. अगली नौकरी 10 पिछली नौकरी 9 से अलग है, इसलिए हम _ _ में से एक को आवंटित कर सकते हैं। फिर हमारे पास होगा 9 10 _।
3. तीसरा, 9 अब आवंटित नहीं किया जा सकता है, क्योंकि पहली नौकरी 9 एक ही काम है और इसे समय पर ठंडा करने की आवश्यकता है। 9 10 _ 9।
4. अंतिम, 8 किसी भी अन्य पिछले दो नौकरियों के समान नहीं है, इसलिए इसे 9 के ठीक बाद आवंटित किया जा सकता है और चूंकि यह अंतिम नौकरी है, इसलिए इसे समय पर ठंडा करने की आवश्यकता नहीं है। अंतिम सूची है 9 10 _ 9 8और अपेक्षित आउटपुट 5 है, जो स्पॉट की संख्या (या स्लॉट की संख्या) है

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

[1,2,3,4,5,6,7,8,9,10] => output : 10 ([1 2 3 4 5 6 7 8 9 10])
[1,1,1] => output: 7 ([1 _ _ 1 _ _ 1])
[3,4,4,3] => output: 6 ([3 4 _ _ 4 3])
[3,4,5,3] => output: 4 ([3 4 5 3])
[3,4,3,4] => output : 5 ([3 4 _ 3 4])
[3,3,4,4] => output : 8 ([3 _ _ 3 4 _ _ 4])
[3,3,4,3] => output : 7 ([3 _ _ 3 4 _ 3])
[3,2,1,3,-4] => output : 5 ([3 2 1 3 -4])
[] => output : 0 ([])
[-1,-1] => output : 4 ([-1 _ _ -1])

इनपुट मान कोई भी पूर्णांक (ऋणात्मक, 0, धनात्मक) हो सकता है। नौकरी-सूची की लंबाई 0 <= लंबाई <= 1,000,000 है।
आउटपुट एक पूर्णांक होगा, स्लॉट्स की कुल संख्या, जो आउटपुट के रूप में परीक्षण के मामले में इंगित की गई है। कोष्ठक के अंदर की सूची है कि आउटपुट कैसे उत्पन्न होगा।

कसौटी कोड-गोल्फ जीतना

code-golf  number  array-manipulation 
— jayko03
स्रोत
क्या यह ठीक है अगर हम 0 के बजाय कुछ भी आउटपुट नहीं करते हैं []?
— बंजर भूमि
8
क्या उत्तर स्वीकार करना थोड़ा जल्दी नहीं है?
— निक केनेडी
7
जैसा कि @NickKennedy ने कहा, यह बहुत दूर है, बहुत जल्द एक समाधान स्वीकार करने वाला है। कुछ लोग सलाह भी देते हैं कि किसी समाधान को स्वीकार न करें ।
— झबरा

जवाबों:

5

05AB1E , 22 बाइट्स

v¯R¬yQiõˆ}2£yåiˆ}yˆ}¯g

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

v           # Loop over the integers `y` of the (implicit) input-list:
 ¯R         #  Push the global_array, and reverse it
   ¬        #  Get the first item (without popping the reversed global_array itself)
    yQi  }  #  If it's equal to the integer `y`:
       õˆ   #   Add an empty string to the global_array
   2£       #  Then only leave the first 2 items of the reversed global_array
     yåi }  #  If the integer `y` is in these first 2 items:
        ˆ   #   Add the (implicit) input-list to the global_array
 yˆ         #  And push the integer `y` itself to the global_array
}¯g         # After the loop: push the global array, and then pop and push its length
            # (which is output implicitly as result)
— केविन क्रूज़सेन
स्रोत
वैश्विक क्षेत्र क्या है? क्या यह कार्यक्रम के शुरू होने पर खाली है?
— अज्ञानता का अवतार
@EmbodimentofIgnorance हाँ, यह एक एकल सरणी है जिसमें मैं कुछ जोड़ सकता हूं, जिसे मैं धक्का दे सकता हूं, और जिसे मैं स्पष्ट कर सकता हूं। और यह वास्तव में शुरू में खाली शुरू होता है।
— केविन क्रूज़सेन
3

ब्रेकीलॉग , 10 बाइट्स

समस्या को देखना हमेशा अच्छा होता है, जहां ब्रेजलॉग सर्वश्रेष्ठ प्रदर्शन करते हैं

⊆Is₃ᶠ≠ᵐ∧Il

व्याख्या

⊆I           # Find the minimal ordered superset of the input (and store in I) where:
   s₃ᶠ       #     each substring of length 3
      ≠ᵐ     #     has only distinct numbers
        ∧Il  # and output the length of that superset

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

— Kroppeb
स्रोत
2

आर , 123 बाइट्स

`-`=nchar;x=scan(,'');while(x!=(y=gsub("([^,]+),(([^,]*,){0,1})\\1(,|$)","\\1,\\2,\\1\\4",x)))x=y;-gsub("[^,]","",y)+(-y>1)

इसे ऑनलाइन आज़माएं - एकल कार्यक्रम!

इसे ऑनलाइन आज़माएं - कई उदाहरण!

एक पूर्ण प्रोग्राम जो इनपुट के रूप में पूर्णांक की अल्पविराम से अलग की गई सूची को पढ़ता है, और आवश्यक स्लॉट को आउटपुट करता है। मुझे यकीन है कि यह कुछ और गोल्फ हो सकता है, और कुछ अन्य भाषाओं में इस रेगेक्स-आधारित समाधान को लागू करना बाइट्स में अधिक कुशल होगा।

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

— निक केनेडी
स्रोत
2

TSQL क्वेरी, 158 बाइट्स

एक तालिका के रूप में इनपुट डेटा।

क्वेरी पुनरावर्ती है

विकल्प (MAXRECURSION 0)

आवश्यक है, क्योंकि संख्याओं की सूची 100 से अधिक हो सकती है, हालांकि यह केवल 32,767 पुनरावर्ती संभाल सकती है - क्या इस कार्य में सीमा की वास्तव में आवश्यकता है?

DECLARE @ table(a int, r int identity(1,1))
INSERT @ VALUES(3),(3),(4),(4);

WITH k as(SELECT null b,null c,1p
UNION ALL
SELECT iif(a in(b,c),null,a),b,p+iif(a in(b,c),0,1)FROM @,k
WHERE p=r)SELECT sum(1)-1FROM k
OPTION(MAXRECURSION 0)

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

— t-clausen.dk
स्रोत
2

आर , 81 70 बाइट्स

sum(l<-rle(s<-scan())$l*3-3,1-l%/%6,((r=rle(diff(s,2)))$l+1)%/%2*!r$v)

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

कई असफल प्रयासों के बाद, कोड बल्कि बदसूरत हो गया और इतना छोटा नहीं था, लेकिन कम से कम अब यह काम करता है ...

पहले, हम एक ही काम के लगातार रन की लंबाई का मूल्यांकन करते हैं। इसके लिए उदाहरण 3, 3, 4, 3देता है:

Run Length Encoding
  lengths: int [1:3] 2 1 1
  values : num [1:3] 3 4 3

इनमें से प्रत्येक रन (len - 1) * 3 + 1चरणों का उत्पादन करता है (+ 1 अलग से नियंत्रित किया जाता है)।

अगला, हम एक ही काम के स्थानों को 2 स्थानों से अलग करते हैं, जैसे:, x, y, xका उपयोग करके diff(s, lag=2)। परिणामी वेक्टर को फ़ंक्शन rद्वारा लगातार रन ( ) में चंक किया जाता rleहै। अब, विभिन्न इंटरलेक्टिव विकल्प के कारण हमें जोड़ने की आवश्यकता हैceiling(r$len/2) शून्य के सभी रनों के लिए चरणों । उदाहरण के लिए:

x y x(लंबाई 1) और x y x y(लंबाई 2) दोनों को 1 अतिरिक्त चरण की आवश्यकता है:x y _ x (y)

x y x y x(लंबाई 3) और x y x y x y(लंबाई 4) दोनों को 2 अतिरिक्त चरणों की आवश्यकता है:x y _ x y _ x (y)

अंत में, हमें एक ही नौकरी के लंबे समय के बीच में इन बारी-बारी से होने वाली घटनाओं की भरपाई करने की आवश्यकता है: x, x, x, x...इसलिए 1-l%/%6केवल इसके बजाय 1।

— किरिल एल।
स्रोत
मैं diff(s,lag=2)निकटता का पता लगाने के लिए उपयोग करने के बारे में टिप्पणी करने के बीच में था ! अब तुम मेरे समाधान से एक बाइट कम हो ...
— Giuseppe
हाँ, अभी तक नहीं दे रहा :) अब कुछ कोष्ठकों से छुटकारा पाने की कोशिश कर रहा हूँ ...
— किरिल एल।
2

पायथन 2 , 67 बाइट्स

r=[]
for x in input():
 while x in r[-2:]:r+=r,
 r+=x,
print len(r)

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

चुनौती सचमुच शाब्दिक रूप से लागू होती है। सूची की प्रतियों का उपयोग "रिक्त" के रूप में करता है, क्योंकि ये किसी भी संख्या के बराबर नहीं हो सकते हैं।

— XNOR
स्रोत
2

चारकोल , 27 23 बाइट्स

Ｆθ«Ｗ№✂υ±²¦¦¦ι⊞υω⊞υι»ＩＬυ

इसे ऑनलाइन आज़माएं!लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｆθ«

नौकरियों पर लूप।

Ｗ№✂υ±²¦¦¦ι⊞υω

जॉब रिजल्ट में अंतिम दो में से एक होते हुए कूलिंग ऑफ स्पॉट जोड़ें।

⊞υι»

परिणाम में वर्तमान नौकरी जोड़ें।

ＩＬυ

स्पॉट की संख्या प्रिंट करें।

— नील
स्रोत
2

आर , 74 68 बाइट्स

length(Reduce(function(x,y)c(y,rep("",match(y,x[2:1],0)),x),scan()))

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

कार्य सरणी (उल्टा) में निर्माण करता है, फिर लंबाई लेता है। किरिल एल के उत्तर की तुलना में अभी थोड़ा छोटा है है, तो कभी-कभी, अनुभवहीन उसका तरीका बिल्कुल अच्छा है। संपादित करें: फिर से छोटा! मैंने किरिल के टेस्ट टेम्पलेट को भी उधार लिया था।

-6 बाइट्स के max(0,which(y==x[2:1])) साथ की जगहmatch(y,x,0) ।

— ग्यूसेप
स्रोत
@Giuspeppe फ़ंक्शन क्या करता cहै?
— अज्ञान
@EmbodimentofIgnorance - cके लिए खड़ा है combine, हालांकि concatenateबेहतर हो सकता है; यह एक ही सूची में अपने तर्कों को जोड़ती है।
— ग्यूसेप
धन्यवाद, मुझे लगा कि यह अजीब था कि गोल्फिंग के लिए डिज़ाइन नहीं की गई भाषा में एक अक्षर होता है
— 1923 को इग्नोरेंस का अवतार।
1

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

{($!=$,|$_ Z$_ Z .[1..*+1])>>.repeated.squish(:with({$+^=[*] $! ne$^a ne$^b,$b==($!=$a)})).sum+$_}

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

ब्लरघ, ऐसा करने का एक बेहतर तरीका है। मुझे यकीन नहीं है कि यह पूरी तरह सही है, हालाँकि यह उन सभी मामलों से गुजरता है जिनके बारे में मैं सोच सकता था।

मूल रूप से, यह इनपुट सूची के सभी तीन गुटों को समूहीकृत करने के साथ शुरू होता है, दोनों ओर पैडिंग के साथ। उदाहरण के लिए, [1,2,1,2]बन जाता है (Any,1,2), (1,2,1), (2,1,2), (1,2,Nil)। हम repeatedप्रत्येक त्रिक में तत्व प्राप्त करते हैं, बनते हैं (), (1), (2), ()।

इसके बाद squishलगातार ऐसे तत्व मिलते हैं जो समान सूची में नहीं हैं, लेकिन समान आकार (जैसे कुछ को स्क्विश नहीं करने के लिए [1,1,1]) हैं, और पहला तत्व इसके पहले तत्व के बराबर नहीं है (क्योंकि हम घंटों को मर्ज नहीं कर सकते हैं [1,1,2,2]), और इससे पहले तत्व को भी स्क्वीज़ ( [1,2,1,2,1,2]) नहीं किया गया है । तो (1), (2)ऊपर दिए गए उदाहरण में एक साथ स्क्वीज़ किया जाएगा।

अंत में, हम sumइस सूची की सभी लंबाई प्राप्त करते हैं, जो हमारे सम्मिलित घंटों का प्रतिनिधित्व करते हैं, और मूल सूची की लंबाई जोड़ते हैं।

उदाहरण के लिए:

(1,1,1) => (Any,1,1),(1,1,1),(1,1,Nil) => (1),(1,1),(1) => (no squishes) => 4+3 = 7
(1,2,1,2,1,2) => (Any,1,2), (1,2,1), (2,1,2), (1,2,1), (2,1,2), (1,2,Nil) => (),(1),(2),(1),(2),() => squish (1),(2) and (1),(2) => 2+6 = 8
— मजाक कर रहा है
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 57 बाइट्स

f=([x,...a],p,q)=>1/x?1+f(x!=p&x!=q?a:[x,...a,x=f],x,p):0

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

टिप्पणी की गई

f = (             // f is a recursive function taking:
  [x,             //   x   = next job
      ...a],      //   a[] = array of remaining jobs
  p,              //   p   = previous job, initially undefined
  q               //   q   = penultimate job, initially undefined
) =>              //
  1 / x ?         // if x is defined and numeric:
    1 +           //   add 1 to the grand total
    f(            //   and do a recursive call to f:
      x != p &    //     if x is different from the previous job
      x != q ?    //     and different from the penultimate job:
        a         //       just pass the remaining jobs
      :           //     else:
        [ x,      //       pass x, which can't be assigned yet
          ...a,   //       pass the remaining jobs
          x = f   //       set x to a non-numeric value
        ],        //
      x,          //     previous job = x
      p           //     penultimate job = previous job
    )             //   end of recursive call
  :               // else:
    0             //   stop recursion
— Arnauld
स्रोत
1

सी (जीसीसी) , 69 बाइट्स

f(j,l)int*j;{j=l>1?(*j-*++j?j[-1]==j[l>2]?j++,l--,3:1:3)+f(j,l-1):l;}

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

सीधी पुनरावृत्ति।

f(j,l)int*j;{               //Jobs, (array) Length
    j=l>1                   //if l > 1, do a recursion:
        ? (*j-*++j          // check if first and second elements are equal (j++)
            ? j[-1]==       //  1st!=2nd; check if first and third are equal
                j[l>2]      //  (first and second if l==2, but we already know 1st!=2nd)
                ? j++,l--,3 //   1st==3rd (j++,l--) return 3+f(j+2,l-2)
                : 1         //   1st!=3rd (or l==2) return 1+f(j+1,l-1)
            : 3             //  1st==2nd            return 3+f(j+1,l-1)
          )+f(j,l-1)        // j and l were modified as needed
        : l;                // nothing more needed  return l
}
— attinat
स्रोत
1

स्मालटाक, 125 बाइट्स

c:=0.n:=q size.1to:n-2do:[:i|(j:=q at:i)=(k:=q at:i+1)ifTrue:[c:=c+2].j=(m:=q at:i+2)ifTrue:[c:=c+1]].k=m ifTrue:[c:=c+1].c+n

व्याख्या

c : accumulator of proximity penalty
q : input array.
n := q length
i : iteration index from 1 to: n-2 (arrays are 1-based in Smalltalk).
j := memory for element i, saves some few bytes when reused
k := similar to j but for i+1.
m := similar to k but for i+2.
— लिएंड्रो
स्रोत
— अरिनीत
1

पर्ल 5 -pl , 42 40 बाइट्स

$a{$_}=~s/.*/$\=$&if++$\<$&;$\+3/e}{$_=0

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

— wastl
स्रोत
-pप्रतिस्थापन का उपयोग करके इसे घटाकर 35 कर दें : ऑनलाइन प्रयास करें!
— Xcali
@Xcali जो खाली इनपुट के लिए कुछ भी नहीं देता है, लेकिन मुझे 39
— wastl
1
1,1,1 के लिए काम नहीं करता है ।
— nwellnhof
@nwellnhof फिक्स्ड
— wastl
0

बैच, 184 बाइट्स

@echo off
@set l=-
@set p=-
@set n=0
@for %%j in (%*)do @call:c %%j
@exit/b%n%
:c
@if %1==%l% (set l=-&set/an+=2)else if %1==%p% set l=-&set/an+=1
@set p=%l%&set l=%1&set/an+=1

इनपुट कमांड-लाइन तर्कों के माध्यम से है और आउटपुट निकास कोड के माध्यम से है। स्पष्टीकरण:

@set l=-
@set p=-

अंतिम दो काम ट्रैक करें।

@set n=0

गिनती शुरू करें।

@for %%j in (%*)do @call:c %%j

प्रत्येक कार्य की प्रक्रिया करें।

@exit/b%n%

अंतिम गणना आउटपुट।

:c

प्रत्येक काम के लिए:

@if %1==%l% (set l=-&set/an+=2)else if %1==%p% set l=-&set/an+=1

यदि हमने हाल ही में कार्य संसाधित किया है, तो उचित संख्या में कूलिंग ऑफ स्पॉट्स में जोड़ें। इसके अतिरिक्त, अंतिम कार्य को साफ़ करें ताकि अगली नौकरी केवल कूलिंग को चालू करे यदि यह इस नौकरी के समान है।

@set p=%l%&set l=%1&set/an+=1

अंतिम दो नौकरियों को अपडेट करें और इस नौकरी के लिए एक स्थान आवंटित करें।

— नील
स्रोत
0

स्विफ्ट, 114 बाइट्स

func t(a:[Int]){
var s=1
for i in 1...a.count-1{s = a[i-1]==a[i] ? s+3:i>1&&a[i-2]==a[i] ? s+2:s+1}
print("\(s)")}

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

— onnoweb
स्रोत
2
के लिए विफल रहता है 3,4,3,4, 5 से शर्त लगाई जानी चाहिए, न कि 6.
— किरिल एल।
इसके अलावा xyxy को @KirillL फिक्स करें। बताया गया है, s = aहो सकता है s=a, और आप कर सकते हैं s+=कई के बजाय s=s+...और निकालने के रिक्त स्थान के बाद ?: for i in 1...a.count-1{s+=a[i-1]==a[i] ?3:i>1&&a[i-2]==a[i] ?2:1}9 बाइट्स को बचाने के लिए।
— डैनियल विदिस
0

पायथन 3 , 79 75 बाइट्स

-3 बाइट्स धन्यवाद mypetlion
-1 बाइट सारा जे के लिए धन्यवाद

f=lambda a,b=[]:a and f(*[a[1:],a,a[:1]+b,[b]+b][a[0]in b[:2]::2])or len(b)

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

— जोनास ऑसेविसियस
स्रोत
1
a[0]in b[:2]and f(a,['']+b)or f(a[1:],[a[0]]+b)f(*[a[1:],a,[a[0]]+b,['']+b][a[0]in b[:2]::2])2 बाइट बचाने के लिए बन सकता है ।
— mypetlion
1
[a[0]]+ba[:1]+b1 बाइट बचाने के लिए बन सकता है ।
— मैपरलियन
1
एक बाइट के ['']+bसाथ प्रतिस्थापित करना [b]+b- bएक सूची है, इसलिए यह कभी भी किसी भी मूल्य के बराबर नहीं होगाa
— सारा जे
0

जावा (JDK) , 110 बाइट्स

j->{int p,q;for(p=q=j.length;p-->1;q+=j[p]==j[p-1]?2:(p>1&&j[p]==j[p-2]&(p<3||j[p-1]!=j[p-3]))?1:0);return q;}

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

Ungolfed टिप्पणी कोड:

j -> {
    int p, q = j.length; // Run all jobs
    for (p = q; p-- > 1;) { // reverse iterate
        q += j[p] == j[p - 1] ? 2 : // add 2 if prev same
        (p > 1 && j[p] == j[p - 2] & // 1 if 2prev same
        (p < 3 || j[p - 1] != j[p - 3]) // except already done
        ) ? 1 : 0; // otherwise 0
    }
    return q;
}
— डैनियल Widdis
स्रोत
के लिए काम नहीं करता है 3,4,3,4,3,4, 8 के बजाय 7 लौटाता है
— अज्ञानता
यह एक दुष्ट छोटी समस्या है।
— डैनियल विदिस
0

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

ṫ-i⁹⁶x;
⁶;ç³Ṫ¤¥¥³¿L’

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

हालाँकि यह @ EriktheOutgolfer के छोटे उत्तर के समान है , मैंने इसे बिना देखे ही लिख दिया। किसी भी मामले में उसकी स्थिति बेहतर है!

व्याख्या

हेल्पर डाइएडिक लिंक, लेफ्ट आइटम के रूप में वर्तमान सूची और राइट के रूप में अगला आइटम लेता है

ṫ-            | take the last two items in the list
  i⁹          | find the index of the new item
    ⁶x        | that many space characters
      ;       | prepend to new item

मुख्य मोनैडिक लिंक, इनपुट के रूप में पूर्णांकों की सूची लेता है

⁶             | start with a single space
 ;            | append...
  ç³Ṫ¤¥       | the helper link called with the current list
              | as left item and the next input item as right
       ¥³¿    | loop the last two as a dyad until the input is empty
          L   | take the length
           ’  | subtract one for the original space
— निक केनेडी
स्रोत
0

जावास्क्रिप्ट (V8), 101 बाइट्स

f=a=>for(var c=0,i=0;i<a.length;i++,c++)a[i-1]==a[i]?c+=2:a[i-2]==a[i]&&(c++,a[i-1]=void 0)
return c}

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

अनपैक्ड कोड इस प्रकार दिखता है:

function f(a)
{
    var c = 0;
    for (var i = 0; i < a.length; i++, c++)
    {
        if (a[i - 1] == a[i])
            c+=2;
        else if (a[i - 2] == a[i])
            c++,a[i-1]=undefined;
    }

    return c;
}

मेरा अब तक का पहला कोड-गोल्फ प्रयास, संभवतः एरे को सिकोड़कर और इसे पुनरावर्ती रूप से पारित करके बहुत कुछ अनुकूलित किया जा सकता है।

— Broxzier
स्रोत
PPCG में आपका स्वागत है! यह एक बहुत अच्छा पहला पोस्ट है!
— R
0

Zsh , 66 60 बाइट्स

निहित से -6 बाइट्स "$@"

for j
{((i=$a[(I)$j]))&&a=
a=("$a[-1]" $j)
((x+=i+1))}
<<<$x

इसे ऑनलाइन आज़माएं! मैं set -xशुरू से जोड़ने की सलाह देता हूं ताकि आप साथ चल सकें।

for j                   # Implicit "$@"
{                       # Use '{' '}' instead of 'do' 'done'
    (( i=$a[(I)$j] )) \ # (see below)
        && a=           # if the previous returned true, empty a
    a=( "$a[-1]" $j )   # set the array to its last element and the new job
    (( x += i + 1 ))    # add number of slots we advanced
}
<<<$x                   # echo back our total
((i=$a[(I)$j]))
    $a[     ]           # Array lookup
       (I)$j            # Get highest index matched by $j, or 0 if not found
  i=                    # Set to i
((           ))         # If i was set nonzero, return true

aहमेशा अंतिम दो कार्य होते हैं, इसलिए यदि लुकअप में एक मेल खाता है a[2], तो हम तीन से वृद्धि करते हैं (जब से नौकरी के स्लॉट होंगे[... 3 _ _ 3 ...] )।

अगर a कोई परेशान है, तो लुकअप विफल हो जाएगा और अंकगणितीय विस्तार एक त्रुटि लौटाएगा, लेकिन यह केवल पहली नौकरी पर होता है और घातक नहीं होता है।

यदि हम $[x+=i+1]इसके बजाय उपयोग करते हैं, तो हम एक और बाइट बचा सकते हैं , और पूरी तरह से अंकों वाले उपयोगकर्ता प्रणाली पर कोई आदेश नहीं हैं।

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