挑战数组#1:交替数组


41

交替阵列

一个交替阵列是其中两个(不一定不同)值交替的任何长度的列表。也就是说,所有偶数索引项都相等,所有奇数索引项都相等。

您的任务是编写一个程序或函数,当给出正整数列表时,如果该程序或函数truthy是交替的,falsy则输出/返回。

这是,因此最短的代码(以字节为单位)获胜!

边缘案例:

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

其他测试用例:

[1,2,1,2]      -> True
[3,4,3]        -> True
[10,5,10,5,10] -> True
[10,11]        -> True
[9,9,9,9,9]    -> True

[5,4,3,5,4,3]   -> False
[3,2,1,2,1,2]   -> False
[1,2,1,2,1,1,2] -> False
[2,2,3,3]       -> False
[2,3,3,2]       -> False

这是一个示例,您可以使用Python 3(非高尔夫版)编写的代码来测试您的解决方案:

def is_alternating(array):
    for i in range(len(array)):
        if array[i] != array[i%2]:
            return False
    return True

数组元素的可能值是什么?
罗伯特·希克曼

@RobertHickman以您的语言的标准int大小为单位的正整数列表
FlipTack

哦,我现在在问题中看到了。糟糕,谢谢。
罗伯特·希克曼

Answers:


27

果冻,4字节

ḣ2ṁ⁼

在线尝试!

这个怎么运作

ḣ2ṁ⁼  Main link. Argument: A (array)

ḣ2    Head 2; truncate A after its second element. If A has two or less elements,
      this returns A itself.
  ṁ   Mold; cyclically repeat the elements of the previous result to create an
      array that has the same shape/length as A.
   ⁼  Test the result for equality with A.

7
该死的。并将其更改2为其他数字将立即带来挑战!
格雷格·马丁

3个字节,但Ɲ发布挑战时不存在。
caird coinheringaahing '18

14

Brainfuck,34个字节

,>,>+>,
[
  [<+<<->>>-]
  +<[-<<]
  >[>]
  ,
]
<.

将数组作为字符串中的字节值,并输出\x00false和\x01true。

在线尝试。

这样可以保持结构

a b 1 c

在磁带上,只要数组是交替的c,当前字符在哪里,b它是前一个字符,a也是前一个前一个字符。如果发现不匹配,指针移动到左边,从而ab1标志全部变为零,而这种情况将一直持续到所有输入被消耗。


13

R,24 23字节

all((a=scan())==a[1:2])

将向量读入STDIN,获取该向量的前两个元素,然后检查相等性。如果和的长度a[1:2]不匹配,R将循环通过a[1:2]以匹配a的长度。这样做会发出警告,但是会起作用。

令人惊讶的是,这甚至适用于空输入,不确定为什么,但是我会继续讲下去。

@MickyT节省了1个字节


您可以使用all((a=scan())==a[1:2])
MickyT

如何输入矢量,列表或单数形式的数据?我尝试在控制台上键入单个数字,但收到警告:“警告消息:在scan()== a [1:2]中:较长的对象长度不是较短的对象长度的倍数”。虽然可以。
skan

通过确实输入单个数字。如果输入长度为奇数,它将发出警告,但仍会给出正确的输出。
2016年

10

MATL7 6字节

2YCs&=

对于交替数组,这会输出一个非空的1矩阵,这是事实。对于非交替数组,矩阵至少包含一个零,因此是虚假的(请参见此处)。

在线尝试!验证所有测试用例

说明

让我们以[1 2 1 2]输入为例。

2YC   % Implicit input. Build matrix whose columns are overlapping blocks of 
      % length 2. If input has size less than 2 this gives an empty array
      % STACK: [1 2 1;
                2 1 2]
s     % Sum of each column. For an empty array this gives 0
      % STACK: [3 3 3]
&=    % Matrix of all pairwise equality comparisons. Implicit display
      % STACK: [1 1 1;
                1 1 1;
                1 1 1]

2
不错的算法!这将是一个果冻般的答案。
丹尼斯

@丹尼斯谢谢!这部分是受到您的果冻方法启发的
路易斯·门多

9

JavaScript(ES6),27个字节

a=>!a.some((v,i)=>a[i&1]-v)

测试用例


8

视网膜,25字节

