Tâche

Étant donné une liste d'entiers L et d'un autre entier s , l'objectif est de calculer les sommes par colonne de toutes les tranches de longueur s (potentiellement chevauchantes) de L , tout en se référant à leur position par rapport à L (voir ci-dessous).

Définitions

Les s -longueur (chevauchement) des tranches de la liste L sont toutes les sous- séquences contiguës (sans enveloppe) de L qui sont d' une longueur s .

Afin de déterminer les positions des tranches s par rapport à L , vous pouvez imaginer construire une "échelle", où chaque tranche s _i a un décalage de i positions depuis le début.

Spécifications

• s est un nombre entier supérieur à 1 et strictement inférieure à la longueur de L .
• L contiendra toujours au moins 3 éléments.
• Vous pouvez concurrencer dans n'importe quel langage de programmation et pouvez prendre des entrées et fournir des sorties par n'importe quelle méthode standard , tout en prenant note que ces failles sont interdites par défaut. Il s'agit de code-golf , donc la soumission la plus courte (en octets) pour chaque langue l' emporte.

Exemples et cas de test

Voici un exemple travaillé:

[1, 2, 3, 4, 5, 6, 7, 8, 9], 3

[1, 2, 3]
   [2, 3, 4]
      [3, 4, 5]
         [4, 5, 6]
            [5, 6, 7]
               [6, 7, 8]
                  [7, 8, 9]
-------------------------------- (+)  | column-wise summation
[1, 4, 9, 12, 15, 18, 21, 16, 9]

Et quelques autres cas de test:

[1, 3, 12, 100, 23], 4         -> [1, 6, 24, 200, 23]
[3, -6, -9, 19, 2, 0], 2       -> [3, -12, -18, 38, 4, 0]
[5, 6, 7, 8, 2, -4, 7], 3      -> [5, 12, 21, 24, 6, -8, 7]
[1, 2, 3, 4, 5, 6, 7, 8, 9], 3 -> [1, 4, 9, 12, 15, 18, 21, 16, 9]
[1, 1, 1, 1, 1, 1, 1], 6       -> [1, 2, 2, 2, 2, 2, 1]
[1, 2, 3, 4, 5, 6, 7, 8, 9], 6 -> [1, 4, 9, 16, 20, 24, 21, 16, 9]

J , 11, 9 8 octets

-1 octet grâce aux miles!

[:+//.]\

Comment ça fonctionne?

L'argument de gauche est s, celui de droite - L

]\ - divise L en sous-listes de longueur s

/. - extrait les diagonales obliques (anti-diagonales)

+/ - les additionne

[: - fait une fourchette à partir des verbes ci-dessus

Voici un exemple de session J pour le premier cas de test:

   a =. 1 2 3 4 5 6 7 8 9

   ] 3 ]\ a 
1 2 3
2 3 4
3 4 5
4 5 6
5 6 7
6 7 8
7 8 9

   ] </. 3 ]\ a 
┌─┬───┬─────┬─────┬─────┬─────┬─────┬───┬─┐
│1│2 2│3 3 3│4 4 4│5 5 5│6 6 6│7 7 7│8 8│9│
└─┴───┴─────┴─────┴─────┴─────┴─────┴───┴─┘

   ] +//. 3 ]\ a 
1 4 9 12 15 18 21 16 9

Essayez-le en ligne!

Haskell , 59 56 octets

s#n=[x*minimum[n,i,length s+1-max i n]|(i,x)<-zip[1..]s]

Essayez-le en ligne!

Définit une fonction (#)qui prend une liste set un nombre ncomme arguments.

Ceci est basé sur l'observation que pour s = [1, 2, 3, 4, 5, 6, 7, 8, 9]etn = 3

[1, 2, 3]
   [2, 3, 4]
      [3, 4, 5]
         [4, 5, 6]
            [5, 6, 7]
               [6, 7, 8]
                  [7, 8, 9]
---------------------------- (+)
[1, 4, 9,12,15,18,21,16, 9]

est le même que

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 3, 3, 3, 3, 2, 1]
---------------------------- (*)
[1, 4, 9,12,15,18,21,16, 9]

Pour générer cette liste initialement croissante, puis constante et enfin décroissante, on peut commencer par

[minimum[i, length s + 1 - i] | i<-[1..length s]]

qui cède [1, 2, 3, 4, 5, 4, 3, 2, 1]. L'ajout en ntant que contrainte supplémentaire dans l' minimumexpression donne la [1, 2, 3, 3, 3, 3, 3, 2, 1]réponse de liste correcte pour n = 3, bien que pour n = 6(ou en général n'importe quelle n > lengths s/2) la contrainte supplémentaire length s + 1 - nsoit nécessaire:

[minimum[i, n, length s + 1 - i, length s + 1 - n] | i<-[1..length s]]

ou plus court:

[minimum[i, n, length s + 1 - max i n] | i<-[1..length s]]

Pour la multiplication par paire [1..length s]est compressée avec s, et parce que ziptronque la liste la plus longue à la longueur de la plus courte, la liste infinie [1..]peut être utilisée:

[x * minimum[i, n, length s + 1 - max i n] | (i,x)<-zip[1..]s]

JavaScript (ES6), 65 62 58 octets

4 octets enregistrés grâce à @Shaggy

Prend une entrée dans la syntaxe de curry (a)(n).

a=>n=>a.map((v,i)=>v*Math.min(++i,n,a.length+1-(n>i?n:i)))

Cas de test

let f =

a=>n=>a.map((v,i)=>v*Math.min(++i,n,a.length+1-(n>i?n:i)))

console.log(JSON.stringify(f([1, 3, 12, 100, 23]        )(4))) // [1, 6, 24, 200, 23]
console.log(JSON.stringify(f([3, -6, -9, 19, 2, 0]      )(2))) // [3, -12, -18, 38, 4, 0]
console.log(JSON.stringify(f([5, 6, 7, 8, 2, -4, 7]     )(3))) // [5, 12, 21, 24, 6, -8, 7]
console.log(JSON.stringify(f([1, 2, 3, 4, 5, 6, 7, 8, 9])(3))) // [1, 4, 9, 12, 15, 18, 21, 16, 9]
console.log(JSON.stringify(f([1, 1, 1, 1, 1, 1, 1]      )(6))) // [1, 2, 2, 2, 2, 2, 1]
console.log(JSON.stringify(f([1, 2, 3, 4, 5, 6, 7, 8, 9])(6))) // [1, 4, 9, 16, 20, 24, 21, 16, 9]

Java 8, 83 octets

L->s->{for(int i=0,l=L.length+1,t,u;++i<l;u=l-(s>i?s:i),L[i-1]*=t<u?t:u)t=i<s?i:s;}

Ce premier cas de test (et les deux derniers que j'ai ajoutés) m'a foutu plusieurs fois, mais cela fonctionne finalement maintenant ..: D

Modifie le tableau d'entrée au lieu d'en renvoyer un nouveau.

Explication:

Essayez-le en ligne.

L->s->{                  // Method with int-array and int parameters, and no return-type
  for(int i=0,           //  Index-integer, starting at 0
      l=L.length+1,      //  The length of the input-array + 1
      t,u;               //  Two temp integers
      ++i<l              //  Loop `i` from 1 to the length (inclusive)
      ;                  //    After every iteration:
       u=l               //     Set temp integer `u` to the length plus 1,
          -(s>i?s:i),    //     minus the highest of `s` and `i`
       L[i-1]*=t<u?t:u)  //     And replace the item with the lowest of `t` and `u`
    t=i<s?i:s;}          //   Set temp integer `t` to the lowest of `i` or `s`

05AB1E , 12 octets

)IŒIùvyNÅ0ì+

Essayez-le en ligne!

MATL , 8 octets

YCPT&Xds

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Considérez les entrées [1, 3, 12, 100, 23]et 4.

YC     % Implicit inputs: row vector L and number s. Create matrix of 
       % overlapping blocks of L with length s, where each block is a column
       % STACK: [  1   3;
                   3  12;
                  12 100;
                 100  23]
P      % Flip vertically
       % STACK: [100  23;
                  12 100;
                   3  12;
                   1   3]
&TXd   % Extract all diagonals, starting from bottom-left, and arrange them as
       % columns of a matrix, with zero padding
       % STACK: [1   3  12 100   0;
                 0   3  12 100  23]
s      % Sum of each column. Since s is less than the length of L, there are
       % at least two rows. Thus function `s` can be used instead of `Xs`.
       % Implicit display
       % STACK: [1   6  24 200  23]

APL (Dyalog Unicode) , 19 14 octets ^SBCS

-5 grâce à ngn.

Fonction infixe tacite anonyme prenant s comme argument de gauche et L comme argument de droite. Suppose ⎕IO( I ndex O rigin) être 0tel quel par défaut sur de nombreux systèmes.

+⌿∘↑((0,⊢)\,/)

Essayez-le en ligne!

Explication avec l'exemple de cas [1,3,12,100,23]

(… ) Appliquez la fonction tacite anonyme suivante:

 ,/ fenêtres superposées de cette taille; [[1,3,12],[3,12,100],[12,100,23]]

 (… )\ Appliquer cumulativement à cette tacite la fonction tacite anonyme suivante:

  ⊢ le bon argument (le plus)

  0, avec un zéro à gauche

La réduction cumulative signifie que nous insérons la fonction dans chaque "espace" entre les termes successifs, en progressant de droite à gauche. Pour chaque "espace", la fonction supprimera l'argument de gauche mais ajoutera un zéro supplémentaire. En effet, cela ajoute autant de zéros à chaque terme qu'il y a d '"espaces" à sa gauche, donc le premier terme n'a aucun espace, le second en a un et le troisième en a deux:[[1,3,12],[0,3,12,100],[0,0,12,100,23]]

↑ augmenter le classement en combinant les listes en une seule matrice, en complétant par des zéros;
 ┌ ┐
 │1 3 12 0 0│
 │0 3 12 100 0│
 │0 0 12 100 23│
 └ ┘
∘ puis
+⌿ additionnez verticalement;[1,6,36,200,23]

Gelée , 6 octets

JṡṬS×ḷ

Essayez-le en ligne!

Comment ça fonctionne

JṡṬS×ḷ  Main link. Left argument: A (array). Right argument: n (integer)

J       Indices; yield [1, ..., len(A)].
 ṡ      Split the indices into overlapping slices of length n.
  Ṭ     Untruth; map each array of indices to a Boolean vector, with 1's at the
        specified indices and 0's elsewhere.
        For example, [3, 4, 5] maps to [0, 0, 1, 1, 1].
   S    Sum the rows, essentially counting how many times each index appears in
        the arrays returned by the ṡ atom.
     ḷ  Left; yield A.
    ×   Multiply the counts to the left with the integers to the right.

Japt , 13 octets

Il a fallu beaucoup trop de temps pour que cela fonctionne quand s> L/2!

Ë*°EmVUÊÄ-EwV

Essayez-le

Explication

                 :Implicit input of array U and integer V
Ë                :Map over each element at 0-based index E in U
 *               :  Multiply by
    m            :  The minumum of
  °E             :    E incremented,
     V           :    V,
          EwV    :    and the maximum of E & V
         -       :    subtracted from
      UÊÄ        :    the length of U plus 1

Wolfram Language (Mathematica) , 42 octets

Min[i,#2,l+1-{i,#2}]~Table~{i,l=Tr[1^#]}#&

Essayez-le en ligne!

Julia , 41 octets

a\n=(a[L=end];a.*min(1:L,L:-1:1,n,L-n+1))

Essayez-le en ligne!

• Redéfinir l' \opérateur.
• a[L=end]est une alternative plus courte à L=length(a).
• Utilise la méthode de Laikoni .

Japt , 13 12 octets

-1 octet grâce à @ETHproductions

ãV
ËEÆÃcDÃyx

Essayez-le en ligne!

R , 52 51 octets

function(l,s)l*pmin(s,x<-seq(l),y<-rev(x),y[1]+1-s)

Essayez-le en ligne!

Cela équivaut à la réponse de Laikoni .

seq(l)produit les indices 1...length(l)depuis length(l)>1(sinon il produirait 1...l[1]). Je l'enregistre sous x, enregistrez son revers sousy , et prends le premier élément de y( length(l)) pour porter proprement la réponse de Laikoni et enregistrer un octet!

Réponse originale, 52 octets

function(l,s,L=sum(l|1)+1)l*pmin(s,x<-2:L-1,L-x,L-s)

Essayez-le en ligne!

La sortie est lmultipliée par élément par le minimum de s, l'indice basé sur 1 de l'élément x,length(l)-x+1 et length(L)-s+1.

Ceci est également équivalent à la réponse de Laikoni, en utilisant L-xau lieu de rev(x)car il est plus court.

APL + WIN, 25 octets

Invite à saisir l’écran de L suivi de s

+/(1-⍳⍴z)⌽¨(⍴L)↑¨s←⎕,/L←⎕

Explication:

L←⎕ prompt for screen input of L

s←⎕,/ prompt for screen input of s and create nested vector of successive s elements of L

(⍴L)↑¨ pad each element of the nested vector with zeros to the length of L

(1-⍳⍴z)⌽¨ incrementally rotate each element of the nested vector

+/ sum the elements of the nested vector

K (oK) , 30 octets

Solution:

{+/t,'(y':x),'|t:(!1-y-#x)#'0}

Essayez-le en ligne!

Exemple:

{+/t,'(y':x),'|t:(!1-y-#x)#'0}[3 -6 -9 19 2 0;2]
3 -12 -18 38 4 0

