将数字列表排序为奇数和偶数类别的最短程序

13

在《新近时代》中，查理·卓别林（Charlie Chaplin）遇到一台计算机时，他被雇用在分拣场中，作为检验员来确定工人是否正确地对物品进行分拣。有问题的物品是大理石包。大理石数为奇数的小包被堆叠在红色篮子中，大理石数为偶数的小包被堆叠在蓝色篮子中。

查理·卓别林（Charlie Chaplin）应该打孔程序，该程序将验证排序过程中是否存在任何异常。马克·斯温（Mack Swain）的直属上司分享了一种他需要编码的算法。

算法

L = List of Marble packets that's already sorted
L_ODD = List of packets with Odd Number of Marbles
L_EVEN = List of packets with Even Number of Marbles
Check_Digit = √(ΣL_ODD² + ΣL_EVEN²)

他的工作是确定Check_Digit，并将其与Boss计算的值相匹配。

查理·卓别林（Charlie Chaplin）在午餐时间可以偷偷溜到马克·斯温（Mack Swain）的抽屉里，确定他的抽屉在前46 32列上有一张带有打孔器的卡片（这意味着马克只能编写一个只有46 32个字符的程序）。

查理·卓别林（Charlie Chaplin）现在需要所有代码忍者的帮助，才能编写出尽可能少的行。如果有人能提出比他的老板短的程序，他还将宣布50分的奖励。

摘要

给定一个正数（奇数和偶数）的列表/数组/向量，您需要编写一个函数，该函数将接受array(int [])/vector<int>/list和计算列表中奇数和偶数之和的平方和的平方根。

程序的大小是函数主体的大小，即不包括函数签名的大小。

例

List = [20, 9, 4, 5, 5, 5, 15, 17, 20, 9]
Odd = [9, 5, 5, 5, 15, 17, 9]
Even = [20, 4, 20]
Check_Digit = √(ΣOdd² + ΣEven²) = 78.49203781276162

注意，实际输出可能会根据实现的浮点精度而有所不同。

得分了

得分计算为Σ(Characters in your Program) - 46。得分计算为Σ(Characters in your Program) - 32。除了来自社区的定期投票之外，最低的负面分数还将获得50点的额外奖励。

编辑

  1. 用于计算分数的偏移量已从46更改为32。请注意，这不会影响排行榜/赏金资格或使任何解决方案无效。

判决

在忍者之间激烈的决斗之后，卓别林先生得到了一些精彩的答案。不幸的是，很少有答案试图利用该规则的不当优势，并且不是很有用。他实际上希望进行公平的决斗，并回答在功能签名中编​​码逻辑的地方，这最终将意味着功能签名是解决方案不可或缺的一部分。最终，忍者萤火虫是明显的赢家，并授予他应有的奖金。 页首横幅（每天更新）

╒══════╤═════════════════╤══════════════╤═════════╤════════╤═══════╕
├ Rank │      Ninja      │   Dialect    │ Punches │ Scores │ Votes ┤
╞══════╪═════════════════╪══════════════╪═════════╪════════╪═══════╡
│  0   │     FireFly     │      J       │   17    │  -15   │   6   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  1   │     tmartin     │     Kona     │   22    │  -10   │   2   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  2   │ Sven Hohenstein │      R       │   24    │   -8   │   7   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  3   │    Ben Reich    │  GolfScript  │   30    │   -2   │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  4   │    mollmerx     │      k       │   31    │   -1   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  5   │ David Carraher  │ Mathematica  │   31    │   -1   │   3   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  6   │     tmartin     │      Q       │   34    │   2    │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  7   │     daniero     │      dc      │   35    │   3    │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  8   │    psion5mx     │    Python    │   38    │   6    │   2   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  9   │       O-I       │     Ruby     │   39    │   7    │   5   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  10  │      gggg       │    Julia     │   40    │   8    │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  11  │ FakeRainBrigand │  LiveScript  │   50    │   18   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  12  │    Sylwester    │    Perl5     │   50    │   18   │   2   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  13  │     daniero     │     Ruby     │   55    │   23   │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  14  │    vasuakeel    │ Coffeescript │   57    │   25   │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  15  │      dirkk      │    XQuery    │   63    │   31   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  16  │  crazedgremlin  │   Haskell    │   64    │   32   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  17  │   Uri Agassi    │     Ruby     │   66    │   34   │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  18  │     Sumedh      │     JAVA     │   67    │   35   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  19  │      Danny      │  Javascript  │   67    │   35   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  20  │     deroby      │      c#      │   69    │   37   │   1   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  21  │  Adam Speight   │      VB      │   70    │   38   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  22  │    Andrakis     │    Erlang    │   82    │   50   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  23  │      Sp0T       │     PHP      │   85    │   53   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  24  │    brendanb     │   Clojure    │   87    │   55   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  25  │  Merin Nakarmi  │      C#      │   174   │  142   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  26  │    Boopathi     │     JAVA     │   517   │  485   │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  27  │      Noyo       │     ES6      │    ?    │   ?    │   2   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  28  │     shiona      │   Haskell    │    ?    │   ?    │   0   │
├──────┼─────────────────┼──────────────┼─────────┼────────┼───────┤
│  29  │      Vivek      │     int      │    ?    │   ?    │   0   │
└──────┴─────────────────┴──────────────┴─────────┴────────┴───────┘
code-golf  sorting 
— 阿比吉特
source
8
为什么最低分数需要奖金，他们已经赢了？
— gggg 2014年
6
此外，偏移量46不会改变顺序。
— 霍华德
@gggg我认为他们的意思是他们会给得分最低的答案+50悬赏。
1
@gggg：实际上，只要允许我就会开始赏金。这就是奖金的意思。
— 阿披吉特（Abhijit）
1
噢，老鼠 在这里，我认为可以利用这些规则，在这里会得到聪明的回报。;]大家还是很有趣的问题，干得好！
— Noyo 2014年

Answers:

7

J，18 17个字符-32 =⁻15

[:+/&.:*:2&|+//.]

（作为“功能主体”；必须用括号括起来或与名称绑定。）

说明

我尝试对每件作品做一个分解图，就像Tobia在APL答案中所做的那样。

               +//. ]    NB. sum up partitions
           2&|           NB.   given by equality on (x mod 2)
        *:               NB. square,
   +/                    NB. sum,
     &.:                 NB. then revert the squaring (square-root)
                         NB. (f&.:g in general acts like g⁻¹(f(g(x))))
[:                       NB. (syntax to indicate composition of +/&.:*: and (2&| +//. ]))

+/&.:*:可以|@j./用OI的复杂幅度技巧来代替，以节省另外两个字符。

例

   f =: [:+/&.:*:2&|+//.]
   f 20 9 4 5 5 5 15 17 20 9
78.492
— 萤火虫
source
9

ES6，（ 48-32 ）= 16（1-32）= -31

原始版本：

f=l=>(e=o=0)+l.map(x=>x%2?e+=x:o+=x)&&Math.hypot(e,o)

整个函数定义为53个字符，仅主体为48个字符。

更新版本，充分利用了问题定义，将几乎所有内容都移出了正文并移入了签名：

f=(l,e=0,o=0,g=x=>x%2?e+=x:o+=x,c=l.map(g)&&Math.hypot(e,o))=>c

现在，新函数定义总计为63个“打孔”，但函数BODY现在仅为ONE DAMN CHARACTER LONG。而且它不再破坏全局名称空间！：D

用法：

>>> f([20, 9, 4, 5, 5, 5, 15, 17, 20, 9])
78.49203781276161
— 能野
source
...现在我觉得有点脏。：]
— Noyo 2014年
+1，因为您的状态更好，所以我删除了我的ES6解决方案：)
— Florent 2014年
哈哈谢谢。一旦操作员看到此规则，我们将查看规则是否已更改。.]
— Noyo 2014年
1
好吧，即使在接受答案并授予赏金之后，规则似乎也确实被隐式更改。那好吧！我仍然认为这是根据挑战规则得分最低的解决方案。：]
— Noyo
1
确实让我想起了一些c代码竞赛，人们将在预处理器中进行各种欺骗，使看似“简单”的函数返回非常复杂的东西。最终结果是偏离路线，编译耗时数小时，而实际执行会在不到一秒钟的时间内返回pi高达10万个数字（或类似的东西），因为结果几乎被硬编码到了二进制文件。无论如何，尽管我认为我们俩都知道你们都在作弊，但我会说“打得很好的先生” = P
— deroby 2014年
7

R，（24 − 32）= −8

f=function(x)
    sum(by(x,x%%2,sum)^2)^.5

功能主体由24个字符组成。

用法：

f(c(20, 9, 4, 5, 5, 5, 15, 17, 20, 9))
[1] 78.49204
— 斯文·霍恩斯坦
source
恩！您有与我刚才阐述的完全相同的解决方案！！sqrt(sum(by(x,x%%2,sum)^2))我只是还没有优化sqrt。...该死的：-) +1 :-) PS：有趣的by是，由于输出格式糟糕，一开始似乎是怎么出现的，但是当您运行sum它时，它是固定的;-)
— Tomas
@Tomas在此示例中，by返回一维数组。一个人不应该根据函数的结果来判断print.by函数。
— Sven Hohenstein
不，by不返回数组（顺便说一句，“数组”是什么意思？在R中没有。您可能表示向量），也不是向量。by返回class的对象by。
— Tomas
@Tomas有是在R.有无阵列看看?array。此外，is.array(by(1,1,I))return TRUE。
— Sven Hohenstein
6

