Retina mı Çöp mü?


47

Mobil tarama keyfimiz için TV'lerimizde ayrıntılı olarak 8K ekranlar, hatta telefonlarımızda 2K ekranlar alabileceğimiz harika bir teknoloji çağında yaşıyoruz. Ekran teknolojisi açısından son yıllarda çok yol kat ettik.

Bunun ürünlerinden biri Apple, Retina tarafından popüler yapılan bir terimdir . Bu, söz konusu ekranın piksel yoğunluğuna o kadar yüksektir ki, 10-12 inç uzaklıktaki bir izleme mesafesinden, tek tek pikseller kolayca seçilemez.

Steve Jobs, bunun gerçekleştiği piksel yoğunluğunun inç başına 300 piksel civarında olduğunu ve reklamlarında kullanılan Retina kelimesiyle bu aralıktaki piksel yoğunluklarını kullanmaya başladıklarını söyledi .

Piksel yoğunluğu aşağıdaki formülle hesaplanabilir:

D = sqrt (a ^ 2 + h ^ 2) / gün

Burada dinç ekranın diyagonaldir, wyatay eksende piksel sayısı ve hdikey eksende piksel sayısıdır.

Senin görevin

Bu görev için hangi ürünlerin satın almaya değer olduğuna karar vermek için Retina standardını kullanacaksınız. Bulunduğunuz modern tüketici olmak, cihaz satın alırken, 90'lı yıllardan kalma bir cihaz değil, iyi bir ürün aldığınızdan emin olmak istersiniz! Öyle ki, bir inşa etmek isteyen program veya fonksiyon olarak ekran genişlik, yükseklik ve diyagonal uzunluğu alır giriş veya fonksiyon parametreleri ve (retina ekranı gibi belirli ekran nitelendirir olmadığını söyler D > 300yoluyla) ekrana baskı veya dönen .

Nedeniyle sizin olmayan Retina cihaz sayısı, hor için program veya fonksiyon irade çıkışı Retina!cihaz nitelendirir ve Trash!ne zaman öyle değil.

Tüm sayıların 0'dan büyük olacağını varsayabilirsiniz. Genişlik ve yükseklik için piksel değerleri her zaman tam sayı olacaktır. Ekran boyutu, ondalık basamakları desteklediği sürece herhangi bir şekilde yorumlanabilir. Giriş seçtiğiniz herhangi bir sırada olabilir ve ayrıca 3 ayrı satıra kadar olabilir.

Örnek G / Ç

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!

Bu , yani en az sayıda bayt kazanıyor.


İşte Stuck çözümü, oluşturduğum bir yığın tabanlı programlama dili:

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

34
Birisi, lütfen, bir Retina cevabı yapın
Digital Trauma,

2
@DigitalTrauma Ama yüzer.
Sp3000,

7
@ Sp3000 pfft, bahaneler! Kendi float ayrıştırma düzenini Retina'da inşa et!
Doktor,

46
@ Sp3000 Tamam, bahisleri kaldıralım. En kısa yasal (topluluk oy birliği) üzerine büyük bir sulu 500 puan ödülü tokatlayacağınıza söz veriyorum.
Dijital Travma,

2
Hmm, seçilen eşik, Apple'ın pazarlamasıyla tam olarak eşleşmiyor, örneğin Retina iMac için: 5120 2880 27
Ed Avis,

Yanıtlar:


5

Pyth - 27 bayt

Üçlü operatör kullanır ve abspisagoru hesaplar.

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

İlk satır width, heightikinci satır olmak üzere iki satır girdi alır diag.

Kurallar gevşetildi, geri çekildi.

Burada çevrimiçi deneyin .


115

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

3 byte tasarruf için randomra için Kredi! (Ve bir çiftin yolunu açıyor.)

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

Bayt sayma amacıyla, her satır ayrı bir dosyaya gider, ancak yukarıdaki kodu tek bir dosyadan olduğu gibi Retina'yı -sbayrakla çalıştırarak çalıştırabilirsiniz .

Bu, önce yoğunluğu ( izleyen olsa bile ondalık bir nokta içermesi gerekir ) önce genişliğini ve yüksekliğini bekler d w h.

Bu biraz yavaş. Verilen test vakalarının çoğunu denemem, çünkü uzun yıllar sürecek. Ancak, test durumlarıyla doğru çalıştığını kontrol edebilirsiniz.

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

Temel olarak, yoğunluğu bir tamsayı yapmak için tüm sayıları çarptıktan sonra, genişliğin ve yüksekliğin 4 basamaktan daha fazla olmasını istemezsiniz.

Bu yavaş olsa da, tamamen kesin ... kayan nokta sorunu veya bunun gibi bir şey yok. Tüm aritmetik (unary) tamsayılar kullanıyor.

Prensip olarak, bir bayt daha tıraş ^edebilirim : ihmal edilebilir, ancak Trash!aşırı geri izleme nedeniyle test durumlarını çok yavaşlatır.

açıklama

İlk önce, kayan nokta işlemlerinden kaçınmak için eşitsizliği yeniden düzenleyelim:

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

Biz de bu değişmez çarparak altında olduğunu fark edebilirsiniz w, hve daynı sayısına göre 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

Tek bir sayının karesini almanın birkaç yolu vardır, ancak kimliği kullanacağız.

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

Bu bize sorunu sadece tamsayı aritmetiği kullanarak (tekli tamsayıları temsil eden) çözmenin bir yolunu verir.

Hadi koddan geçelim. Her bir çizgi çifti bir regex ikamesidir.

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

Bu, genişlik ve yüksekliği 10 ( xyukarıdaki) ile çarparken, yoğunluktaki ondalık noktayı tekrar tekrar sağa kaydırır . Bu, tüm sayıların tam sayı olmasını sağlamak içindir. _Sıfır eklemek yerine, daha sonra sıfır olarak kullanacağım, ekliyorum . (Bu bir golf oyunudur, çünkü aksi takdirde ...${3}0belirsizlikten kaçınmak için yazmam gerekir $30.) +Regex'in önünde, Retina'ya, bu değişimin bitinceye kadar (desen artık uyuşmadığında olduğu gibi) bu değişikliği tekrar etmesini söyler. .

\b
#

Şimdi üç sayıyı unary'e çevirmeye hazırlıyoruz. Prensip olarak, #her sayının önünde bir işaretleyiciye ( ) ihtiyacımız vardır , ancak her sayının sonuna bir tane eklemek daha kolaydır, bu da dönüşüm adımını etkilemez.

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

Bu, dan1111 tarafından geliştirilen bir numara kullanarak , birliğe dönüşüyor . Temelde, mevcut haneleri 10 ile çarparken her basamağı kendi basamağının diline çeviriyorum (işlem sırasında #işaretçiyi sağa doğru hareket ettirerek ). Bu ikili gösteriliş, farklı basamaklarda oldukça karışık olacaktır, ancak toplam sayı, orijinal tamsayının değerine eşit olacaktır. Not \wsonunda - normalde bu sadece 0, ama biz tedavi etmek istiyorum _(bir kelime regex karakter olarak kabul edilir) hem de sıfır olarak.

\d
11

Her basamağı iki 1s'ye çeviririz, böylece a) tüm basamakların aynı olmasını sağlamak (daha sonra gerekli olacak) ve b) sayıların her birini iki katına çıkarmak.

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

Bu iki şey yapar: tüm sayıları kareler (veya her sayının yarısını, toplamı hesaplayarak 2n) kareler ve genişliğin ve yüksekliğin sonuç karelerini ekler. S, işaretleyiciler ve boşluklarla [^.]eşleşen dikkat edin . Eğer bu bir boşluk ya da boşluk ise, bakış açısı hiçbir şeyi yakalamaz, bu da bunların hepsinin basitçe kaldırıldığı anlamına gelir, yani genişlik ve yükseklik için sonuçlar birleştirilir / eklenir. Ondalık nokta sonucu onlardan ayırmak için kalır . Eğer maçları bir yerine, ardından ileri yönlü olmasını sağlar bunun biz yakalama yarım s bununla (yuvarlak aşağı) grubunda sonra . Bu yukarıda belirtilen toplamı hesaplar ve bu daha sonra orijinal sayının karesini verir.1##.d[^.]111

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

Dize şimdi (unary içinde), sonra , sonra (unary içinde). İlk unary sayı sürelerinin ikinciden daha kısa olup olmadığını bilmek istiyoruz . Bir yakalama grubu ve tekrarlama sözdizimi kullanarak bu çarpımı kolayca yapabiliriz . İkinci sayının aslında ondan daha büyük olmasını ve sadece eşit olmasını sağlamak için (yerine ) kullanırız . Eğer öyleyse, hepsini değiştiririz .d2.w2 + h290000{n}1+1*Retina!

1.+
Trash!

İkinci sayı yeterince büyük değilse, önceki adım hiçbir şeyi değiştirmez ve dize yine de bir ile başlar 1. Bu durumda, dizenin tamamını değiştiririz Trash!ve yapılır.


24
Evet, oldu. Şimdi hepimiz mutlu ölebiliriz.
Alex A.

94
Bir yan not olarak, bu Retina olduğu için, diğer tüm cevapları çöpe mi atıyor?
Alex A.

5
Tanrımız geldi!
Kade

7
Tamam, bu yüzden ödül sözüm hala geçerli, ancak ayrıntılı bir açıklama görmek istiyorum (kavramsal olarak bunun nasıl yapıldığını biliyorum, ancak detayları görmek istiyorum). Ayrıca en kısa yasal Retina cevabını ödül olarak vereceğim, bu yüzden millet, ödül hala daha kısa Retina cevaplarına açık!
Dijital Travma,

2
@AlexA. Hayır, çünkü başka bir Retina cevabı var.
Ismael Miguel,

38

Python, 49

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

Dize serpiştirmeyi kullanır.

Her iki taraftaki kareye kare karmaşık norm kullanmaktan daha kısa sürdü.

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

18
Ya Retina!da basmamız gerekiyordu Trash!! @ Rettaisnha retweet değil !!
Doktor,


2
@Mew ama bu tam tersi;)
Doktor

Güzel, (ab) 'in bir ya da başka bir diziyi basmak için kullandığını henüz görmedim
Nick T

15

Retina , 312 bayt

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

Bu çalıştırmak için biraz zaman alıyor, ancak iş gibi görünüyor.

Muhtemelen çok daha fazla golf oynayabilirdi ...

Açıklama:

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

Dize ayrıştırmayı daha uygun hale getirmek için etiketler ekleyin ve üs 1'e dönüştürmeyi kolaylaştırmak için önemsiz şeyler ekleyin ve daha sonra çoğalması için bir 300 ekleyin.

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

Çaprazın 0ondalık bölümünü tamsayı bölümüne eklerken genişliğe ve yüksekliğe s ekleyin . Bu yapıldığında, diyagonal bir tamsayı olacak ve genişlik ve yükseklik çoğuyla 10gerekli olacak şekilde çarpılacaktır .

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

İlk adımda eklediğim arama tablosunu kullanarak tüm sayıları taban 1'e dönüştürün

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

Tüm sayıları kareye hazırla

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

Her sayıyı kare

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

Köşegenin karesini, ilk adımda eklediğimiz 300'ün karesiyle çarpın

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

Yüksekliğe eklenen genişlik hesapladığımız ürüne uyuyorsa, piksel yoğunluğu çok düşük ve Çöp Kutusu!

.*0
Retina!

Aksi takdirde, Retina!



9

APL, 40 36 bayt

Dennis sayesinde 4 byte kurtarıldı!

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

Bu, soldaki ilk iki argümanı ve sağdaki üçüncü argümanı alan adsız bir ikili fonksiyon oluşturur. Soldaki değerlerin karelerinin toplamının, sağdaki değerin karesinin 300 ^ 2 katından büyük olup olmadığını kontrol eder. Çıktı buna göre yazdırılır.

Şunları yapabilirsiniz çevrimiçi denemek !


Göndermeden önce yenilenmiş olmalı ... Soldaki ilk iki argümanı alarak birkaç byte bayttan tasarruf edebilirsiniz.
Dennis,

@Dennis Yardımınız için teşekkürler! Sizinkini gördüğümde cevabımı silmeyi düşündüm çünkü seninki daha iyiydi. : P
Alex A.

9

TI-BASIC, 43

Ana ekrandan iki öğeli bir liste olarak genişlik ve yükseklik alır, Girdi ile çapraz kullanılır.

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

TI-BASIC'in iki baytlık küçük harfleri 7 bayt ekler ( ihayali birim, bir bayttır), bunun oldukça rekabetçi olmasına neden olur. Neyse ki, !aynı zamanda bir bayt, çünkü faktoring işlevini temsil ediyor.


9

JavaScript ES6, 49 bayt

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

JavaScript’in bu kadar uzun matematik operatörleri olmasından nefret ediyorum. Ancak bu olsa bile Math.pythagoreandaha kısa olurdu.


Olumsuz oylamayı açıklayan birileri var mı?
Downgoat

Muhtemelen çok uzun olduğu için.
lirtosiast

1
@ThomasKwa Python sadece 1 byte kısadır
Doktoru

5
Karekökü hesaplamak yerine, değerlerin karelerini karşılaştırırsanız daha kısa olabilir.
Reto Koradi

4
@RetoKoradi Evet, daha kısa:(w,h,d)=>w*w+h*h>9e4*d*d?'Retina!':'Trash!'
pepkin88

8

Excel, 44 bayt

Girişlerinizi bu hücrelere yazın.

  • A1 = Piksel cinsinden genişlik
  • B1 = Piksel cinsinden yükseklik
  • C1 = inç cinsinden çapraz

Ve bu formül sonucunu verir:

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

4
Bunun 9E4*C1^2yerine 2 byte'lık golf oynamaya çalıştım (300*C1)^2... bunun yerine 42 uzunluğu var. Ancak, 9E4Excel'de bir formül yazmak , 90000girdiğiniz anda değişecektir . :(
Ross Presser

7

Prolog, 51 bayt

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

Çalışan a(8192,4320,100.0,R).çıkışlar:R = "Trash!" .

Düzenleme: Bir kenar kasasını düzeltmek ve bir bayt golf oynamak için @PaulButcher sayesinde.


Yoğunluk 180 240 1 -> Trash!örnekten 300 (örn. ) Olduğunda, bu "Retina!" Döndürür . Neyse ki, e karakterli iki karakteri tıraş edebildiğiniz >için >=, onu 52'de bırakarak değiştirin :b(W,H,D,R):-9e4*D*D>=W*W+H*H,R="Trash!";R="Retina!".
Paul Butcher

@PaulButcher 90000 yerine 9e4 kullanmak aslında bir karakter değil, 2 karakter tıraş oluyor. Bu yüzden cevabımı bir bayt kadar kısalttın ve bu yeni olayı düzelttin, teşekkürler.
15'te

1
Aferin! Makul bir kısa Prolog örneği görmek güzel.
Paul Butcher,

Aslında kullanarak @PaulButcher Tıraşlı bir daha bayt <yerine >=... iki dize sonuçları ve takas
Fatalize

5

JavaScript (ES6), 45 bayt

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

CoffeeScript, 47 bayt

Üçlü operatör yok, ancak üstelik var (en son denemede yardımcı olmuyor).

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
Spesifikasyona göre, ( f=) adında bir işleve sahip olmak gerekli değildir . Tüm sürümlerde 2 bayt kesilebilir.
Kroltan


5

Saf Bash (bc / diğer harici komutlar yok), 138 136 135 82 83 bayt

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

Saf bash yapmayı denemeye karar verdim. Muhtemelen birkaç kez verimsizlikler verdim, çünkü bu benim ilk kez golf oynamak olan kodumdur, fakat ben çok fazla bash bilgisine sahibim ve geçmişte herhangi bir harici komut kullanmayan (yani saf bash) olmayan şeyler yazmaya çalışırken çok eğlendim.

Printf deyimi en can sıkıcıdır. Sıfırlamalı sayılarla ilgili daha iyi bir fikri olan var mı?

EDIT: İki bayt kaydedildi, printf'in sıfır için boş bir argüman alacağı ortaya çıktı. Başka bir bayt kaydedildi, daha önce yanlış saydığım ve sadece printf çıktısını bir değişkene atamak, -v kullanmaktan daha küçük çıktı.

EDIT2: Yorumlarda Digital Trauma sayesinde, bu şimdi çok daha önemli. Püf noktaları: bash'ın regex desteğini, sayıları değiştirmek yerine rakam dizisini sıfırlamak yerine kullanmak, ardından sıfır sayısını (bu şekilde koyduğum zaman ... bariz görünüyor) basmak, dizeleri bir ekoyu kaydetmek için bash dizisine koymak ve kurallardaki ufak bir değişikliği hesaba katarak, tüm giriş numaralarını .0 ile sonlandırabilirsiniz.

EDIT3: Digital Trauma'nın önerdiği değişiklik ile ortaya çıkan hatayı düzeltmek için bir bayt eklendi.


102 puan için buna benzer bir şey: a=${3#*.};d=${a/./0};((${#a}-${#3}))||d=;r=(Trash Retina);echo ${r[$1$d**2+$2$d**2>90000*${3/./}**2]}! ( ;yeni satırlarla değiştirebilirsin - sadece bir yorumda bulmaya çalışıyordum).
Dijital Travma

Eğer yoğunluğun tam sayıların biteceğini varsayarsanız .0(tamam sanırım) o zaman 82:a=${3#*.};d=${a/./0};r=(Trash Retina);echo ${r[$1$d**2+$2$d**2>90000*${3/./}**2]}!
Digital Trauma

Orijinal örnek, .0 ile bitmeyen bazılarına sahipti, ancak sorunun şu anda değiştirildiğini farkettim, bu yüzden biraz tasarruf sağlayacak. Fikirler için teşekkürler! Özellikle iki yankı ifadesini azaltma fikrinizi beğendim; Nasıl yapılacağını araştırmaya çalışıyordum, nedense dizi kullanmak benim başıma gelmedi! Bazı nedenlerden dolayı, benim de kullanabileceğim aklıma hiç gelmedi ** ... cevabınızı deneyeceğim ve doğrulayacağım, burada d $ 'nın nasıl çalıştığı konusunda biraz kafam karıştı ama bunu çözeceğim.
Muzer

$dÇok zor değil. aOndalık noktadan sonra yoğunluğun basamaklarını içerir. d=${a/./0}sadece tüm bu rakamları sıfırlarla değiştirir. Böylece bu sıfırları sonuna kadar birleştirebilir wve hondalık noktasını kaldırarak elde edilenle aynı güçle çarpabiliriz d.
Dijital Travma

1
Şerefe, bir dakikalığına delirdiğimi sanıyordum!
Muzer

4

dc, 41 bayt

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

d, w, hSırayla giriş yapılması gerekiyor - Umarım bu iyidir.

Test çıkışı:

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

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

Bu, üç sayısal değeri kabul eden ve bir dize döndüren bir işlev yaratır.

Formülün doğrudan bir uygulamasıdır, birazcık yeniden düzenlendi. Eşitsizliğin her iki tarafı da do zamanki kare ile çarpıldı .


3

R, 59 55 Bayt

Şimdi adsız bir işlev olarak

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

Endeks referanslarına olan ihtiyacı ortadan kaldıran çok basit bir uygulama.

Önceki

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

Oldukça basit, girdiyi taramadan bir vektöre alın (tek satır, boşlukla ayrılmış veya çoklu satır). Vektör kare. Hesaplamayı yap ve sonucu yakala.


3

MATLAB - 49 45 bayt

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

Öncelikle hücre dizisindeki 1. ve 2. konumlarda bulunan Trash!ve Retina!depolanan bir hücre dizisi bildirmek zorunda kaldım . Sonra, denklemi yeniden düzenlemek için birçok kişi tarafından gözlemlenen gözlemi kullanıyorum, böylece koşulu sadece tamsayı aritmetiğini kullanarak kontrol ediyorsunuz. 90000'ü, 9e4baytları kurtarmak için temsil ettim . Eğer bu koşul doğruysa, 1 çıktı, yoksa 0 çıktı veririz. Bu çıktıyı doğrudan hücre dizisine endekslemek için kullanırım. MATLAB 1'de endekslemeye başladığından, endekslemeyi tamamlamak için 1 eklemek zorunda kaldım. Güzel olan şey true, 1 ekleyerek 2 verirken false1 eklerken 1 verir. Bu ya Trash!da Retina!MATLAB komut isteminde verilecektir .

Örnek

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

ans =

Retina!

İhtiyacınız yok int8, true + 1 bir duble (2).
Jonas,

@Jonas Bunu denedim. MATLAB R2013a'da 2 olarak değişmezdi ... Garip.
rayryeng

@Jonas - Çalışması için logicalifadeyi parantez içine almak zorunda kaldım . Operasyon sırası ... Bahşiş için teşekkürler!
rayryeng

Güzel yaklaşım! (Denedim hypotama w*w+h*h>9e4*d*dseninki daha kısa). Ancak, bu soru gereksinimlerini karşılıyor mu? Bu bir program, fonksiyon değil. O almalı Yani w, hve dgirdi olarak. Bunun kod mücadelesinde her zamanki gibi olduğu gibi stdin olduğunu farz ediyorum
Luis Mendo

@LuisMendo ah bunu değiştirmek zorunda kalacağım! Thanks
rayryeng

3

XSLT, 400 bayt

Bu, PPCG'de daha önce hiç görülmemiş bir dilin başlangıcıdır ve daha fazla tanıdıkça gelecekte daha fazla kullanmayı umuyorum.

Kod:

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

Oldukça Basılı

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

Notlar:

XSLT'nin STDIN üzerinden giriş alma yolu olmadığı için, iki <input>etiket arasındaki girişi olan bir XML dosyası kullanmalıyız . Tabii ki, bu yöntemin sınırlamaları vardır, ancak çoğu zorluk için mükemmel çalışacaktır.

Örnek G / Ç

Giriş dosyası:

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

Çıktı dosyası:

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

Giriş dosyası:

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

Çıktı dosyası:

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

Birkaç diğerleri için kullandığınız hile ile 73'e bu kadar kısaltabilir formülü yeniden yazmak ve sqrt işlemini kaldırın: string D(int w,int h,double d){return w*w+h*h>9e4*d*d?"Retina":"Trash";}. Ama ayrıca !her bir dizgeye eklemeniz gerekir, böylece 75'e geri dönebilirim.
goric 15

2

Swift, 77 bayt

İşlev parametresi bildirimleri, bunun olması gerekenden çok daha fazla karakter gerektirdiği anlamına gelir:

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


2

Swift, 56 bayt

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

Temelde GoatInTheMachine ile aynı ancak kapalı kapatma parametreleri var.

Swift ile Code Golfing, her zaman böyle yöntemleri açıklarsanız, çok daha kısadır


2

Haskell, 46

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

Hangi Haskell sistemi kullanılmalı? Verdiğim ghci sürümüyle çalışmıyor, vererek <interactive>:2:8: parse error on input '|'.
Ed Avis

@EdAvis: GHCi programları çalıştırmaz; orada denemek için ihtiyacınız var let f w h d|….
Ry

2

C ++ 72 70 Bayt

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

Diğer çözümlere benzer, kod golf ile ısınmak için kendimi buldum.


1
Sen yazarak birkaç tıraş 90000olarak9e4
Toby Speight

2

İşte bu soruna benim katkım

Ruby, 67 byte stdin'den okuma yapıyor

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

Ruby, bir fonksiyonda 56 bayt

Biraz daha kısa

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

9e4 için önceki katılımcılara teşekkürler!


2

Bash, 85 bayt

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

1
Bu "3000 1500 11.18" için çalışmıyor. Varsayılan olarak, bckesinliği 0 ondalık basamaktır. Belirlemeniz gerekecek scaleveya muhtemelen bc -lölçeği 20'ye ayarlayan ölçeklerden kurtulabilirsiniz
Digital Trauma,

Tamam, cevabımı güncelledim. Teşekkürler!
addison,

1
Oh ve codegolf.stackexchange.com/questions/15279/… adresini ziyaret edin . Örneğin((`bc<<<"sqrt($1^2+$2^2)/$3"`>300))&&echo Retina!||echo Trash!
Dijital Travma,

2

PHP, 47,43,40 38 bayt

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

Gerektirir register_globals==true(ki asla olmamalı!), GET değerleri w, h, d
- Dize tırnak işaretleri kaldırarak kaydedildi 4 bayt. Kötü kodlama, ancak çalışıyor.
- dDenklemin diğer tarafına taşınan ve karekökü, sqrt()işlevini kaydederek
- Geçiş 2 bayt kaydetti hypot()(teşekkür ederim Lucas Costa)


Sadece bunun bir PHP4.1 cevabı olduğunu söylemeniz ve register_globalsyönergeye gerek duymamanız gerekir .
Ismael Miguel,

2
Her iki seçenek de aynı derecede kötü haha
Martijn

2

C # 6, 67 Bayt

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

Bu cevap Wolfsheads'ın cevabına dayanıyor. C # 6'nın yeni bir özelliğini kullanarak 8 bayt daha kısa yaptım.


2

JavaScript (ES6) 58 54 43 Bayt

43 Bayt

Kaldırılan işlev ataması (PPCG kurallarına göre) (-2), ayrıca kare kökü kaldırmak ve 900 (300 ^ 2) (-12) ile karşılaştırmak

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

54 Bayt

Unnessesary parantezlerden kurtuldu (-4 bayt)

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

58 Bayt

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

Burada açıklama:

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

Bu , yoğunluğu test etmek için üçlü operatörleri kullanır ve ok işlevlerini kullanarak birkaç baytı öldürür


1
Bunu, karekökten kaçınarak ve bunun yerine değerlerin karelerini karşılaştırarak kısaltabilirsiniz.
Reto Koradi

1

Java, 82 74 bayt

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

İle ara g(width,height,diagonal)


1
Bu doublegibi pahalı String g(int w,int h,double x){return 9e4*x*x>w*w+h*h?"Trash!":"Retina!";}
dizilerden kurtularak bunu azaltabilirsiniz

@Geobits Teşekkürler, iki yaklaşımdaki baytları bütçelemek için zaman ayırmamıştım, yine de yakaladığınıza sevindim!
DeadChex

1

Clojure, 58 bayt

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

@ Kroltan'ın süslü matematiği, bunu kısaltmak için kullanıldı. (W, h, d) sırasına göre verilen argümanları kullanır.

İlk Clojure golf ... Ne kadar boşluk bırakabildiğime şaşırdım

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.