Nous vivons à une époque technologique merveilleuse où nous pouvons avoir des écrans 8K joliment détaillés sur nos téléviseurs, et même des écrans 2K sur nos téléphones pour notre plus grand plaisir de navigation. Nous avons parcouru un long chemin au cours des dernières années en termes de technologie d'écran.

Un des produits de cette technologie est un terme qui a été rendu populaire par Apple, Retina . Cela fait référence à la densité de pixels de l’affichage en question étant si élevée qu’à une distance de visualisation de 10-12 pouces, les pixels individuels ne peuvent pas être facilement sélectionnés.

Steve Jobs a déclaré que la densité de pixels dans laquelle cela se produit avoisine les 300 pixels par pouce . Ils ont commencé à utiliser des densités de pixels dans cette plage sur leurs appareils avec le mot à la mode Retina utilisé pour la publicité.

La densité de pixels peut être calculée à l'aide de la formule suivante:

Où dest la diagonale de l'écran en pouces, wle nombre de pixels sur l'axe horizontal et hle nombre de pixels sur l'axe vertical.

Ta tâche

Pour cette tâche, vous utiliserez le standard Retina pour décider quels produits valent la peine d'être achetés. En tant que consommateur moderne que vous êtes, lorsque vous achetez des appareils, vous voulez vous assurer d'obtenir un bon produit, pas un appareil des années 90! En tant que tel, vous souhaitez créer un programme ou une fonction prenant la largeur, la hauteur et la diagonale de l'écran en tant que paramètres d'entrée ou fonctions , et vous indiquant si cet écran peut être qualifié de rétine ( D > 300) en le visualisant ou en le retournant .

En raison de votre mépris pour les périphériques non-Retina, votre programme ou votre fonction apparaîtra Retina!lorsque le périphérique est qualifié et Trash!quand il ne l'est pas.

Vous pouvez supposer que tous les nombres seront supérieurs à 0. Les valeurs de pixels pour la largeur et la hauteur seront toujours des nombres entiers. La taille de l'écran peut être interprétée de n'importe quelle manière, à condition qu'elle prenne en charge les nombres décimaux. La saisie peut se dérouler dans l’ordre que vous choisissez et sur 3 lignes distinctes au maximum.

Exemple I / O

1920 1080 4.95   -> Retina!
2560 1440 5.96   -> Retina!
1920 1080 10.5   -> Trash!
10 10 0.04       -> Retina!
4096 2160 19(.0) -> Trash!
8192 4320 100.00 -> Trash!
3000 1500 11.18  -> Retina!
180 240 1(.0)    -> Trash!

C'est du code-golf , donc le plus petit nombre d'octets gagne.

^{Voici une solution Stuck, un langage de programmation basé sur une pile que je crée:}

r;`;/300>"Retina!""Trash!"?

Pyth - 27 octets

Utilise l'opérateur ternaire et abspour calculer pythagore.

?>c.avzQ300"Retina!""Trash!

Prend une entrée sur deux lignes, première ligne width, height, seconde ligne diag.

Les règles ont été assouplies, donc reculons.

Essayez-le en ligne ici .

Retina , 530 220 210 202 201 201 193 191 187 185 (184) octets

Crédits à randomra pour la sauvegarde de 3 octets! (Et ouvrant la voie pour un couple de plus.)

+`\.(\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!

Pour le comptage d'octets, chaque ligne est placée dans un fichier séparé, mais vous pouvez exécuter le code ci-dessus tel quel à partir d'un seul fichier en appelant Retina avec l' -sindicateur.

Cela attend d'abord la densité (qui doit contenir un point décimal, même s'il s'agit d'un point final), suivie de la largeur et de la hauteur, c'est-à-dire d w h.

C'est un peu lent. Je ne voudrais pas essayer la plupart des cas de test donnés, car il durera des siècles. Cependant, vous pouvez vérifier qu'il fonctionne correctement avec les cas de test

19. 4096 2160     -> Trash!
1. 180 240        -> Trash!
1. 181 240        -> Retina!
1. 180 241        -> Retina!
0.04 10 10        -> Retina!

En gros, après avoir multiplié tous les nombres pour que la densité soit un entier, vous ne voulez pas que la largeur et la hauteur aient plus de 4 chiffres.

Bien que ce soit lent, il est tout à fait exact ... il n'y a pas de problèmes de virgule flottante ou quelque chose comme ça. Toute l'arithmétique utilise des entiers (unaires).

En principe, je pourrais supprimer un octet de plus: ^on peut l'omettre, mais cela Trash!ralentira horriblement les tests en raison du nombre excessif de retours en arrière.

Explication

Tout d'abord, réorganisons l'inégalité pour éviter les opérations en virgule flottante:

√(w2 + h2) / d > 300
√(w2 + h2) > 300 d
w2 + h2 > 90000 d2

On peut aussi remarquer que ceci est invariant en multipliant w, het dpar le même nombre 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

Il y a plusieurs façons de mettre en correspondance un nombre unaire, mais nous allons utiliser l'identité

n2 = Σi=1..2n ⌊i/2⌋

Cela nous donne un moyen de résoudre le problème en utilisant uniquement l'arithmétique entière (représentant des entiers dans unaire).

Passons en revue le code. Chaque paire de lignes est une substitution de regex.

+`\.(\d)(.+)( .+)
$1.$2_$3_

Cela déplace à plusieurs reprises le point décimal de la densité vers la droite tout en multipliant la largeur et la hauteur par 10 (valeur xci - dessus). Cela permet de s'assurer que tous les nombres sont des entiers. Au lieu d’ajouter des zéros, je l’ajoute _, ce que je considérerai comme zéro plus tard. (Ceci est une astuce de golf, car sinon, je devrais écrire ...${3}0pour éviter toute ambiguïté $30.) Le +texte placé devant la regex indique à Retina de répéter cette substitution jusqu'à ce que le résultat cesse de changer (ce qui est le cas lorsque le motif ne correspond plus). .

\b
#

Nous préparons les trois chiffres pour la conversion en unaire maintenant. En principe, nous avons besoin d’un marqueur (le #) devant chaque numéro, mais il est plus court d’ajouter un à la fin de chaque numéro, ce qui n’affectera pas l’étape de conversion.

+`(\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#

C'est la conversion au unaire, utilisant une astuce développée par dan1111 . Essentiellement, je traduis chaque chiffre en un chiffre de rep, tout en multipliant les chiffres existants par 10 (en déplaçant le #marqueur à droite dans le processus). Cette représentation binaire sera un mélange de chiffres différents, mais le nombre total sera égal à la valeur de l'entier original. Notez le \wà la fin - normalement c'est juste 0, mais nous voulons _aussi traiter comme zéro (ce qui est considéré comme un caractère de mot dans une regex).

\d
11

Nous transformons chaque chiffre en deux 1, ce qui permet a) de nous assurer que tous les chiffres sont identiques (ce qui sera nécessaire ultérieurement) et b) de doubler chacun des nombres.

(?=(1*)\1)[^.]
$1

Cela fait deux choses: il met tous les nombres au carré (ou plutôt la moitié de chaque nombre, en calculant une somme 2n), et ajoute les carrés résultants de la largeur et de la hauteur. Notez que [^.]correspond à 1s, aux #marqueurs et aux espaces. Si c'est un #ou un espace, le lookahead ne capturera rien, ce qui signifie que tous ceux-ci sont simplement supprimés, c'est-à-dire que les résultats pour la largeur et la hauteur sont concaténés / ajoutés. Le point décimal .reste à séparer le résultat dde ceux-ci. Si [^.]correspond à un à la 1place, le lookahead garantit que nous capturons la moitié du 1s après celui-ci (arrondi au bas) dans le groupe 1. Ceci calcule la somme que j'ai mentionnée ci-dessus, qui donnera alors le carré du nombre original.

^(1+)\.\1{90000}1+
Retina!

La chaîne est maintenant (en unaire), alors , ensuite (en unaire). Nous voulons savoir si le premier nombre unaire est plus court que le second. Nous pouvons facilement faire cette multiplication en utilisant une syntaxe de groupe de capture et de répétition. Nous utilisons (au lieu de ) par la suite pour nous assurer que le deuxième nombre est réellement supérieur à celui-ci et pas simplement égal. Si c'est le cas, nous remplaçons tout cela par .d2.w2 + h290000{n}1+1*Retina!

