52

गुरुत्वाकर्षण बल एक बल है जो किसी भी दो वस्तुओं को द्रव्यमान के साथ आकर्षित करता है। इस चुनौती में हमारी वस्तुएं संख्याएँ होंगी और उनका द्रव्यमान उनका मूल्य होगा। ऐसा करने के लिए, हम बल की ताकत के बारे में परवाह नहीं करते हैं लेकिन इसकी दिशा देखते हैं।

संख्या के इस सेट की कल्पना करें

[1 6 9 4 6 9 7 6 4 4 9 8 7]

उनमें से प्रत्येक खुद के बीच एक बल बनाता है और यह आसन्न संख्या है। कुछ शर्तों के तहत, यह एक संख्या को दूसरी ओर आकर्षित (स्थानांतरित) करने का कारण होगा। जब संख्या आसन्न से बड़ी होती है, तो वह इसे आकर्षित करती है। हमारे पिछले उदाहरण पर एक नज़र डालते हैं:

[1 → 6 → 9 ← 4 6 → 9 ← 7 ← 6 ← 4 4 → 9 ← 8 ← 7]

संख्या 1को स्थानांतरित करने के लिए पर्याप्त बड़ा नहीं है 6, लेकिन संख्या 6है, आदि ... मूल रूप से, संख्या को सबसे बड़े आसन्न संख्या में स्थानांतरित किया जाता है (संख्या से भी बड़ा)। यदि दोनों समीप संख्या समान हैं तो यह आकर्षित नहीं होता है। यह तब भी होता है जब संख्या और इसके आस-पास समान होते हैं।

यह केवल आकर्षण दिखाने के लिए है, लेकिन इसके बाद क्या होता है? आकर्षण के कारण टकराने वाली संख्याएँ संक्षेपित हैं:

[20 32 28]

तो मूल रूप से चुनौती है, संख्याओं के एक सेट को देखते हुए, संख्याओं के आकर्षित सेट का परिणाम।

उदाहरण 1

Input  => [10 15 20 10 20 10 10]
          [10 → 15 → 20 10 20 ← 10 10]
Output => [45 10 30 10]

उदाहरण 2

Input  => [9 9 9 9 8 1 8]
          [9 9 9 9 ← 8 1 8]
Output => [9 9 9 17 1 8]

उदाहरण 3

Input  => [1 6 9 4 6 9 7 6 4 4 9 8 7]
          [1 → 6 → 9 ← 4 6 → 9 ← 7 ← 6 ← 4 4 → 9 ← 8 ← 7]
Output => [20 32 28]

उदाहरण 4

Input  => [1 2 3 2 1]
          [1 → 2 → 3 ← 2 ← 1]
Output => [9]

उदाहरण 5

Input  => [1]
Output => [1]

उदाहरण 6

Input  => [1 1]
Output => [1 1]

उदाहरण 7

Input  => [2 1 4]
Output => [2 5]

आकर्षण केवल एक बार होता है
संख्याएँ आसन्न संख्याओं की ओर आकर्षित नहीं होती हैं
संख्याओं के सेट में केवल धनात्मक पूर्णांक होंगे

code-golf

— लुइस फेलिप डी जीसस मुनोज
स्रोत

1

एक एकल पूर्णांक को ढहने वाले परीक्षण मामले को जोड़ने का सुझाव दें।

— झबरा

2

[1 3 5 4 2]= 15?

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn हां

— लुइस फेलिप डी

14

1 संख्या 6 को आकर्षित करने के लिए पर्याप्त बड़ा नहीं है। यह शब्द मुझमें भौतिक विज्ञानी को परेशान करता है। (वैसे तो कुछ अन्य नियम हैं, लेकिन समस्या की परिभाषा को बदले बिना शब्द को बदलकर इसे ठीक किया जा सकता है)। दो निकायों के बीच आकर्षण बल G*M*m / r^2, दोनों निकायों के लिए समान है। हल्का एक पल की वजह से भारी से अधिक चलता है, आकर्षण की कमी के कारण नहीं। शायद कहते हैं "6 को स्थानांतरित करने के लिए 1 बड़ा नहीं है"।

