Görev

Tamsayılar bir listesi verilen L ve başka bir tamsayıdır s , eğer amaç, bir kolon-bazlı miktarda hesaplamak için olan s -Boy (potansiyel olarak üst üste binmek) dilimleri L göre konumlarını ait ederken, L (aşağıya bakınız).

Tanımlar

S uzunlukta (çakışan) dilimleri liste L arasında (sarma olmadan) tüm bitişik alt diziler olan L uzunluğu vardır s .

Dilimlerin L' ye göre konumlarını elde etmek için , her dilimin ( _i) başlangıçtan itibaren i pozisyonları ofsetine sahip olduğu bir "merdiven" oluşturduğunuzu hayal edebilirsiniz .

gözlük

• s bir tamsayıdır daha yüksek olan 1 ve uzunluğundan kesin olarak daha küçük bir L .
• L her zaman en az 3 element içerecektir.
• Herhangi bir programlama dilinde rekabet edebilir ve herhangi bir standart yöntemle girdi alabilir ve çıktı sağlayabilir , bu boşlukların varsayılan olarak yasak olduğunu unutmayın . Bu kod golf , bu nedenle her dil için en kısa gönderme (bayt cinsinden) kazanır.

Örnekler ve Test Durumları

İşte çalışan bir örnek:

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

Ve bazı test senaryoları:

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

Mil sayesinde -1 bayt!

[:+//.]\

Nasıl çalışır?

Sol argüman s, sağ argüman - L

]\ - L uzunluğu s olan alt listelere ayırır

/. - eğik köşegenleri çıkarır (köşegen olmayanlar)

+/ - onları toplar

[: - yukarıdaki fiillerden çatal yapar

İlk test örneği için örnek bir J oturumu:

   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

Çevrimiçi deneyin!

Haskell , 59 56 bayt

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

Çevrimiçi deneyin!

(#)Listeyi sve sayıyı nbağımsız değişken olarak alan bir işlev tanımlar .

Bu, s = [1, 2, 3, 4, 5, 6, 7, 8, 9]ve için yapılan gözlemlere dayanır.n = 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]

aynıdır

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

Başlangıçta artan, sonra sabit ve nihayet azalan bu listeyi oluşturmak için,

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

hangi verir [1, 2, 3, 4, 5, 4, 3, 2, 1]. İfadeye nek kısıtlama eklemek , ek kısıtlama için gerekli olsa da (veya genel olarak ) minimumdoğru liste [1, 2, 3, 3, 3, 3, 3, 2, 1]cevabını verir :n = 3n = 6n > lengths s/2length s + 1 - n

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

veya daha kısa:

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

Çift çarpma [1..length s]ile sıkıştırılır sve zipdaha uzun listeyi daha kısa olanın uzunluğuna indirgediğinden sonsuz liste [1..]kullanılabilir:

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

JavaScript (ES6), 65 62 58 bayt

@Shaggy sayesinde 4 bayt kaydedildi

Körili sözdiziminde girdi alır (a)(n).

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

Test senaryoları

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 bayt

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

Bu ilk test vakası (ve eklediğim son ikisi) beni birden fazla kez vidaladı, ama sonunda çalışıyor ..: D

Yenisini döndürmek yerine giriş dizisini değiştirir.

Açıklama:

Çevrimiçi deneyin.

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 bayt

)IŒIùvyNÅ0ì+

Çevrimiçi deneyin!

MATL , 8 bayt

YCPT&Xds

Çevrimiçi deneyin! Veya tüm test senaryolarını doğrulayın .

açıklama

Girişleri [1, 3, 12, 100, 23]ve 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 bayt ^SBCS

-5 ngn sayesinde.

Anonim zımni infix fonksiyonu alarak s sol argüman gibi L sağ argüman olarak. Devraldı ⎕IO( Ben nDex Ç rigin) olmak 0gibi birçok sistemlerde varsayılan değerdir.

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

Çevrimiçi deneyin!

Örnek olay ile açıklama [1,3,12,100,23]

(… ) Aşağıdaki anonim zımni fonksiyonunu uygular:

 ,/ bu boyuttaki örtüşen pencereler; [[1,3,12],[3,12,100],[12,100,23]]

 (… )\ Bu zımni toplu olarak aşağıdaki anonim zımni işlevini uygulayın:

  ⊢ doğru (en çok) argüman

  0, solda sıfır ile

Kümülatif azaltma, işlevi birbirini takip eden terimler arasındaki her "boşluğa" yerleştirerek sağdan sola doğru ilerlediğimiz anlamına gelir. Her "boşluk" için, işlev sol argümanı atar, ancak ek bir sıfır ekler. Etkili bir şekilde, bu, her terime, solunda "boşluklar" olduğu kadar çok sıfır ekler, bu nedenle ilk terim sıfır boşluk alır, ikincisi bir alır ve üçüncüsü iki alır:[[1,3,12],[0,3,12,100],[0,0,12,100,23]]

