Multi-level marketing "legs" investment rule

Question

Multi-level marketing related challenge.

A peer wants to get rewarded. So it attracted N investors (N>=1), each i-th investor invested x[i]. When a total sum exceeds threshold x[0]+x[1]+...+x[N-1] >= T a peer could be rewarded. But only if a following conditions are satisfied:

• Minimum amount of investors should be greater than M, (M<=N)
• For at least one integer k, where k>=M and k<=N, any k investors have to invest at least T/k each;

Given N, x[], T, M you should determine whether the peer's reward is generated or not (boolean result, "yes" or "no"). Shortest code wins.

Examples:

---

N=5; M=3; T=10000, in order to generate the peer's reward one of the following must be satisfied:

• any 3 invested at least 3334 each
• any 4 invested at least 2500 each
• all 5 invested at least 2000 each

---

N=6; M=2; T=5000:

• any 2 invested at least 2500 each
• any 3 invested at least 1667 each
• any 4 invested at least 1250 each
• any 5 invested at least 1000 each
• all 6 invested at least 834 each

---

generalized: for any k, where k>=M and k<=N:

• any k of N investors invested at least T/k each

---

Test cases:

format:

N, x[], T, M -> correct answer

6, [999, 999, 59, 0, 0, 0], 180, 3 -> 0
6, [0, 60, 0, 60, 60, 0], 180, 3 -> 1
6, [179, 89, 59, 44, 35, 29], 180, 3 -> 0
6, [179, 89, 59, 44, 35, 30], 180, 3 -> 1
6, [179, 89, 59, 44, 36, 29], 180, 3 -> 1
6, [179, 90, 59, 44, 35, 29], 180, 3 -> 0
6, [30, 30, 30, 30, 29, 30], 180, 3 -> 0
6, [30, 30, 30, 30, 30, 30], 180, 3 -> 1

Answer 1

Jelly,  12  9 bytes

ṢṚ×J$ṫ⁵<Ṃ

A full program which accepts x T M and prints 0 if the peer is rewarded and 1 if not.

Try it online!

How?

ṢṚ×J$ṫ⁵<Ṃ - Main Link: list of numbers, x; number, T   e.g. [100, 50, 77, 22, 14, 45], 180
Ṣ         - sort x                                          [ 14, 22, 45, 50, 77,100]
 Ṛ        - reverse                                         [100, 77, 50, 45, 22, 14]
    $     - last two links as a monad:
   J      -   range of length                               [  1,  2,  3,  4,  5,  6]
  ×       -   multiply                                      [100,154,150,180,110, 84]
     ṫ    - tail from index:
      ⁵   -   5th argument (3rd input), M   (e.g. M=3)      [        150,180,110, 84]
       <  - less than T?                                    [          1,  0,  1,  1]
        Ṃ - minimum                                         0

Answer 2

05AB1E, 9 bytes

{Rƶ.ssè›ß

Try it online or verify all test cases.

Port of @JonathanAllan's Jelly answer, so also takes the inputs x T M and outputs 0 for "yes" and 1 for "no". If this is not allowed, and it should be inverted, a trailing _ can be added.

Explanation:

{           # Sort the (implicit) input `x`
            #  i.e. `x`=[100,50,77,22,14,45] → [14,22,45,50,77,100]
 R          # Reverse it
            #  i.e. [14,22,45,50,77,100] → [100,77,50,45,22,14]
  ƶ         # Multiply it by it's 1-indexed range
            #  i.e. [100,77,50,45,22,14] → [100,154,150,180,110,84]
   .s       # Get all the suffices of this list
            #  i.e. [100,154,150,180,110,84]
            #   → [[84],[110,84],[180,110,84],[150,180,110,84],[100,154,150,180,110,84]]
     s      # Swap to take the (implicit) input `T`
      è     # Get the prefix at index `T`
            #  i.e. [[84],[110,84],[180,110,84],[150,180,110,84],[100,154,150,180,110,84]]
            #   and `T=3` → [150,180,110,84]
       ›    # Check for each list-value if the (implicit) input `M` is larger than it
            #  i.e. [150,180,110,84] and `M`=180 → [1,0,1,1]
        ß   # And pop and push the minimum value in the list (which is output implicitly)
            #  i.e. [1,0,1,1] → 0

---

Alternative for .ssè:

sG¦}

Try it online or verify all test cases.

Explanation:

s       # Swap to take the (implicit) input `T`
 G }    # Loop `T-1` times:
  ¦     #  Remove the first item from the list that many times
        #   i.e. [100,154,150,180,110,84] and `T=3` → [150,180,110,84]

