เขียนฟังก์ชั่นหรือโปรแกรมที่ใช้ในรายการและสร้างรายการของสุดขั้ว

ในรายการ[x_0, x_1, x_2...]มากในท้องถิ่นเป็นx_iเช่นนั้นx_(i-1) < x_iและx_(i+1) < x_iหรือและx_(i-1) > x_i x_(i+1) > x_iขอให้สังเกตว่าองค์ประกอบแรกและสุดท้ายของรายการไม่สามารถสุดขั้วท้องถิ่น

ดังนั้นสำหรับบางตัวอย่าง

local_extremes([1, 2, 1]) = [2]
local_extremes([0, 1, 0, 1, 0]) = [1, 0, 1]
local_extremems([]) = []

นี่คือรหัสกอล์ฟเพื่อให้รหัสที่สั้นที่สุดชนะ!

Mathematica 66 58 51

ทางออกปัจจุบัน

ขอบคุณสั้น ๆ ที่มีส่วนร่วมโดย Calle

Cases[Partition[#,3,1],{a_,b_,c_}/;(a-b) (b-c)<0⧴b]&

Partition[#,3,1] พบอเนกประสงค์

(a-b) (b-c)<0เป็นความจริงและถ้าหากbอยู่ด้านล่างa, cหรือเหนือ,a cและดูที่ใช้สัญญาณของความแตกต่าง มากในท้องถิ่นจะกลับมาอย่างใดอย่างหนึ่งหรือ{-1,1}{1,-1}

ตัวอย่าง

Cases[Partition[#, 3, 1], {a_, b_, c_} /; (a - b) (b - c) < 0 :> b] &[{1, 2, 1}]
Cases[Partition[#, 3, 1], {a_, b_, c_} /; (a - b) (b - c) < 0 :> b] &[{0, 1, 0, 1, 0}]
Cases[Partition[#, 3, 1], {a_, b_, c_} /; (a - b) (b - c) < 0 :> b] &[{}]
Cases[Partition[#, 3, 1], {a_, b_, c_} /; (a - b) (b - c) < 0 :> b] &[{9, 10, 7, 6, 9, 0, 3, 3, 1, 10}]

{2}
{1, 0, 1}
{}
{10, 6, 9, 0, 1}

โซลูชันก่อนหน้า

สิ่งนี้จะดูตัวอย่างอเนกประสงค์ทั้งหมด (สร้างโดยPartition) และพิจารณาว่าองค์ประกอบกลางน้อยกว่าทั้งสองสุดขั้วหรือมากกว่าสุดขั้ว

Cases[Partition[#,3,1],{a_,b_,c_}/;(b<a∧b<c)∨(b>a∧b>c)⧴b]& ;

ทางออกแรก

สิ่งนี้พบสิ่งที่เป็นอเนกประสงค์และมองดูเครื่องหมายของความแตกต่าง มากในท้องถิ่นจะกลับมาอย่างใดอย่างหนึ่งหรือ{-1,1}{1,-1}

Cases[Partition[#,3,1],x_/;Sort@Sign@Differences@x=={-1,1}⧴x[[2]]]&

ตัวอย่าง

Cases[Partition[#,3,1],x_/;Sort@Sign@Differences@x=={-1,1}:>x[[2]]]&[{9, 10, 7, 6, 9, 0, 3, 3, 1, 10}]

{10, 6, 9, 0, 1}

วิเคราะห์ :

Partition[{9, 10, 7, 6, 9, 0, 3, 3, 1, 10}]

{{9, 10, 7}, {10, 7, 6}, {7, 6, 9}, {6, 9, 0}, {9, 0, 3}, {0, 3, 3}, { 3, 3, 1}, {3, 1, 10}}

% อ้างถึงผลลัพธ์จากบรรทัดก่อนหน้าที่เกี่ยวข้อง

Differences/@ %

{{1, -3}, {-3, -1}, {-1, 3}, {3, -9}, {-9, 3}, {3, 0}, {0, -2}, {-2, 9}}

Sort@Sign@Differences@x=={-1,1}ระบุอเนกประสงค์จาก {{9, 10, 7}, {10, 7, 6}, {7, 6, 9}, {6, 9, 0}, {9, 0, 3}, {0, 3, 3}, {3, 3, 1}, {3, 1, 10}} ดังกล่าวว่าการเข้าสู่ระบบ (-, 0, +) ของความแตกต่างประกอบไปด้วยและ-1 1ในกรณีปัจจุบันคือ:

{{9, 10, 7}, {7, 6, 9}, {6, 9, 0}, {9, 0, 3}, {3, 1, 10}}

สำหรับแต่ละกรณีเหล่านี้ x x[[2]]หมายถึงคำที่สอง สิ่งเหล่านี้จะเป็น maxima และ minima ท้องถิ่นทั้งหมด

{10, 6, 9, 0, 1}

J - 19 ตัวอักษร

ไม่สามารถช่วยได้;)

(}:#~0,0>2*/\2-/\])

คำอธิบายดังนี้:

• 2-/\] - ทับแต่ละองค์ประกอบในอาร์กิวเมนต์ (แต่ละแท็กแบบยาว 2 รายการ) ให้ผลต่างกัน
• 2*/\ - ตอนนี้ในแต่ละคู่ของรายการใหม่นำผลิตภัณฑ์
• 0> - ทดสอบว่าผลการค้นหาแต่ละรายการมีค่าน้อยกว่า 0 หรือไม่เกิดขึ้นเฉพาะในกรณีที่สัญลักษณ์หลายรายการมีสัญญาณสลับกันนั่นคือจะไม่เกิดขึ้นหากพวกเขามีสัญญาณเดียวกันหรือเป็นศูนย์
• 0, - ประกาศว่าองค์ประกอบแรกไม่ใช่องค์ประกอบที่รุนแรง
• }: - ตัดองค์ประกอบสุดท้ายออกไปเพราะนั่นอาจจะไม่รุนแรงเกินไป
• #~ - ใช้ค่าจริงทางด้านขวาเพื่อเลือกรายการจากรายการทางด้านซ้าย

การใช้งาน:

   (}:#~0,0>2*/\2-/\]) 1 2 1
2
   (}:#~0,0>2*/\2-/\]) 0 1 0 1 0
1 0 1
   (}:#~0,0>2*/\2-/\]) i.0   NB. i.0 is the empty list (empty result also)

   (}:#~0,0>2*/\2-/\]) 3 4 4 4 2 5
2

Javascript - 62 45 ตัวอักษร

f=a=>a.filter((x,i)=>i&&i<a.length-1&&(a[i-1]-x)*(a[i+1]-x)>0)

แก้ไข

f=a=>a.filter((x,i)=>(a[i-1]-x)*(a[i+1]-x)>0)

Ruby, 83 70 60 55 49 ตัวละคร

f=->a{a.each_cons(3){|x,y,z|p y if(x-y)*(z-y)>0}}

พิมพ์สุดขีดท้องถิ่นทั้งหมดไปยัง STDOUT

ใช้<=>โอเปอเรเตอร์ "ยานอวกาศ" ซึ่งฉันชอบมาก (มันจะคืนค่า 1 หากสิ่งแรกมากกว่าวินาทีที่ -1 ถ้าน้อยกว่าและ 0 ถ้าเท่ากันดังนั้นถ้าพวกเขาเพิ่มเป็น -2 หรือ 2 นั่นหมายความว่าตรงกลางสุดขั้ว)

ไม่อีกแล้วเนื่องจาก @daniero ชี้ให้เห็นว่าวิธี "ชัดเจน" นั้นสั้นกว่าจริง ๆ !

เปลี่ยนไปอีกครั้ง! ตอนนี้มันใช้อัลกอริธึมที่ยอดเยี่ยมที่พบในคำตอบของ MT0 (+1 ถึงเขา!)

นอกจากนี้ฉันชอบeach_consที่จะเลือกnองค์ประกอบต่อเนื่องแต่ละกลุ่มในอาร์เรย์ และการติดตามifก็น่าสนใจเช่นกัน

โดยรวมแล้วฉันชอบความหรูหรา

ตัวอย่างบางส่วนทำงาน:

irb(main):044:0> f[[1,2,1]]
2
=> nil
irb(main):045:0> f[[1,0,1,0,1]]
0
1
0
=> nil
irb(main):046:0> f[[]]
=> nil
irb(main):047:0> f[[1,2,3,4,5,4,3,2,1]]
5
=> nil
irb(main):048:0> f[[1,1,1,1,1]]
=> nil
irb(main):049:0> f[[10,0,999,-45,3,4]]
0
999
-45
=> nil

C ++ - 208 ตัวอักษร

ทางออกที่ยาวที่สุดอีกครั้ง:

#include<iostream>
#include<deque>
using namespace std;
int main(){deque<int>v;int i;while(cin){cin>>i;v.push_back(i);}for(i=0;i<v.size()-2;)if(v[++i]>v[i-1]&v[i]>v[i+1]|v[i]<v[i-1]&v[i]<v[i+1])cout<<v[i]<<' ';}

หากต้องการใช้งานให้ป้อนจำนวนเต็มของคุณจากนั้นอักขระใด ๆ ที่จะขัดข้องกระแสข้อมูลเข้า - อักขระที่ไม่ใช่ตัวเลขใด ๆ ควรใช้งานได้

การป้อนข้อมูล: 0 1 0 x

เอาท์พุท: 1

Matlab - 45 ไบต์

x=input('');y=diff(x);x(find([0 y].*[y 0]<0))

Python 2.7 - 73 ไบต์

e=lambda l:[l[i]for i in range(1,len(l)-1)if(l[i]-l[i-1])*(l[i]-l[i+1])]

ไม่น่าประทับใจเกินไป (ดูที่องค์ประกอบทุกส่วนของรายการยกเว้นรายการแรกและรายการสุดท้ายดูว่าใหญ่หรือเล็กกว่าเพื่อนบ้าน) ฉันส่วนใหญ่โพสต์เพียงเพราะทุกคนรู้ว่าคุณสามารถทำได้x<y>zและทำงานได้ ฉันคิดว่ามันดูเรียบร้อย

ใช่x<y>zมันเป็นคุณสมบัติที่ยอดเยี่ยมของงูหลาม แต่จริงๆแล้วมันไม่ได้ดีที่สุดในกรณีนี้ ขอบคุณ VX สำหรับเคล็ดลับการคูณนั่นไม่ได้เกิดขึ้นกับฉันเลย Wrzlprmft def x(y):เตือนผมว่าการประกาศฟังก์ชั่นที่ไม่ระบุชื่อคือการกดแป้นพิมพ์น้อยกว่า

Haskell 50

f a=[x|(p,x,n)<-zip3 a(tail a)(drop 2 a),x>p&&x>n]

เยลลี่ 8 ไบต์

IṠIỊ¬T‘ị

ลองออนไลน์!

คำอธิบาย

IṠIỊ¬T‘ị
I          Differences between adjacent elements {of the input}
 Ṡ         Take the sign of each difference
  I        Differences between adjacent difference signs
   Ị       Mark the elements that are     in the range -1..1 inclusive
    ¬                                 not
     T     Take the indexes of the marked elements
      ‘      with an offset of 1
       ị   Index back into the original list

องค์ประกอบเป็นเพียงความรุนแรงในท้องถิ่นหากความแตกต่างกับเพื่อนบ้านทางซ้ายมีเครื่องหมายตรงข้ามกับความแตกต่างกับเพื่อนบ้านขวาของมันนั่นคือสัญญาณของความแตกต่างแตกต่างกัน 2 หรือ -2 เจลลี่มีข้อได้เปรียบดั้งเดิมจำนวนหนึ่งสำหรับจัดการกับ "ค้นหาองค์ประกอบที่มีคุณสมบัติบางอย่าง" (โดยเฉพาะเราสามารถค้นหาองค์ประกอบที่มีคุณสมบัติบางอย่างในรายการเดียวและใช้เพื่อแยกองค์ประกอบจากรายการอื่น) ซึ่งหมายความว่าเราสามารถแปลกลับไปเป็น รายการต้นฉบับมากขึ้นหรือน้อยลงโดยตรง (เราเพียงแค่ต้องชดเชยด้วย 1 เพราะองค์ประกอบแรกและสุดท้ายของรายการต้นฉบับได้หายไปในความแตกต่าง)

Python กับ Numpy - 81 74 67 ไบต์ ( 61 54 ไม่มีimportบรรทัด)

import numpy
e=lambda a:a[1:-1][(a[2:]-a[1:-1])*(a[1:-1]-a[:-2])<0]

อินพุตต้องเป็นอาร์เรย์ Numpy

C, 83

x,y,z;main(){y=z=0;while(scanf("%d",&x)){(y-z)*(y-x)>0?printf("%d ",y):1;z=y,y=x;}}

awk - 32 ตัวอักษร

{c=b;b=a;a=$0;$0=b}(b-c)*(a-b)<0

ไม่มีความหวังที่จะตีภาษาอย่าง J หรือ APL โดยย่อ แต่ฉันคิดว่าฉันจะเอาหมวกของฉันใส่แหวน คำอธิบาย:

• ในช่วงเวลาใดก็ตามa, bและcถือx_i, x_(i-1)และx_(i-2)
• b-c และ a-bประมาณอนุพันธ์ก่อนและหลังx_(i-1)
• หากผลิตภัณฑ์ของพวกเขาเป็นลบแสดงว่าเป็นลบและอีกรายการนั้นเป็นบวกx_(i-1)ดังนั้นจึงเป็นสินค้าท้องถิ่นดังนั้นพิมพ์

Brachylogขนาด 17 ไบต์

s₃{b≠h.&k≠&{⌉|⌋}}

ลองออนไลน์!

รับอินพุตผ่านตัวแปรอินพุตและสร้างเอาต์พุตผ่านตัวแปรเอาต์พุต

s₃{             }    For a length-3 substring of the input:
  {b                 its last two elements
    ≠                are distinct,
     h               and the first of those elements is
      .              the output variable;
       &k            its first two elements
         ≠           are also distinct;
          &{⌉| }     either its largest element
          &{ |⌋}     or its smallest element
                }    is also the output variable.

หากการรันค่าสามารถรับประกันได้ว่าจะหายไปs₃{{⌉|⌋}.&bh}จะประหยัดสี่ไบต์

Perl 5 -p , 49 ไบต์

s/\d+ (?=(\d+) (\d+))/say$1if($1-$&)*($1-$2)>0/ge

ลองออนไลน์!

ภาษา Wolfram (Mathematica) , 43 42 ไบต์

#~Pick~ArrayFilter[#[[2]]!=Median@#&,#,1]&

ลองออนไลน์!

ฉันเดาNothingยาวเกินไป ...

#~Pick~                                  &  (* select elements of the input where, *)
       ArrayFilter[                 ,#,1]   (*  when considering the block of length 1 *)
                                            (*    on either side of that element, *)
                   #[[2]]!=Median@#&        (*  its median is not that element *)

05AB1E , 11 10 ไบต์

¥.±¥Ä2Q0šÏ

ลองออนไลน์หรือตรวจสอบกรณีทดสอบอีกสองสามข้อ

คำอธิบาย:

¥           # Get the forward differences (deltas) of the (implicit) input-list
            #  i.e. [9,10,7,6,9,0,3,3,1,10] → [1,-3,-1,3,-9,3,0,-2,9]
 .±         # Get the signum of each delta (-1 if neg.; 0 if 0; 1 if pos.)
            #  → [1,-1,-1,1,-1,1,0,-1,1]
   ¥        # Get the forward differences of that list again
            #  → [-2,0,2,-2,2,-1,-1,2]
    Ä       # Convert each integer to its absolute value
            #  → [2,0,2,2,2,1,1,2]
     2Q     # And now check which ones are equal to 2 (1 if truthy; 0 if falsey)
            #  → [1,0,1,1,1,0,0,1]
       0š   # Prepend a 0
            #  → [0,1,0,1,1,1,0,0,1]
         Ï  # And only leave the values in the (implicit) input-list at the truthy indices
            #  → [10,6,9,0,1]
            # (after which the result is output implicitly)

PHP, 116 114 113

function _($a){for(;$a[++$i+1];)if(($b=$a[$i])<($c=$a[$i-1])&$b<($d=$a[$i+1])or$b>$c&$b>$d)$r[]=$a[$i];return$r;}

ตัวอย่างการใช้งาน:

print_r(_(array(2, 1, 2, 3, 4, 3, 2, 3, 4)));

Array
(
    [0] => 1
    [1] => 4
    [2] => 2
)

Haskell, 70C

รุ่น Golfed

e(a:b:c:r)
 |a<b&&b>c||a>b&&b<c=b:s
 |True=s
 where s=e(b:c:r)
e _=[]

เวอร์ชันที่ไม่ดี

-- if it's possible to get three elements from the list, take this one
extrema (a:b:c:rest)
    | a<b && b>c = b:rec
    | a>b && b<c = b:rec
    | otherwise = rec
    where rec = extrema (b:c:rest)
-- if there are fewer than three elements in the list, there are no extrema
extrema _ = []

Javascript: 102 ตัวอักษร

function h(a){for(u=i=[];++i<a.length-1;)if(x=a[i-1],y=a[i],z=a[i+1],(x-y)*(y-z)<0)u.push(y);return u}

APL, 19 ไบต์

{⍵/⍨0,⍨0,0>2×/2-/⍵}

ฉันแปลงเวอร์ชันถ่าน 20 ตัวเป็น APL แต่ฉันเพิ่มศูนย์ไปที่จุดเริ่มต้นและจุดสิ้นสุดแทนการลบตัวเลขตัวแรกและหลักสุดท้าย มิฉะนั้นจะทำงานเช่นเดียวกับรุ่น J

⍵- โอเมก้าพารามิเตอร์อย่างเป็นทางการ นี่คืออินพุตไปยังฟังก์ชัน

Python 2 , 59 ไบต์

f=lambda l=0,c=0,*r:r and(c,)*(l<c>r[0]or l>c<r[0])+f(c,*r)

ลองออนไลน์!

ฟังก์ชั่นนี้ส่วนใหญ่หลีกเลี่ยงการทำดัชนีทางธุรกิจที่มีค่าใช้จ่ายสูงโดยรับองค์ประกอบของรายการเป็นอาร์กิวเมนต์แทนที่จะเป็นรายการเอง ในขณะที่มีมากกว่าหนึ่งองค์ประกอบในรายการเราสร้างรายการซ้ำโดยตรวจสอบสูงสุดในแต่ละขั้นตอน