— पीटर कॉर्ड्स

4

लेकिन वास्तव में आप "आकर्षित" को "आकर्षित की ओर" के रूप में परिभाषित कर रहे हैं, बल्कि "एक बल बनाता है", जो पहले के वाक्य के साथ टकराव करता है " उनमें से प्रत्येक इसके आसन्न संख्याओं के लिए एक आकर्षण बल बनाता है "। इसलिए हो सकता है कि यह कहने के लिए कि "उनमें से प्रत्येक के बीच एक बल है और यह आसन्न संख्याएँ हैं, को खोलने के लिए, कुछ शर्तों के तहत, यह एक और संख्या को आकर्षित करने (स्थानांतरित) के लिए एक संख्या की ओर ले जाएगा।" मुझे पता है कि यह एक शब्दावली नाइटपिक है, और गुरुत्वाकर्षण का यह मॉडल केवल वास्तविक भौतिकी के समान है, लेकिन इसने मुझे इस टिप्पणी को लिखने के लिए पर्याप्त परेशान किया।

— पीटर कॉर्ड्स

15

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

@ बग्घी के लिए 2 बाइट्स को सहेजा गया

a=>a.filter(n=>n,[...a].map((v,i)=>a[a[p>v&(n=~~a[i+1])<p?k:i+(k=i,n>v&p<n)]+=x=a[i],p=v,i]-=x,p=0))

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

टिप्पणी की गई

a[] $0$

$a_i$ $a_{i+1}$

$4\rightarrow5\rightarrow6$ $[0,\color{red}9,6]$ $[0,0,\color{red}{15}]$

$a_i$ $a_k$ $k<i$ $a_{i-1}$

$6\leftarrow5\leftarrow4$ $[\color{red}{11},0,4]$ $[\color{red}{15},0,0]$

[...a]                 // create a copy of a[]
.map((v, i) =>         // for each value v in a[] at position i:
  a[                   //   this statement updates a[i]:
    a[                 //     this statement updates either a[i] or an adjacent value:
      p > v &          //       if the previous value p is greater than v
      (n = ~~a[i + 1]) //       and the next value n
      < p ?            //       is less than p (attraction to the left):
        k              //         use k (k is initially undefined, but this code cannot
                       //         be triggered during the first iteration)
      :                //       else:
        i + (          //         use either i or i + 1:
          k = i,       //           set k to i
          n > v &      //           use i + 1 if n is greater than v
          p < n        //           and p is less than n (attraction to the right)
        )              //
    ] += x = a[i],     //     add x = a[i] to the entry defined above
    p = v,             //     update the previous value to v
    i                  //     actual index to update a[i]
  ] -= x,              //   subtract x from a[i]
  p = 0                //   start with p = 0
)                      // end of map()

$0$

a.filter(n => n)

— Arnauld
स्रोत

आपके स्पष्टीकरण से, ऐसा लगता है कि आपका कोड [1,3,5,3,1,2,1]आउटपुट और आउटपुट के लिए विफल होगा [14,2], लेकिन यह वास्तव में सही ढंग से और आउटपुट काम करता है [13,3]।

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

@EriktheOutgolfer मैंने उस हिस्से को रीफ़्रेश किया है जो मुझे लगता है कि - भ्रामक था। क्या वो बेहतर है?

— अरनौल में

2

अब यह सिर्फ "उच्चतम पिछले मूल्य" के बजाय "पहले आकर्षित करने वाले" का उल्लेख करता है, इसलिए मैं समझ सकता हूं कि आपका क्या मतलब है।

— द एग्रीगेटर

9

स्टैक्स , 27 25 23 18 बाइट्स

«╥╦.ê§┘h!@ÆEÿ☺╜╫♥B

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

आउटपुट को न्यूलाइन्स द्वारा अलग किया जाता है।

