다단계 마케팅 관련 과제.

동료는 보상 받기를 원합니다. 그래서 N투자자 들을 끌어 모았고 N>=1, 각 i 번째 투자자는 투자했습니다 x[i]. 총액이 임계 값을 초과 x[0]+x[1]+...+x[N-1] >= T하면 동료에게 보상을 줄 수 있습니다. 그러나 다음 조건이 충족되는 경우에만 :

• 최소 투자자 금액은 M( M<=N) 보다 커야합니다 .
• 적어도 하나의 정수의 k경우, k>=M그리고 k<=N모든 k투자자는 적어도 T/k각각 투자해야한다 .

을 감안할 때 N, x[], T, M당신은 동료의 보상 (부울 결과, "예"또는 "아니오") 생성 여부를 결정 없습니다. 가장 짧은 코드가 승리합니다.

예 :

N=5; M=3; T=10000동료의 보상을 생성하려면 다음 중 하나를 충족해야합니다.

• 3 개는 각각 3334 개 이상을 투자
• 4 명은 각각 2500 명 이상을 투자했습니다.
• 5 명 모두 최소 2000 명씩 투자

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

• 2 개는 각각 2500 개 이상 투자
• 3 명은 각각 1667 명 이상을 투자했습니다.
• 4 명은 각각 최소 1250 명을 투자
• 5 개는 각각 최소 1000 개를 투자했습니다
• 6 명 모두 최소 834 명씩 투자

일반화 : 어떤을 위해 k, 여기서 k>=M및 k<=N:

• 임의 k의 N투자가 적어도 투자 T/k각

테스트 사례 :

체재:

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

젤리 ,  12  9 바이트

ṢṚ×J$ṫ⁵<Ṃ

동료에게 보상이 있고 그렇지 않은 경우 수락 x T M하고 인쇄 하는 전체 프로그램 .01

온라인으로 사용해보십시오!

어떻게?

ṢṚ×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 바이트

{Rƶ.ssè›ß

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

포트 @JonathanAllan 의 젤리 답이 때문에도 얻어 입력 x T M및 출력을 0위해 "yes"및 1대한"no" . 이것이 허용되지 않고 역전되어야하는 경우 후행 _을 추가 할 수 있습니다.

설명:

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

에 대한 대안 .ssè:

sG¦}

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오. .

설명:

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]

자바 스크립트, 54 52 바이트

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

온라인으로 사용해보십시오

레티 나 , 79 바이트

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

온라인으로 사용해보십시오! 형식으로 입력을 [x], T, M받습니다. 링크에는 테스트 사례가 포함됩니다. 설명:

\d+
*

단항으로 변환합니다.

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

정렬 [x]순서를 내림차순으로 정렬합니다.

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

각 요소에 [x]색인을 곱하십시오 .

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

의 첫 번째 M-1요소를 삭제하십시오 [x].

(_+).*], \1,

의 나머지 요소 [x]가보다 크거나 같은지 테스트합니다 T.

펄 6 , 46 33 29 바이트

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

온라인으로 사용해보십시오!

익명의 코드 블록은 형식으로 입력을 list, amount, length of list, minimum amount of investors받고 진실 / 실패 all정션을 반환하며 , 진실은 실패하고 거짓은 성공입니다.

설명:

{                           }  # 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 바이트

순서대로 촬영 입력 T, N, x[], M
출력은 0피어 보상 및 1하지 않을 경우

Ÿs{*›W

온라인으로 사용해보십시오! 또는 테스트 스위트

설명

Ÿ        # 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 코어) , 129 , 89 바이트

편집 : 이유에 대한 메커니즘을 설명하면서 40 바이트 오프 골프를 해 주신 Kevin Cruijssen에게 감사드립니다!

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

온라인으로 사용해보십시오!

플래그 /u:System.Linq.Enumerable가 69 바이트 인 C # (Visual C # Interactive Compiler)

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

온라인으로 사용해보십시오!

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

플래그없이 73 바이트

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

온라인으로 사용해보십시오!

자바 스크립트, 72 바이트

암호

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

온라인으로 사용해보십시오!

형식으로 입력을받습니다 (x [], T, M)

설명

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

파이썬 3 , 136 바이트

조건이 충족되는지 확인하기 만하면됩니다. 보상이 주어지면 1, 그렇지 않으면 0

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*

온라인으로 사용해보십시오!

파이썬 ,  71  65 바이트

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

온라인으로 사용해보십시오!

명명되지 않은 함수; 내 젤리 답변의 포트. 따라서 "예"는 False"아니오"입니다 True. 그러나 여기서는 반전의 일부로 테스트 사례를 삭제하고에 enumerate카운트를 시작하는 기능을 활용 합니다 M. ( min대신에 작동합니다 all)

R , 43 42 바이트

접근 방식을 더욱 밀접하게 구현하여 -1 바이트

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

온라인으로 사용해보십시오!

Jonathan의 Jelly 접근 방식의 간단한 R 구현. 나는 많은 변형을 시도했지만이 pips는 몇 바이트로 생각할 수있는 가장 좋은 것입니다.

1은 실패를, 0은 성공을 나타냅니다.

apt, 16 14 13 11 바이트

ñ í*WõX)d¨V

시도 해봐

ñ í*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 (또는 89?) 바이트

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

@Destroigo 의 C # .NET 포트 (내가 더 골프를 친 후), 그래서 그를 찬성해야합니다!

입력 걸린다 N,x,T,M및 출력 true/ false위한 "yes"/ "no"각각.

도전은 구체적으로 boolean결과를 요구하기 때문에 Java에서 유효한 진실 / 거짓 값 이 아니기 때문에 1/를 0그대로 반환 할 수 없습니다 . 대신 / 에 대한 두 개의 고유 한 출력 값 이이 시도에 유효 하면 리턴에서 in을 삭제하여 2 바이트를 절약 할 수 있으며,이 경우 각각 /에 대해 /를 리턴 합니다."yes""no">010"yes""no"

온라인으로 사용해보십시오.

설명:

(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 # (Visual C # 대화식 컴파일러) , 66 바이트

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

온라인으로 사용해보십시오!

@EmbodimentOfIgnorance의 답변에서 영감을 얻었습니다.

이전에 이것을 언급했지만 C # 8에는이 답변을 다음과 같이 만들 수있는 범위 리터럴이 있습니다.

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

예를 들어 SharpLab에 대한 링크를 보았지만 직접 작동시킬 수는 없었습니다.

내가 변경 한 것은이었다 x과 t값은 소수입니다. 이것은 조금 t나눌 수없는 경우를 처리합니다 k.