相同元素之间的最大行程

24

这是一个检修现在这个问题被删除通过AR炕。如果该问题的OP希望重新提出该问题，或者我在发布此信息时遇到问题，我很乐意提供

给定一个整数列表作为输入，找到以相同值开始和结束的连续子列表的最大可能和。子列表的长度必须至少为2。例如，列表

[1, 2, -2, 4, 1, 4]

有2个不同的连续子列表，它们的开始和结束都具有相同的值

[1,2,-2,4,1] -> 6
[4,1,4]      -> 9

较大的总和是9，因此您输出9。

您可以假设每个输入至少包含1个重复项。

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

测试用例

[1,2,-2,4,1,4]  -> 9
[1,2,1,2]       -> 5
[-1,-2,-1,-2]   -> -4
[1,1,1,8,-1,8]  -> 15
[1,1,1,-1,6,-1] -> 4
[2,8,2,-3,2]    -> 12
[1,1,80]        -> 2
[2,8,2,3,2]     -> 17

code-golf number array-manipulation

— 小麦巫师
source

应该[2,8,2,3,2]是12还是17？我假定

— 17。– NikoNyrh

@NikoNyrh它应该是17

— 小麦向导

Hooray for CC BY / SA。您有权发布另一个问题的派生问题，即使稍后社区成员将其标记为欺骗。似乎您应该在我从此博客文章中获取到OP页面的链接。“ 3.显示每个问题的作者姓名并回答[...] 4.将每个作者姓名直接超链接到源站点上的用户个人资料页面” -我没有特权查看已删除的问题，所以我不知道不知道是谁制造的。

— Mindwin

@Mindwin谢谢，我已经添加了指向OP页面的链接。我最初将其省略，是因为我认为如果OP删除了他们的帖子，他们可能希望避免链接到该问题。

— 小麦巫师

删除的原因无关紧要，而且对普通用户（me）不透明。但是归因属于选择退出类型。通过提交并同意许可，他们在这些条件下授予了我们这些权利。外面的任何东西都是例外。GJ。

— Mindwin

Answers:

9

Haskell，62个字节

f 接受一个整数列表并返回一个整数。

f l=maximum[x+sum m-sum n|x:m<-t l,y:n<-t m,x==y]
t=scanr(:)[]

在线尝试！

怎么运行的

t是标准的“获取列表的所有后缀而不导入Data.List.tails”功能。
在中f l，列表解析遍历参数列表的所有非空后缀l，并带有第一个元素x和其余部分m。
对于每个，m选择第一个元素y和其余元素的所有非空后缀都相同n。
如果x和y相等，则列表推导包括它们之间元素的总和。此子列表x:m与其后缀n被删除的子列表相同，因此总和可以计算为x+sum m-sum n。

— ØrjanJohansen
source

8

JavaScript（ES6），68 62字节

a=>a.map(m=(x,i)=>a.map((y,j)=>m=j<=i||(x+=y)<m|y-a[i]?m:x))|m

测试用例

显示代码段

let f =

a=>a.map(m=(x,i)=>a.map((y,j)=>m=j<=i||(x+=y)<m|y-a[i]?m:x))|m

console.log(f([1,2,-2,4,1,4] )) // -> 9
console.log(f([1,2,1,2]      )) // -> 5
console.log(f([-1,-2,-1,-2]  )) // -> -4
console.log(f([1,1,1,8,-1,8] )) // -> 15
console.log(f([1,1,1,-1,6,-1])) // -> 4
console.log(f([2,8,2,-3,2]   )) // -> 12
console.log(f([1,1,80]       )) // -> 2

已评论

a =>                    // a = input array
  a.map(m =             // initialize m to a function (gives NaN in arithmetic operations)
    (x, i) =>           // for each entry x at position i in a:
    a.map((y, j) =>     //   for each entry y at position j in a:
      m =               //     update m:
        j <= i ||       //       if j is not after i
        (x += y) < m |  //       or the sum x, once updated, is less than m
        y - a[i] ?      //       or the current entry is not equal to the reference entry:
          m             //         let m unchanged
        :               //       else:
          x             //         update m to the current sum
    )                   //   end of inner map()
  ) | m                 // end of outer map(); return m

— Arnauld
source

我对- y - a[i]和(x += y) < mIMHO 的订购感到有些困惑，因为它们交换后的代码会更加清晰，因为从那时起，它看起来像一个简单的高尔夫球(x += y) < m || y != a[i]。

— 尼尔

@尼尔，我明白你的意思，但(x+=y)<m|y-a[i]也可能会被误解(x+=y)<(m|y-a[i])。我不确定这是否会消除歧义。（无论如何都进行了编辑，因为我倾向于此版本。）

— Arnauld

好吧，假设他们不会误解y-a[i]|(x+=y)<m为(y-a[i]|(x+=y))<m……

— Neil

5

果冻，12字节

ĠŒc€Ẏr/€ịḅ1Ṁ

在线尝试！

怎么运行的

ĠŒc€Ẏr/€ịḅ1Ṁ  Main link. Argument: A (array)

Ġ             Group the indices of A by their corresponding values.
 Œc€          Take all 2-combinations of grouped indices.
    Ẏ         Dumps all pairs into a single array.
     r/€      Reduce each pair by range, mapping [i, j] to [i, ..., j].
        ị     Index into A.
         ḅ1   Convert each resulting vector from base 1 to integer, effectively
              summing its coordinates.
           Ṁ  Take the maximum.

— 丹尼斯
source

5

外壳，10个字节

▲mΣfΓ~€;ṫQ

在线尝试！

说明

▲mΣfΓ~€;ṫQ  Input is a list, say x=[1,2,-2,4,1,4]
         Q  Slices: [[1],[2],[1,2],..,[1,2,-2,4,1,4]]
   f        Keep those that satisfy this:
    Γ        Deconstruct into head and tail, for example h=2 and t=[-2,4,1]
        ;    Wrap h: [2]
      ~€     Is it an element of
         ṫ   Tails of t: [[-2,4,1],[4,1],[1]]
            Result: [[1,2,-2,4,1],[4,1,4]]
 mΣ         Map sum: [6,9]
▲           Maximum: 9

— 兹加布
source

3

Haskell，66个字节

maximum.f
f(x:y)=[sum$x:take a y|(a,b)<-zip[1..]y,b==x]++f y
f x=x

在线尝试！

— 普维兹
source

3

[R ，108个 103 90 88 83字节

function(l)max(combn(seq(l),2,function(x)"if"(rev(p<-l[x[1]:x[2]])-p,-Inf,sum(p))))

在线尝试！

combn又罢工了！生成所有长度至少2为的子列表，将子列表总和设置为-Inf如果第一个和最后一个不相等，，并取所有总和的最大值。

该"if"会引发一堆警告，但他们是安全的忽略-这可能是最好的高尔夫技巧在这里，rev(p)-p是零的第一个元素IFF p[1]==tail(p,1)，并"if"使用其条件的第一个元素警告。

— 朱塞佩
source

3

Python 3，81个字节

lambda x,e=enumerate:max(sum(x[i:j+1])for i,a in e(x)for j,b in e(x)if(a==b)*j>i)

在线尝试！

— 丹尼斯
source

3

Python，62个字节

f=lambda l:l and max(f(l[1:]),[sum(l)]*(l.pop()in l[:1]),f(l))

在线尝试！

输出一个单例列表。

— 异或
source

2

果冻，13，12个字节

=ṚṖḢ
ẆÇÐfS€Ṁ

在线尝试！

目前正与我竞争的Xcoder先生保存了一个字节。：D

说明：

        # Helper link:
=Ṛ      # Compare each element of the list to the element on the opposite side (comparing the first and last)
  Ṗ     # Pop the last element of the resulting list (so that single elements return falsy)
   Ḣ    # Return the first element of this list (1 if the first and last are equal, 0 otherwise)

        # Main link:
Ẇ       # Return every sublist
 Ç      # Where the helper link
  Ðf    # Returns true (1)
    S€  # Sum each resulting list
      Ṁ # Return the max

— DJMcMayhem
source

2

Wolfram语言（Mathematica），54个字节

Max@SequenceCases[#,{a_,b___,a_}:>2a+b,Overlaps->All]&

在线尝试！

— 马丁·恩德
source

1

Pyth，15个字节

eSsMf&qhTeTtT.:

说明

eSsMf&qhTeTtT.:
             .:Q  Take all sublists of the (implicit) input.
    f qhTeT       Take the ones that start and end with the same number...
     &     tT     ... and have length at least 2.
  sM              Take the sum of each.
eS                Get the largest.

1

05AB1E，9个字节

ŒʒćsθQ}OZ

在线尝试！

说明

Œ          # push sublists of input
 ʒ    }    # filter, keep values where
  ć        # the head of the list, extracted
     Q     # is equal to
   sθ      # the last element of the rest of the list
       O   # sum the resulting sublists
        Z  # get the max

— 艾米尼亚
source

1

干净，94个 90 86个字节

import StdEnv,StdLib
@l=last(sort[sum(l%(i,j))\\e<-l&i<-[0..],j<-elemIndices e l|j>i])

在线尝试！

— 巨大
source

恐怕在[1, 1, 80]测试用例中这将失败。

— 与Orjan约翰森

@ØrjanJohansen修复了它

— 很有可能

1

Python 2，86个字节

丹尼斯超越

lambda x:max(sum(x[i:j+1])for i,v in enumerate(x)for j in range(i+1,len(x))if v==x[j])

在线尝试！

生成所有大于长度2的子列表，其中第一个元素等于最后一个元素，然后将每个子列表映射到其总和并选择最大值。

— FlipTack
source

使用Lambda函数的88个字节

— Halvard Hummel，

@HalvardHummel 使用86个字节enumerate。

— 乔纳森·弗雷希

丹尼斯（Dennis）出乎意料 –老实说，您期望什么？

— Xcoder先生18年

@ Mr.Xcoder我会得到他的解决方案，但是我睡着了:(

— FlipTack

1

红宝石，64字节

->l{w,*r=0;(z=l.index w)&&r<<w+l[z..-1].sum while w=l.pop;r.max}

在线尝试！

— 国标
source

1

朱莉娅0.6字节

a->maximum(sum(a[i:k]) for b=[findin(a,x) for x=a] for i=b,k=b if k>i)

在线尝试！

— gggg
source

1

果冻，11字节

使用挑战后更新的某些功能。

Ẇµ.ịEȧḊµƇ§Ṁ

在线尝试！

怎么运行的？

ịµ.ịEȧḊµƇ§Ṁ || 完整程序。从CLA获取输入，输出到STDOUT。
Ẇ|| 子列表。
 µ µƇ || 过滤保留这些
    ȧḊ|| ...长度至少为2并且...
 .ị|| ...位于floor（0.5）和ceil（0.5）上的元素（模块化，1索引）...
    E || ……相等。
         §|| 每个加起来。
          Ṁ|| 最大。

-1在caird的帮助下。

— Xcoder先生
source

0

批次，179个字节

@set s=%*
@set/a"m=-1<<30
:l
@set/at=n=%s: =,%
@set s=%s:* =%
@for %%e in (%s%)do @set/at+=%%e&if %%e==%n% set/a"m+=(m-t)*(m-t>>31)
@if not "%s%"=="%s: =%" goto l
@echo %m%

将输入作为命令行参数。

— 尼尔
source

0

C，104字节

i,j,s,l;f(a,n)int*a;{for(i=0,l=1<<31;i<n;++i)for(s=a[j=i];++j<n;l=a[j]-a[i]?l:s>l?s:l)s+=a[j];return l;}

在线尝试！

C（gcc），99字节

i,j,s,l;f(a,n)int*a;{for(i=0,l=1<<31;i<n;++i)for(s=a[j=i];++j<n;l=a[j]-a[i]?l:s>l?s:l)s+=a[j];l=l;}

在线尝试！

— 稳定箱
source

99个字节，如果您喜欢未定义的行为。

— 乔纳森·弗雷希

0

Clojure，92个字节

#(apply max(for[i(range(count %))j(range i):when(=(% i)(% j))](apply +(subvec % j(inc i)))))

— 尼古妮
source

0

Java 8，129再见

a->a.stream().map(b->a.subList(a.indexOf(b),a.lastIndexOf(b)+1).stream().mapToLong(Long::intValue).sum()).reduce(Long::max).get()

对于X列表中的每个整数，函数将查找具有start和end的最大子列表的和X。然后，它找到OP指定的最大和。

— 马里奥·伊沙克（Mario Ishac）
source

我还没有测试过，但是在我看来，它可能无法通过[2,8,2,-3,2]测试用例，也有可能失败[1,1,80]。

— 与Orjan约翰森

0

Perl，61 59字节

包括+3为-p：

max_ident_run.pl：

#!/usr/bin/perl -p
s:\S+:$%=$&;($%+=$_)<($\//$%)||$_-$&or$\=$%for<$' >:eg}{

运行方式：

max_ident_run.pl <<< "1 2 -2 4 1 4 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.