Bei dieser Herausforderung musst du diese Herausforderung lösen.

Wettbewerb ist vorbei! Überprüfen Sie das Ende der Frage

Technische Daten:

1. Schreiben Sie den kleinsten Code (Beliebige Sprache *).
2. Die Punktzahl einer Antwort ist die Summe von:
   • Codelänge ohne Leerzeichen .
   • Anzahl der Antworten in derselben Sprache im Quadrat.
   • Länge des Namens der größten Sprache im Wettbewerb abzüglich der Länge Ihrer Sprache.
   • Downvotes minus Upvotes (aka minus Gesamtzahl der Stimmen)
3. Schreiben Sie die Position der Benutzer und die Punktzahl.
4. Jeder Benutzer kann nur eine Antwort schreiben.
5. Die niedrigste Punktzahl gewinnt.

Testen:

Am Ende des Wettbewerbs könnte eine mögliche Eingabe sein (STDIN):

Die Spalten lauten: Benutzername, Sprache, Codelänge (ohne Leerzeichen) und TotalVotes

UserA Python 100 1
UserB Perl 30 2
UserC Java 500 3
UserD Brainfuck 499 4
UserE Perl 29 5

Wenn Ihr Benutzername Leerzeichen wie "Mein Benutzername" enthält, wird er zu "Mein Benutzername", sodass die Eingabe immer genau 4 Spalten enthält .

Die Ausgabe wird (STDOUT) sein:

1 UserE 33
2 UserB 37
3 UserA 103
4 UserD 496
5 UserC 503

Erläuterung:

User  P  N^2  L   V
 A   100  1   3  -1
 B    30  4   5  -2
 C   500  1   5  -3
 D   499  1   0  -4
 E    29  4   5  -5

Brainfuck ist der größte Name mit 9 Zeichen ( 9 - 9 = 0).

Perl und Java haben 4 Zeichen ( 9 - 4 = 5).

Python hat 6 Zeichen ( 9 - 6 = 3).

Perl hat 2 Einträge, also bekommt jeder 4 Extrapunkte.

Über Sprachen:

Der Name der Sprache darf nur englische Buchstaben enthalten (dh [A-Za-z]) und diejenigen, die nicht passen, müssen in etwas anderes "übersetzt" werden.

Am Ende des Wettbewerbs muss jede Sprache ihre Repräsentation haben (Sie können bessere Repräsentationen vorschlagen)

Beispiele:

Python3      -> Python
Ruby1.9      -> Ruby
Shell Script -> Shell
C++          -> Cpp
C#           -> CSharp
><>          -> Fish

Einsendeschluss: 20. August 2011 00:00 UTC

Am Ende des Wettbewerbs muss der Gewinner sein / ihr Programm verwenden, um den Gewinner zu finden. Nicht-Gewinner dürfen ihre Programme verwenden, um den Gewinner zu finden, und ihn auffordern, sein Programm zu verwenden, um den Gewinner zu finden. :)

Der Gewinner (siehe oben) erhält die Antwort!

* Die Whitespace-Sprache hat den unfairen Vorteil, unbegrenzte Komplexität einführen zu können, ohne die Zeichenanzahl zu beeinträchtigen. In Whitespace geschriebene Antworten sind zwar im Wettbewerb, können aber nicht gewinnen.

Wenn Sie die Logik Ihres Programms in Leerzeichen setzen können , können Sie auch nicht gewinnen. Das ist ein subjektives Thema, aber wenn Ihr Programm erheblich größer werden kann, ohne bestraft zu werden, fällt es in diesen Zustand.

Letzte Eingabe

Alphabetische Reihenfolge der Namen (Stand: 20. August 2011 UTC 00:00)

boothby Sage 41 9
Harpyon Python 203 4
JBernardo Python 184 7
JoeyAdams PostgreSQL 225 6
jpjacobs AWK 269 4
Lowjacker Ruby 146 2
PeterTaylor Golfscript 82 4
rmackenzie CommonLisp 542 2
shesek Javascript 243 3
userunknown Scala 252 1

Da die Antworten von mir und Boothby nicht gewinnen dürfen, sollte der Gewinner sich selbst zum Gewinner erklären, indem er diese Frage bearbeitet und die endgültige Ausgabe unten veröffentlicht.

Endgültige Ausgabe