1.+
Trash!

Si le second nombre n'était pas assez grand, alors l'étape précédente n'aura rien changé et la chaîne commencera toujours par un 1. Si c'est le cas, nous remplaçons simplement la chaîne entière par Trash!et nous avons terminé.

Python, 49

lambda w,h,d:"RTertaisnha!!"[w*w+h*h<=9e4*d*d::2]

Utilise l'entrelacement de chaînes.

Il s'est avéré plus court pour concilier les deux côtés que pour utiliser la norme complexe.

w*w+h*h<=9e4*d*d
abs(w+1j*h)<=300*d

Rétine , 312 octets

(\d+) (\d+) (\d+)(?:\.(\d+))?
a$1bc$2dj300ke$3fg$4h9iiiiiiiii8iiiiiiii7iiiiiii6iiiiii5iiiii4iiii3iii2ii1i0
+`(b.*)(d.*)fg(\d)
0$10$2$4fg
+`(a|c|e|j)(\d)(\d*)(i*)((?:b|d|f|k).*h.*\2(i*))
$1$3$4$4$4$4$4$4$4$4$4$4$6$5
g`(i+)
Q$1R$1
+`Q(i+)Ri
$1Q$1R
+`(j(i*).*e)i(.*f)
$1$3$2
a(i*).*c(i*).*f\1\2.*
Trash!
.*0
Retina!

Cela prend un certain temps à courir, mais cela semble fonctionner.

Peut-être pourrait-on jouer au golf beaucoup plus ...

Explication:

(\d+) (\d+) (\d+)(?:\.(\d+))?
a$1bc$2dj300ke$3fg$4h9iiiiiiiii8iiiiiiii7iiiiiii6iiiiii5iiiii4iiii3iii2ii1i0

Ajoutez des balises pour rendre la chaîne plus facile à analyser, et ajoutez des éléments indésirables pour faciliter la conversion en base 1, et ajoutez un 300 pour la multiplier ultérieurement.

+`(b.*)(d.*)fg(\d)
0$10$2$4fg

Ajoute 0s à la largeur et à la hauteur, tout en ajoutant la partie décimale de la diagonale à la partie entière. Lorsque cela sera fait, la diagonale sera un entier et la largeur et la hauteur seront multipliées par le nombre de 10s nécessaires.

+`(a|c|e|j)(\d)(\d*)(i*)((?:b|d|f|k).*h.*\2(i*))
$1$3$4$4$4$4$4$4$4$4$4$4$6$5

Convertir tous les nombres en base 1, en utilisant la table de correspondance que j'ai ajoutée à la première étape

g`(i+)
Q$1R$1

Préparez-vous à concilier tous les chiffres

+`Q(i+)Ri
$1Q$1R

Place chaque numéro

+`(j(i*).*e)i(.*f)
$1$3$2

Multipliez le carré de la diagonale par le carré des 300 insérés dans la première étape

a(i*).*c(i*).*f\1\2.*
Trash!

Si la largeur ajoutée à la hauteur correspond au produit que nous venons de calculer, la densité de pixels est trop faible, et c'est la corbeille!

.*0
Retina!

Sinon, c'est la rétine!

CJam, 30 29 27 octets

q~mh300/<"Retina""Trash"?'!

Nécessite une entrée sous forme de diagonal width height

UPDATE: 1 octet enregistré grâce à Dennis!

Essayez-le en ligne ici

APL, 40 36 octets

Sauvegardé 4 octets grâce à Dennis!

{(9E4×⍵*2)<+/⍺*2:'Retina!'⋄'Trash!'}

Cela crée une fonction dyadique non nommée qui prend les deux premiers arguments à gauche et le troisième à droite. Il vérifie si la somme des carrés des valeurs de gauche est supérieure à 300 ^ 2 fois le carré de la droite. La sortie est imprimée en conséquence.

Vous pouvez l' essayer en ligne !

TI-BASIC, 43

Prend la largeur et la hauteur à travers l’écran d’accueil en tant que liste à deux éléments et en diagonale à l’entrée

Input D
If 300D>√(sum(Ans²
Then
Disp "Retina!
Else
"Trash!

Les lettres minuscules à deux octets de TI-BASIC ajoutent 7 octets ( il'unité imaginaire étant un octet), ce qui le rend très peu compétitif. Heureusement, !est également un octet, car il représente la fonction factorielle.

JavaScript ES6, 49 octets

(w,h,d)=>Math.hypot(w,h)/d>300?'Retina!':'Trash!'

Je déteste le fait que JavaScript ait de tels opérateurs de calcul longs. Mais même s'il y en avait un, Math.pythagoreance serait plus court.

Excel, 44 octets

Tapez vos entrées dans ces cellules.

• A1 = largeur en pixels
• B1 = Hauteur en pixels
• C1 = diagonale en pouces

Et cette formule donne votre résultat:

=IF((300*C1)^2<A1^2+B1^2,"Retina!","Trash!")

Prolog, 51 octets

a(W,H,D,R):-9e4*D*D<W*W+H*H,R="Retina!";R="Trash!".

a(8192,4320,100.0,R).Sorties en cours d'exécution :R = "Trash!" .

Edit: Merci à @PaulButcher pour avoir corrigé un cas de bord et joué un octet au golf.

JavaScript (ES6), 45 octets

f=(w,h,d)=>w*w+h*h>d*d*9e4?'Retina!':'Trash!'

CoffeeScript, 47 octets

Pas d'opérateur ternaire, mais il y a une exponentiation (ce qui n'aide pas dans la dernière tentative).

f=(w,h,d)->w*w+h*h>d*d*9e4&&'Retina!'||'Trash!'

# Previous attempt
f=(w,h,d)->(w*w+h*h)**.5/d>300&&'Retina!'||'Trash!'

O , 40 37 octets

jjjrmd \ / 'īu> {"Retina!" p} {"Corbeille!" p}?

Beaucoup d'octets pour le formatage d'entrée: \

Essayez-le en ligne

Pure Bash (pas de commande bc / autre commande externe), 138 136 135 82 83 octets

a=${3#*.}
d=${a//?/0}
r=(Trash Retina)
echo ${r[$1$d**2+$2$d**2>90000*${3/./}**2]}!

J'ai décidé d'essayer de le faire en pure bash. J'ai probablement fait quelques inefficacités évidentes car il s'agit de ma première participation au golf, mais je connais TRÈS bien bash et je me suis amusé par le passé à essayer d'écrire des choses qui n'utilisent aucune commande externe (c'est-à-dire un pur bash).

La déclaration printf est la plus agaçante. Quelqu'un a-t-il de meilleures idées pour remplir les chiffres avec des zéros?

EDIT: sauvegardé deux octets, printf prendra un argument vide pour zéro. Un autre octet enregistré, s’avère que j’avais précédemment mal compté et que l’attribution de la sortie de printf à une variable est plus petite que l’utilisation de -v.

EDIT2: Grâce à Digital Trauma dans les commentaires, cette baisse est maintenant beaucoup plus importante. Astuces: utiliser le support regex de bash pour remplacer la chaîne de chiffres par des zéros au lieu de le compter, puis d'afficher ce nombre de zéros (cela semble évident quand je le mets comme ça ...), en stockant les chaînes dans un tableau bash pour enregistrer un écho, et en tenant compte d'un léger changement dans les règles, cela signifie que vous pouvez mettre fin à tous les nombres entrés en 0,0.

EDIT3: Ajout d'un octet pour corriger un bug introduit par la modification suggérée par Digital Trauma.

dc, 41 octets

[[Retina!]pq]sr?d*rd*+vr/300<r[Trash!]p

Requiert que les arguments soient entrés dans l' d, w, hordre - j'espère que c'est correct.

Test de sortie:

$ for t in \
> "4.95 1920 1080" \
> "5.96 2560 1440" \
> "10.5 1920 1080" \
> "0.04 10 10" \
> "19 4096 2160" \
> "100.00 8192 4320" \
> "11.18 3000 1500" ; do \
> echo $t | dc -e'9k[[Retina!]pq]sr?d*rd*+vr/300<r[Trash!]p'
> done
Retina!
Retina!
Trash!
Retina!
Trash!
Trash!
Retina!
$ 

Julia, 46 45 42 octets

f(w,h,d)=w^2+h^2>9e4d^2?"Retina!":"Trash!"

Cela crée une fonction qui accepte trois valeurs numériques et renvoie une chaîne.

C'est une implémentation directe de la formule, juste réorganisée un peu. Les deux côtés de l'inégalité ont été multipliés par deux d.

R, 59 55 octets

En tant que fonction non nommée maintenant

function(h,w,d)if(h^2+w^2>9e4*d^2)'Retina!'else'Trash!'

Une implémentation très simple, qui élimine le besoin de références d'index.

précédent

cat(if((n=scan()^2)[1]+n[2]>9e4*n[3])'Retina!'else'Trash!')

Assez simple, obtenez l’entrée de la numérisation dans un vecteur (ligne simple, espace séparé ou multiligne). Place le vecteur. Faites le calcul et cat le résultat.

MATLAB - 49 45 octets

c={'Trash!','Retina!'};c{(w*w+h*h>9e4*d*d)+1}

J'ai d'abord dû déclarer un tableau de cellules qui contient Trash!et Retina!qui sont stockés aux emplacements 1 et 2 du tableau de cellules. Ensuite, j'utilise l'observation observée par beaucoup pour réorganiser l'équation afin que vous vérifiiez la condition en utilisant uniquement l'arithmétique entière. Je représentais 90000 9e4pour sauver quelques octets. Si cette condition est vraie, nous émettons un 1, sinon nous émettons un 0. J'utilise cette sortie pour indexer directement dans le tableau de cellules. Comme MATLAB commence à indexer à 1, j'ai également dû ajouter 1 pour compléter l'indexation. Ce qui est bien, c’est que l’ajout trueavec 1 donne 2, alors que l’ajout falseavec 1 donne 1. Cela produira l’invite de commande MATLAB Trash!ou Retina!.

Exemple

>> w=1920;h=1080;d=4.95;
>> c={'Trash!','Retina!'};c{(w*w+h*h>9e4*d*d)+1}

ans =

Retina!

XSLT, 400 octets

Ceci est le début d'un langage jamais vu auparavant sur PPCG, et j'espère l'utiliser davantage à l'avenir à mesure que je le connaîtras davantage.

Code:

<?xml version="1.0" encoding="UTF-8"?><xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"><xsl:template match="input"><xsl:variable name="n" select="for $i in tokenize(.,'[^\d\.]+')return number($i)" /><xsl:choose><xsl:when test="$n[1]*$n[1]+$n[2]*$n[2]>90000*$n[3]*$n[3]">Retina!</xsl:when><xsl:otherwise>Trash!</xsl:otherwise></xsl:choose></xsl:template></xsl:stylesheet>

Joli imprimé

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:template match="input">
        <xsl:variable name="n" select="for $i in tokenize(.,'[^\d\.]+')return number($i)" />
        <xsl:choose>
            <xsl:when test="$n[1]*$n[1]+$n[2]*$n[2]>90000*$n[3]*$n[3]">
                Retina!
            </xsl:when>
            <xsl:otherwise>
                Trash!
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
</xsl:stylesheet>

Remarques:

Comme XSLT n'a aucun moyen de prendre une entrée via STDIN, nous devons utiliser un fichier XML, avec l'entrée entre deux <input>balises. Bien sûr, cette méthode a ses limites mais elle fonctionnera parfaitement bien pour la plupart des défis.

Exemple I / O

Fichier d'entrée:

<?xml version="1.0" encoding="ISO-8859-1"?>
<input>3000 1500 11.18</input> 

Fichier de sortie:

<?xml version="1.0" encoding="UTF-8"?>Retina!

Fichier d'entrée:

<?xml version="1.0" encoding="ISO-8859-1"?>
<input>1920 1080 10.5</input>

Fichier de sortie:

<?xml version="1.0" encoding="UTF-8"?>Trash!

C # (81)

string D(int w,int h,double d){return Math.Sqrt(w*w+h*h)/d>300?"Retina":"Trash";}

Ungolfed:

string Density(int width, int height, double diagonal)
{
    return Math.Sqrt(width * width + height * height) / diagonal > 300 ? "Retina" : "Trash";
}

Rapide, 77 octets

Les décélérations de paramètres de fonction signifient que cela prend beaucoup plus de caractères qu'il ne le devrait:

func r(w:Float,h:Float,d:Float){print((w*w+h*h)>9e4*d*d ?"Retina!":"Trash!")}

Rapide, 56 octets

let r={print($0*$0+$1*$1>9e4*$2*$2 ?"Retina!":"Trash!")}

Fondamentalement identique à celui de GoatInTheMachine mais avec des paramètres de fermeture implicites

Quand Code Golfing avec Swift, déclare toujours des méthodes comme celle-ci, c'est beaucoup plus court

Haskell, 46 ans

f w h d|w^2+h^2>d^2*9e4="Retina!"|0<1="Trash!"

C ++ 72 70 octets

void F(int w,int h,float d){cout<<w*w+h*h>9e4*d*d?"Retina!":"Trash!";}

Comme pour d’autres solutions, je me suis dit que je pouvais me réchauffer avec le code golf.

Voici ma contribution à ce problème

Ruby, 67 octets lisant stdin

w,h,d=ARGV.map{|v|Float(v)}
puts w*w+h*h>d*d*9e4?"Retina!":"Trash!"

Ruby, 56 octets dans une fonction

Un peu plus court

def r(w,h,d)
puts w*w+h*h>d*d*9e4?"Retina!":"Trash!"
end

Merci aux précédents contributeurs pour le 9e4!

rubis de golf

Bash, 85 octets

if [ $(echo "sqrt($1^2+$2^2)/$3"|bc) -gt 300 ];then
echo Retina!
else
echo Trash!
fi

PHP, 47,43,40 38 octets

<?=sqrt($w*$w+$h*$h)/$d>300?'Retina':'Trash'?>!
<?=sqrt($w*$w+$h*$h)/$d>300?Retina:Trash?>!
<?=$w*$w+$h*$h>9e4*$d*$d?Retina:Trash?>!

<?=hypot($w,$h)/$d>300?Retina:Trash?>!

Requiert register_globals==true(ce qui ne devrait jamais être!), Avec les valeurs GET w, h, d
- 4 octets enregistrés en supprimant les guillemets autour de la chaîne. Mauvais codage, mais ça marche.
- Déplacé det racine carrée de l'autre côté de l'équation, en enregistrant la sqrt()fonction
- 2 octets sauvegardés en passant à hypot()(merci Lucas Costa)

C # 6, 67 octets

string D(int w,int h,double d)=>w*w+h*h>9e4*d*d?"Retina!":"Trash!";

Cette réponse est basée sur la réponse de Wolfsheads. Je l'ai fait 8 octets plus court en utilisant une nouvelle fonctionnalité de C # 6.

JavaScript (ES6) 58 54 43 octets

43 octets

Suppression de l'attribution de fonction (selon les règles PPCG) (-2), suppression de la racine carrée et comparaison à 900 (300 ^ 2) (-12)

(w,h,d)=>w*w+h*h/d*d>300?"Retina!":"Trash!"

54 octets

Élimine les parenthèses inutiles (-4 octets)

a=(w,h,d)=>Math.sqrt(w*w+h*h)/d>300?"Retina!":"Trash!"

58 octets

a=(w,h,d)=>Math.sqrt((w*w)+(h*h))/d>300?"Retina!":"Trash!"

Explication ici:

a =                           // The function is a
 (w,h,d) =>                   // Accepts the three arguments
   Math.sqrt((w*w)+(h*h))/d   // Calculate pixel density
   > 300                      // Above the threshold
   ? "Retina!"                // If so, return "Retina!"
   : "Trash!"                 // Otherwise return "Trash!"

Ceci utilise des opérateurs ternaires pour tester la densité et tue quelques octets en utilisant des fonctions de flèche

Java, 82 74 octets

String g(int w,int h,double d){return 9e4*d*d>w*w+h*h?"Trash!":"Retina!";}

Appelez-le avec g(width,height,diagonal)

Clojure, 58 octets

#(if(>(+(* %1%1)(* %2%2))(* %3%3 90000))"Retina!""Trash!")

Utilisez les mathématiques sophistiquées de @ Kroltan pour raccourcir ceci. Utilise des arguments implicites passés dans l’ordre de (w, h, d).

Premier golf Clojure ... J'ai été surpris de voir combien d'espaces je suis autorisé à laisser de côté