有颠簸吗？

39

给定一个正整数列表，确定是否有一个元素大于其两个邻居或小于其两个邻居（“凸点”）。需要明确的是，颠簸永远不会成为列表的第一或最后一项，因为它们只有一个邻居。

您的程序应输出两个一致的值之一，每个值对应于一个没有凹凸的列表或一个带有凹凸的列表。这些值无关紧要，您可以自己选择它们。

这是代码高尔夫球，因此答案将以字节计分，而字节数越少越好。

测试用例

[] -> False
[1] -> False
[1,2] -> False
[1,2,1] -> True
[1,2,2] -> False
[1,2,3] -> False
[1,2,2,1] -> False
[1,2,2,3] -> False
[1,2,1,2] -> True
[1,3,2] -> True
[3,1,2] -> True
[2,2,2] -> False

code-golf number array-manipulation decision-problem

— 小麦巫师
source

5

测试用例要求：除0-1-2-3之外的数字，是否允许/禁止使用负数？

— 魔术章鱼缸

建议的测试用例：（[1,3,3]确保使用Dennis算法的答案采用增量的符号，而不是仅使用增量本身）

— ETHproductions

1

@ETHproductions已经不被涵盖[1,2,2]吗？还是我错过了什么？

— Nic Hartley

2

@NicHartley，的增量与[1,2,2]这些增量的符号相同，但是并非如此[1,3,3]。

— 毛茸茸的

Answers:

15

果冻，5个字节

IṠIỊẠ

如果有颠簸，则返回0，否则返回1。

在线尝试！

这个怎么运作

IṠIỊẠ  Main link. Argument: A (integer array)

I      Increments; take all forward differences of A.
 Ṡ     Take the signs.
       The signs indicate whether the array is increasing (1), decreasing (-1), or
       constant at the corresponding point. A 1 followed by a -1 indicates a local
       maximum, a -1 followed by a 1 a local minimum.
  I    Increments; take the forward differences again.
       Note that 1 - (-1) = 2 and (-1) - 1 = -2. All other seven combinations of
       signs map to -1, 0, or 1.
   Ị   Insignificant; map each difference d to (-1 ≤ d ≤ 1).
    Ạ  All; return 1 if all differences are insignificant, 0 if not.

— 丹尼斯
source

1

什么是“增量”？递增的是什么？

— 小麦巫师

1

@WheatWizard我认为这等效于05AB1E的deltas（¥）命令：弹出数组[n0，n1，n2，n3]，并推入数组[n1-n0，n2-n1，n3-n2]。

— Kaldo

10

JavaScript（ES6），38个字节

返回一个布尔值。

a=>a.some(x=n=>x*(x=a<n|-(a>(a=n)))<0)

测试用例

显示代码段

let f =

a=>a.some(x=n=>x*(x=a<n|-(a>(a=n)))<0)

console.log(f([]))              // False
console.log(f([1]))             // False
console.log(f([1,2]))           // False
console.log(f([1,2,1]))         // True
console.log(f([1,2,2]))         // False
console.log(f([1,2,3]))         // False
console.log(f([1,2,2,1]))       // False
console.log(f([1,2,2,3]))       // False
console.log(f([1,2,1,2]))       // True
console.log(f([1,3,2]))         // True
console.log(f([2,0,1]))         // True
console.log(f([2,2,2]))         // False
console.log(f([-4,100000,89]))  // True

怎么样？

我们使用a来存储n的先前值。我们设置X到1，如果一个<N ，-1如果一个>Ñ或0，如果A = N。然后我们测试old_x * x <0是否只有在（old_x = 1和x = -1）或（old_x = -1和x = 1）时才有可能。

因为x初始化为some（）的匿名回调函数，所以它在第一次迭代期间被强制为NaN，这使测试变得虚假。

— Arnauld
source

这将以严格模式抛出。

— Aluan Haddad '18

2

@AluanHaddad好吧，仅由于未声明变量，99％的JS高尔夫球代码将以严格模式抛出。PPCG和codereview混合不好。：P

— Arnauld

公平，我对高尔夫并不怎么感兴趣。

— Aluan Haddad '18

4

那为什么要对此发表评论大声笑

— 马克·C，

8

Haskell，42个字节

any(<0).f(*).f(-)
f a b=zipWith a b$tail b

在线尝试！

说明

首先，我们有一个函数f，它接受一个二进制函数和一个列表，并将该二进制函数应用于列表中的每个相邻对。

然后我们的主要功能适用f(-)于输入列表。这将计算差异列表。然后f(*)，我们将其应用于列表以将每个相邻对相乘。最后，我们问是否有任何一对小于零。

如果结束列表中的数字是差异列表中负数和正数的乘积，则它只能是负数。因此，为了产生一个否定的条目（然后返回true），原始列表必须从增加切换到减少，反之亦然，即它必须有一个颠簸。

— 小麦巫师
source

处理空列表的好方法！

— Laikoni '18

6

Python 2，43个字节

f=lambda x,y,z,*t:0>(y-x)*(z-y)or f(y,z,*t)

如果有颠簸，则返回True；否则，则返回错误。（默认情况下允许）

在线尝试！

— 丹尼斯
source

5

带图像包的八度，34 32字节

@StewieGriffin节省了2个字节！

@(x)0||prod(im2col(diff(x),2))<0

在线尝试！

说明

计算连续的差异，将它们排列在长度为2的滑动块中，获得每个块的乘积，并测试是否有这样的负数。

— 路易斯·门多
source

0||prod(...)保存2个字节。您也可以跳过整个any部分，并使用默认的true / falsy定义保存5个字节。

— Stewie Griffin

织补，节省了5个字节将使您的解决方案比我:(尼斯使用映像包短，我不知道这是对TIO。

— Stewie新

1

@StewieGriffin由于挑战要求两个一致的值，因此我无法删除any。谢谢你的0||主意！

— 路易斯·门多

4

R，48个字节

function(x)any(apply(embed(diff(x),2),1,prod)<0)

在线尝试！

如何使用c（1,4,1,4）为例逐步进行工作：

> x=c(1,4,1,4)
> diff(x)
[1]  3 -3  3
> embed(diff(x),2)
     [,1] [,2]
[1,]   -3    3
[2,]    3   -3
> apply(embed(diff(x),2),1,prod)
[1] -9 -9
> any(apply(embed(diff(x),2),1,prod)<0)
[1] TRUE

作为奖励，这是使用package提供类似长度和概念的解决方案zoo：

function(x)any(zoo::rollapply(diff(x),2,prod)<0)

— 浮游动物
source

1

整齐！自我注意：记住embed存在。太糟糕了，rowProds并且colProds在R中不作为别名存在

— Giuseppe

1

@Giuseppe出于绝望，我实际上检查了它们是否存在:)但确实只是rowSums和rowMeans……

— plannapus

1

好吧，至少可以浏览一下文档，.colSums然后根据其他输入（可能在某处有高尔夫应用程序）将输入重塑为矩阵。...现在我只需要找到一个！

— 朱塞佩

@Guiseppe：看看matrixStats包中的功能。

— Michael M

@MichaelM不幸的是，由于软件包名称的长度，它没有竞争力（57字节：）function(x)any(matrixStats::colProds(embed(diff(x),2)))<0。但是，除了标准高尔夫以外，这个包确实是一个宝库。

— plannapus

4

Haskell，33个字节

f(p:r@(c:n:_))=(c-p)*(c-n)>0||f r

在线尝试！

True 如果有颠簸，则没有错误。

— 全人类
source

l`zip3`tail l$drop 2l只是短发。我想知道模式匹配是否会更短？

— 林恩

3

Perl 6，39个字节

{so~(.[1..*]Zcmp$_)~~/'re L'|'s M'/}

在线尝试！

$_是此匿名函数的list参数。 .[1..*]是相同的列表，但删除了第一个元素。 Zcmp将两个列表与cmp运算符一起压缩，得到一个Order值列表。例如，对于输入列表，1, 2, 2, 2, 1这将导致list More, Same, Same, Less。

现在我们只需要知道该列表是否包含两个相邻元素More, Less或Less, More。我使用的技巧是使用将该列表转换为以空格分隔的字符串~，然后测试它是否包含substring re L或s M。（第一个不能只是e L因为Same还以“ e”结尾。）

智能匹配运算符返回一个Match对象（如果匹配成功）或Nil（如果没有成功），则将其so转换为布尔值。

