Retina , 530 220 210 202 201 193 191 187 185 (184) byte
Crediti a randomra per il salvataggio di 3 byte! (E spianando la strada per un altro paio.)
+`\.(\d)(.+)( .+)
$1.$2_$3_
\b
#
+`(\d*)#((((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|\w)
$1$1$1$1$1$1$1$1$1$1$3$4$5$6$7$8$9$10$11#
\d
11
(?=(1*)\1)[^.]
$1
^(1+)\.\1{90000}1+
Retina!
1.+
Trash!
Ai fini del conteggio dei byte, ogni riga va in un file separato, ma è possibile eseguire il codice sopra come da un singolo file invocando Retina con il -sflag.
Questo si aspetta prima la densità (che deve contenere un punto decimale, anche se finale), seguita da larghezza e altezza, cioè d w h.
Questo è un po ' lento. Non proverei la maggior parte dei casi di test indicati, perché funzionerà per anni. Tuttavia, è possibile verificare che funzioni correttamente con i casi di test
19. 4096 2160 -> Trash!
1. 180 240 -> Trash!
1. 181 240 -> Retina!
1. 180 241 -> Retina!
0.04 10 10 -> Retina!
Fondamentalmente, dopo aver moltiplicato tutti i numeri per rendere la densità un numero intero, non si desidera che la larghezza e l'altezza contengano più di 4 cifre.
Mentre questo è lento, è completamente esatto ... non ci sono problemi in virgola mobile o qualcosa del genere. Tutta l'aritmetica utilizza numeri interi (unari).
In linea di principio, potrei radere via un altro byte: ^può essere omesso, ma renderà Trash!i casi di test orribilmente lenti a causa di eccessive quantità di backtracking.
Spiegazione
Innanzitutto, riorganizziamo la disuguaglianza per evitare operazioni in virgola mobile:
√(w2 + h2) / d > 300
√(w2 + h2) > 300 d
w2 + h2 > 90000 d2
Possiamo anche notare che questo è invariante per moltiplicare w, he dper lo stesso numero x:
w2 + h2 > 90000 d2
(x w)2 + (x h)2 > 90000 (x d)2
x2 (w2 + h2) > 90000 x2 d2
w2 + h2 > 90000 d2
Esistono diversi modi per quadrare un numero unario, ma utilizzeremo l'identità
n2 = Σi=1..2n ⌊i/2⌋
Questo ci dà un modo per risolvere il problema usando solo l'aritmetica dei numeri interi (che rappresenta i numeri interi in unario).
Analizziamo il codice. Ogni coppia di righe è una sostituzione regex.
+`\.(\d)(.+)( .+)
$1.$2_$3_
Questo sposta ripetutamente il punto decimale nella densità verso destra moltiplicando larghezza e altezza per 10 (quanto xsopra). Questo per garantire che tutti i numeri siano numeri interi. Invece di aggiungere zero, sto aggiungendo _, che in seguito tratterò come zero. (Questo è un trucco da golf, perché altrimenti avrei bisogno di scrivere ...${3}0per evitare ambiguità con $30.) Il +davanti al regex dice a Retina di ripetere questa sostituzione fino a quando il risultato non smette di cambiare (che è il caso in cui il modello non corrisponde più) .
\b
#
Stiamo preparando i tre numeri per la conversione in unario ora. In linea di principio, abbiamo bisogno di un marcatore (il #) davanti a ciascun numero, ma è più breve aggiungerne uno alla fine di ogni numero, il che non influirà sul passaggio di conversione.
+`(\d*)#((((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|\w)
$1$1$1$1$1$1$1$1$1$1$3$4$5$6$7$8$9$10$11#
Questa è la conversione in unario, usando un trucco che è stato sviluppato da dan1111 . Fondamentalmente sto traducendo ogni cifra in una ripetizione di se stessa, mentre moltiplico le cifre esistenti per 10 (spostando l' #indicatore a destra nel processo). Questa rappresentazione binaria sarà un bel miscuglio di cifre diverse, ma il numero totale sarà uguale al valore dell'intero originale. Nota \walla fine - normalmente questo è giusto 0, ma vogliamo considerare _anche zero (che è considerato un carattere di parola in regex).
\d
11
Trasformiamo ogni cifra in due 1s, quindi a) assicurandoci che tutte le cifre siano uguali (che sarà necessario in seguito) eb) raddoppiando ciascuno dei numeri.
(?=(1*)\1)[^.]
$1
Questo fa due cose: piazza tutti i numeri (o piuttosto la metà di ogni numero, calcolando una somma 2n) e aggiunge i quadrati risultanti della larghezza e dell'altezza. Si noti che [^.]corrisponde a 1s, #marcatori e spazi. Se è uno #o uno spazio, il lookahead non catturerà nulla, il che significa che tutti questi vengono semplicemente rimossi, ovvero i risultati per la larghezza e l'altezza vengono concatenati / aggiunti. Il punto decimale .rimane per separare il risultato dda quelli. Se [^.]corrisponde 1invece a, allora il lookahead assicura che catturiamo metà delle 1s dopo di essa (arrotondate per difetto) in gruppo 1. Questo calcola la somma che ho menzionato sopra, che produrrà quindi il quadrato del numero originale.
^(1+)\.\1{90000}1+
Retina!
La stringa è ora (in unario), quindi , quindi (in unario). Vogliamo sapere se il primo numero unario è più breve del secondo. Possiamo facilmente fare questa moltiplicazione usando un gruppo di acquisizione e la sintassi della ripetizione. Usiamo (invece di ) in seguito per garantire che il secondo numero sia effettivamente maggiore di quello e non solo uguale. In tal caso, lo sostituiamo con .d2.w2 + h290000{n}1+1*Retina!
1.+
Trash!
Se il secondo numero non era abbastanza grande, il passaggio precedente non avrebbe cambiato nulla e la stringa inizierà comunque con a 1. In tal caso, sostituiamo semplicemente l'intera stringa con Trash!e abbiamo finito.
