26人の最も裕福な億万長者は、最も貧しい38億人と同じくらいの富を所有していますか?


37

前書き:

数日前、HNQで出会ったときに同じタイトルでこの投稿を読みました。この質問では、大統領候補のバーニー・サンダースが次のように主張しているという主張が議論されています。

今日、世界で最も裕福な26人の億万長者、26人は、世界人口の半分である地球上で最も貧しい38億人と同じくらいの富を所有しています。
ビデオへのリンク

真実かどうか。質問とその質問への回答とディスカッションをご覧ください。

この主張に基づく実際の課題に関しては:

チャレンジ:

2つの入力:降順で並べ替えられた数値リストLと数値n(は)。出力:合計がリストLの最初のn個の値の合計である、Lの可能な最長のサフィックスサブリスト。n1n<length of L
LnL

例:

入力:L = [500,200,150,150,125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]及びn=2
出力:[125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]

どうして?

リストL()の最初のn=2値は合計します。残りの数字のすべての接尾辞とその合計をとると:L[500,200]700

Suffix:                                                                  Sum:

[-3]                                                                     -3
[-2,-3]                                                                  -5
[0,-2,-3]                                                                -5
[1,0,-2,-3]                                                              -4
[2,1,0,-2,-3]                                                            -2
[2,2,1,0,-2,-3]                                                          0
[3,2,2,1,0,-2,-3]                                                        3
[5,3,2,2,1,0,-2,-3]                                                      8
[5,5,3,2,2,1,0,-2,-3]                                                    13
[5,5,5,3,2,2,1,0,-2,-3]                                                  18
[5,5,5,5,3,2,2,1,0,-2,-3]                                                23
[10,5,5,5,5,3,2,2,1,0,-2,-3]                                             33
[10,10,5,5,5,5,3,2,2,1,0,-2,-3]                                          43
[20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                                       63
[30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                                    93
[30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                                 123
[40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                              163
[50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                           213
[55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                        268
[75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                     343
[75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                  418
[100,75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]              518
[125,100,75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]          643
[150,125,100,75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]      793
[150,150,125,100,75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]  943

以下の合計を持つ最長の接尾辞700[125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]、合計で643あるため、これが結果です。

チャレンジルール:

  • 最初のnプレフィックスの値は、出力サフィックスにカウントされません。すなわち、入力L = [10,5,5,3]およびn=2は、[5,3]であり、ではありません[5,5,3]
  • I / Oは柔軟です。あなたは、入力することができますLの整数/小数/文字列のリスト/ストリーム/配列として、単一の区切り文字列、STDINを1つずつ、などあなたは、整数/小数/文字列のリスト/ストリーム/配列として出力することができますだけでなく、区切り文字列を印刷/返す、各改行に数字を印刷するなど。
  • 出力は空でないことが保証されます。あなたのようなテストケースに対処する必要はありませんので、L = [-5,-10,-13]及びn=2になります[]
  • 入力と出力の両方(またはいずれか)は、必要に応じて降順ではなく昇順でもかまいません。

一般的なルール:

  • これはであるため、バイト単位の最短回答が優先されます。
    コードゴルフ言語では、コードゴルフ以外の言語で回答を投稿しないようにしてください。「任意の」プログラミング言語の可能な限り短い答えを考えてみてください。
  • デフォルトのI / Oルールを使用した回答には標準ルールが適用されるため、STDIN / STDOUT、関数/メソッド、適切なパラメーター、戻り値型、完全なプログラムを使用できます。あなたの電話。
  • デフォルトの抜け穴は禁止されています。
  • 可能であれば、コードのテストへのリンク(TIOなど)を追加してください。
  • また、回答の説明を追加することを強くお勧めします。

テストケース:

Inputs: L=[500,200,150,150,125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3], n=2
Output: [125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]

Inputs: L=[10,5,5,3], n=2
Output: [5,3]

Inputs: L=[7,2,1,-2,-4,-5,-10,-12], n=7
Output: [-12]

Inputs: L=[30,20,10,0,-10,-20,-30], n=1
Output: [20,10,0,-10,-20,-30]

Inputs: L=[100,35,25,15,5,5,5,5,5,5,5,5,5,5,5,5,5], n=1
Output: [15,5,5,5,5,5,5,5,5,5,5,5,5,5]

Inputs: L=[0,-5,-10,-15], n=2
Output: [-10,-15]

Inputs: L=[1000,999,998,900,800,766,525,525,400,340,120,110,80,77,33,12,0,-15,-45,-250], n=2
Output: [525,525,400,340,120,110,80,77,33,12,0,-15,-45,-250]

Inputs: L=[10,5,5], n=1
Output: [5,5]

言語に整数型がないため、正の整数(またはおそらく負ではないかもしれませんが、まだ記述していません)の整数でのみ機能する答えを書くことはできますか?
ニール

3
@ニールここで網膜について話していると思いますか?ただし、その場合、すべての値が負でないと仮定できます。ただし、負の値で動作する2番目のバージョンを用意することをお勧めします。実際に達成できるかもしれないと感じているからです(バイトカウントが大幅に増加し、回避策がいくつかあります)。これは実際の事実よりも一般的な感覚であり、負の値の部分を回避することが実際に可能かどうかはわかりません)。
ケビンクルーッセン

6
実際のテストケースは次のようになります。[131000000000, 96500000000, 82500000000, 76000000000, (7.7 billion more entries)]:p
Arnauld

2
値がどれも基準[1,2,3] n = 1を満たさないシナリオはどうですか?出力には何が必要ですか?
ouflak

「:@ouflak第三の課題ルールを参照してくださいあなたは、テストケースのように対処する必要はありませんので、出力が非空であるために保証をである。L = [-5,-10,-13]そしてn=2その結果[]」また、入力リストがソート降順であることが保証される(またはを選択した場合は昇順)で[1,2,3]始まるため、有効な入力リストではありません(昇順入力を選択した場合[1,2]を除き、その場合は結果になります)。
ケビンクルーッセン

回答:


17

C#(Visual C#Interactive Compiler)88 81 69 68 63バイト

LiefdeWenのおかげで-4バイト

a=>b=>a.Skip(b).Where((x,i)=>a.Skip(i+b).Sum()<a.Take(b).Sum())

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


私はあなたがコールで排除+bすることによってさらに2つを剃ることができると思っていますSkip。最初のnリストをチェックするのは冗長ですが、まだ正しいと思います。
TheRubberDuck

3
@TheRubberDuckいや、接頭辞と接尾辞が重複する場合に追加する必要がありました。すなわち、[10,5,5,3]、n = 2
期限切れデータ


よろしくお願いします!我々はカリー化機能を使用する場合、それはあまりにも実際に少ないです
期限切れのデータ

@ExpiredDataそうそう、私はそれを削除するのを忘れていました。
LiefdeWen

12

EXAPUNKS(2つのEXA、30の命令、594バイトのソリューションファイル)

私はしばらくの間、EXAPUNKSでコードゴルフチャレンジを試してみたかったのですが、あなたは私が見つけることができる最高のフィットのように見えたので、おめでとうございます!

それぞれLおよびnのファイル200および201を介した入力。新しいファイルを介した出力。Lと出力は昇順です。

基本的に、XAはLの最後のn個の値を合計し、それをXBに送信します。次に、Lの先頭を探し、各値を1つずつXBに送信します。XBはまずXAから合計を受け取り、それをレジスタXに格納します。次にXAから値を1つずつ受け取り、Xから新しい値を差し引き、X <0まで出力ファイルにそれらの値を書き込みます。

XA

GRAB 201
SUBI T F T
DROP
GRAB 200
SEEK 9999
SEEK T
MARK FIRST_SUM
ADDI F X X
ADDI T 1 T
SEEK -1
VOID F
TJMP FIRST_SUM
COPY X M
SEEK -9999
MARK SECOND_SUM
COPY F M
TEST EOF
FJMP SECOND_SUM
KILL

XB

MAKE
COPY M X
MARK LOOP
COPY M T
COPY T F
SUBI X T X
TEST X > 0
TJMP LOOP
SEEK -1
VOID F
KILL

ここのレベルのJavaScript


IIRCには、ソリューションを保存する方法がありませんか?その場合、ゲームの指示ではなくバイトカウントを使用する必要があります。
ウィートウィザード

1
@ SriotchilismO'Zaic、うん、ファイルに簡単にアクセスできるとは思わなかったが、見つけたばかりだ。ディスク上のサイズを追加します。私が書いていない多くのメタデータはそれと一緒に保存されますが、これがこのゲームから実際に単一の「バイトカウント」を取得する最良の方法だと思います。
ymbirtt

時間をかけてこれらのファイルを調べて、メタデータを分類する方法があるかどうかを確認したいと思います。また、一部の命令は他の命令よりも多くのメモリを必要とするのだろうか。
小麦ウィザード

@ SriotchilismO'Zaic、彼らは実際にそうします。すべての指示はプレーンテキストとして保存されるため、最初はすべてのマークを1文字の識別子に変換できます。ソリューションの名前がそこにあるので、ソリューション「a」を呼び出すことで数バイトを削除できます。ただし、その一部は、EXA用に作成した仮想ネットワークに関連しているようにも見えます。正直なところ、EXAPUNKSソリューションを採点する「最も適切な」方法は、実際のコードのバイトカウントまたは命令の数を使用することだと思います。これはメタ投稿に値するかもしれません...
ymbirtt

2
@ymbirtt質問をして、指示を見て、保存されたデータに変換するインタープリターを書くことができますか?ソースからあなたのために入力するプログラムを書いてください。それは別の言語としてカウントされます。
期限切れデータ

11

Python 2、60バイト

l,n=input()
s=sum(l[:n])
while sum(l[n:])>s:n+=1
print l[n:]

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


説明:

最初は最初のn項目の合計を取ります。

次に、各サブリストの合計がこの合計と比較されます。1つが大きくならないとすぐに停止します。

次に、結果の(最長)サブリストが出力されます。


2
実際には最も読みやすい1 1
KryštofŘeháček

10

05AB1E14 12バイト

おかげで2バイト節約 Grimyの節約

.$ΔDOI¹£O›.$

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

説明

.$               # drop the first n entries of the list
  Δ              # repeat the following code until the result doesn't change
   DO            # duplicate and sum the copy
     I¹£O        # calculate the sum of the first n items of the input
         ›.$     # if the current sum is greater than the sum of the first n items
                 # remove the first item of the current list

2
「まさに」私が解決策として準備したものと同じ。そして、「正確に」とは、私のことを意味し.$.sʒO²¹£O>‹}θます。:)
ケビンクルーッセン

2
@KevinCruijssen ここでの12
Grimmy

1
ASCIIのみ12(異なる入力方法を使用)。
グリムミー

1
@Grimy:なるほど。、私は決して|上書きしませんでしたlast-input興味深い。
エミグナ

2
@Grimy:これこれをご覧ください。通常、すべての入力が消費されると、最後の入力が次の入力のすべてのインスタンスに暗黙的に使用されます。|ここを使用すると、|実際に最後の入力であった結果ではなく、最後の入力になります。
エミグナ

7

J、18バイト

}.#~+/@{.>:+/\.@}.

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

説明:

二項動詞、n左引数Lとして-、右引数として-を使用します。

                }.  drop the first n items from L 
               @    and
             \.     for each suffix (starting from the longest)
           +/       find its sum
         >.         is this sum smaller or equal than (results in a boolean vector)
    +/              the sum 
      @             of
       {.           the first n items of L
  #~                use the 1s in the boolean vector to copy the respective
}.                  elements of L (without the first n)


7

R、53 55バイト

@Giuseppeは、削除の方法を変更して2バイト節約しました

function(n,L,Y=rev(L[0:-n]))Y[cumsum(Y)<=sum(L[1:n])]

オンラインでお試しください! ルール4で許可されているように、入力を降順で取得し、昇順で出力します。

  • YLを使用して、1:nを削除したrev0:-n
  • Y累積合計が以下の合計に等しい場所から戻るL[X]

@Giuseppeいつもありがとう。X使用を削除しようとしました-(1:n)が、もちろん同じサイズでしたので、そのままにして
おきまし

6

JavaScript(ES6)、66バイト

(a)(n)リストと同様に、昇順で入力を受け取ります。

a=>n=>(g=s=>n?g(s+a.pop(n--)):eval(a.join`+`)>s?g(s,a.pop()):a)(0)

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

コメント済み

a => n =>               // a[] = list, n = number of richest guys
  ( g = s =>            // g is a recursive function taking a sum s
    n ?                 // if n is not equal to 0:
      g(s + a.pop(n--)) //   recursive call: add the last entry to s and decrement n
    :                   // else:
      eval(a.join`+`)   //   if the sum of the remaining entries
      > s ?             //   is greater than s:
        g(s, a.pop())   //     recursive call with the last entry removed
      :                 //   else:
        a               //     stop recursion and return a[]
  )(0)                  // initial call to g with s = 0

1
@KevinCruijssenは要件を読み間違えたようです。今すぐ修正する必要があります。
アーナルド


5

Python 2、59バイト

Python 3との互換性もあります

f=lambda l,n:l[n:]*(sum(l)/2>=l.pop(n)+sum(l[n:]))or f(l,n)

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


説明

接尾辞の合計は、リスト全体の合計の半分と比較されます。接尾辞の合計がより小さいか等しい場合、接尾辞が返されます。そうでない場合、関数はサフィックスの最初の項目がポップアウトされて再帰的に呼び出されます。


4

Pyth16 15バイト

efgs>vzQsT._<vz

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

入力リストは、例で使用されているように降順ではなく、昇順でソートされることが期待されています。

Pythに2番目の入力に複数回アクセスする単一のトークン演算子を持たせたいと本当に思うときがあります(E入力の次の行を評価しますが、繰り返される呼び出しは以前の値を破棄します)。

efgs>vzQsT._<vzQ   Implicit: Q=eval(input()), z=input() - that is, Q is list, z is string n
                   Trailing Q inferred
             vz    Evaluate z as integer
            <  Q   Remove the above number of elements from the end of Q
          ._       Generate a list of all prefixes of the above
 f                 Filter keep elements of the above, as T, where:
    >vzQ             Take the last z elements of Q
   s                 Sum
  g                  Is the above greater than or equal to...
        sT           ... the sum of T?
e                  Take the last remaining element, implicit print

編集:MrXcoderのおかげで1バイト節約


@ Mr.Xcoder良い悲しみ、なんと明らかな節約でしょう!おかげ👍
ソック

4

JavaScript、64バイト

f=(a,n,s=0,[h,...t]=a)=>n<1?f(a)>s?f(t,0,s):a:1/h?f(t,n-1,s+h):s

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

f=(
  a,               // remaining array
  n,               // if n >= 0: we try to find suffix <= s + a[0..n]
                   // if n is NaN (or undefined): we calculate sum(a) + s
  s = 0,           // previous sum
  [h, ...t] = a    // split array (a) into head (h) and tail (t)
) => (n < 1 ?      // if n == 0
  f(a) > s ?       //   if sum(a) > s
    f(t,0,s) :     //     drop head and test tail again
    a :            //   otherwise, a is the answer
  1 / h ?          // if a is not empty
    f(t,n-1,s+h) : //   add head to sum and recurse
    s              //   we only reach here if n is NaN, return the sum
)

4

スタックス、12 バイト

îo╧╫Σ↑>'qµΣº

staxlang.xyzで実行してデバッグしてください!

より良いバージョン

開梱(14バイト)および説明:

:/|]{|+n|+>!}j
:/                Split array at index.
  |]              Suffixes. The bit after the split (the poor) is on top for this.
    {       }j    First item in array that yields truthy under the block:
     |+             Sum array (collective wealth of the many).
       n            Copy second item to top of stack.
        |+          Sum again. Wasted computation, but this location saves a byte.
          >!        Second item on stack less than or equal to first?

コンセンサスにより、この結果をスタックに残すことができます。Staxは暗黙的な印刷を試みますが、失敗する可能性がありますが、mますが、アンパックされたプログラムにをと、出力をうまく見ることができます。

{ ... }jは、と同じように見え{ ... fhます。ほら 編集:そうではありません。前者のみが真実の結果を得ると停止し、後で副作用や致命的なエラーを回避する可能性があります。



3

Japt、16バイト

£sV+YÃæ_x §U¯V x

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

£sV+YÃæ_x §U¯V x     :Implicit input of U=L and V=n
£                    :Map U, with Y being the 0-based indices
 sV+Y                :  Slice U from index V+Y
     Ã               :End map
      æ              :First element that returns true
       _             :When passed through the following function
        x            :  Reduce by addition
          §          :  Less than or equal to
           U¯V       :    Slice U to index V
               x     :    Reduce by addition

3

ゼリー13 12バイト

ṫḊÐƤS>¥ÞḣS¥Ḣ

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

バイトを節約してくれた@JonathanAllanに感謝します!

Ln

説明

ṫ            | Tail: take all values of L from the nth onwards (which is actually one too many; dealt with below)
 ḊÐƤ         | Take all suffixes, removing the first value from each. This will yield a list of all possible suffixes of L that exclude the first n values
       Þ     | Sort by:
    S>¥ ḣS¥  | - The sum is greater than the sum of the first n values of L
           Ḣ | Take the first resulting list and return from link (implicitly output when called as a full program)

あなたは、ソートの代わりに、フィルタリングすることにより、バイトを保存することができます:ṫḊÐƤS>¥ÞḣS¥Ḣ
ジョナサン・アラン

3

ガイア、12バイト

eSe¤Σ¤┅⟪Σ⊃⟫∇

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

スタックがちょうどいいなら、ゴルフできるバイトがあると思います。

e	| eval first input as Gaia code
S	| Split into a list of ["first n elements" "rest of elements"]
e	| dump onto stack
¤Σ	| swap and take the sum (sum of first n elements)
¤┅	| swap and take suffixes
⟪  ⟫∇	| return the first element of suffixes where:
 Σ⊃	| the sum(first n elements) ≥ sum(suffix)

3

Haskell、46バイト

これがどのように見えるかに不満。明らかなゴルフを見逃しているといいのですが。

n#l=until(((sum$take n l)>=).sum)tail$drop n l

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

私はsplitAtガードでパターンマッチングを使用してプレフィックスとサフィックスを取得しようとしましたが、それは3バイト以上であることがわかりました。後でガードを使用して再帰関数に変換して、バイトカウントが低下するかどうかを確認することを計画しています。

説明

n # l = until (((sum $ take n l) >= ) . sum) tail $ drop n l
n # l =                                                        -- define infix operator
n                                                              --  the number of elements
    l                                                          --  the list
        until                                                  -- until
                                        sum                    --  the sum of the suffix
               ((sum $ take n l) >=)                           --  is <= the sum of the prefix
                                             tail              --  remove the first element
                                                    drop n l   -- the suffix

私が「プレフィックス」と呼ぶものは最初のn要素であり、「サフィックス」はリストの残りの部分です。


3

APL(Dyalog Unicode)23 21 バイトSBCS

nL

{⍵↓⍨⍺⌈⊥⍨(+/⍺↑⍵)<+\⌽⍵}

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

{}nL

⌽⍵L

+\ その接頭辞合計

()< ブールマスク:以下:

  ⍺↑⍵ 最初を取る n の要素 L

  +/ それらを合計する

⊥⍨末尾の真実を数える

⍺⌈ 最大の n そしてそれ

⍵↓⍨ その多くの要素を前面からドロップします L


1
@KevinCruijssen素敵に見つけました。一定。
アダム

3

MATL13 12バイト

@MickyTの回答に基づいて、@ Giuseppeのおかげで1バイト節約されました

:&)PtYsbs>~)

