In der Neuen Moderne wird Charlie Chaplin, wenn er auf einen Computer stößt, im Sortierhof als Prüfer eingesetzt, um festzustellen, ob die Arbeiter die Gegenstände richtig sortieren. Bei den fraglichen Gegenständen handelt es sich um Murmelpakete. Pakete mit einer ungeraden Anzahl von Murmeln werden im roten Korb und Pakete mit einer geraden Anzahl von Murmeln im blauen Korb gestapelt.

Charlie Chaplin soll das Programm lochen , das überprüft, ob eine Anomalie im Sortiervorgang vorliegt. Mack Swain, sein direkter Chef, teilt einen Algorithmus, den er zum Codieren benötigt.

Algorithmus

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

Seine Aufgabe ist es, die Check_Digit zu bestimmen und mit dem Wert abzugleichen, den sein Chef berechnet.

Charlie Chaplin konnte sich während seiner Mittagspause an Mack Swains Schublade schleichen und feststellen, dass seine Schublade eine einzige Karte mit Stempeln in den ersten 46 32 Spalten enthält (was bedeutet, dass Mack ein Programm mit nur 46 32 Zeichen schreiben konnte ).

Charlie Chaplin würde jetzt die Hilfe aller Code-Ninjas benötigen, um ein Programm mit möglichst wenigen Zeilen zu schreiben. Er kündigt auch einen Bonus von 50 Punkten an, wenn jemand ein Programm entwickeln kann, das kürzer ist als sein Chef.

Zusammenfassung

Wenn Sie eine Liste / ein Array / einen Vektor positiver Zahlen (ungerade und gerade) haben, müssen Sie eine Funktion schreiben, die array(int [])/vector<int>/listdie Wurzel der Summe der Quadrate der Summen ungerader und gerader Zahlen in der Liste akzeptiert und berechnet.

Die Größe des Programms ist die Größe des Hauptteils der Funktion, dh ohne die Größe der Funktionssignatur.

Beispiel

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

Beachten Sie , dass die tatsächliche Ausgabe abhängig von der Gleitkommapräzision der Implementierung variieren kann.

Ergebnis

Punktzahl wird berechnet als Σ(Characters in your Program) - 46. Punktzahl wird berechnet als Σ(Characters in your Program) - 32. Abgesehen von den regelmäßigen Abstimmungen der Community, würde die niedrigste negative Punktzahl einen zusätzlichen Bonus von 50 Punkten erhalten.

Bearbeiten

1. Der Versatz, der zum Berechnen des Ergebnisses verwendet wurde, wurde von 46 auf 32 geändert. Beachten Sie, dass dies keine Auswirkung auf die Ranglisten- / Kopfgeldberechtigung hat oder eine Lösung ungültig macht.

Urteil

Nach einem grausamen Duell zwischen den Ninjas erhielt Herr Chaplin einige wundervolle Antworten. Leider versuchten nur wenige Antworten, die Regel unangemessen auszunutzen, und waren nicht sehr nützlich. Eigentlich wollte er ein faires Duell und Antworten, bei denen die Logik innerhalb der Funktionssignaturen kodiert wurde, würden schließlich bedeuten, dass die Funktionssignatur ein integraler Bestandteil der Lösung ist. Schließlich war Ninja FireFly der klare Gewinner und verlieh ihm den Bonus, den er verdient hat. Leaderboard (täglich aktualisiert)

╒══════╤═════════════════╤══════════════╤═════════╤════════╤═══════╕
├ 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 Zeichen - 32 = ⁻15

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

(Als "Funktionskörper"; muss in Klammern oder an einen Namen gebunden sein.)

Erläuterung

Ich habe versucht, eine Explosionsdarstellung zu machen, wie Tobia es in APL-Antworten tut.

               +//. ]    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&| +//. ]))

+/&.:*:könnte durch |@j./die Verwendung des komplexen Betrags-Tricks von OI ersetzt werden , um noch zwei weitere Zeichen zu speichern.

Beispiel

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

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

Originalfassung:

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

Die gesamte Funktionsdefinition umfasst 53 Zeichen, der Body nur 48.

Aktualisierte Version, die die Problemdefinition voll ausnutzt und so ziemlich alles aus dem Körper in die Signatur verschiebt:

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

Die neue Funktionsdefinition umfasst jetzt insgesamt 63 "Schläge", aber die Funktion KÖRPER ist jetzt nur EIN VERDAMMTES ZEICHEN LANG. Außerdem wird der globale Namespace nicht mehr beschädigt! : D

Verwendung:

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

Der Funktionskörper besteht aus 24 Zeichen.

Verwendung:

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

Ruby 2.1+ - (39 Zeichen insgesamt - 7 Nichtkörper - 32 Offset = 0)

Etwas andere Herangehensweise. Ich erstelle eine komplexe Zahl a+b*iso, dass aund bdie Summe der geraden und ungeraden Zahlen in listist. Dann nehme ich einfach den absoluten Wert.

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

Meine vorherige Lösung, die 5 Zeichen länger ist, aber mit 1.9.3+ funktioniert:

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

