पड़ोसियों का योग

22

यह एक काफी सरल चुनौती होनी चाहिए।

संख्याओं की एक सरणी के लिए, एक सरणी उत्पन्न करें जहां हर तत्व के लिए सभी पड़ोसी तत्वों को स्वयं जोड़ा जाता है, और उस सरणी का योग लौटाएं।

यहां वह परिवर्तन है जो इनपुट सरणी पर होता है [1,2,3,4,5]

[1,2,3,4,5] => [1+2, 2+1+3, 3+2+4, 4+3+5, 5+4] => [3,6,9,12,9] => 39
 0          => neighbours of item 0, including item 0
[1,2]       => 1 + 2      => 3
   1
[1,2,3]     => 1 + 2 + 3  => 6
     2
  [2,3,4]   => 2 + 3 + 4  => 9
       3
    [3,4,5] => 3 + 4 + 5  => 12
         4
      [4,5] => 4 + 5      => 9

               3+6+9+12+9 => 39

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

[]            => 0 (or falsy)
[1]           => 1
[1,4]         => 10 (1+4 + 4+1)
[1,4,7]       => 28
[1,4,7,10]    => 55
[-1,-2,-3]    => -14
[0.1,0.2,0.3] => 1.4
[1,-20,300,-4000,50000,-600000,7000000] => 12338842

लीडरबोर्ड

कोड स्निपेट दिखाएं

code-golf 
— बैसड्रॉब कंबरवुबवबब
स्रोत
1
— मार्टिन एंडर
क्या हमें फ़्लोटिंग पॉइंट संख्या या केवल पूर्णांक का समर्थन करने की आवश्यकता है?
— corvus_192
@ corvus_192 परीक्षण मामलों में गैर-पूर्णांक शामिल हैं।
— ज्योबिट्स
@Geobits मुझे ध्यान नहीं आया कि, मैं अपना उत्तर संपादित करूँगा।
— corvus_192
2
आपको इसे अगले 2 आयामी सरणियों के साथ करना चाहिए।
— ब्रैडली उफ़नर

जवाबों:

8

MATL , 5 बाइट्स

7BZ+s

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

व्याख्या

7B  % Push array [1, 1, 1], obtained as 7 in binary
Z+  % Take input implicitly. Convolve with [1, 1, 1], keeping size
s   % Sum of resulting array. Display implicitly
— लुइस मेंडो
स्रोत
3
7Bवहाँ पाने के लिए बहुत चालाक उपयोग[1 1 1]
— Suever
मैं MATL नहीं जानता, लेकिन मुझे आश्चर्य है: एक सूची के लिए [a,b,c,...], आप कैसे प्राप्त करते हैं a+bलेकिन प्राप्त करने से बचते हैं a?
— क्रिश्चियन सिवर्स
1
@Christian जोड़-तोड़ ऑपरेशन के माध्यम से किया जाता है। यह आपके द्वारा उल्लिखित आंशिक परिणामों का उत्पादन करेगा, लेकिन इनका बचाव करने वाला एक संस्करण है, क्योंकि यह आउटपुट सरणी बनाता है, जिसमें इनपुट के रूप में केवल कई प्रविष्टियाँ होती हैं। स्वेवर के उत्तर में इसका उपयोग भी किया जाता है
— लुइस मेंडो
19

पायथन, 25 बाइट्स

lambda a:sum((a*3)[1:-1])

यह देखने के लिए कि यह क्यों काम करता है, ओपी में विस्तार को 45 डिग्री से घुमाएं:

             1 + 2                        
           + 1 + 2 + 3                            2 + 3 + 4 + 5
               + 2 + 3 + 4          =       + 1 + 2 + 3 + 4 + 5
                   + 3 + 4 + 5              + 1 + 2 + 3 + 4.
                       + 4 + 5
— लिन
स्रोत
14

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

lambda a:sum(a)*3-a[0]-a[-1]

प्रत्येक अंत तत्व के योग और ऋण का मात्र 3 गुना

— ज़ू ज़ू
स्रोत
मुझे एक साफ 25-बाइट समाधान भी मिला ।
— लिन
1
वास्तव में, क्या होगा अगर aखाली सूची (पहला परीक्षण मामला) है? a[0]फेंक देंगे IndexError, नहीं
— लिन
6

05AB1E , 11 5 बाइट्स

अदनान की बदौलत 6 बाइट बच गईं ।

€Ð¦¨O

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

व्याख्या

€Ð     # triplicate each item in the list
  ¦¨   # remove first and last element
    O  # sum
