Compito

Dato un elenco di numeri interi L e un altro numero intero s , l'obiettivo è calcolare le somme per colonna di tutte le sezioni di L di lunghezza s (potenzialmente sovrapposte) , pur appartenendo alle loro posizioni rispetto a L (vedi sotto).

definizioni

Le sezioni di lunghezza s (sovrapposte) dell'elenco L sono tutte le sottosequenze contigue (senza avvolgimento) di L che sono di lunghezza s .

Al fine di riguardare le posizioni delle fette s rispetto a L , si può immaginare la costruzione di una "scala", dove ogni fetta s _i ha un offset dei posizioni fin dall'inizio.

Specifiche

• s è un numero intero maggiore di 1 e strettamente minore della lunghezza di L .
• L conterrà sempre almeno 3 elementi.
• Puoi competere in qualsiasi linguaggio di programmazione e puoi prendere input e fornire output attraverso qualsiasi metodo standard , tenendo presente che queste scappatoie sono vietate per impostazione predefinita. Questo è code-golf , quindi vince l'invio più breve (in byte) per ogni lingua .

Esempi e casi di test

Ecco un esempio funzionante:

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

E alcuni altri casi di 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 byte

-1 byte grazie alle miglia!

[:+//.]\

Come funziona?

L'argomento di sinistra è s, quello di destra - L

]\ - suddivide L in elenchi secondari con lunghezza s

/. - estrae le diagonali oblique (anti-diagonali)

+/ - li somma

