Bạn được cung cấp một bộ số nguyên dương. Bạn phải sắp xếp chúng thành các cặp sao cho:

• Mỗi cặp chứa 2 số, một trong số đó là bội số của một số khác. Ví dụ: 8 là bội số của 4 và 9 là bội số của 9.
• Nếu cùng một số xảy ra nhiều lần trong tập ban đầu, nó có thể được sử dụng nhiều lần trong các cặp; một số thậm chí có thể được ghép nối với một lần xuất hiện khác của cùng một số
• Số lượng cặp tối đa có thể thu được.

Đầu ra phải là số lượng cặp. Mã ngắn nhất sẽ thắng.

Dữ liệu mẫu

2,3,4,8,9,18 -> 3

7,14,28,42,56 -> 2

7,1,9,9,4,9,9,1,3,9,8,5 -> 6

8,88,888,8888,88888,888888 -> 3

2,6,7,17,16,35,15,9,83,7 -> 2

Haskell, 109 107 76 70 byte

Cảm ơn nimi vì đã tiết kiệm 33 byte và dạy tôi thêm một số Haskell. :)
Cảm ơn xnor vì đã lưu thêm 6 byte.

import Data.List
f l=maximum$0:[1+f t|a:b:t<-permutations l,a`mod`b<1]

Yay, golf Haskell đầu tiên của tôi. Nó hoạt động giống như tất cả các câu trả lời cho đến nay (tốt, không hoàn toàn: nó chỉ tính độ dài của tiền tố dài nhất của các cặp hợp lệ trong mỗi hoán vị, nhưng đó là tương đương và thực sự là mã CJam ban đầu của tôi đã làm).

Đối với sân gôn thêm, nó cũng không hiệu quả bằng cách tạo đệ quy tất cả các hoán vị của hậu tố mỗi lần hai phần tử đầu tiên của một hoán vị là một cặp hợp lệ.

CJam, 22 18 byte

q~e!{2/::%0e=}%:e>

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

Yêu cầu đầu vào dưới dạng danh sách kiểu CJam.

Đây là một chút không hiệu quả cho các danh sách lớn hơn (và Java có thể sẽ hết bộ nhớ trừ khi bạn cung cấp cho nó nhiều hơn).

Giải trình

q~     e# Read and evaluate input.
e!     e# Get all distinct permutations.
{      e# Map this block onto each permutation...
  2/   e#   Split the list into (consecutive) pairs. There may be a single element at the
       e#   end, which doesn't participate in any pair.
  ::%  e#   Fold modulo onto each chunk. If it's a pair, this computes the modulo, which
       e#   yields 0 if the first element is a multiple of the second. If the list has only
       e#   one element, it will simply return that element, which we know is positive.
  0e=  e#   Count the number of zeroes (valid pairs).
}%
:e>    e# Find the maximum of the list by folding max() onto it.

Bình thường, 13 byte

eSm/%Mcd2Z.pQ

Thời gian và lưu trữ phức tạp thực sự khủng khiếp. Điều đầu tiên tôi làm là tạo một danh sách với tất cả các hoán vị của danh sách ban đầu. Điều này có n*n!lưu trữ. Danh sách đầu vào với độ dài 9 đã mất khá nhiều thời gian.

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Giải trình:

eSm/%Mcd2Z.pQ
            Q   read the list of integer
          .p    create the list of all permutations
  m             map each permutation d to:
      cd2          split d into lists of length 2
    %M             apply modulo to each of this lists
   /     Z         count the zeros (=number of pairs with the first 
                   item divisible by the second)
 S              sort these values
e               and print the last one (=maximum)

Toán học, 95 93 87 83 79 60 58 byte

Max[Count[#~Partition~2,{a_,b_}/;a∣b]&/@Permutations@#]&

Mất vài giây cho các ví dụ lớn hơn.

Matlab (120 + 114 = 234)

  function w=t(y,z),w=0;for i=1:size(z,1),w=max(w,1+t([y,z(i,:)],feval(@(d)z(d(:,1)&d(:,2),:),~ismember(z,z(i,:)))));end

chủ yếu:

  a=input('');h=bsxfun(@mod,a,a');v=[];for i=1:size(h,1) b=find(~h(i,:));v=[v;[(2:nnz(b))*0+i;b(b~=i)]'];end;t([],v)

• chức năng topper được gọi bởi phần chính.

• đầu vào ở dạng [. . .]

Matlab (365)

  j=@(e,x)['b(:,' num2str(e(x)) ')'];r=@(e,y)arrayfun(@(t)['((mod(' j(e,1) ',' j(e,t) ')==0|mod(' j(e,t) ',' j(e,1) ')==0)&',(y<4)*49,[cell2mat(strcat(r(e(setdiff(2:y,t)),y-2),'|')) '0'],')'],2:y,'UniformOutput',0);a=input('');i=nnz(a);i=i-mod(i,2);q=0;while(~q)b=nchoosek(a,i);q=[cell2mat(strcat((r(1:i,i)),'|')) '0'];q=nnz(b(eval(q(q~=0)),:));i=i-2;end;fix((i+2)/2)

• Điều này rõ ràng là dài hơn, nhưng oneliner và điều hành, và tôi đã tìm cách thoát khỏi permschức năng bởi vì nó mất mãi mãi.

• Hàm này mất nhiều lần lặp lại để chạy yên tĩnh do các hàm ẩn danh, tôi đang mở để đề xuất ở đây :)