비슷한 인물

변의 비율 이 동일 하면 두 개의 사각형이 비슷 합니다.

이 두 직사각형을 고려하십시오. 높이가 5 줄, 폭이 11자인 직사각형 :

===========
===========
===========
===========
===========

높이가 10 줄, 폭이 22자인 직사각형 :

======================
======================
======================
======================
======================
======================
======================
======================
======================
======================

측면의 비율이 동일하기 때문에 이러한 모양은 비슷합니다. 공식적으로 ( 는 가장 짧은 쪽이고 는 가장 긴 쪽) :$h$$w$

당신은 또한 할 수 있습니다 :

도전

"주"사각형과 일부 "기타"사각형을 사용하고 "기타"중 "주"와 유사한 인쇄 또는 인쇄하는 프로그램이나 함수를 작성하십시오.

입력

모양과 모양 목록. 각 모양은 사각형의 너비와 높이를 나타내는 0이 아닌 양의 정수로 구성됩니다. 예를 들어,

(4,2), (3,9)

는 4x2와 3x9의 두 사각형을 나타냅니다. 그러나 입력의 정확한 형식은 원할 수 있습니다.

출력

"기본"과 유사한 "기타"모양의 인덱스입니다. 인덱스의 정확한 형식과 순서뿐만 아니라 인덱스가 0 또는 1을 기준으로할지 선택할 수 있습니다.

샘플 프로그램

파이썬에서 :

main = eval(raw_input()) # The main rectangle.
rects = eval(raw_input()) # The list of rectangles.
similar = set()
for i, rect in enumerate(rects):
    if max(main)*min(rect) == min(main)*max(rect): # Cross-multiply
        # They are similar.
        similar.add(i)

print similar

샘플 입력 및 출력

입력:

(1, 2)
[(1, 2), (2, 4)]

산출:

set([0, 1])

입력:

(1, 2)
[(1, 9), (2, 5), (16, 8)]

산출:

set([2])

승리

이것은 코드 골프이므로 가장 짧은 제출이 이깁니다.

노트

• 말할 필요도 없지만 표준 허점은 금지되어 있습니다.
• 유사한 수치를 찾기위한 내장을 사용할 수 없습니다. (존재하는지도 모르겠지만 놀라지 않을 것입니다!)

Pyth, 15 바이트

fqcFS@QTcFSvzUQ

파이썬, 61 바이트

lambda a,b,l:[i for i,(x,y)in enumerate(l)if x/y in[a/b,b/a]]

예, 9 문자를 쓰는 데 쓰고 enumerate있습니다. 같은 입력을 1, 2, [(1, 9), (3,6), (2, 5), (16, 8)]받습니다. Python 2의 경우 입력 값을 부동 소수점으로 작성해야합니다.

파이썬 3에서 한 문자 이상 (62) :

def f(a,b,l,i=0):
 for x,y in l:b/a!=x/y!=a/b or print(i);i+=1

CJam, 22 20 19 바이트

{:$::/_0=f=ee::*0-}

위의 함수는 스택에서 부동 소수점 쌍의 단일 배열 (첫 번째 쌍은 needle)을 팝하고 그 결과 1 기반 인덱스 배열을 푸시하는 익명 함수입니다.

CJam 통역사 에서 온라인으로 사용해보십시오 .

작동 원리

:$                e# Sort each pair.
  ::/             e# [a b] -> a/b
     _0=          e# Push a copy of the array and extract the first float (needle).
        f=        e# Check which floats are equal to the needle.
          ee      e# Enumerate the resulting Booleans.
            ::*   e# Multiply each Boolean by its index.
                  e# This yields 0 for the needle (index 0) and for non-matching
                  e# haystack pairs (Boolean 0).
               0- e# Remove all zeroes from the array.

하스켈 , 48 바이트

(a!b)l=[i|(i,(x,y))<-zip[0..]l,x/y+y/x==a/b+b/a]

온라인으로 사용해보십시오!

이것을 다음과 같이 호출하십시오 (!) 1 2 [(1, 9), (3,6), (2, 5), (16, 8)].

내 파이썬 답변의 포트 근처 . 이 표현식 zip[0..]l은 목록을 색인으로 열거합니다.

이 함수 는 함수에 다른 충돌이 없으므로 x/y+y/x==a/b+b/a비율 x/y이 a/b또는인지 확인합니다 .b/af(z) = z + 1/zf(z) = f(1/z)

