Ti viene dato un set di numeri interi positivi. È necessario disporli in coppie in modo tale che:

• Ogni coppia contiene 2 numeri, uno dei quali è un multiplo dell'altro. Ad esempio, 8 è un multiplo di 4 e 9 è un multiplo di 9.
• Se lo stesso numero si presenta più volte nel set iniziale, può essere usato più volte nelle coppie; un numero può anche essere associato a un'altra ricorrenza dello stesso numero
• Si ottiene il numero massimo possibile di coppie.

L'output deve essere il numero di coppie. Il codice più corto vince.

Dati di esempio

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

Grazie a nimi per aver salvato 33 byte e avermi insegnato un po 'di più Haskell. :)
Grazie a xnor per aver salvato altri 6 byte.

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

Sì, il mio primo golf Haskell. Funziona allo stesso modo di tutte le risposte finora (beh, non del tutto: conta solo la lunghezza del prefisso più lungo delle coppie valide in ogni permutazione, ma è equivalente ed è effettivamente quello che ha fatto il mio codice CJam originale).

Per maggiore golfitude è anche inefficace in quanto genera ricorsivamente tutte le permutazioni del suffisso ogni volta che i primi due elementi di una permutazione sono una coppia valida.

CJam, 22 18 byte

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

Provalo online.

Prevede input sotto forma di un elenco in stile CJam.

Questo è un po ' inefficiente per elenchi più grandi (e Java probabilmente esaurirà la memoria a meno che tu non lo dia di più).

Spiegazione

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 byte

eSm/%Mcd2Z.pQ

Il tempo e la complessità di archiviazione sono davvero terribili. La prima cosa che faccio è creare un elenco con tutte le permutazioni dell'elenco originale. Questo richiede n*n!archiviazione. Gli elenchi di input con lunghezza 9 richiedono già molto tempo.

Provalo online: dimostrazione o suite di test

Spiegazione:

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 byte

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

Richiede alcuni secondi per gli esempi più grandi.

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

principale:

  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 funzione topper è chiamata dalla parte principale.

• l'input è nella 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)

• Apparentemente è più lungo, ma diretto ed esecutivo, e sono riuscito a sfuggire alla permsfunzione perché ci vuole sempre.

• Questa funzione richiede molte riprese per funzionare in modo silenzioso a causa di funzioni anonime, sono aperto ai suggerimenti qui :)