Te dan un conjunto de enteros positivos. Debe organizarlos en pares de manera que:

• Cada par contiene 2 números, uno de los cuales es múltiplo de otro. Por ejemplo, 8 es múltiplo de 4 y 9 es múltiplo de 9.
• Si el mismo número aparece muchas veces en el conjunto inicial, se puede usar tantas veces en los pares; un número puede incluso emparejarse con otra ocurrencia del mismo número
• Se obtiene el número máximo posible de pares.

La salida debe ser el número de pares. El código más corto gana.

Data de muestra

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 bytes

Gracias a nimi por guardar 33 bytes y enseñarme algo más de Haskell. :)
Gracias a xnor por guardar otros 6 bytes.

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

Sí, mi primer campo de golf de Haskell. Funciona igual que todas las respuestas hasta ahora (bueno, no del todo: solo cuenta la longitud del prefijo más largo de pares válidos en cada permutación, pero eso es equivalente y en realidad es lo que hizo mi código CJam original).

Para una mayor golfitud también es extra ineficiente al generar recursivamente todas las permutaciones del sufijo cada vez que los dos primeros elementos de una permutación son un par válido.

CJam, 22 18 bytes

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

Pruébalo en línea.

Espera entrada en forma de una lista de estilo CJam.

Esto es un poco ineficiente para listas más grandes (y Java probablemente se quedará sin memoria a menos que le des más).

Explicación

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.

Pyth, 13 bytes

eSm/%Mcd2Z.pQ

El tiempo y la complejidad del almacenamiento es realmente terrible. Lo primero que hago es crear una lista con todas las permutaciones de la lista original. Esto requiere n*n!almacenamiento. Las listas de entrada con longitud 9 ya toman bastante tiempo.

Pruébelo en línea: demostración o conjunto de pruebas

Explicación:

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)

Mathematica, 95 93 87 83 79 60 58 bytes

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

Toma unos segundos para los ejemplos más grandes.

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

principal:

  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)

• la función principal se llama por la parte principal.

• la entrada está en la forma [. . .]

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)

• Esto aparentemente es más largo, pero en línea y ejecutivo, y logré escapar de la permsfunción porque lleva una eternidad.

• Esta función requiere muchas repeticiones para funcionar bien en silencio debido a las funciones anónimas, estoy abierto a sugerencias aquí :)