[: - crea una forcella dai verbi sopra

Ecco un esempio di sessione J per il primo caso di 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

Provalo online!

Haskell , 59 56 byte

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

Provalo online!

Definisce una funzione (#)che accetta un elenco se un numero ncome argomenti.

Questo si basa sull'osservazione che per s = [1, 2, 3, 4, 5, 6, 7, 8, 9]en = 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]

equivale a

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

Per generare questo elenco inizialmente crescente, quindi costante e infine decrescente, possiamo iniziare con

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

quale cede [1, 2, 3, 4, 5, 4, 3, 2, 1]. L'aggiunta ncome vincolo aggiuntivo minimumnell'espressione produce la [1, 2, 3, 3, 3, 3, 3, 2, 1]risposta di elenco corretta per n = 3, sebbene per n = 6(o in generale qualsiasi n > lengths s/2) length s + 1 - nsia necessario il vincolo aggiuntivo :

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

o più corto:

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

Per la moltiplicazione a coppie [1..length s]è zippato con s, e poiché ziptronca l'elenco più lungo alla lunghezza di quello più corto è [1..]possibile utilizzare l' elenco infinito :

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

JavaScript (ES6), 65 62 58 byte

4 byte salvati grazie a @Shaggy

Accetta input nella sintassi del curry (a)(n).

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

Casi 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 byte

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

Quel primo caso di test (e gli ultimi due che ho aggiunto) mi ha fregato più volte, ma finalmente funziona ora ..: D

Modifica l'array di input invece di restituirne uno nuovo.

Spiegazione:

Provalo online.

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 byte

)IŒIùvyNÅ0ì+

Provalo online!

MATL , 8 byte

YCPT&Xds

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Considerare input [1, 3, 12, 100, 23]e 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 byte ^SBCS

-5 grazie a ngn.

Funzione di infusione tacita anonima che assume s come argomento di sinistra e L come argomento di destra. Assume ⎕IO( I NDICE O rigine) di essere 0come è di default su molti sistemi.

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

Provalo online!

Spiegazione con caso esemplificativo [1,3,12,100,23]

(... ) applica la seguente funzione tacita anonima:

 ,/ finestre sovrapposte di quella dimensione; [[1,3,12],[3,12,100],[12,100,23]]

 (... )\ applica cumulativamente questo tacito la seguente funzione tacita anonima:

  ⊢ l'argomentazione giusta (la maggior parte)

  0, con uno zero a sinistra

Riduzione cumulativa significa che inseriamo la funzione in ogni "spazio" tra termini successivi, procedendo da destra a sinistra. Per ogni "spazio", la funzione eliminerà l'argomento sinistro ma aggiungerà uno zero aggiuntivo. In effetti, questo aggiunge tutti gli zeri a ciascun termine quanti sono gli "spazi" alla sua sinistra, quindi il primo termine ottiene zero spazi, il secondo ne ottiene uno e il terzo ne ottiene due:[[1,3,12],[0,3,12,100],[0,0,12,100,23]]

↑ aumentare il grado combinando le liste in un'unica matrice, riempiendo di zeri;
 ┌ ┐
 │1 3 12 0 0│
 │0 3 12 100 0│
 │0 0 12 100 23│
 └ ┘
∘ quindi
+⌿ sommare verticalmente;[1,6,36,200,23]

Gelatina , 6 byte

JṡṬS×ḷ

Provalo online!

Come funziona

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 byte

Ci è voluto troppo tempo per farlo funzionare quando s> L/2!

Ë*°EmVUÊÄ-EwV

Provalo

Spiegazione

                 :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 byte

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

Provalo online!

Julia , 41 byte

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

Provalo online!

• Ridefinire \ operatore.
• a[L=end] è un'alternativa più breve a L=length(a) .
• Usa il metodo di Laikoni .

Japt , 13 12 byte

-1 byte grazie a @ETHproductions

ãV
ËEÆÃcDÃyx

Provalo online!

R , 52 51 byte

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

Provalo online!

Ciò equivale alla risposta di Laikoni .

seq(l)produce gli indici 1...length(l)poiché length(l)>1(altrimenti produrrebbe 1...l[1]). Lo salvo come x, salvo il suo contrario come ye prendo il primo elemento di y(length(l) ) per portare ordinatamente la risposta di Laikoni e salvare un byte!

Risposta originale, 52 byte

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

Provalo online!

L'output è l elementwise moltiplicata per il minimo s, l'indice a base 1 dell'elemento x, length(l)-x+1e length(L)-s+1.

Questo equivale anche alla risposta di Laikoni, usando L-xinvece direv(x) come è più breve.

APL + WIN, 25 byte

Richiede l'inserimento dello schermo di L seguito da s

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

Spiegazione:

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 byte

Soluzione:

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

Provalo online!

Esempio:

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

Spiegazione:

Non pensare di poter competere con J su questo. Genera un elenco di zeri da aggiungere e anteporre all'elenco delle finestre scorrevoli, quindi riassumi:

{ 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 ripartizione è la seguente ... anche se questo sembra ancora goffo.

{+/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

Buccia , 4 byte

mΣ∂X

Provalo online!

Utilizza l'idea della risposta J di Galen Ivanov .

Spiegazione

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

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

Provalo online!

Python 2 , 68 66 byte

-2 byte grazie a Laikoni

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

Provalo online!

Perl 5 , 63 byte

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

Provalo online!

C (cc) , 83 81 79 byte

Esistono sostanzialmente tre "fasi" per la manipolazione dell'elenco: accelerazione, sustain e cool-off. Man mano che andiamo lungo l'elenco, aumenteremo il nostro fattore fino a raggiungere un massimo. Se una serie completa di sezioni può rientrare nell'elenco, questo massimo sarà uguale alla lunghezza delle sezioni. Altrimenti, sarà lo stesso del numero di sezioni che si adattano. All'altra estremità, diminuiremo di nuovo il fattore, per atterrare a 1 sull'ultimo elemento.

La lunghezza delle fasi di accelerazione e di raffreddamento che fermano questo plateau è inferiore di un fattore massimo.

I loop non golfati prima di combinarli si spera chiariscano (R = lunghezza della fase di accelerazione):

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;

Tre loop è troppo, quindi decidere il fattore basato su r ci dà un loop (usando s per R per salvare alcuni byte):

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

Provalo online!

Perl, 45 44 byte

Include +4 per -ai Si noti inoltre che questo codice fornisce 2 avvisi perl all'avvio. Puoi sopprimerli al costo di un colpo aggiungendo l' Xopzione

Dare la lunghezza della maschera dopo l' -iopzione e l'array su una riga su STDIN:

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

Solo il codice:

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

Rubino , 62 byte

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

Provalo online!

Essenzialmente una porta della risposta javascript di Arnauld , tranne quella necessariawith_index è molto più doloroso.

Nel tempo impiegato da me per decidere di inoltrarlo, sono passato da questa versione a 70 byte, che è più vicina all'algoritmo di Dennis .

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

Clojure, 72 byte

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

Pyt , 106 byte

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

Prende L sulla prima riga come matrice e prende s sulla seconda riga

Spiegazione:

                     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

Provalo online!

Python + numpy, 64 byte

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

Chiamalo con l come elenco e N come lunghezza.