Ruby 2.1+-（共39个字符-7个非body-32个偏移量= 0）

略有不同的方法。我创建一个复数a+b*i，使a和b分别是中的偶数和奇数之和list。然后，我只取绝对值。

f=->l{l.reduce{|s,x|s+x*1i**(x%2)}.abs}

我以前的解决方案，长了5个字符，但可以在1.9.3+上运行：

f=->l{l.reduce{|s,x|s+x*?i.to_c**(x%2)}.abs}

最后要说明的是，如果允许使用Rails + Ruby 2.1+，我们可以Array#sum将正文降至25个字符：

l.sum{|x|x+1i**(x%2)}.abs
— OI
source
非常聪明，我喜欢！这也会为我节省一些J字符。
— FireFly 2014年
谢谢@FireFly。你的很好。一定要学习J。干杯!
— OI 2014年
您只需要计算函数的主体数即可，我说的是37个字符。
— steenslag 2014年
感谢小费@steenslag。更新。我还使用新的Complex简写简化了另外5个字符。不过，仅适用于Ruby 2.1及更高版本。
— OI 2014年
5

Python 2.7：45，否：40，否：38-32 = 6

这里没有什么新鲜的东西，只是我在最近的毕达哥拉斯挑战中看到的复数技巧，lambda的紧凑性和语法/括号最小化的组合：

lambda x:abs(sum(a*(1-a%2+a%2*1j)for a in x))

更新-保存了几个字符。感谢@DSM提供了将复杂组件提高到0/1的技巧。

lambda x:abs(sum(a*1j**(a%2)for a in x))

好的，阅读问题并识别出“函数主体”计数规则可以节省另外两个字符：

def f(x):
    return abs(sum(a*1j**(a%2)for a in x))

iPython测试：

In [650]: x = [20, 9, 4, 5, 5, 5, 15, 17, 20, 9]

In [651]: print (lambda l:abs(sum(a*(1-a%2+a%2*1j)for a in l)))(x)
78.4920378128

...

In [31]: def f(x):
   ....:     return abs(sum(a*1j**(a%2)for a in x))
   ....:

In [32]: f(x)
Out[32]: 78.49203781276162
— psion5mx
source
真好！就像问题是完全针对abs复数建立的
— jozxyqk
4

APL（27-46 = -19）

{.5*⍨+/2*⍨+⌿⍵×[1]z,⍪~z←2|⍵}

例如：

      {.5*⍨+/2*⍨+⌿⍵×[1]z,⍪~z←2|⍵} 20 9 4 5 5 5 15 17 20 9
78.49203781
— 马里纳斯
source
4

Mathematica 31-32 = -1