यह कार्यक्रम सरणी में आसन्न जोड़े पर संचालित होता है, और यह निर्धारित करता है कि क्या इस प्रक्रिया का उपयोग करके उनके बीच एक विभाजन होना चाहिए।

कुछ मनमाने इनपुट पर विचार करें [... w x y z ...]। यहाँ यह निर्धारित करने का तरीका है कि क्या बीच में विभाजन होना चाहिए xऔर y।

अगर x == y, तो हाँ।
अगर x > yहै, तो आईएफएफ z >= x।
अगर y > xहै, तो आईएफएफ w >= y।

योग को अभ्यास के रूप में छोड़ दिया जाता है।

— पुनरावर्ती
स्रोत

8

रेटिना 0.8.2 , 64 बाइट्स

\d+
$*
(?<=(1+)) ((?=(1+\1))(?<!\3 \1 )|(?!\1)(?!1+ \1))

1+
$.&

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

\d+
$*

यूनीरी में बदलें।

(?<=(1+)) ((?=(1+\1))(?<!\3 \1 )|(?!\1)(?!1+ \1))

आकर्षित संख्याओं के बीच विभाजकों को हटा दें। विभाजक से पहले संख्या के लिए (?<=(1+))सेट \1। विभाजक के बाद, दो मामले हैं:

विभाजक के बाद की संख्या विभाजक से पहले की दोनों संख्याओं से अधिक है
विभाजक से पहले की संख्या विभाजक के बाद की दोनों संख्याओं से अधिक है

इन मामलों में दो संख्याओं के बीच एक आकर्षण होता है और विभाजक को हटाने से संख्याओं के आपस में टकराने का कारण बनता है।

1+
$.&

दशमलव में परिवर्तित करें।

— नील
स्रोत

6

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

Ø0jMÆmær0Ʋ3Ƥ×=4$o<ʋƝk⁸§

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

एक मोनडिक लिंक जो पूर्णांकों की सूची को अपने तर्क के रूप में लेता है और पूर्णांकों की सूची देता है।

व्याख्या

