त्रिकोणों की संख्या गिनें

22

सकारात्मक पूर्णांक की एक सूची को देखते हुए, त्रिकोणों की संख्या ज्ञात करें जो हम इस प्रकार बना सकते हैं कि उनकी ओर की लंबाई इनपुट सूची के तीन अलग-अलग प्रविष्टियों द्वारा दर्शाई जाती है।

(प्रेरणा सीआर से आती है ।)

विवरण

  • एक त्रिभुज का निर्माण किया जा सकता है यदि तीन पक्ष लंबाई के सभी क्रमपरिवर्तन a,b,c सख्त त्रिकोण असमानता संतुष्ट करते हैं(इसका अर्थ है , और all hold।)
    a+b>c.
    a+b>ca+c>bb+c>a
  • सूची में अलग-अलग पदों पर तीन पक्ष की लंबाई दिखाई देनी चाहिए, लेकिन जरूरी नहीं कि जोड़ीदार अलग हो।a,b,c
  • इनपुट सूची में तीन नंबर का क्रम मायने नहीं रखता है। यदि हम एक सूची aऔर तीन संख्याओं a[i], a[j], a[k](जहां i,j,kजोड़ीदार अलग हैं) (a[i],a[j],a[k]), (a[i],a[k],a[j]), (a[j], a[i], a[k])पर विचार करते हैं , तो आदि सभी को एक ही त्रिकोण माना जाता है ।
  • इनपुट सूची में कम से कम 3 प्रविष्टियाँ शामिल हो सकती हैं।
  • आप मान सकते हैं कि इनपुट सूची आरोही क्रम में क्रमबद्ध है।

उदाहरण

एक छोटा सा परीक्षण कार्यक्रम यहाँ पर आज़मा कर देख सकते हैं!

Input, Output:
[1,2,3]  0
[1,1,1]  1
[1,1,1,1] 4
[1,2,3,4] 1
[3,4,5,7] 3
[1,42,69,666,1000000] 0
[12,23,34,45,56,67,78,89] 34
[1,2,3,4,5,6,7,8,9,10] 50

इस के इनपुट के [1,2,3,...,n-1,n]लिए A002623 है ।

[1,1,...,1](लंबाई n) के इनपुट के लिए यह A000292 है ।

पहले nफाइबोनैचि संख्याओं ( A000045 ) के इनपुट के लिए यह A000004 है ।

code-golf  sequence  array-manipulation  integer  geometry 
— flawr
स्रोत
4
मुझे लगता है कि चुनौती एक अलग त्रिकोण के रूप में गिना जा सकता है। से A000292 लिंक, मैं इसे ले [1,1,1,1]4 "अलग" त्रिकोण की अनुमति देता है, सब [1,1,1], किसी भी तीन 1 के का उपयोग कर चुना जाना? लेकिन, यह 24 नहीं है, क्योंकि तीनों 1 को अनियंत्रित चुना गया है, अर्थात यह एक आदेशित सूची के बजाय तीन सूचकांकों का उपसमूह है?
— xnor
2
@xnor Thatnks यह इंगित करने के लिए, कि यह सब सही लगता है - मैंने अभी विवरण में एक बिंदु जोड़ा है। मुझे उम्मीद है कि अब यह स्पष्ट हो जाएगा।
— दोष

जवाबों:

10

आर , 62 52 40 34 बाइट्स

sum(c(1,1,-1)%*%combn(scan(),3)>0)

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

लुइस मेंडो के ऑक्टेव समाधान का पोर्ट

चूंकि a<=b<=c, त्रिकोण स्थिति के बराबर है a+b-c>0। a+b-cसंक्षेप मैट्रिक्स उत्पाद द्वारा कब्जा कर लिया है [1,1,-1] * X, जहां Xइनपुट सरणी के 3-संयोजन है।

टिप्पणियों में 3 अलग-अलग लोगों द्वारा किए गए सुधारों के लिए बहुत सारे सुझाव थे:

आर , 40 बाइट्स

y=combn(scan(),3);sum(y[3,]<y[1,]+y[2,])

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

— ग्यूसेप
स्रोत
— रॉबर्ट एस।
3
x[3]<x[1]+x[2]के बराबर है 2*x[3]<sum(x): 51 बाइट्स
— रॉबिन राइडर
4
वास्तव में, कि 45 बाइट्स बनाते हैं । कई टिप्पणियों के लिए क्षमा करें!
— रॉबिन राइडर
1
@RobinRyder आलिया [चालाक है, वास्तव में दृष्टिकोण को साफ करता है।
— क्रिमिनल
2
40
— निक केनेडी
9

स्टैक्स , 8 7 बाइट्स

-1 के लिए पुनरावर्ती के लिए धन्यवाद !

é═rê÷┐↨

भागो और इसे staxlang.xyz पर डीबग करें!

अनपैक्ड (8 बाइट्स) और स्पष्टीकरण:

r3SFE+<+
r           Reverse
 3S         All length-3 combinations
   F        For each combination:
    E         Explode: [5,4,3] -> 3 4 5, with 3 atop the stack
     +        Add the two shorter sides
      <       Long side is shorter? 0 or 1
       +      Add result to total

वह साफ सुथरी चाल है। यदि आपके पास निर्देशों का एक क्रम है जो हमेशा 0 या 1 में परिणाम देगा और आपको अपने सरणी के आइटम को गिनने की आवश्यकता है जो आपके कार्यक्रम के अंत में सत्य परिणाम देता है, तो F..+बाइट से कम है{..f% ।

मान लें कि प्रारंभिक सूची आरोही क्रमबद्ध है। इस धारणा के बिना, oशुरुआत में 8 बाइट्स के लिए छड़ी ।

— खुल्द्रेसथ न’बैरी
स्रोत
1
r3SFE+<+7. पैक करने के लिए। यह फ़िल्टर परिणामों को जोड़ने के लिए एक फ़ॉरेस्ट लूप का उपयोग करता है। जोड़ केवल एक ही तत्व मौजूद होने पर एक संचालन नहीं है।
— पुनरावर्ती
6

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

([]%)
[c,b,a]%l|a+b>c=1
p%(h:l)=(h:p)%l+p%l
_%_=0

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

पुनरावर्ती l(उलट) के सभी बाद उत्पन्न करता है, और जाँच करता है कि कौन से लंबाई -3 वाले त्रिकोण बनाते हैं।

50 बाइट्स

f l=sum[1|[a,b,c]<-filter(>0)<$>mapM(:[0])l,a+b>c]

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

एक ही विचार, mapMप्रत्येक के साथ lस्वयं (शामिल) या 0(बहिष्कृत) में प्रत्येक मूल्य को मैप करके, उसके बाद परिणाम उत्पन्न करना ।

50 बाइट्स

([]%)
p%(b:t)=sum[1|c<-t,a<-p,a+b>c]+(b:p)%t
_%_=0

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

हर विभाजन बिंदु को मध्य तत्व लेने की कोशिश करता है b।

51 बाइट्स

f(a:t)=f t+sum[1|b:r<-scanr(:)[]t,c<-r,a+b>c]
f _=0

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

फ़ंक्शन q=scanr(:)[]प्रत्यय की सूची उत्पन्न करता है। बराबर तत्वों को सही समय की संख्या सहित विचार करने की आवश्यकता से बहुत परेशानी होती है।

52 बाइट्स

q=scanr(:)[]
f l=sum[1|a:r<-q l,b:s<-q r,c<-s,a+b>c]

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

सहायक फ़ंक्शन q=scanr(:)[]प्रत्यय की सूची उत्पन्न करता है।

57 बाइट्स

import Data.List
f l=sum[1|[a,b,c]<-subsequences l,a+b>c]

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

— XNOR
स्रोत
4

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

{⊇Ṫ.k+>~t}ᶜ

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

मैं अपने पुराने समाधान में हल किए गए इनपुट का लाभ लेना भूल गया हूँ:

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

{⊇Ṫ¬{p.k+≤~t}}ᶜ

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

{            }ᶜ    The output is the number of ways in which
 ⊇                 a sublist of the input can be selected
  Ṫ                with three elements
   ¬{       }      such that it is not possible to show that
     p             for some permutation of the sublist
       k+          the sum of the first two elements
         ≤         is less than or equal to
      .   ~t}      the third element.
— असंबंधित स्ट्रिंग
स्रोत
4

पर्ल 6 , 35 बाइट्स

+*.combinations(3).flat.grep(*+*>*)

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

व्याख्या

यह एक कोड है, यानी लंबोदर कार्यों के लिए एक संक्षिप्त संकेतन (जो केवल बहुत ही सरल मामलों में काम करता है)। प्रत्येक *एक तर्क के लिए एक प्लेसहोल्डर है। तो हम लंबाई की सूची लेते हैं (जो पहली बार में प्रकट होती है *), 3 तत्वों के सभी संयोजन बनाते हैं (वे हमेशा उसी क्रम में निकलते हैं जैसे कि मूल सूची में, ताकि इसका अर्थ है कि संयोजन भी क्रमबद्ध हो जाएं), सूची को समतल करें, और फिर सूची को 3-बाय -3 लें, और फ़िल्टर करें ( grep) केवल उन ट्रिपल को संतुष्ट करें *+*>*, जो कि पहले दो तर्कों का योग तीसरे से अधिक है। यह सभी तिकड़ी देता है, और हम अंत में उन्हें एक के साथ संख्यात्मक संदर्भ मजबूर करने के साथ गिनते हैं +।

(निश्चित रूप से हमें केवल "दो छोटे> सबसे बड़े" के मामले के लिए इसका परीक्षण करने की आवश्यकता है। यदि यह पकड़ में है, तो दूसरा तुच्छ रूप से पकड़ रखता है, यदि यह नहीं करता है, तो ट्रिपलेट सही त्रिकोण लंबाई को निरूपित नहीं करता है और हम नहीं करते हैं। आगे देखने की जरूरत है।)

— Ramillies
स्रोत
4

रेटिना , 55 बाइट्स

\d+
*
L$`_+
$<'
%L$w`(,_+)\b.*\1(_*)\b(?<=^_+\2,.*)
_
_

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं, लेकिन 5 वें मामले में मूल्यों के साथ आज इसे खत्म करने की अनुमति दी गई है। सॉर्ट किए गए इनपुट मानता है। स्पष्टीकरण: Regexes वास्तव में एक से अधिक चीज़ों का मिलान पसंद नहीं करता है। एक सामान्य रेगेक्स उन सभी मूल्यों को खोजने में सक्षम होगा जो एक त्रिकोण का सबसे छोटा पैर हो सकता है। vलुकहेड से बचने के लिए रेटिना का विकल्प यहां मदद नहीं करता है। हालांकि रेटिना का wविकल्प थोड़ा अधिक सहायक है, क्योंकि यह एक ही समय में सबसे छोटा और सबसे लंबा पैर दोनों को खोजने में सक्षम होगा। हालांकि इस चुनौती के लिए पर्याप्त नहीं है, क्योंकि कई मध्य पैर हो सकते हैं।

\d+
*

इनपुट को unary में बदलें।

L$`_+

प्रत्येक इनपुट नंबर के लिए ...

$<'

... एक ऐसी लाइन बनाएं जो मूल संख्या को उस नंबर पर शुरू करने के लिए छोटा किया गया हो। $'आम तौर पर मैच के बाद स्ट्रिंग का मतलब है, लेकिन <यह पिछले विभाजक के बाद स्ट्रिंग का मतलब है, पर 2 बाइट्स बर्बाद करने से परहेज करता है $&। इसलिए प्रत्येक पंक्ति उस संख्या को सबसे छोटे पैर के रूप में उपयोग करते हुए सभी संभावित समाधानों का प्रतिनिधित्व करती है।

%L$w`(,_+)\b.*\1(_*)\b(?<=^_+\2,.*)
_

उन पंक्तियों में से प्रत्येक के लिए, सभी संभव मध्य और सबसे लंबे पैर मिलते हैं, लेकिन यह सुनिश्चित करना कि अंतर पहले चरण से कम है। _पैरों के प्रत्येक मिलान संयोजन के लिए आउटपुट ।

_

पाए गए त्रिकोणों की कुल संख्या की गणना करें।

— नील
स्रोत
3

05AB1E , 12 10 9 बाइट्स

मेरा पहली बार 05AB1E का उपयोग कर! -1 के लिए [गंभीर] के लिए धन्यवाद!

3.Æʒ`α›}g

इसे ऑनलाइन आज़माएं!या परीक्षण सूट

मेरे स्टेक्स उत्तर का एक सीधा पोर्ट। तीन प्रविष्टियों के सभी संयोजन प्राप्त करें और उन लोगों को गिनें जो संभवतः त्रिकोण बना सकते हैं। यह उस गिनती का हिस्सा है जो वास्तव में मुझे मिला है। मैं वहाँ बाइट्स का एक भार खर्च करता हूं। वहाँ कुछ धोखेबाज़ गलती करने के लिए बाध्य है।

3.Æʒ`α›}g
3.Æ          List of length-3 combinations
   ʒ   }g    Count truthy results under operation:
    `          Push the two shorter sides, then the long one
     α         Absolute difference (negated subtraction in this case)
      ›        Remaining short side is longer?
— खुल्द्रेसथ न’बैरी
स्रोत
2
मुझे यकीन है कि ग्रैमी कुछ छोटा होगा, क्योंकि वह आमतौर पर मेरे उत्तरों पर काम करता है। ;) लेकिन आपका जवाब काफी हद तक वैसा ही दिखता है जैसा मेरे मन में था। केवल अंतर यह है कि मैंने ìफिल्टर के Šअंदर (ट्रिपल स्वैप) के बजाय फ़िल्टर से पहले (प्रत्येक को उल्टा) का उपयोग किया है । वैकल्पिक रूप से, आप ε...}Oइसके बजाय उपयोग भी कर सकते हैं ʒ...}g, लेकिन बाइट-काउंट समान रहता है। पुनश्च: 10 और टीआईओ की आपकी बाइट गिनती सही है, लेकिन आपके वास्तविक उत्तर में अभी भी एक अनावश्यक स्पष्टता है yजिसे हटाया जा सकता है। :) अच्छा पहला जवाब है, तो मुझे से +1।
— केविन क्रूज़सेन
क्षमा करें, @ केविनक्रूजसेन को निराश करने के लिए, मेरे पास 3.ÆʒRÆd_}gजो कुछ है, वही बायटाउन है।
— ग्रैमी
2
@KevinCruijssen ओह वास्तव में मुझे लगता है कि 3.Æʒ`α›}g9. है
— ग्रिमी
@Grimy Haha, यह जानती थी। एक्सडी प्रिटी स्ट्रेट-फॉरवर्ड गोल्फ कि अब मैं इसे देखता हूं .. लेकिन आप आमतौर पर उन प्रकार के गोल्फ (या सामान्य रूप से गोल्फ ..) के साथ आने में बेहतर होते हैं, जैसा कि मैंने अपनी पहली टिप्पणी में उल्लेख किया है। ; पी
— केविन क्रूज़सेन
2

Zsh , 66 बाइट्स

for a;z=$y&&for b (${@:2+y++})for c (${@:3+z++})((t+=c<a+b))
<<<$t

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

क्रमबद्ध इनपुट का लाभ उठाते हुए, और forहेडर में वृद्धि ( पेरेंट लूप के अनुसार वेतन वृद्धि एक बार होती है)।

for a;{
  z=$y
  for b (${@:2+y++});{   # subarray starting at element after $a
    for c (${@:3+z++})   # subarray starting at element after $b
      ((t+=c<a+b))
  }
}
— GammaFunction
स्रोत
2

एक्सेल VBA, 171 164 152 बाइट्स

-26 बाइट्स टेलरस्कॉट को धन्यवाद

Sub z
t=[A:A]
u=UBound(t)
For i=1To u-2
For j=i+1To u-1
For k=j+1To u
a=t(i,1):b=t(j,1):c=t(k,1)
r=r-(a+b>c)*(b+c>a)*(c+a>b)
Next k,j,i
Debug.?r
End Sub

इनपुट A:Aसक्रिय शीट की सीमा में है। आउटपुट तत्काल विंडो पर है।

चूंकि यह प्रत्येक सेल के हर संयोजन को देखता है जो 2 20 सेल लंबा होता है (जो लगभग 2 60 संयोजन है), यह कोड है ... तेज़ नहीं। आप इसे बहुत तेज़ बना सकते हैं लेकिन बाइट्स की कीमत पर।

— इंजीनियर टोस्ट
स्रोत
आप ड्रॉप कर सकते हैं ()में, उप बयान में अंतरिक्ष Debug.? rऔर ड्रॉप कर सकते हैं Next:Next:Nextकरने के लिए Next k,j,i। उस तरफ से - अच्छी तरह से अभी भी 2 ** 60 संयोजन कर रहा है लेकिन यह काम करता है
— टेलर स्कॉट
ओह और हे, आप कुछ और बाहर छोड़ सकते हैं अगरr=r-(a+b>c)*(b+c>a)*(c+a>b)
— स्कॉट पर टेलर स्कॉट
1

चारकोल , 17 बाइट्स

ＩΣ⭆θ⭆…θκ⭆…θμ›⁺νλι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। सॉर्ट किए गए इनपुट मानता है। स्पष्टीकरण:

   θ                Input array
  ⭆                 Map over elements and join
      θ             Input array
     …              Truncated to length
       κ            Outer index
    ⭆               Map over elements and join
          θ         Input array
         …          Truncated to length
           μ        Inner index
        ⭆           Map over elements and join
              ν     Innermost value
             ⁺      Plus
               λ    Inner value
            ›       Is greater than
                ι   Outer value
 Σ                  Take the digital sum
Ｉ                   Cast to string for implicit print
— नील
स्रोत
1

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

*1sm>sPded.cQ3

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

          .cQ3  # All combinations of length 3 from Q (input), sorted in ascending order
   m            # map over that lambda d:
     sPd        #   sum(d[:-1])
    >   ed      #     > d[-1]
  s             # sum all of those (uses the fact that True = 1)
*1              # multiply by 1 so it doesn't output True if there's only one triangle

वैकल्पिक (14 बाइट्स भी):

lfTm>sPded.cQ3
— ar4093
स्रोत
1

पर्ल 5 ( -p), 55 52 बाइट्स

regex backtracking का उपयोग करते हुए, -3 बाइट्स @Cows क्वैक का उपयोग करके धन्यवाद ^(?!) और बैकट्रैक के बजाय ।

$d='(\d++)';$_=/$d.* $d.* $d(?{$n++if$1+$2>$3})^/+$n

या

$_=/(\d++).* (\d++).* (\d++)(?{$n++if$1+$2>$3})^/+$n

TIO

— नहुएल फौलीउल
स्रोत
हो सकता (?!)है ^?
— कृति लिथोस
धन्यवाद यह विफल हो जाता है / अच्छी तरह से पीछे हट जाता है
— नाहुएल फौइउल
1

जेली , 9 बाइट्स

œc3+>ƭ/€S

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

एक विवादास्पद लिंक पूर्णांकों की क्रमबद्ध सूची को अपने तर्क के रूप में लेता है और त्रिकोणों की संख्या लौटाता है।

व्याख्या

œc3       | Combinations of length 3
     ƭ/€  | Reduce each using each of the following in turn:
   +      | - Add
    >     | - Greater than
        S | Sum (counts the 1s)

वैकल्पिक 9s:

œc3Ṫ€<§ƊS
œc3Ṫ<SƊ€S
— निक केनेडी
स्रोत
0

SNOBOL4 (CSNOBOL4) , 181 बाइट्स

	S =TABLE()
R	X =X + 1
	S<X> =INPUT	:S(R)
I	I =J =K =I + 1	LT(I,X)	:F(O)
J	J =K =J + 1	LT(J,X)	:F(I)
K	K =K + 1	LT(K,X - 1)	:F(J)
	T =T + 1 GT(S<I> + S<J>,S<K>)	:(K)
O	OUTPUT =T
END

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

पाशविक बल हे(n3)कलन विधि। इनपुट को एक नईलाइन की अलग सूची के रूप में लेता है और त्रिकोण की संख्या, या के लिए एक खाली लाइन आउटपुट करता है 0। यह संभवतः स्वीकार्य है क्योंकि SNOBOL 0संख्यात्मक गणना के लिए खाली स्ट्रिंग का इलाज करता है ।

— ग्यूसेप
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.