N से सबसे बड़ी संख्या n स्थिति ज्ञात करें

Question

_{इस सवाल की अगली कड़ी ।}

कार्य

सकारात्मक पूर्णांक की एक सरणी को देखते हुए, सबसे बड़ा तत्व k खोजें जिसके लिए:

वहां मौजूद कुछ सकारात्मक पूर्णांक दूरी n , ताकि सरणी में तत्व स्थित n  करने के लिए स्थानों को छोड़ दिया या सही से कश्मीर के बराबर होती है n ।

सरणी को इस शर्त को पूरा करने वाले कम से कम एक तत्व को शामिल करने की गारंटी है।

सबसे छोटा कोड (बाइट्स में) जीतता है। आप चाहे तो I / O प्रारूप चुन सकते हैं।

उदाहरण

इनपुट दिया

[4, 6, 7, 9, 3, 6, 5, 7, 2]

पात्र मूल्य हैं:

• 4, के रूप में वहाँ एक है 7इसकी सही करने के लिए 7 पदों स्थित
• पहला 6, जैसा कि 3इसके दाईं ओर स्थित 3 स्थितियां हैं
• 3, के रूप में वहाँ एक है 4अपने बाईं ओर 4 पदों स्थित
• 5, के रूप में वहाँ एक है 2इसकी सही करने के लिए 2 पदों स्थित
• दूसरा 7, जैसा कि 3इसके बाईं ओर स्थित 3 स्थितियां हैं।

इन मूल्यों में से, सबसे बड़ा है 7।

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

[1, 13] → 13
[2, 9, 8, 3, 72, 2] → 8
[5, 28, 14, 5, 6, 3, 4, 7] → 14
[1, 3, 5, 15, 4, 1, 2, 6, 7, 7] → 7
[5, 1, 3, 5, 2, 5, 5, 8, 5, 1, 5, 1, 2, 3] → 5
[5, 12, 2, 5, 4, 7, 3, 3, 6, 2, 10, 5, 5, 5, 4, 1, 8, 5] → 10

Comments

उदाहरण के भीतर दो और (कुछ हद तक बेमानी) मामलों: पहले 6 (फिर से) के रूप में वहाँ एक 5 पाँच स्थिति यह सही है; या दूसरा 7 (फिर) के रूप में वहाँ 6 छह पदों के लिए छोड़ दिया है।

— जोनाथन एलन

1. मेरे फोन पर शीर्षक "से सबसे बड़ी संख्या की स्थिति का पता लगाएं" प्रतीत होता है। 2. कहा गया शर्त यह है कि वहाँ कुछ k मौजूद है जैसे कि (एक संपत्ति जो k पर निर्भर नहीं है)। यह निश्चित रूप से गलत होना चाहिए।

— पीटर टेलर

@PeterTaylor "यह" इस "तत्व" में k को संदर्भित करता है।

— तैमूर

@ टैमर, कि दो कारणों से कोई मतलब नहीं है: सबसे पहले, क्योंकि कश्मीर को एक तत्व नहीं कहा गया है; और दूसरी बात यह है कि हमें " सबसे बड़ा तत्व संतोषजनक " स्थिति को खोजने के लिए कहा जाता है , इसलिए " इस तत्व " की स्थिति के बाहर एक एंटीकेडेंट है।

— पीटर टेलर

शायद आप यह कहकर सभी भ्रम से बच सकते हैं कि " सबसे बड़ा तत्व k ऐसा खोजें" और फिर परिभाषा में इस तत्व के बजाय k का उपयोग करें ?

— मार्टिन एंडर

Answer 1

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

Jạþ`=ḅa¹Ṁ

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

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

Jạþ`=ḅa¹Ṁ  Main link. Argument: A (array)

J          Indices; yield [1, ..., len(A)].
   `       Use the previous return value as left and right argument:
 ạþ        Absolute difference table; take the absolute value of the difference
           of each pair of indices, yielding a 2D array.
    =      Compare each absolute difference with the corresponding item of A.
     ḅ     Base; convert each Boolean list from base i to integer, where i is the
           corresponding item of A. The value of i is not important; we only care
           if the list contains a 1, which will result in a non-zero integer.
       ¹   Identity; yield A.
      a    Logical AND; replace non-zero values with the corresponding items of A.
        Ṁ  Take the maximum.

Comments

हम्म, निश्चित नहीं है कि इस बारे में नीति क्या है, लेकिन अब आपके पास अलग-अलग उत्तरों में दो अलग-अलग दृष्टिकोण हैं, एक ही प्रोग्राम भाषा में एक ही उपयोगकर्ता द्वारा। क्या यह 9- और 10-बाइट स्निपेट दोनों को एक ही उत्तर में रखना उचित नहीं होगा, क्योंकि यह एक ही प्रोग्रामिंग भाषा है और आप दोनों के पास है? मैं एक ही प्रोग्रामिंग भाषा में कई उपयोगकर्ताओं द्वारा कई उत्तरों को समझ सकता हूं, लेकिन मुझे लगता है कि एक ही प्रोग्रामिंग भाषा में एक ही उपयोगकर्ता द्वारा अलग-अलग दृष्टिकोण संपादन के रूप में बेहतर अनुकूल होंगे। एकदम मेरे विचार।

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

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

— डेनिस

Answer 2

05AB1E , 21 बाइट्स

vyN+Ny-})¹gL<Ãv¹yè})Z

व्याख्या

v      }               # for each num in input
 yN+                   # push index + num
    Ny-                # push index - num
        )              # wrap stack in a list
         ¹gL<Ã         # remove indices outside the range of input
              v¹yè})   # get list of elements in input at the remaining indices
                    Z  # get max

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

Comments

आप शायद हर समय इसका इस्तेमाल करते हैं, लेकिन मैंने केवल "लिस्ट में रैप स्टैक" देखा है। साफ।

— ग्रीनएजजैड

@GreenAsJade: हाँ, यह उन कमांडों में से एक है जिसका मैं सबसे ज्यादा इस्तेमाल करता हूँ :)

— Emigna

Answer 3

हास्केल, 61 57 55 बाइट्स

f x=maximum[a|(n,a)<-x,(i,b)<-x,b==abs(n-i)]
f.zip[0..]

प्रयोग उदाहरण: (f.zip[0..]) [5,28,14,5,6,3,4,7]-> 14।

(अधिक या कम) परिभाषा का एक सीधा कार्यान्वयन: nइनपुट सूची के प्रत्येक सूचकांक के xलिए a := x!!nअगर कोई सूचकांक है iजहां b := x!!iबराबर होता है abs(n-i)। अधिकतम खोजें।

संपादित करें: @xnor ने दो बाइट्स बचाए। धन्यवाद!

Comments

चूंकि आप उपयोग नहीं कर रहे हैं x, इसलिए किसी फ़ंक्शन को परिभाषित करना और उसमें zरचना करना छोटा होना चाहिए zip[0..]।

— xnor

Answer 4

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

,N+JFfJị¹Ṁ

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

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

,N+JFfJị¹Ṁ  Main link. Argument: A (array)

,N          Pair A with -A (element-wise negative).
   J        Yield the indices of A [1, ..., len(A)].
  +         Add the elements of A (and their negatives) with the corr. indices.
    F       Flatten the resulting 2D array.
     fJ     Filter indices; remove invalid indices (not in [1, ..., len(A)]) from
            the generated array. The result is the list of all indices of eligible
            elements of A.
       ị¹   Retrieve the corresponding elements of A.
         Ṁ  Take the maximum.

Answer 5

पायथन 3, 85 80 72 बाइट्स

lambda l,e=enumerate:max(i for p,i in e(l)for s,j in e(l)if j==abs(s-p))

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

Answer 6

EXCEL: 32 30 बाइट्स

=MAX(IF(A:A-ROW(A:A)<0,A:A,0))

मुझे अभी भी विश्वास नहीं हो रहा है कि मुझे यह छोटा है ...

उपयोग कैसे करें:
किसी भी सेल में इसे पेस्ट करें। कॉलम ए की कोशिकाओं को चिपकाएं। चिपकाने के बाद, संपादन करते समय, इसे सही ढंग से दर्ज करने के लिए control+ shift+ दबाएं enter।
अपने मानों को स्तंभ A, 1 मान प्रति कक्ष (CSV प्रविष्टि के अनुसार) में रखें।

यदि आप यह पता लगाना चाहते हैं कि यह कैसे काम करता है, तो मैंने एक्सेल प्रश्न में अपने सुझाव के लिए अतिरिक्त टिप पोस्ट की है ।

Comments

मैं इन एक्सेल गोल्फ प्यार कर रहा हूँ - जो सोचा था !!

— ग्रीनएजेड जेड

Answer 7

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

a=>Math.max(...a.filter((_,i)=>a.some((e,j)=>e==i-j|e==j-i)))

Answer 8

पर्ल, 45 बाइट्स

के लिए +2 शामिल है -ap

STDIN पर एक लाइन पर नंबर दें:

largest.pl <<< "5 12 2 5 4 7 3 3 6 2 10 5 5 5 4 1 8 5"

largest.pl:

#!/usr/bin/perl -ap
($_)=sort{$b-$a}map@F[$^P=$n-$_,$n+++$_],@F

^Pशाब्दिक नियंत्रण चरित्र द्वारा प्रतिस्थापित करके एक और बाइट प्राप्त किया जा सकता है , लेकिन यह हाल के पर्ल्स पर STDERR पर चेतावनी देता है।

मान लिया गया है largest number + array length < 2^32

Answer 9

पायथ, 19 17 बाइट्स

-2 बाइट्स के लिए @ Pietu1998 का ​​धन्यवाद

eS@LQ@UQs.e,-kb+b

एक प्रोग्राम जो STDIN पर एक सूची का इनपुट लेता है और परिणाम प्रिंट करता है।

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

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

eS@LQ@UQs.e,-kb+b  Program. Input: Q
         .e        Map over Q (implicit input fill) with elements as b and indices as k:
            -kb     k-b
               +b   k+b (Implicit fill with k)
           ,        2-element list of those (possible indices)
        s          Flatten that
      UQ           Yield [0, 1, 2, 3..., len(Q)-1]
     @             Filter the flattened list by presence in the above, removing invalid
                   indices
  @LQ              Index into Q at those indices
 S                 Sort that
e                  Yield the last element of that, giving the maximum
                   Implicitly print

Comments

}#के रूप में ही है @। इसके अलावा, यदि आप अंतिम बिट को पुनर्व्यवस्थित करते हैं तो आप अंतिम ,-kb+bkको हटा सकते हैं kक्योंकि पायथ ऑटो इसे सम्मिलित करता है।

— पुरकाकूदरी

@ Pietu1998 धन्यवाद। मैं एन्युमरेट के लिए निहित भरण के बारे में नहीं जानता था; क्या वह किसी अन्य मानचित्र-प्रकार के कार्यों के लिए काम करता है?

— बाइकिंग बाइकिंग

किसी भी लैम्ब्डा के लिए काम करता है, यह किसी भी लैम्ब्डा के पहले लैम्ब्डा वेरिएबल के साथ ऑटोफिल करता है।

— पुरकाकूदरी

Answer 10

MATL, 13 बाइट्स

ttn:tYTq=a)X>

इनपुट एक कॉलम वेक्टर होना चाहिए। Ie, इनपुट अर्धविराम से अलग है [1; 2; 3] की तरह, या अल्पविराम के साथ अंत में एक ट्रांस टिक के साथ अलग हो जाता है जैसे [1,2,3]।

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

सभी परीक्षण मामले: (ए) , (बी) , (सी) , (डी) , (ई) , (एफ)

2 वर्णों को बचाने के लिए MATL चैटरूम में सुझावों के लिए स्वेअर का धन्यवाद ।

स्पष्टीकरण:

समग्र रणनीति मेरे ऑक्टेव / MATLAB उत्तर के समान है, जहां मूल अवधारणा को समझाया गया है: /codegolf//a/94161/42247

इस MATL उत्तर में विशिष्ट कोड निम्नानुसार बनाया गया है:

विधि का मूल टोप्लेट्ज़ मैट्रिक्स का निर्माण है जिसकी ij'th प्रविष्टि एब्स (ij) है। हम पहले टोटलिट्ज़ मैट्रिक्स का निर्माण एंट्री एब्स (i-1) +1 के साथ करते हैं और MATL की टोप्लेट्ज़ कमांड YT के साथ बनाते हैं:

n:tYT % Equivalent to @(v)toeplitz(1:length(v))

यह देखने के लिए कि यह कैसे काम करता है, आइए हम इस कोड स्निपेट 'v' को इनपुट वेक्टर कहते हैं। 'N' v की लंबाई पाता है, फिर ':' वेक्टर 1: लंबाई (v) का निर्माण करता है। इसके बाद 't' स्टैक पर 1: लंबाई (v) की एक और कॉपी बनाता है; MATL में YT फ़ंक्शन में एक प्रसिद्ध बग के कारण इस अतिरिक्त प्रतिलिपि की आवश्यकता है (tolplitz () के MATL समतुल्य), जिसमें यह 1 के बजाय इनपुट की दो प्रतियों की अपेक्षा करता है। फिर YT इस वेक्टर की दो प्रतियों को लेता है 1 : स्टैक से लंबाई (v), और उनमें से abs (ij) +1 टोप्लेट्ज़ मैट्रिक्स बनाता है।

अब हमें एंटिब्स एब्स (आईजे) के साथ टोप्लेट्ज़ मैट्रिक्स प्राप्त करने के लिए इस मैट्रिक्स से 1 को घटाना होगा, और आईजे स्थानों को खोजना होगा जहां यह एब्स (आईजे) टोप्लेट्ज़ मैट्रिक्स सभी कॉलम वैक्टर के मैट्रिक्स के बराबर है जिसमें इनपुट की प्रतियां हैं। वेक्टर v। यह निम्नानुसार किया जाता है:

t n:tYT q=
% t [code] q= is equivalent to @(v) [code](v)-1 == v

पहला 't' इनपुट की एक अतिरिक्त प्रतिलिपि बनाता है और इसे स्टैक पर संग्रहीत करता है। 'N: tYT' पहले वर्णित के रूप में tolplitz मैट्रिक्स बनाता है और इसे स्टैक में आउटपुट करता है। तब 'क्यू' टोप्लेट्ज़ मैट्रिक्स से 1 घटाता है, और '=' एब्स (ij) मैट्रिक्स और वेक्टर के बीच एलिमेंट की समानता की तुलना करता है जिनके कॉलम इनपुट की कॉपी होते हैं। ध्यान दें कि एक मैट्रिक्स से कॉलम वेक्टर की तुलना करके, हम स्पष्ट रूप से MATLAB / MATL के ऑपरेटर प्रसारण नियमों का लाभ उठा रहे हैं (तुलना में कॉलम वेक्टर किसी भी आदेश को जारी किए बिना मैट्रिक्स बनाने के लिए कॉपी किया जाता है)।

अंत में, हमें पंक्ति सूचकांकों को खोजने की आवश्यकता है i जहाँ एक स्तंभ j है जैसे कि मैट्रिक्स 1 में निर्मित अंतर में ij'th प्रविष्टि, फिर इन सूचकांकों के अनुरूप इनपुट वेक्टर का मान प्राप्त करें, फिर अधिकतम लें। यह निम्नलिखित तीन चरणों में है:

1) किसी भी पंक्ति के लिए सूचकांक खोजें जिसमें एक गैर-रेखा हो:

tn:tYTq= a
% [code] a is equivalent to @(v) any([code](v))

2) उन सूचकांकों के अनुरूप इनपुट वेक्टर के तत्वों को निकालें:

t tn:tYTq= a ) X>
% t [code] ) is equivalent to @(v) v([code](v)]

3) अधिकतम तत्व ढूंढें और वापस लौटें:

t tn:tYTq= a ) X>
% [code] X> is equivalent to @(v) max(v).

Comments

फ़ंक्शन का व्यवहार रिलीज़ 20.2.2YT में बदल गया है । अब यह डिफ़ॉल्ट रूप से 1 इनपुट का उपयोग करता है (जो सामान्य रूप से अधिक उपयोगी है)। हालांकि यह आपको यहां 1 बाइट बचाएगा ( पहले हटा दें ), इसका फायदा नहीं उठाया जा सकता क्योंकि भाषा में परिवर्तन चुनौती को स्थगित कर देता है। लेकिन इसका प्रभाव यह है कि आपका उत्तर अब नई रिलीज़ में मान्य नहीं है, जो अब TIO में हैtYT

— लुइस मेंडू

आप या तो लिंक किए गए कोड को संपादित कर सकते हैं और एक नोट छोड़ सकते हैं, या MATL ऑनलाइन दुभाषिया के लिए इस लिंक का उपयोग कर सकते हैं , जो पुराने रिलीज का समर्थन करता है। दुर्भाग्य से आपको अन्य लिंक को भी अपडेट करना होगा। असुविधा के लिए खेद है

— लुइस मेंडो

इस बात का लिहाज किए बिना, आप कर सकते हैं जगह बाइट 1 बचाने के n:द्वाराf

— लुइस Mendo

Answer 11

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

->a{i=-1;a.map{|e|i+=1;[a[j=i+e]||0,a[0>(k=i-e)?j:k]||0].max}.max}

Answer 12

ऑक्टेव / MATLAB, 40 बाइट्स

@(v)max(v(any(toeplitz(1:nnz(v))-v==1)))

इनपुट एक कॉलम वेक्टर होना चाहिए।

3 बाइट बचाने वाले सुझावों के लिए लुइस मेंडो का धन्यवाद (टिप्पणी देखें)

4 और बाइट्स (~ (सम) ()) को किसी भी () के साथ बदलने वाले सुझावों के लिए स्वेअर के लिए धन्यवाद

स्पष्टीकरण:

एक इनपुट वेक्टर v को देखते हुए, यह समस्या सभी समाधानों को खोजने के बराबर है, जो कि निम्नलिखित असतत समीकरण के j,

abs(i-j) = v(i),   i,j both in 1..k,

जहाँ abs () निरपेक्ष मान फ़ंक्शन है। प्रत्येक v (i) जिसके लिए इस समीकरण को हल किया जाता है, एक उम्मीदवार समाधान है जिसे हम अधिकतम कर सकते हैं।

I और j के असतत कार्य के रूप में, बाएं हाथ की तरफ की सभी संभावनाओं को टोलपिट्ज़ मैट्रिक्स में व्यवस्थित किया जा सकता है जो इस तरह दिखता है:

[0, 1, 2, 3, 4]
[1, 0, 1, 2, 3]
[2, 1, 0, 1, 2]    <--- abs(i-j)
[3, 2, 1, 0, 1]
[4, 3, 2, 1, 0]

और चूंकि दाहिने हाथ की तरफ मैं पर निर्भर नहीं करता है, इसलिए इसके लिए सभी संभावनाओं को एक मैट्रिक्स में व्यवस्थित किया जा सकता है जहां कॉलम इनपुट की सभी प्रतियां हैं

[v(1), v(1), v(1), v(1), v(1)]
[v(2), v(2), v(2), v(2), v(2)]
[v(3), v(3), v(3), v(3), v(3)]   <--- v(i)
[v(4), v(4), v(4), v(4), v(4)]
[v(5), v(5), v(5), v(5), v(5)]

समीकरण के सभी समाधान खोजने के लिए, हम इन दो मैट्रिक्स को घटाते हैं और उन स्थानों को खोजते हैं जहां शून्य है। पंक्तियाँ जहाँ एक शून्य होता है, वांछित सूचकांकों के अनुरूप होता है, जहाँ aj होता है जैसे कि abs (ij) = v (i)।

अन्य चाल:

• निरपेक्ष मान फ़ंक्शन प्लस वन, एब्स (आईजे) +1 का निर्माण करने के लिए कम वर्ण लगते हैं, फिर उन स्थानों की जांच करें जहां अंतर 1 है, बजाय सच्चे (अनशिक्षित) निरपेक्ष मान फ़ंक्शन के निर्माण के।
• स्वचालित रूप से वी की कॉलम प्रतियां बनाने के लिए प्रसारण के लिए स्वचालित ऑपरेटर का उपयोग करता है
• इनपुट की लंबाई nnz () के बजाय लंबाई () के माध्यम से हो जाती है, जो समस्या बयान में इनपुट सकारात्मक होने के बाद से काम करता है।

Comments

इनपुट प्रारूप डिफ़ॉल्ट रूप से लचीला है। आप vएक कॉलम वेक्टर के रूप में ले सकते हैं , बस उस उत्तर में बताएं। इसके अलावा, आप को बदलने के findद्वारा ~~करने के लिए दो और बाइट्स बचाने

— लुइस Mendo

@LuisMendo धन्यवाद, मैंने आपके सुझावों को शामिल करने के लिए पोस्ट को संपादित किया!

— निक अल्जीर

विभिन्न भाषाओं के लिए (या एक ही भाषा में काफी अलग दृष्टिकोण) आपको एक और उत्तर पोस्ट करना चाहिए । वहाँ एक है Matl चैटरूम आप भाषा के बारे में कोई प्रश्न हैं

— लुइस Mendo

MATL toeplitz( YT) में बग के कारण BTW, यह डिफ़ॉल्ट रूप से दो इनपुट (एक नहीं) का उपयोग करता है

— लुइस

अच्छा ठीक है। मैंने इसे MATL में अनुवादित किया और एक और उत्तर यहाँ पोस्ट किया: codegolf.stackexchange.com/a/94183/42247

— निक

Answer 13

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

Max@MapIndexed[{If[#2[[1]]>#,a[[#2-#]],{}],a[[#2+#]]~Check~{}}&,a=#]&

अनाम फ़ंक्शन। पूर्णांक की सूची को इनपुट के रूप में लेता है और आउटपुट के रूप में पूर्णांक देता है। उत्पन्न किसी भी संदेश को अनदेखा करें।

Answer 14

स्काला, 94 बाइट्स

a=>a.zipWithIndex.filter(p=>a.zipWithIndex.exists(x=>x._1==Math.abs(p._2-x._2))).unzip._1.max

Answer 15

PHP, 128 बाइट्स

<?foreach(($i=$_GET[i])as$k=>$v){$k-$v<0?:!($i[$k-$v]>$m)?:$m=$i[$k-$v];if($k+$v<count($i))if($i[$k+$v]>$m)$m=$i[$k+$v];}echo$m;

Answer 16

जावा 7, 125 123 बाइट्स

int c(int[]a){int r=0,i=0,l=a.length,x;for(;i<l;r=l>(x=i+a[i])?a[x]>r?a[x]:r:r,r=(x=i-a[i++])>0?a[x]>r?a[x]:r:r);return r;}

2 बाइट्स ने @mrco को धन्यवाद दिया ।

अनगुल्ड (सॉर्ट) और परीक्षण कोड:

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

class M{
  static int c(int[] a){
    int r = 0,
        i = 0,
        l = a.length,
        x;
    for(; i < l; r = l > (x = i + a[i])
                      ? a[x] > r
                         ? a[x]
                         : r
                      : r,
                 r = (x = i - a[i++]) > 0
                      ? a[x] > r
                         ? a[x]
                         : r
                      : r);
    return r;
  }

  public static void main(String[] a){
    System.out.println(c(new int[]{ 1, 13 }));
    System.out.println(c(new int[]{ 2, 9, 8, 3, 72, 2 }));
    System.out.println(c(new int[]{ 5, 28, 14, 5, 6, 3, 4, 7 }));
    System.out.println(c(new int[]{ 1, 3, 5, 15, 4, 1, 2, 6, 7, 7 }));
    System.out.println(c(new int[]{ 5, 1, 3, 5, 2, 5, 5, 8, 5, 1, 5, 1, 2, 3 }));
    System.out.println(c(new int[]{ 5, 12, 2, 5, 4, 7, 3, 3, 6, 2, 10, 5, 5, 5, 4, 1, 8, 5 }));
  }
}

आउटपुट:

13
8
14
7
5
10

Comments

आपको x & y की आवश्यकता नहीं है। बस उनमें से एक (-2) का पुन: उपयोग करें। इसके अलावा, मुझे नहीं लगता कि आप आर को एक विशाल टर्नरी में सेट कर सकते हैं-अगर आपको हमेशा दोनों मामलों का परीक्षण करना है, तो बाएं और दाएं।

— mrco

@mrco धन्यवाद, को हटा दिया ,y। और मैं वास्तव में एक ही निष्कर्ष पर आया था कि एकल त्रैमासिक यदि। बेशक, यह संभव है, लेकिन आप इसे दो बार कर देंगे, जिससे यह बहुत लंबा हो जाएगा।

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

Answer 17

जावा, 118 बाइट्स

int f(int[]a){int t=0,i,j,z=0,l=a.length;while(t<l*l){i=t/l;j=t++%l;z=a[i]>z&&((i<j?j-i:i-j)==a[j])?a[i]:z;}return z;}

Comments

PPCG में आपका स्वागत है! :)

— मार्टिन एंडर

Answer 18

पायथन, 58 बाइट्स

टोनी एस के रूबी जवाब के आधार पर । यह उत्तर पायथन 2 और 3 में काम करता है। गोल्फ के सुझावों का स्वागत है।

lambda n:max([n[i+v]for i,v in enumerate(n)if i+v<len(n)])

Ungolfing

def f(array):
    result = []
    for index, value in enumerate(array):
        if index + value < len(array):
            result.append(array[index + value])
    return max(result)

Answer 19

रूबी 56 बाइट्स

मेरा सबसे छोटा माणिक समाधान।

->n{x=[];i=0;n.map{|v|x<<n[v+i]&&v+i<n.size;i+=1};x.max}

रेल कंसोल में परीक्षण करना बहुत आसान है

a = ->n{x=[];i=0;n.map{|v|x<<n[v+i]&&v+i<n.size;i+=1};x.max}
a[[1, 13]
=> 13
a[[2, 9, 8, 3, 72, 2]]
=> 8
a[[5, 12, 2, 5, 4, 7, 3, 3, 6, 2, 10, 5, 5, 5, 4, 1, 8, 5]]
=> 10

यह 63 बाइट्स पर शुरू हुआ, इसे नीचे ट्रिम करने में मदद करने के सुझावों के लिए धन्यवाद!

Comments

आप .mapइसके बजाय का उपयोग कर सकते हैं.each

— Cyoce

भी (x) if (y)साथ प्रतिस्थापित किया जा सकता है(y)&&(x)

— Cyoce

आप a<<bइसके बजाय का उपयोग कर सकते हैंa+=[b]

— शर्लक

@ शर्लक 9 मैं << के बारे में भूल गया। + = [B] का उपयोग करके Cyoce के सुझाव के साथ && का उपयोग करके काम नहीं किया। अब यह करता है, धन्यवाद!

— टोनी एस।

Answer 20

दरअसल , 17 बाइट्स

यह उत्तर वास्तव में मेरे पाइथन उत्तर का पोर्ट है । गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

;╗ñ♂Σ⌠╜l>⌡░⌠╜E⌡MM

Ungolfing

         Implicit input L.
;╗       Duplicate L and save a copy of L to register 0.
ñ        enumerate() the other copy of L.
♂Σ       sum() all the pairs of [index, value of n]. Call this list Z.
⌠...⌡░   Push values of Z where the following function returns a truthy value. Variable v_i.
  ╜        Push L from register 0.
  l        Push len(L).
  >        Check if len(L) > v_i.
⌠...⌡M   Map the following function over Z_filtered. Variable i.
  ╜        Push L from register 0.
  E        Take the ith index of L.
M        max() the result of the map.
         Implicit return.

Answer 21

T-SQL (sqlserver 2016), 132 बाइट्स

golfed:

;WITH C as(SELECT value*1v,row_number()over(order by 1/0)n FROM STRING_SPLIT(@,','))SELECT max(c.v)FROM C,C D WHERE abs(D.n-C.n)=D.v

Ungolfed:

DECLARE @ varchar(max)='2, 9, 8, 3, 72, 2'

;WITH C as
(
  SELECT
    value*1v,
    row_number()over(order by 1/0)n
  FROM
    STRING_SPLIT(@,',')
)
SELECT
  max(c.v)
FROM
  C,C D
WHERE
  abs(D.n-C.n)=D.v

बेला

Answer 22

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

let f =
    
l=>l.map((n,i)=>m=Math.max(m,l[i+n]|0,l[i-n]|0),m=0)|m

console.log(f([1, 13])); // → 13
console.log(f([2, 9, 8, 3, 72, 2])); // → 8
console.log(f([5, 28, 14, 5, 6, 3, 4, 7])); // → 14
console.log(f([1, 3, 5, 15, 4, 1, 2, 6, 7, 7])); // → 7
console.log(f([5, 1, 3, 5, 2, 5, 5, 8, 5, 1, 5, 1, 2, 3])); // → 5
console.log(f([5, 12, 2, 5, 4, 7, 3, 3, 6, 2, 10, 5, 5, 5, 4, 1, 8, 5])); // → 10

Answer 23

क्लोजर, 68 बाइट्स

#(apply max(map(fn[i](get % i 0))(flatten(map-indexed(juxt - +)%))))

उदाहरण के लिए (map-indexed (juxt - +) [3 4 1 2])है ([-3 3] [-3 5] [1 3] [1 5])(सूचकांक +/-अपने मूल्य), इन मूल सदिश से लुक-अप मूल्यों के लिए उपयोग किया जाता है (आउट-ऑफ-श्रृंखला के लिए दोषी 0) और अधिकतम मूल्य पाया जाता है। अभी भी थोड़ा वर्बोज़ लगता है लेकिन कम से कम मुझे इस्तेमाल करने के लिए मिला juxt:)