সবচাইতে লম্বা কে?

Question

এন বাচ্চারা, দু'জনই তাদের সঠিক আকার ভাগ করে না নিয়ে কিছু ক্রমে সারিবদ্ধ হয়ে দাঁড়িয়েছে। প্রত্যেকে কেবল তাদের নিকটবর্তী প্রতিবেশীদের সাথে উচ্চতার তুলনা করতে পারে। যখন শিক্ষক উচ্চারণ করেন "আপনি যদি সবচেয়ে উঁচু হন তবে হাত তুলুন", তারা যদি তাদের প্রতিবেশী উভয়ের চেয়ে লম্বা হয় তবে তারা তা করে এবং তারা একই সাথে এটি করে। যদি কেউ তাদের হাত বাড়ায় তবে সে জিতবে। যদি একের অধিক হাত বাড়ানো থাকে তবে তারা সবাই সারি থেকে সরিয়ে ফেলা হয় (বাকী বাচ্চাদের ক্রম সংরক্ষণ করে) এবং তারা প্রক্রিয়াটি পুনরাবৃত্তি করে।

একটি প্রোগ্রাম লিখুন, যা স্বতন্ত্র পূর্ণসংখ্যার অ্যারে নেয় (আপনি ধরে নিতে পারেন যে তারা কঠোরভাবে ইতিবাচক) এবং এই গেমের বিজয়ীকে আউটপুট করে। এটি কোড-গল্ফ, তাই সংক্ষিপ্ততম কোডটি জয়ী।

উদাহরণ (অন্তর্বর্তী স্তর সহ প্রদর্শিত):

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

---

বর্তমান নেতারা:

1. জেলি: 17 বাইট [ডেনিস দ্বারা ♦]
2. এমএটিএল: 20 বাইট [লুইস মেন্ডো দ্বারা]
3. এপিএল: ২৮ বাইট [শূন্যপদ]
4. কে: 40 বাইট [পল কেরিগান দ্বারা]

পাইথনসের যুদ্ধও চলছে। এখনও আরও গল্ফের ভাষা দেখাতে অপেক্ষা করছে।

আমি বর্তমানে ডেনিসের উত্তর গ্রহণ করেছি - যদি নতুন বিজয়ী থাকে তবে আমি নির্বাচনটি আপডেট করব।

Comments

আরও বেশি শোনাচ্ছে "কে হতে পারে সবচেয়ে লম্বা, বা নাও হতে পারে?" - প্রকৃতপক্ষে "কে সবচেয়ে উঁচু" তা খুঁজে পেতে আপনাকে নিজের হাতকে নীচে ফেলে

— Alnitak

আমি বাচ্চাদের গেমগুলির সাথে মিল খুঁজে পেয়েছি, যেখানে এক ব্যক্তি কিছু স্বাক্ষর বাক্য উচ্চারণ করে যার নাম অনুসারে গেমটির নামকরণ করা হয়েছে। মজাদারভাবে যথেষ্ট, সবচেয়ে দীর্ঘতম জয়ের সম্ভাবনা কম (বিশাল ব্যবধানে)। তাত্পর্যপূর্ণভাবে, এন এর বাইরে! অনুমতি, কেবল 2 ^ (এন -1) ক্ষেত্রে তিনি জিতেন।

— প্রাচ্য

Answer 1

জেলি , 17 বাইট

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

ইনপুটটি পূর্ণসংখ্যার কমা-বিচ্ছিন্ন স্ট্রিং।

এটি অনলাইন চেষ্টা করুন!

ভিত্তি তৈরির জন্য ক্রেডিটগুলি @ এক্সানডারহল, @ শার্লক এবং @ এরিকগল্ফারে যায়।

কিভাবে এটা কাজ করে

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.

Answer 2

জাভাস্ক্রিপ্ট (ES6), 78 76 72 বাইট

-২ বাইটের জন্য @ এডসি 65 কে ধন্যবাদ

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>

এখানে কয়েকটি আরও প্রচেষ্টা, ব্যবহার .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এবং এর ফলাফলটি দেয়।

Comments

নাস্তা স্নিপেট কোথায়?

— ক্রিটসি লিথোস

@ ক্রিটিক্সিলিথোস যুক্ত হয়েছে :-)

— ইটিএইচ প্রডাকশন

"[[1,2,5,8,9,12,3,4,10] আউটপুট: 5" আমি মনে করি এটির ফলাফল 8 হতে হবে না 5 not ।

— প্রাচ্য

আমার বাজে কথা, স্নিপেট ফাংশনে প্রেরণের আগে তার যুক্তিগুলিকে সংখ্যায় রূপান্তর করছিল না। এটি স্থির করা হয়েছে।

— ইটিএইচ প্রডাকশন

আপনি আপনার ফিল্টার উদাহরণে স্যুইচ qএবং এর মাধ্যমে 4 বাইট সংরক্ষণ করতে পারেন r। আপনি এড়ানো &&rএবং ফিল্টার এক্সপ্রেশন খুব বাইট সংক্ষিপ্ত হিসাবে পরিণত হয়।

— নিল

Answer 3

এমএটিএল , 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)

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

সংরক্ষণ করার জন্য আপনাকে @ZacharyT, @orion ধন্যবাদ, এবং @mathmandan 5 45 বাইট অনেক!

Answer 5

হাস্কেল, 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(উপরে দেখুন) তালিকাটি বেঁধে রাখুন এবং sযদি x\\nসিঙ্গলটন তালিকা এবং f nঅন্যথায় উপাদানটি ফিরে পান ।

Comments

আপনি আমদানি থেকে মুক্তি পেতে পারেন এবং এর সাথে 3 বাইট সংরক্ষণ করতে পারেন f x|y@(_:z)<-x++[0]=(#)=<<(x\\)$[b|(a,b,c)<-zip3(0:y)y z,b<a||b<c]।

— Zgarb

@ জগারব: \\ এখনও আমদানি দরকার। বিটিডব্লিউ, tailsদ্বারা প্রতিস্থাপন করা যেতে পারে ...|a:b:c:_<-scanr(:)[]$0:x++[0],...।

— নিমি

ওহ ঠিক আছে, আমি বুঝতে পারিনি।

— জাগারব

Answer 6

গণিত, 107 108 বাইট

(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]থেকে সরানxy#|##&Alternatives)। লুপটি শেষ হয়ে গেলে ফিরে আসুন y। যদি আউটপুট অবশ্যই একটি পূর্ণসংখ্যা হতে পারে (একক পূর্ণসংখ্যাযুক্ত তালিকার চেয়ে), ফিরে #&@@y(+4 বাইট)।

আমাকে 2 টি বাইট সংরক্ষণ এবং নিয়ম মেনে চলার জন্য মার্টিন ইন্ডারকে ধন্যবাদ। পরামর্শ খুলুন।

Comments

আমি মনে করি না যে !Lessআপনি প্রত্যাশা মতো কাজ করে, যেহেতু এটি আসলে কোনও ফাংশনকে মূল্যায়ন করে না। আপনাকে সম্ভবত সেখানে Greater(বা #>#2&) ব্যবহার করতে হবে। আপনি x~Split~Lessপ্রথমটি Splitযদিও এবং শর্তের >জন্য ব্যবহার করতে পারেন Length।

— মার্টিন এণ্ডার

Clear@yফাংশন কলগুলির মধ্যে মূল্যায়ন করার বিষয়ে, আমি ভয় করি যে এটি বৈধ নয় । হয় আপনাকে এটিকে নিজেই পুনরায় সেট করতে হবে, এটিকে আরও ভালভাবে স্কোপ করতে হবে, Inputএবং এবং এর সাথে একটি সম্পূর্ণ প্রোগ্রামে রূপান্তর করতে হবে Print।

— মার্টিন এণ্ডার

Answer 7

পার্ল 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 )

}

Answer 8

পাইথন 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]

ইয়োডলের উত্তরের মতো শর্ট সার্কিট রিটার্ন ব্যবহার করে (জ্যাচারি টি দ্বারা)

Comments

ব্যবহার: আপনি বন্ধ বাইট 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]।

— প্রাচ্য

Answer 9

গণিত, 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]তারপরে মূল তালিকাটি বিয়োগ করে এবং যেখানে 0 রয়েছে সেখানে ফিরে আসে; এরা হস্তান্তরকারী বাচ্চা।

If[Equal@@a, #[[Last@a]], #0@Fold[Drop@##&,#,Reverse@a]]&সমস্ত উপাদান aসমান কিনা তা নির্ভর করে শাখাগুলি ( এক্ষেত্রে , তারা কেবলমাত্র aসিঙ্গলটন হলেই হবে ); যদি তা হয় তবে এই শিশুটি বিজয়ী এবং আমরা তার সংখ্যা আউটপুট করব; যদি তা না হয়, তবে আমরা aসরানো অবস্থানগুলিতে সমস্ত উপাদানগুলির সাথে তালিকায় এই ক্রিয়াকলাপটিকে পুনরাবৃত্তভাবে কল করি ।

Answer 10

পাইথন 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)

Answer 11

পিএইচপি, 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];

Answer 12

k, 40 বাইট

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

ব্যাখ্যা:
$ একটি যদি-অন্যথায় হয়।

শর্তটি হ'ল 1 হ'ল বি এর যোগফল, যা পূর্বের ও পোস্ট পজিশনের (পাইপ বিপরীত) এর চেয়ে বড় কিনা তা পরীক্ষা করে নির্ধারিত সর্বনিম্ন দুটি তালিকার সংখ্যার হিসাবে সংজ্ঞায়িত হয়।

এটি সত্য হলে আমরা এক্স ফিরিয়ে দেব যেখানে বি সত্য।
অন্যথায় আমরা আসল অবস্থান ছাড়াই পুনরাবৃত্তি করি।

Answer 13

স্কলা 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 টির সাথে তুলনা করে সঠিক নম্বরটি পাবেন (নোবডিসের উচ্চতা ধরে ধরে) নেতিবাচক!)

Answer 14

সি ++ 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);}

শিখেছি যে টের্নারি অপারেটরটি সি ++ অবজেক্টের সাথে ব্যবহার করা যেতে পারে। ইনপুটটির সাথে একটি এলোমেলো অ্যাক্সেস ধারক হতে হবেpush_back মতো vector, dequeএবং list।

দুটি পাত্রে তৈরি করে tএবংs একই ধরণের এবং স্থানীয় লম্বা appends tএবং বিশ্রাম s। এর পরিবর্তে যদি কেবল 1 টি উপাদান থাকে tতবে অন্যথায় পুনরাবৃত্তির সাথে কল করুন 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);
}

Answer 15

আর, 83 বাইট

দুটি ভিন্ন সংস্করণ:

এটি একটি ভেক্টর এন লাগে:

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

এটি পুনরাবৃত্তভাবে সংজ্ঞায়িত একটি ফাংশন তৈরি করে:

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

Answer 16

এপিএল (ডায়ালগ ইউনিকোড) , 28 বাইট ^{এসবিসিএস}

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

এটি অনলাইন চেষ্টা করুন!