出力は昇順です。

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

説明

入力2とを検討してください[500,200,150,150,125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]

:      % Implicit input: n. Push [1 2 ... n]
       % STACK: [1 2]
&)     % Implicit input: array. Two-output indexing: pushes the subarray
       % indexed by [1 2 ... n] and the remaining subarray
       % STACK: [500 200], [150 150 125 ... -2 -3]
P      % Flip
       % STACK: [500 200], [-3 -2 ... 125 150 150]
t      % Duplicate top of the stack
       % STACK: [500 200], [-3 -2 ... 125 150 150], [-3 -2 ... 125 150 150]
Ys     % Cumulative sum
       % STACK: [500 200], [-3 -2 ... 125 150 150], [-3 -5 ...646 796 946]
b      % Bubble up in the stack
       % STACK: [-3 -2 ... 125 150 150], [-3 -5 ...646 796 946], [500 200]
s      % Sum
       % STACK: [-3 -2 ... 125 150 150], [-3 -5 ...646 796 946], 7
>~     % Greater than, negate; element-wise
       % STACK: [-3 -2 ... 125 150 150], [1 1 ... 1 0 0]
)      % Index. Implicit display
       % STACK: [-3 -2 ... 125]

3

PowerShell99 97バイト

param($n,$l)do{$a+=$l[$i++]}until($a-gt($l[-1..-$n]-join'+'|iex)-or$i-gt$l.count-$n)$l[($i-2)..0]

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