Wenn Rails + Ruby 2.1+ erlaubt wäre, könnten wir Array#sumden Body auf nur 25 Zeichen reduzieren:

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

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

Nichts sehr Neues, nur eine Kombination aus dem komplexen Zahlentrick, den ich in der letzten Pythagoras-Herausforderung gesehen habe, Lambda für Kompaktheit und Syntax- / Klammer-Minimierung:

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

Update - speicherte ein paar Zeichen. Vielen Dank an @DSM für den Trick, die komplexe Komponente auf 0/1 zu erhöhen.

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

Ok, das Lesen der Frage und das Erkennen der Zählregel 'body of the function' spart weitere 2 Zeichen:

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

iPython-Test:

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

z.B:

      {.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] Erzeugt die geraden und ungeraden Paketlisten.

Das Innere ermittelt Trdie Summen, die beide quadriert und dann (vom Äußeren Tr) aufsummiert werden .

N konvertiert von einer irrationalen Zahl (der Quadratwurzel einer ganzen Zahl) in eine dezimale Approximation.

Beispiel

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

78,492

Ist dies f[n_]:=nicht der Fall, kann ein zusätzliches Zeichen gespeichert werden.

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

Beispiel

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)

Verwenden von Arrays, wie von @Tomas vorgeschlagen. Dies spart einige Zeichen, da ich die Parität jeder Zahl berechnen und als Index verwenden kann, anstatt die Parität mit zu ändern, um die richtigen Werte zu verzweigen und in die richtigen Register zu schreiben. Es stellt sich auch heraus, dass Arrays eine 0 ergeben, auch wenn das Array / der Index nicht verwendet wurde, sodass Sie nichts initialisieren müssen.

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

Angenommen, die Zahlen befinden sich bereits auf dem Stapel und das Ergebnis bleibt als einziger Wert übrig, wenn es fertig ist.

Prüfung:

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

Erste Version mit den Registern o und e zum Speichern von ungeraden und geraden Zahlen.

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

Die Verwendung einer Lambda-Funktion spart einige Bytes in Zeilenumbrüchen, Tabulatoren und return.

Beispiel:

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

Rubin (66 - 32 = 34)

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

Prüfung:

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

Rubin, 55 - 46 = 9

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

Prüfung:

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

Implementierung

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

Ausgabe

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

Kaffeeskript, (57 - 32 = 25)

Implementierung

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

Ich glaube nicht, dass GolfScript in diesem Fall eine große Chance hat!

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

Vollständiger Code:

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: Nur zum Spaß funktioniert das auch, leider ändert es nicht die Anzahl der benötigten Zeichen:

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

Prolog (73 - 32 = 41)

Hier zählen wir alles nach ': -' als Funktionskörper.

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

Funktion wie folgt aufrufen:

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

Matlab (44 - 46 = -2)

Funktionskörper ist 44 Zeichen:

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

Gesamtfunktion wie folgt:

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

Tests der Funktion:

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

Dies könnte mit etwas zipMagie kürzer sein , aber fürs Erste:

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

Zur Vervollständigung stellt sich heraus, dass Sie Zip-Magie ausführen können, diese kostet Sie jedoch mehr (um einige Zeichen). Daher gilt Folgendes, es sei denn, jemand kann eine der folgenden Verbesserungen vornehmen:

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

Lesbar

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

Kaum idiomatisch.

Haskell, 64C - 46 = 18

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

Nicht zu schwer zu lesen. Beispiellauf:

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

Aktuelle Methode in Java-Code

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

Testklasse

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

Das ist das Beste, was ich als Neuling hervorgebracht habe. Ich bin mir sicher, dass es auch einige kürzere Versionen geben muss.

BEARBEITEN:

Eine reduzierte Version des Codes könnte sein:

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

Diese Version enthält nur 64 (21 weniger als die ursprüngliche Antwort) Zeichen.

Gesagt 64-32 = 32

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

Über die freie Verwendung des Begriffs Schreiben Sie eine Funktion

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)

Implementierung

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

Ausgabe

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

BaseX wurde als XQuery-Prozessor verwendet.

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 ist nicht so toll dafür. Die meisten Verknüpfungen bestehen aus mehr Zeichen (Tupel usw.).

Das einzig Wahre ist zu beachten:

• {lists,sum}ist ein Funktionsverweis auf lists:sumund kann aufgerufen werden
• Gerade Zahlen werden berechnet, indem die Liste der ungeraden Zahlen von der vollständigen Liste subtrahiert --( Liste subtrahiert ) wird

Kann anrufen mit:

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

Ausgabe: 78.49203781276162

Haskell

57 - 32 = 25

Gerade Optimierung von Crazed Gremlins Antwort:

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

Optimierungen:

• read$showist kürzer als fromIntegral- 3 Zeichen
• s=sum\nund zwei shat eine Gesamtlänge von 8 Zeichen, zwei sumsind nur 6 Zeichen. - 2 Zeichen
• Wenn Sie Filter in Operator umwandeln, werden keine Leerzeichen mehr benötigt - 2 Zeichen

Ich habe auch versucht, dem Operator mehr Dinge hinzuzufügen, aber es hat genauso lange gedauert:

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