— Emigna
स्रोत
€Ð¦¨Oकाम करता है :)?
— अदनान
@ अदनान: शानदार! मैंने इसे 3 * के साथ करने का एक तरीका सोचने की कोशिश की, लेकिन मैंने कभी भी इस पर विचार नहीं €Ðकिया €Dकि मैंने पहले भी इस्तेमाल किया है : P
— Emigna
4

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

l=>eval(l.join`+`)*3-l[0]-l.pop()

रिटर्न NaNजब एक खाली सूची दी।

— Arnauld
स्रोत
यदि आप गुणा में शामिल होने पर 2 और पात्रों को काट सकते हैं जैसे किv=>eval(v.join`*3+`+"*2")-v[0]
— Grax32
@ ग्रेक्स - अच्छा! हालाँकि, खाली सरणी के लिए यह अब और गलत नहीं होगा।
— Arnauld
वहाँ हमेशा कुछ है वहाँ नहीं है?
— ग्रैक्स 32
@Grax - नहीं, पहला परीक्षण मामला एक खाली सरणी है।
— Arnauld
4

आर, 75 70 52 34 33 31 बाइट्स

तीन बार योग करें और पहले और अंतिम तत्व को घटाएं

sum(x<-scan())*3-x[1]-tail(x,1)

संपादित करें: @rturnbull के लिए 3 अतिरिक्त बाइट्स सहेजे गए

— Billywob
स्रोत
3

स्काला, 47 बाइट्स

def&(a:Float*)=(0+:a:+0)sliding 3 map(_.sum)sum

प्रीपेंड करता है और एक 0 को जोड़ता है, फिर पड़ोसियों को योग करने के लिए आकार 3 की स्लाइडिंग विंडो का उपयोग करता है, और कुल राशि की गणना करता है

— corvus_192
स्रोत
3

जावा 7, 72 बाइट्स

float c(float[]a){float s=0,l=0;for(float i:a)s+=l=i;return 3*s-l-a[0];}
— Numberknot
स्रोत
मुझे नहीं लगता कि सरणी के पहले और अंतिम तत्वों को दर्शाते हुए अतिरिक्त इनपुट जोड़ना चुनौती की भावना में है।
— ज्योबिट्स
@ जीबिट्स मैं इसे बदल देता हूं .....
— नंबरनोट
ठंडा। आप इसे :) के floatबजाय का उपयोग करके कुछ और गोल्फ कर सकते हैंdouble
— Geobits
क्या मैं इसके बजाय इसका उपयोग कर सकता हूं .... डबल में फ्लोट की परिशुद्धता 2 है।
— 13
1
क्यों नहीं int?
— साइडगेट
3

गणितज्ञ, 34 32 29 बाइट्स

कुछ प्रेरणा ले लिन के नीरस पायथन जवाब ...

Check[3Tr@#-Last@#-#[[1]],0]&

या

Check[3(+##)-#&@@#-Last@#,0]&

या

Check[##-#/3&@@#*3-Last@#,0]&

दुर्भाग्य से, यह दृष्टिकोण मैथेमेटिका में उतना सुविधाजनक नहीं है जितना कि पायथन में है, क्योंकि सूची के पहले और अंतिम तत्व को खाली करने का कोई छोटा और सुरक्षित तरीका नहीं है जो खाली हो सकता है।

— मार्टिन एंडर
स्रोत
2
मुझे सिखाने के लिए +1Check
— ग्रेग मार्टिन
2

MATLAB, 31 28 26 बाइट्स

3 बाइट्स @Luis की बदौलत बच गईं

@(x)sum(conv(x,1:3>0,'s'))

यह एक अनाम फ़ंक्शन बनाता ansहै जिसे नाम दिया जा सकता है जैसे:ans([1, 2, 3, 4, 5])

एक ऑनलाइन डेमो (जो ऑक्टेव का उपयोग करता है) प्रदान करने के लिए, मुझे अंतिम इनपुट के 'same'बजाय इसका उपयोग 's'करना थाconv

ऑनलाइन डेमो

व्याख्या

हम सभी 1 के कर्नेल के convसाथ कनवल्शन ( ) करते हैं ( 1 x 3एक सरणी बनाकर 1:3और फिर शून्य की तुलना करके >0) और तीसरे इनपुट को निर्दिष्ट करके मूल के आकार को बनाए रखें 'same'या MATLAB में हम बस इसे छोटा कर सकते हैं 's'। हम तो परिणाम के लिए राशि को लागू करते हैं।

— Suever
स्रोत
आप शायद करने के लिए छोटा कर सकते हैं's'
— लुइस Mendo
1
@LuisMendo ओह अच्छा कॉल! MATLAB इसकी अनुमति देता है लेकिन ऑक्टेव (निश्चित रूप से) नहीं है
— स्वेवर
2

जे, 9 बाइट्स

+/@,}.,}:

के लिए [1, 2, 3, 4, 5], पड़ोसी हैं

1 2 3 4 5
1+2
1+2+3
  2+3+4
    3+4+5
      4+5

फिर रकम के विकर्णों के साथ देखें

(2+3+4+5)+(1+2+3+4+5)+(1+2+3+4)

इसलिए हमें केवल इनपुट के योग को उसके सिर के साथ और उसकी पूंछ को हटाए जाने की आवश्यकता है।

प्रयोग

   f =: +/@,}.,}:
   f 1 2 3 4 5