1 boothby 39
2 PeterTaylor 79
3 Lowjacker 151
4 JBernardo 185
5 Harpyon 207
6 JoeyAdams 220
7 shesek 241
8 userunknown 257
9 jpjacobs 273
10 rmackenzie 541

Golfscript, 83 Zeichen (82 ohne Leerzeichen)

n/{},{' ':s/}%.{1=}%\{~~\~\-\.`{=}+4$\,,.*\,-+2${,}%$)\;+[\]}%$\;.,,]zip{~)s@~s@n}%

Erläuterung:

# Split the string containing all the input on newlines
n/
# Remove empty lines
{},
# Split each line on spaces (storing the space character in variable s)
{' ':s/}%
# We now have an array of arrays of words. Duplicate it, filter the copy to contain
# only the second word of each array, and reorder with the array of second words first
.{1=}%\
# Map each line
{
    # Unpack the array ["user" "lang" "length" "votes"] and evaluate the integers
    ~~\~\
    # Subtract votes from length and bring "lang" to the top
    -\
    # Create a function to match the string "lang"
    .`{=}+
    # Stack is currently [array of langs] "user" (length-votes) "lang" {"lang"=}
    # Duplicate the array of langs and apply the match function as a filter
    4$\,
    # Get the length of the array of matches and square it
    ,.*
    # Stack is [array of langs] "user" (length-votes) "lang" (num with lang)^2
    # Bring the "lang" to the top, get its length, subtract and add
    \,-+
    # Stack is [array of langs] "user" (score-length of longest lang)
    # Get an array of length of language names and sort it
    2${,}%$
    # Drop it apart from the largest value, and add that to the score
    )\;+
    # Package the "user" score from the top of the stack as [score "user"]
    [\]
}%
# Sort. Since each element is a [score "user"] value, this will sort by score.
$
# Discard the [array of langs].
\;
# Stack is an array of [score "user"] arrays. Get its length and create an array of the
# same length which counts from 0.
.,,
# Group and zip, so we go from [[score0 "user0"] ... [scoren "usern"]] [0 ... n] to
# [[[score0 "user0"] 0] ... [[scoren "usern"] n]]
]zip
# Map each [[scorei "useri"] i]
{
    # Expand, increment i (so we count from 1 rather than 0), add a space
    ~)s
    # Bring the [scorei "useri"] to the top, unpack, add a space
    @~s
    # Bring the scorei to the top, add a newline
    @n
}%
# We now have an array [[1 " " "userA" " " scoreA "\n"] ... [n " " "userZ" " " scoreZ "\n"]
# so Golfscript's standard output formatting does the rest

Salbei: 48 42 41 ohne Leerzeichen (insgesamt 60246 Byte)

Nur um ein Idiot zu sein:

s = '   '
for c in '<lots of whitespace>'.split(s):
    s+=chr(len(c))
exec s

Beachten Sie, dass die erste Zeile äquivalent sein sollte s='\t', aber der SE-Codeblock die Registerkarte in 4 Leerzeichen übersetzt.

Der Whitespace wird entpackt zu:

exec preparse("""
import sys
instances = {}
maxlen = 0
inputs = [line.split() for line in sys.stdin.readlines()]
for i in [0..len(inputs)-1]:
    user, language, length, votes = inputs[i]
    if language in instances:
        instances[language]+=1
    else:
        instances[language]=1
    if len(language) > maxlen:
        maxlen = len(language)

scoresheet = []
for i in [0..len(inputs)-1]:
    user, language, length, votes = inputs[i]
    length = int(length)
    votes = int(votes)
    score = length + (maxlen - len(language)) + instances[language]*instances[language] - votes
    scoresheet.append((score,user))

scoresheet.sort(reverse=False)
for user, score in scoresheet:
    print user, score""")

Beachten Sie, dass meine Verwendung von [0..len(inputs)-1]dafür sorgt, dass dies kein Python-Skript ist, da Sage ein Superpython * ist. Leider greift exec auf Python zurück ... also muss ich es vorbereiten.

edit 1: Aufteilen auf Tabs, nicht auf Zeilenumbrüche - was habe ich gedacht? Edit 2: Erleichtert den Code den Augen und recycelt die Aufteilungsregisterkarte, indem eine weitere 'Newline' in den Leerraum verschoben wird

* ok, nicht ganz: wir brechen xor

Python, 184

Deshalb liebe ich Räume.

