Cela devrait être un défi assez simple.

Pour un tableau de nombres, générez un tableau où pour chaque élément tous les éléments voisins sont ajoutés à lui-même et retournez la somme de ce tableau.

Voici la transformation qui se produit sur le tableau d'entrée [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

Cas de test

[]            => 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

Classement

var QUESTION_ID=96188,OVERRIDE_USER=41257;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

MATL , 5 octets

7BZ+s

Essayez-le en ligne!

Explication

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

Python, 25 octets

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

Pour voir pourquoi cela fonctionne, faites pivoter l'expansion de l'OP de 45 degrés:

             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

Python 2, 28 octets

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

Juste 3 fois la somme et moins un de chaque élément d'extrémité

05AB1E , 11 5 octets

6 octets enregistrés grâce à Adnan .

€Ð¦¨O

Essayez-le en ligne!

Explication

€Ð     # triplicate each item in the list
  ¦¨   # remove first and last element
    O  # sum

JavaScript (ES6), 40 33 octets

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

Renvoie NaNlorsque donné une liste vide.

R, 75 70 52 34 33 31 octets

Additionner trois fois et soustraire le premier et le dernier élément

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

Edit: enregistré 3 octets supplémentaires grâce à @rturnbull

Scala, 47 octets

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

Ajoute et ajoute un 0, puis utilise une fenêtre coulissante de taille 3 pour additionner les voisins et calcule la somme totale

Java 7, 72 octets

float c(float[]a){float s=0,l=0;for(float i:a)s+=l=i;return 3*s-l-a[0];}

Mathematica, 34 32 29 octets

Inspiré par la réponse soignée de Lynn en Python ...

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

ou

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

ou

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

Malheureusement, cette approche n'est pas aussi pratique dans Mathematica que dans Python, car il n'existe aucun moyen court et sûr de supprimer le premier et le dernier élément d'une liste qui pourrait être vide.

MATLAB, 31 28 26 octets

3 octets économisés grâce à @Luis

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

Cela crée une fonction anonyme nommée ansqui peut être appelée comme:ans([1, 2, 3, 4, 5])

Afin de fournir une démo en ligne (qui utilise Octave), j'ai dû utiliser 'same'au lieu de 's'comme dernière entrée pourconv

Démo en ligne

Explication

Nous effectuons la convolution ( conv) avec un 1 x 3noyau de tous les 1 (créé en créant un tableau 1:3puis en le comparant à zéro >0) et conservons la taille de l'original en spécifiant la troisième entrée comme 'same'ou dans MATLAB, nous pouvons simplement raccourcir cela 's'. Nous appliquons ensuite la somme au résultat.

Gelée , 5 octets

ẋ3ṖḊS

Essayez-le en ligne!

Traduction de ma réponse Python .

ẋ3      Concatenate three copies of the input list
  Ṗ     Remove the last element
   Ḋ    Remove the first element
    S   Sum

J, 9 octets

+/@,}.,}:

Car [1, 2, 3, 4, 5]les voisins sont

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

Regardez ensuite le long des diagonales des sommes

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

Il suffit donc de trouver la somme de l'entrée avec sa tête retirée et sa queue retirée.

Usage

   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

Explication

+/@,}.,}:  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

Brain-Flak , 68 octets

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

Essayez-le en ligne!

Explication:

#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
({}{}<>)

PowerShell v2 +, 40 octets

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

Semblable aux autres réponses, résume la liste, multiplie par 3, soustrait les éléments finaux. Supprime une erreur spectaculaire pour une entrée vide, puis crache 0, mais comme STDERR est ignoré par défaut, c'est OK.

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

Rubis, 35 33 31 octets

Inspiré par la solution de Lynn:

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

Le to_asegment est là pour gérer le tableau vide.

EDIT: Merci à m-chrzan et histocrat.

Perl 6 , 25 octets

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

Étendu:

# 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
}

Tester:

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;
}

PHP, 39 octets

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

Courez comme ceci:

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

Explication

Le défi peut être réduit à l'ajout de chaque numéro 3 fois, sauf le premier et le dernier numéro (ajouté deux fois). Par conséquent, je retourne 3 fois la somme, moins le premier et le dernier nombre.

> <> , 25 (+3 pour -v ) = 28 octets

Prend l'entrée de la pile avec  -vet suppose que stdin est vide, en s'appuyant sur elle pour fournir une -1valeur.

:{:}+i*v
:$v?=1l<+++:
;n<

C # avec LINQ, 42 octets

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

Nécessite l' System.Linqespace de noms.

C #, 84 octets

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);};

Programme complet avec cas de test:

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
        }
    }
}

Raquette 48 octets

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

Non golfé:

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

Essai:

(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)) 

Sortie:

0
1
10
28
55
-14
1.4000000000000001
12338842

Gloo , 12 octets

Il s'avère qu'une fonctionnalité de Gloo ne fonctionne pas comme prévu, j'ai donc dû le faire de manière douloureuse.

__]:]:]:,,[+

Explication:

__                   // 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.

Elixir , 93 octets

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

Fonction anonyme utilisant l'opérateur de capture.

Programme complet avec cas de test:

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

Essayez-le en ligne sur ElixirPlayground !

TI-Basic, 17 octets

Simplement trois fois la somme de la liste, moins le premier et le dernier élément.

3sum(Ans)-Ans(1)-Ans(dim(Ans)-1

Rubis, 41 octets

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

Programme complet avec cas de test:

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

Ma première tentative en Ruby.

Javascript, 46 octets

a.reduce((t,c,i)=>t+(a[i-1]|0)+c+(a[i+1]|0),0)

const a = [1,2,3,4,5];
console.log(a.reduce((t,c,i)=>t+(a[i-1]|0)+c+(a[i+1]|0),0));

Merci @rlemon pour les 2 octets supplémentaires

Pyke, 9 5 octets

3*tOs

Essayez-le ici!

Java 8, 60

d->d.length>0?Arrays.stream(d).sum()*3-d[0]-d[d.length-1]:0;

C ++, 67 octets

#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;
}

Haskell, 25 octets

Du plus rapide

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

via plus jolie

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

jusqu'à la plus laide mais la plus courte

let y x=sum$init x++x++tail x in y[1..5]     
--  1234567890123456789012345

Lot, 67 octets

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

S'il n'y a pas de paramètres, la dernière commande devient 0 * 3 - -0.