एक बहुपद के इंटीग्रल रूट का पता लगाएं

19

चुनौती

चुनौती ऐसे प्रोग्राम को लिखना है जो किसी भी n-डिग्री बहुपद समीकरण के गुणांक को इनपुट के रूप में लेता है और x के अभिन्न मूल्यों को लौटाता है जिसके लिए समीकरण सही रहता है। गुणांक को घटती या बढ़ती शक्ति के क्रम में इनपुट के रूप में प्रदान किया जाएगा। आप सभी गुणांक को पूर्णांक मान सकते हैं ।

इनपुट और आउटपुट

इनपुट शक्ति के घटते या बढ़ते क्रम में समीकरण का गुणांक होगा। समीकरण की डिग्री, यानी, एक्स की अधिकतम शक्ति, इनपुट में कुल तत्वों की संख्या से हमेशा 1 कम है।

उदाहरण के लिए: 

[1,2,3,4,5] -> represents x^4 + 2x^3 + 3x^2 + 4x + 5 = 0 (degree = 4, as there are 5 elements)
[4,0,0,3] -> represents 4x^3 + 3 = 0 (degree = 3, as there are 3+1 = 4 elements)

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

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

उदाहरण

[1,5,6] -> (-3,-2)
[10,-42,8] -> (4)
[1,-2,0] -> (0,2)
[1, 1, -39, -121, -10, 168] -> (-4, -3, -2, 1, 7)
[1, 0, -13, 0, 36] -> (-3, -2, 2, 3)
[1,-5] -> (5)
[1,2,3] -> -

ध्यान दें कि दूसरे उदाहरण में समीकरण में रूट 0.2 भी है, लेकिन यह प्रदर्शित नहीं होता है क्योंकि 0.2 पूर्णांक नहीं है।

स्कोरिंग

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड (बाइट्स में) जीतता है!

code-golf  number  integer  polynomials  equation 
— मनीष कुंडू
स्रोत
7
नोट: पास करने के लिए मतदान से पहले, पर विचार करें कि इस सवाल यह है कि नहीं का डुप्लिकेट इस एक । मैं इस समस्या के लिए कम से कम एक दृष्टिकोण के बारे में सोच सकता हूं जो अन्य चुनौती के लिए मामूली रूप से परिवर्तनीय नहीं होगा (हालांकि यह नहीं कह रहा है कि क्या है? यह आपके लिए छोड़ दिया गया है; पी)।
— 14
क्या हम मान सकते हैं कि हमें केवल अपनी भाषा के पूर्णांक सीमा के अंदर जड़ों को वापस करने की आवश्यकता है? या फिर एल्गोरिथ्म काम करना चाहिए भले ही भाषाओं के पूर्णांक प्रकार की सीमा बढ़ गई हो, लेकिन व्यवहार समान रहा।
— Οआयुस
1
यदि आपकी भाषा उन लोगों का समर्थन करती है, तो क्या हम एक मूल बहुपद प्रकार का उपयोग कर सकते हैं?
— दोष
1
यदि कोई समाधान स्वीकार नहीं किया जाता है तो क्या कार्यक्रम हमेशा के लिए चलते हैं?
— जैक एम
1
कि चीजों को सरल रखना है।
— मनीष कुंडू

जवाबों:

6

MATL , 13 12 बाइट्स

|stE:-GyZQ~)

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

यह इस तथ्य का उपयोग करता है कि, पूर्णांक गुणांक के लिए, किसी भी जड़ का पूर्ण मूल्य गुणांक के पूर्ण मूल्यों के योग से कड़ाई से कम है।

व्याख्या

[1 5 6]उदाहरण के रूप में इनपुट पर विचार करें ।

|    % Implicit input. Absolute value
     % STACK: [1 5 6]
s    % Sum
     % STACK: 12
t    % Duplicate
     % STACK: 12, 12
E    % Multiply by 2
     % STACK: 12, 24
:    % Range
     % STACK: 12, [1 2 ... 23 24]
-    % Subtract, elemet-wise
     % STACK: [11 10 ... -11 -12]
G    % Push input again
     % STACK: [11 10 ... -11 -12], [1 5 6]
y    % Duplicate from below
     % STACK: [11 10 ... -11 -12], [1 5 6], [11 10 ... -11 -12]
ZQ   % Polyval: values of polynomial at specified inputs
     % STACK: [11 10 ... -11 -12], [182 156 ... 72 90]
~    % Logical negation: turns nonzero into zero
     % STACK: [11 10 ... -11 -12], [0 0 ... 0] (contains 1 for roots)
)    % Index: uses second input as a mask for the first. Implicit display
     % STACK: [-3 -2]
— लुइस मेंडो
स्रोत
3
रूचे के प्रमेय के विकल्प के रूप में, तर्कसंगत जड़ प्रमेय भी आपके द्वारा उपयोग किए जाने वाले बाउंड को सही ठहराने के लिए पर्याप्त होगा। तर्कसंगत मूल सिद्धांत के अनुसार, सभी पूर्णांक जड़ें गुणांक के पूर्ण मूल्यों के अधिकतम द्वारा पूर्ण मान में बंधी होती हैं, जो राशि की तुलना में बंधी हुई होती हैं। या यहां तक ​​कि तंग, "अंतिम" nonzero गुणांक के निरपेक्ष मूल्य से - यानी x की सबसे छोटी शक्ति का गुणांक जिसमें एक nonzero गुणांक है। (संभवत: किसी भी बाइट को बचाने में मदद नहीं करता है, बस एक वैकल्पिक प्रमाण है क्योंकि
— आरआरटी ​​शायद रूचे की
1
@mathmandan जो दृष्टिकोण तीन बाइट्स लंबा है: इसे यहां आज़माएं , हालांकि मुझे यकीन है कि मैंने एक चाल या दो को याद किया है
— Giuseppe
@Giuseppe दोनों को धन्यवाद। हो सकता है X>t_w&:GyZQ~), लेकिन अभी भी 13 बाइट्स
— लुइस मेंडो
1
... लेकिन मुझे सीमा के लिए एक छोटा विकल्प मिला
— लुइस मेंडो
5

भूसी , 10 9 बाइट्स

-1 बाइट ज़गरब को धन्यवाद

uSȯf¬`Bṁṡ

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

व्याख्या

       ṁṡ   Concatenate together the symmetric ranges of each coefficient
            (It is guaranteed that the integer roots lie in the range [-n..n],
                        where n is the coefficient with the largest magnitude)
 Sȯf        Find all the values in that range which
    ¬       are zero
     `B     when plugged through the polynomial
            (Base conversion acts as polynomial evaluation)
u           De-duplicate the roots
— H.PWiz
स्रोत
आप ṁṡइसके बजाय oṡ►aयदि आप बाद में समर्पण कर सकते हैं।
— जर्गब
@Zgarb बहुत अच्छा! धन्यवाद
— H.PWiz
5

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

f l|t<-sum$abs<$>l=[i|i<-[-t..t],foldl1((+).(i*))l==0]

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

ब्रूट बल और सिंथेटिक विभाजन।

UniHaskell के साथ Ungolfed और-XUnicodeSyntax

import UniHaskell

roots    ∷ Num a ⇒ [a] → [a]
roots xs = [r | r ← -bound … bound, foldl1 ((+) ∘ (r ×)) xs ≡ 0]
             where bound = sum $ abs § xs

वैकल्पिक समाधान, 44 बाइट्स

नामी को श्रेय।

f l=[i|i<-[minBound..],foldl1((+).(i*))l==0]

यह ऑनलाइन कोशिश करने के साथ सौभाग्य है , क्योंकि यह एक 'श्रेणी में हर नंबर की जाँच करता है Int।

— totallyhuman
स्रोत
आप पूरी चीज़ को हटा सकते iहैं [minBound..]और उसमें से इसे हटा सकते हैं t। fस्पष्ट Intसूचियों के साथ कॉल करें , जैसे f [1::Int,5,6]। बेशक यह उचित समय में खत्म नहीं होता है।
— nimi
@nimi ऐसा क्यों रुकेगा? यह असीम पाश नहीं होगा?
— पूरी तरह से
नहीं, Boundedप्रकार पर रोक maxBound, जैसे print [minBound::Bool ..]।
— नीम
4

पायथन 2 + सुन्न, 95 93 91 103 93 91 82 बाइट्स

-2 बाइट्स ओवी को
धन्यवाद, जड़ों की ऊपरी / निचली सीमा के लिए लुइस मेंडो को धन्यवाद
-10 बाइट्स मिस्टर एक्सकोडर की बदौलत

from numpy import*
def f(r):s=sum(fabs(r));q=arange(-s,s);print q[polyval(r,q)==0]

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

— छड़ी
स्रोत
— ओव्स
@LuisMendo हाँ।
— रॉड
3
हमारी वर्तमान आम सहमति यह प्रतीत होती है कि कार्यक्रमों को हमेशा समाप्त होना चाहिए, जब तक कि चुनौती अन्यथा न हो।
— जर्गब
@Zgarb, वहाँ तय!
— रॉड
का उपयोग करते हुए numpy.polyvalकाफी कुछ बाइट्स बचाता है
— श्री Xcoder
4

Wolfram भाषा (Mathematica) , 50 47 42 25 27 बाइट्स

{}⋃Select[x/.Solve[#~FromDigits~x==0],IntegerQ]&

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

अद्यतन: लुइस मेंडो के तथ्य का उपयोग करते हुए, एक और 3 बाइट्स को बंद कर दिया

Pick[r=Range[s=-Tr@Abs@#,-s],#~FromDigits~r,0]&

सीमा के साथ ढलान प्राप्त करना, हम इस 5 और बाइट्स को कम कर सकते हैं @ एक पेड़ का सुझाव:

Pick[r=Range[s=-#.#,-s],#~FromDigits~r,0]&

इसे पोस्ट करने के बाद, ओपी ने "देशी बहुपद" की अनुमति देते हुए टिप्पणी की, इसलिए यहां 25 बाइट समाधान है जो इनपुट के रूप में बहुपद को स्वीकार करता है। यह काम करता है क्योंकि डिफ़ॉल्ट रूप से गणितज्ञ कारक पूर्णांक से अधिक बहुपद रखते हैं, और कोई तर्कसंगत जड़ें एक रूप में दिखाई देती हैंm*x+b कि पैटर्न मिलान विफल हो जाता है।

Cases[Factor@#,b_+x:>-b]&

जैसा कि @alephalpha ने बताया कि यह उस मामले के लिए विफल होगा जहां शून्य एक जड़ है, इसलिए यह तय करने के लिए कि हम उपयोग कर सकते हैं Optional प्रतीक का:

Cases[Factor@#,b_:0+x:>-b]&

यह ठीक गणितज्ञ 11.0.1 को पार करता है, लेकिन विफल रहता है और चारों ओर कोष्ठकों के एक अतिरिक्त सेट की आवश्यकता होती है b_:0 संस्करण 11.2 में । यह 27 बाइट्स तक वापस ले जाता है, प्लस 11.0.1 संस्करण के बाद दो और। यह एक "ठीक" में रखा गया था की तरह लग रहा है यहाँ

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

— केली लोवदर
स्रोत
1
मुझे लगता है कि आप #.#इसके बजाय उपयोग कर सकते हैं Tr@Abs@#: यह एक खराब बाध्य लेकिन कम बाइट्स है।
— पेड़ नहीं
1
ओपी ने एक टिप्पणी में कहा कि आप अपनी भाषा के मूल बहुपद का उपयोग कर सकते हैं यदि कोई मौजूद है। मैं गणितज्ञ को अच्छी तरह से नहीं जानता लेकिन मुझे लगता है कि एक है ... क्या इससे बाइट्स बचेंगे?
— नहीं
1
— एलीफ़लफा
1
@alephalpha, फिक्स्ड
— केली लोल्डर
— रोमन
3

वोल्फ्राम भाषा (गणितज्ञ) , ३३ २६ 31 बाइट्स

टिप्पणियों में केली लोडर द्वारा नोट की गई एक त्रुटि।

x/.{}⋃Solve[#==0,x,Integers]&

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

पिछले गलत समाधान:

मैंने अभी देखा कि बिना पूर्णांक समाधान के, आउटपुट खाली सूची के बजाय अपरिभाषित है; जो कुछ बाइट्स को हटाने की अनुमति देता है।

x/.Solve[#==0,x,Integers]&

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

अब यदि कोई पूर्णांक समाधान मौजूद नहीं है, तो फ़ंक्शन लौटता है x।

पहले:

x/.Solve[#==0,x,Integers]/.x->{}&

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

— celtschk
स्रोत
यह 1,2,1 के साथ वर्तमान में विफल रहता है क्योंकि यह रूट को दोहराता है और ओपी ने कहा कि उन्हें अलग होना चाहिए। आपको Unionइसे ठीक करने की आवश्यकता है।
— केली लोल्डर
@ केलीलॉडर: आह, मैं चूक गया। लेकिन तब, यह दिए गए परीक्षण मामलों में भी गायब था।
— celtschk
@ केलीलौड: मैंने अब इसे ठीक कर लिया है। यदि आप इसकी वजह से कम हो गए हैं, तो क्या आप इसे वापस कर सकते हैं?
— celtschk
@cellschk, हाँ किया।
— केली लोल्डर
29 अछूता सुविधा का उपयोग करके बाइट्सSolve : चर की सूची को छोड़ा जा सकता है।
— रोमन
3

आर , 61 59 बाइट्स

मेरे (गलत) दृष्टिकोण को इंगित करने के लिए @mathmandan के लिए एक विशेष धन्यवाद बचाया जा सकता है, और गोल्फ!

function(p)(x=-(t=p[!!p][1]):t)[!outer(x,seq(p)-1,"^")%*%p]

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

बढ़ते क्रम में गुणांक की सूची के रूप में इनपुट लेता है , अर्थात, का c(-1,0,1)प्रतिनिधित्व करता है -1+0x+1x^2।

तर्कसंगत रूट प्रमेय का उपयोग करते हुए, 47 बाइट्स के लिए निम्नलिखित दृष्टिकोण बहुत काम करता है:

function(p)(x=-p:p)[!outer(x,seq(p)-1,"^")%*%p]

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

-p:pएक सममित रेंज (एक चेतावनी के साथ) उत्पन्न करता है का केवल पहला तत्व का उपयोग p, a_0। तक वाजिब रूट प्रमेय , के सभी परिमेय मूल Pरूप से किया जाना चाहिए p/qजहां pविभाजित a_0और qविभाजित a_n(प्लस या माइनस)। इसलिए, बस का उपयोग कर a_0के लिए पर्याप्त है |a_0|>0, किसी के लिए के रूप में q, |p/q|<=a_0। हालाँकि, जब a_0==0, तब कोई पूर्णांक विभाजित होता है 0, और इस प्रकार यह विफल हो जाता है।

हालाँकि, मैथमैडान बताते हैं कि वास्तव में, इस मामले में, इसका मतलब यह है कि इसका एक निरंतर कारक है, x^kजिसे फैक्टर आउट किया जा सकता है, और, यह मानते हुए कि kयह अधिकतम है, हम देखते हैं कि

P(x) = x^k(a_k + a_{k+1}x + ... a_n x^{n-k}) = x^k * Q(x)

हम तब तर्कसंगत जड़ प्रमेय को लागू करते हैं Q(x), और जैसा a_kकि अधिकतम की गैर-बराबरी से होने की गारंटी है k, a_kपूर्णांक की जड़ों के लिए बाध्यता प्रदान करता है Q, और जड़ों की Pजड़ Qशून्य के साथ होती है, इसलिए हम सभी पूर्णांक होंगे Pइस विधि को लागू करने से जड़ें ।

यह बहुपद के पहले नॉनजेरो गुणांक को खोजने के बराबर है, t=p[!!p][1]और भोले के बजाय इसका उपयोग p[1]सीमा के रूप में करता है। इसके अलावा, चूंकि रेंज में -t:tहमेशा शून्य होता है, इसलिए Pइस सीमा पर आवेदन करने से हमें एक मूल के रूप में शून्य मिलेगा, यदि वास्तव में यह है।

ungolfed:

function(polynom) {
 bound <- polynom[polynom != 0][1]             #first nonzero value of polynom
 range <- -bound:bound                         #generates [-bound, ..., bound]
 powers <- outer(range,seq_along(p) - 1, "^")  #matrix where each row is [n^0,n^1,n^2,...,n^deg(p)]
 polyVals <- powers %*% polynom                #value of the polynomial @ each point in range
 return(range[polyVals == 0])                  #filter for zeros and return
}

— ग्यूसेप
स्रोत
(मुझे लगता है कि आप maxइसके बजाय पूर्ण मूल्यों का उपयोग कर सकते हैं sum; यह बाइट गिनती नहीं बदलेगा, लेकिन इसे प्रदर्शन में सुधार करना चाहिए।) वैसे भी, हाँ, छोटे संस्करण के साथ काम नहीं करता है a_0==0। आर में कुछ छोटा रास्ता है जो पहले (शक्तियों के आरोही के साथ) नॉनज़रो गुणांक के लिए खोज करता है, और इसके बजाय इसका उपयोग करता है? यह पहले से संभव के रूप में कई एक्स के रूप में फैक्टरिंग के अनुरूप होगा (बेशक, फिर आपको आउटपुट 0भी याद रखना होगा, जो संभवतः कुछ बाइट्स खर्च करेगा।)
— मैथमंडन
@mathmandan maxअधिक कुशल होगा, लेकिन आपके दूसरे बिंदु के रूप में, 0जब तक कि यह रेंज द्वारा उत्पन्न नहीं किया जाता है -t:t(जहां tपहला गैर-गुणांक गुणांक है) के बारे में मुझे चिंता करने की ज़रूरत नहीं है , यह 2 बाइट्स बचाता है!
— ग्यूसेप
ओह बहुत अच्छा! (और साथ ही एक सुंदर व्याख्या।)
— मैथमैडैन
2

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

ASŒRḅ@Ðḟ

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

कैसे?

ASRÐḟ @ Ðḟ || पूर्ण कार्यक्रम (विवादास्पद लिंक)।

के रूप में || पूर्ण मूल्यों का योग।
  ŒR || और अपने नकारात्मक मूल्य से सममित समावेशी सीमा बनाएं।
       Ðḟ || और उन है कि एक सत्य मूल्य उपज त्यागें ...
     ḅ @ || जब उन्हें बहुपद में प्लग किया जाता है (बेस कंवर्जन का उपयोग करता है)।

लुइस के उत्तर के आधार पर । एक विकल्प ।

— श्री Xcoder
स्रोत
क्या ऐसा कुछ है जो मुझे (अनुमत) रिवर्स ऑर्डर लेने और करने के बारे में याद आ रहा है Ær+.Ḟ?
— जोनाथन एलन
मैं थोड़ा उलझन में हूं क्योंकि अजगर का जवाब सुन्न के साथ ऐसा नहीं है, और मैं सोच रहा हूं कि मैंने कुछ बढ़त मामले को याद किया है।
— जोनाथन एलन
@JonathanAllan जैसा कि मुझे उम्मीद थी, आपका विफल होना [1,2,3]।
— श्री एक्सकोडर
"यदि दिए गए समीकरण का कोई हल नहीं है, तो आउटपुट अपरिभाषित है"
— जोनाथन एलन
@JonathanAllan लेकिन यह करता है असफल के लिए [10,-42,8], है ना?
— श्री एक्सकोडर
2

ऑक्टेव , 59 49 बाइट्स

@(p)(x=-(t=p(~~p)(end)):sign(t):t)(!polyval(p,x))

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

यह मेरे R उत्तर का एक पोर्ट है । अंतर केवल इतना है कि मुझे स्पष्ट रूप से उपयोग करना है sign(t)और endरेंज उत्पन्न करना है, और यह है किpolyval बहुपद की गणना करना है।

घटते क्रम में गुणांक के एक पंक्ति वेक्टर के रूप में इनपुट लेता है।

— ग्यूसेप
स्रोत
2

सी (जीसीसी) , 127 126 123 बाइट्स

x,X,j,m,p;f(A,l)int*A;{for(m=j=0;j<l;m+=abs(A[j++]));for(x=~m;X=x++<m;p||printf("%d,",x))for(p=j=0;j<l;X*=x)p+=A[l-++j]*X;}

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

व्याख्या

सी (जीसीसी) , 517 बाइट्स

x,X,j,m,p;                      // global integer variables
f(A,l)int*A;{                   // define function, takes in integer array pointer and length
 for(m=j=0;j<l;m+=abs(A[j++])); // loop through array, sum up absolute values
  for(x=~m;X=x++<m;             // loop through all values x in [-m, m], prime X
   p||printf("%d,",x))          // at loop's end, print x value if polynomial value is zero
    for(p=j=0;j<l;X*=x)         // loop through coefficients
     p+=A[l-++j]*X;}            // build polynomial

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

— जोनाथन फ्रेच
स्रोत
l+~j++करने के लिए golfed किया जा सकता हैl-++j
— केविन Cruijssen
@KevinCruijssen बहुत बहुत धन्यवाद।
— जोनाथन फ्रेच
@ceilingcat धन्यवाद।
— जोनाथन फ्रेच
1

जावा 8, 141 140 बाइट्स

a->{int l=a.length,s=0,i,r,f,p;for(int n:a)s+=n<0?-n:n;for(r=~s;r++<s;System.out.print(p==0?r+",":""))for(p=i=0,f=1;i<l;f*=r)p+=a[l-++i]*f;}

@Rod पायथन 2 उत्तर (उसका 82 बाइट्स संस्करण) से प्रेरित है ।

मजेदार चुनौती! मैंने निश्चित रूप से इसके बारे में बहुत कुछ सीखा है, जब बहुपदों के बारे में जांच की और यह देखा कि यहां कुछ अन्य लोगों ने कैसे किया है।

स्पष्टीकरण:

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

a->{                   // Method with integer-array parameter and no return-type
  int l=a.length,      //  The length of the input-array
      s=0,             //  Sum-integer, starting at 0
      i,               //  Index integer
      r,               //  Range-integer
      f,               //  Factor-integer
      p;               //  Polynomial-integer
  for(int n:a)         //  Loop over the input-array
    s+=n<0?-n:n;       //   And sum their absolute values
  for(r=~s;r++<s;      //  Loop `r` from `-s` up to `s` (inclusive) (where `s` is the sum)
      System.out.print(p==0?r+",":""))
                       //    After every iteration: print the current `r` if `p` is 0
    for(p=i=0,         //   Reset `p` to 0
        f=1;           //   and `f` to 1
        i<l;           //   Loop over the input-array again, this time with index (`i`)
        f*=r)          //     After every iteration: multiply `f` with the current `r`
      p+=              //    Sum the Polynomial-integer `p` with:
         a[l-++i]      //     The value of the input at index `l-i-1`,
                 *f;}  //     multiplied with the current factor `f`
— केविन क्रूज़सेन
स्रोत
0

जावास्क्रिप्ट (ईएस 6), 97 बाइट्स

a=>[...Array((n=Math.max(...a.map(Math.abs)))-~n)].map(_=>n--).filter(i=>!a.reduce((x,y)=>x*i+y))

शक्ति के घटते क्रम में गुणांक लेता है और अवरोही क्रम में परिणाम उत्पन्न करता है।

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