リストを昇順で取得し、出力は降順です(テストケースと比較しやすいため:^))

リストを逆方向にたどり、アキュムレータを最後にn追加されたエントリと比較します(+sでそれらを接着し、結果の文字列をに渡しますinvoke-expression)。untilループには、Rich Neighbourhoodへの移行を処理するための追加のロジックが必要でした。これは、Rich Guysよりも金持ちでない場合でも、リスト全体を変更するまで停止しないためです。

展開済み:

param($n,$list)
do{
  $acc+=$list[$i++]
}until($acc -gt ($list[-1..-$n] -join '+'|invoke-expression) -or ($i -eq $list.count-$n))
$list[($i-2)..0]

3

Retina 0.8.2、99バイト

\d+
$*
^
;,
+`;,(1+)(,.*)1$
$1;$2
,
;$'¶$`,
;.*(;.*)
$1$1
T`,`_`.*;
1G`(1+);\1;
.*;

(1*),
$.1,
,$

オンラインでお試しください!リンクには、一部のテストケースのみが含まれます。場合によっては、12バイトのコストで負の数を使用動作させることができます(特に、最初のnエントリはLまだ正である必要があります。理論的には、最初のnエントリの合計が正である必要があるだけです)。説明:

\d+
$*

単項に変換します。

^
;,

