망막 또는 쓰레기?


47

우리는 멋진 기술 시대에 살고 있으며 TV에서 8K 화면을 아름답게 자세히 볼 수 있으며 휴대 전화에서 2K 디스플레이를 사용하여 모바일 탐색의 즐거움을 누릴 수 있습니다. 우리는 최근 몇 년 동안 화면 기술 측면에서 먼 길을 왔습니다.

이것의 제품 중 하나는 Apple, Retina 가 대중적으로 만든 용어입니다 . 이것은 해당 디스플레이 의 픽셀 밀도 가 너무 높아서 10-12 인치 떨어진 시거리에서 개별 픽셀을 쉽게 선택할 수 없다는 것을 의미합니다.

Steve Jobs는 이것이 발생하는 픽셀 밀도 는 인치당 300 픽셀 정도 라고 광고에 사용되는 Retina 버즈 워드를 사용 하여 장치에서이 범위의 픽셀 밀도를 사용하기 시작했습니다 .

픽셀 밀도는 다음 공식으로 계산할 수 있습니다.

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

여기서 d인치 스크린의 대각선이고, w수평축의 화소의 수를 나타내고, h세로축의 화소 수이다.

당신의 작업

이 작업에서는 Retina 표준을 사용하여 구매할 가치가있는 제품을 결정합니다. 현대의 소비자이기 때문에 장치를 구입할 때 90 년대의 일부 장치가 아닌 좋은 제품을 얻고 자합니다! 따라서 화면 너비, 높이 및 대각선 길이를 입력 또는 함수 매개 변수 로 사용하고 화면 에 인쇄하거나을 반환 하여 특정 화면이 망막 화면 ( )으로 적합한 지 여부를 알려주 는 프로그램 또는 기능 을 구축하려고 합니다 .D > 300

Retina 이외의 장치에 대한 경멸로 인해 장치 또는Retina! 장치가 자격을 갖추 Trash!었을 때 와 그렇지 않은 경우 프로그램이나 기능 이 출력 됩니다 .

모든 숫자가 0보다 크다고 가정 할 수 있습니다. 너비와 높이의 픽셀 값은 항상 정수입니다. 화면 크기는 소수를 지원하는 한 어떤 식 으로든 해석 될 수 있습니다. 입력은 원하는 순서대로 입력 할 수 있으며 최대 3 개의 개별 라인에있을 수도 있습니다.

예제 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!

이것은 이므로 가장 적은 수의 바이트가 이깁니다.


다음은 스택 기반 프로그래밍 언어 인 Stuck 솔루션입니다.

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

34
누군가, 제발, Retina 답변을 하세요
Digital Trauma

2
@DigitalTrauma하지만 뜬다.
Sp3000

7
@ Sp3000 pfft, 변명!. Retina에서 자신의 플로트 파싱 정규식을 만드십시오!
Optimizer

46
@ Sp3000 좋아, 스테이크를 올릴 수 있습니다. 본인은이 코멘트 게시 타임 스탬프에서 1 주일 동안이 질문에 대한 가장 짧은 합법적 (커뮤니티 합의) Retina 답변에 대해 육즙이 많은 500pt 현상금을기로 약속합니다.
디지털 외상

2
흠, 선택한 임계 값은 애플의 마케팅과 맞지 않습니다 (예 : Retina iMac) : 5120 2880 27
Ed Avis

답변:



115

망막 , 530 220 210 202 201 193 191 187 185 (184) 바이트

3 바이트 절약을위한 randomra의 크레딧! (그리고 몇 가지 더 길을 포장합니다.)

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

바이트 수 계산을 위해 각 줄은 별도의 파일로 이동하지만 -s플래그 와 함께 Retina를 호출하여 단일 파일에서와 같이 위의 코드를 실행할 수 있습니다 .

이것은 밀도가 먼저 ( 후행이더라도 소수점을 포함 해야 함) 예상하고 너비와 높이가 뒤 따릅니다 d w h.

이것은이다 조금 느린. 주어진 테스트 사례를 대부분 시도하지는 않을 것입니다. 그러나 테스트 사례에서 올바르게 작동하는지 확인할 수 있습니다

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

기본적으로 밀도를 정수로 만들기 위해 모든 숫자를 곱한 후에는 너비와 높이가 4 자리를 초과하지 않기를 원합니다.

이것은 느리지 만 완전히 정확합니다 ... 부동 소수점 문제 또는 이와 유사한 것은 없습니다. 모든 산술은 (단항) 정수를 사용합니다.