Answer 3

C# (Visual C# Interactive Compiler) with flag /u:System.Linq.Enumerable, 69 bytes

(n,x,t,m)=>Range(0,n-m+1).Where(b=>x.Count(a=>a>=t/(b+m))>=b+m).Any()

Try it online!

// Takes in 4 parameters as input
(n,x,t,m)=>
// Create a new array with the length of all the numbers from m to n, inclusive
Range(0,n-m+1)
// And filter the results by
.Where((_,b)=>
// If the number of people that invested more than the total amount divided by the index plus m
x.Count(a=>a>=t/(b+m))
// Is greater than the index plus m
>= b+m)
// And check if there is at least one value in the filtered IEnumerable<int>, and if there is, return true
.Any()

Without any flags, 73 bytes

(n,x,t,m)=>new int[n-m+1].Where((_,b)=>x.Count(a=>a>=t/(b+m))>=b+m).Any()

Try it online!

Answer 4

JavaScript, 54 52 bytes

(x,t,m,n)=>x.sort((a,b)=>a-b).some(i=>i*n-->=t&n>=m)

Try it online

Answer 5

Retina, 79 bytes

\d+
*
O^`_+(?=.*])
_+(?=.*])(?<=(\W+_+)+)
$#1*$&
+`\W+_+(.*_)_$
$1
(_+).*], \1,

Try it online! Takes input in the format [x], T, M. Link includes test cases. Explanation:

\d+
*

Convert to unary.

O^`_+(?=.*])

Sort [x] in descending order.

_+(?=.*])(?<=(\W+_+)+)
$#1*$&

Multiply each element of [x] by its index.

+`\W+_+(.*_)_$
$1

Delete the first M-1 elements of [x].

(_+).*], \1,

Test whether any remaining element of [x] is greater or equal to T.

Answer 6

Perl 6, 46 33 29 bytes

{$^b>all $^a.sort Z*[...] @_}

Try it online!

Anonymous code blocks that takes input in the form list, amount, length of list, minimum amount of investors and returns a truthy/falsey all Junction, where truthy is failed and falsey is success.

Explanation:

{                           }  # Anonymous code block
     all                       # Are all of
         $^a.sort                # The sorted list
                  Z*             # Zip multiplied by
                     [...] @_    # The range from length of list to the minimum amount
 $^b>                          # Not smaller than the given amount?

Answer 7

05AB1E, 6 bytes

Input taken in the order T, N, x[], M
Output is 0 for peer reward and 1 if not

Ÿs{*›W

Try it online! or as a Test Suite

Explanation

Ÿ        # push the range [N ... T]
 s{      # push the list x[] sorted ascending
   *     # elementwise multiplication (crops to shortest list)
    ›    # for each element, check if M is greater than it
     W   # push min of the result
         # output implicitly

Answer 8

C# (.NET Core), 129, 89 bytes

EDIT: Thanks to Kevin Cruijssen for golfing off 40 bytes while explaining the mechanics as to why!

(n,q,t,m)=>{int c=0,j;for(;m<=n&c<1;c=c<m++?0:1)for(j=n;j-->0;)c+=q[j]<t/m?0:1;return c;}

Try it online!

Answer 9

JavaScript, 72 bytes

Code

(x,T,M)=>x.sort(t=(d,e)=>e-d).map((s,i)=>s*i+s).slice(M-1).sort(t)[0]>=T

Try it online!

Accepts input in format (x[],T,M)

Explanation

x.sort(t=(d,e)=>e-d)     \\sort numbers in reverse numerical order
.map((s,i)=>s*i+s)       \\Multiply each number in array by position(1 indexed) in array
.slice(M-1)              \\Remove the first M-1 elements (at least M people)
.sort(t)[0]              \\Get the maximum value in the array
>=T                      \\True if the maximum value is >= the threshold

Answer 10

Python 3, 136 bytes

Just tests the conditions to make sure they are met. 1 if the reward is given, 0 if not.

lambda N,x,T,M:(sum(x)>=T)*(M<=N)*any(any(all(j>=T/k for j in i)for i in combinations(x,k))for k in range(M,N+1))
from itertools import*

Try it online!

Answer 11

Japt, 16 14 13 11 bytes

ñ í*WõX)d¨V

Try it

ñ í*WõX)d¨V
                  :Implicit input of array U=x and integers V=T, W=M & X=N
