Desafío relacionado con el marketing multinivel.

Un compañero quiere ser recompensado. Por lo tanto, atrajo a los Ninversores ( N>=1), cada i-ésimo inversor invirtió x[i]. Cuando una suma total excede el umbral, x[0]+x[1]+...+x[N-1] >= Tun compañero podría ser recompensado. Pero solo si se cumplen las siguientes condiciones:

• La cantidad mínima de inversores debe ser mayor que M( M<=N)
• Para al menos un número entero k, dónde k>=My k<=N, cualquier kinversor tiene que invertir al menos T/kcada uno;

Dado N, x[], T, Mque debe determinar si la recompensa de los pares se genera o no (resultado booleano, "sí" o "no"). El código más corto gana.

Ejemplos:

N=5; M=3; T=10000, para generar la recompensa de un compañero, debe cumplirse uno de los siguientes:

• 3 invirtieron al menos 3334 cada uno
• 4 invirtieron al menos 2500 cada uno
• los 5 invirtieron al menos 2000 cada uno

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

• 2 invirtieron al menos 2500 cada uno
• 3 invirtieron al menos 1667 cada uno
• 4 invirtieron al menos 1250 cada uno
• 5 invertidos al menos 1000 cada uno
• los 6 invirtieron al menos 834 cada uno

generalizado: para cualquier k, donde k>=My k<=N:

• cualquiera kde los Ninversores invirtió al menos T/kcada

Casos de prueba:

formato:

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

Jalea ,  12  9 bytes

ṢṚ×J$ṫ⁵<Ṃ

Un programa completo que acepta x T Me imprime 0si el compañero es recompensado y 1si no.

Pruébalo en línea!

¿Cómo?

ṢṚ×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è›ß

Pruébelo en línea o verifique todos los casos de prueba .

Puerto de la respuesta Jelly de @JonathanAllan , por lo que también toma las entradas x T My salidas 0por "yes"y 1para "no". Si esto no está permitido, y debe invertirse, _se puede agregar un final .

Explicación:

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

Alternativa para .ssè:

sG¦}

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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)

Pruébalo en línea

Retina , 79 bytes

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

Pruébalo en línea! Toma entrada en el formato [x], T, M. El enlace incluye casos de prueba. Explicación:

\d+
*

Convierte a unario.

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

Ordenar [x]en orden descendente.

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

Multiplica cada elemento de [x]por su índice.

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

Eliminar los primeros M-1elementos de [x].

(_+).*], \1,

Pruebe si algún elemento restante de [x]es mayor o igual a T.

Perl 6 , 46 33 29 bytes

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

Pruébalo en línea!

Bloques de código anónimo que toman la entrada en el formulario list, amount, length of list, minimum amount of investorsy devuelven un cruce de verdad / falsey all, donde la verdad falla y falsey es un éxito.

Explicación:

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

Entrada efectuará siguiendo el orden T, N, x[], M
salida es 0por la recompensa de pares y 1si no se

Ÿs{*›W

Pruébalo en línea! o como un conjunto de pruebas

Explicación

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

EDITAR: ¡Gracias a Kevin Cruijssen por jugar 40 bytes mientras explicaba la mecánica de por qué!

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

Pruébalo en línea!

C # (compilador interactivo de Visual C #) con indicador /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()

Pruébalo en línea!

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

Sin banderas, 73 bytes

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

Pruébalo en línea!

JavaScript, 72 bytes

Código

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

Pruébalo en línea!

Acepta entradas en formato (x [], T, M)

Explicación

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

Simplemente prueba las condiciones para asegurarse de que se cumplan. 1 si se otorga la recompensa, 0 si no.

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*

Pruébalo en línea!

Python ,  71  65 bytes

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

Pruébalo en línea!

Una función sin nombre; puerto de mi respuesta Jelly. Como tal, "sí" es Falsey "no" es True. Aquí, sin embargo, descartamos los casos de prueba como parte de la inversión y aprovechamos la capacidad de iniciar el enumerateconteo M. ( mintambién funcionaría en lugar de all)

R , 43 42 bytes

-1 bytes al implementar el enfoque aún más de cerca

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

Pruébalo en línea!

Implementación R simple del enfoque Jonathan's Jelly. Intenté varias variaciones, pero esto es lo mejor que se me ocurre por unos pocos bytes.

1 implica fracaso, 0 implica éxito.

Japt, 16 14 13 11 bytes

ñ í*WõX)d¨V

Intentalo

ñ í*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 (¿o 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;}

Respuesta de C # .NET del puerto de @Destroigo (después de jugar un poco más), ¡así que asegúrese de votarlo!

Toma entradas N,x,T,My salidas true/ falsepara "yes"/ "no"respectivamente.

Dado que el desafío pide específicamente booleanresultados, no puedo devolver el 1/ 0as como está, ya que esos no son valores de verdad / falsey válidos en Java. Si dos valores de salida distintos para "yes"/ "no"son válidos para este desafío en su lugar, >0se puede descartar en el retorno para guardar dos bytes, en cuyo caso devolverá 1/ 0para "yes"/ "no"respectivamente.

Pruébalo en línea.

Explicación:

(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 # (compilador interactivo de Visual C #) , 66 bytes

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

Pruébalo en línea!

Inspirado por la respuesta de @ EmbodimentOfIgnorance.

He mencionado esto antes, pero C # 8 tiene un rango literal que podría hacer que esta respuesta sea algo como esto:

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

Vi un enlace a SharpLab con un ejemplo, pero no pude hacerlo funcionar.

Una cosa que cambié fue el xy los tvalores son decimales. Esto maneja el caso donde tno es divisible por kun poco mejor.