원칙적으로, 나는 더 많은 바이트를 삭감 ^할 수 있습니다 : 생략 할 수는 있지만 Trash!과도한 역 추적으로 인해 테스트 사례가 엄청나게 느려질 것입니다.

설명

먼저 부동 소수점 연산을 피하기 위해 불평등을 재정렬 해 보겠습니다.

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

우리는 또한이 불변 증식중인 것을 알 수 있습니다 w, h그리고 d같은 번호로 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

단항 수를 제곱하는 몇 가지 방법이 있지만, 우리는 정체성을 활용할 것입니다

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

이것은 정수 산술 (단항으로 정수를 나타냄) 만 사용하여 문제를 해결할 수있는 방법을 제공합니다.

코드를 살펴 봅시다. 각 라인 쌍은 정규식 대체입니다.

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

이렇게하면 밀도의 소수점이 오른쪽으로 반복 이동하면서 너비와 높이에 10을 곱합니다 ( x위). 이것은 모든 숫자가 정수가되도록하기위한 것입니다. 0을 추가하는 대신을 추가 _하고 있습니다. 나중에 0으로 처리합니다. (이것은 골프 트릭입니다. 그렇지 않으면 ...${3}0에 대한 모호함을 피하기 위해 작성해야합니다 $30.) +정규 표현식 앞에는 Retina가 결과가 더 이상 변경되지 않을 때 까지이 대체를 반복하도록 지시합니다 (패턴이 더 이상 일치하지 않는 경우) .

\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#

이것은 dan1111에 의해 개발 된 트릭을 사용하여 단항으로 변환합니다 . 기본적으로 각 숫자를 자체의 대표 숫자로 변환하고 기존 숫자에 10을 곱합니다 ( #마커를 프로세스의 오른쪽으로 이동 ). 이 이진 표현은 다른 숫자로 뒤죽박죽이 될 것이지만 총 수는 원래 정수 값과 같습니다. 주 \w말에 - 일반적으로 이것은 단지입니다 0,하지만 우리가 치료하고자하는 _(단어 정규식의 문자로 간주되는)뿐만 아니라 0으로.

\d
11

우리는 각 숫자를 두 개의 숫자로 바꾸어 1a) 모든 숫자가 같은지 확인하고 (나중에 필요할 것임) b) 각 숫자를 두 배로 늘립니다.

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

이것은 두 가지 일을합니다 : 그것은 모든 수의 제곱 (또는 합을 계산하여 각 숫자의 절반 2n)과 너비와 높이의 결과 제곱을 더합니다. 공지 사항이 [^.]일치 1의, #마커와 공간. 그것이 #공간이거나 공간이라면, lookahead는 아무것도 포착하지 못합니다. 즉, 모든 것이 단순히 제거됩니다. 즉 너비와 높이에 대한 결과가 연결 / 추가됩니다. 소수점 .은 결과와 분리됩니다 d. 만약 [^.]일치하는 1대신, 다음 내다 것을 보장의 우리 캡처 절반 1의 IT (둥근 아래) 그룹의 후 1. 이것은 위에서 언급 한 합계를 계산하여 원래 숫자의 제곱을 산출합니다.

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

문자열은 이제 (단항으로), 그 다음에 (단항으로)입니다. 첫 번째 단항 수가 두 번째보다 짧은 지 알고 싶습니다 . 캡처 그룹과 반복 구문을 사용하여이 곱셈을 쉽게 수행 할 수 있습니다 . 우리 는 두 번째 숫자가 실제로 그것 보다 크고 같지 않도록하기 위해 이후에 (대신에 )를 사용합니다 . 그렇다면 모든 것을로 대체합니다 .d2.w2 + h290000{n}1+1*Retina!

1.+
Trash!

두 번째 숫자가 충분히 크지 않으면 이전 단계에서 아무것도 변경되지 않았고 문자열은 여전히로 시작합니다 1. 이 경우 전체 문자열을 바꾸고 Trash!완료합니다.


24
글쎄요. 이제 우리는 모두 행복하게 죽을 수 있습니다.
Alex A.

94
참고로, 이것은 Retina이기 때문에 다른 모든 답변을 쓰레기로 만들 수 있습니까?
Alex A.

5
우리 신이 도착했습니다!
Kade