Ø0j                     | Join [0, 0] with input list
         Ʋ3Ƥ            | For each length 3 infix, do the following as a monad:
   M                    | - Indices of maximum
    Æm                  | - Mean
      ær0               | - Round to even (so the means of [1, 2, 3], [1, 2], [2, 3] and [1, 3] will all round to 2
                  ʋƝ    | For each neighbouring pair, do the following as a dyad:
            ×           | - Multiply
             =4$        | - Check if equal to 4
                o       | - Or
                 <      | - First number less than second
                    k⁸  | Split input after truthy values of the above
                      § | Sum, vectorised

@ पुनरावर्ती के स्टेक्स उत्तर से ली गई कुछ प्रेरणा ।

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

4

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

a,b,c,s;P(){s=!printf("%d ",s);}f(int*v){for(b=s=0,c=*v;a=b,b=c;a<b|b<a&c<a||P(),s+=b,b<c&c<=a|!c&&P())c=*++v;}

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

पूर्णांक की एक शून्य-समाप्त सरणी लेता है।

व्याख्या

a,b,c,  // Three consecutive elements of input array
s;      // Accumulator for sum
P(){s=!printf("%d ",s);}  // Print and clear s
f(int*v){
    for(
        // Init
        b=s=0,
        c=*v;
        // Loop test
        a=b,  // Shift b into a
        b=c;  // Shift c into b, exit if zero
        // Post loop
        a<b|b<a&c<a||P(),  // Print if a==b || (b<a && a<=c)
        s+=b,  // Accumulate
        b<c&c<=a|!c&&P()   // Print if c==0 || (b<c && c<=a)
    )
        // Loop body
        c=*++v;  // Read next number into c
}

— nwellnhof
स्रोत

3

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

l=input()
a=[(L<R>C)-(R<L>C)for L,C,R in zip([0]+l,l,l[1:]+[0])]
while any(a):
 i=0
 while a[i]==0:i+=1
 m=a.pop(i);x,y=[i,i+m][::m];l[x:y+1]=l[i]+l[i+m],
print l

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

— आउटगोल्फर को एरिक करें
स्रोत

3

जे , 45 बाइट्स

+//.~0,[:+/\2(<+.1=*)/\3(>./1:/@I.@E.])\0,,&0

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

पुनरावर्ती के मूल स्टैक्स उत्तर से प्रेरित

— जोनाह
स्रोत

3

आर , 222 196 173 बाइट्स

यहाँ रॉबिन राइडर की कुछ मदद से एक समाधान है

n=length(d<-diff(y<-x<-scan()));l=c(1,sign(d[-n]+d[-1]),-1);m=!!l*n&c(d[1]>0,d[-1]>0|d[-n]<0,d[n]<0);for(t in 1:n){for(i in which(m))y[a]=y[a<-i+l[i]]+x[i];y=x=y-x*m};x[!m]

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

टिप्पणियों का एक छोटा सेट

n=length(d<-diff(y<-x<-scan()));  #read input and compute pairwise differences
                    #d[-n]+d[-1]: compare left and right differences
l=c(1,sign(d[-n]+d[-1]),-1)                 #direction of attraction
m=!!l*n&                          #indices of attracted numbers
  c(d[1]>0,d[-1]>0|d[-n]<0,d[n]<0)  
                                   #!!l*n eliminates zeroes in l & the case n==0
for(t in 1:n){                   #excessive loop on transfers
 for(i in which(m))
   y[a]=y[a<-i+l[i]]+x[i]         #transfer right vs. left
 y=x=y-m*x}                        #complete transfer
x[!m]                             #output

— शीआन
स्रोत

1

के sign(e)बजाय -4 बाइट्स(e>0)-(e<0)

— रॉबिन राइडर

1

भी {}में पाश के लिए अनावश्यक हैं के बाद से वहाँ पाश में केवल एक ही शिक्षा है।

— रॉबिन राइडर

1

उपरोक्त 2 टिप्पणियों के साथ 189 बाइट्स + की परिभाषा को आगे बढ़ाते हुए y।

— रॉबिन राइडर

1

इस तथ्य का उपयोग करते हुए 179 बाइट्स कि mएक बूलियन है

— रॉबिन राइडर

3

पायथन, 114 112 बाइट्स

lambda a:eval('['+'+'.join(str(c)+',0'*((e<c>d)==(c<d>b))for b,c,d,e in zip([0]+a,a,a[1:]+[0],a[2:]+[0,0]))+']')

यह इस तथ्य का उपयोग करता है कि तीर की दिशा वास्तव में मायने नहीं रखती है, और यह कि [i] और [i + 1] के बीच एक तीर की उपस्थिति चार तत्वों की सीमा को देखकर निर्धारित की जा सकती है [i- 1: मैं 3 +]।

संपादित करें: नियम स्पष्टीकरण के लिए जो किंग को धन्यवाद

— rikhavshah
स्रोत

2

पर्ल 5 , 156 147 बाइट्स

$q='$F[$i';map{eval"\$i++while$q]$_"}"<$q+1]",">$q+1]&&$q]>$q+2]&&\$i<\@F"if eval"$q-1]-$q+1]||$q]>$q+1]";$\.=$".sum@F[$p..$i];($p=++$i)<@F&&redo}{

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

— Xcali
स्रोत

2

के (ngn / k) , 46 बाइट्स

{+/'x@.={x x}/(!#x)+{-/2=+/x<\:x 2 0}'3'0,x,0}

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

0,x,0 0s के साथ तर्क को घेरें

3' लगातार वस्तुओं की ट्रिपल

{ }' प्रत्येक के लिए

x 2 0वर्तमान ट्रिपल के अंतिम और पहले प्राप्त करें - x[2]और x[0]। वे उस के पड़ोसी हैं x[1], जिस पर त्रिक केंद्रित है

x<\: वर्तमान ट्रिपलेट में से प्रत्येक के मुकाबले कम-से-कम का उपयोग करके तुलना करें

+/योग। परिणाम एक जोड़ी है x[2]और इसके अनुरूप हैx[0]

2=जाँच करें कि या तो पड़ोसी अन्य 2 तत्वों से अधिक है x, 0 या or-1 बूलियनों की एक जोड़ी लौटाएं

-/उन्हें घटाओ। -1 का परिणाम x[1]बाईं ओर, 1 से दाईं ओर आकर्षित होता है, और 0 का अर्थ है कि यह जगह पर रहता है

(!#x)+ पहली वस्तु में 0, दूसरी से 1, आदि जोड़ते हैं, इससे सूचकांकों की गणना होती है कि कौन सी वस्तुएँ आकर्षित होती हैं

{x x}/अभिसरण तक खुद के साथ सूचकांक। परिणाम वे प्रभावी संकेत हैं जिनके कारण प्रत्येक वस्तु अंततः आकर्षित होती है

x@.=xउन लोगों द्वारा समूह (मूल तर्क)। परिणाम सूचियों की एक सूची है

+/' प्रत्येक राशि

— NGN
स्रोत

2

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

(fn[l](loop[o[0]m(vec(map-indexed(fn[i v](def f #(max(nth l(+ % i)0)v))(-(f -1)(f 1)))l))i 0](defn f[x](update o(-(count o)x)#(+(l i)%)))(cond(<=(count m)i)(pop o)(>(m i)0)(recur(f 2)m(inc i))(<(m i)0)(recur(f 1)m(inc i))1(recur(conj(f 1)0)m(inc i)))))

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

स्पष्टीकरण:

(fn [l]
  (loop [o [0]
         m (vec(map-indexed (fn [i v] ; This maps each element l[i] of l to max(l[i-1], l[i]) - max(l[i+1], l[i])
                              (def f #(max (nth l (+ % i) 0) v))
                              (- (f -1) (f 1)))
                            l))       ; l[x] is zero when l[x] is out of bounds of the input vector l
         i 0]
    (defn f [x] (update o (- (count o) x) #(+ (l i) %)))
    ; Defines a function f(x) that returns the result of mapping the (x-1)th to last element of o over the function g(y) = l[i] + y

    (cond
      (<= (count m) i) (pop o) ; If the length of m is less than or equal to i, there are no more elements in m, so return all but the last element of o
      (> (m i) 0) (recur (f 2) m (inc i)) ; If m[i] is positive, l[i] is pulled toward to the previous element, so add l[i] to the 2nd to last element of o
      (< (m i) 0) (recur (f 1) m (inc i)) ; If m[i] is negative, l[i] is pulled toward the next element, so add l[i] to the last element of o
      1 (recur (conj (f 1) 0) m (inc i))))) ; 1 is truthy
      ; If the length of l is less than or equal to i, and m[i] is not positive or negative, we have m[i] = 0, so l[i] is not pulled toward any other element

— TheGreatGeek
स्रोत

1

एपीएल (डायलॉग क्लासिक) , 52 51 बाइट्स

{+/(⊃∘⍵¨⊢)⌸{⍵[⍵]}⍣≡(⍳≢⍵)+{-/2=+⌿⍵∘.<1↓1⌽⍵}¨3,/∊0⍵0}

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

मेरे k उत्तर का अनुवाद

— NGN
स्रोत

1

05AB1E , 21 बाइट्स

0.øŒ3ùεZQXsÂU‚ÆZ≠}Å¡O

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

— ग्रिमी
स्रोत

संख्या के बीच गुरुत्वाकर्षण बल

टिप्पणियाँ

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

टिप्पणी की गई

स्टैक्स , 27 25 23 18 बाइट्स

रेटिना 0.8.2 , 64 बाइट्स

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

व्याख्या

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

व्याख्या

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

जे , 45 बाइट्स

आर , 222 196 173 बाइट्स

पायथन, 114 112 बाइट्स

पर्ल 5 , 156 147 बाइट्स

के (ngn / k) , 46 बाइट्स

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

स्पष्टीकरण:

एपीएल (डायलॉग क्लासिक) , 52 51 बाइट्स

05AB1E , 21 बाइट्स