の先頭にマーカーを挿入しますL

+`;,(1+)(,.*)1$
$1;$2

リストのn時間を下に移動して、合計していきます。これは削除されますnが、カンマは残ります。

,
;$'¶$`,

の各サフィックスのエントリを作成しますL

;.*(;.*)
$1$1

中央を接尾辞のコピーに置き換えます。

T`,`_`.*;

サフィックスのコピーを合計します。

1G`(1+);\1;

サフィックスの合計がプレフィックスの合計を超えない最初のエントリを取得します。

.*;

合計を削除します。

(1*),
$.1,

10進数に変換します。

.,$

前に来た末尾のコンマを削除しますn


いい答えだ。:)負の数を含む12バイト以上のバージョンにTIOリンクを追加できますか。そして、それは最初のときに動作しないことn数値の合計は負の値になります。正の整数で動作する限り、それでも大丈夫です。よくやった。
ケビンクルイッセン

1
@KevinCruijssen私の負数バージョンは非常に遅いことが判明しましたが、rオプションを使用してそれを修正することができたので、いくつかのテストケースにリンクしました。
ニール

2

、17バイト

IΦθ¬∨‹κη‹Σ…θηΣ✂θκ

オンラインでお試しください!リンクは、コードの詳細バージョンです。説明:

  θ                 Input `L`
 Φ ¬                Filter out elements where
      κ             Current index
     ‹              Is less than
       η            Input `n`
    ∨               Logical Or
           θ        Input `L`
          … η       First `n` terms
         Σ          Summed
        ‹           Is less than
              ✂θκ   Remainder of `L`
             Σ      Summed
