32

N बच्चे, जिनके दो सही आकार नहीं हैं, कुछ क्रम में पंक्तिबद्ध हैं। प्रत्येक केवल अपने नजदीकी पड़ोसियों के साथ ऊंचाइयों की तुलना कर सकता है। जब शिक्षक चिल्लाता है "अगर तुम सबसे ऊंचे हो तो हाथ उठाओ", वे ऐसा करते हैं यदि वे अपने दोनों पड़ोसियों से लम्बे हैं, और वे एक साथ ऐसा करते हैं। यदि केवल कोई अपना हाथ उठाता है, तो वह जीतता है। यदि एक से अधिक अपने हाथ बढ़ाते हैं, तो वे सभी पंक्ति से समाप्त हो जाते हैं (बाकी बच्चों के आदेश को संरक्षित करते हुए) और वे प्रक्रिया को दोहराते हैं।

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

उदाहरण (दिखाए गए मध्यवर्ती चरणों के साथ):

5 3 9 8 7 → 3 8 7 → 8

१ २ ९ ४ → ९

९ ३ 8 7 ४ १२ ५ → ३ 12 4 5 → 3 4 → 4

वर्तमान नेताओं:

जेली: 17 बाइट्स [डेनिस tes द्वारा]
MATL: 20 बाइट्स [लुइस मेंडो द्वारा]
APL: 28 बाइट्स [voidhawk]
k: 40 बाइट्स [पॉल केरिगन द्वारा]

वहाँ भी अजगर की लड़ाई चल रही है। फिर भी अधिक गोल्फिंग भाषाओं के प्रदर्शन की प्रतीक्षा है।

मैंने वर्तमान में डेनिस का उत्तर स्वीकार कर लिया है - यदि नए विजेता हैं, तो मैं चयन को अपडेट करूंगा।

code-golf math array-manipulation

— ओरियन
स्रोत

2

अधिक लगता है "कौन सबसे लंबा हो सकता है, या नहीं हो सकता है?" - वास्तव में "जो सबसे लंबा है" आपको अपने हाथों को नीचे

— Alnitak

4

मैंने बच्चों के खेल में समानता दिखाई, जहां एक व्यक्ति कुछ हस्ताक्षर वाक्यांश चिल्लाता है जिसके बाद खेल का नाम दिया जाता है। मजेदार रूप से पर्याप्त, सबसे बड़ा कम से कम (एक बड़े अंतर से) जीतने की संभावना है। असममित रूप से, N से बाहर! क्रमपरिवर्तन, केवल 2 ^ (N-1) मामलों में वह जीतता है।

— ओरियन डेस

4

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

j@N»3\=x@ḟ@ḢṖ?µ¬¿

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

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

जमीनी कार्य को पूरा करने के लिए क्रेडिट्स @Xanderhall, @Sherlock, और @ ErikGolfer पर जाते हैं।

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

j@N»3\=x@ḟ@ḢṖ?µ¬¿ Main link: Argument: A (integer or list of integers)

               ¬¿ While the logical NOT of A (0 for a positive integer, a non-empty
                  array for a non-empty array) is truthy:
              µ     Execute the chain of links to the left.
  N                   Negative; multiply all integers in A by -1.
j@                    Join -A, separating by A. This prepends and appends a
                      negative to A and appends more integers that will be ignored.
   »3\                Compute the maxima of all overlapping slices of length 3.
      =               Compare the maxima with the elements of A, yielding 1 or 0.
       x@             Repeat the elements of A, 1 or 0 times.
                      This ignores Booleans without a counterpart in A.
            Ṗ?        If the popped result is truthy, i.e., if it has at least two
                      elements:
         ḟ@             Filter/remove those elements from A.
                      Else:
           Ḣ            Head; extract the (only) element of the return value.

— डेनिस
स्रोत

10

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

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

f=a=>a.map((c,i)=>(p>c|c<a[i+1]?q:r).push(p=c),p=q=[],r=[])&&r[1]?f(q):r

पूर्णांक के एक सरणी में ले जाता है और एक सरणी को आउटपुट करता है जिसमें केवल विजेता होता है।

टेस्ट स्निपेट

कोड स्निपेट दिखाएं

f=a=>a.map((c,i)=>(p>c|c<a[i+1]?q:r).push(p=c),p=q=[],r=[])&&r[1]?f(q):r

g=a=>a?console.log("Input:",`[${a}]`,"Output:",f(a.map(Number))+""):console.error("Invalid input")

g([5,3,9,8,7])
g([1,2,9,4])
g([9,3,8,7,4,12,5])

<input id=I value="9 1 8 2 7 3 6 4 5"><button onclick="g(I.value.match(/\d+/g))">Run</button>

Expand snippet

यहाँ कुछ अन्य प्रयास, उपयोग .filterऔर सरणी समाहार हैं:

f=a=>(q=a.filter((c,i)=>p>(p=c)|c<a[i+1]||0*r.push(c),p=r=[]))&&r[1]?f(q):r
f=a=>(r=a.filter((c,i)=>p<(p=c)&c>~~a[i+1]||0*r.push(c),p=q=[]))[1]?f(q):r
f=a=>[for(c of(i=p=q=[],r=[],a))(p>c|c<a[++i]?q:r).push(p=c)]&&r[1]?f(q):r
f=a=>(q=[for(c of(i=p=r=[],a))if(p>(p=c)|c<a[++i]||0*r.push(c))c])&&r[1]?f(q):r

या एक डबल लूप के लिए, बहुत लंबा:

a=>eval("for(r=[,1];r[1]&&(p=i=q=[],r=[]);a=q)for(c of a)(p>c|c<a[++i]?q:r).push(p=c));r")

व्याख्या

जिस तरह से यह काम बहुत सरल है: यह उन लोगों की एक सरणी बनाता है जो अपेक्षाकृत अधिक लम्बे होते हैं ( r) और उन लोगों की एक सरणी जो (नहीं हैं q), फिर लौटता है rयदि इसमें केवल एक आइटम है; यदि नहीं, तो यह उसी पर चलता है qऔर उसी का परिणाम देता है।

— ETHproductions
स्रोत

स्नैक स्निपेट कहाँ है?

— क्रिकटी लिथोस 20

@KritiiLithos गयी :-)

— ETHproductions

"[1,2,5,8,9,12,3,4,10] आउटपुट: 5" मुझे लगता है कि यह आउटपुट 8 होना चाहिए, 5 नहीं। पहले, 12 और 10 समाप्त हो गए, फिर 9 और 4, फिर 8 जीत ।

— १०:१५

1

@ मेरी बुरी, स्निपेट फ़ंक्शन में भेजने से पहले अपने तर्कों को संख्याओं में परिवर्तित नहीं कर रहा था। यह तय किया गया है।

— ETHproductions

आप स्विच करके अपने फ़िल्टर उदाहरण पर 4 बाइट्स बचा सकते हैं qऔर r। आप इससे बचें &&rऔर फ़िल्टर एक्सप्रेशन बाइट से भी छोटा हो जाता है।

— नील

8

MATL , 20 बाइट्स

`tTYadZSd0<~&)nq}x2M

इनपुट एक स्तंभ वेक्टर है, जो ;विभाजक के रूप में उपयोग करता है।

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

व्याख्या

यह चुनौती में वर्णित प्रक्रिया का प्रत्यक्ष कार्यान्वयन है। ए do... whileलूप तत्वों को हटाता रहता है जब तक कि केवल एक को हटा दिया गया हो; और वह एक आउटपुट है।

हटाए जाने वाले तत्वों का पता मतभेदों, साइनम, फिर मतभेदों को ले कर लगाया जाता है। जो एक नकारात्मक मूल्य देते हैं वे हटाए जाने वाले हैं।

`        % Do...while
  t      %   Duplicate. Takes input (implicit) the first time
  TYa    %   Append and prepend a zero
  d      %   Consecutive differences
  ZS     %   Signum
  d      %   Consecutive differences
  0<~    %   Logical mask of non-negative values: these should be kept
  &)     %   Split array into two: those that should kept, then those removed
  nq     %   Size minus 1. This is used as loop condition. The loop will exit
         %   if this is 0, that is, if only one element was removed
}        % Finally (i.e. execute at the end of the loop)
  x      %   Delete array of remaining elements
  2M     %   Push last element that was removed
         % End (implicit)
         % Display (implicit)

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

4

पायथन 3, 265 260 248 243 203 121 117 112 111 बाइट्स

def T(I):
 b=[0];q=[];J=b+I+b
 for i,x in enumerate(I):[q,b][J[i]<x>J[i+2]]+=x,
 return len(b)<3and b[1]or T(q)

5 45 बहुत बाइट्स बचाने के लिए @ZacharyT, @orion और @mathmandan को धन्यवाद !

— Yodle
स्रोत

2

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

import Data.List
f x=(#)=<<(x\\)$[b|a:b:c:_<-tails$0:x++[0],b<a||b<c]
[s]#_=s
_#i=f i

प्रयोग उदाहरण: f [9,3,8,7,4,12,5]-> 4।

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

f x =                            -- main function with parameter x
         [b|                  ]  -- make a list of all b
            a:b:c:_              -- where b is the second element of all lists with
                                 -- at least 3 elements
             <- tails $ 0:x++[0] -- drawn from the tails of x with a 0 pre- and
                                 -- appended (tails [1,2,3] -> [1,2,3],[2,3],[3],[])
               ,b<a||b<c         -- and b is not greater than its neighbors
   (#)=<<(x\\)                   -- feed the list difference of x and that list
                                 -- and the list itself to the function #

[s]#_s                           -- if the list difference is a singleton list,
                                 -- return the element
_#i=f i                          -- else start over with the list of b's

एक प्रकार, 85 बाइट्स:

import Data.List
f x|n<-[b|a:b:c:_<-tails$0:x++[0],b<a||b<c]=last$f n:[s|[s]<-[x\\n]]

की सूची को बाँधें b(ऊपर देखें) n और तत्व को वापस करें sयदि x\\nएक सिंगलटन सूची है और f nअन्यथा।

— nimi
स्रोत

आप आयात से छुटकारा पा सकते हैं और 3 बाइट्स बचा सकते हैं f x|y@(_:z)<-x++[0]=(#)=<<(x\\)$[b|(a,b,c)<-zip3(0:y)y z,b<a||b<c]।

— जर्गर्ब

@Zgarb: \\ अभी भी आयात की आवश्यकता है। Btw, tailsभी द्वारा प्रतिस्थापित किया जा सकता है ...|a:b:c:_<-scanr(:)[]$0:x++[0],...।

— १६:५६

ओह ठीक है, मुझे इसका एहसास नहीं था।

— जगरब

2

गणितज्ञ, १०hem १०atic बाइट्स

(For[x=y=#,Length@y>1,x=DeleteCases[x,#|##&@@y],y=Intersection[Max@@@x~Split~Less,#&@@@Split[x,#>#2&]]];y)&

व्याख्या

पहला, सेट xऔर yइनपुट के बराबर List। तब तक लूप जारी रहता है Length@y==1। x~Split~Lessनिरंतर, बढ़ते हुए तत्वों Split[x,#>#2&]की सूचियों की सूची है, निरंतर, घटते हुए तत्वों की सूचियों की सूची है। Maxपूर्व की सभी सूचियों को लेना, बच्चों की सूची को उनके अधिकार से बच्चे की तुलना में लम्बे (सही-सबसे बच्चे के साथ) देता है। #&उत्तरार्द्ध की सभी सूचियों का पहला तर्क ( ) लेने से बच्चों की सूची बच्चों की तुलना में उनके बाएं (सबसे बाएं बच्चे के साथ) लंबी हो जाती है। इन दोनों के प्रतिच्छेदन में उन बच्चों की सूची होगी जिन्होंने अपना हाथ उठाया था। इसके बराबर सेट करें y। किसी तत्व से मेल खाने वाले तत्वों x=DeleteCases[x,#|##&@@y]को हटाता xहै )। एक बार जब लूप समाप्त हो जाता है, तो वापस लौटेंy ( #|##&के बराबर है)Alternativesy। यदि आउटपुट पूर्णांक (एक पूर्णांक युक्त सूची के बजाय) होना चाहिए, तो वापस लौटें#&@@y (+4 बाइट्स)।

2 बाइट बचाने और मुझे नियमों का अनुपालन करने के लिए मार्टिन एंडर का धन्यवाद। सुझाव के लिए खोलें।

— ngenisis
स्रोत

मुझे नहीं लगता !Lessकि आप अपेक्षा के अनुरूप काम करते हैं, क्योंकि यह वास्तव में किसी फ़ंक्शन का मूल्यांकन नहीं करता है। आपको संभवतः वहां Greater(या #>#2&) उपयोग करने की आवश्यकता होगी । आप x~Split~Lessपहली बार Splitहालांकि और शर्त के >लिए उपयोग कर सकते Lengthहैं।

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

1

Clear@yफ़ंक्शन कॉल के बीच मूल्यांकन करने के लिए , मुझे डर है कि यह मान्य नहीं है । आप या तो इसे अपने आप को पुनर्स्थापित करने के लिए, गुंजाइश बेहतर होगा, या के साथ एक पूर्ण कार्यक्रम में इस बारी Inputऔर Print।

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

1

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

{(@_,{(($/=(0,|@$_,0).rotor(3=>-2).classify({+so .[1]>.[0,2].all})){1}>1??$/{0}!!$/{1})».[1]}...*==1)[*-1][0]}

विस्तारित:

{  # bare block lambda with implicit parameter list ｢@_｣

  (                                    # generate a sequence
    @_,                                # starting with the input

    {   # code block used to get the next value in the sequence
        # which has implicit parameter ｢$_｣

        (
          (


            $/ =   # store in ｢$/｣ for later use

            ( 0, |@$_, 0 )             # the input with 0s before and after
            .rotor( 3 => -2 )          # take 3 at a time, back up 2, repeat
            .classify({
              +                        # Numify the following:
              so                       # simplify the following Junction
              .[1] > .[ 0, 2 ].all     # is the middle larger than its neighbors
            })



          ){1}                         # look at the values where it is true
          > 1                          # is there more than 1?

        ??                             # if so
          $/{ 0 }                      # look at the false ones instead

        !!                             # otherwise
          $/{ 1 }                      # look at the true ones

      )».[1]                           # undo the transformation from ｢.rotor｣
    }

    ...                                # keep doing that until

    * == 1                             # there is only one value
  )\
  [ * - 1 ]                            # the last value of the sequence
  [ 0 ]                                # make it a singular value ( not a list )

}

— ब्रैड गिल्बर्ट b2gills
स्रोत

1

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

def f(A):
 t=[0];l=[];a=b=0
 for c in A+[0]:[l,t][a<b>c]+=[b];a,b=b,c
 return t[-2]and f(l)or t[1]

योडल के जवाब के रूप में शॉर्ट-सर्कुलेटिंग रिटर्न का उपयोग करता है (ज़ाचरी टी द्वारा)

— TFeld
स्रोत

का उपयोग करते हुए: आप द्वारा बंद बाइट्स 3 अधिक ले जा सकते हैं +=b,के बजाय +=[b](mathmandan को ऋण) का उपयोग कर t=[0]का उपयोग करने tमें जोड़ने के लिए A, और तब से अब हम 0 से आरंभ में t, जाँच t[-2]<1से भी कम है len(t)<2उपयोग करते हैं, और t[1]उस मामले में परिणाम के रूप में।

— ओरियन

आखिरी लाइन बन रही है return t[-2]and f(l)or t[1]।

— Orion

0

गणितज्ञ, 101 बाइट्स

If[Equal@@(a=Position[Max/@Partition[#,3,1,{2,2},0]-#,0]),#[[Last@a]],#0@Fold[Drop@##&,#,Reverse@a]]&

इनपुट के रूप में संख्याओं की एक सूची लेने और एक एकल संख्या (विजेता) के रूप में आउटपुट के साथ एक सूची को वापस करने के लिए अपर्सिव फ़ंक्शन।

एल्गोरिथ्म का मूल है Max/@Partition[#,3,1,{2,2},0], जो इनपुट सूची से इन-मैक्स-ऑफ-ऑफ-मी-एंड-माय-पड़ोसियों की सरणी की गणना करता है। a=Position[...-#,0]फिर मूल सूची को घटाता है और जहां 0s है वहां लौटता है; ये बच्चे पैदा करने वाले हैं।

If[Equal@@a, #[[Last@a]], #0@Fold[Drop@##&,#,Reverse@a]]&शाखाओं के आधार पर कि क्या सभी तत्व aसमान हैं या नहीं (इस मामले में, वे केवल तभी होंगे यदि aएक सिंगलटन है); यदि ऐसा है, तो यह बच्चा विजेता है और हम उसका नंबर आउटपुट करते हैं; यदि नहीं, तो हम इस फ़ंक्शन को aहटाए गए पदों पर सभी तत्वों के साथ सूची पर कॉल करते हैं ।

— ग्रेग मार्टिन
स्रोत

0

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

def f(l):k=[x[0]for x in zip(l,[0]+l,l[1:]+[0])if(max(x),)>x];return(len(k)+2>len(l))*max(l)or f(k)

— Lulhum
स्रोत

0

PHP, 131 बाइट्स

$r=$a=$argv;for(;$r[1];$a=array_values(array_diff($a,$r))){$r=[];foreach($a as$i=>$x)if($x>$a[$i-1]&$x>$a[$i+1])$r[]=$x;}echo$r[0];

कमांड लाइन तर्कों से संख्या लेता है। यदि नाम एक सकारात्मक संख्या के साथ शुरू होता है तो विफल रहता है।

टूट - फूट

// import (and init $r[1])
$r=$a=$argv;
// while more than 1 raised hand, remove them from data
for(;$r[1];$a=array_values(array_diff($a,$r)))
{
    // reset hands
    $r=[];
    // raise hands
    foreach($a as$i=>$x)
        if($x>$a[$i-1]&$x>$a[$i+1])$r[]=$x;
}
// output
echo$r[0];

— टाइटस
स्रोत

0

k, 40 बाइट्स

{$[1=+/B:(|>':|x)&>':x;x@&B;.z.s x@&~B]}

व्याख्या:
$ एक और है।

शर्त यह है कि क्या 1 बी का योग है, जिसे x और पूर्व की स्थिति से अधिक होने के बाद चेक करके उत्पन्न दो सूचियों में से न्यूनतम के रूप में परिभाषित किया गया है (पाइप रिवर्स है)।

यदि यह सत्य है तो हम x को वापस लेते हैं जहां B सत्य है।
अन्यथा हम सच्चे पदों के बिना पुनरावृत्ति करते हैं।

— पॉल केरिगन
स्रोत

0

स्काला 129 बाइट्स

golfed

def x(a:List[Int]):Int={val (y,n)=(0+:a:+0).sliding(3).toList.partition(l=>l.max==l(1));if(y.length>1)x(n.map(_(1)))else y(0)(1)}

Ungolfed

def whoIsTallest(a: List[Int]): Int = {
  val (handUp, handDown) = (0 +: a :+ 0).sliding(3).toList.partition {
    case x :: y :: z :: Nil => y > x && y > z
  }
  if (handUp.length > 1)
    whoIsTallest(handDown.map(_(1)))
  else
    handUp.head(1)
}

0 की सूची के साथ बाएँ और दाएँ सूची को पैडिंग करके, फिर 3 के समूह में समूह बना सकते हैं और उन लोगों के लिए सूची का विभाजन कर सकते हैं जहाँ हाथ ऊपर है, बाएँ और दाएँ अधिकांश तत्व बाहर की ओर 0 की तुलना करते हैं, इसलिए सही संख्या प्राप्त करें (nobodys ऊंचाई मानकर नकारात्मक है!)

— sprague44
स्रोत

0

सी ++ 14, 182 बाइट्स

#define P .push_back(c[i]);
int f(auto c){decltype(c)t,s;int i=0;(c[0]>c[1]?t:s)P for(;++i<c.size()-1;)(c[i-1]<c[i]&&c[i]>c[i+1]?t:s)P(c[i-1]<c[i]?t:s)P return t.size()<2?t[0]:f(s);}

सीखा है कि टर्नरी ऑपरेटर का उपयोग C ++ ऑब्जेक्ट्स के साथ किया जा सकता है। इनपुट को एक यादृच्छिक अभिगमन कंटेनर होना चाहिए push_back, जैसे vector, dequeऔर list।

एक ही प्रकार के दो कंटेनर बनाता है tऔर sस्थानीय को सबसे लंबा tऔर बाकी को जोड़ता हैs । यदि tबदले में केवल 1 तत्व है , तो एक साथ, अन्यथा पुनरावर्ती स्वयं को बुलाता है s।

Ungolfed:

int f(auto c){
  decltype(c)t,s;
  int i=0;
  (c[0]>c[1] ? t : s).push_back(c[i]);
  for(;++i<c.size()-1;)
    (c[i-1]<c[i]&&c[i]>c[i+1] ? t : s).push_back(c[i]);
  (c[i-1]<c[i] ? t : s).push_back(c[i]);
  return t.size()<2 ? t[0] : f(s);
}

— कार्ल नेफ
स्रोत

0

आर, 83 बाइट्स

दो अलग-अलग संस्करण:

यह एक वेक्टर N लेता है:

while(T){Z=diff(sign(diff(c(0,N,0))))<0;if(sum(Z)>1)N=N[!Z]else{print(N[Z]);break}}

यह एक फ़ंक्शन F को पुनरावर्ती रूप से परिभाषित करता है:

F=function(N){Z=diff(sign(diff(c(0,N,0))))<0;if(sum(Z)>1)F(N[!Z])else return(N[Z])}

— Skan
स्रोत

0

एपीएल (Dyalog यूनिकोड) , 28 बाइट्स ^SBCS

{1=≢⍸s←⍵=3⌈/∊0⍵0:s/⍵⋄∇⍵/⍨~s}

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

— voidhawk
स्रोत

सबसे लंबा कौन है?

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

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

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

टेस्ट स्निपेट

व्याख्या

MATL , 20 बाइट्स

व्याख्या

पायथन 3, 265 260 248 243 203 121 117 112 111 बाइट्स

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

गणितज्ञ, १०hem १०atic बाइट्स

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

विस्तारित:

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

गणितज्ञ, 101 बाइट्स

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

PHP, 131 बाइट्स

k, 40 बाइट्स

स्काला 129 बाइट्स

golfed

Ungolfed

सी ++ 14, 182 बाइट्स

एपीएल (Dyalog यूनिकोड) , 28 बाइट्स SBCS

एपीएल (Dyalog यूनिकोड) , 28 बाइट्स ^SBCS