import          sys
x = sys.stdin.read(
    ).split()
z = x [  1 : : 4  ]
for i , ( j , k
) in enumerate (
      sorted (
       zip (
        [
      int(i)
    - int(j) +
  z.count(k) ** 2
+ max(map(len, z)) -
      len(k)
  for i, j, k in
       zip (
    x[2 : : 4],
    x[3 : : 4],
         z
         )
         ],
     x[ : : 4]
         )
         ),
         1
         ):
   print i, k, j

Es ist viel lesbarer!

PostgreSQL - 225 Zeichen ohne Leerzeichen

242 → 225: Ersetzte Unterabfragen mit Windowing - Klauseln .

\set QUIET 1
\t
\a
\f ' '
CREATE TEMPORARY TABLE t (u TEXT, l TEXT, c INT, v INT);
\copy t FROM PSTDIN WITH DELIMITER ' ';
SELECT row_number() OVER (ORDER BY score), *
    FROM (SELECT u,
                 c
                 + count(*) OVER (PARTITION BY l)^2
                 + max(length(l)) OVER ()
                 - length(l)
                 - v AS score
                 FROM t) AS q

Getestet auf 9.2devel

Verwendung und Ausgabe:

$ psql -f meta.sql < meta.in
1 UserE 33
2 UserB 37
3 UserA 103
4 UserD 496
5 UserC 503

Python 2 - 210 203 Nicht-Leerzeichen

import sys
e=enumerate
n=len
l=[x.split()for x in sys.stdin.readlines()]
for i,(x,y)in e(sorted((int(x[2])-int(x[3])+n(list(y for y in l if y[1]==x[1]))**2+max(n(x[1])for x in l)-n(x[1]),i)for i, x in e(l))):print i+1,l[y][0],x

Verwendung und Ausgabe:

$ cat meta.txt | python meta.py
1 UserE 33
2 UserB 37
3 UserA 103
4 UserD 496
5 UserC 503

AWK, 277 269 ​​Zeichen ohne Leerzeichen

Gebraucht in8 Zeichen zu schneiden.

Spaced Version und kommentierte Version:

{
        # read in user strings
        u[NR]=$0
        # count number of times language has been used
        l[$2]+=1
}

END{
        # get maximum language length
        M=0
        X=NR
        for (g in l){
                f=length(g)
                if(f>M)
                        M=f
        }
        # get score for user i
        for(i in u){
                split(u[i],c)
                s[i]=c[3]+l[c[2]]^2+M-length(c[2])-c[4]
        }
        # sort scores and users
        for(i=2;i<=X;++i){
                for(j=i;s[j-1]>s[j];--j){
                        t=s[j]
                        x=u[j]
                        s[j]=s[j-1]
                        u[j]=u[j-1]
                        s[j-1]=t
                        u[j-1]=x
                }
        }
        # output
        for(i=1;i<=X;++i){
                split(u[i],c)
                print i,c[1],s[i]
        }
}

Verwendung:

awk -f meta.awk data.txt

Ruby, 146 Zeichen + 4 Leerzeichen

b=$<.map &:split
puts b.map{|u,l,c,v|[b.map{|_,n|n.size}.max-l.size+b.count{|_,n|n==l}**2+eval(c+?-+v),u]}.sort.map.with_index{|(s,u),i|[i+1,u,s]*' '}

JavaScript, 243 Zeichen

for(g=0,H="length",i=J.split("\n"),p=[],l={};i[H]&&p.push(a=i.pop().split(" "));)
    X=a[1],X[H]>g&&(g=X[H]),l[X]=l[X]+1||1
for(i=-1;m=p[++i];)p[i]=[m[0],+m[2]+Math.pow(l[m[1]],2)+(g-m[1][H])-m[3]]
p.sort(function(a,b){return a[1]<b[1]?-1:1}).join("\n")

Länger als die meisten anderen Lösungen ... aber das Beste, was ich in JavaScript finden konnte.

Verwendung

Die Eingabe sollte in einer J-Variablen erfolgen. Öffnen Sie zum Beispiel eine Konsole und schreiben Sie:

J="UserA Python 100 1\nUserB Perl 30 2\nUserC Java 500 3\nUserD Brainfuck 499 4\nUserE Perl 29 5";
for(g=0,H="length",i=J.split("\n"),p=[],l={};i[H]&&p.push(a=i.pop().split(" "));)
    X=a[1],X[H]>g&&(g=X[H]),l[X]=l[X]+1||1