I                   Cast to string
                    Implicitly print on separate lines


2

PowerShell、86バイト

param($n,$l)$l|?{$k++-ge$n}|?{(&{$l|%{$s+=($_,0,-$_)[($n-le$i)+(++$i-ge$k)]};$s})-ge0}

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

展開済み:

param($n,$list)
$list|?{$k++-ge$n}|?{                               # tail elements after $n only
    $sumLeftSegmentMinusSumRightSgement = &{        # calc in a new scope to reinit variables $s, $i
        $l|%{$s+=($_,0,-$_)[($n-le$i)+(++$i-ge$k)]} # sum(list[0..n-1]) - sum(list[k-1..list.Count-1])
        $s                                          # output sum to the outer scope
    }
    $sumLeftSegmentMinusSumRightSgement -ge 0       # output elements where sum >= 0
}

2

MathGolf、13バイト

(‼≥≤Σ\æ╞`Σ≥▼Þ

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

説明

入力を受け取ります n L

(               pops n and decrements (TOS is n-1)
 ‼              apply next two operators to stack simultaneously
  ≥             slice L[n-1:] (gets all elements with index >= n-1)
   ≤            slice L[:n] (gets all elements with index <= n-1)
    Σ           get sum of topmost list (this is the sum of n largest elements)
     \          swap top elements
      æ    ▼    do while false with pop using block of length 4
       ╞        discard from left of string/array
        `       duplicate the top two items on the stack
         Σ      sum the list which is on top
          ≥     is the sum of the partial list >= the desired sum?
            Þ   discard everything but TOS

これが機能する理由は、最初のステップで、実際にリストを2つの重複する部分に分割するためです。例として、L = [4, 3, 2, 1], n = 2リストを[3, 2, 1]とに分割し[4, 3]ます。最初のリストに余分な要素がある理由は、ループ内で最初に発生するのは破棄であるためです。余分な要素が付加されていない場合、出力がリストの残り全体である場合は失敗します。



1

Clojure、66 75バイト

#(loop[v(drop %2 %)](if(>(apply + v)(apply +(take %2 %)))(recur(rest v))v))

悲しいことに、シーケンスの合計の短いイディオムはないようです。

編集:サンプルをオンラインで試すに追加するときリンク多くの負の数が存在する場合、元の答えが間違った結果を与えたことに気付きました。

doseq用途「キー」構造化代入されたシンボルで、それは、最大データ終了やや明確にする必要がありますので。#(...)は匿名関数であり、ここではシンボルにバインドしていますf

(def f #(loop[v(drop %2 %)](if(>(apply + v)(apply +(take %2 %)))(recur(rest v))v)))


(doseq [{:keys [L n]} [{:L [10,5,5,3] :n 2}
                       {:L [7,2,1,-2,-4,-5,-10,-12] :n 7}
                       {:L [30,20,10,0,-10,-20,-30] :n 1}]]
  (println (f L n)))

出力:

(5 3)
(-12)
(20 10 0 -10 -20 -30)

1
テストコードを使用してTIOを追加してもよろしいですか(リストにClojureが表示されます)。どういうわけか不可能な場合(バージョンの不一致、またはTIOで利用できないビルトインの使用)、それが機能することを検証するために、いくつかのテストケースを含むスクリーンショットを含めることができますか?
ケビンクルイッセン

1

APL(NARS)、32文字、64バイト

{v/⍨(+/⍺↑⍵)≥+/¨{⍵↓v}¨¯1+⍳≢v←⍺↓⍵}

テストとコメント:

  q←{v/⍨(+/⍺↑⍵)≥+/¨{⍵↓v}¨¯1+⍳≢v←⍺↓⍵}
  2 q 500,200,150,150,125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,¯2,¯3
125 100 75 75 55 50 40 30 30 20 10 10 8 5 5 5 3 2 2 1 0 ¯2 ¯3 
  2 q 10,5,5,3
5 3 
  ⎕fmt  7 q 7,2,1,¯2,¯4,¯5,¯10,¯12
┌1───┐
│ ¯12│
└~───┘
  2 q 0,¯5,¯10,¯15
¯10 ¯15 
  ⎕fmt 1 q 100,35,25,15,5,5,5,5,5,5,5,5,5,5,5,5,5
┌14───────────────────────────┐
│ 15 5 5 5 5 5 5 5 5 5 5 5 5 5│
└~────────────────────────────┘
  2 q 1000,999,998,900,800,766,525,525,400,340,120,110,80,77,33,12,0,¯15,¯45,¯250
525 525 400 340 120 110 80 77 33 12 0 ¯15 ¯45 ¯250 
  1 q 10,5,5
5 5 
  ⎕fmt  2 q ¯5,¯10,¯13
┌0─┐
│ 0│
└~─┘
  ⎕fmt  1 q 30,20,10,0,¯10,¯20,¯30
┌6───────────────────┐
│ 20 10 0 ¯10 ¯20 ¯30│
└~───────────────────┘


   {v/⍨(+/⍺↑⍵)≥+/¨{⍵↓v}¨¯1+⍳≢v←⍺↓⍵}
                             v←⍺↓⍵   v is ⍵[(⍺+1)..≢⍵] 
                  {⍵↓v}¨¯1+⍳≢v        build the array of array cut v of 0..((≢v)-1) elements
               +/¨                   sum each of these element of array above
      (+/⍺↑⍵)≥                       compare ≥ with the sum of ⍵[1..⍺] obtain one bolean array
                                     has the same lenght of v
   v/⍨                               return the element of v that are 1 of the boolean array above

バイト長を誤って報告しました...


1

MS SQL Server 2017、271バイト

create function f(@L nvarchar(max),@ int)returns table return
select v
from(select*,sum(iif(n<=@,v,0))over()r,sum(v)over(order by v)p
from(select row_number()over(order by-v)n,v
from STRING_SPLIT(@L,',')cross apply(select
try_parse(value as int)v)t)t)t
where p<=r and @<n

入力データを格納するために、よりリレーションに似たテーブルを使用するとコードがより簡潔になることを知っていますが、数値リストとSTRING_SPLIT関数を格納するために文字データ型を使用すると、Build Schema部分が短くなります:)

より読みやすいバージョン:

CREATE FUNCTION f(@L NVARCHAR(MAX), @n INT)
  RETURNS TABLE AS RETURN (
    SELECT
      v
    FROM (
      SELECT
        *,
        SUM(IIF(n<=@n, v, 0)) OVER() AS r,
        SUM(v) OVER(ORDER BY v) AS p
      FROM(
        SELECT ROW_NUMBER() OVER(ORDER BY -v) AS n, v
        FROM STRING_SPLIT(@L, ',')
        CROSS APPLY(
          SELECT TRY_PARSE(value AS INT) AS v
        ) AS t
      ) AS t
    ) AS t
    WHERE p <= r AND @n < n
  );

SQL Fiddleで試してみてください!


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