它会定期振荡吗？

19

挑战

给定一个列表，确定将列表分组为增加和减少元素的运行是否将导致大小相等的列表的列表。

换句话说，列表的“转折点”平均间隔开。

例

这是一个例子： 0, 3, 7, 5, 2, 3, 6

0, 3, 7增加，7, 5, 2减少和2, 3, 6增加。因此，这是事实。

另一个例子： 1, 4, 6, 8, 5, 3, 5, 7, 9

1, 4, 6, 8增加，8, 5, 3减少和3, 5, 7, 9增加。因此，这是虚假的。

规则和规格

没有相邻的元素将相等
可以假定所有数字都在您的语言的合理数字范围内
您可以假设所有数字都是整数，如果它可以帮助您打高尔夫
这是代码高尔夫球，因此最短的答案将获胜
以任何合理表示形式的列表形式输入，并以任何真实/虚假值输出。这两个值必须一致。

测试用例

Input -> Output
1, 3, 5, 8, 6, 4, 2, 3, 5, 7, 6, 4, 2, 5, 7, 9, 6, 4, 2 -> True
1, 3, 5, 7, 6, 4, 5, 7, 9, 8, 6, 4, 2, 3, 5 -> False
2, 3, 6, 4, 2, 3, 7, 5, 3, 4, 6 -> True
3, 6, 4, 8, 5, 7, 3, 5, 2 -> True
8 -> True
1, 3, 5, 7 -> True
4, 5, 7, 6, 8, 9 -> False
6, 4, 2, 3, 5, 4, 2 -> True
8, 5, 3, 2, 4, 6, 5, 3, 2, 5, 7 -> False

注意：您可能无法假定所有数字都是一位数字（除非您的语言能够处理所有数字）；测试用例反映了这一点，因为对我来说，用这种方式键入用例更容易：P这是一些测试用例，其数字超出该范围：

1, 5, 10, 19, 15, 13, 8, 13, 18, 23, 19, 18, 14 -> True
15, 14, 17, 16, 19, 18 -> True
12, 16, 19, 15, 18, 19 -> False

code-golf array-manipulation decision-problem

— 超中微子
source

第一次运行是否总是会增加，还是输入会以减少运行开始？

— 乔丹

@Jordan可以开始减少。我将为此添加一个测试用例。

— HyperNeutrino

小组总是完整的吗？例如，将1, 2, 3, 2是有效的输入，如果这样认为是对还是错？在该示例中，下一个值为1会使它为true，但为3会使它为false。

— 汤姆·卡彭特

1

@TomCarpenter这被认为是错误的。它们必须都具有相同的长度（因此必须完整）。

— HyperNeutrino

Answers:

9

MATL，10 9字节

dZS&Y'da~

在线尝试！

感谢路易斯·门多（Luis Mendo），节省了一个字节！

说明：

假设输入为[0, 3, 7, 5, 2, 3, 6]：

            % Implicit input:                                [0, 3, 7, 5, 2, 3, 6]
d           % Difference between adjacent elements:          [3, 4, -2, -3,  1,  3]
 ZS         % Sign of the differences:                       [1, 1, -1, -1, 1, 1]
   &Y'      % Length of runs of consecutive elements:        [2, 2, 2]
     d      % Difference between the lengths:                [0, 0]
      a     % Any non-zero elements:                         False
       ~    % Negate, to get a truthy value if all are zero: True

— 斯蒂夫·格里芬
source

8

果冻，6 个字节

IṠŒgAE

在线尝试！

感谢Adnan，节省了1个字节！

怎么运行的

IṠŒgAE-完整程序。

I-增量（增量）。
 Ṡ-每个符号。如果为负，则为-1；如果为空，则为0；如果为正，则为1。
  Œg-相邻元素的分组运行。
    A-绝对值。向量化。这会将-1和1映射到相同的值。
     E-都相等吗？

打高尔夫球时，我发现了一些更酷，更长的替代方法：IṠŒgL€E，IṠŒrṪ€E（改用运行长度编码）。

