ใน New Modern Timesเมื่อชาร์ลีแชปลินได้พบกับคอมพิวเตอร์เขาเป็นลูกจ้างในการเรียงลำดับลานขณะที่ตรวจสอบเพื่อตรวจสอบว่าคนงานจะได้อย่างถูกต้องเรียงลำดับรายการ รายการที่มีปัญหาคือแพ็คเก็ตของหินอ่อน แพ็คเก็ตที่มีจำนวนของ Marbles จะถูกเรียงซ้อนในตะกร้าสีแดงและแพ็คเก็ตที่มีจำนวนของ Marbles จะซ้อนกันในตะกร้าสีน้ำเงิน

Charlie Chaplin ควรชกโปรแกรมที่จะตรวจสอบว่ามีความผิดปกติใด ๆ ในขั้นตอนการเรียงลำดับ Mack Swain Boss ทันทีของเขาแบ่งปันอัลกอริทึมที่ต้องการรหัส

ขั้นตอนวิธี

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 และจับคู่กับค่าที่เจ้านายของเขาคำนวณ

ชาร์ลีแชปลินในช่วงเวลาอาหารกลางวันของเขาสามารถแอบเข้าไปในลิ้นชักของแม็คสเวนได้และพบว่าลิ้นชักของเขามีการ์ดใบเดียวที่มีหมัดต่อ46 46คอลัมน์แรก(ซึ่งหมายความว่าแม็คสามารถเขียนโปรแกรมได้เพียง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คะแนนจะถูกคำนวณเป็น นอกเหนือจากการ upvoting ปกติจากชุมชนคะแนนลบต่ำสุดจะได้รับโบนัสเพิ่มเติม 50 คะแนน

แก้ไข

1. ออฟเซ็ตที่ใช้ในการคำนวณคะแนนได้เปลี่ยนจาก 46 เป็น 32 หมายเหตุสิ่งนี้จะไม่ส่งผลกระทบต่อสิทธิ์ของผู้นำบอร์ด / รางวัลหรือการแก้ปัญหาใด ๆ

คำตัดสิน

หลังจากการต่อสู้ที่น่าสยดสยองระหว่าง Ninjas มิสเตอร์แชปลินได้รับคำตอบที่ยอดเยี่ยม น่าเสียดายที่บางคำตอบพยายามใช้ประโยชน์จากกฎอย่างไม่เหมาะสมและไม่มีประโยชน์มากนัก จริง ๆ แล้วเขาต้องการการต่อสู้ที่ยุติธรรมและคำตอบที่ตรรกะถูกเข้ารหัสภายในฟังก์ชันลายเซ็นในที่สุดก็หมายความว่าลายเซ็นของฟังก์ชั่นเป็นส่วนหนึ่งของการแก้ปัญหา ในที่สุด Ninja FireFly เป็นผู้ชนะที่ชัดเจนและมอบโบนัสที่เขาสมควรได้รับแก่เขา กระดานผู้นำ (อัปเดตทุกวัน)

╒══════╤═════════════════╤══════════════╤═════════╤════════╤═══════╕
├ 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 ตัวอักษร - 32 = ⁻15

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

(ในฐานะ "ฟังก์ชันเนื้อหา" จะต้องวงเล็บหรือผูกกับชื่อ)

คำอธิบาย

ฉันพยายามทำให้มุมมองที่ระเบิดของแต่ละชิ้นทำเหมือนที่โทเบียทำในคำตอบของ 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

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 "punches" ทั้งหมด แต่ฟังก์ชั่น BODY ตอนนี้เป็นเพียงตัวละครแช่งยาวหนึ่งตัว และจะไม่ทำลายเนมสเปซส่วนกลางอีกต่อไป : D

การใช้งาน:

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

ร่างกายของฟังก์ชั่นประกอบด้วย 24 ตัวอักษร

การใช้งาน:

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

Ruby 2.1+ - (รวม 39 ตัวอักษร - 7 ตัว - 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

Python 2.7: 45, เปล่า: 40, ไม่: 38 - 32 = 6

ไม่มีอะไรใหม่มากที่นี่เพียงแค่การผสมผสานของจำนวนเชิงซ้อนที่ฉันเห็นในการท้าทาย Pythagoras เมื่อเร็ว ๆ นี้แลมบ์ดาเพื่อความกะทัดรัดและการย่อขนาดไวยากรณ์ / วงเล็บ:

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

ตกลงอ่านคำถามและตระหนักถึงกฎการนับ 'เนื้อหาของฟังก์ชัน' จะบันทึกอีก 2 ตัวอักษร:

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

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

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

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

dc 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

dc 16 (48 - 32)

เวอร์ชันแรกที่ใช้รีจิสเตอร์oและeเพื่อเก็บตัวเลขคี่และคู่

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

Python 9 (55 - 46)

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

การใช้ฟังก์ชั่นแลมบ์ดาช่วยประหยัดไบต์บางอย่างเกี่ยวกับการขึ้นบรรทัดใหม่, 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

ทับทิม (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 

Ruby, 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`

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

การดำเนินงาน

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

Coffeescript, (57 - 32 = 25)

implementaion

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

ฉันไม่คิดว่า GolfScript มีโอกาสมากมายในอันนี้!

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

อารัมภบท (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).

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

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 ได้ แต่จะทำให้คุณเสียค่าใช้จ่ายมากขึ้น (โดยตัวละครไม่กี่ตัว) ดังนั้นสิ่งที่กล่าวมาข้างต้นนั้นจะมีความหมาย

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

อ่านง่าย

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

ถึงแม้ว่าจะไม่ค่อยมีสำนวน

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

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

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

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)

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

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.

เออร์แลงไม่ดีสำหรับเรื่องนี้ ทางลัดส่วนใหญ่จบลงด้วยการมีตัวอักษรมากขึ้น (tuples ฯลฯ )

สิ่งที่บันทึกจริงเท่านั้น:

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

Haskell

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