M`\b(\d+),\d+,(?!\1\b)
^0

在线尝试!

代替具有交替的值相匹配的输入的(这会导致在一个正则表达式的一些烦人的边缘效应),我匹配输入不是有效的,则事后否定的结果。

匹配无效输入的好处在于,这是一个属性,可以在本地检查,并且不需要专门处理空输入或短输入:如果任何输入包含两个相距一个位置的不同值,则该输入无效。

因此,第一阶段对匹配的数目进行计数,\b(\d+),\d+,(?!\1\b)并捕获一个值,然后匹配下一个值,然后断言顺序中的第三个值是不同的。对于有效输入,此值为零;对于无效值,其值为正。

第二阶段只计算匹配的数量的^01,如果第一阶段的恢复01其他。


7

Mathematica,29个字节

#=={}||Equal@@(Most@#+Rest@#)&

Luis Mendo的MATL算法的端口。未命名函数采用数字(或什至是更通用的对象)列表并返回TrueFalse。测试连续元素的总和是否相等。不幸的是MostRest在空列表上cho了一下,因此必须单独进行测试。

Mathematica,33个字节

Differences[#,1,2]~MatchQ~{0...}&

未命名函数采用数字(或什至是更通用的对象)列表并返回TrueFalse。该函数Differences[#,1,2]获取的差值不是连续的整数对,而是相距两个距离的整数对。然后我们只检查结果列表中是否只有零。

另外,再增加一个字节(将更2改为#2),我们得到了一个函数,该函数输入一个整数列表和另一个正整数#2,并检查输入列表是否是#2周期性地对常数序列进行交错的结果。例如,

Differences[#,1,#2]~MatchQ~{0...}&[{1,2,3,4,5,1,2,3,4,5,1,2},5]

评估为True


7

Haskell,27 26字节

and.(zipWith(==)=<<drop 2)

这将评估为可解决挑战的匿名函数。想法是从列表中删除前两个数字,使用相等性压缩原始列表,然后检查结果是否仅包含Trues。 在线尝试!

感谢nimi 1个字节!



1
真好 and.(zipWith(==)=<<drop 2)保存一个字节。
nimi

7

视网膜39 32 28字节

^(\d*)((,\d+)(,\1(\3|$))*)?$

在线尝试!

感谢Martin,节省了7个字节!多亏Kobi保存了3个!然后向Kritixi提出另一个想法。

我们可以选择匹配一个占用整个输入的数字,任意一对数字或任意一对数字,然后在同一对数字之后匹配任意次,并且可以选择不包含第二个数字。如果输入为一元,则可以节省2个字节。


1
另一种^(\d+)?(.\d+)?(.\1\2)*(.\1)?$29字节替代方案。这并没有匹配,1,,1
Kritixi Lithos

1
@Kobi好主意,谢谢!我使用了Kritixi的一些答案(在第二个捕获组中添加了逗号)来保存另一个1!
FryAmTheEggman '16

6

Pyth,9个字节

q<*<Q2lQl

说明

q<*<Q2lQlQQ   Implicitly add enough Qs to make the code run

   <Q2        Take the first two elements of the input
  *   lQ      Repeat those len(input) times
 <      lQ    Take the first len(input) elements
q         Q   Check if those are equal to the input

您可能需要更新说明中的代码(这是不同的atm)
FlipTack

@ Flp.Tkc Pyth将Qs 隐式添加到代码中。我在解释中添加了它们,以使发生的事情更清晰,但它们并没有真正出现在代码中。
助记符

5

Brachylog,15个字节

:{~c#Tbh#Co}f#=

在线尝试!

说明

:{         }f       Find all results of the predicate below
             #=     They must all be equal

  ~c#T              Deconcatenate the input into three lists
      bh#C          The middle list has two elements
        #Co         Order that couple of elements as the output

5

APL,7个字节

⊢≡⍴⍴2⍴⊢

说明:

  • 2⍴⊢:将输入数组重塑2
  • ⍴⍴:按照输入的原始大小重塑结果,并重复元素
  • ⊢≡:查看结果是否等于原始输入

测试用例:

      true←(1 2 1 2)(10 5 10 5 10)(10 11)(9 9 9 9 9)
      false←(5 4 3 5 4 3)(3 2 1 2 1 2)(1 2 1 2 1 1 2)(2 2 3 3)(2 3 3 2)
      ( ⊢≡⍴⍴2⍴⊢ ) ¨ true
1 1 1 1
      ( ⊢≡⍴⍴2⍴⊢ ) ¨ false
0 0 0 0 0

5

Java 8,63字节

i->{int r=0,x=1;for(;++x<i.length;)r|=i[x]-i[x-2];return r==0;}

这是一个 Predicate< int[ ] >

说明:将结果初始化为0。对于每个元素,将结果与当前元素和较早的元素2标记之间的差异进行Biteise或。返回true如果结果等于0。否则返回false


5

Perl 6的 49个43  42字节

{!grep {![==] @_},roundrobin |.rotor: 2,:partial}

试试吧

{!.grep: ->\a,\b=$_[1] {sum .[0,1]Z!==a,b}}

试试吧

{!.grep: ->\a,\b=.[1] {sum .[0,1]Z!==a,b}}

试试吧

展开:

{
  !              # invert

  .grep:         # find any mismatches

  ->
    \a,
    \b = .[1]   # optional second parameter with default of second value from input
  {
    sum          # count up the values that don't match

    .[ 0, 1 ]    # the first two values from the input
    Z[![==]]     # zip not equal
    a, b         # the current two values under test.
  }
}

$_[1]可以比缩短一个字节.[1]。内部Lambda的主体可以比短1个字节{.[0]!=a||.[1]!=b}
smls,2016年

1
@smls我不知道为什么看不到.[1]!=如果它后面没有空格,则似乎也不起作用。我认为$_!=3正在解析某些内容,就像它被写为一样!( $_ = 3 )
Brad Gilbert b2gills

啊。看起来是Rakudo错误
smls


3

J,8个字节

-:$$2&{.

说明

-:$$2&{.  input: (y)
    2&{.  the first two elements of y
   $      shaped like
  $       the shape of y
-:        and check if they match

测试用例

   f =: -:$$2&{.
   ]true =: '' ; 1 ; 1 1 ; 1 2 1 ; 1 2 1 2 ; 10 5 10 5 10 ; 10 11 ; 9 9 9 9 9
++-+---+-----+-------+------------+-----+---------+
||1|1 1|1 2 1|1 2 1 2|10 5 10 5 10|10 11|9 9 9 9 9|
++-+---+-----+-------+------------+-----+---------+
   f each true
+-+-+-+-+-+-+-+-+
|1|1|1|1|1|1|1|1|
+-+-+-+-+-+-+-+-+
   ]false =: 5 4 3 5 4 3 ; 3 2 1 2 1 2 ; 1 2 1 2 1 1 2 ; 2 2 3 3 ; 2 3 3 2
+-----------+-----------+-------------+-------+-------+
|5 4 3 5 4 3|3 2 1 2 1 2|1 2 1 2 1 1 2|2 2 3 3|2 3 3 2|
+-----------+-----------+-------------+-------+-------+
   f each false
+-+-+-+-+-+
|0|0|0|0|0|
+-+-+-+-+-+

您应该可以将{.Take 替换为$Shape。
2015年


3

bash,56 54 38字节

[ -z $3 ]||((($1==$3))&&(shift;$0 $*))

将其保存为脚本,然后将数字列表作为参数传递(对于n元素列表,将传递n个参数)。输出为退出​​代码:如果列表是交替的,则为0(代表true),否则为1(代表false)。

(PPCG标准I / O方法允许以退出代码返回输出。)

这是递归的:

  • 如果列表中的元素少于3个,则以返回代码0退出;否则,返回0。
  • 否则,如果第一个元素!=第三个元素,则返回返回码1;
  • 否则,在删除第一个元素的情况下在列表上递归运行程序。

1

Python 2.7,38个字节

>> i=lambda a:(a[:2]*len(a))[0:len(a)]==a

测试用例:

>> print i([1,2,1,2])
>> True
>> print i([10,5,10,5,10]
>> True
>> print i([5,4,3,5,4,3])
>> False
>> print i([3,2,1,2,1,2])
>> False

2
我将此称为此答案的重复。
mbomb007 '16

1

Pyke,6字节,无竞争

2<Ql{q

在这里尝试!

2<     -   inp[:2]
    {  -  reshape(^, v)
  Ql   -   len(inp)
     q - ^ == inp

允许重塑节点获取列表以及字符串


1

深圳IO(汇编程序),83 76字节,无竞争

Shenio io是一款益智游戏,您可以在其中使用特殊的汇编语言编写代码。

不幸的是,您只能使用-999到999之间的整数作为输入或输出,并且无法判断数组是否已结束。因此,我认为该阵列写在一个ROM上,该ROM在读取最后一个单元格后便回绕了。这意味着只能使用偶数数组,这就是它无法竞争的原因。

码:

@mov x0 dat
@mov x0 acc
teq x0 dat
+teq x0 acc
b:
+mov 1 p1
-mov 0 p1
-jmp b

说明:

  # calling for x0 will cause rom to move 1 cell forward

 @ mov x0 dat # Moves value to variable dat (only run once)
 @ mov x0 acc # Moves rom position forward and moves x0 to acc           
  teq x0 dat  # See if dat equals x0  
+ teq x0 acc  # If last expression was true, see x0 equals acc
b:            # Label for jumps (GOTO)
+ mov 1 p1    # Set output (p1) to 1 (same case as previous line)
- mov 0 p1    # if any expression was false, set output to 0 
- jmp b       # jump to b: (same case as prev line)

抱歉,如果有任何混淆,这是我的第一个代码高尔夫球答案。

编辑:通过一次运行的代码替换循环删除了7个字节


欢迎来到PPCG!
FlipTack


1

红宝石,131个 119字节

a=->x{!(x.values_at(*x.each_index.select{|i|i.even?}).uniq)[1]&!(x.values_at(*x.each_index.select{|i|i.odd?}).uniq[1])}

Lambda a需要一个数组x,如果数组中的奇数索引元素有0或1个唯一值,而偶数索引元素有0或1个唯一值,则Lambda会返回true。

值得注意的字节安全

  • 使用lambda def
  • !arr[1]arr.length < 2
  • &&&

测试用例

p a[[]]
p a[[1]]
p a[[1,1]]
p a[[1,2,1]]
p a[[1,2,1,2]]
p a[[3,4,3]]
p a[[10,5,10,5,10]]
p a[[10,11]]
p a[[9,9,9,9,9]]

#false
p a[[5,4,3,5,4,3]]==false
p a[[3,2,1,2,1,2]]==false
p a[[1,2,1,2,1,1,2]]==false
p a[[2,2,3,3]]==false
p a[[2,3,3,2]]==false

1

Dart,46个字节

(l){var i=0;return l.every((x)=>x==l[i++%2]);}

运行:

void main() {
  var f = (l){var i=0;return l.every((x)=>x==l[i++%2]);};
  print(f([1,2,1,2,1]));
}

1

C#,54个字节

using System.Linq;p=>!p.Where((v,i)=>v!=p[i%2]).Any();

过滤数组以显示与偶数的第一个值和赔率的第二个值不匹配的值。如果没有任何结果,则返回true。



0

C#,66个字节

a=>{int r=1,i=0;for(;i<a.Length;)if(a[i]!=a[i++%2])r=0;return r;};

匿名函数,它接收一个整数数组,如果数组是交替的,则返回1,否则返回0。

具有完整功能和测试用例的完整程序:

using System;

public class Program
{
    public static void Main()
    {
        Func<int[], int> f =
        a =>
        {
            int r = 1,  // return value. 1 is true, by default
                i = 0;  // iterator
            for ( ; i<a.Length ; )  // for each array element
                if ( a[i] != a[i++%2] ) // if the even (or odd) elements are not the same
                    r = 0;      // a falsy (0) value will be assigned to the return element
            return r;       // returning if the array is alternating or not
        };

        // test cases:
        Console.WriteLine("Edge cases (all TRUE):");
        Console.WriteLine(f(new int[]{}));      //  True
        Console.WriteLine(f(new int[]{1}));     //  True
        Console.WriteLine(f(new int[]{1,1}));   //  True
        Console.WriteLine(f(new int[]{1,2,1})); //  True

        Console.WriteLine("Some other TRUE test cases:");
        Console.WriteLine(f(new int[]{1,2,1,2}));      // True
        Console.WriteLine(f(new int[]{10,5,10,5,10})); // True
        Console.WriteLine(f(new int[]{10,11}));        // True
        Console.WriteLine(f(new int[]{9,9,9,9,9}));    // True

        Console.WriteLine("Some FALSE test cases:");
        Console.WriteLine(f(new int[]{5,4,3,5,4,3}));   // False
        Console.WriteLine(f(new int[]{3,2,1,2,1,2}));   // False
        Console.WriteLine(f(new int[]{1,2,1,2,1,1,2})); // False
        Console.WriteLine(f(new int[]{2,2,3,3}));       // False
        Console.WriteLine(f(new int[]{2,3,3,2}));       // False
    }
}

0

八度,51字节

@(L)numel(L)<3||(f=@(n)isequal(L{n:2:end}))(1)&f(2)

输入是一个正整数的单元格数组。

在线尝试!


0

Clojure,70个字节

(fn[c](let[n #(max(count(set(take-nth 2 %)))1)](=(n c)(n(rest c))1))))

检查第二个项目的不重复计数是否为1,并处理空集合作为特殊情况。还尝试了许多方法reducegroup-by但没有很多运气。


0

R的另一种选择:36个字节。

all(rep_len(head(x,2),length(x))==x)

我想我找到了一个简短得多的版本:15个字节

all(!diff(x,2))
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.