39
   f '' NB. Empty array
0
   f 1
1
   f 1 4
10
   f 1 4 7
28
   f 1 4 7 10
55
   f _1 _2 _3
_14
   f 0.1 0.2 0.3
1.4
   f 1 _20 300 _4000 50000 _600000 7000000
12338842

व्याख्या

+/@,}.,}:  Input: array A
       }:  Return a list with the last value in A removed
    }.     Return a list with the first value in A removed
      ,    Join them
   ,       Join that with A
+/@        Reduce that using addition to find the sum and return
— मील की दूरी पर
स्रोत
अच्छा लगा। और खुश 6k +!
— कॉनर ओ'ब्रायन
2

ब्रेन-फ्लैक , 68 बाइट्स

(<><>)([]){{}({}({})<>{})<>({}<(({})<>{})><>)([][()()])}{}({}{}<>{})

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

स्पष्टीकरण:

#Push a 0
(<><>)

#Push the stack height
([])

#While true:
{

    #Pop the stack height 
    {}

    #Add the sum of the top 3 elements to the other stack, and pop the top of the stack
    ({}({})<>{})<>({}<(({})<>{})><>)

    #Push the new stack height minus two
    ([][()()])

#End
}

#Pop the exhausted counter
{}

#Add the top two numbers to the other stack
({}{}<>)
— DJMcMayhem
स्रोत
2

PowerShell v2 +, 40 बाइट्स

param($a)($a-join'+'|iex)*3-$a[0]-$a[-1]

अन्य उत्तरों के समान, सूची को sums, 3 से गुणा करता है, अंतिम तत्वों को घटाता है। खाली इनपुट के लिए एक शानदार त्रुटि Barfs, और फिर बाहर थूकता है 0, लेकिन चूंकि STDERR को डिफ़ॉल्ट रूप से अनदेखा किया जाता है, यह ठीक है।

PS C:\Tools\Scripts\golfing> .\sum-of-neighbors.ps1 @()
Invoke-Expression : Cannot bind argument to parameter 'Command' because it is an empty string.
At C:\Tools\Scripts\golfing\sum-of-neighbors.ps1:1 char:22
+ param($a)($a-join'+'|iex)*3-$a[0]-$a[-1]
+                      ~~~
    + CategoryInfo          : InvalidData: (:String) [Invoke-Expression], ParameterBindingValidationException
    + FullyQualifiedErrorId : ParameterArgumentValidationErrorEmptyStringNotAllowed,Microsoft.PowerShell.Commands.InvokeExpressionCommand

0

PS C:\Tools\Scripts\golfing> .\sum-of-neighbors.ps1 @(1)
1

PS C:\Tools\Scripts\golfing> .\sum-of-neighbors.ps1 @(1,4)
10

PS C:\Tools\Scripts\golfing> .\sum-of-neighbors.ps1 @(1,4,7)
28

PS C:\Tools\Scripts\golfing> .\sum-of-neighbors.ps1 @(1,4,7,10)
55

PS C:\Tools\Scripts\golfing> .\sum-of-neighbors.ps1 @(-1,-2,-3)
-14

PS C:\Tools\Scripts\golfing> .\sum-of-neighbors.ps1 @(0.1,0.2,0.3)
1.4

PS C:\Tools\Scripts\golfing> .\sum-of-neighbors.ps1 @(1,-20,300,-4000,50000,-600000,7000000)
12338842
— AdmBorkBork
स्रोत
ParameterArgumentValidationErrorEmptyStringNotAllowedಠ_ an क्या अपवाद है!
— केड
2

रूबी, 35 33 31 बाइट्स

लिन के समाधान से प्रेरित:

->a{[*(a*3)[1..-2]].reduce:+}

to_aखंड खाली सरणी को संभालने के लिए होती है।

EDIT: m-chrzan और histocrat का धन्यवाद।

— ली डब्ल्यू
स्रोत
आपको चारों ओर कोष्ठक की आवश्यकता नहीं है :+।
— m-chrzan
[*(a*3)[1..-2]].to_aदो कम बाइट्स में करता है।
— हिस्टोक्रैट
आप रूबी को 2.4.0 देना चाहते हैं। इसके साथ आता है Array#sum।
— मार्टिन एंडर
2

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

{.sum*3-.[0]-(.[*-1]//0)}    # generates warning
{+$_&&.sum*3-.[0]-.[*-1]}

विस्तारित:

# bare block lambda with implicit parameter ｢$_｣
{
  +$_        # the number of elements

  &&         # if that is 0 return 0, otherwise return the following

  .sum * 3   # sum them up and multiply by 3
  - .[ 0 ]   # subtract the first value
  - .[*-1]   # subtract the last value
}

परीक्षा:

use v6.c;
use Test;

my &code = {+$_&&.sum*3-.[0]-.[*-1]}

my @tests = (
  []            => 0,
  [1]           => 1,
  [1,4]         => 10,
  [1,4,7]       => 28,
  [1,4,7,10]    => 55,
  [-1,-2,-3]    => -14,
  [0.1,0.2,0.3] => 1.4,
  [1,-20,300,-4000,50000,-600000,7000000] => 12338842,
);

plan +@tests;

for @tests -> $_ ( :key(@input), :value($expected) ) {
  is code(@input), $expected, .gist;
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
1

PHP, 39 बाइट्स

<?=3*array_sum($a=$argv)-$a[1]-end($a);

इस तरह से चलाएं:

echo '<?=3*array_sum($a=$argv)-$a[1]-end($a);' | php -- 1 -20 300 -4000 50000 -600000 7000000 2>/dev/null;echo

व्याख्या

पहली और आखिरी संख्या (दो बार जोड़ा गया) को छोड़कर, हर संख्या को 3 बार जोड़ने के लिए चुनौती को कम किया जा सकता है। इसलिए मैं 3 गुना राशि लौटाता हूं, पहली और आखिरी संख्या घटाता हूं।

— aross
स्रोत
1

> <> , 25 (+3) के लिए -v ) = 28 बाइट्स

स्टैक से इनपुट लेता है  -vऔर मान लेता है कि स्टड खाली है, एक -1मूल्य प्रदान करने के लिए उस पर निर्भर है ।

:{:}+i*v
:$v?=1l<+++:
;n<
— हारून
स्रोत
1

LINQ, 42 बाइट्स के साथ C #

a=>3*a.Sum()-(a.Length>0?a[0]+a.Last():0);

System.Linqनामस्थान की आवश्यकता है ।

सी #, 84 बाइट्स

a=>{int i=0,l=a.Length;var r=0d;for(;i<l;)r+=3*a[i++];return(l>0?r-a[0]-a[l-1]:0);};

परीक्षण मामलों के साथ पूरा कार्यक्रम:

using System;

namespace SumOfNeighbours
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<double[],double>f= a=>{int i=0,l=a.Length;var r=0d;for(;i<l;)r+=3*a[i++];return(l>0?r-a[0]-a[l-1]:0);};


            // test cases:
            double[] x = new double[]{1,2,3,4,5};
            Console.WriteLine(f(x));    // 39

            x = new double[] {};
            Console.WriteLine(f(x));    // 0

            x = new double[] {1};
            Console.WriteLine(f(x));    // 1

            x = new double[] {1,4};
            Console.WriteLine(f(x));    // 10 (1+4 + 4+1)

            x = new double[] {1,4,7};
            Console.WriteLine(f(x));    // 28

            x = new double[] {1,4,7,10};
            Console.WriteLine(f(x));    // 55

            x = new double[] {-1,-2,-3};
            Console.WriteLine(f(x));    // -14

            x = new double[] {0.1,0.2,0.3};
            Console.WriteLine(f(x));    // 1.4

            x = new double[] {1,-20,300,-4000,50000,-600000,7000000};
            Console.WriteLine(f(x));    // 12338842
        }
    }
}
— adrianmp
स्रोत
1

रैकेट 48 बाइट्स

(if(null? l)0(-(* 3(apply + l))(car l)(last l)))

Ungolfed:

(define (f lst)
  (if (null? lst)
      0
      (- (* 3 (apply + lst))
         (first lst)
         (last lst))))

परिक्षण: 

(f '()) 
(f '(1))
(f '(1 4)) 
(f '(1 4 7)) 
(f '(1 4 7 10)) 
(f '(-1 -2 -3)) 
(f '(0.1 0.2 0.3)) 
(f '(1 -20 300 -4000 50000 -600000 7000000))

आउटपुट: 

0
1
10
28
55
-14
1.4000000000000001
12338842
— rnso
स्रोत
1

ग्लो , 12 बाइट्स

ग्लू की एक विशेषता को चालू करने का इरादा काम नहीं कर रहा है इसलिए मुझे यह एक दर्दनाक तरीका करना पड़ा।

__]:]:]:,,[+

स्पष्टीकरण:

__                   // duplicate the input list twice
  ]:]:]:             // flatten each list, and rotate stack left 
        ,,           // pop the last 2 numbers 
                     // (which are the first and last element of the list)
          [+         // wrap all items in a list and sum.
— Kade
स्रोत
1

अमृत , 93 बाइट्स

&if (length(&1)>0),do: Enum.reduce(&1,fn(n,r)->n+r end)*3-Enum.at(&1,0)-List.last(&1),else: 0

बेनामी फ़ंक्शन कैप्चर ऑपरेटर का उपयोग करते हुए।

परीक्षण मामलों के साथ पूरा कार्यक्रम:

s=&if (length(&1)>0),do: Enum.reduce(&1,fn(n,r)->n+r end)*3-Enum.at(&1,0)-List.last(&1),else: 0
# test cases:
IO.puts s.([])            # 0
IO.puts s.([1])           # 1
IO.puts s.([1,4])         # 10 (1+4 + 4+1)
IO.puts s.([1,4,7])       # 28
IO.puts s.([1,4,7,10])    # 55
IO.puts s.([-1,-2,-3])    # -14
IO.puts s.([0.1,0.2,0.3]) # 1.4
IO.puts s.([1,-20,300,-4000,50000,-600000,7000000]) # 12338842

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

— adrianmp
स्रोत
1

टीआई-बेसिक, 17 बाइट्स

बस सूची के योग का तीन गुना, पहला और अंतिम तत्व शून्य से।

3sum(Ans)-Ans(1)-Ans(dim(Ans)-1
— Timtech
स्रोत
मेरा मानना ​​है कि मेटा पर आम सहमति Ansइनपुट का एक अमान्य रूप है।
— कॉनर ओ'ब्रायन
आप इसे एक सूची के साथ उपयोग कर सकते हैं, चिंता न करें। इसे पास करें जैसे{1,3,5,7,2,6}:prgmNEIGHBOR
— टाइमटेक
यह अभी भी Ansइनपुट के रूप में है।
— कॉनर ओ'ब्रायन
क्या ऐसा लगता है कि मुझे परवाह है? यह TI-Basic में इनपुट पास करने का मानक तरीका है।
— टिमटेक
as much as I agree with you, that doesn't make the answer any more valid.
— Conor O'Brien
1

Ruby, 41 bytes

->a{a.reduce(0,:+)*3-(a[0]?a[0]+a[-1]:0)}

Full program with test cases:

f=->a{a.reduce(0,:+)*3-(a[0]?a[0]+a[-1]:0)}

#test cases
a=[]            
puts f.call(a)  # 0

a=[1]           
puts f.call(a)  # 1

a=[1,4]         
puts f.call(a)  # 10

a=[1,4,7]       
puts f.call(a)  # 28

a=[1,4,7,10]    
puts f.call(a)  # 55

a=[-1,-2,-3]    
puts f.call(a)  # -14

a=[0.1,0.2,0.3] 
puts f.call(a)  # 1.4

a=[1,-20,300,-4000,50000,-600000,7000000] 
puts f.call(a)  # 12338842

My first attempt in Ruby.

— adrianmp
स्रोत
As of Ruby 2.4.0 there's Array#sum. I haven't yet installed the preview release though to test whether this can simply be dropped into this solution.
— Martin Ender
1

C++, 67 bytes

#import<valarray>
int f(std::valarray<int>v){return 3*v.sum()-v[0]-v[v.size()-1];}

Usage:

#include <iostream>
int main() {
    std::cout << f({1,2,1});
    return 0;
}
— Anedar
स्रोत
1

Haskell, 25 bytes

From fastest

sum.sequence[(0-).head,(3*).sum,(0-).last]$[1..5]

via prettiest

sum.sequence[sum.init,sum,sum.tail]$[1..5]

down to ugliest but shortest

let y x=sum$init x++x++tail x in y[1..5]     
--  1234567890123456789012345
— Roman Czyborra
स्रोत
1

Batch, 67 bytes

@set/as=l=0
@for %%n in (%*)do @set/as+=l=%%n
@cmd/cset/as*3-%1-l

If there are no parameters, the last command turns into 0 * 3 - -0.

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