Somme des voisins

22

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

Afficher l'extrait de code

code-golf 
— Bassdrop Cumberwubwubwub
source
1
— Martin Ender
Avons-nous besoin de prendre en charge les nombres à virgule flottante ou uniquement les nombres entiers?
— corvus_192
@ corvus_192 Les cas de test incluent des non-entiers.
— Geobits
@Geobits Je ne l'ai pas remarqué, je vais modifier ma réponse.
— corvus_192
2
Vous devriez faire cela avec des tableaux bidimensionnels ensuite.
— Bradley Uffner

Réponses:

8

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
— Luis Mendo
source
3
Utilisation très intelligente de 7Blà pour obtenir[1 1 1]
— Suever
Je ne connais pas MATL, mais je me demande: pour une liste [a,b,c,...], comment obtenez-vous a+bmais évitez-vous de l'obtenir a?
— Christian Sievers
1
@Christian L'addition se fait au moyen d'une opération de convolution. Cela produirait les résultats partiels auxquels vous vous référez, mais il existe une version de convolution qui les évite, car elle produit un tableau de sortie avec seulement autant d'entrées que l'entrée. Ceci est également utilisé dans la réponse de Suever
— Luis Mendo
19

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
— Lynn
source
14

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é

— Zoo Zoo
source
J'ai également trouvé une solution soignée de 25 octets .
— Lynn
1
En fait, que faire si ala liste est vide (premier cas de test)? a[0]va jeter un IndexError, non?
— Lynn
6

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
— Emigna
source
Ça €Ð¦¨Omarche :)?
— Adnan
@Adnan: Brillant! J'ai essayé de penser à un moyen de le faire avec 3 *, mais je n'ai même jamais envisagé €Ðmême si j'en ai utilisé €Dauparavant: P
— Emigna
4

JavaScript (ES6), 40 33 octets

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

Renvoie NaNlorsque donné une liste vide.

— Arnauld
source
Vous pouvez couper 2 caractères supplémentaires si vous déplacez la multiplication dans la jointure comme ceciv=>eval(v.join`*3+`+"*2")-v[0]
— Grax32
@Grax - Nice! Cependant, ce ne serait plus faux pour le tableau vide.
— Arnauld du
Il y a toujours quelque chose qui n'est pas là?
— Grax32
@Grax - Non. Le premier cas de test est un tableau vide.
— Arnauld
4

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

— Billywob
source
3

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

— corvus_192
source
3

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];}
— Numberknot
source
Je ne pense pas que l'ajout d'entrées supplémentaires indiquant les premier et dernier éléments du tableau soit dans l'esprit du défi.
— Geobits
@Geobits je le change .....
— Numberknot
Cool. Vous pouvez floatdouble
— jouer au
Puis-je l'utiliser à la place .... Double a 2x la précision du flotteur.
— Numberknot
1
pourquoi pas ints?
— sidgate
3

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.

— Martin Ender
source
2
+1 pour m'avoir Check
— appris
2

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.

— Suever
source
Vous pouvez probablement raccourcir à's'
— Luis Mendo
1
@LuisMendo Oh bon appel! MATLAB le permet mais Octave ne le fait pas (bien sûr)
— Suever
2

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
— miles
source
Agréable. Et heureux 6k +!
— Conor O'Brien
2

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
({}{}<>)
— DJMcMayhem
source
2

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
— AdmBorkBork
source
ParameterArgumentValidationErrorEmptyStringNotAllowedಠ_ಠ Quelle exception!
— Kade
2

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.

— Lee W
source
Vous n'avez pas besoin de parenthèses autour :+.
— m-chrzan
[*(a*3)[1..-2]]fait .to_aen deux octets de moins.
— histocrate
Vous voudrez peut-être essayer Ruby 2.4.0. Il vient avec Array#sum.
— Martin Ender
2

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;
}
— Brad Gilbert b2gills
source
1

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.

— aross
source
1

> <> , 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<
— Aaron
source
1

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
        }
    }
}
— adrianmp
source
1

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
— rnso
source
1

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.
— Kade
source
1

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 !

— adrianmp
source
1

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
— Timtech
source
Je crois que le consensus sur la méta dit que Ansc'est une forme d'entrée invalide.
— Conor O'Brien
Vous pouvez l'utiliser avec une liste, ne vous inquiétez pas. Passez le comme{1,3,5,7,2,6}:prgmNEIGHBOR
— Timtech
C'est toujours Ansen entrée.
— Conor O'Brien
Est-ce qu'on dirait que ça me fait quelque chose? C'est la manière standard de transmettre des entrées dans TI-Basic.
— Timtech
autant que je sois d'accord avec vous, cela ne rend pas la réponse plus valable.
— Conor O'Brien
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.

— adrianmp
source
Depuis Ruby 2.4.0, il y en a Array#sum. Je n'ai pas encore installé la version d'aperçu pour tester si cela peut simplement être déposé dans cette solution.
— Martin Ender
1

Java 8, 60

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

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;
}
— Anedar
source
1

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
— Roman Czyborra
source
1

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.

— Neil
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.