Con số tương tự

Hai hình chữ nhật giống nhau nếu tỷ lệ các cạnh của chúng là như nhau.

Xét hai hình chữ nhật này; một hình chữ nhật cao 5 dòng và rộng 11 ký tự:

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

và một hình chữ nhật cao 10 dòng và rộng 22 ký tự:

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

Những hình dạng này là tương tự nhau vì tỷ lệ của các mặt của chúng là như nhau. Để đặt nó chính thức (với $h$ là bên ngắn nhất và $w$ là bên dài nhất):

Bạn cũng có thể làm:

Các thách thức

Viết chương trình hoặc hàm có hình chữ nhật "chính" và một số hình chữ nhật "khác" và bản in của "cái khác" tương tự như "chính".

Đầu vào

Một hình dạng và một danh sách các hình dạng. Mỗi hình bao gồm 2 số nguyên dương khác không, biểu thị chiều rộng và chiều cao của hình chữ nhật. Ví dụ:

(4,2), (3,9)

biểu thị hai hình chữ nhật, 4x2 và 3x9. Các định dạng chính xác của đầu vào có thể là tuy nhiên bạn mong muốn.

Đầu ra

Các chỉ số của các hình dạng "khác" tương tự như "chính". Bạn có thể chọn xem các chỉ số dựa trên 0 hay 1, cũng như định dạng và thứ tự chính xác của đầu ra.

Chương trình mẫu

Trong 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

Đầu vào và đầu ra mẫu

Đầu vào:

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

Đầu ra:

set([0, 1])

Đầu vào:

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

Đầu ra:

set([2])

Chiến thắng

Đây là môn đánh gôn, vì vậy bài nộp ngắn nhất sẽ thắng.

Ghi chú

• Điều này nên đi mà không nói, nhưng sơ hở tiêu chuẩn bị cấm .
• Không có nội dung nào để định vị các số liệu tương tự có thể được sử dụng. (Tôi thậm chí không biết nếu điều đó tồn tại, nhưng tôi sẽ không ngạc nhiên!)

Bình thường, 15 byte

fqcFS@QTcFSvzUQ

Python, 61 byte

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

Có, tôi đang sử dụng 9 ký tự để viết enumerate . Có đầu vào như1, 2, [(1, 9), (3,6), (2, 5), (16, 8)] . Đối với Python 2, các giá trị đầu vào cần được viết dưới dạng float.

Một char dài hơn (62) trong Python 3:

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 byte

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

Trên đây là một hàm ẩn danh bật ra một mảng các cặp dấu phẩy động (cặp đầu tiên là kim) từ ngăn xếp và đẩy mảng các chỉ mục dựa trên 1 trở lại.

Hãy thử trực tuyến trong trình thông dịch CJam .

Làm thế nào nó hoạt động

:$                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 byte

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

Hãy thử trực tuyến!

Gọi như thế này (!) 1 2 [(1, 9), (3,6), (2, 5), (16, 8)] .

Một cổng gần câu trả lời Python của tôi . Cách diễn đạtzip[0..]l liệt kê danh sách với các chỉ số của nó.

Biểu thức x/y+y/x==a/b+b/akiểm tra tỷ lệ x/ynày là a/bhoặc b/a, vì hàm f(z) = z + 1/zcó f(z) = f(1/z)và không có xung đột nào khác.

Người tuyết 1.0.2 , 61 ký tự

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

Vô nghĩa (trừ khi bạn tình cờ biết Snowman), hay chính xác là phù hợp với mục tiêu thiết kế của ngôn ngữ là khó hiểu nhất có thể.

Định dạng đầu vào giống như trong bài viết, định dạng đầu ra cũng là điểm trừ tương tự set(và ).

Ungolfed (hoặc chưa hoàn thành, thực sự):

}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

Tôi khá tự hào về một số thủ thuật tôi đã sử dụng trong phần này:

• Tôi đã sử dụng định dạng đầu vào giống như trong bài viết. Nhưng thay vì cố gắng phân tích nó bằng cách nào đó, điều này sẽ trở nên rất lộn xộn, tôi chỉ nối hai dòng và sau đó sử dụng một biểu thức chính để trích xuất tất cả các số thành một mảng lớn (sau đó tôi đã làm 2aG, tức là lấy mỗi nhóm 2).

• :nD;aFlà khá lạ mắt. Nó chỉ đơn giản là lấy một mảng gồm hai phần tử và chia phần tử thứ nhất cho phần tử thứ hai. Điều này có vẻ khá đơn giản, nhưng thực hiện nó theo cách trực quan ( a[0]/a[1]) sẽ còn lâu hơn rất nhiều trong Snowman: 0aa`NiN`aA|,nD(và giả sử rằng chúng ta không phải lo lắng về việc gây rối với các biến hiện có khác). Thay vào đó, tôi đã sử dụng phương thức "gấp" với một vị từ "chia", trong đó, với một mảng gồm hai phần tử, đạt được điều tương tự.

• 0AAgaAtrông có vẻ vô hại, nhưng những gì nó thực sự làm là lưu trữ một 0biến, sau đó lấy tất cả các biến có chỉ số lớn hơn (vì vậy, tất cả các biến ngoại trừ biến đầu tiên). Nhưng mẹo là, thay vì AaG(sẽ loại bỏ mảng ban đầu và 0), tôi đã sử dụng AAg, giữ cả hai. Bây giờ tôi sử dụng aA, at-index, sử dụng cùng một0 phần tử để lấy phần tử đầu tiên của mảng, hơn nữa, đây là ở chế độ tiêu thụ ( aAthay vì aa), vì vậy nó cũng bị loại bỏ 0mảng ban đầu và hiện đang là rác cho chúng tôi

  Than ôi, 0AAgaA*|về cơ bản giống như những gì GolfScript làm trong một nhân vật : (. Tuy nhiên, tôi vẫn nghĩ nó khá đẹp, theo tiêu chuẩn của Snowman. :)

Toán học, 41 byte

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

Sử dụng:

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

Pyth - 14 byte

Lọc bằng cách so sánh chỉ tiêu, sau đó bản đồ indexOf.

xLQfqcFSTcFvzQ

Phòng thử nghiệm .

APL (Dyalog Unicode) , 16 13 byte ^SBCS

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

Hãy thử trực tuyến!

-3 cảm ơn @ngn!

Giải trình:

(=.×∘⌽∨=.×)⍤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)

Định dạng đầu ra là một vectơ nhị phân giống như 1 1 0 0 1hình chữ nhật "khác" trông giống như.

APL (Dyalog mở rộng) , 11 byte ^SBCS

=/-×⍥(⌈/)¨⌽

Hãy thử trực tuyến!

Giải trình:

=/-×⍥(⌈/)¨⌽ ⍝ 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

Định dạng đầu ra giống như câu trả lời chính của Dyalog.

Cảm ơn Adám đã giúp đỡ chơi golf + Mở rộng.

Julia, 62 byte

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

Các findchức năng định vị các yếu tố đúng trong một vector boolean. .*thực hiện phép nhân nguyên tố của vectơ.

Ung dung:

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

Sử dụng:

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

K5, 19 byte

Tôi nghĩ rằng điều này sẽ thực hiện các mẹo:

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

Đưa ra một danh sách các cặp trong đó đầu tiên là "chính". Tính tỷ lệ bằng cách chia kích thước được sắp xếp của mỗi cặp. Trả về danh sách các vị trí được lập chỉ mục 0 của các cặp khớp. (có thể cho rằng định dạng đầu vào mà tôi đã chọn làm cho -1 này được lập chỉ mục- nếu điều này được coi là không hợp lệ trên một1+ đầu và thêm hai ký tự vào kích thước chương trình của tôi.)

