ความท้าทายที่เกี่ยวข้องกับการตลาดหลายระดับ

เพื่อนต้องการได้รับรางวัล ดังนั้นมันจึงดึงดูดNนักลงทุน ( N>=1) นักลงทุนรายที่ฉันลงทุน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 ลงทุนอย่างน้อย 2,500
• ทั้ง 5 ลงทุนอย่างน้อย 2,000 ต่อ

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

• 2 ใด ๆ ที่ลงทุนอย่างน้อย 2,500
• ๆ 3 ลงทุนอย่างน้อย 1667 แต่ละอัน
• ๆ 4 ลงทุนอย่างน้อย 1,250 ต่อแต่ละ
• 5 ลงทุนอย่างน้อย 1,000 อัน
• ทั้ง 6 ลงทุนอย่างน้อย 834 ต่อคน

generalized: สำหรับใด ๆ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และพิมพ์0หากเพื่อนได้รับรางวัลและ1หากไม่ได้รับ

ลองออนไลน์!

อย่างไร?

ṢṚ×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 's คำตอบ Jellyจึงยังต้องใช้ปัจจัยการผลิต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]

JavaScript, 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

Perl 6 , 46 33 29 ไบต์

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

ลองออนไลน์!

บล็อกโค้ดแบบไม่ระบุชื่อที่รับอินพุตในแบบฟอร์มlist, amount, length of list, minimum amount of investorsและส่งคืนallJunction ที่เป็นความจริง / เท็จซึ่งความจริงล้มเหลวและล้มเหลวก็คือความสำเร็จ

คำอธิบาย:

{                           }  # 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รางวัล peer และ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 Core) , 129 , 89 ไบต์

แก้ไข: ขอบคุณ Kevin Cruijssen สำหรับการเล่นกอล์ฟ 40 ไบท์ในขณะที่อธิบายกลไกว่าทำไม!

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

ลองออนไลน์!

C # (Visual C # Interactive Compiler)พร้อมแฟล็/u:System.Linq.Enumerableก 69 ไบต์

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

ลองออนไลน์!

JavaScript ขนาด 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

Python 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*

ลองออนไลน์!

Pythonขนาด 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)

ลองออนไลน์!

การนำ R มาใช้อย่างง่ายของวิธีการของ Jelly ของ Jonathan ฉันลองใช้ชุดรูปแบบที่หลากหลาย แต่สิ่งนี้ทำให้ฉันคิดได้ดีที่สุดโดยไม่กี่ไบต์

1 หมายถึงความล้มเหลว 0 หมายถึงความสำเร็จ

Japt, 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;}

คำตอบ C # .NETของพอร์ตของ@Destroigo (หลังจากฉันเล่นกอล์ฟไปมากกว่านี้) ดังนั้นอย่าลืมโหวตให้เขา!

ใช้อินพุตN,x,T,Mและเอาต์พุตtrue/ falseสำหรับ"yes"/ "no"ตามลำดับ

เนื่องจากความท้าทายขอbooleanผลลัพธ์เป็นพิเศษฉันจึงไม่สามารถส่งกลับ1/ 0ตามที่เป็นอยู่เนื่องจากสิ่งเหล่านั้นไม่ใช่ค่าความจริง / เท็จใน Java หากมีค่าเอาต์พุตสองค่าที่แตกต่างกันสำหรับ"yes"/ "no"ถูกต้องสำหรับความท้าทายนี้แทนค่า>0ในการส่งคืนสามารถลดลงเพื่อบันทึกสองไบต์ในกรณีนี้มันจะส่งคืน1/ 0สำหรับ"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 # Interactive Compiler) , 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ดีกว่าเล็กน้อย