इसी तरह के आंकड़े

दो आयतें समान हैं यदि उनके पक्षों के अनुपात समान हैं।

इन दो आयतों पर विचार करें; एक आयत 5 लाइनें लंबी और 11 चौड़ी चौड़ी:

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

और एक आयत 10 लाइनें लंबी और 22 चौड़ी चौड़ी:

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

ये आकृतियाँ समान हैं क्योंकि इनके पक्षों के अनुपात समान हैं। यह औपचारिक रूप से रखने के लिए (के साथ कम से कम पक्ष जा रहा है और लंबाई की ओर जा रहा है): $h$ $w$

\frac{ज_{1}}{w_{1}} = \frac{ज_{2}}{w_{2}}

$\frac{h_1}{w_1} = \frac{h_2}{w_2}$

आप भी कर सकते हैं:

\frac{ज_{1}}{ज_{2}} = \frac{w_{1}}{w_{2}}

$\frac{h_1}{h_2} = \frac{w_1}{w_2}$

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो "मुख्य" आयत और कुछ "अन्य" आयतों और प्रिंटों को लेता है जो "दूसरों" के "मुख्य" के समान हैं।

इनपुट

एक आकृति और आकृतियों की सूची। प्रत्येक आकृति में 2 गैर-शून्य सकारात्मक पूर्णांक होते हैं, जो आयत की चौड़ाई और ऊंचाई को दर्शाते हैं। उदाहरण के लिए, यह:

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

जीतना

यह कोड-गोल्फ है, इसलिए सबसे कम सबमिशन जीतता है।

यह कहे बिना जाना चाहिए, लेकिन मानक खामियों पर प्रतिबंध लगा दिया जाता है ।
समान आंकड़ों का पता लगाने के लिए किसी भी निर्माण का उपयोग नहीं किया जा सकता है। (अगर मुझे पता नहीं है कि मौजूद है, लेकिन मुझे आश्चर्य नहीं होगा!)

code-golf rational-numbers

— kirbyfan64sos
स्रोत

क्या फ्लोटिंग पॉइंट डिवीजन का उपयोग करने की अनुमति है? चाहेंगे [1.0 2.0]एक स्वीकार्य इनपुट प्रारूप हो सकता है?

— डेनिस

@ डेनिस ने अपनी चुनी हुई भाषा प्रदान नहीं की है और इसमें फ्लोटिंग लो प्राइसेस सटीक है और इसलिए परीक्षण के मामले विफल हो जाते हैं, यह ठीक होना चाहिए। ;)

— kirbyfan64sos

सूचकांकों के बजाय हम वास्तविक समान आकृतियों का उत्पादन भी कर सकते हैं?

— orlp

@orlp नहीं !!! : D

— kirbyfan64sos

3

क्या सूचकांकों का आउटपुट स्वरूप अनिवार्य है? जैसे एक परीक्षण मामले के लिए [(1,2), (2,4), (1,9), (2,5), (16,8)], केवल [0,1,4]और [1,2,5]अनुमति है, या हम भी उत्पादन [1,1,0,0,1]कर सकते हैं या [(1,2), (2,4), (16,8)]?

— केविन क्रूज़सेन

5

अजगर, 15 बाइट्स

fqcFS@QTcFSvzUQ

— orlp
स्रोत

11

अजगर, 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)]। पायथन 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

— XNOR
स्रोत

क्या आप इसे समझाते हैं? मैं जानना चाहता हूं कि क्या हो रहा है।

— The_Basset_Hound

इनपुट सूची में प्रत्येक तत्व के लिए @BassetHound, iइंडेक्स के रूप में समझ और (x,y)बिंदु के रूप में unpacks । यह तब जांचता है कि क्या मूल्य x/yया तो प्रारंभिक दो संख्याओं के भागफल ( a/b) या उसके पारस्परिक ( b/a) के बराबर है । यदि यह उन मानों में से एक के बराबर है, तो उस मान iको सूची में जोड़ा जाता है, अन्यथा इसे छोड़ दिया जाता है।

— फ्राईमईएग्गमैन

9

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.

— डेनिस
स्रोत

8

हास्केल , 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/bb/af(z) = z + 1/zf(z) = f(1/z)

— XNOR
स्रोत

