重なり合うスライスの列ごとの合計


19

仕事

整数のリストを考えるとLと別の整数sの目標は、すべての列単位の合計を計算することであるSの -length(潜在的にオーバーラップ)のスライスLをに対するその位置を関係する一方で、L(下記参照します)。

定義

Sの -length スライス(重複)リストのLは、すべての連続するサブシーケンス(折り返しなし)であるL長さであるS

Lに対するスライスsの位置特定するために、各ラダーs iが最初からi位置のオフセットを持つ「ラダー」の構築を想像できます。


スペック

  • s1より大きく、厳密にLの長さより小さい整数です。
  • Lには常に少なくとも3つの要素が含まれます。
  • デフォルトではこれらの抜け穴は禁止されていることに注意しながら、任意のプログラミング言語で競争し、任意の標準的な方法で入力を取得し、出力を提供できます。これはであるため、すべての言語の最短の送信(バイト単位)が優先されます。

例とテストケース

これが実際の例です:

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

さらにいくつかのテストケース:

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

2
最初のテストケースは迷惑です。;)単にsより大きいためL/2。ケース[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]
ケビンクルーッセン

2
@KevinCruijssen編集してくれませんか?これらはいくつかの良いテストケースですが、私は今モバイルにいます;)ありがとう!
Mr Xcoder

回答:


11

J11、9つの、8バイト

マイルのおかげで-1バイト!

[:+//.]\

使い方?

左の引数はs、右の引数-L

]\ -Lを長さsのサブリストに分割します

/. -斜めの対角線(反対角線)を抽出します

+/ -それらを合計します

[: -上記の動詞から分岐します

最初のテストケースのJセッションの例を次に示します。

   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

オンラインでお試しください!


「斜めの対角線」と「対角線」に違いはありますか?
ルイスメンドー

@Luis Mendo-「斜め」とは、J副詞の場合、左上から右下に/.向かう主対角線とは対照的に、左下から右上に向かうことを意味すると思います。
ガレンイワノフ

1
ああ、ありがとう。それが通常対角線
ルイスメンドー

2
あなたは置き換えることができ,/\]\
マイル

@milesはい、もちろんです!ありがとうございました!
ガレンイワノフ

9

Haskell59 56バイト

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

オンラインでお試しください!

引数として(#)リストsと数字を受け取る関数を定義nします。

これは、s = [1, 2, 3, 4, 5, 6, 7, 8, 9]および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]

と同じです

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

これを最初に増加し、次に定数、最後に減少するリストを生成するには、

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

