आपको फ्लोटिंग-पॉइंट नंबरों के दो एरे दिए जाएंगे। आपका कार्य दो सरणियों के संगत तत्वों को जोड़ना है, और प्रत्येक जोड़ी की अधिकतम प्राप्त करना है। हालांकि , यदि दो संबंधित तत्व समान हैं, तो आपको इसके बदले उनकी राशि लेनी होगी।

उदाहरण के लिए, सूचियों को देखते हुए [1, 3, 3.2, 2.3]और [3, 1, 3.2, 2.6], आपको निम्नलिखित कार्य करने चाहिए:

तत्वों को जोड़ी (या ज़िप) [[1, 3], [3, 1], [3.2, 3.2], [2.3, 2.6]]:।
प्रत्येक जोड़ी के माध्यम से जाओ और ऊपर की प्रक्रिया को लागू करें [3, 3, 6.4, 2.6]:।

ऐनक

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

नियम

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
मानक इनपुट और आउटपुट नियम लागू होते हैं। आप किसी भी उचित प्रारूप में इनपुट (और आउटपुट) ले सकते हैं।
डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।

परीक्षण के मामलों

Array_1, Array_2 -> आउटपुट

[], [] -> []
[१, २, ३], [१, ३, २] -> [२, ३, ३]
[1, 3, 3.2, 2.3], [3, 1, 3.2, 2.6] -> [3, 3, 6.4, 2.6]
[1,2,3,4,5,5,7,8,9,910], [10,9,8,7,6,5,4,3,2,1,1] -> [10, 9, 8, 7, 6, 10, 7, 8, 9, 10]
[-3.2, -3.2, -2.4, 7, -10.1], [100, -3.2, 2.4, -7, -10.1] -> [100, -6.4, 2.4, 7, -20.2]

आप कहते हैं कि संख्याएं हमेशा आपकी भाषा की "क्षमताओं" के भीतर "फिट" रहेंगी। जब तक आप "दुरुपयोग" नहीं करते हैं। क्या केवल एक भाषा में पूर्णांक का समर्थन करना, जिसमें फ्लोट नहीं है, को एक दुरुपयोग माना जाएगा? सवाल यह है कि फ़्लोटिंग पॉइंट लेकिन मुझे वास्तव में एक कारण नहीं दिखता है कि इसे क्यों तैरना पड़ता है। एक ही प्रक्रिया पूर्णांक पर की जा सकती है। मैं इसे ब्रेन-फ्लैक में हल करना चाहूंगा लेकिन ब्रेन-फ्लैक केवल ints का समर्थन करता है।

— गेहूं जादूगर

@WheatWizard मैं इसके लिए एक अपवाद बना सकता हूं। आगे बढ़ें और अपना उत्तर दें और उल्लेख करें कि मैंने इसे भ्रम से बचने की अनुमति दी है।

8

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

=‘×»

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

यह मेरे एपीएल उत्तर के समान सटीक दृष्टिकोण का उपयोग करता है , जैली को छोड़कर एक संख्या में एक जोड़ने के लिए एक बिलिन है!

— जाकारी
स्रोत

एक स्पॉर्ट्सपोर्ट होने के लिए नफरत है, लेकिन उन पात्रों में से कुछ नहीं हैं जो किसी भी समझदार एन्कोडिंग में एक से अधिक बाइट करते हैं?

— सेड्रिक नाइट

यह जेली कोडपेज का उपयोग करता है ।

— Zacharý

मैं अंत में प्रतियोगिता के खिलाफ जीता!

— ज़ाचरी

2

@ जाकारी एक व्यक्ति, 4 btytes ... इस ग्रीष्मकालीन ... आप ... होगा ... जा ... उसके बारे में जेली ... जेली के लिए मूल्यांकन जम्मू ।

— मैजिक ऑक्टोपस Urn

11

कोटलिन, 78 75 71 66 65 59 बाइट्स

यह मेरा पहला प्रयास है, मस्त रहो: डी

a.zip(b).map{(a,b)->when{b>a->b;a>b->a;else->a*2}}.toList()

TIO इस समाधान के साथ काम नहीं करता (और मुझे पता नहीं क्यों), नीचे परीक्षण के लिए स्रोत कोड

