Retina oder Müll?


47

Wir leben in einem wundervollen Zeitalter der Technologie, in dem wir auf unseren Fernsehern wunderschön detaillierte 8K-Bildschirme und auf unseren Handys sogar 2K-Bildschirme für unser mobiles Surfvergnügen haben können. In den letzten Jahren haben wir in Bezug auf die Bildschirmtechnologie einen langen Weg zurückgelegt.

Eines der Produkte davon ist ein Begriff, der von Apple, Retina, populär gemacht wurde . Dies bezieht sich auf die Pixeldichte der fraglichen Anzeige, die so hoch ist, dass bei einem Betrachtungsabstand von 10 bis 12 Zoll einzelne Pixel nicht einfach herausgegriffen werden können.

Steve Jobs sagte, dass die Pixeldichte, bei der dies auftritt, ungefähr 300 Pixel pro Zoll beträgt , und sie begannen, Pixeldichten in diesem Bereich auf ihren Geräten mit dem für Werbung verwendeten Retina- Schlagwort zu verwenden.

Die Pixeldichte kann mit der folgenden Formel berechnet werden:

D = sqrt (w 2 + h 2) / d

Wo dist die Diagonale des Bildschirms in Zoll, wist die Anzahl der Pixel auf der horizontalen Achse und hist die Anzahl der Pixel auf der vertikalen Achse.

Deine Aufgabe

Für diese Aufgabe verwenden Sie den Retina- Standard, um zu entscheiden, welche Produkte es wert sind, gekauft zu werden. Als der moderne Verbraucher, der Sie sind, möchten Sie beim Kauf von Geräten sicherstellen, dass Sie ein gutes Produkt erhalten, kein Gerät aus den 90er Jahren! Als solches möchten Sie ein Programm oder eine Funktion erstellen , die die Bildschirmbreite, -höhe und -diagonale als Eingabe- oder Funktionsparameter verwendet und Ihnen mitteilt, ob der jeweilige Bildschirm als Retina-Bildschirm ( D > 300) qualifiziert ist, indem Sie auf den Bildschirm drucken oder zurückkehren .

Aufgrund Ihrer Missachtung von Nicht-Retina-Geräten wird Ihr Programm oder Ihre Funktion ausgegeben, Retina!wenn sich das Gerät qualifiziert und Trash!wenn dies nicht der Fall ist.

Sie können davon ausgehen, dass alle Zahlen größer als 0 sind. Pixelwerte für Breite und Höhe sind immer ganze Zahlen. Die Bildschirmgröße kann beliebig interpretiert werden, sofern Dezimalstellen unterstützt werden. Die Eingabe kann in beliebiger Reihenfolge erfolgen und sich auch in bis zu 3 separaten Zeilen befinden.

Beispiel 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!

Das ist , also gewinnt die geringste Anzahl von Bytes.


Hier ist eine Stuck-Lösung, eine stapelbasierte Programmiersprache, die ich mache:

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

34
Bitte machen Sie eine Retina- Antwort
Digitales Trauma

2
@DigitalTrauma Schwimmt aber.
Sp3000,

7
@ Sp3000 pfft, entschuldigungen !. Bauen Sie in Retina Ihren eigenen Parsing-Regex für Floats!
Optimierer

46
@ Sp3000 Okay, lasst uns den Einsatz erhöhen. Hiermit verspreche ich, eine Woche nach dem Zeitstempel des Kommentars eine große, saftige 500-Punkte-Prämie auf die kürzeste legale Retina-Antwort zu geben.
Digitales Trauma

2
Hmm, die gewählte Schwelle passt nicht ganz zum Apple-Marketing, z. B. für den Retina iMac: 5120 2880 27
Ed Avis

Antworten:


5

Pyth - 27 Bytes

Verwendet den ternären Operator und abszur Berechnung des Pythagoras.

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

Nimmt Eingaben in zwei Zeilen vor, erste Zeile width, height, zweite Zeile diag.

Die Regeln waren locker, also rollte sie zurück.

Probieren Sie es hier online aus .


115

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

Dank an randomra für das Speichern von 3 Bytes! (Und ebnen den Weg für ein paar mehr.)

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

Zu Zwecken der Byte-Zählung wird jede Zeile in eine separate Datei geschrieben. Sie können den obigen Code jedoch wie aus einer einzelnen Datei ausführen, indem Sie Retina mit dem -sFlag aufrufen .

Dies erwartet zuerst die Dichte (die einen Dezimalpunkt enthalten muss , auch wenn es sich um einen nachgestellten handelt), gefolgt von Breite und Höhe, d d w h. H.

Das ist etwas langsam. Ich würde die meisten Testfälle nicht ausprobieren, da sie ewig laufen werden. Sie können jedoch überprüfen, ob es mit den Testfällen ordnungsgemäß funktioniert

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

Nach dem Multiplizieren aller Zahlen, um die Dichte zu einer Ganzzahl zu machen, soll die Breite und Höhe nicht mehr als 4 Stellen haben.

Dies ist zwar langsam, aber völlig genau ... es gibt keine Fließkomma-Probleme oder ähnliches. Alle Arithmetik verwendet (unäre) Ganzzahlen.

Im Prinzip könnte ich ein weiteres Byte ^weglassen : das kann weggelassen werden, aber es wird Trash!Testfälle aufgrund von übermäßig viel Backtracking schrecklich langsam machen .

Erläuterung

Zuerst ordnen wir die Ungleichung neu an, um Gleitkommaoperationen zu vermeiden:

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

Wir können auch feststellen , dass diese invariant unter Multiplikation ist w, hund ddurch die gleiche Anzahl 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

Es gibt verschiedene Möglichkeiten, eine unäre Zahl zu quadrieren, aber wir werden die Identität nutzen

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

Dies gibt uns eine Möglichkeit, das Problem nur mit einer Ganzzahlarithmetik (die Ganzzahlen in Unary darstellt) zu lösen.

Lass uns den Code durchgehen. Jedes Zeilenpaar ist eine reguläre Ersetzung.

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

Dadurch wird der Dezimalpunkt in der Dichte wiederholt nach rechts verschoben, während Breite und Höhe mit 10 multipliziert werden (siehe xoben). Dies soll sicherstellen, dass alle Zahlen Ganzzahlen sind. Anstatt Nullen anzufügen, füge ich Nullen hinzu, _die ich später als Null behandeln werde. (Dies ist ein Golf-Trick, da ich sonst schreiben müsste ...${3}0, um Mehrdeutigkeiten zu vermeiden $30.) Das +vor der Regex weist Retina an, diese Ersetzung zu wiederholen, bis sich das Ergebnis nicht mehr ändert (was der Fall ist, wenn das Muster nicht mehr übereinstimmt). .

\b
#

Wir bereiten die drei Zahlen für die Umwandlung in Unary vor. Grundsätzlich benötigen wir einen Marker (das #) vor jeder Zahl, aber es ist auch kürzer, einen am Ende jeder Zahl hinzuzufügen, was den Konvertierungsschritt nicht beeinflusst.

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

Dies ist die Umstellung auf Unary mit einem von dan1111 entwickelten Trick . Im Wesentlichen übersetze ich jede Ziffer in eine Wiederholungsziffer für sich selbst, während ich die vorhandenen Ziffern mit 10 multipliziere (dabei bewege ich den #Marker nach rechts). Diese binäre Darstellung ist ein Durcheinander verschiedener Ziffern, aber die Gesamtzahl entspricht dem Wert der ursprünglichen Ganzzahl. Beachten Sie die \wam Ende - normalerweise ist dies nur 0, aber wir möchten auch _als Null behandeln (was in regulären Ausdrücken als Wortzeichen betrachtet wird).

\d
11

Wir wandeln jede Ziffer in zwei 1s um, um a) sicherzustellen, dass alle Ziffern gleich sind (was später erforderlich sein wird) und b) jede der Zahlen zu verdoppeln.

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

Dies führt zu zwei Dingen: Es quadriert alle Zahlen (oder vielmehr die Hälfte jeder Zahl, indem eine Summe berechnet wird 2n) und addiert die resultierenden Quadrate der Breite und der Höhe. Beachten Sie, dass s, Markierungen und Leerzeichen [^.]übereinstimmen . Wenn es sich um ein oder ein Leerzeichen handelt, erfasst der Lookahead nichts. Dies bedeutet, dass alle Elemente einfach entfernt werden, dh die Ergebnisse für die Breite und Höhe werden verkettet / hinzugefügt. Das Komma bleibt, um das Ergebnis von diesen zu trennen . Wenn Streichhölzer ein statt, dann sind die Look - Ahead stellt sicher , dass wir capture Hälfte der s , nachdem es (abgerundet) in der Gruppe . Dies berechnet die oben erwähnte Summe, die dann das Quadrat der ursprünglichen Zahl ergibt.1##.d[^.]111

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

Die Zeichenfolge ist jetzt (in unary), dann , dann (in unary). Wir wollen wissen, ob die erste unäre Zahl kürzer ist als die zweite. Wir können diese Multiplikation leicht mit einer Erfassungsgruppen- und Wiederholungssyntax durchführen. Wir verwenden (anstatt ) danach, um sicherzustellen, dass die zweite Zahl tatsächlich größer als diese und nicht gleich ist. Wenn ja, ersetzen wir das alles durch .d2.w2 + h290000{n}1+1*Retina!

1.+
Trash!

Wenn die zweite Zahl nicht groß genug war, hat der vorherige Schritt nichts geändert und die Zeichenfolge beginnt immer noch mit einem 1. In diesem Fall ersetzen wir einfach die gesamte Zeichenfolge durch Trash!und sind fertig.


24
Nun, es ist passiert. Jetzt können wir alle glücklich sterben.
Alex A.

94
Als Randnotiz, da dies Retina ist, bringt das alle anderen Antworten in den Papierkorb?
Alex A.

5
Unser Gott ist angekommen!
Kade

7
OK, mein Kopfgeldversprechen steht noch, aber ich würde gerne eine gründliche Erklärung sehen (konzeptionell denke ich, dass ich weiß, wie es gemacht wurde, aber ich würde gerne die Details sehen). Außerdem werde ich das Kopfgeld an die kürzeste legale Retina-Antwort vergeben, also, Leute, das Kopfgeld ist immer noch offen für kürzere Retina-Antworten!
Digital Trauma

2
@AlexA. Nein, weil es eine andere Antwort auf Retina gibt.
Ismael Miguel

38

Python, 49

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

Verwendet String-Interleaving.

Es stellte sich heraus, dass es kürzer war, beide Seiten zu quadrieren, als die komplexe Norm zu verwenden.

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

18
Wir sollten entweder drucken Retina!oder Trash!! Nicht retweetet @ertaisnha !!
Optimierer


2
@Mew aber das ist das Gegenteil;)
Optimierer

Schön, ich habe noch nicht gesehen, dass (ab) verwendet wird, um die eine oder andere Zeichenfolge zu drucken
Nick T

15

Retina , 312 Bytes

(\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!

Das dauert eine Weile, aber es scheint zu funktionieren.

Könnte wohl noch viel mehr golfen werden ...

Erläuterung:

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

Fügen Sie Tags hinzu, um das Parsen der Zeichenfolge zu vereinfachen, und fügen Sie Junk hinzu, um die Konvertierung in Basis 1 zu vereinfachen, und fügen Sie 300 hinzu, um sie mit später zu multiplizieren

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

Fügen Sie 0s an die Breite und Höhe an, während Sie den Dezimalteil der Diagonale an den ganzzahligen Teil anhängen. In diesem Fall ist die Diagonale eine ganze Zahl, und Breite und Höhe werden mit den 10erforderlichen Werten multipliziert .

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

Konvertieren Sie alle Zahlen zur Basis 1, indem Sie die im ersten Schritt angehängte Nachschlagetabelle verwenden

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

Bereiten Sie sich darauf vor, alle Zahlen zu quadrieren

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

Quadrieren Sie jede Zahl

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

Multiplizieren Sie das Quadrat der Diagonale mit dem Quadrat der 300, die Sie im ersten Schritt eingefügt haben

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

Wenn die an die Höhe angehängte Breite in das gerade berechnete Produkt passt, ist die Pixeldichte zu niedrig und es handelt sich um Papierkorb!

.*0
Retina!

Ansonsten ist es Retina!



9

APL, 40 36 Bytes

4 Bytes gespart dank Dennis!

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

Dies erzeugt eine unbenannte dyadische Funktion, die die ersten beiden Argumente links und das dritte rechts übernimmt. Es wird geprüft, ob die Summe der Quadrate der linken Werte größer ist als das 300-fache des Quadrats der rechten. Die Ausgabe wird entsprechend gedruckt.

Sie können es online ausprobieren !


Sollte vor dem Posten aktualisiert worden sein ... Sie können ein paar Bytes speichern, indem Sie die ersten beiden Argumente auf der linken Seite verwenden.
Dennis

@ Tennis Vielen Dank für Ihre Hilfe! Ich dachte darüber nach, meine Antwort zu löschen, als ich deine sah, weil deine besser war. : P
Alex A.

9

TI-BASIC, 43

Legt Breite und Höhe als Liste mit zwei Elementen über den Homescreen und diagonal über die Eingabe fest.

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

Die 2-Byte-Kleinbuchstaben von TI-BASIC addieren 7 Byte (da ies sich um die imaginäre Einheit handelt, die aus einem Byte besteht), wodurch die Wettbewerbsfähigkeit beeinträchtigt wird. Zum Glück !ist auch ein Byte, weil es die Fakultätsfunktion darstellt.


9

JavaScript ES6, 49 Byte

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

Ich hasse es, dass JavaScript so lange mathematische Operatoren hat. Aber selbst wenn es einen Math.pythagoreangäbe, wäre dieser kürzer.


Hat jemand etwas dagegen, Abstimmungen zu erklären?
Downgoat

Wahrscheinlich zu lang.
Lirtosiast

1
@ ThomasKwa Python ist nur 1 Byte kürzer
Optimierer

5
Anstatt die Quadratwurzel zu berechnen, kann sie kürzer sein, wenn Sie die Quadrate der Werte vergleichen.
Reto Koradi

4
@ RetoKoradi Ja, es ist kürzer:(w,h,d)=>w*w+h*h>9e4*d*d?'Retina!':'Trash!'
Pepkin88

8

Excel, 44 Bytes

Geben Sie Ihre Eingaben in diese Zellen ein.

  • A1 = Breite in Pixel
  • B1 = Höhe in Pixel
  • C1 = Diagonale in Zoll

Und diese Formel gibt Ihr Ergebnis:

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

4
Ich habe versucht, 2 Bytes davon durch Eingabe von 9E4*C1^2anstelle von (300*C1)^2... zu golfen. Dies ergibt eine Länge von 42. Das Eingeben 9E4einer Formel in Excel wird jedoch in geändert, 90000sobald Sie die Eingabetaste drücken. :(
Ross Presser

7

Prolog, 51 Bytes

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

Laufende a(8192,4320,100.0,R).Ausgaben:R = "Trash!" .

Edit: Danke an @PaulButcher für das Korrigieren eines Edge-Cases und das Golfen eines Bytes.


Dies gibt "Retina!" Zurück, wenn die Dichte 180 240 1 -> Trash!aus dem Beispiel 300 (z. B. ) beträgt . Zum Glück, da Sie zwei Zeichen mit e-Notation abschneiden können >, >=bleibt es bei 52:b(W,H,D,R):-9e4*D*D>=W*W+H*H,R="Trash!";R="Retina!".
Paul Butcher

@PaulButcher Wenn Sie 9e4 anstelle von 90000 verwenden, werden 2 Zeichen entfernt, nicht eines. Sie haben meine Antwort also effektiv um ein Byte verkürzt und diesen Randfall korrigiert, danke.
Fatalize

1
Gut gemacht! Es ist gut, ein einigermaßen kurzes Prolog-Beispiel zu sehen.
Paul Butcher

@PaulButcher Rasiert ein weiteres Byte, indem <stattdessen tatsächlich >=die beiden Zeichenfolgenergebnisse verwendet und
ausgetauscht werden

5

JavaScript (ES6), 45 Byte

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

CoffeeScript, 47 Bytes

Kein ternärer Operator, aber es gibt eine Potenzierung (die beim letzten Versuch nicht hilft).

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!'

1
Gemäß der Spezifikation ist es nicht erforderlich, die Funktion named ( f=) zu haben. Sie können in allen Versionen 2 Bytes abschneiden.
Kroltan


5

Pure Bash (kein bc / andere externe Befehle), 138 136 135 82 83 Bytes

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

Ich beschloss, es in purer Bash zu versuchen. Ich habe wahrscheinlich ein paar offensichtliche Ineffizienzen gemacht, da dies mein erstes Mal Code-Golfen ist, aber ich bin SEHR vertraut mit Bash und hatte in der Vergangenheit Spaß daran, Dinge zu schreiben, die keine externen Befehle verwenden (dh reine Bash).

Die printf-Anweisung ist am ärgerlichsten. Hat jemand bessere Ideen für das Auffüllen von Zahlen mit Nullen?

BEARBEITEN: Zwei Bytes gespeichert. Es stellt sich heraus, dass printf ein leeres Argument für Null akzeptiert. Hat ein weiteres Byte gespeichert, hat sich herausgestellt, dass ich zuvor falsch gezählt habe, und die Ausgabe von printf nur einer Variablen zuzuweisen, ist kleiner als die Verwendung von -v.

EDIT2: Dank Digital Trauma in den Kommentaren ist dies jetzt viel deutlicher gesunken. Tricks: Verwenden Sie die Regex-Unterstützung von bash, um die Ziffernfolge durch Nullen zu ersetzen, anstatt sie zu zählen, und drucken Sie dann diese Anzahl von Nullen aus (scheint offensichtlich, wenn ich es so ausdrücke ...). Speichern Sie die Zeichenfolgen in einem Bash-Array, um ein Echo zu speichern. und unter Berücksichtigung einer geringfügigen Änderung der Regeln, dh Sie können alle eingegebenen Zahlen in .0 beenden.

EDIT3: Ein Byte wurde hinzugefügt, um den Fehler zu beheben, der durch die vorgeschlagene Änderung von Digital Trauma verursacht wurde.


Etwas wie dies für eine Punktzahl von 102: a=${3#*.};d=${a/./0};((${#a}-${#3}))||d=;r=(Trash Retina);echo ${r[$1$d**2+$2$d**2>90000*${3/./}**2]}! (Sie können das ;durch Zeilenumbrüche ersetzen - ich habe nur versucht, es in einem Kommentar zu bekommen).
Digitales Trauma

Und wenn Sie davon ausgehen, dass die Dichte mit ganzen Zahlen endet .0(ok, glaube ich), können Sie 82 Punkte erzielen:a=${3#*.};d=${a/./0};r=(Trash Retina);echo ${r[$1$d**2+$2$d**2>90000*${3/./}**2]}!
Digitales Trauma

Das ursprüngliche Beispiel hatte einige, die nicht mit .0 endeten, aber ich stelle fest, dass die Frage jetzt geändert wurde, so dass einiges gespart wird. Danke für die Ideen! Mir gefällt besonders Ihre Idee, die beiden Echo-Statements zu reduzieren. Ich habe versucht, herauszufinden, wie das geht, aus irgendeinem Grund kam es mir nicht in den Sinn, ein Array zu verwenden! Aus irgendeinem Grund ist mir AUCH nie in den Sinn gekommen, dass Sie ** verwenden könnten ... Ich werde versuchen, Ihre Antwort zu überprüfen. Ich bin ein wenig verwirrt darüber, wie $ d hier funktioniert, aber ich werde es herausfinden.
Muzer

Das $dist nicht zu knifflig. aenthält die Nachkommastellen der Dichte. d=${a/./0}Ersetzt einfach alle diese Ziffern durch Nullen. Auf diese Weise können wir diese Nullen bis zum Ende zusammenfassen wund hmit derselben Zehnerpotenz multiplizieren, die durch Entfernen des Dezimalpunkts von erreicht wird d.
Digital Trauma

1
Prost, ich dachte, ich werde für eine Minute verrückt!
Muzer

4

Gleichstrom, 41 Bytes

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

Benötigt die Eingabe von Argumenten in der richtigen d, w, hReihenfolge - ich hoffe, das ist in Ordnung.

Testausgang:

$ 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!
$ 

3

Julia, 46 45 42 Bytes

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

Dadurch wird eine Funktion erstellt, die drei numerische Werte akzeptiert und eine Zeichenfolge zurückgibt.

Es ist eine direkte Implementierung der Formel, die nur ein wenig umgestellt wurde. Beide Seiten der Ungleichung wurden ddann zum Quadrat multipliziert .


3

R 59 55 Bytes

Als unbenannte Funktion jetzt

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

Sehr einfache Implementierung, bei der keine Indexverweise erforderlich sind.

Bisherige

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

Ziemlich einfach ist es, die Eingabe vom Scan in einen Vektor zu übertragen (einzeilig, durch Leerzeichen getrennt oder mehrzeilig). Quadrieren Sie den Vektor. Mach die Berechnung und kater das Ergebnis.


3

MATLAB - 49 45 Bytes

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

Ich musste zuerst ein Zellenarray deklarieren, das die Positionen 1 und 2 des Zellenarrays enthält Trash!und in Retina!diesen gespeichert ist. Als nächstes benutze ich die Beobachtung, die von vielen beobachtet wurde, um die Gleichung neu zu ordnen, so dass Sie die Bedingung nur mit Ganzzahlarithmetik überprüfen. Ich habe 90000 dargestellt 9e4, um einige Bytes zu sparen. Wenn diese Bedingung erfüllt ist, geben wir eine 1 aus, ansonsten eine 0. Mit dieser Ausgabe indiziere ich direkt in das Zellenarray. Da MATLAB mit der Indizierung bei 1 beginnt, musste ich auch 1 hinzufügen, um die Indizierung abzuschließen. Was schön ist, ist, dass das Hinzufügen truemit 1 2 ergibt, während das Hinzufügen falsemit 1 1 ergibt. Dies wird entweder Trash!oder Retina!in der MATLAB-Eingabeaufforderung ausgegeben .

Beispiel

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

ans =

Retina!

brauchst du nicht int8, true + 1 ist ein double (2).
Jonas

@Jonas Das habe ich versucht. Bei MATLAB R2013a würde es nicht zu 2 werden ... Seltsam.
rayryeng - Wiedereinsetzung von Monica

@ Jonas - Ich musste den logicalAusdruck in Klammern kapseln, damit er funktioniert. Reihenfolge der Operationen ... oh. Danke für den Tipp!
Rayryeng - Wiedereinsetzung von Monica

Netter Ansatz! (Habe ich mit probiert hypotaber dein w*w+h*h>9e4*d*dist kürzer). Entspricht dies jedoch den Fragenanforderungen? Es ist ein Programm, keine Funktion. Also sollte es dauern w, hund dals Eingänge. Ich nehme an, das bedeutet Standard, wie bei Code-Abfragen üblich
Luis Mendo

@ LuisMendo ah, das muss ich ändern! Dank
rayryeng - wieder einzusetzen Monica

3

XSLT, 400 Bytes

Dies ist das Debüt einer noch nie dagewesenen Sprache bei PPCG, und ich hoffe, dass ich sie in Zukunft mehr verwenden kann, wenn ich sie näher kennenlerne.

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>

Ziemlich gedruckt

<?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>

Anmerkungen:

Da XSLT keine Möglichkeit zur Eingabe über STDIN bietet, müssen wir eine XML-Datei verwenden, bei der die Eingabe zwischen zwei <input>Tags erfolgt. Natürlich hat diese Methode ihre Grenzen, aber für die meisten Herausforderungen funktioniert sie einwandfrei.

Beispiel I / O

Eingabedatei:

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

Ausgabedatei:

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

Eingabedatei:

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

Ausgabedatei:

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

2

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";
}

Sie können diese bis zu 73 mit dem Trick verkürzen mehrere andere verwendet haben die Formel neu schreiben und die sqrt Betrieb entfernen: string D(int w,int h,double d){return w*w+h*h>9e4*d*d?"Retina":"Trash";}. Aber Sie müssen auch !zu jeder Zeichenfolge hinzufügen , so dass ich denke, zurück zu 75 wäre.
GORIC

2

Schnell, 77 Bytes

Deklarationen von Funktionsparametern bedeuten, dass dies viel mehr Zeichen erfordert, als es sollte:

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


2

Schnell, 56 Bytes

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

Grundsätzlich dasselbe wie bei GoatInTheMachine , jedoch mit impliziten Schließparametern

Wenn Code Golfing mit Swift immer solche Methoden deklariert, ist es viel kürzer


2

Haskell, 46

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

Welches Haskell-System sollte verwendet werden? Es funktioniert nicht mit der Version von Ghci, die ich ausprobiert habe <interactive>:2:8: parse error on input '|'.
Ed Avis

@EdAvis: GHCi führt keine Programme aus. um es dort zu versuchen, brauchst du let f w h d|….
Ry

2

C ++ 72 70 Byte

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

Ähnlich wie bei anderen Lösungen habe ich mich mit Codegolf aufgewärmt.


1
Sie können ein Paar rasieren, indem Sie 90000als9e4
Toby Speight

2

Hier ist mein Beitrag für dieses Problem

Ruby, 67 Bytes, die von stdin lesen

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

Ruby, 56 Bytes in einer Funktion

Ein bisschen kürzer

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

Vielen Dank an die bisherigen Mitwirkenden für den 9e4!


2

Bash, 85 Bytes

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

1
Dies funktioniert nicht für "3000 1500 11.18". Standardmäßig bcbeträgt die Genauigkeit 0 Dezimalstellen. Sie müssen festlegen scale, oder Sie können wahrscheinlich davonkommen, mit bc -ldem implizit die Skalierung auf 20 festgelegt wird
Digitales Trauma

Oh ok, ich habe meine Antwort aktualisiert. Vielen Dank!
Addison

1
Oh, und schauen Sie sich codegolf.stackexchange.com/questions/15279/… an . Zum Beispiel((`bc<<<"sqrt($1^2+$2^2)/$3"`>300))&&echo Retina!||echo Trash!
Digital Trauma

2

PHP, 47 , 43 , 40, 38 Bytes

<?=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?>!

Benötigt register_globals==true(was es niemals sein sollte!), Mit GET-Werten w, h, d
- 4 Bytes durch Entfernen von Anführungszeichen um den String gespeichert. Schlechte Codierung, aber es funktioniert.
- Verschoben dund Quadratwurzel auf die andere Seite der Gleichung, Speichern der sqrt()Funktion
- 2 Bytes durch Umschalten auf gespeichert hypot()(danke Lucas Costa)


Sie sollten nur sagen, dass dies eine PHP4.1-Antwort ist und Sie die register_globalsDirektive nicht setzen müssen.
Ismael Miguel

2
Jede Option ist genauso schlecht haha
Martijn

2

C # 6, 67 Bytes

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

Diese Antwort basiert auf der Antwort von Wolfsheads. Ich habe es mit einer neuen Funktion von C # 6 um 8 Bytes kürzer gemacht.


2

JavaScript (ES6) 58 54 43 Bytes

43 Bytes

Funktionszuweisung (gemäß PPCG-Regeln) entfernt (-2) sowie Quadratwurzel entfernt und mit 900 (300 ^ 2) verglichen (-12)

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

54 Bytes

Unnötige Klammern (-4 Bytes) loswerden

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

58 Bytes

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

Erklärung hier:

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!"

Hierbei werden ternäre Operatoren verwendet , um die Dichte zu testen, und mithilfe von Pfeilfunktionen werden einige Bytes gelöscht


1
Sie können dies verkürzen, indem Sie die Quadratwurzel vermeiden und stattdessen die Quadrate der Werte vergleichen.
Reto Koradi

1

Java, 82 74 Bytes

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

Nennen Sie es mit g(width,height,diagonal)


1
Sie können dies reduzieren, indem Sie das kostspielige doubleArray wie String g(int w,int h,double x){return 9e4*x*x>w*w+h*h?"Trash!":"Retina!";}folgt
entfernen

@Geobits Danke, ich hatte mir nicht die Zeit genommen, die Bytes für die beiden Ansätze herauszusuchen. Ich bin froh, dass du sie erwischt hast!
DeadChex

1

Clojure, 58 Bytes

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

Benutzt @ Kroltans ausgefallene Mathematik, um dies zu verkürzen. Verwendet implizite Argumente, die in der Reihenfolge (w, h, d) übergeben werden.

Erste Clojure Golf ... Ich war überrascht, wie viel Leerzeichen ich auslassen darf

Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.