ตัวเลขที่คล้ายกัน

สี่เหลี่ยมสองรูปนั้นคล้ายกันถ้าอัตราส่วนของด้านเท่ากัน

ลองพิจารณาสี่เหลี่ยมสองรูปนี้ สี่เหลี่ยมผืนผ้าสูง 5 เส้นและกว้าง 11 ตัวอักษร:

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

และสี่เหลี่ยมผืนผ้าสูง 10 เส้นและกว้าง 22 ตัวอักษร:

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

รูปร่างเหล่านี้คล้ายกันเพราะอัตราส่วนของด้านข้างเท่ากัน ที่จะนำมันอย่างเป็นทางการ (กับเป็นด้านที่สั้นที่สุดและเป็นด้านที่ยาวที่สุด):$h$$w$

คุณยังสามารถทำสิ่งต่อไปนี้

ความท้าทาย

เขียนโปรแกรมหรือฟังก์ชั่นที่ใช้สี่เหลี่ยม "หลัก" และสี่เหลี่ยมบางอัน "อื่น ๆ " และพิมพ์ที่ "อื่น ๆ " คล้ายกับ "main"

การป้อนข้อมูล

รูปร่างและรายการของรูปร่าง แต่ละรูปร่างประกอบด้วย 2 จำนวนเต็มบวกที่ไม่เป็นศูนย์ซึ่งแสดงถึงความกว้างและความสูงของสี่เหลี่ยมผืนผ้า ตัวอย่างเช่นสิ่งนี้:

(4,2), (3,9)

หมายถึงสองรูปสี่เหลี่ยมผืนผ้า 4x2 และ 3x9 รูปแบบการป้อนข้อมูลที่แน่นอนอาจเป็นไปได้

ผลลัพธ์

ดัชนีของรูปร่าง "อื่น ๆ " ที่คล้ายกับ "หลัก" คุณสามารถเลือกได้ว่าจะใช้ดัชนี 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 ค่าอินพุตต้องถูกเขียนเป็นแบบลอย

ถ่านหนึ่งอันยาวกว่า (62) ใน 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 ไบต์

{:$::/_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)]เรียกเช่นนี้

ใกล้ท่าเรือของฉันคำตอบหลาม นิพจน์จะ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)และไม่มีการชนอื่น ๆ

Snowman 1.0.2 , 61 chars

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

พูดพล่อยๆที่บริสุทธิ์ (เว้นแต่คุณจะรู้ Snowman) หรือที่สอดคล้องกับเป้าหมายการออกแบบของภาษาที่สับสนที่สุดเท่าที่จะทำได้

รูปแบบอินพุตเหมือนกับโพสต์รูปแบบเอาต์พุตเป็นลบ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

ฉันค่อนข้างภูมิใจในกลเม็ดที่ฉันใช้ในเกมนี้:

• ฉันใช้รูปแบบอินพุตเหมือนในโพสต์ แต่แทนที่จะพยายามที่จะแยกมันอย่างใดซึ่งจะได้รับยุ่งจริงๆผมเพียงแค่ตัดแบ่งเส้นสองเส้นและใช้ regex เพื่อแยกตัวเลขทั้งหมดลงในอาร์เรย์ขนาดใหญ่ (มีซึ่งผมก็ไม่ได้ทำแล้ว2aGคือได้รับกลุ่มที่ 2 ทุกครั้ง)

• :nD;aFสวยแฟนซี มันใช้เวลาเพียงสองอาร์เรย์และแบ่งองค์ประกอบแรกด้วยองค์ประกอบที่สอง ซึ่งดูเหมือนเรียบง่าย แต่ทำในวิธีที่ใช้งานง่าย ( a[0]/a[1]) จะอยู่ไกลใน Snowman อีกต่อไป: 0aa`NiN`aA|,nD(และนั่นคือสมมุติว่าเราไม่ต้องกังวลกับการยุ่งกับตัวแปรอื่น ๆ ที่มีอยู่) แต่ฉันใช้วิธี "fold" กับภาคแสดงของ "หาร" ซึ่งสำหรับอาร์เรย์ของสององค์ประกอบจะได้รับสิ่งเดียวกัน

• 0AAgaAดูไร้เดียงสาเพียงพอ แต่สิ่งที่จริง ๆ แล้วคือการจัดเก็บ0ตัวแปรจากนั้นนำตัวแปรทั้งหมดที่มีดัชนีมากกว่านั้น (ดังนั้นตัวแปรทั้งหมดยกเว้นตัวแรก) แต่เคล็ดลับคือแทนที่จะใช้AaG(ซึ่งจะกำจัดอาร์เรย์เดิมและ0) ฉันใช้AAgซึ่งทำให้ทั้งสอง ตอนนี้ฉันใช้aAat-index โดยใช้แบบเดียวกัน0เพื่อรับองค์ประกอบแรกของอาเรย์ - นอกจากนี้ยังอยู่ในโหมดใช้งาน ( aAแทนaa) ดังนั้นมันจึงกำจัด0อาเรย์และอาเรย์ดั้งเดิมด้วยซึ่งตอนนี้ขยะสำหรับ เรา.

  อนิจจา0AAgaA*|ทำสิ่งเดียวกับที่ GolfScript ทำในตัวละครเดียว: (. อย่างไรก็ตามฉันยังคงคิดว่ามันค่อนข้างดีตามมาตรฐานของ 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

Test Suite

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ฟังก์ชั่นตั้งอยู่องค์ประกอบจริงในเวกเตอร์บูล .*ดำเนินการคูณเวกเตอร์แบบตามองค์ประกอบ

Ungolfed:

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+การเริ่มต้นและเพิ่มอักขระสองตัวตามขนาดของโปรแกรมของฉัน)

ตัวอย่างการใช้งาน:

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

สิ่งนี้ทำงานในoK - โปรดทราบว่าฉันขึ้นอยู่กับการแบ่งโดยปริยายเสมอให้ผลลัพธ์จุดลอยตัว มันจะทำงานใน Kona _ถ้าคุณเพิ่มจุดทศนิยมให้ตัวเลขทั้งหมดในการป้อนข้อมูลและเพิ่มพื้นที่หลัง

Octave / 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.

หากต้องการตรวจสอบว่าคู่ความกว้างความสูงสองคู่แสดงสี่เหลี่ยมที่คล้ายกันหรือไม่เพียงแค่ใช้สี่ไบต์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 ไบต์

^{-2 ไบต์ขอบคุณ mazzy x2}

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

ลองออนไลน์!

ใช้การจัดทำดัชนีแบบมีเงื่อนไขเพื่อสลับระหว่างดัชนี zero-based ปัจจุบันและ 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)

Joins จะมีเพราะ 05AB1E ไม่สามารถกำหนดดัชนีในรายการหลายมิติ AFAIK

หากเอาต์พุตคู่ความกว้าง / ความสูงที่เป็นความจริงหรือแสดงรายการของค่าความจริง / falsey ตามรายการอินพุตนั้นอาจเป็น8 ไบต์แทน:

ʒ‚ε{ü/}Ë

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

ε‚ε{ü/}Ë

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด