İki çocuğu, ikisi tam olarak aynı boyuta sahip değil, bir sıraya göre dizilmiş. Her biri yükseklikleri sadece yakın komşularıyla karşılaştırabilir. Öğretmen "en uzun boyluysanız el kaldırsın" diye bağırdığında, iki komşularından daha uzunlarsa bunu yaparlar ve aynı anda yaparlar. Sadece biri elini kaldırırsa, o kazanır. Birden fazla el kaldırırsa, hepsi sıradan çıkarılır (diğer çocukların sırasını koruyarak) ve işlemi tekrarlar.

Bir dizi farklı tam sayı alan (kesinlikle olumlu olduklarını varsayabilirsiniz) kabul eden ve bu oyunun kazananı olan bir program yazın. Bu kod golf, yani en kısa kod kazanır.

Örnekler (gösterilen ara aşamalar ile):

5 3 9 8 7 → 3 8 7 → 8

1 2 9 4 → 9

9 3 8 7 4 12 5 → 3 7 4 5 → 3 4 → 4

Güncel liderler:

1. Jöle: 17 bayt [Dennis ♦]
2. MATL: 20 bayt [Luis Mendo tarafından]
3. APL: 28 bayt [voidhawk]
4. k: 40 bayt [Paul Kerrigan]

Ayrıca devam eden bir Pythons savaşı var. Hala daha fazla golf dilinin görünmesini bekliyorum.

Şu anda Dennis ♦ 'in cevabını kabul ettim - eğer yeni kazananlar varsa, seçimi güncelleyeceğim.

Jöle , 17 bayt

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

Giriş, virgülle ayrılmış bir tamsayı dizesidir.

Çevrimiçi deneyin!

Krediler, zemin düzenlemesi için @Xanderhall, @Sherlock ve @ErikGolfer'e gider.

Nasıl çalışır

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.

JavaScript (ES6), 78 76 72 bayt

-4 baytlık @ edc65 için teşekkürler

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

Bir tamsayı dizisini alır ve yalnızca kazananı içeren bir dizi çıkarır.

Test snippet'i

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>

İşte .filtercomprhensions ve dizi dizileri kullanan diğer birkaç deneme :

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

Ya da çok uzun bir döngü için:

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")

açıklama

Bunun çalışma şekli oldukça basittir: göreceli olarak uzun olanlardan oluşan rbir dizi ( q) ile olmayanlardan ( ) oluşan bir dizi oluşturur , sonra ryalnızca bir öğeye sahipse geri döner ; eğer değilse, kendisi çalışır qve bunun sonucunu döndürür.

MATL , 20 bayt

`tTYadZSd0<~&)nq}x2M

Giriş, ;ayırıcı olarak kullanan bir sütun vektörüdür .

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

Bu, zorlukta açıklanan prosedürün doğrudan bir uygulamasıdır. Bir do... whiledöngü, yalnızca biri kaldırılıncaya kadar öğeleri kaldırmaya devam eder; ve bu da çıktı.

Kaldırılacak elemanlar farklar, işaretler ve ardından tekrar farklar alınarak tespit edilir. Negatif değer verenler kaldırılacak olanlardır.

`        % 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)

Python3, 265 260 248 243 203 121 117 112 111 bayt

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 lot baytı kurtardığınız için @ ZacharyT, @orion ve @mathmandan teşekkür ederiz !

Haskell, 85 bayt

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

Kullanım örneği: f [9,3,8,7,4,12,5]-> 4.

Nasıl çalışır:

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

Bir değişken, ayrıca 85 bayt:

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]]

bN ('ye bakınız) listesini n'ye bağlayın ve seğer x\\nbir singleton listesi ise elemanı geri döndürün f n.

Mathematica, 107 108 bayt

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

açıklama

İlk olarak, girişe eşit xve ayarlayın . Döngü kadar devam eder . ardışık, artan elemanların listelerinin listesi, ardışık, azalan elemanların listelerinin listesidir. Eski listedeki tüm listelerin alınması, çocuklara göre daha uzun boylu olan çocukların listesini (en sağdaki çocukla birlikte) verir. İkinci listedeki tüm listelerin ilk argümanını ( ) almak, çocuklardan daha solundaki çocuklardan daha uzun olanları (en soldaki çocukla birlikte) listeler. Bu ikisinin kesişimi, ellerini kaldıran çocukların listesi olacaktır. Bunu eşit olarak ayarlayın . bir öğeyle eşleşen herhangi bir öğeden kaldırır ( eşdeğerdir)yListLength@y==1x~Split~LessSplit[x,#>#2&]Max#&yx=DeleteCases[x,#|##&@@y]xy#|##&Alternatives). Döngü sona erdiğinde, geri dönün y. Çıktının bir tamsayı olması gerekiyorsa (tek bir tamsayı içeren bir liste yerine), döndürün #&@@y(+4 bayt).

Martin Ender'e 2 bayt kaydetme ve beni kurallara uyma konusunda teşekkür ederiz. Önerilere açık.

Perl 6 , 111 bayt

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

Expanded:

{  # 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 )

}

Python 2, 100 98 bayt

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]

Yodle'nin cevabında olduğu gibi kısa devre geri dönüşünü kullanır (Zachary T)

Mathematica, 101 bayt

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

İsimsiz özyinelemeli işlev, giriş olarak sayıların bir listesini alarak ve çıktı olarak tek bir sayıya sahip (listeyi kazanan) bir listeyi döndürür.

Algoritmanın çekirdeği Max/@Partition[#,3,1,{2,2},0], girdi listesinden (en-ben-ben-ve-komşularımın) dizisini hesaplar. a=Position[...-#,0]daha sonra orijinal listeyi çıkarır ve 0'ların olduğu yere döner; bunlar el yetiştiren çocuklar.

If[Equal@@a, #[[Last@a]], #0@Fold[Drop@##&,#,Reverse@a]]&tüm öğelerin aeşit olup olmadığına bağlı olarak dallar (bu durumda, yalnızca abir tekil ise olacaktır ); öyleyse, o zaman bu çocuk kazanan ve biz onun numarasını çıktı; eğer değilse, o zaman tekrar tekrar sırayla bu fonksiyonu listedeki tüm elemanlar akaldırılmış konumdayken çağırırız .

Python 2, 99 Bayt

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)

PHP, 131 bayt

$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];

Komut satırı argümanlarından sayıları alır. Dosya adı pozitif bir sayıyla başlarsa başarısız olur.

Yıkmak

// 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];

k, 40 bayt

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

Açıklama:
$ bir if-else.

Buradaki koşul, 1'in, x'in önceki ve sonraki konumlardan daha büyük olup olmadığını kontrol ederek oluşturulan iki listenin minimum olarak tanımlanan B toplamı olup olmadığıdır (Boru ters).

Eğer bu doğruysa, B'nin doğru olduğu yere x döneriz.
Aksi takdirde, gerçek pozisyonlar olmadan tekrarlanırız.

Scala 129 bayt

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)
}

Listeyi 0'larla sola ve sağa kaydırarak 3'lü gruplar halinde gruplandırabilir ve elin yukarı kaldırıldığı yerler için listeyi bölümlendirebilir, sol ve sağ çoğu eleman dıştaki 0'a göre karşılaştırılabilir, böylece doğru sayıyı alın (nobodys yüksekliği negatif!)

C ++ 14, 182 bayt

#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);}

Üçlü işlecin C ++ nesneleriyle kullanılabileceği öğrenildi. Giriş gerektirir olan bir rastgele erişim kap olduğu push_backgibi vector, dequeve list.

İki konteyner oluşturur tve saynı türde ve yerel yüksek ekler tve dinlenme s. Buna karşılık yalnızca 1 eleman varsa t, aksi halde özyinelemeli kendisini arayın.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);
}

R, 83 bayt

İki farklı versiyon:

Bu bir N alır:

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

Bu, özyinelemeli olarak tanımlanmış bir F fonksiyonunu yaratır:

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

APL (Dyalog Unicode) , 28 bayt ^SBCS

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

Çevrimiçi deneyin!