ñ                 :Sort U
  í               :Interleave with
    WõX           :  Range [W,X]
   *              :  And reduce each pair of elements by multiplication
       )          :End interleaving
        d         :Any
         ¨V       :  Greater than or equal to V

Answer 12

Python,  71  65 bytes

lambda x,T,M:all(i*v<T for i,v in enumerate(sorted(x)[-M::-1],M))

Try it online!

An unnamed function; port of my Jelly answer. As such "yes" is False and "no" is True. Here, however, we discard test-cases as a part of the reversal and take advantage of the ability to initiate the enumerate count to M. (min would also work in place of all)

Answer 13

R, 43 42 bytes

-1 bytes by implementing the approach even more closely

function(N,x,S,M)min(sort(x,T)[M:N]*M:N<S)

Try it online!

Simple R implementation of Jonathan's Jelly approach. I tried a bunch of variations but this pips the best I could think of by a few bytes.

1 implies failure, 0 implies success.

Answer 14

Java 8, 91 (or 89?) bytes

(N,x,T,M)->{int c=0,j;for(;M<=N&c<1;c=c<M++?0:1)for(j=N;j-->0;)c+=x[j]<T/M?0:1;return c;}

Port of @Destroigo's C# .NET answer (after I golfed it some more), so make sure to upvote him!

Takes inputs N,x,T,M and outputs true/false for "yes"/"no" respectively.

Since the challenge specifically asks for boolean results, I can't return the 1/0 as is, since those aren't valid truthy/falsey values in Java. If any two distinct output values for "yes"/"no" is valid for this challenge instead, the >0 in the return can be dropped to save two bytes, in which case it'll return 1/0 for "yes"/"no" respectively.

Try it online.

Explanation:

(N,x,T,M)->{           // Method with the four parameters and boolean return-type
  int c=0,             //  Count integer, starting at 0
      j;               //  Temp index integer
  for(;M<=N            //  Loop as long as `M` is smaller than or equal to `N`
       &c<1            //  and `c` is not 1 yet:
      ;                //    After every iteration:
       c=c<M++?        //     If `M` is smaller than `c`:
                       //     (and increase `M` by 1 afterwards with `M++`)
          0            //      Set `c` to 0
         :             //     Else:
          1)           //      Set `c` to 1
    for(j=N;j-->0;)    //   Inner loop `j` in the range (`N`,0]:
       c+=             //    Increase the counter `c` by:
          x[j]         //     If the `j`'th value in `x`
              <T/M?    //     is smaller than `T` divided by `M`:
                   0   //      Leave the counter `c` unchanged by adding 0
                  :    //     Else:
                   1;  //      Increase the counter `c` by 1
  return c>0;}         //  Return whether the counter `c` is 1

Answer 15

C# (Visual C# Interactive Compiler), 66 bytes

(n,x,t,m)=>Enumerable.Range(m,n-m+1).Any(k=>x.Count(y=>y>=t/k)>=k)

Try it online!

Inspired by @EmbodimentOfIgnorance's answer.

I've mentioned this before, but C# 8 has a range literal which could make this answer something like this:

(n,x,t,m)=>[m..n-m+1].Any(k=>x.Count(y=>y>=t/k)>=k)

I saw a link to SharpLab with an example, but I wasn't able to get it to work myself.

One thing I changed was the x and t values are decimals. This handles the case where t is not divisible by k a little better.