눈사람 1.0.2 , 61 문자

}vgvgaC"[0-9]+"sM:10sB;aM2aG:AsO:nD;aF;aM0AAgaA*|:#eQ;AsItSsP

순전히 횡설수설 (눈사람을 알지 않는 한), 가능한 한 혼란스러운 언어의 디자인 목표와 정확히 일치 합니다.

출력 포맷이 동일한 마이너스 소식과 입력 형식은 동일 set(하고 ).

Ungolfed (또는 실제로 축소되지 않은) :

}vgvgaC     // read two lines of input, concatenate
"[0-9]+"sM  // use a regex to grab all numbers
:10sB;aM    // essentially map(parseInt)
2aG         // take groups of 2 (i.e. all the ordered pairs)

// now map over each ordered pair...
:
  AsO       // sort
  :nD;aF    // fold with division - with 2 array elements, this is just a[0]/a[1]
;aM

// we now have an array of short side to long side ratios
// take out the first one
0AAgaA      // active vars beg, b=array[0], g=the rest
*|          // store first ordered pair in permavar, bring the rest to top

// select indices where...
:
  #         // retrieve first ordered pair
  eQ        // equal?
;AsI

tSsP  // to-string and output

나는 이것에 사용한 몇 가지 트릭을 매우 자랑스럽게 생각합니다.

• 게시물에서와 동일한 입력 형식을 사용했습니다. 그러나 어쨌든 그것을 어쨌든 파싱하려고하는 대신, 실제로 두 줄을 연결하고 정규 표현식을 사용하여 모든 숫자를 하나의 큰 배열로 추출했습니다 ( 2aG즉, 내가 한 모든 그룹을 얻습니다).

• :nD;aF꽤 멋지다. 단순히 두 요소의 배열을 취하고 첫 번째 요소를 두 번째 요소로 나눕니다. 이것은 매우 단순 해 보이지만 직관적 인 방법 ( a[0]/a[1])은 눈사람에서 훨씬 길어질 것입니다 0aa`NiN`aA|,nD. 대신 "fold"메소드를 "divide"라는 술어와 함께 사용하여 두 요소의 배열에 대해 동일한 것을 달성했습니다.

• 0AAgaA충분히 무해 해 보이지만 실제로는 0변수에 a 를 저장 한 다음 인덱스보다 큰 모든 변수를 가져옵니다 (첫 번째 변수를 제외한 모든 변수). 그러나 트릭은 AaG(원래 배열과을 제거하는) 대신을 0사용 AAg하여 둘 다 유지합니다. 이제 aA, at-index를 사용하여 배열의 첫 번째 요소를 가져 오기 위해 매우 동일0 하게 사용합니다. 더 나아가 이것은 소비 모드 ( aA대신 대신 aa)이므로 0원래 배열도 제거 합니다. 우리.

  아아, 0AAgaA*|본질적으로 GolfScript가 한 문자에서하는 것과 동일한 기능을 수행합니다 (. 그러나 나는 여전히 눈사람 표준에 따르면 꽤 멋지다고 생각합니다. :)

수학, 41 바이트

