Multi-Level-Marketing-Herausforderung.

Ein Peer möchte belohnt werden. Es zog also NInvestoren an ( N>=1), jeder i-te Investor investierte x[i]. Wenn eine Gesamtsumme den Schwellenwert überschreitet, kann x[0]+x[1]+...+x[N-1] >= Tein Peer belohnt werden. Aber nur wenn folgende Bedingungen erfüllt sind:

• Die Mindestanzahl an Anlegern sollte größer sein als M( M<=N)
• Für mindestens eine Ganzzahl k, bei der k>=Mund k<=Njeder kAnleger mindestens T/kjede investieren muss;

Vorausgesetzt, N, x[], T, MSie sollten bestimmen, ob die Belohnung des Peers generiert wird oder nicht (boolesches Ergebnis, "Ja" oder "Nein"). Der kürzeste Code gewinnt.

Beispiele:

N=5; M=3; T=10000Um die Belohnung des Peers zu generieren, muss eine der folgenden Bedingungen erfüllt sein:

• 3 investierten jeweils mindestens 3334
• 4 investierten jeweils mindestens 2500
• Alle 5 investierten jeweils mindestens 2000

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

• 2 investierten jeweils mindestens 2500
• 3 investierten jeweils mindestens 1667
• 4 investierten jeweils mindestens 1250
• 5 investierten jeweils mindestens 1000
• Alle 6 investierten jeweils mindestens 834

verallgemeinert: für jeden k, wo k>=Mund k<=N:

• jeder kder NAnleger investiert mindestens T/kjeweils

Testfälle:

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

Gelee ,  12  9 Bytes

ṢṚ×J$ṫ⁵<Ṃ

Ein vollständiges Programm, das akzeptiert x T Mund druckt, 0ob der Peer belohnt wird und 1wenn nicht.

Probieren Sie es online aus!

Wie?

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

{Rƶ.ssè›ß

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Port von @JonathanAllans Jelly-Antwort , nimmt also auch die Ein- x T Mund Ausgänge 0für "yes"und 1für "no". Wenn dies nicht zulässig ist und invertiert werden sollte, kann ein Trailing _hinzugefügt werden.

Erläuterung:

{           # 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 für .ssè:

sG¦}

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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 Bytes

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

Probieren Sie es online aus

Netzhaut , 79 Bytes

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

Probieren Sie es online aus! Nimmt Eingaben im Format vor [x], T, M. Link enthält Testfälle. Erläuterung:

\d+
*

In unary konvertieren.

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

[x]In absteigender Reihenfolge sortieren .

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

Multiplizieren Sie jedes Element [x]mit seinem Index.

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

Löschen Sie die ersten M-1Elemente von [x].

(_+).*], \1,

Testen Sie, ob ein verbleibendes Element von [x]größer oder gleich ist T.

Perl 6 , 46 33 29 Bytes

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

Probieren Sie es online aus!

Anonymer Code blockiert, der Eingaben in das Formular übernimmt list, amount, length of list, minimum amount of investorsund eine Truthy / Falsey- allKreuzung zurückgibt , bei der Truthy fehlschlägt und Falsey Erfolg hat.

Erläuterung:

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

Eingang in der Reihenfolge genommen T, N, x[], Die M
Ausgabe ist 0für Peer - Belohnung und 1wenn nicht

Ÿs{*›W

Probieren Sie es online aus! oder als Testsuite

Erläuterung

Ÿ        # 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: Vielen Dank an Kevin Cruijssen für das Golfen von 40 Bytes und die Erklärung der Mechanik, warum!

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

Probieren Sie es online aus!

C # (Visual C # Interactive Compiler) mit Flag /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()

Probieren Sie es online aus!

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

Ohne Flags 73 Bytes

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

Probieren Sie es online aus!

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

Probieren Sie es online aus!

Akzeptiert Eingaben im Format (x [], T, M)

Erläuterung

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 Bytes

Testen Sie einfach die Bedingungen, um sicherzustellen, dass sie erfüllt sind. 1 wenn die Belohnung gegeben wird, 0 wenn nicht.

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*

Probieren Sie es online aus!

Python ,  71  65 Bytes

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

Probieren Sie es online aus!

Eine unbenannte Funktion; Port meiner Jelly Antwort. Als solches ist "Ja" Falseund "Nein" True. Hier verwerfen wir jedoch Testfälle als Teil der Umkehrung und nutzen die Möglichkeit, die enumerateZählung zu initiieren M. ( minwürde auch anstelle von arbeiten all)

R , 43 42 Bytes

-1 Bytes durch noch genauere Implementierung des Ansatzes

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

Probieren Sie es online aus!

Einfache R-Implementierung von Jonathans Jelly-Ansatz. Ich habe eine Reihe von Variationen ausprobiert, aber dies ist das Beste, was ich mir vorstellen kann, um ein paar Bytes.

1 bedeutet Misserfolg, 0 bedeutet Erfolg.

Japt, 16 14 13 11 Bytes

ñ í*WõX)d¨V

Versuch es

ñ í*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 (oder 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 @Destroigos C # .NET-Antwort (nachdem ich noch ein bisschen Golf gespielt habe), also stellen Sie sicher, dass Sie ihn positiv bewerten!

Nimmt Ein- N,x,T,Mund Ausgänge true/ falsefür "yes"/ "no".

Da die Herausforderung speziell nach booleanErgebnissen fragt , kann ich das 1/ so 0wie es ist nicht zurückgeben, da dies in Java keine gültigen Wahrheits- / False-Werte sind . Wenn stattdessen zwei unterschiedliche Ausgabewerte für "yes"/ "no"für diese Herausforderung gültig sind, kann der Wert >0in der Rückgabe gelöscht werden, um zwei Bytes zu sparen. In diesem Fall wird 1/ 0für "yes"/ zurückgegeben "no".

Probieren Sie es online aus.

Erläuterung:

(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 # Interactive Compiler) , 66 Byte

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

Probieren Sie es online aus!

Inspiriert von der Antwort von @ EmbodimentOfIgnorance.

Ich habe dies bereits erwähnt, aber C # 8 hat ein Bereichsliteral, das diese Antwort in etwa so aussehen lassen könnte:

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

Ich habe einen Link zu SharpLab mit einem Beispiel gesehen, aber ich konnte ihn nicht selbst zum Laufen bringen.

Eine Sache, die ich geändert habe, war die xund tWerte sind Dezimalstellen. Dies behandelt den Fall, in dem tnicht durch ketwas besser teilbar ist .