√Tr[(Tr/@GatherBy[#,OddQ])²]//N &

GatherBy[#,OddQ] 产生偶数分组，奇数分组的列表。

内部Tr求和，将两者均平方，然后求和（由外部求和Tr）。

N 从无理数（整数的平方根）转换为十进制近似值。

例

√Tr[(Tr/@GatherBy[#,OddQ])²]//N &[{9, 5, 5, 5, 15, 17, 9, 20, 4, 20}]

78.492

如果f[n_]:=未包括在计数中，则可以保存其他字符。

    f[n_]:=
    √Tr[(Tr/@GatherBy[n,OddQ])²]//N

例

f[{9, 5, 5, 5, 15, 17, 9, 20, 4, 20}]

78.492

— 戴维
source
3

Perl5：（50-32 = 18）

map{$0[$_&1]+=$_}@ARGV;print sqrt$0[0]**2+$0[1]**2
— 西尔韦斯特
source
+1也许您可以使用say代替print和<>代替@ARGV（同时在STDIN而不是命令行上提供args）来节省一些字符
— Tomas
@Tomas不会使用sayrequire use吗？从参数数组切换到<>需要一个额外的split/ /,。
— Sylwester 2014年
1）不，可以从命令行启用功能。2）如果您每行提供这些数字，我想不需要拆分。
— Tomas
3

直流3（35-32）

使用@Tomas建议的数组。这样可以节省一些字符，因为我可以计算每个数字的奇偶校验并将其用作索引，而不必通过对奇偶校验进行微调来将其正确分支并放入正确的寄存器中。而且事实证明，即使未使用数组/索引，数组也会为您提供0，因此您不必初始化任何东西。

[d2%dsP;S+lP:Sz0<L]dsLx0;S2^1;S2^+v

假设数字已经在堆栈上，并且将结果保留为完成后剩下的唯一值。

测试：

$ dc  
20 9 4 5 5 5 15 17 20 9  
[d2%dsP;S+lP:Sz0<L]dsLx0;S2^1;S2^+v 
p
78

直流16（48-32）

使用寄存器o和e来存储奇数和偶数的第一个版本。

0dsose[dd2%rd1+2%*lo+so*le+sez0<x]dsxxle2^lo2^+v
— 达涅罗
source
1
+1使用直流。哈哈sose;-)也许您可以使用dc array命令获得较短的结果？
— Tomas
1
@Tomas多谢！出于某些愚蠢的原因，我首先放弃了使用数组的想法，但是在您提出建议后，我再次尝试了一下，结果证明它们非常有帮助！必须使用寄存器来临时存储奇偶校验，但是总的来说，我认为这是一种更为优雅的解决方案。
— daniero 2014年
不客气，我知道这会有所帮助:-)
— Tomas
2

Python，9（55-46）

lambda x:sum([sum([i*(d-i%2) for i in x])**2for d in(0,1)])**0.5

使用lambda函数可在换行符，制表符和上保存一些字节return。

例：

x = [20, 9, 4, 5, 5, 5, 15, 17, 20, 9]
print (lambda x:sum([sum([i*(d-i%2) for i in x])**2for d in(0,1)])**0.5)(x)
78.4920378128
— Flogo
source
2

红宝石（66-32 = 34）

f=->a{o,e=a.partition(&:odd?).map{|x|x.reduce(:+)**2};(e+o)**0.5}

测试：

f.([20, 9, 4, 5, 5, 5, 15, 17, 20, 9])
=> 78.49203781276162
— 乌里·阿加西（Uri Agassi）
source
1
Math.hypot *a.partition(&:odd?).map{|x|eval x*?+}
— 刮掉
2

红宝石，55-46 = 9

f=->a{h=[0,0];a.map{|v|h[v%2]+=v};e,o=h;(e*e+o*o)**0.5}

测试：

f[[20, 9, 4, 5, 5, 5, 15, 17, 20, 9]] => 78.49203781276162`
— 达涅罗
source
1
您可以使用以下数组h： f=->a{h=[0,0];a.map{|v|h[v%2]+=v};e,o=h;(e*e+o*o)**0.5}
— Neil Slater 2014年
@NeilSlater Doh！谢谢:)
— daniero 2014年
2

Q，34-32 = 2

{sqrt sum{x*x}(+/')(.)x(=)x mod 2}

。

q){sqrt sum{x*x}(+/')(.)x(=)x mod 2} 20 9 4 5 5 5 15 17 20 9
78.492037812761623
— 马丁
source
2

朱莉娅40-46 = -6

实作

function f(l)
    a=sum(l);b=sum(l[l%2 .==1]);hypot(a-b,b)
end

输出量

julia> f([20, 9, 4, 5, 5, 5, 15, 17, 20, 9])
78.49203781276161
— gggg
source
2

Coffeescript，（57-32 = 25）

实施方式

f=(a)->r=[0,0];r[e%2]+=e for e in a;[e,o]=r;(e*e+o*o)**.5
— 瓦苏阿达里
source
我不知道coffeescript，但是我想知道您是否可以删除之后的空格+=并更改0.5为.5
— user12205 2014年
2

高尔夫脚本30

.{2%},]{{+}*}/.@\-]{2?}/+2-1??

我认为GolfScript在这一方面没有太多机会！

— 本·赖希
source
2

c＃：69-32 = 37

double t=l.Sum(),o=l.Sum(x=>x*(x%2)),e=t-o;return Math.Sqrt(o*o+e*e);

完整代码：

class Program
{
    static void Main(string[] args)
    {
        int[] list = { 20, 9, 4, 5, 5, 5, 15, 17, 20, 9 };
        Console.WriteLine(F(list));
        Console.ReadKey();
    }

    static double F(int[] l)
    {
        double t = l.Sum(),  // total sum of all elements
               o = l.Sum(x => x * (x % 2)),  // total of odd elements, if even %2 will return zero
               e = t - o; // even = total - odd
        return Math.Sqrt(o * o + e * e);
    }        
}

PS：只是为了好玩，它也可以工作，可悲的是它并没有改变所需的字符数：

double t=l.Sum(),o=l.Sum(x=>x*(x%2));return Math.Sqrt(t*t-2*o*(t-o));
— 德罗比
source
2

序言（73-32 = 41）

在这里，我们将'：-'之后的所有内容都计为函数体。

f([],0,0,0).
f([H|T],O,E,X):-(1 is H mod 2,f(T,S,E,_),O is H+S,!;f(T,O,S,_),E is H+S),sqrt(O*O+E*E,X).

调用函数如下：

f([20, 9, 4, 5, 5, 5, 15, 17, 20, 9],_,_,X).
— mwcoomber
source
1

Matlab（44-46 = -2）

功能主体为44个字符：

C=mod(A,2)>0;O=(sum(A(C))^2+sum(A(~C))^2)^.5

总功能如下：

function O = Q(A)
C=mod(A,2)>0;O=(sum(A(C))^2+sum(A(~C))^2)^.5
end

功能测试：

>> A = [20 9 4 5 5 5 15 17 20 9];
>> Q(A)

O =

   78.4920


ans =

   78.4920

>> B = [8 3 24 1 9 8 4 5 52];
>> Q(B)

O =

   97.6729


ans =

   97.6729
— 病毒化
source
1

Python 2.7-64-46 = 18

使用一些zip魔术可以缩短时间，但现在：

(sum(s for s in x if s%2)**2+sum(s for s in x if s%2==0)**2)**.5

为了完成任务，事实证明您可以执行zip magic，但是要花更多的钱（减少几个字符），因此上面的说法是正确的，除非有人可以改善以下两个方面：

sum(map(lambda i:sum(i)**2,zip(*[[(0,i),(i,0)][i%2]for i in x])))**.5
1
您不需要sum（）内的[方括号]。
— daniero 2014年
1
我认为您可以通过在复杂的平面上工作来显着改善这一点，例如abs(sum(1j**(i%2)*i for i in x))。
— DSM 2014年
@DSM太疯狂了！我从来没想过这点。我无法对其进行太大的更改进行编辑，但是请做出并回答，以便我投票赞成！
@DSM：我脑子里有一个类似的版本，但是您更时尚
— Abhijit 2014年
Python接受!s%2吗？这至少是您可以接受的增量更改
— 并不是Charles
1

C＃174

using System;class P{static void Main(){double[] L={20,9,4,5,5,5,15,17,20,9};double O=0,E=0;foreach(int i in L){if(i%2==0)E+=i;else O+=i;}Console.Write(Math.Sqrt(E*E+O*O));}}

可读的

using System;
class P
{
  static void Main()
  {
      double[] L = { 20, 9, 4, 5, 5, 5, 15, 17, 20, 9 };
      double O = 0, E = 0;
      foreach (int i in L)
      {
        if (i % 2 == 0)
            E += i;
        else
            O += i;
      }
      Console.Write(Math.Sqrt(E * E + O * O));
   }
}

查理的输出

— 梅林·纳卡米
source
您根本没有打高尔夫球。我们正在努力寻找适合老板打孔卡的解决方案！
— 2014年
为什么不？请解释。
— Merin Nakarmi 2014年
2
您的代码完全缩进，到处都有空格。高尔夫代码就是要获得最少的角色数。这个问题被标记为code-golf。
— Riking
谢谢Riking。我编辑了 我的角色现在更少了。:)
— Merin Nakarmi
我认为该列表应作为输入提供，而不是硬编码。
— Timwi
1

Clojure = 87-46 = 41

(defn cd [v]
  (let [a apply ** #(* % %)]
    (Math/sqrt(a + (map #(** (a + (% 1)))(group-by even? v))))))

不过，这几乎不是习惯用法。

— 布伦丹
source
1

Haskell，64C-46 = 18

c x=sqrt$fromIntegral$s(f odd x)^2+s(f even x)^2
f=filter
s=sum

不太难读。示例运行：

*Main> c [1..10]
39.05124837953327
— 丹卡德
source
1

int e=0,o=0;for(int i :n){if(i%2==0)e+=i;else o+=i;}System.out.println(Math.sqrt(e*e+o*o));

Java代码中的实际方法

public static void checkDigit(int[] n)
{
    int e=0,o=0;for(int i :n){if(i%2==0)e+=i;else o+=i;}System.out.println(Math.sqrt(e*e+o*o));
}

测试班

public class Sint
{
    public static void main(String[] args)
    {
        if(args == null || args.length == 0)
            args = "20 9 4 5 5 5 15 17 20 9".split(" ");
        int[] n = null;
        try
        {
            n = new int[args.length];
            for(int i=0; i<args.length; i++)
                n[i] = Integer.parseInt(args[i]);
            System.out.print("int array is: ");
            for(int dd : n) System.out.print(dd+", ");
            System.out.print("\n");
            checkDigit(n);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    public static void checkDigit(int[] n)
    {
        int e=0,o=0;for(int i :n){if(i%2==0)e+=i;else o+=i;}System.out.println(Math.sqrt(e*e+o*o));
    }
}
— 维维克
source
1

PHP 85-32 = 53

$a=$b=0;foreach($x as $q){if(($q%2)==0)$a=$a+$q;else$b=$b+$q;}echo sqrt($a*$a+$b*$b);

这是我成为新手最好的选择。我确定也必须有一些较短的版本。

编辑：

代码的简化版本可以是：

foreach($x as$q)($q%2)?$a=$a+$q:$b=$b+$q;echo sqrt($a*$a+$b*$b);

此版本只有64个字符（比原始答案少21个字符）。

这样说，64-32 = 32

— Sp0T
source
独立完成，获得了58个基础：foreach($l as$m)$m%2?$o+=$m:$e+=$m;echo sqrt($o*$o+$e*$e);
— Yoda 2014年
1

VB.net（81c-11c = 70）-32 = 38

通过自由使用术语“ 编写函数”

Function(n)Math.Sqrt(n.Sum(Function(x)x Mod 2=0)^2+n.Sum(Function(x)x Mod 2=1)^2)
— 亚当·斯派特
source
1

XQuery，（63-32 = 31）

实作

declare default function namespace 'http://www.w3.org/2005/xpath-functions/math';
declare function local:f($s) {
  sqrt(pow(fn:sum($s[. mod 2=0]),2)+pow(fn:sum($s[. mod 2=1]),2))
};

输出量

local:f((20, 9, 4, 5, 5, 5, 15, 17, 20, 9))

BaseX被用作XQuery处理器。

— 恢复莫妮卡-DIRKK
source
1

Erlang：82C-32 = 50

fun(L)->F={lists,sum},O=[X||X<-L,X rem 2>0],E=F(L--O),math:sqrt(F(O)*F(O)+E*E)end.

Erlang对此不是很好。大多数快捷方式最终会包含更多字符（元组等）

唯一需要注意的真实内容：

  • {lists,sum}是对函数的引用lists:sum，可以调用
  • 通过从完整列表中减去--（列表减）奇数列表来计算偶数

可以使用以下方式致电：

fun(L)->F={lists,sum},O=[X||X<-L,X rem 2>0],E=F(L--O),math:sqrt(F(O)*F(O)+E*E)end([20,9,4,5,5,5,15,17,20,9]).

输出： 78.49203781276162

— 安德拉基斯
source
1

哈斯克尔

57-32 = 25

直接优化crazedgremlins答案：

c x=sqrt$read$show$sum(odd%x)^2+sum(even%x)^2
(%)=filter

优化：

  • read$show短于fromIntegral- 3个字符
  • s=sum\n并且两个s的总长度为8个字符，两个sum的仅为6个字符。- 2个字符
  • 将过滤器转换为运算符消除了空白的需要-2个字符

我还尝试向操作员添加更多内容，但结果却很长：

c x=sqrt$read$show$odd%x+even%x
(%)=(((^2).sum).).filter
— 筱娜
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.