— 肖恩
source

3

Wolfram语言（Mathematica），40个字节

MatchQ[{___,x_,y_,z_,___}/;x<y>z||x>y<z]

在线尝试！

— Alephalpha
source

3

红宝石，55 46字节

->a{a.each_cons(3).any?{|x,y,z|(y-x)*(y-z)>0}}

在线尝试！

Lambda接受数组并返回布尔值。

-9个字节：替换(x<y&&y>z)||(x>y&&y<z)为(y-x)*(y-z)>0（感谢GolfWolf）

->a{
  a.each_cons(3)              # Take each consecutive triplet
    .any?{ |x,y,z|            # Destructure to x, y, z
      (y-x)*(y-z) > 0         # Check if y is a bump
    }
}

— benj2240
source

1

我认为您可以使用|代替||，为您节省1个字节。

— Yytsi '18

46个字节

— Cristian Lupascu，

使用'0 <（yx）* y- = z'保存1个字节

— GB

3

PostgreSQL 173字节

SELECT DISTINCT ON(a)a,x>j and x>k OR x<least(j,k)FROM(SELECT a,x,lag(x,1,x)OVER(w)j,lead(x,1,x)OVER(w)k FROM d WINDOW w AS(PARTITION BY rn ORDER BY xn))d ORDER BY 1,2 DESC;
     a     | c 
-----------+---
 {1}       | f
 {1,2}     | f
 {1,2,1}   | t
 {1,2,1,2} | t
 {1,2,2}   | f
 {1,2,2,1} | f
 {1,2,2,3} | f
 {1,2,3}   | f
 {1,3,2}   | t
 {2,2,2}   | f
 {3,1,2}   | t
(11 rows)

— 埃文·卡洛尔
source

您好，欢迎来到该网站。我不熟悉PostgreSQL，但您也许可以减少使用的空白量。通常，大多数语言不需要您使用大多数种类的间距。

— 小麦巫师

@WheatWizard是将示例数据存入数据库，这无关紧要。

— 埃文·卡罗尔

那你的代码是什么？我们不允许将输入而不是输入直接插入代码中。如果是这种情况，您应该重写它，以便它通过标准方法进行输入。

— 小麦巫师

@WheatWizard，从您提供的链接codegolf.meta.stackexchange.com/a/5341/23085

— Evan Carroll，

1

好吧，如果那是您使用的输入格式，那就可以了。最好在这里打高尔夫球，很高兴看到人们以不太常用的语言打高尔夫球。

— 小麦巫师

3

Java 8，108 104 101 86 84 79 72字节

a->{int i=a.length,p=0;for(;i-->1;)i|=p*(p=a[i]-a[i-1])>>-1;return-i>1;}

-2个字节，感谢@OlivierGrégoire。
-13个字节，感谢@Nevay。

在线尝试。

— 凯文·克鲁伊森
source

1

84个字节。我更改了迭代顺序（向下），交换了两个乘法操作数，然后删除了多余的-1。

— 奥利维尔·格雷戈尔（OlivierGrégoire），

1

79字节：（对于真实情况，对于虚假情况，a->{int i=a.length;for(;i-->2;)i|=(a[i]-a[--i])*(a[i]-a[i-1])>>-1;return-~i|3;}返回）-或，如果使用是否存在异常作为返回值-13a->{for(int i=0;++i>0;)i|=(a[i-1]-a[i])*(a[i]-a[i+1]);}

— 则为

1

72位元组：a->{int i=a.length,p=0;for(;i-->1;)i|=p*(p=a[i]-a[i-1])>>-1;return-i>1;}

— Nevay

3

R，58 56字节

function(x)any(abs(diff(sign(diff(c(NA,x)))))>1,na.rm=T)

在线尝试！

感谢Giuseppe，节省了2个字节

— NofP
source

3

您可以删除括号{}中的-2个字节。

— 朱塞佩

另外，我认为您可以移植Stewie Griffin的方法获得42个字节

— Giuseppe

@Giuseppe，我认为Stewie移植了我的方法，不同之处在于我的方法可以正确处理测试用例中列出的空向量。与R相比，Matlab对空向量的宽容度

— 更高。– NofP

c()是NULL与整数的空向量不同的integer(0)，而在MATLAB []中double默认为a ，但是如果要保持这种方式，那是完全合理的。

— 朱塞佩

3

J，16 15字节

-1字节感谢FrownyFrog

1 e.0>2*/\2-/\]

在线尝试！

原始：16个字节

0>[:<./2*/\2-/\]

2-/\] -每个相邻项目的差异

2*/\ -每个相邻项目的产品

[:<./ - 最低

0> -是负面的吗？

在线尝试！

— 加伦·伊万诺夫（Galen Ivanov）
source

你好！难道不能将其简化为这种更简单的显式形式0> <./ 2 * / \ 2-/ \（13个字节）吗？

— Mathias Dolidon

@Mathias Dolidon这在解释器中有效，但是在PPCG中，如果有输入，通常会提供一个函数（J动词）。如果动词是隐性动词，则不计算赋值f=.字节。请记住，我是新用户：)

— Galen Ivanov

我也是，您已经为我澄清了规则。谢谢！:)

— Mathias Dolidon

1

1 e.0>2*/\2-/\]

— FrownyFrog

@FrownyFrog谢谢！看来我很少使用e。:)

— Galen Ivanov

2

Japt，11个字节

@ETHproductions --5个字节

ä- mÌäa d>1

在线尝试！| 测试用例

这使用了丹尼斯算法

— 奥立佛
source

2

Japt，9个字节

ä- ä* d<0

在线尝试！

奥利弗的答案与其他答案所使用的方法的混搭。

— ETH生产
source

2

附件，39字节

Any&:&{_*~?Sum[__]}@Slices&2@Sign@Delta

在线尝试！

对此结果感到非常满意。

说明

这是四个功能的组合：

Delta
Sign
Slices&2
Any&:&{_*~?Sum[__]}

Delta获取元素之间的差异。=

然后，Sign将其应用于每个差异，从而为我们提供1s，0s和-1s 的数组。=

然后，Slices&2给出数组中所有长度为2的切片，给出所有对的差。

最后，Any&:&{_*~?Sum[__]}等于，对于输入x：

Any[&{_*~?Sum[__]}, x]
Any[[el] -> { el[0] and not (el[0] + el[1] = 0) }, x]

这将搜索总和为零但不为零的元素。如果存在任何这样的元素对，那么就会发生碰撞。

— 科纳·奥布莱恩
source

2

MATL，8字节

dZSd|1>a

在线尝试！

— 斯蒂夫·格里芬
source

2

外壳，7个字节

V<0Ẋ*Ẋ-

在线尝试！

说明

V<0Ẋ*Ẋ-  Implicit input, say [2,5,5,1,4,5,3]
     Ẋ-  Consecutive differences: [3,0,-4,3,1,-2]
   Ẋ*    Consecutive products: [0,0,-12,3,-2]
V<0      Is any of them negative? Return 1-based index: 3

— 兹加布
source

2

八度，33字节

@(x)0||abs(diff(sign(diff(x))))>1

在线尝试！

说明：

@(x)                           % Anonymous function taking x as input
                  diff(x)       % Takes the difference between consecutive elements
             sign(diff(x))      % The sign of the differences
        diff(sign(diff(x)))     % The difference between the signs
    abs(diff(sign(diff(x)))>1   % Check if the absolute value is 2
@(x)abs(diff(sign(diff(x)))>1   % Output as matrices that are treated truthy or falsy

— 斯蒂夫·格里芬
source

2

Brachylog，10个字节

s₃.¬≤₁∧¬≥₁

在线尝试！

true.如果有颠簸，则成功（），如果没有颠簸，则成功（）false.。

说明

这已经相当可读了：

s₃.           There is a substring of the input…
  .¬≤₁        …which is not non-decreasing…
      ∧       …and…
       ¬≥₁    …which is not non-increasing

— 致命
source

2

05AB1E，7个字节

¥ü‚P0‹Z

在线尝试！

说明

¥         # calculate delta's
 ü‚       # pair each element with the next element
   P      # product of each pair
    0‹    # check each if less than 0
      Z   # max

— 艾米尼亚
source

是否没有一个1字节的替代方法可以0‹基本上检查数字是否为负号？

— 魔术章鱼缸

@MagicOctopusUrn：d用于检查仅包含堆栈的顶部[0-9]，这与我们在此处想要的相反。但是现在它更加智能了，负数/浮点数也算作数字。

— Emigna '18

啊...可能宣誓就a看了这个negative标志并返回了真值或其他内容...但是我认为您是对的，我正在记住您的d把戏。

— 魔术章鱼缸

2

Brachylog，10个字节

s₃s₂ᶠ-ᵐ×<0

在线尝试！

不像@Fatalize现有的10个字节的答案那么整洁和优雅，但是它可以工作！

s₃   % There exists a substring of three elements [I,J,K] in the array such that

s₂ᶠ  % When it's split into pairs [[I,J],[J,K]]

-ᵐ   % And each difference is taken [I-J, J-K]

×    % And those differences are multiplied (I-J)*(J-K)
     % (At a bump, one of those will be negative and the other positive. 
     % At other places, both differences will be positive, or both negative, 
     %  or one of them 0 - ultimately resulting in a non-negative product.)

<0   % The product is negative

— sundar-恢复莫妮卡
source

1

外壳，9个字节

▼mεẊ-Ẋo±-

在线尝试！

使用丹尼斯算法。

— 暴民埃里克
source

1

Perl 5，54 + 2（`-pa`）= 56字节

map$\|=$F[$_-1]!=(sort{$a-$b}@F[$_-2..$_])[1],2..$#F}{

在线尝试！

— Xcali
source

1

Python 2，60个字节

lambda l:any(p>c<n or p<c>n for p,c,n in zip(l,l[1:],l[2:]))

在线尝试！

几乎是同一件事，以为会更短...

Python 2，63个字节

f=lambda l:l[3:]and(l[0]>l[1]<l[2]or l[0]<l[1]>l[2]or f(l[1:]))

在线尝试！

— 全人类
source

1

使用乘法代替58个字节

— Shieru Asakoto

1

Pyt，11 7 字节

₋ʁ*0<Ʃ±

如果有凹凸则输出1，否则输出0

在线尝试！

小麦港巫师的Haskell答案

旧方法（11个字节）：

₋±₋Å1≤ĐŁ↔Ʃ=

在线尝试！

如果有颠簸，则返回False，否则返回True

丹尼斯港的果冻答案

— mudkip201
source

1

Wolfram语言（Mathematica），37 36字节

FreeQ[(d=Differences)@Sign@d@#,-2|2]&

给出与测试用例答案相反的结果（False和True相反）。加上a !可以切换到正常形式。

要么

Abs@(d=Differences)@Sign@d@#~FreeQ~2&

也扭转输出，所以更换FreeQ与MatchQ正常形态。

说明：取序列差异的符号。如果结果序列包括{1，-1}或{-1,1}，则会有碰撞。在任何一种情况下，{1，-1}或{-1,1}的差的绝对值为2。

通过对最终列表进行平方处理来舍弃另一个字节，而不是取绝对值：

FreeQ[(d=Differences)@Sign@d@#^2,4]&

在线尝试！

— 凯莉·洛德（Kelly Lowder）
source

1

Perl，35个字节

包括+3用于-p

bump.pl：

#!/usr/bin/perl -p
s%\S+ %$a*1*($a=$&-$')%eg;$_=/-/

运行方式：

bump.pl <<< "3 1 2"

— 吨·霍斯佩尔
source

1

朱0.6，57 56个字节

l->any(p>c<n||p<c>n for(p,c,n)=zip(l,l[2:end],l[3:end]))

基本上只是完全人类的python答案。来自user71546的-1个字节

在线尝试！

朱莉娅0.6，39字节

f(x,y,z,a...)=x>y<z||x<y>z||f(y,z,a...)

Lispy递归样式，又名Dennis的python答案。true当凹凸存在时返回，否则抛出错误。这可能应该是42个字节，因为在调用时必须先将其展开。例如，a=[1,2,1]您致电f(a...)。f(a)=f(a...)会消除这种需求，但会更长。我需要获得更好的递归，而且我真的不喜欢编写会引发错误的代码。

在线尝试！

— gggg
source

1

似乎之后的空间for不是必须的；）

— Shieru Asakoto

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.

Licensed under cc by-sa 3.0 with attribution required.