↑ listeleri tek bir matriste birleştirerek sırayı yükseltmek, sıfırlarla doldurmak;
 ┌ ┐
 │1 3 12 0 0│
 │0 3 12 100 0│
 │0 0 12 100 23│
 └ ┘
∘ sonra
+⌿ dikey olarak toplayın;[1,6,36,200,23]

Jöle , 6 bayt

JṡṬS×ḷ

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

O zaman bu çalışma almak için çok uzun sürdü s> L/2!

Ë*°EmVUÊÄ-EwV

Dene

açıklama

                 :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 Dili (Mathematica) , 42 bayt

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

Çevrimiçi deneyin!

Julia , 41 bayt

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

Çevrimiçi deneyin!

• Yeniden Tanımlama \Operatörü yeniden .
• a[L=end] daha kısa bir alternatiftir L=length(a) .
• Laikoni'nin yöntemini kullanır .

Japt , 13 12 bayt

@ETHproductions sayesinde -1 bayt

ãV
ËEÆÃcDÃyx

Çevrimiçi deneyin!

R , 52 51 bayt

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

Çevrimiçi deneyin!

Bu Laikoni'nin cevabına eşdeğerdir .

seq(l) endeksleri üretir 1...length(l)length(l)>1o zamandan beri (aksi takdirde üretecektir 1...l[1]). Ben x, olarak kaydediyorum, tersini ykaydediyorum vey (length(l) Laikoni'nin cevabını düzgün bir şekilde taşımak ve bir bayt kaydetmek için ) !

Orijinal cevap, 52 bayt

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

Çevrimiçi deneyin!

Çıktı leleman olarak minimums elemanın, 1 tabanlı endeksi x, length(l)-x+1velength(L)-s+1 .

Bu, Laikoni'nin daha kısa L-xyerine kullanmak yerine cevabına eşdeğerdir rev(x).

APL + WIN, 25 bayt

L ve ardından s'nin ekran girişi istemleri

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

Açıklama:

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 bayt

Çözüm:

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

Çevrimiçi deneyin!

Misal:

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

Açıklama:

Bu konuda J ile rekabet edebileceğimi düşünmeyin . Kayar pencere listesine eklenecek ve başa eklenecek sıfırlar listesi oluşturun, ardından özetleyin:

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

Arıza aşağıdaki gibidir ... ancak bu hala beceriksiz hissettirir.

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

Kabuk , 4 bayt

mΣ∂X

Çevrimiçi deneyin!

Bu fikri Galen Ivanov'un J cevabından kullanır .

açıklama

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

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

Çevrimiçi deneyin!

Python 2 , 68 66 bayt

Laikoni sayesinde -2 bayt

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

Çevrimiçi deneyin!

Perl 5 , 63 bayt

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

Çevrimiçi deneyin!

C (gcc) , 83 81 79 bayt

Listenin manipülasyonunda temel olarak üç "aşama" vardır: artış, sürdürme ve soğuma. Listede ilerledikçe, maksimuma ulaşana kadar faktörümüzü artıracağız. Dilim dolu bir liste listeye sığabiliyorsa, bu maksimum dilim dilimlerin uzunluğu ile aynı olacaktır. Aksi takdirde, uygun dilim sayısı ile aynı olacaktır. Diğer ucunda ise, faktörü tekrar azaltacağız, son unsurun üzerine 1 ineceğiz.

Bu platoyu işaretleyen rampa ve soğuma evrelerinin uzunluğu, bu maksimum faktörden daha azdır.

Kurtulmamış döngüler onları birleştirmeden önce umarım daha açık hale getirir (R = rampa aşamasının uzunluğu):

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;

Üç döngü çok fazla, bu nedenle r'ye dayalı faktöre karar vermek bize bir döngü verir (bazı baytları kaydetmek için s için R'yi kullanarak):

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

Çevrimiçi deneyin!

Perl, 45 44 bayt

Şunlar için +4 içerir: -ai Bu kodun başlangıçta 2 perl uyarısı verdiğine de dikkat edin. Bunları bir vuruş maliyetiyleXSeçeneği

-iSTDIN'de bir satırdaki seçenek ve diziden sonra maske uzunluğunu verin :

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

Sadece kod:

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

Ruby , 62 bayt

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

Çevrimiçi deneyin!

Esasen Arnauld'un javascript cevabının bir limanı , ancak ihtiyaç with_indexçok daha acı verici.

Bunu gerçekten göndermeme karar verdiğim zaman, Dennis'in algoritmasına daha yakın olan bu 70 baytlık versiyondan aşağı doğru golf oynadım .

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

Clojure, 72 bayt

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

Pyt , 106 bayt

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

L'yi ilk satırda dizi olarak alır ve s'yi ikinci satırda alır

Açıklama:

                     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

Çevrimiçi deneyin!

Python + numpy, 64 bayt

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

Bunu liste olarak l ve uzunluk olarak N ile çağırın.