Défi lié au marketing à plusieurs niveaux.

Un pair veut être récompensé. Il a donc attiré des Ninvestisseurs ( N>=1), chaque i-ème investisseur ayant investi x[i]. Lorsqu'une somme totale dépasse le seuil, x[0]+x[1]+...+x[N-1] >= Tun pair pourrait être récompensé. Mais seulement si les conditions suivantes sont remplies:

• Le nombre minimum d'investisseurs doit être supérieur à M , ( M<=N)
• Pour au moins un entier k, où k>=Met k<=N, tout kinvestisseur doit investir au moinsT/k chacun;

Donné N, x[], T, M vous devez déterminer si la récompense du pair est générée ou non (résultat booléen, «oui» ou «non»). Le code le plus court gagne.

Exemples:

N=5; M=3; T=10000, afin de générer la récompense du pair, l'une des conditions suivantes doit être remplie:

• 3 investis au moins 3334 chacun
• 4 investis au moins 2500 chacun
• chacun des 5 a investi au moins 2000 chacun

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

• 2 investis au moins 2500 chacun
• 3 investis chacun au moins 1667
• 4 investis au moins 1250 chacun
• 5 investis au moins 1 000 chacun
• chacun des 6 a investi au moins 834 chacun

généralisé: pour tout k, où k>=Met k<=N:

• l'un kdes Ninvestisseurs a investi au moins T/kchacun

Cas de test:

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

Gelée ,  12  9 octets

ṢṚ×J$ṫ⁵<Ṃ

Un programme complet qui accepte x T Met imprime 0si le pair est récompensé et1 sinon.

Essayez-le en ligne!

Comment?

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

{Rƶ.ssè›ß

Essayez-le en ligne ou vérifiez tous les cas de test .

Port de la réponse Jelly de @JonathanAllan , prend donc également les entrées x T Met sorties 0pour "yes"et 1pour "no". Si cela n'est pas autorisé et doit être inversé, une fin _peut être ajoutée.

Explication:

{           # 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 pour .ssè:

sG¦}

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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 octets

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

Essayez-le en ligne

Rétine , 79 octets

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

Essayez-le en ligne! Prend la saisie dans le format [x], T, M. Le lien inclut des cas de test. Explication:

\d+
*

Convertissez en unaire.

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

Trier [x]par ordre décroissant.

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

Multipliez chaque élément de [x]par son index.

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

Supprimer le premier M-1 éléments de [x].

(_+).*], \1,

Testez si un élément restant de [x]est supérieur ou égal à T.

Perl 6 , 46 33 29 octets

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

Essayez-le en ligne!

Blocs de code anonymes qui prennent une entrée dans le formulaire list, amount, length of list, minimum amount of investorset retournent une jonction vérité / falsey all, où la vérité est échouée et falsey est un succès.

Explication:

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

Entrée pris dans l'ordre T, N, x[], La M
sortie est 0une récompense par les pairs et 1sinon

Ÿs{*›W

Essayez-le en ligne! ou comme suite de tests

Explication

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

EDIT: Merci à Kevin Cruijssen d'avoir joué au golf sur 40 octets tout en expliquant la mécanique pour expliquer pourquoi!

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

Essayez-le en ligne!

C # (Visual C # Interactive Compiler) avec indicateur /u:System.Linq.Enumerable, 69 octets

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

Essayez-le en ligne!

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

Sans aucun indicateur, 73 octets

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

Essayez-le en ligne!

JavaScript, 72 octets

Code

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

Essayez-le en ligne!

Accepte une entrée au format (x [], T, M)

Explication

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 octets

Il suffit de tester les conditions pour vous assurer qu'elles sont remplies. 1 si la récompense est donnée, 0 sinon.

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*

Essayez-le en ligne!

Python ,  71  65 octets

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

Essayez-le en ligne!

Une fonction sans nom; port de ma réponse Jelly. En tant que tel, «oui» est Falseet «non» l'est True. Ici, cependant, nous rejetons les cas de test dans le cadre de l'inversion et profitons de la possibilité d'initier le enumeratecomptage M. ( minfonctionnerait également à la place de all)

R , 43 42 octets

-1 octets en implémentant l'approche encore plus étroitement

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

Essayez-le en ligne!

Implémentation R simple de l'approche Jelly de Jonathan. J'ai essayé un tas de variations mais cela pépine le mieux que je pouvais penser de quelques octets.

1 implique un échec, 0 implique un succès.

Japt, 16 14 13 11 octets

ñ í*WõX)d¨V

Essayez-le

ñ í*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 (ou 89?) Octets

(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 de la réponse C # .NET de @Destroigo (après l'avoir joué un peu plus), alors assurez-vous de voter pour lui!

Prend des entrées N,x,T,Met des sorties true/ falsepour "yes"/ "no"respectivement.

Étant donné que le défi demande spécifiquement des booleanrésultats, je ne peux pas retourner le 1/ 0tel quel , car ce ne sont pas des valeurs truey / falsey valides en Java. Si deux valeurs de sortie distinctes pour "yes"/ "no"sont valables pour ce défi à la place, le >0retour peut être supprimé pour enregistrer deux octets, auquel cas il retournera 1/ 0pour "yes"/ "no"respectivement.

Essayez-le en ligne.

Explication:

(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 octets

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

Essayez-le en ligne!

Inspiré par la réponse de @ EmbodimentOfIgnorance.

J'ai déjà mentionné cela, mais C # 8 a un littéral de plage qui pourrait rendre cette réponse quelque chose comme ceci:

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

J'ai vu un lien vers SharpLab avec un exemple, mais je n'ai pas pu le faire fonctionner moi-même.

J'ai changé une chose xet les tvaleurs sont des décimales. Cela gère le cas où tn'est pas divisible par kun peu mieux.