同様の数字

2つの長方形は、辺の比率が同じ場合に似ています。

これらの2つの長方形を検討してください。高さ5行、幅11文字の長方形：

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

高さ10行、幅22文字の長方形：

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

これらの形状は、側面の比率が同じであるため類似しています。正式に配置するには（$h$が最短辺、$w$が最長辺）：

次のこともできます。

チャレンジ

「メイン」長方形といくつかの「その他」長方形を取り、「その他」が「メイン」に似ているものを印刷するプログラムまたは関数を作成します。

入力

形状と形状のリスト。各形状は、2つのゼロ以外の正の整数で構成され、長方形の幅と高さを示します。たとえば、これ：

(4,2), (3,9)

は、4x2と3x9の2つの長方形を示します。ただし、入力の正確な形式は必要に応じて変更できます。

出力

「メイン」に類似した「その他」の形状のインデックス。インデックスが0ベースか1ベースか、出力の正確な形式と順序を選択できます。

サンプルプログラム

Pythonの場合：

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

Python、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の場合、入力値はfloatとして記述する必要があります。

Python 3で1文字長い（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-}

上記は、スタックから浮動小数点ペア（最初のペアはニードル）の単一の配列をポップし、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.

Haskell、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)]ます。

私のPythonの答えのニアポート。式zip[0..]lは、インデックスを使用してリストを列挙します。

発現x/y+y/x==a/b+b/a比は、そのチェックx/yのいずれかであるa/b、またはb/a機能があるため、f(z) = z + 1/z持っていないf(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

私はこれで使用したトリックのいくつかをかなり誇りに思っています。

• 投稿と同じ入力形式を使用しました。しかし、どうにかしてそれを解析しようとするのではなく、本当に面倒になります。2行を連結し、正規表現を使用してすべての数値を1つの大きな配列に抽出しました（これ2aGで、2のすべてのグループを取得しました）。

• :nD;aFかなり派手です。2つの要素の配列を受け取り、最初の要素を2番目の要素で除算します。これは非常に単純に思えa[0]/a[1]ますが、Snowmanでは直感的な方法（）を使用するとはるかに長くなります0aa`NiN`aA|,nD（他の既存の変数との干渉を心配する必要がないと仮定しています）。代わりに、2つの要素の配列に対して同じことを達成する、「分割」の述語とともに「fold」メソッドを使用しました。

• 0AAgaA無害に見えますが、実際には0変数にa を格納し、それよりも大きいインデックスを持つすべての変数を取得します（したがって、最初の変数を除くすべての変数）。しかし、トリックは、AaG（元の配列とを取り除く）の代わりに、両方を保持する0を使用しましたAAg。今、私は配列の最初の要素を取得するためにまったく同じをaA使用して、インデックスを使用します-さらに、これは（ではなく）消費モードですので、0aAaa0、元の配列も削除します米国。

  残念ながら、0AAgaA*|GolfScriptが1文字で行うのと本質的に同じことを行います(。ただし、Snowmanの基準からすれば、まだかなりいいと思います。:)

Mathematica、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バイト

商を比較してフィルタリングし、次にをマッピングしますindexOf。

xLQfqcFSTcFvzQ

テストスイート。

APL（Dyalog Unicode）、16 13 バイト^SBCS

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

オンラインでお試しください！

-3 @ngnに感謝！

説明：

(=.×∘⌽∨=.×)⍤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の回答と同じです。

ゴルフのゴルフ+拡張のヘルプを提供してくれた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}'

最初が「メイン」であるペアのリストを取得します。各ペアのソートされた次元を分割することにより、比率を計算します。一致するペアのインデックスが0の位置のリストを返します。（おそらく、私が選択した入力形式は、これに-1をインデックス付けします-これが無効なタックとみなされる場合1+先頭に、プログラムのサイズに2文字を追加する場合）

使用例：

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

これはOKで実行されます-常に浮動小数点の結果を生成する除算に暗黙的に依存していることに注意してください。入力内のすべての数値に小数点を追加し、の後にスペースを追加すると、コナで機能します_。

オクターブ/ Matlab、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

Brachylog、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.

2つの幅と高さのペアが同様の長方形を表すかどうかを判断するには、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

Haskell、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]]}

オンラインでお試しください！

条件付きインデックスを使用して、比率が揃っているかどうかに基づいて、現在のゼロベースのインデックスとnullの間でスワップします。幸いなことに、この場合、$i印刷されるかどうかに関係なく増分します。

Javascript（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)

J05AB1Eは多次元リストのインデックスを決定できないため、これらの点は存在します。

真実の幅/高さのペアを出力する場合、または入力リストに基づいて真実/偽の値のリストを出力する場合、8 バイトになります代わりに。

ʒ‚ε{ü/}Ë

オンラインで試すか、、すべてのテストケースを確認してください。

ε‚ε{ü/}Ë

オンラインそれを試してみたり、すべてのテストケースを確認してください。