Ví dụ sử dụng:

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

Điều này chạy trong oK - lưu ý rằng tôi hoàn toàn phụ thuộc vào phép chia luôn tạo ra kết quả dấu phẩy động. Nó sẽ hoạt động trong Kona nếu bạn thêm dấu thập phân cho tất cả các số trong đầu vào và thêm khoảng trắng sau dấu _.

Octave / Matlab, 44 byte

Sử dụng chức năng ẩn danh:

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

Kết quả là lập chỉ mục dựa trên 1.

Để sử dụng nó, xác định chức năng

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

và gọi nó với định dạng sau

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

Bạn có thể thử nó trực tuyến .

Nếu kết quả có thể ở dạng lập chỉ mục logic ( 0biểu thị không giống nhau, 1biểu thị tương tự): 38 byte :

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

Ví dụ tương tự như trên:

>> @(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 byte

z{iXhpᵐ/ᵛ∧Xt}ᵘ

Hãy thử trực tuyến!

Đưa đầu vào dưới dạng danh sách chứa danh sách chứa hình chữ nhật chính và danh sách các hình chữ nhật khác (vì vậy trường hợp kiểm tra 1 là [[[1,2]],[[1,2],[2,4]]]) và đưa ra danh sách các chỉ số dựa trên 0 thông qua biến đầu ra.

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.

Nếu loại định dạng đầu vào kỳ quặc và cụ thể đó là gian lận, thì lâu hơn một chút ...

Brachylog , 18 byte

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

Hãy thử trực tuyến!

Lấy đầu vào dưới dạng danh sách chứa hình chữ nhật chính và danh sách các hình chữ nhật khác (vì vậy trường hợp kiểm tra 1 là rõ ràng hơn [[1,2],[[1,2],[2,4]]]) và đưa ra danh sách các chỉ số dựa trên 0 thông qua biến đầu ra.

{               }ᵘ    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.

Để xác định xem hai cặp chiều rộng có chiều cao biểu thị các hình chữ nhật tương tự nhau hay không, chỉ cần lấy bốn byte pᵐ/ᵛ(đưa ra tỷ lệ chia sẻ hoặc đối ứng của nó). Tất cả phần còn lại đang xử lý nhiều hình chữ nhật để so sánh, và đầu ra là các chỉ số.

dzaima / APL , 7 byte

=/⍤÷⍥>¨

Hãy thử trực tuyến!

8 byte xuất ra một danh sách các chỉ số thay vì một vectơ boolean

      ¨ 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 byte

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

PowerShell , 57 byte

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

Hãy thử trực tuyến!

Các chỉ số dựa trên 1.

PowerShell , 58 56 byte

^{-2 byte nhờ mazzy x2}

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

Hãy thử trực tuyến!

Điều này hơi lạm dụng input may be however you desire mệnh đề bằng cách có các thành phần của hình dạng đầu tiên đi kèm để tiết kiệm 3 byte.

PowerShell , 61 59 byte

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

Hãy thử trực tuyến!

Sử dụng lập chỉ mục có điều kiện để trao đổi giữa chỉ số dựa trên zero hiện tại và null dựa trên việc các tỷ lệ có xếp hàng hay không. May mắn trong trường hợp này, $igia tăng bất kể nó được in hay không.

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

Thay thế, cũng 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)

Đầu vào được lấy dưới dạng đối tượng JSON và một mảng các đối tượng JSON

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

05AB1E , 15 14 byte

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

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

ʒ               # 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)

Các J oins ở đó vì 05AB1E không thể xác định các chỉ số trong danh sách đa chiều afaik

Nếu xuất ra các cặp chiều rộng / chiều cao là trung thực hoặc xuất ra danh sách các giá trị trung thực / falsey dựa trên danh sách đầu vào, thì đó có thể là 8 byte :

ʒ‚ε{ü/}Ë

Dùng thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

ε‚ε{ü/}Ë

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .