introduzione

La distanza di Hausdorff misura la differenza tra due sottoinsiemi di uno spazio metrico. Intuitivamente, uno spazio metrico è solo un set con una funzione di distanza integrata; in questa sfida, useremo i numeri naturali con la distanza ordinaria d(a, b) := abs(a - b). La distanza di Hausdorff tra due insiemi finiti non vuoti Aed Bè data da

max(max(min(d(a, b) for b in B) for a in A),
    max(min(d(a, b) for a in A) for b in B))

in notazione simile a Python. La distanza di Hausdorff può essere calcolata trovando l'elemento Aper cui la distanza dall'elemento più vicino Bè massima, e l'elemento Bper cui la distanza dall'elemento più vicino Aè massima, e quindi prendendo il massimo di queste distanze. In altre parole, se la distanza di Hausdorff è d, allora ogni elemento di Aè a distanza ddi qualche elemento di Be viceversa.

Ingresso

Il tuo input è un unico elenco di numeri interi. Contiene solo gli elementi 0,1,2,3, che indicano se il dato indice dell'elenco è un elemento di né Ané B, solo A, solo Bo entrambi Ae B. Ad esempio, l'input [0,1,1,0,2,3]significa che A = {1,2,5}e B = {4,5}, se utilizziamo l'indicizzazione basata su 0 (il che non fa alcuna differenza, poiché le nostre metriche sono invarianti per la traduzione).

Produzione

Il risultato è la distanza di Hausdorff tra Ae B; nell'esempio sopra, lo è 3. Se uno dei set è vuoto, la distanza non è definita e si dovrà tornare -1.

Regole

È possibile scrivere un programma completo o una funzione. Vince il conteggio di byte più basso e non sono consentite scappatoie standard.

Casi test

[] -> -1
[0] -> -1
[0,1,0] -> -1
[2,0,0,2] -> -1
[0,1,2,3] -> 1
[0,3,3,0,0,0,0,3] -> 0
[1,0,0,1,0,0,1,3,1] -> 7
[1,0,0,0,0,3,0,0,0,0,2] -> 5
[0,1,1,3,1,3,2,1,1,3,0,3] -> 2
[2,2,2,1,2,0,3,1,3,1,0,3] -> 3
[1,3,0,2,0,2,2,1,0,3,2,1,1,2,2] -> 2
[1,0,1,1,2,0,1,2,3,1,0,0,0,1,2,0] -> 4

CJam, 53 52 46 38 37 byte

3,q~f{f&:L,{L=},}$~ff{-z}_z+::e<W+:e>

Accetta input su STDIN come array in stile CJam:

[0 1 2 3]

Ecco un cablaggio di test che converte tutti i casi di test in questo formato ed esegue il codice su di essi. Sebbene i risultati si trovino nel campo di input, non vengono utilizzati dal codice (rimuovili se non ti fidi di me :)).

Spiegazione

Innanzitutto, analizziamo l'input per ottenere i due set A e B:

3,q~f{f&:L,{L=},}$~
3,                  "Push [0 1 2]. 1 is for A, 2 is for B, and 0 we can luckily ignore
                     as we'll see later.";
  q~                "Read and evaluate the input.";
    f{          }   "Map this block onto the [0 1 2] array, copying in the input for
                     each iteration.";
      f&:L          "Take the bitwise AND with each element of the input and store the
                     result in L.";
          ,{  },    "Get the length N, and filter the range [0 .. N-1] by evaluating
                     the block for each element.";
            L=      "Check if the bitwise AND at that index yielded something non-zero.
                     This gives an empty array for 0, A for 1 and B for 2.";
                 $  "Sort the three arrays. This has two important effects: a) it moves
                     the empty array resulting from 0 to the front, and b) if only one
                     of A and B is empty, it moves the non-empty one to the end.";
                  ~ "Unwrap the array, dumping all three sets on the stack.";

E ora troviamo le differenze assolute e selezioniamo il massimo dei minuti:

ff{-z}_z+::e<W+:e>
ff{-z}             "Turn A and B into a matrix of absolute differences.";
      _z           "Duplicate and transpose.";
        +          "Add the two together, so I've got one row of distances for
                    each element in either A or B.";
         ::e<      "Find the minimum of each row.";
             W+    "Add a -1 in case one set was empty.";
               :e> "Get the overall maximum.";

Si noti che abbiamo sempre mantenuto l'array vuoto risultante dall'iniziale 0in fondo allo stack, ma gli array vuoti non contribuiscono all'output.

CJam, 57 56 52 byte

Penso che questo possa essere giocato un po 'a golf, ma ecco qui:

q~ee_{W=2%},\{W=1>},]0ff=_W%]{~ff-{:z$1<~}%W+$W=}/e>

L'input entra come in un elenco in stile CJam, ad es.

[1 0 0 0 0 3 0 0 0 0 2]

5

Come funziona :

Il codice è diviso in due parti:

Analizzare l'input negli elenchi Ae B:

q~ee_{W=2%},\{W=1>},]0ff=_W%]
q~                               "Eval the input array";
  ee                             "Enumerate and prepend index with each element. For ex:
                                  [5 3 6]ee gives [[0 5] [1 3] [2 6]]";
    _{W=2%},                     "Make a copy and filter out elements with value 1 or 3";
            \{W=1>},             "On the original, filter elements with value 2 or 3";
                    ]            "Wrap stack in an array. Stack right now contains
                                  enumerated A and B in an array";
                     0ff=        "Get the index of the enumerated arrays. Stack is [A B]";
                         _W%     "Make a copy and swap order. Stack is now [A B] [B A]";
                            ]    "Wrap this in an array";

Esecuzione delle azioni richieste sulle due coppie di Ae B:

{~ff-{:z$1<~}%W+$W=}/e>
{                  }/            "Run this loop for both the pairs, [A B] and [B A]"
 ~ff-                            "Unwrap [A B] and take difference of every pair";
     {      }%                   "For each row in the matrix difference";
      :z$                        "abs each term and then sort";
         1<~                     "Take only the first element of the array";
              W+                 "Add -1 to compensate for an empty array";
                $W=              "Take max";
                     e>          "Take max of the two maximums";

Provalo online qui

Lua, 235 byte

Sicuramente non un vincitore, ma almeno una sfida divertente.

A={}B={}c={}d={}m=math p=m.min q=m.max u=unpack for k=1,#arg do for h=0,1 do if
arg[k]/2^h%2>=1 then A[#A+1]=k for i=1,#B do l=m.abs(B[i]-k)d[i]=p(d[i]or
l,l)c[#A]=p(c[#A]or l,l)end end A,B=B,A c,d=d,c end end
print(q(q(-1,u(c)),u(d)))

L'input funziona in questo modo:

lua hausdorff.lua <space-separated-sequence>

... ed ecco uno script di prova:

local testcase = arg[1] or 'hausdorff.lua'
print('testing '..testcase)
local function run(args) 
    return function(expected)
        local result = tonumber(
            io.popen('lua.exe '..testcase..' '..args):read'*a':match'%S+')
        print(args..' -> '..expected..' :: '..result)
        assert(result == expected,
            ("for input %q expected %s but got %s"):format(
                args, expected, result))
    end
end
run''(-1)
run'0'(-1)
run'0 1 0'(-1)
run'2 0 0 2'(-1)
run'0 1 2 3'(1)
run'0 3 3 0 0 0 0 3'(0)
run'1 0 0 1 0 0 1 3 1'(7)
run'1 0 0 0 0 3 0 0 0 0 2'(5)
run'0 1 1 3 1 3 2 1 1 3 0 3'(2)
run'2 2 2 1 2 0 3 1 3 1 0 3'(3)
run'1 3 0 2 0 2 2 1 0 3 2 1 1 2 2'(2)
run'1 0 1 1 2 0 1 2 3 1 0 0 0 1 2 0'(4)

... produce ...

testing hausdorff.lua
 -> -1 :: -1
0 -> -1 :: -1
0 1 0 -> -1 :: -1
2 0 0 2 -> -1 :: -1
0 1 2 3 -> 1 :: 1
0 3 3 0 0 0 0 3 -> 0 :: 0
1 0 0 1 0 0 1 3 1 -> 7 :: 7
1 0 0 0 0 3 0 0 0 0 2 -> 5 :: 5
0 1 1 3 1 3 2 1 1 3 0 3 -> 2 :: 2
2 2 2 1 2 0 3 1 3 1 0 3 -> 3 :: 3
1 3 0 2 0 2 2 1 0 3 2 1 1 2 2 -> 2 :: 2
1 0 1 1 2 0 1 2 3 1 0 0 0 1 2 0 -> 4 :: 4

Pyth, 43 40 39 38 byte

J+m0yQQLq3.|Fb?eS.e&Yfy:J-kT+hkT0JyJ_1

Il mio algoritmo opera direttamente sulla stringa di input e non converte mai questo numero. Calcola solo una volta al massimo e mai un minimo.

Grazie a @isaacg per aver salvato un byte.

Provalo online: Pyth Compiler / Executor

spiegazioni:

Innanzitutto inserirò molti zeri davanti all'ingresso.

          implicit: Q = input()
    yQ    powerset(Q)
  m0yQ    map each element of the powerset to 0 (creates 2^Q zeros, I said lots)
 +    Q   zeros + Q
J         assign to J

Quindi definisco una funzione di supporto y, che dice se gli indici di un elenco (come quello di input) compaiono in entrambi i set A e BEg y([0, 1, 0, 0, 1, 1]) = False, ma y([0, 1, 0, 2]) = y([3]) = True.

Lq3.|Fb
L          define a function y(b), which returns _
   .|Fb       fold b by bitwise or
 q3            == 3

Successivamente controllo prima se il risultato è -1.

?...yJ_1   print ... if numbers appear in both sets (`yJ`) else -1   

Ora per le cose interessanti:

  .e              J    map each pair k,Y in enumerate(J) to:
    &Y                   Y and ... (acts as 0 if Y == 0 else ...)
      f          0       find the first number T >= 0, where:
       y                    indices appear in both sets in the substring
        :J-kT+hkT           J[k-T:k+T+1]
eS                     sort and take last element (maximum)

Si noti che troverò sempre un numero T, poiché so già che gli indici compaiono in entrambi i set nell'elenco J. Il numero è massimo length(Q). Questo è anche il motivo dell'inserimento degli zeri. Se sono stati length(Q)inseriti almeno zeri, k-Tè sempre >= 0necessario per la suddivisione dell'elenco. Quindi perché inserisco 2^length(Q)zero anziché length(Q)zero? Nel caso di test []ho bisogno di almeno 1 zero, altrimenti yJrestituirà un errore.

Mathematica, 88 byte

Max[Min/@#,Min/@Thread@#,-1]/.∞->-1&@Outer[Abs[#-#2]&,p=Position;p[#,1|3],p[#,2|3],1]&

Haskell, 145 126 124 byte

s t x=[e|(e,i)<-zip[0..]x,t i]
d#e=maximum[minimum[abs$i-j|j<-e]|i<-d]
[]%_= -1
_%[]= -1
d%e=max(d#e)$e#d
f x=s(>1)x%s odd x

Prova:

*Main> map f [[], [0], [0,1,0], [2,0,0,2], [0,1,2,3],
              [0,3,3,0,0,0,0,3], [1,0,0,1,0,0,1,3,1],
              [1,0,0,0,0,3,0,0,0,0,2], [0,1,1,3,1,3,2,1,1,3,0,3],
              [2,2,2,1,2,0,3,1,3,1,0,3],
              [1,3,0,2,0,2,2,1,0,3,2,1,1,2,2],
              [1,0,1,1,2,0,1,2,3,1,0,0,0,1,2,0]]

[-1,-1,-1,-1,1,0,7,5,2,3,2,4]

sfiltra i numeri naturali in base a un predicato te all'elenco di input x. #calcola la massima distanza dei suoi parametri de e. %prende insiemi vuoti A o B o prende il massimo finale di d#ee e#d. fè la funzione principale che chiama %con i set A e B.

Modifica: @Zgarb ha trovato molti byte da salvare; @ ali0sha altro 2. Grazie!

Perl, 56 55

Aggiunto +2 per -lp.

L'elenco di input deve essere fornito su stdin senza spazi, ad esempio:

echo 1011201231000120 | perl -lp hausdorf.pl

hausdorf.pl:

s%%$z=$_&=$p|=$'|P.$p;$q+=!!y/12/3/%eg;$_=$z=~3?$q:-1

Per supportare gli spazi tra gli elementi dell'elenco di input basta dividere la finale $qper 2 per un costo di 2 colpi

Python 2, 124

Questo sembra decisamente non ottimale. Oh bene.

lambda a,E=enumerate:-min([1]+[~l*(n<3)for i,n in E(a)for l,_ in E(a)if{0}|set(n*a+n/3*[5])>{0,n}>=set(a[max(i-l,0):i-~l])])

APL (49)

{(⊂⍬)∊∆←(↓2 2⊤⍵)/¨⊂⍳⍴⍵:¯1⋄⌈/{⌈/⌊/⍵}¨(+,⍉¨)|∘.-/∆}

Casi test:

      ({(⊂⍬)∊∆←(↓2 2⊤⍵)/¨⊂⍳⍴⍵:¯1⋄⌈/{⌈/⌊/⍵}¨(+,⍉¨)|∘.-/∆} ¨ testcases) ,⍨ '→',⍨ ↑ ⍕¨testcases
                               → ¯1
0                              → ¯1
0 1 0                          → ¯1
2 0 0 2                        → ¯1
0 1 2 3                        →  1
0 3 3 0 0 0 0 3                →  0
1 0 0 1 0 0 1 3 1              →  7
1 0 0 0 0 3 0 0 0 0 2          →  5
0 1 1 3 1 3 2 1 1 3 0 3        →  2
2 2 2 1 2 0 3 1 3 1 0 3        →  3
1 3 0 2 0 2 2 1 0 3 2 1 1 2 2  →  2
1 0 1 1 2 0 1 2 3 1 0 0 0 1 2 0→  4

Spiegazione:

• ⍳⍴⍵: ottiene un elenco di numeri da 1 alla lunghezza dell'elenco di input
• ↓2 2⊤⍵: per ciascun valore nell'elenco di input, ottenere il primo byte e il secondo byte
• ∆←(... )/⊂⍳⍴⍵: per entrambi gli elenchi di byte, selezionare i valori corrispondenti da ⍳⍴⍵. Conservali in ∆.

• (⊂⍬)∊∆... :¯1: se questo elenco contiene un elenco vuoto, ritorna -1. Altrimenti:

• |∘.-/∆: ottieni la differenza assoluta tra ogni coppia di valori, dando una matrice

• (+,⍉¨): ottiene una copia ruotata e non ruotata di quella matrice
• {⌈/⌊/⍵}: per entrambe le matrici, ottenere il massimo dei minimi delle righe
• ⌈/: quindi ottieni il massimo

Perl, 189 176 157B

Ora con il 500% in più di stato.

use List::Util qw'max min';@I=<>;sub f{$n=($n%2)+1;map{$I[$_]&$n?$_:()}0..$#I}sub i{@t=f;max map{$b=$_;min map{abs$_-$b}@t}f}$r=max i,i;print defined$r?$r:-1

Leggibile:

use List::Util qw'max min';
@I=<>;
sub f {
    $n = ($n%2) + 1;
    map { $I[$_] & $n ? $_ : () } 0..$#I
}
sub i {
    @t = f;
    max map {
        $b = $_;
        min map { abs $_ - $b } @t
    } f
}
$r = max i,i;
print defined $r ? $r : -1

Esempio di utilizzo:

ingresso

0
1
2
3

perl golf.pl < input

Clojure, 167 byte

#(let[P apply F(fn[I](filter(fn[i](I(% i)))(range(count %))))A(F #{1 3})B(F #{2 3})d(fn[X Y](P min(for[x X](P max(for[y Y](P -(sort[x y])))))))](-(min(d A B)(d B A))))

Dovrebbe esserci un modo più breve ... Esiste?