Dato un elenco di cerchi, genera l'area del rettangolo contenente più piccolo

28

Ti verrà dato un elenco di raggi, devi emettere l'area del rettangolo più piccolo in cui si adatteranno tutti.

Ad esempio, data la lista [5,3,1.5]che si produrrebbe 157.460.

Questa è l'immagine:

La larghezza è 15,7460 e l'altezza è 10, quindi l'area è 157,460

Regole:

  • Ottieni l'elenco tramite stdin o argomento della funzione, emetti la risposta tramite stdout o return della funzione.

  • I raggi avranno al massimo 2 decimali.

  • L'elenco avrà una lunghezza compresa tra 2 e 6.

  • L'output deve essere accurato con 3 decimali o più.

  • Se necessario, π = 3,1416.

Casi test:

  • [5,3,1.5] = 157.460

  • [9,4,8,2] = 733.431- lavora qui .

  • [18,3,1] = 1296.000

Vince il codice più breve in byte.

code-golf  math  optimization 
— Tim
fonte
— DJMcMayhem
1
non vedo un criterio vincente oggettivo
— Maltysen il
questa è una delle nostre regole più centrali
— Maltysen il
2
@Tim La maggior parte sono codici golf, con l'obiettivo di codificarli nel minor numero di byte. Penso che ciò costituirebbe una buona sfida per il golf in codice, in quanto ha una specifica esatta.
— xnor
Consiglio di sbarazzarsi della condizione "arrotondato non troncato" perché è periferico all'attività e alcune lingue possono semplicemente farlo mentre altre hanno bisogno di una codifica aggiuntiva per realizzarla. Non sono sicuro se intendi che sia OK generare più di 3 cifre decimali, ma suggerirei di consentire anche questo.
— xnor

Risposte:

16

Python 2 + PySCIPOpt , 267 byte

from pyscipopt import*
R=input()
m=Model()
V,C=m.addVar,m.addCons
a,b,c=V(),V(),V()
m.setObjective(c)
C(a*b<=c)
P=[]
for r in R:
 x,y=V(),V();C(r<=x);C(x<=a-r);C(r<=y);C(y<=b-r)
 for u,v,s in P:C((x-u)**2+(y-v)**2>=(r+s)**2)
 P+=(x,y,r),
m.optimize()
m.printBestSol()

Come funziona

Scriviamo il problema come segue: minimizza c sulle variabili a , b , c , x 1 , y 1 ,…, x n , y n , dove

  • ab ≤ c ;
  • r i ≤ x i ≤ a - r i e r i ≤ y i ≤ b - y i , per 1 ≤ i ≤ n ;
  • ( x i - x j ) 2 + ( y i - y j ) 2 ≥ ( r i + r j ) 2 , per 1 ≤ j < i ≤ n .

Ovviamente, stiamo usando una libreria di ottimizzazione esterna su questi vincoli, ma non puoi semplicemente dar loro da mangiare a qualsiasi vecchio ottimizzatore, anche quelli di Mathematica NMinimizerestano bloccati ai minimi locali per questi piccoli casi di test. Se osservi attentamente i vincoli, vedrai che costituiscono un programma quadratico a vincoli quadratici e trovare l'ottimale globale per un QCQP non convesso è NP-difficile. Quindi abbiamo bisogno di un po 'di magia incredibilmente potente. Ho scelto il solutore SCIP di livello industriale , che è l'unico risolutore di QCQP globale che ho potuto trovare con una licenza gratuita per uso accademico. Fortunatamente, ha alcuni collegamenti Python molto belli.

Ingresso e uscita

Passa l'elenco dei raggi su stdin, come [5,3,1.5]. L'output mostra objective value:un'area rettangolare, x1, x2dimensioni rettangolo, x3un'area rettangolare ancora x4, x5prime coordinate del centro del cerchio, x6, x7seconde coordinate del centro del cerchio, ecc

Casi test

[5,3,1.5] ↦ 157.459666673757

5,3,1.5

SCIP Status        : problem is solved [optimal solution found]
Solving Time (sec) : 0.04
Solving Nodes      : 187
Primal Bound       : +1.57459666673757e+02 (9 solutions)
Dual Bound         : +1.57459666673757e+02
Gap                : 0.00 %
objective value:                     157.459666673757
x1                                                 10   (obj:0)
x2                                   15.7459666673757   (obj:0)
x3                                   157.459666673757   (obj:1)
x4                                                  5   (obj:0)
x5                                                  5   (obj:0)
x6                                                  7   (obj:0)
x7                                   12.7459666673757   (obj:0)
x8                                                1.5   (obj:0)
x9                                   10.4972522849871   (obj:0)

[9,4,8,2] ↦ 709.061485909243

Questo è meglio della soluzione del PO. Le dimensioni esatte sono 18 per 29 + 6√3.

9,4,8,2

SCIP Status        : problem is solved [optimal solution found]
Solving Time (sec) : 1.07
Solving Nodes      : 4650
Primal Bound       : +7.09061485909243e+02 (6 solutions)
Dual Bound         : +7.09061485909243e+02
Gap                : 0.00 %
objective value:                     709.061485909243
x1                                                 18   (obj:0)
x2                                   39.3923047727357   (obj:0)
x3                                   709.061485909243   (obj:1)
x4                                                  9   (obj:0)
x5                                   30.3923047727357   (obj:0)
x6                                                 14   (obj:0)
x7                                   18.3923048064677   (obj:0)
x8                                                  8   (obj:0)
x9                                                  8   (obj:0)
x10                                                 2   (obj:0)
x11                                  19.6154311552252   (obj:0)

