Trong Thời hiện đại mới , khi Charlie Chaplin bắt gặp một chiếc máy tính, anh ta được thuê trong Xưởng phân loại, làm người xác nhận để xác định xem các công nhân có sắp xếp chính xác các mặt hàng hay không. Các mục trong câu hỏi là các gói bi. Các gói có số lượng viên bi lẻ được xếp chồng lên nhau trong Giỏ màu đỏ và Gói có số lượng viên bi được xếp chồng lên nhau trong Giỏ màu xanh.

Charlie Chaplin là nghĩa vụ phải đấm chương trình đó sẽ xác nhận nếu có bất kỳ sự bất thường trong quá trình sắp xếp. Mack Swain, ông chủ trực tiếp của mình, chia sẻ một thuật toán mà anh ta cần viết mã.

Thuật toán

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²)

Công việc của anh ta là xác định Check_Digit và khớp với giá trị mà ông chủ của anh ta tính toán.

Charlie Chaplin trong giờ ăn trưa, đã có thể lẻn vào ngăn kéo của Mack Swain và xác định, rằng ngăn kéo của anh ta có một lá bài với những cú đấm vào 46 32 cột đầu tiên (có nghĩa là Mack có thể viết một chương trình chỉ với 46 32 ký tự).

Charlie Chaplin bây giờ sẽ cần sự giúp đỡ của tất cả các ninja mã để viết một chương trình với càng ít dòng càng tốt. Anh ta cũng công bố tiền thưởng 50 điểm, nếu ai đó có thể đưa ra một chương trình ngắn hơn Boss của anh ta.

Tóm lược

Đưa ra một danh sách / mảng / vectơ của các số dương (lẻ và chẵn), bạn cần viết một hàm, nó sẽ chấp nhận array(int [])/vector<int>/listvà tính gốc của tổng bình phương của tổng các số lẻ và chẵn trong danh sách.

Kích thước của chương trình là kích thước của phần thân của hàm, tức là không bao gồm kích thước của chữ ký hàm.

Thí dụ

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

Lưu ý , đầu ra thực tế có thể thay đổi dựa trên độ chính xác của dấu phẩy động của triển khai.

Ghi bàn

Điểm được tính như Σ(Characters in your Program) - 46. Điểm được tính như Σ(Characters in your Program) - 32. Ngoài việc nâng cấp thường xuyên từ cộng đồng, điểm âm thấp nhất sẽ nhận được thêm 50 điểm thưởng.

Biên tập

1. Phần bù được sử dụng để tính Điểm đã được thay đổi từ 46 thành 32. Lưu ý, điều này sẽ không ảnh hưởng đến tính đủ điều kiện của ban lãnh đạo / tiền thưởng hoặc làm mất hiệu lực bất kỳ giải pháp nào.

Bản án

Sau cuộc đấu tay đôi khủng khiếp giữa các Ninjas, ông Chaplin đã nhận được một số câu trả lời tuyệt vời. Thật không may, một số câu trả lời đã cố gắng tận dụng lợi thế của quy tắc và không hữu ích lắm. Anh ta thực sự muốn có một cuộc đấu tay đôi công bằng và câu trả lời trong đó logic được mã hóa trong chữ ký hàm cuối cùng có nghĩa là chữ ký hàm là một phần không thể thiếu của giải pháp. Cuối cùng, Ninja FireFly là người chiến thắng rõ ràng và trao cho anh phần thưởng mà anh xứng đáng nhận được. Bảng xếp hạng (cập nhật mỗi ngày)

╒══════╤═════════════════╤══════════════╤═════════╤════════╤═══════╕
├ 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   │
└──────┴─────────────────┴──────────────┴─────────┴────────┴───────┘

J, 18 17 ký tự - 32 = ⁻15

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

(Là một "cơ quan chức năng"; phải được ngoặc đơn hoặc ràng buộc với một tên.)

Giải trình

Tôi đã cố gắng tạo ra một cái nhìn bùng nổ về những gì mỗi tác phẩm làm, giống như Tobia làm trong các câu trả lời của 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&| +//. ]))

+/&.:*:có thể được thay thế bằng |@j./cách sử dụng thủ thuật cường độ phức tạp của OI để cứu thêm hai nhân vật nữa.