Position[a=Sort@#;Sort@#/a&/@#2,{x_,x_}]&

용법:

Position[a = Sort@#; Sort@#/a & /@ #2, {x_, x_}] &[{1, 2}, {{1, 2}, {2, 5}, {16, 8}}]
(* {{1}, {3}} *)

Pyth-14 바이트

몫을 비교하여 필터링 한 다음 map indexOf.

xLQfqcFSTcFvzQ

테스트 스위트 .

APL (Dyalog Unicode) , 16 13 바이트 ^SBCS

(=.×∘⌽∨=.×)⍤1

온라인으로 사용해보십시오!

@ngn 덕분에 -3!

설명:

(=.×∘⌽∨=.×)⍤1
(     ∨   )   ⍝ "OR" together...
 =.    =.     ⍝ ...fold by equality of:
   ×∘⌽        ⍝ - the arguments multiplied by itself reversed
         x    ⍝ - the argument multiplied by itself
           ⍤1 ⍝ Applied at rank 1 (traverses)

출력 형식은 1 1 0 0 1"기타"사각형이 유사하게 보이는 이진 벡터 입니다.

APL (Dyalog Extended) , 11 바이트 ^SBCS

=/-×⍥(⌈/)¨⌽

온라인으로 사용해보십시오!

설명:

=/-×⍥(⌈/)¨⌽ ⍝ takes only a right argument: ⍵, shape: (main (other...))
          ⌽ ⍝ two transformations:
  -         ⍝ - left (L) vectorized negation: -⍵
          ⌽ ⍝ - right (R): reverse. (main other) => (other main)
     (⌈/)¨  ⍝ transformation: calculate the max (since L is negated, it calculates the min)
            ⍝ (/ reduces over ⌈ max)
            ⍝ this vectorizes, so the "main" side (with only one rect) will get repeated once for each "other" rect on both sides
   ×⍥       ⍝ over multiplication: apply the transformation to both sides. F(L)×F(R)
=/          ⍝ reduce the 2-element matrix (the "main" that's now the side of the "other") to check which are equal

출력 형식은 기본 Dyalog 답변과 동일합니다.

golf + Extended 도움말에 대한 Adám에게 감사드립니다.

줄리아, 62 바이트

f(m,o)=find([(t=sort(m).*sort(i,rev=true);t[1]==t[2])for i=o])

이 find함수는 부울 벡터에서 실제 요소를 찾습니다. .*벡터를 요소 단위로 곱합니다.

언 골프 드 :

function f(m::Array, o::Array)
    find([(t = sort(m) .* sort(i, rev=true); t[1] == t[2]) for i in o])
end

용법:

f([1,2], {[1,9], [2,5], [16,8]})

K5, 19 바이트

나는 이것이 트릭을 할 것이라고 생각한다.

&(*t)=1_t:{%/x@>x}'

첫 번째가 "main"인 쌍 목록을 가져옵니다. 각 쌍의 정렬 된 차원을 나누어 비율을 계산합니다. 일치하는 쌍의 0 인덱스 위치 목록을 리턴합니다. (아마도 내가 선택한 입력 형식이 1+처음 에 유효하지 않은 압정으로 간주 되고 내 프로그램 크기에 두 문자를 추가 하는 경우이 색인을 -1로 만듭니다 .)

사용 예 :

  &(*t)=1_t:{%/x@>x}'(1 2;1 2;2 4;2 5;16 8)
0 1 3

이것은 oK 에서 실행됩니다. 나는 항상 부동 소수점 결과를 생성하는 나눗셈에 암묵적으로 의존한다는 점에 유의하십시오. 입력의 모든 숫자에 소수점을 추가하고 뒤에 공백을 추가하면 Kona에서 작동합니다 _.

옥타브 / 매트랩, 44 바이트

익명 함수 사용하기 :

@(x,y)find((max(x))*min(y')==min(x)*max(y'))

결과는 1 기반 인덱싱입니다.

사용하려면 함수를 정의하십시오

>> @(x,y)find((max(x))*min(y')==min(x)*max(y'));

다음 형식으로 호출하십시오.

>> ans([1 2], [1 9; 2 5; 16 8])
ans =
     3

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

결과가 논리적 인덱싱에 있을 수있는 경우 ( 0유사하지 않음, 1유사 함) : 38 바이트 :

@(x,y)(max(x))*min(y')==min(x)*max(y')

위와 같은 예 :

>> @(x,y)(max(x))*min(y')==min(x)*max(y')
ans = 
    @(x,y)(max(x))*min(y')==min(x)*max(y')

>> ans([1 2], [1 9; 2 5; 16 8])
ans =
 0     0     1

근접 , 14 바이트

z{iXhpᵐ/ᵛ∧Xt}ᵘ

온라인으로 사용해보십시오!

기본 사각형과 다른 사각형 목록을 포함하는 목록을 포함하는 목록 으로 입력을 받습니다 (따라서 테스트 사례 1은[[[1,2]],[[1,2],[2,4]]] ) 출력 변수를 통해 0부터 시작하는 색인 ​​목록을 출력합니다.

z                 Zip the elements of the input, pairing every "other" rectangle with the main rectangle.
 {          }ᵘ    Find (and output) every unique possible output from the following:
  iX              X is an element of the zip paired with its index in the zip.
    h             That element
      ᵐ           with both of its elements
     p            permuted
        ᵛ         produces the same output for both elements
       /          when the first element of each is divided by the second.
         ∧Xt      Output the index.

그런 종류의 홀수 및 특정 입력 형식이 바람을 피우면 조금 길어집니다 ...

Brachylog , 18 바이트

{hpX&tiYh;X/ᵛ∧Yt}ᶠ

온라인으로 사용해보십시오!

기본 사각형과 다른 사각형의 목록을 포함하는 목록으로 입력을 취하고 (테스트 사례 1이 더 명확함 [[1,2],[[1,2],[2,4]]]) 출력 변수를 통해 0 기반 색인 목록을 출력합니다.

{               }ᵘ    Find (and output) every possible output from the following:
  p                   A permutation of
 h                    the first element of the input
   X                  is X,
    &                 and
      i               a pair [element, index] from
     t                the last element of the input
       Y              is Y,
        h             the first element of which
            ᵛ         produces the same output from
           /          division
         ;            as
          X           X.
             ∧Yt      Output the index.

두 개의 너비-높이 쌍이 유사한 사각형을 나타내는 지 확인하려면 4 바이트 만 사용합니다 pᵐ/ᵛ(공유 비율 또는 그 역수를 출력 함). 나머지는 비교하기 위해 여러 사각형을 처리하고 출력은 인덱스입니다.

dzaima / APL , 7 바이트

=/⍤÷⍥>¨

온라인으로 사용해보십시오!

부울 벡터 대신 인덱스 목록을 출력하는 8 바이트

      ¨ for each (pairing the left input with each of the right)
    ⍥>    do the below over sorting the arguments
=/          equals reduce
  ⍤         after
   ÷        vectorized division of the two

하스켈, 75 바이트

import Data.List
a(x,y)=max x y/min x y
s r=elemIndices(True).map((==a r).a)

PowerShell , 57 바이트

$args|%{$x,$y=$_|sort
($i++)[$r-$y/$x]
if(!$r){$r=$y/$x}}

온라인으로 사용해보십시오!

인덱스는 1부터 시작합니다.

PowerShell , 58 56 바이트

^{mazzy x2로 인해 -2 바이트}

param($x,$y,$b)$b|%{($i++)[$x/$y-($z=$_|sort)[0]/$z[1]]}

온라인으로 사용해보십시오!

이것은 input may be however you desire첫 번째 모양의 구성 요소를 별도로 가져 와서 3 바이트를 절약함으로써 절을 약간 남용합니다 .

PowerShell , 61 59 바이트

param($a,$b)$b|%{($i++)[$a[0]/$a[1]-($x=$_|sort)[0]/$x[1]]}

온라인으로 사용해보십시오!

조건부 인덱싱을 사용하여 비율이 정렬되는지 여부에 따라 현재 0부터 시작하는 인덱스와 null 사이를 전환합니다. 운 좋게도이 경우 $i인쇄 여부에 관계없이 증가합니다.

자바 스크립트 (ES6), 75

(a,b)=>b.filter(e=>e.l*a.h==a.l*e.h||e.l*a.l==a.h*e.h).map(e=>b.indexOf(e))

대안, 또한 75

(a,b)=>b.map((e,i)=>e.l*a.h==a.l*e.h||e.l*a.l==a.h*e.h?i:-1).filter(e=>e+1)

입력은 JSON 객체 및 JSON 객체의 배열로 간주됩니다.

{
    l: length of rectangle,
    h: height of rectangle
}

05AB1E , 15 14 바이트

ʒ‚ε{ü/}Ë}J¹Jsk

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오. .

설명:

ʒ               # Filter the (implicit) input-list by:
 ‚              #  Pair the current width/height with the (implicit) input width/height
  ε             #  Map both width/height pairs to:
   {            #   Sort from lowest to highest
    ü/          #   Pair-wise divide them from each other
      }Ë        #  After the map: check if both values in the mapped list are equals
        }J      # After the filter: join all remaining pairs together to a string
          ¹J    # Also join all pairs of the first input together to a string
            s   # Swap to get the filtered result again
             k  # And get it's indices in the complete input-list
                # (which is output implicitly)

그만큼 J다차원리스트 AFAIK에 05AB1E이 인덱스를 결정할 수 없기 때문에 oins이있다

정확한 너비 / 높이 쌍을 출력하거나 입력 목록을 기반으로 진실 / 거짓 값 목록을 출력하는 경우 대신 8 바이트 일 수 있습니다 .

ʒ‚ε{ü/}Ë

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

ε‚ε{ü/}Ë

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .