_{liên quan và lấy cảm hứng từ - Tìm phân vùng tổng hợp}

Một tập hợp Ađược định nghĩa ở đây như là rành mạch tổng hợp miễn phí nếu

• 1) nó bao gồm ít nhất ba yếu tố |A| ≥ 3, và
• 2) tính tổng riêng biệt của nó A + A = { x + y | x, y in A}(với x,yriêng biệt, nghĩa là, x≠y) không có yếu tố chung với A.

_{(Obsolete -... Không sử dụng này đi về phía trước trái ở đây chỉ bởi vì một số câu trả lời có thể đã sử dụng nó Nó không phù hợp với các điều kiện trên Ngoài ra, phương trình x + y = zkhông có giải pháp cho x,y,z ∈ A(một lần nữa với x,y,zriêng biệt, tức là x≠y, x≠z, y≠z.) )}

Đối với một ví dụ đơn giản, {1,3,5}rõ ràng là không có tổng, nhưng {1,3,4}không phải. {1,3}và {3}cũng không, vì chúng không có ít nhất ba yếu tố.

Thách thức ở đây là tìm ra tập hợp con không có tổng lớn nhất của đầu vào đã cho.

Đầu vào

• Một bộ Asố nguyên không có thứ tự trong bất kỳ định dạng thuận tiện .
• Các số nguyên có thể là dương, âm hoặc bằng 0, nhưng có thể được coi là phù hợp với [int]kiểu dữ liệu gốc của ngôn ngữ của bạn (hoặc tương đương).
• Bộ này được đảm bảo chỉ có các yếu tố riêng biệt (không có nhiều trang ở đây).
• Bộ này không nhất thiết phải được sắp xếp.

Đầu ra

• Tập hợp con lớn nhất của A(có thể là Achính nó), hoàn toàn không có tổng. Đầu ra có thể ở bất kỳ định dạng phù hợp.
• Nếu không có tập hợp con như vậy tồn tại, xuất ra một tập hợp trống hoặc giá trị falsey khác .
• Nếu nhiều tập con được gắn với giá trị lớn nhất, hãy xuất bất kỳ hoặc tất cả chúng.
• Tập hợp con không nhất thiết phải được sắp xếp, hoặc theo thứ tự như đầu vào. Ví dụ, đối với đầu {1,3,5}ra đầu vào {5,1,3}là chấp nhận được.

Quy tắc bổ sung

• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn , vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất sẽ thắng.

Ví dụ

Input     -> Output (any or all)
{0}       -> {}
{1, 2, 3} -> {}
{1, 3, 5} -> {1, 3, 5}
{1, 2, 3, 4, 5} -> {1, 2, 5}  {1, 2, 4}  {1, 3, 5}  {2, 3, 4}  {2, 4, 5}  {3, 4, 5}
{-5, 4, 3, -2, 0} -> {-5, 4, 3}  {-5, 4, -2}  {4, 3, -2}
{-5, 4, 3, -2} -> {-5, 4, 3}  {-5, 4, -2}  {4, 3, -2}
{-17, 22, -5, 13, 200, -1, 1, 9} -> {-17, 22, -5, 13, 200, -1, 1}  {-17, 22, -5, 200, -1, 1, 9}  {-17, -5, 13, 200, -1, 1, 9}

Thạch , 17 byte

8BḊ+œc2S€f
ŒPÇÐḟṪ

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

MATL , 47 43 byte

nW:qB!ts2#Sw2>)PZ)"1G@)XJ2XN!"@sJ@X-m~*]?J.

Hãy thử trực tuyến!

Giải trình

Điều này sử dụng hai vòng lặp: một vòng lặp bên ngoài để tạo ra tất cả các tập hợp con có thể và một vòng lặp bên trong để lấy tất cả các cặp phần tử và xem tổng có bằng bất kỳ phần tử nào khác của tập hợp con không.

Các tập hợp con của ít nhất 3 phần tử được kiểm tra theo thứ tự giảm số lượng phần tử. Mã dừng lại ngay khi tìm thấy một tập hợp con hợp lệ.

          % Take input implicitly
nW:q      % Generate [0 1 ... 2^n-1] where n is input length
B!        % Convert to binary. Gives a matrix. Each number corresponds to a column.
          % This will be used to select the elements of each subset
ts        % Duplicate. Sum of each column
2#S       % Sort. Output the sorted array and the indices of the sorting. Each index
          % corresponds to one possible subset
w2>       % Swap. Logical index of values that exceed 2. This is used to pick only
          % subsets of more than 2 elements
)         % Keeps only indices of subsets that have at least 3 elements
P         % Flip. This moves subsets with more elements to the front. As soon as a
          % subset fulfills the condition the outer loop will be exited, so we need
          % to start with the bigger subsets
Z)        % Index into columns of binary matrix. Each column is the binary pattern
          % defining a subset with at least 3 elements, starting with bigger subsets
"         % For each column. Each iteration corresponds to a subset
  1       %   Push 1
  G@)     %   Pick actual elements of each subset (logical index into input)
  XJ      %   Copy to clipboard J
  2XN!    %   All pairs of 2 elements from that subset. Each pair is a column
  "       %   For each column. Each iteration corresponds to a pair of elements
    @s    %     Sum of those two elements
    J@X-  %     Array with the other elements (obtained with set difference)
    m~    %     True if the sum of the two elemens is not a member of the array
    *     %     Multiply. Corresponds to logical AND
  ]       %   End for
  ?       %   If result is true: no sum of two elements equalled any element
    J     %     Push found subset (will be displayed implicitly)
    .     %     Exit loop
          %   End if implicitly
          % End for implicitly
          % Display stack implicitly

Python, 137 byte

Một cách tiếp cận ngây thơ. Vòng lặp trên tất cả các tập hợp con của đầu vào chứa ít nhất 3 giá trị, kiểm tra thuộc tính cho từng tập hợp. Trả về []khi không tìm thấy kết quả hoặc [S]nếu có ít nhất một kết quả được tìm thấy (trong đó Scó một số bộ).

from itertools import*
lambda a:[c for n in range(3,len(a)+1)for c in combinations(a,n)if all(x+y-z for(x,y,z)in permutations(c,3))][-1:]

Javascript 246 263

a=>([...Array(1<<(l=a.length))].map((x,i)=>i.toString(2)).filter(n=>/1.*1.*1/.test(n)).map(s=>('0'.repeat(l)+s).slice(-l).replace(/./g,(b,p)=>+b&&o.push(a[p]),o=[])&&o).filter(u=>u.every((x,i)=>!u.some((y,j)=>j-i&&u.some((z,k)=>k-j&&!(z-x-y))))))

Rất lâu :( ... Nhưng đó là một mã hóa tốt .. (tôi nghĩ)

Ít chơi gôn hơn:

f=a=>(
    [...Array(1<<(l=a.length))]
        .map((x,i)=>i.toString(2))
        .filter(n=>/1.*1.*1/.test(n))
        .map(s=>
            ('0'.repeat(l)+s).slice(-l).replace(/./g,
                (b,p)=>+b&&o.push(a[p])
            ,o=[])&&o
        )
        .filter(u=>
            u.every((x,i)=>
                !u.some((y,j)=>
                    j-i&&u.some((z,k)=>k-j&&!(z-x-y))
                )
            )
        )
)

document.body.innerHTML = JSON.stringify( f([1,2,3,4,5]), null, 1 );

Toán học - 89 84 83 77 76 byte

6 byte được lưu nhờ @ Sp3000

Có lẽ có thể chơi golf nhiều hơn nữa, có cách nào ngắn hơn để lọc không?

Select[Subsets@#,Length@#>2&&Intersection[#,Tr/@#~Subsets~{2}]=={}&]~Last~0&

Hàm ẩn danh, trả 0về không có câu trả lời.

Ruby, 107 byte

Đầu vào là một mảng. Thu thập một tập hợp con đủ điều kiện cho mỗi kích thước tập hợp con từ 3đến độ dài đầu vào, sau đó trả về tập hợp con lớn nhất trong số tập hợp con được tìm thấy. Trả về nilnếu không tìm thấy kết quả.

Do thông số kỹ thuật mâu thuẫn, có hai giải pháp hiện có cùng một mã số.

Sử dụng định nghĩa đầu tiên: ( { x + y | x, y ∈ A } ∩ A = ∅)

->s{((3..s.size).map{|i|s.combination(i).find{|e|e.combination(2).map{|a,b|a+b}&e==[]}}-[p])[-1]}

Sử dụng định nghĩa thứ hai ( ∀ x, y, z ∈ A: x + y ≠ z)

->s{((3..s.size).map{|i|s.combination(i).find{|e|e.permutation(3).all?{|a,b,c|a+b!=c}}}-[p])[-1]}

Bình thường, 27 byte

ef!f!*Fm-Fd.pYfqlY3yTfglT3y

Bộ thử nghiệm.