Thách thức liên quan đến tiếp thị đa cấp.

Một đồng nghiệp muốn nhận được phần thưởng. Vì vậy, nó thu hút Ncác nhà đầu tư ( N>=1), mỗi nhà đầu tư thứ i đầu tư x[i]. Khi tổng số tiền vượt quá ngưỡng, x[0]+x[1]+...+x[N-1] >= Tmột đồng nghiệp có thể được khen thưởng. Nhưng chỉ khi một điều kiện sau được thỏa mãn:

• Số lượng nhà đầu tư tối thiểu phải lớn hơn M, ( M<=N)
• Đối với ít nhất một số nguyên k, ở đâu k>=Mvà k<=N, bất kỳ knhà đầu tư nào cũng phải đầu tư ít nhất T/kmỗi số nguyên;

Cho N, x[], T, Mbạn nên xác định xem phần thưởng của đồng nghiệp có được tạo ra hay không (kết quả boolean, "có" hoặc "không"). Mã ngắn nhất sẽ thắng.

Ví dụ:

N=5; M=3; T=10000, để tạo ra phần thưởng của đồng nghiệp, một trong những điều sau đây phải được thỏa mãn:

• bất kỳ 3 đầu tư ít nhất 3334 mỗi
• bất kỳ 4 đầu tư ít nhất 2500 mỗi
• Tất cả 5 đầu tư ít nhất 2000 mỗi

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

• bất kỳ 2 đầu tư ít nhất 2500 mỗi
• bất kỳ 3 đầu tư ít nhất 1667 mỗi
• bất kỳ 4 đầu tư ít nhất 1250 mỗi
• bất kỳ 5 đầu tư ít nhất 1000 mỗi
• tất cả 6 đầu tư ít nhất 834 mỗi

khái quát: cho bất kỳ k, ở đâu k>=Mvà k<=N:

• bất kỳ kcủa Ncác nhà đầu tư có vốn đầu tư ít nhất T/kmỗi

Các trường hợp thử nghiệm:

định dạng:

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

Thạch ,  12  9 byte

ṢṚ×J$ṫ⁵<Ṃ

Một chương trình đầy đủ chấp nhận x T Mvà in 0nếu đồng đẳng được khen thưởng và 1nếu không.

Hãy thử trực tuyến!

Làm sao?

ṢṚ×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

05AB1E , 9 byte

{Rƶ.ssè›ß

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Cảng @JonathanAllan 's Jelly câu trả lời , vì vậy cũng có đầu vào x T Mvà đầu ra 0cho "yes"và 1cho "no". Nếu điều này là không được phép, và nó nên được đảo ngược, một dấu vết _có thể được thêm vào.

Giải trình:

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

Thay thế cho .ssè:

sG¦}

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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]

JavaScript, 54 52 byte

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

Dùng thử trực tuyến

Võng mạc , 79 byte

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

Hãy thử trực tuyến! Đưa đầu vào theo định dạng [x], T, M. Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

\d+
*

Chuyển đổi sang unary.

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

Sắp xếp [x]theo thứ tự giảm dần.

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

Nhân mỗi phần tử của [x]chỉ số của nó.

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

Xóa các M-1yếu tố đầu tiên của [x].

(_+).*], \1,

Kiểm tra xem bất kỳ phần tử còn lại của [x]là lớn hơn hoặc bằng T.

Perl 6 , 46 33 29 byte

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

Hãy thử trực tuyến!

Các khối mã ẩn danh nhận đầu vào dưới dạng list, amount, length of list, minimum amount of investorsvà trả về một Giao diện trung thực / falsey all, trong đó sự thật là thất bại và falsey là thành công.

Giải trình:

{                           }  # 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?

05AB1E , 6 byte

Đầu vào lấy theo thứ tự T, N, x[], M
Đầu ra là 0để thưởng đồng đẳng và 1nếu không muốn nói

Ÿs{*›W

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

Ÿ        # 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

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

EDIT: Cảm ơn Kevin Cruijssen vì đã chơi golf 40 byte trong khi giải thích cơ học là tại sao!

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

Hãy thử trực tuyến!

C # (Trình biên dịch tương tác Visual C #) với cờ /u:System.Linq.Enumerable, 69 byte

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

Hãy thử trực tuyến!

// 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()

Không có cờ, 73 byte

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

Hãy thử trực tuyến!

JavaScript, 72 byte

Mã

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

Hãy thử trực tuyến!

Chấp nhận đầu vào ở định dạng (x [], T, M)

Giải trình

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

Python 3 , 136 byte

Chỉ cần kiểm tra các điều kiện để đảm bảo chúng được đáp ứng. 1 nếu phần thưởng được trao, 0 nếu không.

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*

Hãy thử trực tuyến!

Python ,  71  65 byte

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

Hãy thử trực tuyến!

Một chức năng không tên; cổng câu trả lời Jelly của tôi. Như "có" là Falsevà "không" là True. Tuy nhiên, ở đây, chúng tôi loại bỏ các trường hợp thử nghiệm như là một phần của sự đảo ngược và tận dụng khả năng để bắt đầu enumerateđếm đến M. ( mincũng sẽ làm việc thay thế all)

R , 43 42 byte

-1 byte bằng cách thực hiện cách tiếp cận thậm chí chặt chẽ hơn

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

Hãy thử trực tuyến!

Thực hiện R đơn giản của phương pháp Jelly của Jonathan. Tôi đã thử một loạt các biến thể nhưng điều này tốt nhất tôi có thể nghĩ đến bằng một vài byte.

1 ngụ ý thất bại, 0 ngụ ý thành công.

Japt, 16 14 13 11 byte

ñ í*WõX)d¨V

Thử nó

ñ í*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

Java 8, 91 (hoặc 89?) Byte

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

Câu trả lời C # .NET của @Destroigo (sau khi tôi đánh gôn thêm), vì vậy hãy đảm bảo nâng cấp anh ấy!

Lấy đầu vào N,x,T,Mvà đầu ra true/ falsecho "yes"/ "no"tương ứng.

Vì thử thách đặc biệt yêu cầu booleankết quả, tôi không thể trả lại 1/ 0như vậy, vì những giá trị không hợp lệ / falsey không hợp lệ trong Java. Thay vào đó, nếu có hai giá trị đầu ra riêng biệt cho "yes"/ "no"hợp lệ cho thử thách này, thì >0phần trả về có thể được loại bỏ để lưu hai byte, trong trường hợp đó, nó sẽ trả về 1/ 0cho "yes"/ "no"tương ứng.

Hãy thử trực tuyến.

Giải trình:

(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

C # (Trình biên dịch tương tác Visual C #) , 66 byte

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

Hãy thử trực tuyến!

Lấy cảm hứng từ câu trả lời của @ EmbodimentOfIgnorance.

Tôi đã từng đề cập đến điều này trước đây, nhưng C # 8 có một phạm vi nghĩa đen có thể khiến câu trả lời này giống như thế này:

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

Tôi đã thấy một liên kết đến SharpLab với một ví dụ, nhưng tôi không thể làm cho nó hoạt động được.

Một điều tôi đã thay đổi là xvà tgiá trị là số thập phân. Điều này xử lý trường hợp tkhông chia hết cho kmột chút tốt hơn.