fun main(args: Array<String>) {
    bestOfTwo(floatArrayOf(), floatArrayOf()).print()
    bestOfTwo(floatArrayOf(0F), floatArrayOf(0F)).print()
    bestOfTwo(floatArrayOf(1F,2F,3F), floatArrayOf(1F,3F,2F)).print()
    bestOfTwo(floatArrayOf(1F,3F,3.2F,2.3F), floatArrayOf(3F,1F,3.2F,2.6F)).print()
    bestOfTwo(floatArrayOf(1F,2F,3F,4F,5F,5F,7F,8F,9F,10F), floatArrayOf(10F,9F,8F,7F,6F,5F,4F,3F,2F,1F)).print()
    bestOfTwo(floatArrayOf(-3.2F,-3.2F,-2.4F,7F,-10.1F), floatArrayOf(100F,-3.2F,2.4F,-7F,-10.1F)).print()
}


fun bestOfTwo(a :FloatArray, b :FloatArray): List<Float> =
    a.zip(b).map{(a,b)->when{b>a->b;a>b->a;else->a*2}}.toList()


fun List<Float>.print() {
    this.forEach { print("$it, ") }; println("")
}

संपादित करें:

-3 को "a + 2" द्वारा "a + b [i]" से बदलें

-4 "मैपइंडएक्सएक्सडेड" विधि को "ज़िप" से बदलें (@AnonymousReality स्विफ्ट समाधान के लिए धन्यवाद)

-5 की जगह "मैथ.मैक्स" पद्धति को कब से करें

-1 जब स्थिति के अनुसार परिवर्तन

-6 परिवर्तन द्वारा toFloatArray () byList ()

— वैलेंटाइन मिशालक
स्रोत

10

PPCG में आपका स्वागत है! कृपया निराश न हों (यह उस सिस्टम के एक मामूली झटके का परिणाम है जो तब होता है जब एक नए उपयोगकर्ता की पहली पोस्ट गुणवत्ता के लिए ऑटो-फ़्लैग की जाती है और फिर उन्होंने कहा पोस्ट में सुधार होता है !!)

— जोनाथन एलन

2

सबसे खराब "सुविधा" कभी ... btw इसके बारे में बुरा नहीं लगता है।

— आउटगॉल्फ

10

पायथन 2 , 45 बाइट्स

मेरे प्रारंभिक समाधान और @ovs ' का मिश्रण ।

lambda*a:map(lambda x,y:max(x,y)*-~(x==y),*a)

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

पायथन 2 , 49 बाइट्स

lambda x,y:[max(a,b)*-~(a==b)for a,b in zip(x,y)]

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

पायथन 2 , 46 बाइट्स

@ovs ने 3 बाइट को बचाने के लिए इस विधि का सुझाव दिया।

lambda*x:[max(a,b)*-~(a==b)for a,b in zip(*x)]

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

कैसे?

सबसे पहले, हम *या तो का उपयोग करके, संबंधित तत्वों को जोड़ते हैं zip()। यह हमें एक नक्शे या एक सूची समझ के साथ काम करके अपनी आगे की गोल्फिंग करने की अनुमति देता है।

इस उत्तर में शांत चाल यह हिस्सा है max(x,y)*-~(x==y):। वह कैसे काम करता है? - ठीक है, जैसा कि आप में से अधिकांश पहले से ही जानते हैं, पायथन ऑटो-बूल मानों को पूर्णांक में तब परिवर्तित करता है जब उनका उपयोग अंकगणितीय कार्यों में किया जाता है। इसलिए, जैसे हालत मिले, उसका (x==y)मूल्यांकन किया जाता 1है। हालाँकि, यदि दोनों मान समान नहीं हैं, तो यह 0बदले में लौटता है । फिर, बिटवाइज़ आपरेशन -~वेतन वृद्धि मूल्य द्वारा bool से लौटे 1, हमें दे रही है या तो 2या 1। max(a,b)जोड़ी का अधिकतम मूल्य देता है और *इसे ऊपर दिए गए मूल्य से गुणा करता है (इसलिए यह 2केवल तब ही गुणा हो जाता है जब वे समान हों, जिस स्थिति max()में दोनों का मान लौटाता है)।

यह इस तथ्य पर आधारित है कि दो समान संख्याओं का योग वास्तव में या तो दोगुना है, और इस तरह की "गालियां" पायथन के बूल वर्ग का एक उपवर्ग है।

— श्री Xcoder
स्रोत

वाह, यह वास्तव में तेज था!

और अधिक सरल, बाइट्स की एक ही नंबर:lambda*a:map(lambda x,y:(x<=y)*y+(x>=y)*x,*a)

— jferard

@ जेरार्ड I तथ्य, यह पहले से ही लुइस का समाधान है।

— श्री Xcoder

@ Mr.Xcoder उफ़! मैंने पूरा पृष्ठ नहीं पढ़ा ...

— jferard

कभी भी "ऊपर" न कहें, जैसा कि आदेश बदल सकता है (मैं आपके समाधान को ऊपर नहीं देखता हूं)

— Zacharý

8

जावास्क्रिप्ट (ईएस 6), 53 49 45 43 बाइट्स

a=>b=>a.map((x,y)=>(y=b[y])>x?y:y<x?x:x+y)

मिस्टर एक्सकोडर से एक ट्रिक उधार लेकर 4 बाइट्स बचाए गए।
2 बाइट्स ने अरनौलड को धन्यवाद दिया।

कोशिश करो

o.innerText=(f=

a=>b=>a.map((x,y)=>(y=b[y])>x?y:y<x?x:x+y)

)(i.value=[1,3,3.2,2.3])(j.value=[3,1,3.2,2.6]);oninput=_=>o.innerText=f(i.value.split`,`.map(eval))(j.value.split`,`.map(eval))

<input id=i><input id=j><pre id=o>

स्निपेट का विस्तार करें

व्याख्या

a=>b=>

बेनामी फ़ंक्शन पैरामीटर के माध्यम से तर्क के रूप में 2 सरणियों को ले रहा है aऔर b, सिंटैक्स में करी (यानी, कॉल के साथ)f(a)(b)

a.map((x,y)=>                      )

पहले एरे पर मैप करें, प्रत्येक एलीमेंट को एक फंक्शन से गुजारा जाए जहां xकरंट एलिमेंट हो और yकरंट इंडेक्स हो।

(y=b[y])

yदूसरे एरे में इंडेक्स पर तत्व प्राप्त करें और इसे नए मान के रूप में असाइन करें y।

>x?y

जाँच करें कि yक्या अधिक से अधिक है xऔर, यदि हां, तो वापस लौटें y।

:y<x?x

और, जाँच करें कि yक्या इससे कम है xऔर यदि है तो वापस कर देंx

:x+y

और, का योग xऔर लौटाओ y। (गुणा xया y2 से भी बाइट्स की एक ही नंबर के लिए यहाँ काम करेगा।)

— झबरा
स्रोत

j.value.split`,`.map(eval)या eval('['+j.value+']')? इसके अलावा x+ynter IMHO दिखेगा।

— नील

@ नील: 1) मुझे टाइप करने के लिए पूर्व आसान लगता है। इसके अलावा, मेरी एक मशीन पर स्निपेट के कुछ जोड़े हैं; .map(eval)इनसे निपटना आसान है। 2) सहमत, पल में संपादित करेंगे।

— Shaggy

7

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

x!y|x>y=x|x<y=y|1<2=x+y
zipWith(!)

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

— क्रिस्टियन लुपस्कू
स्रोत

2

एक ही बाइट गिनती: x!y=max x y+sum[x|x==y]।

— नौ

7

आर , 31 29 बाइट्स

function(a,b)pmax(a,b)+a*!a-b

pmax दो (या अधिक) सरणियों के समानांतर अधिकतम लेता है (आवश्यकतानुसार छोटे को पुनर्चक्रित करता है)।

मैं लुइस मेंडो की टिप्पणी को देख रहा था और जाहिर है मुझे एहसास हुआ कि दृष्टिकोण आर के लिए भी काम कर सकता है। मुझे 30 बाइट्स को मिला यही कारण है, लेकिन फिर मैं बजाय सूचकांकों हो रही मेरी मूल जवाब में सुधार करने के विभिन्न तरीकों के साथ प्रयोग करना शुरू कर दिया, और पर ठोकर खाई !a-bके रूप में TRUEजहां a==bऔर FALSEअन्यथा, के बराबर a==b। हालांकि, जो भी कारण के लिए, आर के लिए कोष्ठक की आवश्यकता नहीं होती है !a-bजैसा कि वह करता है a==b, जिसने मुझे दो बाइट्स बचाए।

जैसा कि टिप्पणियों में जेडीएल ने उल्लेख किया है , यह काम करता है क्योंकि !(नकारात्मकता) -आर में बाइनरी ऑपरेटर की तुलना में कम पूर्वता है , जो अजीब है।

इसे ऑनलाइन आज़माएं! (नया संस्करण)

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

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

यह पता चला है कि एकात्मक "!" बाइनरी की तुलना में R में कम वरीयता है "-", जो मुझे लगता है कि काफी असामान्य है (और मुझे इस जवाब को पढ़ने तक महसूस नहीं हुआ!)

— JDL

@JDL हाँ, मुझे लगभग हमेशा आर सिंटैक्स पृष्ठ को खोलना पड़ता है जबकि इस तरह के अजीब झगड़े के मामले में गोल्फिंग ... और यह भी क्योंकि मैं :अंकगणित के साथ बातचीत करते समय कभी भी इसकी पूर्वता को याद नहीं कर सकता ।

— Giuseppe

7

पायथन 3 , 48 46 44 बाइट्स

-2 बाइट्स @nwellnhof को धन्यवाद

lambda*a:map(lambda*x:max(x)*2/len({*x}),*a)

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

— OVS
स्रोत

6

Dyalog एपीएल, 5 बाइट्स

⌈×1+=

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

कैसे?

⌈, तत्व-वार अधिकतम तर्क
×, तत्व-वार गुणा
1+=, 1 तर्कों के तत्व-वार समानता में जोड़ा गया

यह काम करता है क्योंकि यदि संख्या असमान हैं, तो 1+=वह होगा 1, जो अधिकतम से गुणा होने पर अधिकतम होता है। जब संख्या बराबर होती है, 1+=तो वापस आ जाएगी 2, जब वह अधिकतम से गुणा होती है, हम अधिकतम से दोगुना हो जाते हैं, या अधिकतम अपने आप में जुड़ जाते हैं।

— जाकारी
स्रोत

5

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

żSṀE?€

प्रत्येक पक्ष पर संख्याओं की सूची लेने और परिणामी सूची वापस करने के लिए एक डाईएडिक लिंक।

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

कैसे?

żSṀE?€ - Link: list of numbers L, list of numbers R   e.g. [1,3,3.2,2.3], [3,1,3.2,2.6]
ż      - zip - interleave L & R                       [[1,3],[3,1],[3.2,3.2],[2.3,2.6]]
     € - for each pair:
    ?  - { if:
   E   -   ...condition: equal                          0      0       1         0
 S     -   ...then: sum                                               6.4
  Ṁ    -   ...else: maximum                             3      3                2.6
       - }                                    ... ->   [3     ,3     ,6.4      ,2.6]

एक वैकल्पिक यह दो लिंक , 6 बाइट्स की एक सूची लेने वाला एक विवादास्पद लिंक है :

+»⁼?"/

* मुझे नहीं लगता कि मैंने पहले कभी भी कोड के बाइट काउंट से लगभग तीन गुना टेस्ट-सूट फुटर बनाया है!

— जोनाथन एलन
स्रोत

Outgolfed! । प्रश्न की व्यावहारिक रूप से व्याख्या के लिए +1।

— ज़ाचारि

... और मैं पकड़ा गया है कि »सदिश से पहले भूल जाते हैं !

— जोनाथन एलन

यह और क्या करेगा, किसी भी जटिल तरीके से अधिकतम सरणी लें?

— ज़ाचारि

किसी भी दृढ़ परिभाषा के लिए कोई ज़रूरत नहीं है, पायथन प्रबंधन - उदाहरण के लिए max([1,1,0],[1,0,3]) -> [1,1,0](नहीं [1,1,3])।

— जोनाथन एलन

तो, मूल रूप से अनंत-आधार?

— ज़ाचारि

5

05AB1E , 5 बाइट्स

øεMÃO

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

-1 Emigna को धन्यवाद ।

— आउटग्रॉफर को एरिक करें
स्रोत

का उपयोग कर अच्छा विचार γ!

— एमिगा

@Emigna मैं वास्तव में "मैक्सिमल एलिमेंट्स" चाहता था, और {γθसंभवत: सबसे छोटा है जो मुझे इसके लिए मिल सकता है।

— आउटगॉल्फ

कैसे के बारे में øεMÃO?

— एमिगा

@Emigna कूल, धन्यवाद! (डुह मैंने ऐसा क्यों नहीं सोचा था MÃ) याय को अब बढ़त मिल गई है: पी btw øεZÃOभी काम करेगा

— एरिक आउटगोलफेर

4

MATL , 7 बाइट्स

X>tG=s*

इनपुट एक दो-पंक्ति मैट्रिक्स है, जहां प्रत्येक पंक्ति सरणियों में से एक है।

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

व्याख्या

X>   % Implicit input. Maximum of each column
t    % Duplicate
G    % Push input
=    % Is equal? Element-wise with broadcast. Gives a two-row matrix
s    % Sum of each column. Gives a row vector containing 1 and 2
*    % Multiply, element-wise. Implicit display

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

4

जावा 8, 80 69 67 66 65 64 63 बाइट्स

(a,b,l)->{for(;l-->0;)if(a[l]>=b[l])b[l]=a[l]*(a[l]>b[l]?1:2);}

बाइट्स को सहेजने के बजाय दूसरा इनपुट-ऐरे को संशोधित करता है या एक नया फ्लोट-ऐरे लौटाता है।

-11 बाइट्स को अतिरिक्त पूर्णांक-इनपुट के रूप में लें, जिसे चुनौती नियमों के अनुसार अनुमति दी गई है।
-5 बाइट्स @ ऑलिवरग्रेगोइरे (एक बार में एक बाइट .. xD) की बदौलत
-1 बाइट अप्रत्यक्ष रूप से @Shaggy के JS उत्तर के लिए धन्यवाद , a[l]*2इसके बजाय का उपयोग करके a[l]+b[l]।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

(a,b,l)->{          // Method with 2 float-array and integer parameters and no return-type
  for(;l-->0;)      //  Loop over the array
    if(a[l]>=b[l])  //   If the current value in `a` is larger or equal to `b`:
      b[l]=         //   Modify the second input-array:
       a[l]*        //    Use `a` multiplied by:
        (a[l]>b[l]? //     If the current value in `a` is larger than `b`:
          1         //      Multiply by 1
         :          //     Else (`a` is smaller of equal to `b`):
          2)        //      Multiply by 2
                    //  End of loop (implicit / single-line body)
}                   // End of method

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

2

"यदि यह आपकी बाइट की संख्या को कम करने में आपकी मदद करता है, तो आप इनपुट के रूप में सूचियों की लंबाई भी ले सकते हैं।" यह निश्चित रूप से आपके बाइट-काउंट को कम कर देगा;)

— ओलिवियर ग्रेजायर

1

इसके अलावा, 2 बाइट्स कम:a->b->l->{float A,B;for(;l-->0;b[l]=(A=a[l])<B?B:A>B?A:A+B)B=b[l];}

— ओलिवियर ग्राईगोयर

और आप इनिशियलाइज़ेशन float A, Bमें लगाकर एक और बाइट बचा सकते हैं for।

— ओलिवियर ग्रेगोइरे

1

या यह: (a,b,l)->{for(;l-->0;)if(a[l]>=b[l])b[l]=a[l]*(a[l]>b[l]?1:2);}(63 बाइट्स)

— ओलिवियर ग्रेगोइरे

3

@ OlivierGrégoire Lol .. गोल्फ के साथ हर बाइट में मदद करता है, लेकिन इसका मतलब यह नहीं है कि आपको एक बार में एक बाइट को गोल करना होगा। ; पी

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

3

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

m*eSdhnd{dC

यहाँ कोशिश करो!

पायथ , 12 बाइट्स

m*eSdhqhdedC

यहाँ कोशिश करो!

या

m*eSdh!tl{dC

यहाँ कोशिश करो!

— श्री Xcoder
स्रोत

@ जाकुब यह एरिक का समाधान है, दुख की बात है। मैं वह भी उपयोग करना चाहता था, लेकिन मैं अब नहीं कर सकता

— श्री Xcoder

ओह, यह एक नहीं देखा।

— जकुबे

3

05AB1E , 9 8 7 बाइट्स

एरिक आउट के रूप में बाइट को सहेजा गया आउटगॉल्फ ने बताया कि सूचियों की एक सूची वैध इनपुट है।

øεMsËi·

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

व्याख्या

ø          # zip the lists
 ε         # apply to each pair
  M        # get max
   s       # swap the top 2 elements on the stack
    Ëi     # if all elements are equal
      ·    # double the max

— Emigna
स्रोत

वाह, यह वास्तव में तेज था!

आप ‚किसी सूची और सूची की जोड़ी के रूप में और इनपुट को हटाकर एक बाइट बचा सकते हैं ।

— आउटगॉल्फ

@EriktheOutgolfer: सच है। मैंने मान लिया कि हमें इसकी अनुमति नहीं थी, लेकिन मैं देख रहा हूं कि चुनौती मानक I / O नियमों को निर्दिष्ट करती है। सूचित करने के लिए धन्यवाद :)

— Emigna

1

@ एग्निमा टिप: अपने दिमाग से बाहर नियम न बनाएं;)

— एरिक आउटलेगर

1

@EriktheOutgolfer: हाँ, मुझे वास्तव में ऐसा करने से रोकने की आवश्यकता है। विशेष रूप से नियम जो मेरे कार्यक्रमों को लंबा बनाते हैं;)

— एमिगा

3

मैथेमेटिका, 31 बाइट्स

MapThread[If[#==#2,2#,Max@##]&]

— alephalpha
स्रोत

3

जे, 7 बाइट्स

>.`+@.=

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

एक सूची को बाएं तर्क के रूप में और दूसरी को दाईं ओर ले जाता है।

सौभाग्य से, समानता एक रैंक शून्य ऑपरेशन है।

व्याख्या

>.`+@.=
      =  Compare equality pairwise
    @.   If equal
   +       Sum
>.       (Else) take greater value

@.नहीं है वास्तव में एक अगर बयान है, लेकिन इस मामले में यह काम करता है एक (यह gerund में अनुक्रमित के रूप में >.`+अपने अधिकार का तर्क का परिणाम के आधार पर और कहा कि इनपुट करने के लिए लागू होता है)।

— गोभी
स्रोत

अच्छा काम, मुझे पता है कि मैं ऐसा नहीं कर सका, भले ही आप मेरे एपीएल के मेरे अनुवाद से बाहर हो गए हों। > _ <

— Zacharý

जे वास्तव में यहाँ चमकता है

— जोनाह

@ Zacharý चूहों, फिर भी अच्छी तरह से गोल्फ।

— कोल

3

रूबी , 42 बाइट्स

->a,b{a.zip(b).map{|x,y|[x+y,x,y][x<=>y]}}

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

स्पेसशिप ऑपरेटर महान है।

— ymbirtt
स्रोत

3

टीआई-बेसिक, 23 21 बाइट्स

Prompt A,B
(ʟA=ʟB)ʟA+max(ʟA,ʟB

बहुत खराब सूचियों में से प्रत्येक में दो बाइट्स होते हैं ...

— Timtech
स्रोत

आप दो बाइट्स के लिए Xऔर Yफिर, का उपयोग करके ʟXऔर ʟYउन्हें, यानी " Prompt X,Y:ʟX(ʟX=ʟY)+max(ʟ1,ʟ2" का उपयोग करके बचा सकते हैं ।

— स्कॉट मिलनर

इसके अलावा, यह वर्तमान में अमान्य है, क्योंकि एक सूची L1(L1=L2)में तत्व प्राप्त करने का प्रयास करता है L1, जो एक त्रुटि फेंकता है। इसे ठीक करने के लिए, ऑर्डर को स्वैप करें, अर्थात (L1=L2)L1।

— स्कॉट मिलनर

@ScottMilner उन दोनों को इंगित करने के लिए धन्यवाद।

— टिमटेक

2

ऑक्टेव, 36 बाइट

@(a,b)a.*(a>b)+b.*(b>a)+2.*a.*(a==b)

— user73789
स्रोत

1

साइट पर आपका स्वागत है! आप कुछ बाइट्स@(a,b)max(a,b).*(1+(a==b))

— लुइस मेंडो

5

या बेहतर, अपने दृष्टिकोण का उपयोग करते हुए,@(a,b)a.*(a>=b)+b.*(b>=a)

— लुइस मेंडो

2

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

ms.MZdC

इसे यहाँ आज़माएँ।

— आउटग्रॉफर को एरिक करें
स्रोत

2

पायथन 3 , 49 46 45 बाइट्स

3 बाइट्स @ Mr.Xcoder (दो तर्कों के बजाय बजाए), और 1 बाइट के लिए धन्यवाद @ovs (सूची समझ के बजाय नक्शा ) के लिए हटा दिया गया

lambda*x:map(lambda a,b:a*(a>=b)+b*(b>=a),*x)

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

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

1

46 बाइट्स lambda*c:[a*(a>=b)+b*(b>=a)for a,b in zip(*c)]:। यह पता चला है कि यह काफी अच्छा है :) - बहुत बुरा आगे गोल्फ के लिए कोई जगह नहीं है

— श्री एक्सकोडर

@ Mr.Xcoder धन्यवाद! अच्छा विचार!

— लुइस मेंडो

ज़िप के बजाय मानचित्र का उपयोग करके 45 बाइट्स ।

— ovs

2

आम लिस्प, 60 59 बाइट्स

(mapcar(lambda(x y)(*(max x y)(if(= x y)2 1)))(read)(read))

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

-1 बाइट @ ज़ाचारी को धन्यवाद!

— रेंज़ो
स्रोत

59 बाइट्स: (mapcar(lambda(x y)(*(max x y)(if(= x y)2 1)))(read)(read))।

— ज़चारि

आपका स्वागत है, मैं लिस्प को अच्छी तरह से नहीं जानता, मैंने सिर्फ लिस्प में अपने अन्य उत्तरों का अनुवाद किया, जो एक बाइट को बचाकर समाप्त हुआ।

— Zacharý

2

सुन्न के साथ अजगर, 28 बाइट्स

lambda a,b:a*(a>=b)+b*(b>=a)

मान लिया जाता है कि इनपुट को दो संख्यात्मक सरणियों के रूप में दिया गया है।

: हम numpy उपयोग कर रहे हैं तो यहाँ मेरी बदतर समाधान हैlambda a,b:n.fmax(a,b)*((a==b)+1)

— एरिक

@ मुझे यह विचार पसंद है, लेकिन ऐसा करने के लिए मुझे इसकी आवश्यकता होगी import numpy as n। मैं इसके बिना यहां से दूर हो जाता हूं क्योंकि यह इनपुट में निहित है।

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

— एरिक

@ सामान्य रूप से, आप केवल एक चर का उल्लेख कर सकते हैं nयदि आपने nअपने कोड में परिभाषित किया है, तो आयात स्पष्ट होना चाहिए। डिफ़ॉल्ट रूप से, हम उत्तर के रूप में फ़ंक्शन या पूर्ण कार्यक्रमों की अनुमति देते हैं , जिसमें अनाम फ़ंक्शन शामिल हैं।

1

ठीक है, यह केवल आयात करने के बजाय, खस्ता सरणियों के रूप में इनपुट की आवश्यकता है numpy। लेकिन क्या यह भी उपयोग किए बिना काम करता है return?

— ज़ाचारि

2

Linq 47 + 18 = 65 बाइट्स का उपयोग करके C # (.NET Core)

x=>y=>x.Zip(y,(a,b)=>a>b?a:b>a?b:b+a).ToArray()

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

सी # (.NET कोर), 82 बाइट्स

x=>y=>l=>{for(int i=0;i<l;i++)x[i]=x[i]>y[i]?x[i]:y[i]>x[i]?y[i]:y[i]*2;return x;}

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

— Dennis.Verweij
स्रोत

आप नामस्थान

— सिस्टम

@jkelm हाँ, मैं सोच रहा था कि क्या 'सिस्टम का उपयोग कर रहे हैं?' को शामिल किया जाना है या नहीं, मुझे लगता है कि नहीं। मैं इसे साफ कर

— दूंगा

System.Linq "Visual C # Interactive Compiler" में शामिल है। मुझे Arrayबनाम IListबनाम लौटने के बारे में पूरी तरह से यकीन नहीं है IEnumerable, लेकिन अगर सभी पात्र हैं तो आप बाइट की गिनती 37 तक प्राप्त कर सकते हैं - tio.run/##Sy7WTS7O/…

— dana

2

पर्ल 6 , 34 28 बाइट्स

{map {.max*2/set $_},[Z] $_}

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

— nwellnhof
स्रोत

1

स्विफ्ट 3, 81 79 बाइट्स

func n(a:[Double],b:[Double]){for(x,y)in zip(a,b){print((x==y) ?x+y:max(x,y))}}

स्विफ्ट में एक दिलचस्प संपत्ति है कि एक इंट सीधे कास्टेबल नहीं है Double, इसलिए आपको Doubleफ़ंक्शन को पास करने से पहले किसी भी सरणियों को एस के सरणियों के रूप में निर्दिष्ट करना होगा ।

(उदाहरण के लिए) var k:[Double] = [1,2,3,4,5,5,7,8,9,10]

संपादित करें: -2 बाइट्स @EriktheOutgolfer के लिए धन्यवाद

— AnonymousReality
स्रोत

क्या आपको आसपास (x,y)और पहले रिक्त स्थान की आवश्यकता है ??

— आउटगॉल्फ

@EriktheOutgolfer पहले ?की जरूरत है क्योंकि स्विफ्ट उन्हें टर्नरीज़ के बजाय वैकल्पिक प्रकार के रूप में व्यवहार करेगा (जो कि वे नहीं हैं)। दूसरे नहीं हैं। इसके अलावा, यह काफी गोल्फ हो सकता है।

@EriktheOutgolfer - TheIOSCoder ने आपको पहले ही आंशिक रूप से उत्तर दिया है, लेकिन आप सही हैं, आपको लूप के लिए लोगों की आवश्यकता नहीं है, दिलचस्प!

— AnonymousReality

73 बाइट्स: func n(a:[Float],b:[Float]){print(zip(a,b).map{$0==$1 ?2*$0:max($0,$1)})}(फ्लोट की अशुद्धि को डिफ़ॉल्ट रूप से नियंत्रित करने की आवश्यकता नहीं है)

— श्री एक्सकोडर

या 74 बाइट्स:func n(a:[Float],b:[Float]){print(zip(a,b).map{($0==$1 ?2:1)*max($0,$1)})}

— श्री Xcoder

1

सी, 76 75 बाइट्स

एक बाइट को बचाने के लिए @ केविन क्रूज़सेन को धन्यवाद!

f(a,b,n)float*a,*b;{for(;n--;++a,++b)printf("%f ",*a>*b?*a:*b>*a?*b:*a*2);}

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

— Steadybox
स्रोत

1

जाप , 13 बाइट्स

íV,È¥Y Ä *XwY

इसे ऑनलाइन आज़माएं! -Qआउटपुट सरणी को प्रारूपित करने के लिए ध्वज के साथ ।

— जस्टिन मेरिनर
स्रोत

अच्छी तरह से किया। मैंने पहले इस पर 2 प्रयास किए और दोनों 17 बाइट्स में बाहर आए। मैं भूल गया íकि एक फ़ंक्शन को दूसरे तर्क के रूप में ले सकता हूं ।

— शैगी

1

जंग , 107 97 बाइट्स

|a:V,b:V|a.iter().zip(b).map(|(&x,y)|if x==y{x+y}else{x.max(y)}).collect::<V>();
type V=Vec<f32>;

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

@Mgc की बदौलत 8 बाइट्स बचाए

— jferard
स्रोत

1

मुझे लगता है कि आप एकत्र किए गए प्रकारों का उपयोग करके Vecऔर एस की maxविधि का उपयोग करके 8 बाइट्स बचा सकते हैं f32:|a:Vec<f32>,b:Vec<f32>|a.iter().zip(b).map(|(&x,y)|if x==y{x+y}else{x.max(y)}).collect::<Vec<_>>();

— एमजीसी

1

@mgc धन्यवाद! टाइप इंट्रेंस एक अच्छा विचार था, लेकिन इस मामले में उपनाम भी छोटा है।

— जाफर

1

स्विफ्ट 4 , 41 बाइट्स

{zip($0,$1).map{$0==$1 ?2*$0:max($0,$1)}}

परीक्षण के मामलों:

let f: ([Float], [Float]) -> [Float]
    = {zip($0,$1).map{$0==$1 ?2*$0:max($0,$1)}}

let testcases: [(inputA: [Float], inputB: [Float], expected: [Float])] = [
    (
        inputA: [],
        inputB: [],
        expected: []
    ),
    (
        inputA: [1, 2, 3],
        inputB: [1, 3, 2],
        expected: [2, 3, 3]
    ),
    (
        inputA: [1, 3, 3.2, 2.3],
        inputB:  [3, 1, 3.2, 2.6],
        expected: [3, 3, 6.4, 2.6]
    ),
    (
        inputA: [1,2,3,4,5,5,7,8,9,10],
        inputB:  [10,9,8,7,6,5,4,3,2,1],
        expected: [10, 9, 8, 7, 6, 10, 7, 8, 9, 10]
    ),
    (
        inputA: [-3.2, -3.2, -2.4, 7, -10.1],
        inputB:  [100, -3.2, 2.4, -7, -10.1],
        expected: [100, -6.4, 2.4, 7, -20.2]
    ),
]

for (caseNumber, testcase) in testcases.enumerated() {
    let actual = f(testcase.inputA, testcase.inputB)
    assert(actual == testcase.expected,
        "Testcase #\(caseNumber) \((testcase.inputA, testcase.inputB)) failed. Got \(actual), but expected \(testcase.expected)!")
    print("Testcase #\(caseNumber) passed!")
}

— अलेक्जेंडर - मोनिका को बहाल करें
स्रोत

दो एरर का सबसे अच्छा प्राप्त करें

ऐनक

नियम

परीक्षण के मामलों

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

कोटलिन, 78 75 71 66 65 59 बाइट्स

पायथन 2 , 45 बाइट्स

पायथन 2 , 49 बाइट्स

पायथन 2 , 46 बाइट्स

कैसे?

जावास्क्रिप्ट (ईएस 6), 53 49 45 43 बाइट्स

कोशिश करो

व्याख्या

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

आर , 31 29 बाइट्स

पायथन 3 , 48 46 44 बाइट्स

Dyalog एपीएल, 5 बाइट्स

कैसे?

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

कैसे?

05AB1E , 5 बाइट्स

MATL , 7 बाइट्स

व्याख्या

जावा 8, 80 69 67 66 65 64 63 बाइट्स

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

पायथ , 12 बाइट्स

05AB1E , 9 8 7 बाइट्स

मैथेमेटिका, 31 बाइट्स

जे, 7 बाइट्स

व्याख्या

रूबी , 42 बाइट्स

टीआई-बेसिक, 23 21 बाइट्स

ऑक्टेव, 36 बाइट

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

पायथन 3 , 49 46 45 बाइट्स

आम लिस्प, 60 59 बाइट्स

सुन्न के साथ अजगर, 28 बाइट्स

Linq 47 + 18 = 65 बाइट्स का उपयोग करके C # (.NET Core)

सी # (.NET कोर), 82 बाइट्स

पर्ल 6 , 34 28 बाइट्स

स्विफ्ट 3, 81 79 बाइट्स

सी, 76 75 बाइट्स

जाप , 13 बाइट्स

जंग , 107 97 बाइट्स

स्विफ्ट 4 , 41 बाइट्स