— Xcoder先生
source

我认为IṠŒgḂE应该保存一个字节

— Adnan

@Adnan灿A（绝对值）的替代品Ḃ，还是有一招我没有得到有关Ḃ？

— Xcoder先生17年

将1和-1统一为相同数字的任何函数都应足够

— Adnan

7

八度，54 50字节

@(x)nnz(unique(diff(find([diff(diff(x)>0) 1]))))<2

在线尝试！

说明

@(x)nnz(unique(diff(find([diff(diff(x)>0) 1]))))<2

@(x)                                                % Define anonymous function    
                               diff(x)              % Deltas (consecutive differences)
                                      >0            % Positive? Gives signs
                          diff(         )           % Deltas between signs
                         [                1]        % Append 1 to "close" last group
                    find(                   )       % Indices of nonzeros
               diff(                         )      % Deltas. Gives group lengths
        unique(                               )     % Remove duplicates
    nnz(                                       )    % Number of nonzeros. Gives length
                                                <2  % If 1 or 0: input is periodic

— 路易斯·门多
source

6

Wolfram语言（Mathematica），38个字节

Equal@@(1^Differences@#~SplitBy~Sign)&

在线尝试！

说明

Equal@@(1^Differences@#~SplitBy~Sign)&  (* Input:                {3, 6, 4, 8, 5, 7, 3, 5, 2} *)

          Differences@#                 (* Take differences:     {3, -2, 4, -3, 2, -4, 2, -3} *)
                       ~SplitBy~Sign    (* Split by sign:        {{3}, {-2}, {4}, {-3}, {2}, {-4}, {2}, {-3}} *)
        1^                              (* Raise to power of 1:  {{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}} *)
Equal@@                                 (* Check equal:          True *)

— 郑焕民
source

Equal@@(1^Split@Sign@Differences@#)&Equal@@Im@Split@Sign@Differences@#&比它短2个字节，比它短1个字节。

— 米莎·拉夫罗夫

现在，我正在考虑复数，使用Arg而不是Sign保存另一个字节。

— Misha Lavrov

5

05AB1E，8 7字节

¥0.SγaË

在线尝试！

-1感谢Adnan。

— 魔术章鱼缸
source

¥0.SγaË应该保存一个字节

— Adnan

什么是a在文档中我找不到它。is_letter(a)???

— 魔术章鱼缸

是的，这是正确的

— Adnan

@Adnan啊...好主意，好主意。

— 魔术章鱼缸

4

C（GCC），143个 140 138 136 135 132字节

保存了三个字节；使用变量r来存储函数的返回布尔值，而不是使用终止return。
保存了两个字节；打高尔夫球int A[]到int*A（使用指针而不是阵列）。
感谢Steadybox节省了两个字节；打高尔夫球f(int*A,int a)去f(A,a)int*A;。
保存一个字节；打高尔夫球if(d!=...去if(d-...。
保存了三个字节；打高尔夫球;j++...j+1去;...++j。

j,d,e,l,m,r;f(A,a)int*A;{for(d=A[0]>A[1],r=1,j=m=l=0;j-~-a;){l++;if(d-(e=A[j]>A[++j]))d=e,j--,r*=l>=(m=!m?l:m),l=0;}r*=-~l==m||m<1;}

在线尝试！

定义一个函数f，该函数查看列表中除最后一个元素之外的每个元素，并确定该元素与列表中下一个元素的关系。当关系第一次翻转时，将存储连续相等比较的次数，在初始运行之后，任何长度与存储的长度不同的运行都会导致输出错误。最后，查看倒数第二个元素与最后一个元素的关系，以使其与列表的其余部分匹配。

— 乔纳森·弗雷奇
source

您可以使用f(A,a)int*A;代替f(int*A,int a)。

— Steadybox

3

腐霉菌，11个字节

qFlM.g._k.+

在这里尝试。

— 暴民埃里克
source

3

Python 2中，107 105 103 97 96个 94个 91字节

lambda l:len({sum(g)**2for k,g in groupby(map(cmp,l[:-1],l[1:]))})<2
from itertools import*

在线尝试！

Python 3中，102个 100 97字节

lambda l:len({len([*g])for k,g in groupby(x>y for x,y in zip(l,l[1:]))})<2
from itertools import*

在线尝试！

— 场
source

您可以使用{...}，而不是set(...)保存3个字节

— 罗德

3

外壳，7个字节

EmLġ±Ẋ-

在线尝试！

如何运作

EmLġ±Ẋ-〜完整程序。

     Ẋ〜映射成对的相邻元素。
      -〜减去（这将计算增量）
   ġ〜组使用相等谓词。
    ±〜符号。
 mL〜获取长度。
E〜都相等吗？

一些可爱的选择：

εġLġ±Ẋ-
εüLġ±Ẋ-

— Xcoder先生
source

2

JavaScript（ES6），81个字节

这似乎太久了。我可能在这里丢失了某些东西……返回true或undefined。

f=(a,p=1)=>a.every((n,i)=>!i|!(1/(y=a[i+1]))|!(i%p)^y>n^a[i-1]>n)||a[p]&&f(a,p+1)

查找周期0 <p <a.length，以便每p个元素发生一次所有方向变化。

测试用例

显示代码段

f=(a,p=1)=>a.every((n,i)=>!i|!(1/(y=a[i+1]))|!(i%p)^y>n^a[i-1]>n)||a[p]&&f(a,p+1)

console.log(f([1, 3, 5, 8, 6, 4, 2, 3, 5, 7, 6, 4, 2, 5, 7, 9, 6, 4, 2])) // -> True
console.log(f([1, 3, 5, 7, 6, 4, 5, 7, 9, 8, 6, 4, 2, 3, 5])) // -> False
console.log(f([2, 3, 6, 4, 2, 3, 7, 5, 3, 4, 6])) // -> True
console.log(f([3, 6, 4, 8, 5, 7, 3, 5, 2])) // -> True
console.log(f([8])) // -> True
console.log(f([1, 3, 5, 7])) // -> True
console.log(f([4, 5, 7, 6, 8, 9])) // -> False
console.log(f([15, 14, 17, 16, 19, 18])) // -> True
console.log(f([19, 15, 14, 17, 18, 17, 16, 19, 20])) // -> True

— Arnauld
source

2

Python 2，96个字节

import re
def f(x):exec"x=map(cmp,x[1:],x[:-1]);"*2;re.match('.([^1]*)(-?1, \\1)*9',`x+[9]`)<0<_

在线尝试！通过出口代码输出：崩溃（1）为假，干净出口（0）为真。

Python 2，106个字节

def f(x):d=map(cmp,x[1:],x[:-1]);l=len(d);s=(d+[0])[0];k=(d+[-s]).index(-s);print((k*[s]+k*[-s])*l)[:l]==d

在线尝试！

— 林恩
source

我不确定，尽管(...)[:l]<d可能与相反(...)[:l]==d。

— 乔纳森·弗雷奇

2

Haskell，79 78 77字节

import Data.List
g s|h:t<-(1<$)<$>group(zipWith(<)s$tail s)=all(==h)t
g _=1<3

在线尝试！

给定一个列表s，zipWith(<)s$tail s测试每个元素是否小于其后继元素，例如s=[2,3,6,4,2,3,7,5,3]yields [True,True,False,False,True,True,False,False]。然后group将相同的元素一起运行：[[True,True],[False,False],[True,True],[False,False]]。要检查所有这些列表是否具有相同的长度，请将它们的元素替换为yield 1（请参见此技巧），[[1,1],[1,1],[1,1],[1,1]]并检查t此列表尾部的所有元素是否等于head h：all(==h)t。

这种方法不适用于单例列表，但由于这些列表始终为真，因此我们可以根据自己的情况进行处理：g[_]=1<3。

— 莱科尼
source

1

R，57字节

function(x){d=diff
sum(rle(d(which(!!d(d(x)>0))))$v^0)<2}

在线尝试！

— NofP
source

1

Japt，15个字节

ä- mg ò¦ mÊä¥ e

在线尝试！

说明

ä- mg ò¦ mÊä¥ e                                                  [0,3,7,5,2,3,6]
ä-                // Difference between neighboring elements     [-3,-4,2,3,-1,-3]
   mg             // Get the sign of each element                [-1,-1,1,1,-1,-1]
      ò¦          // Partition between different elements        [[-1,-1],[1,1],[-1,-1]]
         mÊ       // Get the length of each element              [2,2,2]
           ä¥     // Check for uniqueness                        [true,true]
              e   // Return true if all elements are truthy      true

— 奥立佛
source

1

R，36个字节

function(n)!sd(rle(sign(diff(n)))$l)

diff计算连续的差异，然后将其sign压缩至±1。rle然后进行游程编码。所有元素都rle应该相同，即向量的标准差为零。!然后产生正确的逻辑输出。

— JDL
source

1

Haskell（Lambdabot），59个字节

g(map(1<$).group.ap(zipWith(<))tail->h:t)=all(==h)t;g _=1<3

基于@Laikoni的答案

— 黑帽
source

很好，我不知道Lamdabot是否启用了ViewPatterns。中缺少一个空格g_=1<3。

— Laikoni '17

@Laikoni我都没有，但是我实际上去了#haskell并对其进行了测试

— BlackCap，

0

的Java（OpenJDK的8），437个 302 256 188字节

a->{int i=0,g=0,x=0,l=0;String d="";for(;i<~-a.length;d+=a[0].compare(a[i+1],a[i++])+1);for(String s:d.split("(?<=(.))(?!\\1)"))if(g++<1)x=s.length();else if(s.length()!=x)l++;return l<1;}

在线尝试！

— 罗伯托·格雷厄姆
source

0

Clojure，70个字节

#({0 1 1 1}(count(set(map count(partition-by pos?(map -(rest %)%))))))

传回1为True，而传回nil（AKA为null）为Falsy。

— 尼古妮
source

0

Java（OpenJDK 8），135字节

a->{Integer i=0,c,d=0,p=0,r=0;for(;++i<a.length;)d+=(i<2|(c=i.signum(a[i-1]-a[i]))<0?d<0:d>0)?c:p==0|p==-d?c-(p=d):1-(r=1);return r<1;}

在线尝试！

说明

a->{                    // int array
 Integer i=0,c,d=0,p=0,r=0;
                        // variable definitions, use Integer to abuse static calls
 for(;++i<a.length;)    // Loop from 1 till length - 1
  d+=                   // Change d
   (i<2                 // First iteration?
     |(c=i.signum(a[i-1]-a[i]))<0?d<0:d>0
   )                    // Or do c and d have the same sign?
    ?c                  // then increase the magnitude of d.
    :p==0|p==-d         // else we're in a u-turn. Is it the first? Or is the magnitude the same as previously?
     ?c-(p=d)           // assign the new magnitude with sign to p and reset d to -1 (if was positive) or 1 (if was negative)
     :1-(r=1);          // else just do r=1 (technically: "add 1-1=0 to d" as well)
 return r<1;            // return whether there were wrong amplitudes.
}

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

0

Python 2中，110个 99字节

-11个字节，感谢@Lynn

d=input()
exec"d=map(cmp,d[:-1],d[1:]);"*2
x=[i+1for i,e in enumerate(d)if e]
for i in x:i%x[0]>0<q

在线尝试！

— ovs
source

您可以通过计算双重差异来节省一些字节，例如exec"d=map(cmp,d[:-1],d[1:]);"*2

— Lynn

0

红宝石，57个字节

->a{!a.each_cons(2).chunk{|x,y|x>y}.uniq{|*,x|x.size}[1]}

在线尝试！

— 约旦
source

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.