अनुग्रह अवधि के लिए गणना का संपादन संपादित करें


23

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

कहते हैं कि आप मिनटों में संपादित करें [0,3,4,7,9,10,11,12]। इसका परिणाम कई बार 3 संस्करणों में होता है [0,7,12], बाकी उनकी ग्रेस पीरियड्स में होता है।

0:  [3,4]
7:  [9,10,11]
12: []
  • पहला संपादन मिनट में है। मिनट 3 और 4 पर संपादन इसकी 5-मिनट की अनुग्रह अवधि के भीतर है, और इसलिए गणना नहीं करते हैं।
  • दूसरा संपादन मिनट 7 पर है। मिनट 9, 10, 11 पर संपादन इसकी कृपा अवधि के भीतर है।
  • मिनट 12 पर तीसरा संपादन 5 मिनट की अनुग्रह अवधि के ठीक 7 मिनट पर शुरू होता है।

तो, आउटपुट 3 है।

मिनटों में समय की सूची बढ़ती पूर्णांक की एक सूची होगी। प्रारंभिक पोस्टिंग के लिए पहला नंबर हमेशा 0 होगा, जिसे हम एक एडिट के रूप में गिनते हैं।

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

[0]
[0,3,5,7]
[0,3,4,7,9,10,11,12]
[0,30,120]
[0,4,8,12,16]
[0,4,8,12,16,20]
[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]
[0,5,10,15,20]
[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
[0,1,4,5,9,11,12,14,16,18,23,24,26,28,29,30]

आउटपुट:

1
2
3
3
3
3
4
5
5
6

प्रतिलिपि बनाने में आसानी के लिए, यहाँ इनपुट्स, आउटपुट और इनपुट / आउटपुट जोड़े हैं:

[[0], [0, 3, 5, 7], [0, 3, 4, 7, 9, 10, 11, 12], [0, 30, 120], [0, 4, 8, 12, 16], [0, 4, 8, 12, 16, 20], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], [0, 5, 10, 15, 20], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], [0, 1, 4, 5, 9, 11, 12, 14, 16, 18, 23, 24, 26, 28, 29, 30]]
[1, 2, 3, 3, 3, 3, 4, 5, 5, 6]
[([0], 1), ([0, 3, 5, 7], 2), ([0, 3, 4, 7, 9, 10, 11, 12], 3), ([0, 30, 120], 3), ([0, 4, 8, 12, 16], 3), ([0, 4, 8, 12, 16, 20], 3), ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], 4), ([0, 5, 10, 15, 20], 5), ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], 5), ([0, 1, 4, 5, 9, 11, 12, 14, 16, 18, 23, 24, 26, 28, 29, 30], 6)]

लीडरबोर्ड:


हालाँकि यह वास्तव में कष्टप्रद है अगर आपका संपादन अनुग्रह अवधि नहीं करता है, क्योंकि तब आपको अपनी नई अनुग्रह अवधि का उपयोग करना होगा ताकि यह देखा जा सके कि क्या आप इसे इस तरह से संपादित करना चाहते हैं ...
नील

जवाबों:


20

जावास्क्रिप्ट, 36 बाइट्स

f=$=>$>f&&1+f($.filter(b=>b-$[0]>4))

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

यह काम किस प्रकार करता है

प्रत्येक पुनरावर्ती कॉल में हम सरणी से सभी तत्वों को हटाते हैं जो पहले तत्व से 4 मिनट से अधिक दूर हैं।
चर नाम के साथ थोड़ी सी चाल है $। चेक $>fपहले सरणी को एक स्ट्रिंग में परिवर्तित करता है और फिर इसे फ़ंक्शन के स्ट्रिंग प्रतिनिधित्व से fतुलना करता है और फिर उनकी तुलनात्मक रूप से करता है। कड़े हुए सरणी का पहला वर्ण एक अंक है और इसलिए केवल एक-चर चर नाम है जिसका एससीआई सूचकांक सभी अंकों के सूचकांकों से छोटा है $$किसी भी अन्य चर नाम के साथ प्रतिस्थापित करना हमेशा वापस आएगा false


3
मुझे इस साइट को इन जैसे उत्तरों के कारण पसंद है।
क्रिस्टियन लुपस्कू

1
बहुत अच्छी चाल!
Arnauld

1
ओह, अब, यह एक महान चाल है!
झबरा

8

गणितज्ञ, 46 40 37 33 बाइट्स

(i=1;j=0;#-j<5||(i++;j=#)&/@#;i)&

व्याख्या

i=1;j=0

सेट iकरने के लिए 1और jकरने के लिए 0

... /@#

इनपुट के सभी तत्वों पर मानचित्र ...

#-j<5||(i++;j=#)&

यदि (element) - j < 5गलत है, तो वेतन वृद्धि iऔर jतत्व (शॉर्ट-सर्किट मूल्यांकन) पर सेट करें।

;i

आउटपुट i



5

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

a=input()
x=[0]
for k in a:x+=[k]*(k-x[-1]>4)
print len(x)

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

  • @Mr की बदौलत 2 बाइट्स बचाए। Xcoder।

49 बाइट्स

f=lambda a:a>[]and-~f([x for x in a if x-a[0]>4])

@PirateBay के समाधान में दिखाए गए पुनरावर्ती पद्धति का उपयोग करना ।

  • @Mr को बाइट धन्यवाद दिया। Xcoder।
  • 2 बाइट्स @Halvardamm की बदौलत सहेजे गए।

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


and 1+f(...)and-~f(...)49 बाइट्स के लिए प्रतिस्थापित किया जा सकता है
श्री एक्सकोडर

@ Mr.Xcoder ओह, उन सभी बिटकॉइन ट्रिक्स को नहीं भूल सकते।
मील

x=a[:1]के समतुल्य है x=[0], क्योंकि यह प्रश्न स्पष्ट रूप से बताता है कि पहला तत्व हमेशा 0( 62 बाइट्स ) है
श्री एक्सकोडर



3

MATLAB, 34 बाइट्स

@(x)nnz(uniquetol(x+1,4/max(x+1)))

अनाम फ़ंक्शन जो किसी इनपुट को इनपुट करता है और एक नंबर आउटपुट करता है।

यह uniquetolफ़ंक्शन का उपयोग करता है , विशेष रूप से इसका रूप y = uniquetol(x, t), जो सहिष्णुता yके xसाथ अद्वितीय तत्व देता है t। ऐसा करने में, फ़ंक्शन "आलसी" दृष्टिकोण का पालन करता है : सॉर्ट करें x, इसकी पहली प्रविष्टि चुनें, और जब तक वे नवीनतम चुनी गई प्रविष्टि की सहनशीलता के भीतर हैं, तब तक प्रविष्टियों को छोड़ते रहें। ठीक वैसा ही यहाँ है।

uniquetolसमारोह स्वचालित रूप में अधिकतम निरपेक्ष मूल्य द्वारा निर्दिष्ट सहिष्णुता मापता है a। यही कारण है कि हमें यहां विभाजन की आवश्यकता है। x+1इसका उपयोग x0 से विभाजन से बचने के बजाय किया जाता है ।

परीक्षण मामलों का सत्यापन:

>> f = @(x)nnz(uniquetol(x+1,4/max(x+1)));
>> inputs = {...
       [0] ...
       [0,3,5,7] ...
       [0,3,4,7,9,10,11,12] ...
       [0,30,120] ...
       [0,4,8,12,16] ...
       [0,4,8,12,16,20] ...
       [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19] ...
       [0,5,10,15,20] ...
       [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20] ...
       [0,1,4,5,9,11,12,14,16,18,23,24,26,28,29,30] ...
   };
>> outputs = cellfun(f, inputs)
outputs =
     1     2     3     3     3     3     4     5     5     6

1
TIL के बारे में uniquetol... R2015a में पेश किया गया । मेरे पास R2014b है :( अच्छा जवाब :)
स्टीवी ग्रिफिन

@Stewie मुझे पता था कि यह अस्तित्व में है, लेकिन मुझे लगता है कि यह पहली बार है जब मैं इसका उपयोग कर रहा हूं
लुइस

2

05AB1E , 20 19 18 15 14 11 बाइट्स

v®y‹iy4+©\¼

स्पष्टीकरण:

v          # loop on input
 ®          # push register_c, start at -1
  y‹i         # if current item greater than last item
   y4+         # push new max on stack
    ©\          # push new max on register_c, and pop it from stack
     ¼           # increment counter_variable
                  # implicit print of counter_variable

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

संपादित करें

  • -3 बाइट्स रिले के लिए धन्यवाद और counter_variable का उपयोग
  • सब के बाद counter_variable के लिए कोई ज़रूरत नहीं है
  • -3 बाइट्स फिर से रिले और रजिस्टर_सी के उपयोग के लिए धन्यवाद

आप 3 बाइट्स को बचाने के लिए काउंटर चर का उपयोग कर सकते हैं:¼4¹vDy‹i¼y4+}}¾
रिले

oooooh, एक काउंटर चर है, यह आसान है! धन्यवाद!!
सिरिल गैंडन

1
11 बाइट्स:v®y‹iy4+©\¼
रिले

2

भूसी, 6 बाइट्स

Lüo<+5

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

  o<+5        a function that takes two arguments and checks if
              the second is less than the the first plus 5
 ü            remove equal elements from the input list using the above
              function as the equality test
L             return the length of the remaining list

वाह, मुझे उस üतरह काम का एहसास नहीं था ! यह बहुत आसान है।
जरगब

@ ज़र्ब: मैंने पहली बार कोशिश की, ġलेकिन यह काम नहीं करता है, जबकि हास्केल के groupByकाम करता है length.groupBy((>).(+5)):। तब मैंने पाया üकि जो एक छोटे हास्केल के बराबर होता है nubBy:।
नौ

2

हास्केल , 31 30 बाइट्स

f(x:y)=f[z|z<-y,z-4>x]+1
f x=0

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

जार्गब को 1 बाइट धन्यवाद दिया


z-4>xएक बाइट को बचाना चाहिए।
जरगब

@Zgarb मैं क्या सोच रहा था ??? धन्यवाद! :)
क्रिस्टियन लुपस्कू


1

MATL , 13 12 बाइट्स

`ttX<4+>)t}@

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

व्याख्या

`        % Do..while
  t      %   Duplicate. Takes input (implicitly) the first time
  tX<    %   Duplicate and get minimum, i.e the first entry
  4+     %   Add 4
  >      %   Greater than? Element-wise
  )      %   Keep entries that fulfill that
  t      %   Duplicate. This is used as loop condition
}        % Finally (execute at the end of the loop)
  @      %   Push number of iterations. This is the output
         % End (implicit). A new iteration is run if top of the stack is truthy

1

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

L&lbhyfg-Thb5b

यह एक पुनरावर्ती कार्य है। इसके साथ बुलाओy[0 1 2 3 4 5 6 7 8)जहां [...)आपकी सूची है , करें।

वैकल्पिक रूप से, इसे यहाँ आज़माएँ!या सभी परीक्षण मामलों को सत्यापित करें।


व्याख्या

यह लगभग पायथन समाधान के बराबर है। एक अनुवाद निम्नलिखित परिणाम देगा:

def y(b):
 return (len(b) and y(filter(lambda T:T>=b[0]+5,b)) + 1)

कोड ब्रेकडाउन

L&lbhyfg-Thb5b   - Function called y that accepts a list parameter b.

L                - Define the function.
  lb             - The length of b...
 &               - ... Logical AND ...
    h            - Increment by 1.
     y           - The result given by calling the function recursively on the following:
      f      b     - b filtered...
        -Thb       - ... For the elements whose difference compared to the first element...
       g    5      - ... Is greater than or equal to 5.

मैं के साथ एक वैकल्पिक हल खोजने की कोशिश कर रहा हूँ .U। सुझावों का स्वागत है
श्री एक्सकोडर


1

C # .NET, 63 बाइट्स

a=>{int e=0;foreach(int l in a)if(l-a[e]>4)a[++e]=l;return-~e;}

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

a=>{                   // Method with integer-array parameter and integer return-type
  int e=0;             //  Amount of edits (starting at 0)
  foreach(int l in a)  //  Loop over the input-array
    if(l-a[e]>4)       //   If the current value minus the current edit is larger than 4:
      a[++e]=l;        //    Raise the edit-count by 1 first,
                       //    and set the current value to this next current edit
                       //  End of loop (implicit / single-line body)
  return-~e;           //  Return the amount of edits + 1
}                      // End of method





0

रेटिना , 32 26 बाइट्स

.+
$*11
(1+)(¶1{1,4}\1)*\b

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.+
$*11

यूनिरी में कनवर्ट करें, लेकिन 1 जोड़ें, क्योंकि 0 रेटिना में एक मुश्किल अवधारणा है।

(1+)(¶1{1,4}\1)*\b

संपादन की संख्या की गणना करें, लेकिन प्रत्येक मैच में सभी अनुग्रह संपादन शामिल करें।


0

कोटलीन, 52 बाइट्स

एक फ़ंक्शन के रूप में पोस्ट करना, अगर यह स्वीकार्य नहीं है तो मैं इसे एक विधि में बदल दूंगा

प्रस्तुत करने

{var x=it[0]
var o=1
it.map{if(it>x+4){o++
x=it}}
o}

सजा हुआ

{
    // Last counted edit
    var x=it[0]
    // Current edit total
    var o = 1
    // For each edit
    it.map{
        // If it was 5 or more minutes ago
        if (it>x+4) {
            // Increase edit count
            o++
            // Make it the last counted edit
            x=it
        }
    }
    // Return the edit count
    o
}