[18,3,1] ↦ 1295.999999999

18,3,1

SCIP Status        : problem is solved [optimal solution found]
Solving Time (sec) : 0.00
Solving Nodes      : 13
Primal Bound       : +1.29599999999900e+03 (4 solutions)
Dual Bound         : +1.29599999999900e+03
Gap                : 0.00 %
objective value:                       1295.999999999
x1                                   35.9999999999722   (obj:0)
x2                                                 36   (obj:0)
x3                                     1295.999999999   (obj:1)
x4                                   17.9999999999722   (obj:0)
x5                                                 18   (obj:0)
x6                                   32.8552571627738   (obj:0)
x7                                                  3   (obj:0)
x8                                                  1   (obj:0)
x9                                                  1   (obj:0)

Casi bonus

[1,2,3,4,5] ↦ 230.244214912998

1,2,3,4,5

SCIP Status        : problem is solved [optimal solution found]
Solving Time (sec) : 401.31
Solving Nodes      : 1400341
Primal Bound       : +2.30244214912998e+02 (16 solutions)
Dual Bound         : +2.30244214912998e+02
Gap                : 0.00 %
objective value:                     230.244214912998
x1                                   13.9282031800476   (obj:0)
x2                                    16.530790960676   (obj:0)
x3                                   230.244214912998   (obj:1)
x4                                                  1   (obj:0)
x5                                   9.60188492354373   (obj:0)
x6                                    11.757778088743   (obj:0)
x7                                   3.17450418828415   (obj:0)
x8                                                  3   (obj:0)
x9                                    13.530790960676   (obj:0)
x10                                  9.92820318004764   (obj:0)
x11                                   12.530790960676   (obj:0)
x12                                                 5   (obj:0)
x13                                                 5   (obj:0)

[3,4,5,6,7] ↦ 553.918025310597

3,4,5,6,7

SCIP Status        : problem is solved [optimal solution found]
Solving Time (sec) : 90.28
Solving Nodes      : 248281
Primal Bound       : +5.53918025310597e+02 (18 solutions)
Dual Bound         : +5.53918025310597e+02
Gap                : 0.00 %
objective value:                     553.918025310597
x1                                   21.9544511351279   (obj:0)
x2                                   25.2303290086403   (obj:0)
x3                                   553.918025310597   (obj:1)
x4                                                  3   (obj:0)
x5                                   14.4852813557912   (obj:0)
x6                                   4.87198593295855   (obj:0)
x7                                   21.2303290086403   (obj:0)
x8                                   16.9544511351279   (obj:0)
x9                                                  5   (obj:0)
x10                                                 6   (obj:0)
x11                                                 6   (obj:0)
x12                                  14.9544511351279   (obj:0)
x13                                  16.8321595389753   (obj:0)

[3,4,5,6,7,8] ↦ 777.87455544487

3,4,5,6,7,8

SCIP Status        : problem is solved [optimal solution found]
Solving Time (sec) : 218.29
Solving Nodes      : 551316
Primal Bound       : +7.77874555444870e+02 (29 solutions)
Dual Bound         : +7.77874555444870e+02
Gap                : 0.00 %
objective value:                      777.87455544487
x1                                   29.9626413867546   (obj:0)
x2                                   25.9614813640722   (obj:0)
x3                                    777.87455544487   (obj:1)
x4                                   13.7325948669477   (obj:0)
x5                                   15.3563780595534   (obj:0)
x6                                   16.0504838821134   (obj:0)
x7                                   21.9614813640722   (obj:0)
x8                                   24.9626413867546   (obj:0)
x9                                   20.7071098175984   (obj:0)
x10                                                 6   (obj:0)
x11                                  19.9614813640722   (obj:0)
x12                                                 7   (obj:0)
x13                                                 7   (obj:0)
x14                                  21.9626413867546   (obj:0)
x15                                  8.05799919177801   (obj:0)
— Anders Kaseorg
fonte
Peccato che l'ultimo dia un leggero errore di arrotondamento, ma bel lavoro!
— Tim
Mi sembra che [1,2,3,4,5] potrebbe essere migliorato facendo toccare anche il raggio 3 e il raggio 5 cerchi, quindi ruotando leggermente il raggio 4 / raggio 5 in diagonale in senso orario (il raggio raggio 1 dovrebbe essere spostato di mezzo ma c'è molto spazio morto per quello. Sia il mio istinto che i miei calcoli indicano che un rettangolo lungo e sottile può contenere il raggio 4 / raggio 5 cerchi in modo più efficiente di uno più quadrato
— Level River St
@LevelRiverSt Non sono d'accordo. Spostare 3 verso l'alto per toccare 5 spingerebbe 4 a destra (in senso antiorario da 5), ​​non lasciandolo spostare a sinistra (in senso orario da 5). La configurazione del mio programma è (7 + 4√3) × (9 + √ (29 + 16√3)) ≈ 13.9282 × 16.5308 ≈ 230.244, mentre la configurazione suggerita è (30 + 15√3) / 4 × (36 + 3 √5 + 6√15) / 4 ≈ 13.9952 × 16.4865 ≈ 230.732.
— Anders Kaseorg,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.