शायद hएक ऑपरेटर तीन तर्क ले रहा है? यह एक बाइट बचा सकता है, और मुझे लगता है कि यह नियमों के भीतर रहेगा।

— dfeuer

@ फ़ेडरर ज़रूर, यह निश्चित रूप से आधुनिक मानकों द्वारा अनुमति दी जाती है, हालांकि यह फ़ज़ीर था कि आई / ओ के साथ स्वतंत्रता क्या ली जा सकती है।

— XNOR

7

स्नोमैन 1.0.2 , 61 वर्ण

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

शुद्ध जिबरिश (जब तक कि आप स्नोमैन को नहीं जानते), उर्फ बिल्कुल भाषा के डिजाइन लक्ष्य के अनुरूप है जितना संभव हो उतना भ्रामक है।

इनपुट फॉर्मेट पोस्ट की तरह ही है, आउटपुट फॉर्मेट भी एक ही माइनस set(और है )।

अघोषित (या अघोषित, वास्तव में):

}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]) दूर होगा, अब तक स्नोमैन में: 0aa`NiN`aA|,nD(और यह मानकर कि हमें अन्य मौजूदा चर के साथ खिलवाड़ करने की चिंता नहीं है)। इसके बजाय, मैंने "डिवाइड" की विधेय के साथ "फोल्ड" पद्धति का उपयोग किया, जो दो तत्वों की एक सरणी के लिए, एक ही चीज को प्राप्त करता है।
0AAgaAसहज रूप से पर्याप्त दिखता है, लेकिन वास्तव में यह क्या करता है एक 0चर के लिए स्टोर करता है , फिर सभी चर को एक सूचकांक से अधिक लेता है (इसलिए, पहले एक को छोड़कर सभी चर)। लेकिन चाल है, के बजाय AaG(जो मूल सरणी और 0) से छुटकारा मिलेगा , मैंने इस्तेमाल किया AAg, जो दोनों को रखता है। अब मैं उपयोग करता हूं aA, एट-इंडेक्स, सरणी के पहले तत्व को प्राप्त करने के लिए बहुत ही समान0 का उपयोग करता हूं - इसके अलावा, यह उपभोग-मोड ( aAइसके बजाय aa) में है, इसलिए यह छुटकारा दिलाता है 0और मूल सरणी भी, जो अब के लिए कचरा हैं हमें।

काश, 0AAgaA*|अनिवार्य रूप से एक ही चीज़ जो गोल्फस्क्रिप्ट एक चरित्र में करता है (:। हालांकि, मुझे अभी भी लगता है कि स्नोमैन मानकों द्वारा यह बहुत अच्छा है। :)

— Doorknob
स्रोत

3

गणितज्ञ, 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}} *)

— मार्टिन एंडर
स्रोत

1

मुझे पता था कि गणितज्ञ किसी तरह आने वाला है!

— kirbyfan64sos

3

पायथ - 14 बाइट्स

उद्धरणों की तुलना करके फिल्टर, फिर नक्शे indexOf।

xLQfqcFSTcFvzQ

टेस्ट सूट ।

— Maltysen
स्रोत

यह मुख्य आकार को सॉर्ट नहीं करता है, इसलिए यह गलत उत्तर देगा जब मुख्य आकार की पहली साइड की लंबाई बड़ी हो। इस परीक्षण मामले को

— isaacg

@isaacg अच्छी बात है, ठीक कर देंगे।

— माल्टीसेन

उदाहरण के लिए, दोहराया तत्वों के साथ इनपुट पर यह विफल रहता है 1,2और सही के बजाय [(1, 2), (2, 4), (1, 2)]देगा । [0, 1, 0][0, 1, 2]

— orlp

मैं, यह एक स्वीकार करना चाहते हैं, क्योंकि यह है कम से कम है, लेकिन समस्या @orlp तय उल्लेख?

— kirbyfan64sos

1

@ kirbyfan64sos No.

— orlp

3

एपीएल (डायलॉग यूनिकोड) , 16 13 बाइट्स ^{एसबीसीएस}

(=.×∘⌽∨=.×)⍤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, जिसमें "अन्य" आयत एक जैसा दिखता है।

एपीएल (Dyalog विस्तारित) , 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 को धन्यवाद।

— Ven
स्रोत

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

— NGN

धन्यवाद। उस पहले का निरीक्षण करने की कोशिश करेंगे

— वेन

2

जूलिया, 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]})

— एलेक्स ए।
स्रोत

2

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

यह ओके में चलता है - ध्यान दें कि मैं स्पष्ट रूप से विभाजन पर निर्भर करता हूं जो हमेशा फ्लोटिंग पॉइंट परिणाम उत्पन्न करता है। यह काम करेगा Kona अगर आप इनपुट में सभी संख्याओं के लिए एक दशमलव बिंदु जोड़ा और के बाद एक स्थान जोड़ा _।

— JohnE
स्रोत

2

ऑक्टेव / मतलाब, 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

— लुइस मेंडो
स्रोत

2

ब्रेकीलॉग , 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.

अगर अजीब और विशिष्ट इनपुट स्वरूपण धोखा दे रहा है, तो यह थोड़ा लंबा है ...

ब्रेकीलॉग , 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ᵐ/ᵛ(जो साझा अनुपात या इसके पारस्परिक अनुपात को आउटपुट करता है)। सभी शेष तुलना करने के लिए कई आयतों को संभाल रहे हैं, और आउटपुट सूचकांकों हैं।

— असंबंधित स्ट्रिंग
स्रोत

2

डीज़िमा / एपीएल , 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

— dzaima
स्रोत

हालांकि यह एक अच्छा जवाब है, हमें सूचकांकों का उत्पादन करना होगा। तो आपके TIO परीक्षण मामले में परिणाम होना चाहिए [0,1,4]या [1,2,5](यह निश्चित नहीं है कि आपकी भाषा 0- या 1-अनुक्रमित है)। यदि तीनों आउटपुट-प्रारूपों की अनुमति दी जाती है तो यह एक बेहतर चुनौती है; सत्य मान रखने के लिए फ़िल्टर; केवल अनुमत सूचकांकों के बजाय सत्य / गलत मूल्यों (जैसे अब आपके पास) की सूची।

— केविन क्रूज़सेन

@KevinCruijssen "आप [...] आउटपुट का सटीक प्रारूप और क्रम चुन सकते हैं।" एपीएल में बूलियन वेक्टर के रूप में सूचकांकों को स्टोर करना बहुत आम बात है, लेकिन आप सही हैं, शायद यह स्पष्ट किया जाना चाहिए।

— dzaima

खैर, मैंने पढ़ा " आप सूचकांक 0- या कर रहे हैं कि क्या चुन सकते हैं, 1-आधारित रूप में अच्छी तरह सटीक प्रारूप और उत्पादन के आदेश के रूप में। " के रूप में यह हो सकता है [0,1,4], [1,2,5], 4\n0\n1, 5 2 1, आदि आदि, क्योंकि यह अभी भी कहा गया है सूचकांकों । लेकिन मैंने ओपी को स्पष्ट करने के लिए कहा है (यदि वे प्रतिक्रिया देते हैं, क्योंकि यह 4 साल पुरानी चुनौती है)। मेरे 05AB1E उत्तर में इसका मतलब होगा 14 बाइट्स यदि इंडेक्स अनिवार्य हैं 8 बाइट्स यदि अन्य दो विकल्पों में से किसी एक की अनुमति है। बावजूद, मैंने आपके जवाब को गलत ठहराया। :)

— केविन क्रूज़सेन

1

हास्केल, 75 बाइट्स

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

— लीफ़ विलर्ट्स
स्रोत

५६ बाइट्स

— २२:०४

54 बाइट्स

— डेफ़र

1

पॉवरशेल , 57 बाइट्स

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

इसे ऑनलाइन आज़माएं!

संकेत 1-आधारित हैं।

— Mazzy
स्रोत

1

पॉवरशेल , 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 बाइट्स को बचाने के लिए अलग-अलग आने से क्लॉज का थोड़ा दुरुपयोग करता है ।

पॉवरशेल , 61 59 बाइट्स

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

इसे ऑनलाइन आज़माएं!

वर्तमान शून्य-आधारित सूचकांक और शून्य रेखा के आधार पर शून्य के बीच स्वैप करने के लिए सशर्त अनुक्रमण का उपयोग करता है। सौभाग्य से, इस मामले में, $iचाहे वह मुद्रित हो या न हो , वेतन वृद्धि।

— Veskah
स्रोत

1

यदि आप -इसके बजाय उपयोग करते हैं तो आप अधिक बचत कर सकते हैं -ne।

— माज़ी

0

जावास्क्रिप्ट (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
}

— DankMemes
स्रोत

मुझे नहीं लगता कि यह दूसरे परीक्षण मामले के साथ काम करता है।

— kirbyfan64sos

@ kirbyfan64sos क्षमा करें, उस हिस्से को नहीं देखा। यह तय है (लेकिन मुझे यकीन है कि मैं इसे और अधिक गोल्फ कर सकता हूं)

— 23

ये JSON ऑब्जेक्ट्स नहीं हैं, ये प्लेन जावास्क्रिप्ट ऑब्जेक्ट्स हैं। JSON एक डेटा ट्रांसफर प्रारूप है।

— edc65

0

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कारण वहाँ हैं क्योंकि 05AB1E बहुआयामी सूचियों पर सूचकांक का निर्धारण नहीं कर सकते हैं

यदि सत्य की चौड़ाई या ऊँचाई जोड़े का उत्पादन करते हैं, या इनपुट-सूची के आधार पर सत्य / फाल्सी मूल्यों की सूची का उत्पादन करते हैं, तो इसके बजाय 8 बाइट्स हो सकते हैं :

ʒ‚ε{ü/}Ë

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

ε‚ε{ü/}Ë

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

— केविन क्रूज़सेन
स्रोत

लुकाइकल आकार

इसी तरह के आंकड़े

चुनौती

इनपुट

उत्पादन

नमूना कार्यक्रम

नमूना इनपुट और आउटपुट

जीतना

टिप्पणियाँ

अजगर, 15 बाइट्स

अजगर, 61 बाइट्स

CJam, 22 20 19 बाइट्स

यह काम किस प्रकार करता है

हास्केल , 48 बाइट्स

स्नोमैन 1.0.2 , 61 वर्ण

गणितज्ञ, 41 बाइट्स

पायथ - 14 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 16 13 बाइट्स ^{एसबीसीएस}

एपीएल (Dyalog विस्तारित) , 11 बाइट्स ^SBCS

जूलिया, 62 बाइट्स

K5, 19 बाइट्स

ऑक्टेव / मतलाब, 44 बाइट्स

ब्रेकीलॉग , 14 बाइट्स

ब्रेकीलॉग , 18 बाइट्स

डीज़िमा / एपीएल , 7 बाइट्स

हास्केल, 75 बाइट्स

पॉवरशेल , 57 बाइट्स

पॉवरशेल , 58 56 बाइट्स

पॉवरशेल , 61 59 बाइट्स

जावास्क्रिप्ट (ES6), 75

05AB1E , 15 14 बाइट्स

लुकाइकल आकार

इसी तरह के आंकड़े

चुनौती

इनपुट

उत्पादन

नमूना कार्यक्रम

नमूना इनपुट और आउटपुट

जीतना

टिप्पणियाँ

अजगर, 15 बाइट्स

अजगर, 61 बाइट्स

CJam, 22 20 19 बाइट्स

यह काम किस प्रकार करता है

हास्केल , 48 बाइट्स

स्नोमैन 1.0.2 , 61 वर्ण

गणितज्ञ, 41 बाइट्स

पायथ - 14 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 16 13 बाइट्स एसबीसीएस

एपीएल (Dyalog विस्तारित) , 11 बाइट्स SBCS

जूलिया, 62 बाइट्स

K5, 19 बाइट्स

ऑक्टेव / मतलाब, 44 बाइट्स

ब्रेकीलॉग , 14 बाइट्स

ब्रेकीलॉग , 18 बाइट्स

डीज़िमा / एपीएल , 7 बाइट्स

हास्केल, 75 बाइट्स

पॉवरशेल , 57 बाइट्स

पॉवरशेल , 58 56 बाइट्स

पॉवरशेल , 61 59 बाइट्स

जावास्क्रिप्ट (ES6), 75

05AB1E , 15 14 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 16 13 बाइट्स ^{एसबीसीएस}

एपीएल (Dyalog विस्तारित) , 11 बाइट्स ^SBCS