शून्य से सटे सबसे बड़ी संख्या का पता लगाएं

38

चुनौती:

इनपुट के रूप में पूर्णांक की एक वेक्टर / सूची लें, और एक शून्य से सटे सबसे बड़ी संख्या का उत्पादन करें।

विशेष विवरण:

  • हमेशा की तरह, वैकल्पिक इनपुट और आउटपुट प्रारूप
  • आप मान सकते हैं कि कम से कम एक शून्य और कम से कम एक गैर-शून्य तत्व होगा।

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

1 4 3 6 0 3 7 0
7

9 4 9 0 9 0 9 15 -2
9

-4 -6 -2 0 -9
-2

-11 0 0 0 0 0 -12 10
0

0 20 
20

गुड लक और खुश गोल्फ!

code-golf  number 
— स्टीवी ग्रिफिन
स्रोत
आपको 4 वें की तरह एक परीक्षण मामला जोड़ना चाहिए, लेकिन जहां परिणाम नकारात्मक है (सूची में सकारात्मक संख्याएं हैं)।
— mbomb007
मैं रेटिना में यह कोशिश करने जा रहा था, लेकिन फिर मैंने देखा कि नकारात्मक हैं। रेटिना नकारात्मकता से नफरत करता है।
— mbomb007
2
रेटिना को यह निर्धारित न होने दें कि आप क्या कर सकते हैं और क्या नहीं। संभालो, तुम मालिक हो!
— स्टीवी ग्रिफिन

जवाबों:

19

MATL , 10 बाइट्स

t~5BZ+g)X>

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

व्याख्या

[-4 -6 -2 0 -9]एक उदाहरण के रूप में इनपुट लेते हैं ।

t     % Input array. Duplicate
      %   STACK: [-4 -6 -2 0 -9],  [-4 -6 -2 0 -9]
~     % Logical negate. Replaces zeros by logical 1, and nonzeros by logical 0
      %   STACK: [-4 -6 -2 0 -9],  [0 0 0 1 0]
5B    % Push logical array [1 0 1] (5 in binary)
      %   STACK: [-4 -6 -2 0 -9], [0 0 0 1 0], [1 0 1]
Z+    % Convolution, maintaining size. Gives nonzero (1 or 2) for neighbours of
      % zeros in the original array, and zero for the rest
      %   STACK: [-4 -6 -2 0 -9], [0 0 1 0 1]
g     % Convert to logical
      %   STACK: [-4 -6 -2 0 -9], [0 0 1 0 1]
)     % Use as index into original array
      %   STACK: [-2 -9]
X>    % Maximum of array.
      %   STACK: -2
      % Implicitly display
— लुइस मेंडो
स्रोत
x(~~(dec2bin(5)-48))। उस एक को लागू करने के लिए कौन विचार था? तार्किक सरणियों के लिए बहुत चालाक, और उपयोगी! :) अच्छा जवाब!
— स्टीवी ग्रिफिन
1
@WeeingIfFirst धन्यवाद! मैंने dec2bin()-'0'MATLAB में सैकड़ों बार उपयोग किया था , इसलिए मुझे पता था कि एक MATL :-) में होना था
— लुइस
5
वैसे, यह तथ्य कि आपने हर ऑपरेशन के बाद स्टैक की सामग्री को शामिल किया है, अकेले एक उत्थान के लायक है। इसे समझना इतना आसान हो जाता है (और संभवतः सीखना) MATL =)
— स्टीवी ग्रिफिन
2
कनवल्शन रॉक्स। +1
— सूपर सेप
10

05AB1E , 9 बाइट्स

ü‚D€P_ÏOZ

व्याख्या

ü‚         # pair up elements
  D        # duplicate
   €P      # product of each pair (0 if the pair contains a 0)
     _     # logical negate, turns 0 into 1 and everything else to 0
      Ï    # keep only the pairs containing at least 1 zero
       O   # sum the pairs
        Z  # take max

ऑनलाइन दुभाषिया में काम नहीं करता है, लेकिन ऑफ़लाइन काम करता है।

— Emigna
स्रोत
यह अद्भुत है! बस समय में: पी।
— अदनान
1
बस इन ऑपरेटरों में से एक को लागू किया या? :)
— स्टेवी ग्रिफिन
1
@EeingIfFirst: üकल ही जोड़ा गया था :)
— एमिग्ना
2
क्या यह वापसी नहीं होगी 0यदि वास्तविक उत्तर नकारात्मक होगा? मुझे लगता है कि आपको ज़ीरो फेंकना होगा।
— लिन
1
@ लिन अच्छा कैच! इसे (राशि) के ˜साथ प्रतिस्थापित करके आसानी से तय किया जा सकता है O।
— अदनान
9

हास्केल, 63 43 बाइट्स

f x=maximum[a+b|(a,b)<-tail>>=zip$x,a*b==0]

4 बाइट्स के लिए @MartinEnder को धन्यवाद!

— BlackCap
स्रोत
मुझे लगता है कि आप a*b==0इसके बजाय उपयोग कर सकते हैं ||।
— मार्टिन एंडर
आपको ज़िप के साथ पिछले संस्करण में वापस जाना होगा। यहाँ और अब आसन्न नहीं हैं
— डेमियन
आपको यहां लैम्बडाबोट की आवश्यकता नहीं है। यह "नियमित" हास्केल है
— डेमियन
8

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

eSsM/#0,Vt

फॉर्म जोड़े, शून्य सदस्य द्वारा फ़िल्टर, योग द्वारा सॉर्ट, सबसे बड़ा रिटर्न।

— orlp
स्रोत
,Vt(प्रत्यय QQ) उसी जोड़े को वापस लौटाता है .:Q2, जो जोड़े गए थे। हालांकि काम करना चाहिए।
— पुरकाकूदरी
f}0Tहै/#0
— isaacg
7

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

let f =
    
l=>l.map((n,i)=>m=l[i-1]==0|l[i+1]==0&&n>m?n:m,m=-1/0)|m

console.log(f([1, 4, 3, 6, 0, 3, 7, 0]));       // 7
console.log(f([9, 4, 9, 0, 9, 0, 9, 15, -2]));  // 9
console.log(f([-4, -6, -2, 0, -9]));            // -2
console.log(f([-11, 0, 0, 0, 0, 0, -12, 10]));  // 0
console.log(f([3, 0, 5]));                      // 5
console.log(f([28, 0, 14, 0]));                 // 28
स्निपेट का विस्तार करें

संपादित करें: हंट्रो के लिए 2 बाइट्स सहेजे गए
संपादित करें: 1 बाइट को ETHproductions के लिए धन्यवाद बचाया

— Arnauld
स्रोत
1
आप ==इसके बजाय दो बाइट बचा सकते हैं===
— हंट्रो सेप
1
मैं आपको कई जगहों पर कुछ बाइट्स बचा सकता हूं:l=>l.map((n,i)=>m=l[i-1]*l[i+1]==0&n>m?n:m,m=-1/0)|m
— ETHproductions
त्रुटि: {"संदेश": "सिंटैक्स त्रुटि", "फ़ाइल नाम": " stacksnippets.net/js ", " लिनेनो ": 15, "कॉलनो": 3}
— RosLuP
@RosLuP - इसमें एरो फंक्शन सपोर्ट के साथ ES6 की आवश्यकता होती है और यह सभी ब्राउज़रों पर काम नहीं करेगा (इसमें केवल इन तक सीमित नहीं है: एज से पहले सभी IE वर्जन, v10 के नीचे के सभी सफ़ारी वर्जन, आदि)
— Arnauld
6

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

a=>(m=-1/0,a.reduce((l,r)=>(m=l*r||l+r<m?m:l+r,r)),m)

क्योंकि मुझे प्रयोग करना पसंद है reduce। वैकल्पिक समाधान, 53 बाइट्स:

a=>Math.max(...a.map((e,i)=>e*a[++i]==0?e+a[i]:-1/0))
— नील
स्रोत
5

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

lambda a:max(sum(x)for x in zip(a,a[1:])if 0in x)

टेस्ट्स आइडोन पर हैं

जोड़े के माध्यम से जिप्स, जो किसी भी शून्य से युक्त हैं, अधिकतम रिटर्न देता है।

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

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

->a{a.each_cons(2).map{|a,b|a*b!=0?-1.0/0:a+b}.max}

प्रयोग

f=->a{a.each_cons(2).map{|a,b|a*b!=0?-1.0/0:a+b}.max}
p f[gets.split.map(&:to_i)]
— cia_rana
स्रोत
मुझे नहीं लगता कि आपको चारों ओर कोष्ठक की आवश्यकता है a+b।
— मार्टिन एंडर
@Martin एंडर सिंटैक्स त्रुटि होती है ... ideone.com/F6Ed4B
— cia_rana
यह रूबी 2.3 में काम करता है। (उदाहरण के लिए यहां उपलब्ध: repl.it/languages/ruby )
— मार्टिन
@Martin एंडर जब मैं "==" के बजाय "!" का उपयोग करता हूं, तो यह काम करता है। आपके सुझाव के लिए धन्यवाद! ideone.com/F6Ed4B
— cia_rana
वहाँ एक बग है :(। -3 -2 0रिटर्न 0। मुझे लगता है कि इसे बदलने के ...?0:...साथ ...?-1.0/0:...इसे ठीक करना चाहिए, 5 बाइट्स जोड़ना चाहिए।
— m-chrzan
4

PHP, 77 68 71 बाइट्स

अनाम की ओर से -3 बाइट, मार्टिनएंडर से -4 और -2

preg_match_all("#(?<=\b0 )\S+|\S+(?= 0)#",$argv[1],$m);echo max($m[0]);

साथ दौड़ो php -r '<code>' '<space separated values>'

— टाइटस
स्रोत
2
\Kअब तक के मैच को छोड़ने के लिए उपयोग करना लुक-बैक का उपयोग करने से कम है।
— user59178
2
आप इनपुट के लिए अंतरिक्ष पृथक्करण का उपयोग भी कर सकते हैं और फिर \S+एक हस्ताक्षरित पूर्णांक से मिलान करने के लिए उपयोग कर सकते हैं । आपको संभवतः इसका उपयोग करना होगा \b0,ताकि आपको पहले से तैयारी न करनी पड़े ,।
— मार्टिन एंडर
1
क्या यह इनपुट की तरह काम करता है 4 0 0 5?
— टन हास्पेल
@TonHharma नहीं \Kविकल्प के साथ काम नहीं करता है ? अज्ञात कारण से, दूसरा वैकल्पिक रिटर्न 0 0, ताकि 0मैच से पहले कोई और मैच न हो 5। निश्चित, धन्यवाद।
— टाइटस
अन्य PHP समाधान के साथ register_globals पर एक नज़र डालें
— Jörg Hülsermann
4

जावा 7, 118 105 106 बाइट्स

int d(int[]a){int i=0,m=1<<31,c;for(;++i<a.length;m=a[i]*a[i-1]==0&(c=a[i]+a[i-‌​1])>m?c:m);return m;}

13 बाइट्स ने इसके बजाय अंकगणितीय दृष्टिकोण का उपयोग करके @cliffroot को धन्यवाद बचाया । 1 अतिरिक्त बाइट @mrco को धन्यवाद जब उसने एक बग की खोज की (जोड़ा गया परीक्षण मामला बदले में 2, 1, 0वापस आ 2जाएगा 1)।

Ungolfed और परीक्षण कोड:

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

class M{
  static int c(int[] a){
    int i,
        m = a[i=0],
        c;
    for(; ++i < a.length; m = a[i] * a[i-1] == 0 & (c = a[i] + a[i - 1]) > m)
                           ? c
                           : m);
    return m;
  }

  public static void main(String[] a){
    System.out.println(c(new int[]{ 1, 4, 3, 6, 0, 3, 7, 0 }));
    System.out.println(c(new int[]{ 9, 4, 9, 0, 9, 0, 9, 15, -2 }));
    System.out.println(c(new int[]{ -4, -6, -2, 0, -9 }));
    System.out.println(c(new int[]{ -11, 0, 0, 0, 0, 0, -12, 10 }));
    System.out.println(c(new int[]{ 0, 20 }));
    System.out.println(c(new int[]{ 2, 1, 0 }));
  }
}

आउटपुट:

7
9
-2
0
20
1
— केविन क्रूज़सेन
स्रोत
1
अंकगणित का उपयोग करते हुए थोड़ा अलग दृष्टिकोण, काम करने लगता हैint d(int[]a){int i,m=a[i=0],c;for(;++i<a.length;m=a[i]*a[i-1]==0&(c=a[i]+a[i-1])>m?c:m);return m;}
— क्लिफरोट
3
आउटपुट गलत है, जब पहली संख्या 0 के निकट नहीं है, लेकिन परीक्षण के मामले {2, 1, 0} द्वारा 0. किसी भी संख्या से निकटवर्ती संख्या की तुलना में बड़ा है। आप इसे I को 0 से सीधे और m को 1 << 31 (+1 समग्र) के साथ आरंभ करके ठीक कर सकते हैं।
— mrco
3

MATLAB इमेज प्रोसेसिंग टूलबॉक्स, 32 बाइट्स के साथ

@(x)max(x(imdilate(~x,[1 0 1])))

यह एक अनाम फ़ंक्शन है। परीक्षण मामलों के लिए उदाहरण का उपयोग करें:

>> f = @(x)max(x(imdilate(~x,[1 0 1])))
f =
  function_handle with value:
    @(x)max(x(imdilate(~x,[1,0,1])))

>> f([1 4 3 6 0 3 7 0])
ans =
     7

>> f([9 4 9 0 9 0 9 15 -2])
ans =
     9

>> f([-4 -6 -2 0 -9])
ans =
    -2

>> f([-11 0 0 0 0 0 -12 10])
ans =
     0

>> f([0 20])
ans =
    20
— लुइस मेंडो
स्रोत
3

दिल्लोग एपीएल , 14 बाइट्स

⌈/∊2(+↑⍨0∊,)/⎕

⌈/ सबसे बड़ा

∊चपटा हुआ (" e nlisted")

2(... )/जोड़ीदार

 + योग (शून्य प्लस कुछ है)

 ↑⍨ अगर लिया गया

 0 शून्य

 ∊ का सदस्य है

 , जोड़ी (बाएं हाथ की संख्या और दाहिने हाथ की संख्या का जलावन)

TryAPL ऑनलाइन!

— एडम
स्रोत
3

आर, 48 47 बाइट्स

EDIT: @Vlo की बदौलत एक एरर फिक्स्ड हुआ और इसे स्टैडिन्स से इनपुट पढ़ने के लिए बदल दिया गया, एक बाइट को परिन्थेस को असाइन wऔर स्किप करके बचाया गया । 

function(v)sort(v[c(w<-which(v==0)-1,w+1)],T)[1]


v=scan();w=which(v==0);sort(v[c(w-1,w+1)],T)[1]

बिना स्पष्टीकरण के

  1. वे संकेत खोजें जिनके लिए वेक्टर vमान 0 पर है:w <- which(v == 0)
  2. नए वेक्टर बनाएं जिसमें सूचकांक शामिल हों +-1: w-1औरw+1
  3. तत्वों को निकालें जो सूचकांकों से मेल खाते हैं w-1औरw+1
  4. अवरोही क्रम में क्रमबद्ध करें और मुट्ठी तत्व निकालें

ध्यान दें कि यदि अंतिम या पहला तत्व vशून्य है, w+-1तो प्रभावी रूप से वेक्टर की लंबाई के बाहर एक सूचकांक प्राप्त करेगा जो कि v[length(v)+1]रिटर्न देता है NA। यह आम तौर पर कोई समस्या नहीं है लेकिन जब तक कोई विकल्प निर्दिष्ट नहीं करता है, तो वेक्टर में कोई भी घटना होने पर max()फ़ंक्शन असुविधाजनक रूप से वापस आ NAजाते हैं na.rm=T। इस प्रकार यह उपयोग करने की तुलना में पहले तत्व को सॉर्ट करने और निकालने के लिए 2 बाइट्स है max(), जैसे:

max(x,na.rm=T)
sort(x,T)[1]
— Billywob
स्रोत
1
एक अतिरिक्त कोष्ठक की आवश्यकता होती है अन्यथा सभी परीक्षण मामलों में विफल रहता है जहां अधिकतम 0 के दाईं ओर होता है जैसे c(1, 4, 3, 6, 0, 10, 7, 0) c((w<-which(v==0))-1,w+1)स्कैन के साथ थोड़ा छोटा भी होता हैsort((v<-scan())[c(w<-which(v==0)-1,w+1)],T)[1]
— Vlo
@ उस स्पष्ट त्रुटि को इंगित करने के लिए धन्यवाद, +1। अपने सुझाए गए समाधान में आप ()हालांकि भूल गए ;)। कोड अपडेट किया और vअब पूर्व हेरफेर सौंपा ।
— बिलीवॉब
3

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

@MartinEnder के कारण 3 बाइट्स बचाए ।

Max[Tr/@Partition[#,2,1]~Select~MemberQ@0]&

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

— LegionMammal978
स्रोत
2

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

के लिए +1 शामिल है -p

STDIN पर लाइन पर नंबर दें

largest0.pl <<< "8 4 0 0 5 1 2 6 9 0 6"

largest0.pl:

#!/usr/bin/perl -p
($_)=sort{$b-$a}/(?<=\b0 )\S+|\S+(?= 0)/g
— टन हास्पेल
स्रोत
2

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

f(l)=max(map(sum,filter(t->0 in t,zip(l,l[2:end])))...)

पड़ोसी मूल्यों के लिए tuples बनाएं, उन tuples को लें जिनमें 0, tuple मान हों और अधिकतम खोजें

— nyro_0
स्रोत
1

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

def f(x):x=[9]+x;print max(x[i]for i in range(len(x)) if 0in x[i-1:i+2:2])

हर तत्व के माध्यम से चक्र करें, यदि 0वर्तमान तत्व के बाईं या दाईं ओर की स्थिति में है, तो इसे जनरेटर में शामिल करें, और फिर इसके माध्यम से चलाएं max। हमें कुछ गैर- 0संख्या के साथ सूची को पैड करना होगा । यह कभी भी शामिल नहीं होगा क्योंकि स्लाइस [-1:2:2]में कुछ भी शामिल नहीं होगा।

— एससीबी
स्रोत
1

टी-एसक्यूएल, 182 बाइट्स

golfed:

DECLARE @x varchar(max)='1 5 4 3 6 1 3 17 1 -8 0 -7'

DECLARE @a INT, @b INT, @ INT WHILE @x>''SELECT @a=@b,@b=LEFT(@x,z),@x=STUFF(@x,1,z,''),@=IIF(@a=0,IIF(@b<@,@,@b),IIF(@b<>0 or @>@a,@,@a))FROM(SELECT charindex(' ',@x+' ')z)z PRINT @

Ungolfed: 

DECLARE @x varchar(max)='1 5 4 3 6 1 3 17 1 -8 0 -7'

DECLARE @a INT, @b INT, @ INT
WHILE @x>''
  SELECT 
   @a=@b,
   @b=LEFT(@x,z),
   @x=STUFF(@x,1,z,''),
   @=IIF(@a=0,IIF(@b<@,@,@b),IIF(@b<>0 or @>@a,@,@a))
  FROM(SELECT charindex(' ',@x+' ')z)z 
PRINT @

बेला

— t-clausen.dk
स्रोत
1

PowerShell v3 +, 62 बाइट्स

param($n)($n[(0..$n.count|?{0-in$n[$_-1],$n[$_+1]})]|sort)[-1]

अन्य उत्तरों की तुलना में थोड़ा लंबा, लेकिन एक निफ्टी दृष्टिकोण।

इनपुट लेता है $n। फिर सूचकांकों के माध्यम से छोरों 0..$n.count, उन सूचकांकों को बाहर निकालने के लिए Where-Object( |?{...}) का उपयोग करता है जहां सरणी में पिछला या अगला आइटम है 0, और उन वापस सरणी स्लाइस में फ़ीड करता है $n[...]। हम तो |sortउन तत्वों, और सबसे बड़ा लेते हैं [-1]।

उदाहरण

PS C:\Tools\Scripts\golfing> @(1,4,3,6,0,3,7,0),@(9,4,9,0,9,0,9,15,-2),@(-4,-6,-2,0,-9),@(-11,0,0,0,0,0,-12,10)|%{""+$_+" --> "+(.\largest-number-beside-a-zero.ps1 $_)}
1 4 3 6 0 3 7 0 --> 7
9 4 9 0 9 0 9 15 -2 --> 9
-4 -6 -2 0 -9 --> -2
-11 0 0 0 0 0 -12 10 --> 0

PS C:\Tools\Scripts\golfing> @(0,20),@(20,0),@(0,7,20),@(7,0,20),@(7,0,6,20),@(20,0,6)|%{""+$_+" --> "+(.\largest-number-beside-a-zero.ps1 $_)}
0 20 --> 20
20 0 --> 20
0 7 20 --> 7
7 0 20 --> 20
7 0 6 20 --> 7
20 0 6 --> 20
— AdmBorkBork
स्रोत
1

क्यू, 38 बाइट्स

{max x where 0 in'x,'(next x),'prev x}
— लियाम बैरन
स्रोत
जब 0 के बाद अधिकतम आता है तो यह काम नहीं करता है । इसके अलावा, मैं कोई क्यू विशेषज्ञ नहीं हूं, लेकिन मुझे लगता है कि आपको {}इसे बनाने के लिए अपने कोड को घेरना होगा ।
— डेनिस
1

जे, 18 बाइट्स

[:>./2(0&e.\#+/\)]

व्याख्या

[:>./2(0&e.\#+/\)]  Input: array A
                 ]  Identity. Get A
     2              The constant 2
      (         )   Operate on 2 (LHS) and A (RHS)
               \    Get each subarray of size 2 from A and
             +/       Reduce it using addition
           \        Get each subarray of size 2 from A and
       0&e.           Test if 0 is a member of it
            #       Filter for the sums where 0 is contained
[:>./               Reduce using max and return
— मील की दूरी पर
स्रोत
1

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

{max map ->$/ {$1 if !$0|!$2},(1,|@_,1).rotor(3=>-2)}

विस्तारित:

# bare block lambda with implicit signature of (*@_)
{
  max

    map

      -> $/ {           # pointy lambda with parameter ｢$/｣
                        # ( ｢$0｣ is the same as ｢$/[0]｣ )
        $1 if !$0 | !$2 # return the middle value if either of the others is false
      },

      ( 1, |@_, 1 )     # list of inputs, with added non-zero terminals
      .rotor( 3 => -2 ) # grab 3, back-up 2, repeat until less than 3 remain
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
1

PHP, 66 बाइट्स

foreach($a=$argv as$k=>$v)$v||$m=max($m,$a[$k-1],$a[$k+1]);echo$m;

बहुत सीधा। इनपुट पर Iterates, और जब कोई संख्या होती है 0, तो यह $m2 आसन्न संख्याओं की उच्चतम संख्या और किसी भी पिछले मान पर सेट होती है $m।

इस तरह से चलाएं ( -dकेवल सौंदर्यशास्त्र के लिए जोड़ा गया):

php -d error_reporting=30709 -r 'foreach($a=$argv as$k=>$v)$v||$m=max($m,$a[$k-1],$a[$k+1]);echo$m;' -- -4 -6 -2 0 -9;echo
— aross
स्रोत
1

सी # 76 74 बाइट्स

using System.Linq;i=>i.Zip(i.Skip(1),(a,b)=>a*b==0?1<<31:a+b).Max(‌​);

स्पष्टीकरण:

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

उपयोग:

[TestMethod]
public void LargestFriend()
{
    Assert.AreEqual(7, F(new int[] { 1, 4, 3, 6, 0, 3, 7, 0 }));
    Assert.AreEqual(9, F(new int[] { 9, 4, 9, 0, 9, 0, 9, 15, -2 }));
    Assert.AreEqual(-2, F(new int[] { -4, -6, -2, 0, -9 }));
    Assert.AreEqual(0, F(new int[] { -11, 0, 0, 0, 0, 0, -12, 10 }));
    Assert.AreEqual(20, F(new int[] { 0, 20 }));
}
— Grax32
स्रोत
नमस्ते। आप अंतरिक्ष को हटा सकते हैं int[]i) {। इसके अलावा, मैं आपके वर्तमान कोड में 75 बाइट्स गिनता हूं (यदि आप स्थान हटाते हैं तो 74)।
— केविन क्रूज़सेन
मुझे लगता है कि आप टर्नरीज़ को निकालकर 4 बाइट बचा सकते हैं:a?b?i.Min()).Max():a:b
— टाइटस
इसके अलावा using System.Linq;, नहीं?
— Pinkfloydx33
यह सच है लेकिन यह सवाल सिर्फ एक विधि के लिए पूछा गया है, न कि एक पूर्ण कार्यक्रम और उपयोग करने System.Linq;के लिए डिफ़ॉल्ट नए वर्ग टेम्पलेट का हिस्सा है।
— ग्रेक्स 32
@Grax किसी भी तरह से आपको usingअपने बाइट काउंट में स्टेटमेंट को शामिल करने की आवश्यकता है
— TheLethalCoder
1

आर, 48 54 बाइट्स

s=scan()

w=which;max(s[c(w(s==0)+1,w(s==0)-1)],na.rm=T)

कंसोल इनपुट से वेक्टर पढ़ता है, फिर 0 से सटे सभी मानों पर अधिकतम लेता है।

संपादित करें: सीमा पर उत्पादित एनए कैच, धन्यवाद rturnbull!

— सिर की टक्कर
स्रोत
क्या मैं गलत कर रहा हूँ? pastebin.com/0AA11xcw
— मैनटवर्क
यह इस तरह के मामलों के लिए विफल रहता है 20 0, क्योंकि s[w(s==0)+1]रिटर्न NA, और इसे वापस करने के लिए maxडिफ़ॉल्ट उपचार NAहै। आप तर्क जोड़कर ठीक कर सकते हैं na.rm=T, या कोड का उपयोग करने के लिए फिर से काम कर सकते हैं sort(ऊपर पोस्ट किए गए अन्य आर उत्तर देखें)।
— rturnbull
क्या आप एक लाइन में सब कुछ संघनित कर सकते हैं? मैं नहीं जानता कि आर में कैसे कोड करूं, लेकिन मैं मान रहा हूं कि आप कर सकते हैं।
— मौसमी
@ Qwerp-Derp: जहां तक ​​मुझे पता है, नहीं। वेक्टर में पढ़ने के लिए कंसोल इनपुट के लिए स्कैन () प्रतीक्षा करता है, इनपुट स्ट्रीम एक खाली लाइन दर्ज करके बंद हो जाती है। यदि आप दो लाइनों को एक के रूप में चलाते हैं, तो दूसरा भाग कम से कम आंशिक रूप से वेक्टर के इनपुट के लिए पहचाना जाएगा।
— हेडक्रैश
0

रैकेट 183 बाइट्स

(λ(k)(let*((lr(λ(l i)(list-ref l i)))(l(append(list 1)k(list 1)))(m(for/list((i(range 1(sub1(length l))))
#:when(or(= 0(lr l(sub1 i)))(= 0(lr l(add1 i)))))(lr l i))))(apply max m)))

विस्तृत संस्करण: 

(define f
 (λ(k)
    (let* ((lr (λ(l i)(list-ref l i)))
           (l (append (list 1) k (list 1)))
           (m (for/list ((i (range 1 (sub1(length l))))
                         #:when (or (= 0 (lr l (sub1 i)))
                                    (= 0 (lr l (add1 i))) ))
                (lr l i) )))
      (apply max m) )))

परिक्षण: 

(f (list 1 4 3 6 0 3 7 0))
(f (list 9 4 9 0 9 0 9 15 -2))
(f (list -4 -6 -2 0 -9))
(f (list -11 0 0 0 0 0 -12 10))
(f (list 0 20 ))

आउटपुट: 

7
9
-2
0
20
— rnso
स्रोत
0

C 132 बाइट्स

मुख्य रिटर्न कोड का उपयोग कर आउटपुट:

int main(int a,char**_){int i,m=0;_[0]=_[a]="1";for(i=1;i<a;++i){m=(*_[i-1]-48||*_[i+1]-48?m>atoi(_[i])?m:atoi(_[i]):m);}return m;}

मुझे ऐसा लग रहा है कि मुझे अटोई कॉल में से एक को बचाकर कुछ बाइट्स को बचाने में सक्षम होना चाहिए, लेकिन मुझे एक कुशल तरीका नहीं मिला। ( ,tप्लस t=प्लस ,प्लस tदो बार बहुत लंबा है)। इसके अलावा यह तकनीकी रूप से अपरिभाषित व्यवहार का उपयोग करता है (_ [a] से "1" की स्थापना) लेकिन हर संकलक जो मुझे पता है वह डिफ़ॉल्ट रूप से इसकी अनुमति देता है।

रणनीति: 1 के साथ सरणी के प्रारंभ और अंत को पैड करें, फिर प्रत्येक पड़ोसी की जांच करने वाले आंतरिक अनुभाग पर लूप करें।

— LambdaBeta
स्रोत
0

PHP 69 64 बाइट्स

Jörg Hülsermann और टाइटस से कुछ दूर और बाइट्स। =(-5)

Register_globals सक्षम होना चाहिए। उपयोग:http://localhost/notnull.php?i[]=9&i[]=-5i[]=...

$x=$_GET['i'];
$y=0;
foreach($x as $j){
if($y<abs($j)){
$y=$j;
}
}
echo $y;

golfed:

$x=$_GET['i'];$y=0;foreach($x as $j)if($y<abs($j))$y=$j;echo $y;
— रोमन ग्रैफ़
स्रोत
सरणी के रूप में सीधे इनपुट का उपयोग क्यों न करें। मैं json_encode का कारण नहीं देख सका।
— जोर्ग हल्सरमैन सेप
गैर-डिफ़ॉल्ट सेटिंग्स के लिए आपको सेटिंग की पूरी लंबाई को अपनी बाइट काउंट में जोड़ना होगा। (देखें meta.codegolf.stackexchange.com/q/4778#4778 ) इस मामले में -d register_globals=1(या एक ऐसा संस्करण निर्दिष्ट करें जहां register_globals डिफ़ॉल्ट रूप से सक्षम है)
— टाइटस
लेकिन json_decodeएक अच्छा विचार है।
— टाइटस
@ टिट्स मेरा मतलब है ?id[]=1&id[]=2&id[]=3 और फिर $_GET["id"]एक सरणी देता है। इस कारण json_decode मेरे लिए कोई मायने नहीं रखता है
— Jörg Hülsermann
@ JörgHülsermann यह बाइट खर्च करता है, लेकिन यह अभी भी एक अच्छा विचार है।
— टाइटस
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.