Tokoh serupa

Dua persegi panjang serupa jika rasio sisi mereka sama.

Pertimbangkan dua persegi panjang ini; persegi panjang 5 garis dan lebar 11 karakter:

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

dan persegi panjang 10 garis dan 22 karakter lebar:

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

Bentuk-bentuk ini serupa karena rasio sisi-sisinya sama. Singkatnya (dengan $h$ sebagai sisi terpendek dan menjadi sisi terpanjang):$w$

Anda juga dapat melakukan:

Tantangan

Tulis program atau fungsi yang mengambil persegi panjang "utama" dan beberapa persegi panjang dan cetakan "lainnya" yang mana dari "yang lain" mirip dengan "utama".

Input

Bentuk dan daftar bentuk. Setiap bentuk terdiri dari 2 bilangan bulat positif bukan nol, yang menunjukkan lebar dan tinggi persegi panjang. Misalnya, ini:

(4,2), (3,9)

menunjukkan dua persegi panjang, 4x2 dan 3x9. Format input yang tepat mungkin sesuai keinginan Anda.

Hasil

Indeks bentuk "lain" yang mirip dengan "utama". Anda dapat memilih apakah indeksnya berbasis 0 atau 1, serta format dan urutan output yang tepat.

Program sampel

Dengan 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

Input dan output sampel

Memasukkan:

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

Keluaran:

set([0, 1])

Memasukkan:

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

Keluaran:

set([2])

Kemenangan

Ini adalah kode-golf, sehingga pengiriman terpendek menang.

Catatan

• Ini harus dilakukan tanpa berkata, tetapi celah standar dilarang .
• Tidak ada builtin untuk menemukan angka yang sama dapat digunakan. (Aku bahkan tidak tahu kalau itu ada, tapi aku tidak akan terkejut!)

Pyth, 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]]

Ya, saya menggunakan pengeluaran 9 karakter untuk menulis enumerate . Mengambil input seperti 1, 2, [(1, 9), (3,6), (2, 5), (16, 8)]. Untuk Python 2, nilai input harus ditulis sebagai float.

Satu char lagi (62) dalam 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-}

Di atas adalah fungsi anonim yang memunculkan array tunggal pasangan titik mengambang (pasangan pertama adalah jarum) dari tumpukan dan mendorong array indeks berbasis 1 sebagai imbalannya.

Cobalah online di Internet juru bahasa CJam .

Bagaimana itu bekerja

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

Cobalah online!

Sebut seperti ini (!) 1 2 [(1, 9), (3,6), (2, 5), (16, 8)] .

Dekat-port jawaban Python saya . Ekspresizip[0..]l menyebutkan daftar dengan indeksnya.

Ekspresi x/y+y/x==a/b+b/amemeriksa apakah rasionya x/ysalah a/batau b/a, karena fungsi f(z) = z + 1/zmemiliki f(z) = f(1/z)dan tidak ada tabrakan lainnya.

Snowman 1.0.2 , 61 karakter

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

Omong kosong murni (kecuali jika Anda mengenal Snowman), alias persis sejalan dengan tujuan desain bahasa menjadi membingungkan mungkin.

Format input sama seperti pada postingan, format output juga minus set(dan sama ).

Tidak disatukan (atau tidak dijinakkan, sungguh):

}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

Saya cukup bangga dengan beberapa trik yang saya gunakan dalam trik ini:

• Saya menggunakan format input yang sama seperti pada posting. Tetapi alih-alih mencoba menguraikannya entah bagaimana, yang akan menjadi benar-benar berantakan, saya hanya menggabungkan dua baris dan kemudian menggunakan regex untuk mengekstraksi semua angka menjadi satu array besar (yang kemudian saya lakukan 2aG, yaitu mendapatkan setiap kelompok 2).

• :nD;aFcukup mewah. Ini hanya membutuhkan array dari dua elemen dan membagi yang pertama dengan yang kedua. Yang tampaknya cukup sederhana, tetapi melakukannya dengan cara intuitif ( a[0]/a[1]) akan jauh, jauh lebih lama di Snowman: 0aa`NiN`aA|,nD(dan itu dengan asumsi kita tidak perlu khawatir tentang mengacaukan dengan variabel lain yang ada). Sebaliknya, saya menggunakan metode "lipat" dengan predikat "divide," yang, untuk array dua elemen, mencapai hal yang sama.

• 0AAgaAterlihat cukup berbahaya, tetapi apa yang sebenarnya dilakukannya adalah menyimpan a 0ke variabel, kemudian mengambil semua variabel dengan indeks lebih besar dari itu (jadi, semua variabel kecuali yang pertama). Tapi triknya adalah, alih-alih AaG(yang akan menghilangkan array asli dan 0), saya menggunakan AAg, yang membuat keduanya. Sekarang saya menggunakan aA, at-index, menggunakan hal yang sama0 untuk mendapatkan elemen pertama dari array — lebih jauh, ini berada dalam mode konsumsi ( aAbukan aa), sehingga ia menghilangkan 0array asli dan juga, yang sekarang menjadi sampah untuk kami.

  Sayangnya, 0AAgaA*|tidak dasarnya hal yang sama yang GolfScript tidak dalam satu karakter: (. Namun, saya masih berpikir itu cukup bagus, menurut standar Snowman. :)

Mathematica, 41 byte

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

Pemakaian:

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

Pyth - 14 byte

Memfilter dengan membandingkan quotients, lalu memetakan indexOf.

xLQfqcFSTcFvzQ

Test Suite .

APL (Dyalog Unicode) , 16 13 byte ^SBCS

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

Cobalah online!

-3 Terima kasih kepada @ngn!

Penjelasan:

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

Format output adalah vektor biner seperti 1 1 0 0 1persegi panjang "lainnya" yang mirip.

APL (Dyalog Extended) , 11 byte ^SBCS

=/-×⍥(⌈/)¨⌽

Cobalah online!

Penjelasan:

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

Format output sama dengan jawaban Dyalog utama.

Terima kasih kepada Adám untuk bantuan golf + Diperpanjang.

Julia, 62 byte

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

The findFungsi menempatkan elemen yang benar dalam vektor boolean. .*melakukan perkalian elemen secara vektor.

Tidak Disatukan:

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

Pemakaian:

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

K5, 19 byte

Saya pikir ini akan melakukan trik:

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

Membawa daftar pasangan di mana yang pertama adalah "utama". Hitung rasio dengan membagi dimensi yang diurutkan dari setiap pasangan. Mengembalikan daftar posisi 0-diindeks dari pasangan yang cocok. (bisa dibilang format input yang saya pilih membuat -1 ini diindeks- jika ini dianggap tidak valid pada 1+awal dan menambahkan dua karakter ke ukuran program saya.)

Contoh penggunaan:

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

Ini berjalan dalam OK - perhatikan bahwa saya secara implisit tergantung pada divisi selalu menghasilkan hasil floating point. Ini akan bekerja di Kona jika Anda menambahkan titik desimal ke semua angka dalam input dan menambahkan spasi setelah _.

Oktaf / Matlab, 44 byte

Menggunakan fungsi anonim:

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

Hasilnya adalah pengindeksan berbasis 1.

Untuk menggunakannya, tentukan fungsinya

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

dan menyebutnya dengan format berikut

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

Anda dapat mencobanya secara online .

Jika hasilnya bisa dalam pengindeksan logis ( 0menunjukkan tidak mirip, 1menunjukkan serupa): 38 byte :

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

Contoh yang sama seperti di atas:

>> @(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}ᵘ

Cobalah online!

Mengambil input sebagai daftar yang berisi daftar yang berisi persegi panjang utama dan daftar persegi panjang lainnya (jadi test case 1 adalah [[[1,2]],[[1,2],[2,4]]]), dan menampilkan daftar indeks berbasis 0 melalui variabel output.

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.

Jika pemformatan input yang aneh dan spesifik semacam itu curang, itu sedikit lebih lama ...

Brachylog , 18 byte

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

Cobalah online!

Mengambil input sebagai daftar yang berisi persegi panjang utama dan daftar persegi panjang lainnya (jadi test case 1 lebih jelas [[1,2],[[1,2],[2,4]]]), dan menampilkan daftar indeks berbasis 0 melalui variabel output.

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

Untuk menentukan apakah dua pasangan lebar-tinggi mewakili persegi panjang yang serupa, hanya dibutuhkan empat byte pᵐ/ᵛ (yang menghasilkan rasio bersama atau timbal baliknya). Semua sisanya menangani beberapa persegi panjang untuk membandingkan, dan hasilnya berupa indeks.

dzaima / APL , 7 byte

=/⍤÷⍥>¨

Cobalah online!

8 byte menghasilkan daftar indeks bukan vektor 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}}

Cobalah online!

Indeks berbasis 1.

PowerShell , 58 56 byte

^{-2 byte berkat mazzy x2}

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

Cobalah online!

Ini sedikit menyalahgunakan input may be however you desireklausa dengan memiliki komponen bentuk pertama datang secara terpisah untuk menghemat 3 byte.

PowerShell , 61 59 byte

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

Cobalah online!

Menggunakan pengindeksan bersyarat untuk bertukar antara indeks berbasis nol saat ini dan nol berdasarkan pada apakah rasio tersebut sesuai atau tidak. Untungnya dalam hal ini, $ipeningkatan terlepas dari apakah itu dicetak atau tidak.

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

Alternatif, juga 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)

Input diambil sebagai objek JSON, dan larik objek JSON

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

05AB1E , 15 14 byte

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

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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

The Joins ada karena 05AB1E tidak dapat menentukan indeks pada daftar multidimensi AFAIK

Jika mengeluarkan pasangan lebar / tinggi yang benar, atau mengeluarkan daftar nilai kebenaran / palsu berdasarkan daftar masukan, itu bisa 8 byte sebagai gantinya:

ʒ‚ε{ü/}Ë

Cobalah secara online atau verifikasi semua kasus uji .

ε‚ε{ü/}Ë

Cobalah online atau verifikasi semua kasus uji .