7
그래, 현상금 약속은 여전히 ​​유효하지만, 나는 철저한 설명을 원합니다 (개념적으로 나는 그것이 어떻게되었는지 알고 있지만 세부 사항을보고 싶다고 생각합니다). 또한 나는 가장 짧은 합법적 인 Retina 답변에 현상금을 수여 할 것입니다. 여러분, 현상금은 여전히 ​​더 짧은 Retina 답변에 열려 있습니다!
디지털 외상

2
@AlexA. 아니요, 다른 Retina 답변이 있기 때문입니다.
Ismael Miguel

38

파이썬, 49

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

문자열 인터리빙을 사용합니다.

복잡한 표준을 사용하는 것보다 양면이 제곱되는 것이 더 짧았습니다.

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

18
우리는 중 하나를 인쇄하기로했다 Retina!Trash!! 트윗 담아 가기
Optimizer


2
@Mew 그러나 그것은 반대입니다;)
Optimizer

니스, 나는 하나 또는 다른 문자열을 인쇄하는 데 사용하는 것을 아직 보지 못했습니다.
Nick T

15

레티 나 312 바이트

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

실행하는 데 시간이 오래 걸리지 만 작동하는 것 같습니다.

아마 더 많은 골프를 쳤을 것입니다 ...

설명:

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

문자열을 구문 분석하기에 더 편리하게하기 위해 태그를 추가하고, 밑줄 1을 쉽게 변환 할 수 있도록 정크를 추가하고 나중에 곱하기 위해 300을 추가하십시오.

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

0너비와 높이에 s를 추가 하고 대각선의 소수점 부분을 정수 부분에 추가합니다. 이 작업이 완료되면 대각선이 정수가되고 너비와 높이에 곱하기 10가 필요 하지만 많은 값이 필요합니다.

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

첫 번째 단계에서 추가 한 조회 테이블을 사용하여 모든 숫자를 밑수 1로 변환

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

모든 숫자의 제곱을 준비하십시오

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

각 숫자의 제곱

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

대각선의 제곱에 첫 번째 단계에서 삽입 한 300의 제곱을 곱하십시오.

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

높이에 추가 된 너비가 방금 계산 한 제품에 맞으면 픽셀 밀도가 너무 낮아 휴지통입니다.

.*0
Retina!

그렇지 않으면 Retina입니다!



9

APL, 40 36 바이트

Dennis 덕분에 4 바이트를 절약했습니다!

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

이렇게하면 이름이없는 2 차원 함수가 만들어져 왼쪽의 첫 번째 두 인수와 오른쪽의 세 번째 인수가 사용됩니다. 왼쪽 값의 제곱의 합이 오른쪽 값의 제곱의 300 ^ 2 배보다 큰지 확인합니다. 그에 따라 출력이 인쇄됩니다.

당신은 할 수 있습니다 온라인으로보십시오 !


게시하기 전에 새로 고쳐야합니다 ... 왼쪽의 처음 두 인수를 사용하여 몇 바이트 바이트를 저장할 수 있습니다.
Dennis

@Dennis 도와 주셔서 감사합니다! 당신이 더 좋았 기 때문에 당신을 보았을 때 내 대답을 삭제하는 것을 고려했습니다. : P
Alex A.

9

TI-BASIC, 43

홈 화면을 통해 두 요소 목록으로 너비와 높이를 가져오고 입력을 통해 대각선으로 가져옵니다.

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

TI-BASIC의 2 바이트 소문자는 7 바이트 ( i가상 단위 인 1 바이트)를 추가하여 경쟁이 치열합니다. 고맙게도, !그것은 계승 함수를 나타 내기 때문에 1 바이트입니다.


9

자바 스크립트 ES6, 49 바이트

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

JavaScript에는 긴 수학 연산자가 있다는 것이 싫어. 그러나 이것이 있었더라도 Math.pythagorean더 짧을 것입니다.


downvote를 설명하는 사람이 있습니까?
Downgoat

아마도 너무 길었을 것입니다.
lirtosiast

1
@ThomasKwa Python은 1 바이트 더 짧습니다
Optimizer

5
제곱근을 계산하는 대신 값의 제곱을 비교하면 짧을 수 있습니다.
Reto Koradi

4
@RetoKoradi 네, 더 짧습니다 :(w,h,d)=>w*w+h*h>9e4*d*d?'Retina!':'Trash!'
pepkin88

8

엑셀, 44 바이트

이 셀에 입력 내용을 입력하십시오.

  • A1 = 픽셀 너비
  • B1 = 픽셀 높이
  • C1 = 인치 단위의 대각선

그리고이 수식은 결과를 제공합니다.

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

4
입력 9E4*C1^2하지 않고 2 바이트를 골프화하려고 시도했지만 (300*C1)^2길이는 42입니다. 그러나 9E4Excel에서 수식을 90000입력하면 Enter 키를 누르 자마자 변경됩니다 . :(
Ross Presser

7

프롤로그, 51 바이트

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

a(8192,4320,100.0,R).출력을 실행 :R = "Trash!" .

편집 : 엣지 케이스를 수정하고 1 바이트 골프를하는 @PaulButcher에게 감사드립니다.


이 예 180 240 1 -> Trash!에서 밀도가 300 (예 :)이면 "Retina!"를 반환합니다 . 다행스럽게도 e 표기법을 사용하여 두 문자를 깎을 수 있기 때문에 52 >쪽으로 >=b(W,H,D,R):-9e4*D*D>=W*W+H*H,R="Trash!";R="Retina!".
Paul Butcher

@PaulButcher 90000 대신 9e4를 사용하면 실제로는 1자가 아니라 2자가 줄어 듭니다. 그래서 당신은 효과적으로 1 바이트만큼 내 대답을 단축 하고이 경우를 수정했습니다. 감사합니다.
페이탈 라이즈

1
잘 했어! 합리적으로 짧은 프롤로그 예제를 보는 것이 좋습니다.
Paul Butcher

@PaulButcher 실제로 두 문자열 결과 <대신에를 사용하여 하나의 바이트를 더 면도했습니다 >=.
Fatalize

5

자바 스크립트 (ES6), 45 바이트

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

CoffeeScript, 47 바이트

삼항 연산자는 없지만 지수가 있습니다 (최근 시도에는 도움이되지 않음).

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
사양에 따라 ( f=) 라는 함수를 가질 필요는 없습니다 . 모든 버전에서 2 바이트를 차단할 수 있습니다.
Kroltan


5

순수 배시 (NO BC / 다른 외부 명령), 138 (136) 135 82 83 바이트

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

나는 순수한 배쉬에서 그것을하기로 결정했다. 이것이 처음으로 코드 골프이기 때문에 아마도 몇 가지 명백한 비효율을했을 것입니다.

printf 문이 가장 성가신 것입니다. 누구든지 0으로 숫자를 채우는 데 더 좋은 아이디어가 있습니까?

편집 : 2 바이트를 저장하면 printf는 빈 인수를 0으로합니다. 다른 바이트를 저장하면 이전에 잘못 계산 한 것으로 나타 났으며 printf의 출력을 변수에 할당하는 것이 -v를 사용하는 것보다 작습니다.

EDIT2 : 의견에 Digital Trauma 덕분에 이제 훨씬 더 크게 떨어졌습니다. 트릭 : bash의 정규식 지원을 사용하여 숫자 문자열을 세는 대신 0으로 바꾸고 그 숫자를 0으로 인쇄하고 (그렇게하면 분명히 보입니다 ...) 문자열을 bash 배열에 저장하여 에코를 저장합니다. 규칙의 약간의 변경을 고려하면 모든 입력 번호를 .0으로 끝낼 수 있습니다.

EDIT3 : Digital Trauma의 제안 된 수정으로 인한 버그를 수정하기위한 바이트가 추가되었습니다.


102 점에 대해 이와 같은 것 : a=${3#*.};d=${a/./0};((${#a}-${#3}))||d=;r=(Trash Retina);echo ${r[$1$d**2+$2$d**2>90000*${3/./}**2]}! (당신은 줄 ;바꿈으로 바꿀 수 있습니다 -방금 주석에 넣으려고했습니다).
디지털 외상

당신이 밀도 전체 숫자에 종료됩니다 가정한다면 .0: (좋아, 내가 생각하는) 당신은 82 득점 수a=${3#*.};d=${a/./0};r=(Trash Retina);echo ${r[$1$d**2+$2$d**2>90000*${3/./}**2]}!
디지털 외상

원래 예제에는 .0으로 끝나지 않은 일부가 있었지만 질문이 수정 된 것을 알았으므로 상당히 절약 할 수 있습니다. 아이디어 주셔서 감사합니다! 나는 특히 두 개의 반향 문을 줄이는 아이디어를 좋아한다. 나는 그것을하는 방법을 연구하려고했지만 어떤 이유로 든 배열을 사용하는 것이 발생하지 않았습니다! 어떤 이유로 든, 당신이 **를 사용할 수 있다는 것도 나에게 결코 발생하지 않았습니다. 나는 대답을 확인하고 시도 할 것입니다. $ d가 어떻게 작동하는지 조금 혼란 스럽지만 알아 낼 것입니다.
Muzer

$d너무 까다로운 없습니다. a소수점 뒤의 밀도 자릿수가 포함됩니다. d=${a/./0}모든 숫자를 0으로 바꿉니다. 따라서 우리는 소수점을 제거함으로써 달성되는 10의 거듭 제곱 w과 그 끝에 0을 h곱하고 곱할 수 있습니다 d.
디지털 외상

1
건배, 나는 내가 잠시 화를 내고 있다고 생각했다!
Muzer

4

dc, 41 바이트

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

args를 d, w, h순서대로 입력해야합니다 -이것이 좋기를 바랍니다.

테스트 출력 :

$ 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

줄리아, 46 45 42 바이트

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

세 개의 숫자 값을 받아들이고 문자열을 반환하는 함수를 만듭니다.

공식을 직접 구현 한 것으로 조금 재정렬되었습니다. 불평등의 양쪽에 곱한 d다음 제곱했습니다.


3

R, 59 55 바이트

명명되지 않은 기능으로

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

매우 간단한 구현으로 인덱스 참조가 필요하지 않습니다.

이전

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

상당히 간단합니다. 스캔에서 벡터로 입력을 가져옵니다 (한 줄, 공백 또는 여러 줄). 벡터를 제곱합니다. 계산을 수행하고 결과를 표시하십시오.


3

MATLAB- 49 45 바이트

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

먼저 셀 배열의 위치 1과 2에 저장 되어 Trash!있고 포함하는 셀 배열을 선언해야했습니다 Retina!. 다음으로, 많은 사람들이 관찰 한 관측 값을 사용하여 방정식을 재정렬하여 정수 산술 만 사용하여 조건을 확인합니다. 9e4일부 바이트를 절약하기 위해 90000을 나타 냈습니다 . 이 조건이 true이면 1을 출력하고 그렇지 않으면 0을 출력합니다.이 출력을 사용하여 셀형 배열에 직접 색인을 생성합니다. MATLAB은 1에서 인덱싱을 시작하기 때문에 인덱싱을 완료하려면 1을 추가해야했습니다. 어떤 좋은 것은 추가하는 것입니다 true추가하는 동안 1로하면, 2를 제공 false1로하면 1이 출력됩니다 중 하나를 제공 Trash!하거나 Retina!프롬프트 MATLAB 명령에.

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

ans =

Retina!

필요하지 않습니다 int8. true + 1은 double (2)입니다.
Jonas

@Jonas 나는 그것을 시도했다. MATLAB R2013a ... 2에서는 2로 변경되지 않습니다.
rayryeng-복원 모니카

@Jonas- logical표현식을 괄호로 묶어야 작동했습니다. 작업 순서 ... d' oh. 팁 고마워!
rayryeng-복원 모니카

좋은 접근 방식! (나는 노력 hypot했지만 당신 w*w+h*h>9e4*d*d은 더 짧습니다). 그러나 이것이 질문 요구 사항을 충족합니까? 기능이 아니라 프로그램입니다. 그것은해야 그래서 w, hd입력으로합니다. 코드 챌린지에서 평소와 같이 stdin을 의미한다고 가정합니다.
Luis Mendo

@LuisMendo 아 그것을 변경해야합니다! 고마워
rayryeng-복원 모니카

3

XSLT, 400 바이트

이것은 PPCG에서 볼 수 없었던 언어의 데뷔이며 앞으로 더 많이 알기 위해 앞으로 더 많이 사용할 수 있기를 바랍니다.

암호:

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

예쁜 인쇄

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

노트:

XSLT는 STDIN을 통해 입력을받을 방법이 없으므로 두 <input>태그 사이에 입력이있는 XML 파일을 사용해야 합니다. 물론이 방법에는 한계가 있지만 대부분의 문제에 완벽하게 작동합니다.

예제 I / O

입력 파일:

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

결과물 파일:

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

입력 파일:

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

결과물 파일:

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

언 골프 드 :

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

다른 사람들이 공식을 다시 작성하고 sqrt 연산을 제거하는 데 사용한 트릭으로 이것을 최대 73까지 줄일 수 있습니다 string D(int w,int h,double d){return w*w+h*h>9e4*d*d?"Retina":"Trash";}. 그러나 !각 문자열 에 추가해야 하므로 75로 돌아갑니다.
goric

2

스위프트, 77 바이트

함수 매개 변수 감소는 다음보다 많은 문자를 차지합니다.

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


2

스위프트, 56 바이트

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

기본적으로 GoatInTheMachine 과 동일 하지만 암시 적 클로저 매개 변수

Swift로 코드 골프를 할 때 항상 이와 같은 방법을 선언하면 훨씬 짧습니다.


2

하스켈, 46

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

어떤 Haskell 시스템을 사용해야합니까? 내가 시도한 ghci 버전에서는 작동하지 않습니다 <interactive>:2:8: parse error on input '|'.
Ed Avis

@EdAvis : GHCi는 프로그램을 실행하지 않습니다. 거기에서 시도하려면 let f w h d|….
Ry-

2

C ++ 72 70 바이트

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

다른 솔루션과 비슷한 코드 골프로 몸을 따뜻하게 할 수 있다고 생각했습니다.


1
당신은 서면으로 몇 면도 수 900009e4
토비 Speight

2

이 문제에 대한 나의 기여는 다음과 같습니다.

루비, stdin에서 읽은 67 바이트

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

루비, 함수에서 56 바이트

조금 더 짧은

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

9e4의 기고자들에게 감사합니다!


2

배쉬, 85 바이트

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

1
"3000 1500 11.18"에서는 작동하지 않습니다. 기본적으로 bc의 정밀도는 소수점 이하 0 자리입니다. 을 설정해야 scale하거나, 또는 bc -l암시 적으로 스케일을 20으로 설정하는 것을 피할 수 있습니다.
Digital Trauma

오, 나는 대답을 업데이트했다. 감사!
addison

1
아, codegolf.stackexchange.com/questions/15279/…를 확인하십시오 . 예를 들어((`bc<<<"sqrt($1^2+$2^2)/$3"`>300))&&echo Retina!||echo Trash!
Digital Trauma

2

PHP, 47,43,40 38 바이트

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

register_globals==trueGET 값이 w, h, d 인 필수 항목 ( 필수 없음 )
-문자열 주위의 따옴표를 제거하여 4 바이트를 절약했습니다. 나쁜 코딩이지만 작동합니다.
- d방정식의 반대편으로 이동 하고 제곱근을 돌려 sqrt()함수를 저장합니다
-로 전환하여 2 바이트를 절약 했습니다 hypot()(감사합니다 Lucas Costa).


이것은 PHP4.1 답변이라고 register_globals지시 해야하며 지시문을 설정할 필요가 없습니다 .
Ismael Miguel

2
어느 옵션이든 나쁜 하하입니다
Martijn

2

C # 6, 67 바이트

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

이 답변은 Wolfsheads 답변을 기반으로합니다. C # 6의 새로운 기능을 사용하여 8 바이트 더 짧게 만들었습니다.


2

자바 스크립트 (ES6) 58 54 43 바이트

43 바이트

기능 할당 제거 (PPCG 규칙에 따라) (-2), 제곱근 제거 및 900 (300 ^ 2) (-12)과 비교

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

54 바이트

불필요한 괄호를 제거했습니다 (-4 바이트)

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

58 바이트

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

여기에 설명 :

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

이것은 삼항 연산자 를 사용하여 밀도를 테스트하고 화살표 함수 를 사용하여 몇 바이트를 죽입니다.


1
제곱근을 피하고 대신 값의 제곱을 비교하여 더 짧게 만들 수 있습니다.
Reto Koradi

1

자바, 82 74 바이트

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

전화 해 g(width,height,diagonal)


1
다음 double과 같은 고가의 배열을 제거하여이를 줄일 수 있습니다 . String g(int w,int h,double x){return 9e4*x*x>w*w+h*h?"Trash!":"Retina!";}때로는 가장 간단합니다. :)
Geobits

@ Geobits 감사합니다, 나는 두 가지 접근 방식으로 바이트를 계산하는 데 시간이 걸리지 않았습니다.
DeadChex

1

클로저, 58 바이트

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

@Kroltan의 멋진 수학을 사용하여 이것을 단축했습니다. (w, h, d) 순서로 전달 된 암시 적 인수를 사용합니다.

첫 Clojure 골프 ... 나는 얼마나 많은 공백을 남겨 둘 수 있는지 놀랐습니다.

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.