Thí dụ

   f =: [:+/&.:*:2&|+//.]
   f 20 9 4 5 5 5 15 17 20 9
78.492

ES6, (48 - 32) = 16 (1 - 32) = -31

Phiên bản gốc:

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

Toàn bộ định nghĩa hàm là 53 ký tự, chỉ thân là 48.

Phiên bản cập nhật, tận dụng tối đa định nghĩa vấn đề và di chuyển khá nhiều thứ ra khỏi cơ thể và vào chữ ký:

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

Định nghĩa hàm mới hiện có tổng cộng 63 "cú đấm", nhưng chức năng BODY giờ chỉ là MỘT ĐẶC ĐIỂM DAMN. Thêm vào đó, nó không còn làm hỏng không gian tên toàn cầu! : D

Sử dụng:

>>> f([20, 9, 4, 5, 5, 5, 15, 17, 20, 9])
78.49203781276161

R, (24 - 32) = 8

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

Phần thân hàm gồm 24 ký tự.

Sử dụng:

f(c(20, 9, 4, 5, 5, 5, 15, 17, 20, 9))
[1] 78.49204

Ruby 2.1+ - (tổng cộng 39 ký tự - 7 phi thân - 32 offset = 0)

Cách tiếp cận hơi khác nhau. Tôi tạo một số phức a+b*isao cho avà blà tổng của số chẵn và số lẻ listtương ứng. Sau đó, tôi chỉ lấy giá trị tuyệt đối.

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

Giải pháp trước đây của tôi, dài hơn 5 ký tự nhưng hoạt động trên 1.9.3+:

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

Ở một lưu ý cuối cùng, nếu Rails + Ruby 2.1+ được cho phép, chúng ta có thể sử dụng Array#sumđể đưa phần thân xuống chỉ còn 25 ký tự:

l.sum{|x|x+1i**(x%2)}.abs

Python 2.7: 45, nay: 40, nay: 38 - 32 = 6

Không có gì mới ở đây, chỉ là sự kết hợp của thủ thuật số phức mà tôi đã thấy trong thử thách Pythagoras gần đây, lambda về tính gọn nhẹ và tối thiểu hóa cú pháp / dấu ngoặc đơn:

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

Cập nhật - lưu một vài ký tự. Cảm ơn @DSM về thủ thuật nâng thành phần phức tạp lên 0/1.

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

Ok, đọc câu hỏi và nhận ra quy tắc đếm 'phần thân của hàm' sẽ lưu 2 ký tự khác:

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

Kiểm tra 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

APL (27 - 46 = -19)

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

ví dụ:

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

Toán học 31-32 = -1

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

GatherBy[#,OddQ] tạo ra các danh sách gói chẵn, lẻ.

Bên trong Tr tìm thấy các tổng, cả hai đều được bình phương và sau đó được tổng (bằng bên ngoài Tr).

N chuyển đổi từ một số vô tỷ (căn bậc hai của một số nguyên) thành một xấp xỉ thập phân.

Thí dụ

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

78.492

Nếu f[n_]:=không được tính vào số lượng, một ký tự bổ sung có thể được lưu.

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

Thí dụ

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

78.492

Kona, 22 - 32 = -10

{(+/(+/'x@=x!2)^2)^.5}

Perl5: (50 - 32 = 18)

map{$0[$_&1]+=$_}@ARGV;print sqrt$0[0]**2+$0[1]**2

đc 3 (35 - 32)

Sử dụng mảng, theo đề xuất của @Tomas. Điều này tiết kiệm một số ký tự vì tôi có thể tính chẵn lẻ của mỗi số và sử dụng nó làm chỉ số, thay vì điều chỉnh tính chẵn lẻ như một phương pháp phân nhánh và đặt các giá trị đúng vào các thanh ghi bên phải. Ngoài ra, hóa ra các mảng sẽ cho bạn 0 ngay cả khi mảng / chỉ mục chưa được sử dụng, vì vậy bạn không phải khởi tạo bất cứ thứ gì.

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

Giả sử các số đã có trên ngăn xếp và để lại kết quả là giá trị duy nhất còn lại khi hoàn thành.

Kiểm tra:

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

đc 16 (48 - 32)

Phiên bản đầu tiên sử dụng các thanh ghi o và e để lưu các số lẻ và chẵn.

0dsose[dd2%rd1+2%*lo+so*le+sez0<x]dsxxle2^lo2^+v

Con trăn, 9 (55 - 46)

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

Sử dụng hàm lambda sẽ lưu một số byte trên dòng mới, tab và return.

Thí dụ:

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

Hồng ngọc (66 - 32 = 34)

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

kiểm tra:

f.([20, 9, 4, 5, 5, 5, 15, 17, 20, 9])
=> 78.49203781276162 

Hồng ngọc, 55 - 46 = 9

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

Kiểm tra:

f[[20, 9, 4, 5, 5, 5, 15, 17, 20, 9]] => 78.49203781276162`

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

Julia, 40-46 = -6

Thực hiện

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

Đầu ra

julia> f([20, 9, 4, 5, 5, 5, 15, 17, 20, 9])
78.49203781276161

Bản thảo, (57 - 32 = 25)

Triển khai

f=(a)->r=[0,0];r[e%2]+=e for e in a;[e,o]=r;(e*e+o*o)**.5

GolfScript 30

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

Tôi không nghĩ GolfScript có nhiều cơ hội cho cái này!

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);

Mã đầy đủ:

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);
    }        
}

Tái bút: Để giải trí, điều này cũng hoạt động, thật đáng buồn là nó không thay đổi số lượng ký tự cần thiết:

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

Prolog (73 - 32 = 41)

Ở đây chúng ta đếm mọi thứ sau ': -' là thân hàm.

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).

Chức năng gọi như vậy:

f([20, 9, 4, 5, 5, 5, 15, 17, 20, 9],_,_,X).

Matlab (44 - 46 = -2)

Cơ thể chức năng là 44 ký tự:

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

Tổng số chức năng như sau:

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

Các thử nghiệm của chức năng:

>> 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

Con trăn 2.7 - 64-46 = 18

Điều này có thể ngắn hơn bằng cách sử dụng một số zipphép thuật, nhưng bây giờ:

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

Để hoàn thành, hóa ra bạn có thể thực hiện phép thuật zip, nhưng nó tốn kém hơn (bằng một vài ký tự), vì vậy, các giá trị trên, trừ khi ai đó có thể cải thiện một trong hai điều sau:

sum(map(lambda i:sum(i)**2,zip(*[[(0,i),(i,0)][i%2]for i in x])))**.5

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));}}

Có thể đọc được

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));
   }
}

Clojure = 87 - 46 = 41

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

Mặc dù khó thành ngữ.

Haskell, 64C - 46 = 18

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

Không quá khó đọc. Chạy ví dụ:

*Main> c [1..10]
39.05124837953327

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));

Phương thức thực tế trong mã 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));
}

Lớp kiểm tra

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));
    }
}

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);

Đây là điều tốt nhất tôi trở thành người mới. Tôi chắc chắn phải có một số phiên bản ngắn hơn là tốt.

BIÊN TẬP:

Một phiên bản rút gọn của mã có thể là:

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

Phiên bản này chỉ có 64 (21 ít hơn câu trả lời ban đầu).

Nói như vậy, 64-32 = 32

VB.net (81c - 11c = 70) - 32 = 38

Thông qua việc sử dụng tự do của thuật ngữ Viết một hàm

Function(n)Math.Sqrt(n.Sum(Function(x)x Mod 2=0)^2+n.Sum(Function(x)x Mod 2=1)^2)

XQuery, (63 - 32 = 31)

Thực hiện

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))
};

Đầu ra

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

BaseX đã được sử dụng làm bộ xử lý XQuery.

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 không tuyệt vời cho việc này. Hầu hết các phím tắt kết thúc là nhiều ký tự hơn (bộ dữ liệu, v.v.)

Những điều thực sự duy nhất cần lưu ý:

• {lists,sum} là một tham chiếu chức năng để lists:sum và có thể được gọi
• Các số chẵn được tính bằng cách trừ --( trừ danh sách ) danh sách số lẻ từ danh sách đầy đủ

Có thể gọi bằng cách sử dụng:

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]).

Đầu ra: 78.49203781276162

Haskell

57 - 32 = 25

Tối ưu hóa thẳng của crazinggremlins trả lời:

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

Tối ưu hóa:

• read$showngắn hơn fromIntegral- 3 ký tự
• s=sum\nvà hai s's có tổng chiều dài 8 ký tự, hai sum' chỉ là 6 ký tự. - 2 ký tự
• làm cho bộ lọc thành toán tử không cần khoảng trắng - 2 ký tự

Tôi cũng đã thử thêm nhiều thứ vào toán tử, nhưng cuối cùng nó cũng dài như sau:

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