परीक्षा

var r:(IntArray)->Int=
{var x=it[0]
var o=1
it.map{if(it>x+4){o++
x=it}}
o}

fun main(args: Array<String>) {
    println(r(intArrayOf(0)))
    println(r(intArrayOf(0,3,5,7)))
    println(r(intArrayOf(0,3,4,7,9,10,11,12)))
    println(r(intArrayOf(0,30,120)))
    println(r(intArrayOf(0,4,8,12,16)))
    println(r(intArrayOf(0,4,8,12,16,20)))
    println(r(intArrayOf(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19)))
    println(r(intArrayOf(0,5,10,15,20)))
    println(r(intArrayOf(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20)))
    println(r(intArrayOf(0,1,4,5,9,11,12,14,16,18,23,24,26,28,29,30)))
}

TryItOnline


0

पॉवरशेल , 74 बाइट्स

for($x,$y=$args[0];$y;$x,$y=$y){if($l-le$x-5){$i++;$l=$x}}$i+1+($l-le$x-5)

Iterative समाधान। forअंत में अतिरिक्त जांच की आवश्यकता होने के कारण लूप पर बाड़ लगाने की वजह से लंबा ।गोल्फ सुझाव का स्वागत करते हैं।

हम $args[0]एक शाब्दिक सरणी के रूप में इनपुट लेते हैं , पहले तत्व को $xशेष और शेष में छीलते हैं$y । फिर, जब तक इसमें तत्व हैं तब तक $yहम लूप करते हैं।

प्रत्येक पुनरावृत्ति, हम जाँचते हैं कि क्या वर्तमान टाइमस्टैम्प $x, एडिट टाइमस्टैम्प 5से अधिक दूर है या नहीं $l। यदि हां, तो हम अपने काउंटर को बढ़ाते हैं $i++और हमारे टाइमस्टैम्प को चालू करने के लिए सेट करते हैं। फिर, लूप के पुनरावृत्ति पर, हम अगले तत्व को छील देते हैं$x देते हैं और शेष को अंदर छोड़ देते हैं$y

एक बार जब हम लूप से बाहर हो जाते हैं, तो हम प्रारंभिक संपादन के लिए $i, प्लस आउटपुट , साथ 1ही अंतिम टाइमस्टैम्प पिछले एडिट से पांच से अधिक दूर होते हैं (बूलियन मान के साथ पूर्णांक में डाली जाती है)। यह परिणाम पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

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


0

आर , 52 बाइट्स

function(l){while(sum(l|1)){l=l[l-l[1]>=5]
F=F+1}
F}

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

साधारण अनाम फ़ंक्शन जो पुनरावृत्तियां सूची से उन तत्वों को हटाती हैं जो पहले तत्व से 5 से कम दूर हैं जब तक कि सूची खाली नहीं होती है, तब काउंटर लौटाता है।


0

क्लोजर, 53 बाइट्स

#(count(set(reductions(fn[r v](if(<(- v r)5)r v))%)))

यह "शुरुआती समय संपादित करें" का ट्रैक रखता है, और फिर उनकी अलग गिनती लौटाता है।


0

जाप , 14 बाइट्स

Ê©1+ßUf_aUg)>4

कोशिश करो


व्याख्या

सरणी का निहित इनपुट U

Ê

की लंबाई प्राप्त करें U

©

तार्किक और ( &&) - Êसत्य (गैर-शून्य) होने पर केवल निम्नलिखित निष्पादित करें ।

ß

पुनरावर्ती कॉल।

Uf_

किसी फ़ंक्शन के माध्यम से प्रत्येक तत्व को फ़िल्टर करके ( f) U

aUg

aवर्तमान तत्व और पहले तत्व ( g) के बीच अंतर ( ) प्राप्त करें U

>4

4 से अधिक है?

1+

जोड़ें 1

परिणामी पूर्णांक का निहित उत्पादन।


0

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

+4Ḣ<x@µÐĿL’

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

व्याख्या

+4Ḣ<x@µÐĿL’  Input: array A
      µÐĿ    Repeat until the results converge
+4             Add 4
  Ḣ            Head
   <           Greater than
    x@         Copy only the true values
         L   Length
          ’  Decrement

12 बाइट्स

;I4<1;x@;ð/L

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

व्याख्या

;I4<1;x@;ð/L  Input: array A
         ð/   Reduce A from left-to-right using
;               Concatenate
 I              Increment
  4<            Greater than 4
    1;          Prepend 1
      x@        Times each of
        ;       Concatenate
           L  Length
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.