を生成し[1, 2, 3, 4, 5, 4, 3, 2, 1]ます。式に追加のn制約として追加minimumすると、の正しいリストの[1, 2, 3, 3, 3, 3, 3, 2, 1]答えが得られますが、追加の制約が必要n = 3ですn = 6(または一般的にはn > lengths s/2length s + 1 - n

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

または短いです:

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

ペアごとの乗算[1..length s]はで圧縮されszip長いリストは短いリストの長さに切り捨てられるため、無限リスト[1..]を使用できます。

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

6

JavaScript(ES6)、65 62 58バイト

@Shaggyのおかげで4バイト節約

カリー化構文の入力を受け取ります(a)(n)

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

テストケース


DOESのa=>n=>a.map((v,i)=>v*Math.min(++i,n,a.length+1-(n>i?n:i)))58バイトのために動作しますか?
シャギー

@Shaggyどういうわけか、コードに本当に愚かなことがあることは知っていましたが、それを理解できませんでした...どうもありがとう!
アーナルド

6

Java 8、83バイト

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

最初のテストケース(および追加した最後の2つ)で何度も何度も失敗しましたが、ようやく機能するようになりました。.:D

新しい配列を返す代わりに、入力配列を変更します。

説明:

オンラインでお試しください。

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`


5

MATL、8バイト

YCPT&Xds

オンラインでお試しください!または、すべてのテストケースを確認します

説明

入力[1, 3, 12, 100, 23]とを検討してください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]

5

APL(Dyalog Unicode)19 14 バイトSBCS

-5 ngnに感謝します。

sを左引数として、Lを右引数としてとる匿名の暗黙の挿入関数。想定している⎕IOI NDEX O RIGIN)であることを0できるだけ多くのシステムでデフォルトです。

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

オンラインでお試しください!

事例の説明 [1,3,12,100,23]

() 次の匿名暗黙関数を適用します。

,/ そのサイズの重複するウィンドウ。 [[1,3,12],[3,12,100],[12,100,23]]

()\ 次の匿名の暗黙関数をこの暗黙に適用します。

   一番右の引数

  0, 左側にゼロがある

累積的な削減とは、連続する用語間のすべての「スペース」に関数を挿入し、右から左へと進むことを意味します。「スペース」ごとに、関数は左の引数を破棄しますが、追加のゼロを追加します。事実上、これは左側に「スペース」があるのと同じ数のゼロを各用語に追加するため、最初の用語はゼロのスペースを取得し、2番目は1を取得し、3番目は2を取得します。[[1,3,12],[0,3,12,100],[0,0,12,100,23]]

 リストを単一の行列に結合してランクを上げ、ゼロでパディングします。
┌ ┐
│1 3 12 0 0│
│0 3 12 100 0│
│0 0 12 100 23│
└ ┘
 次に、
+⌿ 垂直方向に合計します。[1,6,36,200,23]


1
⊢,⍨¨0⍴⍨¨⍳∘≢->{0,⍵}\
ngn

@ngnこれらの賢い削減については常に考えていますが、実際にはこれを個別に投稿する必要があります。ところで、私は+⌿∘↑((0,⊢)\,/)もっとエレガントだと思う。
アダム

ああ、これは解決策の一部を単純化する明確なケースであり、新しいアイデアではありません
-ngn

@ngn一方、この CMCを解決しください!
アダム

ここのコメントでこれがトピックに当てはまるかどうかわかりませんが、「each」を使用してみませんか?2{(⊃⌽⍺),⊃⍵}/⊢->2{⊃¨(⌽⍺)⍵}/⊢
ngn

4

ゼリー、6バイト

JṡṬS×ḷ

オンラインでお試しください!

使い方

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.

3

Japt、13バイト

s> L/2!の場合、これを機能させるのに時間がかかりすぎました。

Ë*°EmVUÊÄ-EwV

それを試してみてください


説明

                 :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

この機能を使用するには、非常に長い時間がかかりましたs > L/2」他のテストケースは簡単ですが、最初のテストケース(および最後に追加した2つのテストケース)は迷惑でした!.. +1からです!
ケビンクルーッセン




1

R52 51バイト

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

オンラインでお試しください!

これは、ライコニの答えに相当します

seq(l)インデックスを生成する1...length(l)のでlength(l)>1(そうでなければ生じるであろう1...l[1])。としてx保存し、その逆として保存し、ライコニの答えをきちんと移植するために()のy最初の要素を取り、バイトを保存します!ylength(l)

元の回答、52バイト

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

オンラインでお試しください!

出力されたl要素単位の最小値を乗じs、素子の1から始まるインデックスxlength(l)-x+1およびlength(L)-s+1

これは、ライコニの答えと同等で、短いのではL-xなく、を使用しrev(x)ています。


1

APL + WIN、25バイト

Lに続いてsの画面入力のプロンプト

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

説明:

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

1

K(oK)、30バイト

溶液:

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

オンラインでお試しください!

例:

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

説明:

私はこれでJと競争できるとは思わない。スライディングウィンドウリストに追加および追加するゼロのリストを生成し、合計します。

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

内訳は次のとおりです...これはまだ不器用に感じますが。

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





0

C(gcc)83 81 79バイト

リストの操作には、ランプアップ、サステイン、クールオフの3つの「フェーズ」があります。リストに沿って進むと、最大値に達するまで係数を増やします。スライスの完全な実行がリストに収まる場合、この最大値はスライスの長さと同じになります。それ以外の場合、適合するスライスの数と同じになります。もう一方の端では、係数を再び減らして、最後の要素の1に着地します。

このプラトーを終了するランプアップとクールダウンのフェーズの長さは、その最大係数よりも1つ短くなります。

それらを結合する前のループは、願わくば明確になります(R =ランプアップ段階の長さ):

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;

3つのループが多すぎるので、rに基づいて係数を決定すると、1つのループが得られます(Rにsを使用していくつかのバイトを節約します)。

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

オンラインでお試しください!


0

Perl、45 44バイト

+4を含む-ai また、このコードは起動時に2つのperl警告を出すことに注意してください。Xオプションを追加することにより、1ストロークのコストでこれらを抑制することができます

-iSTDINの1行にオプションと配列の後にマスク長を指定します。

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

コードだけ:

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

0

ルビー、62バイト

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

オンラインでお試しください!

基本的にArnauldのjavascriptの回答の移植版ですwith_indexが、必要なことははるかに苦痛です。

私が実際にこれを提出することを決めるのにかかった時間で、私はデニスのアルゴリズムに近いこの70バイトのバージョンからゴルフを始めました。

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

0

Clojure、72バイト

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

0

Pyt、106 バイト

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

最初の行でLを配列として受け取り、2番目の行でsを受け取ります

説明:

                     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

オンラインでお試しください!


0

Python + numpy、64バイト

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

リストとしてlを、長さとしてNを指定してこれを呼び出します。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.