for(i=-1;m=p[++i];)p[i]=[m[0],+m[2]+Math.pow(l[m[1]],2)+(g-m[1][H])-m[3]]
p.sort(function(a,b){return a[1]<b[1]?-1:1}).join("\n")

CoffeScript, 177 Zeichen

Über die gleiche Logik in CoffeScript:

g=0;H="length";l={};([A,+C+Math.pow(l[B],2)+(g-B[H])-D] for [A,B,C,D] in for a in J.split "\n" then [_,X]=a=a.split " ";X[H]>g&&g=X[H];l[X]=l[X]+1||1;a).sort((a,b)->`a[1]<b[1]?-1:1`).join "\n"

Common Lisp - 546

(wenn Golfspieler Klammern festigen, Leerzeichen nicht mitzählen)

;;;; This is an answer to Code-Golf question
;;;; 3203/meta-golf-challenge
;;;; By using Common Lisp I plan to have the longest
;;;; Language-name while I cannot hope to have the
;;;; lowest character count due to Lisp's
;;;; linguistic tradition I can avoid the 16 or 25-pt
;;;; penalty atached to being the 4th or 5th PY
;;;; based answer.

(defun f (i)
 (loop for e in y do
  (if (eq i (nth 0 e))
   (return (nth 1 e))
  )
 )
)

(setf x
 (loop for l = (read-line () () () ())
  while l collect (loop for i = 0 then (1+ j)
                   as j = (position #\Space l :start i)
                   collect (subseq l i j) while j)
 )
)

(setf y
 (loop for a in x collect
  (list
   (+
    (read-from-string (nth 2 a))
    (expt (reduce #'+ (loop for b in x collect (if (string= (nth 1 a) (nth 1 b)) 1 0) ) ) 2 )
    (+ 5 (- (reduce #'min (loop for b in x collect (length (nth 1 b)))) (length (nth 1 a))))
    (* -1 (read-from-string (nth 3 a)))
   )
   (car a)
  )
 )
)

(setf g
 (sort (loop for c in y collect (nth 0 c)) #'<)
)

(loop for i = 0 then (1+ i) while (< i (length g)) do
 (setf a (nth i g))
 (format t "~A ~A ~A~%" (1+ i) (f a) a)
)

Stark golfen, war und ist meine übliche Lisp-Lösung die längste auf dem Brett. Also habe ich mich entschlossen, ein bisschen zu schummeln, indem ich einen deutlich kürzeren Bootloader geschrieben und das als meine Vorlage angegeben habe.(Ich betrachte @ Boothbys Einreichung als Präzedenzfall für dieses Verhalten.)

Ein großes Dankeschön an Peter Taylor für seine Hilfe beim Herauspressen des letzten Chars aus diesem Bootstrapper.

BASH - 35

wget -q goo.gl/R4R54
cat -|clisp l.lsp

Verwendung : cat ./test0 | bash ./btstrp.sh

Joey Adams wies darauf hin, dass dies keine faire Lösung ist, da ich "die Komplexität Ihrer Lösung willkürlich erhöhen kann, ohne die Codegröße entsprechend zu erhöhen", ein Punkt, der in der Spezifikation nicht klar zum Ausdruck kommt.

Scala 269 ​​266 252 ohne Leerzeichen und Zeilenumbrüche.

val b = io.Source.stdin.getLines.toList.map (_.split (" "))
b.map (a => {
  val l = b.filter (_(1) .equals ( a(1))).size
  a(0) -> (a (2).toInt + l * l + (b.map (x => x(1).length).max - a(1).length) - a(3).toInt)
}).sortBy (_._2).zipWithIndex .map (m => m._2 + " " + m._1._1 + " "+ m._1._2).mkString ("\n")

Aufruf:

cat user.lst | scala -i metagolf.scala

Aktualisierung:

• vereinfacht (l => l.foo) -> (_.foo)
• Aufruf
• Gareths Hauch von Stdin

meine Lösung:

* 0 boothby 39
1 PeterTaylor 79
2 Lowjacker 151
* 3 JBernardo 185
4 Harpyon 207
5 JoeyAdams 220
6 shesek 241
7 userunknown 257
8 jpjacobs 273
9 rmackenzie 541

*) aus dem Wettbewerb