Explication:

Ne pense pas que je puisse rivaliser avec J sur celui-ci. Générez une liste de zéros à ajouter et à ajouter à la liste des fenêtres coulissantes, puis résumez:

{ t,'(y':x),'|t:(!(#x)+1-y)#'0 }[1 2 3 4 5 6 7 8 9;3]
(1 2 3 0 0 0 0 0 0
 0 2 3 4 0 0 0 0 0
 0 0 3 4 5 0 0 0 0
 0 0 0 4 5 6 0 0 0
 0 0 0 0 5 6 7 0 0
 0 0 0 0 0 6 7 8 0
 0 0 0 0 0 0 7 8 9)

La répartition est la suivante ... bien que cela semble toujours maladroit.

{+/t,'(y':x),'|t:(!1-y-#x)#'0} / the solution
{                            } / lambda taking x and y implicitly
                          #'0  / take (#) each (') zero
                 (       )     / do this together
                       #x      / count (#) length of x
                     y-        / take count away from length y
                   1-          / take that result from 1
                  !            / til, generate range to that number
               t:              / save in variable t
              |                / reverse it
            ,'                 / join with each
      (y':x)                   / sliding window size y over x
    ,'                         / join with each
   t                           / prepend t
 +/                            / sum up

Husk , 4 octets

mΣ∂X

Essayez-le en ligne!

Utilise l'idée de la réponse J de Galen Ivanov .

Explication

     -- implicit input number n and list s, e.g. s = [1,2,3,4,5,6] and n = 4 
   X -- get sublists of length n of list s           [[1,2,3,4],[2,3,4,5],[3,4,5,6]]
  ∂  -- anti-diagonals                               [[1],[2,2],[3,3,3],[4,4,4],[5,5],[6]]
mΣ   -- get the sum of each of the lists             [1,4,9,12,10,6]

C (gcc) , 100 octets

j,x;f(L,l,s)int*L;{for(j=0;j<l;j++)L[j]*=j<s&j<l-s?-~j:j>s&j>l-s?l-j:(x=s<l-j?s:l-j)<l-~-s?x:l-~-s;}

Essayez-le en ligne!

Python 2 , 68 66 octets

-2 octets grâce à Laikoni

lambda l,n:[v*min(n,i+1,len(l)-max(i,n-1))for i,v in enumerate(l)]

Essayez-le en ligne!

Perl 5 , 63 octets

$b=<>;map{say$_*=$n+$b>@F?$n-$b<0?$i:--$i:$i<$b?++$i:$i;++$n}@F

Essayez-le en ligne!

C (gcc) , 83 81 79 octets

La manipulation de la liste comporte essentiellement trois «phases»: montée en puissance, maintien et refroidissement. À mesure que nous avancerons dans la liste, nous augmenterons notre facteur jusqu'à ce que nous atteignions un maximum. Si une série complète de tranches peut entrer dans la liste, ce maximum sera le même que la longueur des tranches. Sinon, ce sera le même que le nombre de tranches qui correspondent. À l'autre extrémité, nous diminuerons à nouveau le facteur, pour atterrir à 1 sur le dernier élément.

La longueur des phases de montée en puissance et de refroidissement qui serre ce plateau est inférieure de un à ce facteur maximum.

Espérons que les boucles non golfées avant de les combiner le rendent plus clair (R = durée de la phase de montée en puissance):

for (r = 1; r <= R; r++) L[r - 1] *= r;
for (; r < n - R; r++)   L[r - 1] *= R + 1;
for (; r < n; r++)       L[r - 1] *= n - r + 1;

Trois boucles, c'est beaucoup trop, donc décider du facteur basé sur r nous donne une boucle (en utilisant s pour R pour économiser quelques octets):

r;f(L,n,s)int*L;{for(r=0,s=2*s-1>n?n-s:s-1;r++<n;)*L++*=r>s?r<n-s?s+1:n-r+1:r;}

Essayez-le en ligne!

Perl, 45 44 octets

Comprend +4 pour -ai Notez également que ce code donne 2 avertissements perl au démarrage. Vous pouvez les supprimer au prix d'un coup en ajoutant l' Xoption

Donnez la longueur du masque après l' -ioption et le tableau sur une ligne sur STDIN:

perl -ai4 -E 'say$_*grep$_~~[$^I..@F],$a..$^I+$a++for@F' <<< "1 3 12 100 23"

Juste le code:

say$_*grep$_~~[$^I..@F],$a..$^I+$a++for@F

Rubis , 62 octets

->a,l{a.map.with_index{|x,i|x*[i+1,l,a.size-[l-1,i].max].min}}

Essayez-le en ligne!

Essentiellement un portage de la réponse javascript d' Arnauld , sauf que le besoin with_indexest beaucoup plus douloureux.

Dans le temps qu'il m'a fallu pour décider de soumettre cela, j'ai joué au golf à partir de cette version de 70 octets, qui est plus proche de l'algorithme de Dennis .

->a,l{c=a.map{0};(0...a.size).each_cons(l){|h|h.map{|i|c[i]+=a[i]}};c}

Clojure, 72 octets

#(let[R(range 1(inc(count %)))](map *(map min(repeat %2)R(reverse R))%))

Pyt , 106 octets

ĐŁĐ←⇹řĐ↔Đ04ȘĐ04Ș>Đ04Ș03Ș¬*07ȘážÁ*+04Ș⇹Đ3ȘĐ3Ș-⁺Đ4Ș⇹ŕĐ3Ș<Ь3Ș*3Ș*+⇹ĐŁ⑴04Ș3Ș⇹04Ș*Đ04ȘĐ04Ș<Đ04Ș*06ȘážÁ03Ș¬*++*

Prend L sur la première ligne comme un tableau et prend s sur la deuxième ligne

Explication:

                     Implicit input (L)
Đ                    Duplicate L
ŁĐ                   Get length of L (len) and push it twice
←                    Get s
⇹ř                   Push [1,2,...,len]
Đ↔Đ                  Push [len,...,2,1] twice
04ȘĐ                 Push 0, flip top 4 on stack, and duplicate top [1,2,...,len]
04Ș>                 Is [len,...,2,1]>[1,2,...,len] (element-wise) [boolean array]
Đ                    Duplicate top of stack                   
04Ș03Ș¬*             Pushes [1,2,...,ceil(len/2),0,...,0]
07ȘážÁ               Push 0, flip top seven on stack, and remove all 0s from stack
*                    Pushes [0,0,...,0,floor(len/2),floor(len/2)-1,...,1]
+                    Adds top two on stack element-wise

The top of the stack is now:
     [1,2,...,ceil(len/2),floor(len/2),...,2,1] (let's call it z)

04Ș                  Push zero and swap top four on stack
⇹                    Swap top two on stack
Đ3ȘĐ3Ș-⁺Đ4Ș⇹ŕĐ3Ș<Ь3Ș*3Ș*+     Pushes min of (len-s+1,s) [let's call it m]
⇹ĐŁ⑴04Ș3Ș⇹04Ș*                Pushes an array [m,m,...,m] with length len
Đ04ȘĐ04Ș<Đ04Ș*06ȘážÁ03Ș¬*++    Pushes element-wise min of [m,m,...,m] and z
*                              Element-wise multiplication of above with L

Essayez-le en ligne!

Python + numpy, 64 octets

from pylab import *
lambda l,N:convolve(*ones((2,len(l)-N-1)))*l

Appelez cela avec l comme liste et N comme longueur.