En ese desafío tienes que resolver ese desafío.

El concurso ha terminado! Verifica el final de la pregunta

Especificaciones:

1. Escriba el código más pequeño (Cualquier idioma *).
2. El puntaje de una respuesta es la suma de:
   • Longitud del código sin espacios en blanco .
   • Número de respuestas usando ese mismo idioma al cuadrado.
   • Longitud del nombre del idioma más importante en el concurso menos la longitud de su idioma.
   • Votos a favor menos Votos a favor (alias menos Total de votos)
3. Escriba la posición de los usuarios y la puntuación.
4. Cada usuario puede escribir solo una respuesta.
5. El puntaje más bajo gana.

Pruebas:

Entonces, al final del concurso, una posible entrada podría ser (STDIN):

Las columnas son: nombre de usuario, idioma, longitud del código (sin espacios en blanco) y TotalVotes

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

Si su nombre de usuario tiene espacios como "Mi nombre de usuario", se convertirá en "MyUserName", por lo que la entrada siempre tendrá exactamente 4 columnas .

La salida será (STDOUT):

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

Explicación:

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 es el nombre más grande con 9 caracteres ( 9 - 9 = 0).

Perl y Java tienen 4 caracteres ( 9 - 4 = 5).

Python tiene 6 caracteres ( 9 - 6 = 3).

Perl tiene 2 entradas, por lo que cada una obtiene 4 puntos extra.

Acerca de los idiomas:

El nombre del idioma debe contener solo letras en inglés (es decir, [A-Za-z]) y las que no encajan deben "traducirse" a otra cosa.

Al final del concurso, cada idioma debe tener su representación (puede proponer mejores representaciones)

Ejemplos:

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

Fecha límite: 20 de agosto de 2011 00:00 UTC

Al final del concurso, el ganador debe usar su programa para encontrar al ganador. Se permite a los no ganadores usar sus programas para encontrar al ganador y decirle que use su programa para encontrar al ganador. :)

¡El ganador (ver arriba) obtiene la respuesta aceptada!

* El lenguaje Whitespace tiene la ventaja injusta de poder introducir una complejidad ilimitada sin penalizar el recuento de caracteres. Las respuestas escritas en espacios en blanco pueden estar en el concurso pero no pueden ganar.

Si puede hacer la lógica de su programa en espacios en blanco , tampoco puede ganar. Ese es un tema subjetivo, pero si su programa puede aumentar considerablemente de tamaño sin ser penalizado, cae en esa condición.

Entrada final

Orden alfabético de nombres (a partir del 20 de agosto de 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

Como las respuestas tanto mías como de boothby no pueden ganar, el ganador debe proclamarse ganador editando esta pregunta y publicando el resultado final a continuación.

Salida final

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 caracteres (82 sin contar espacios en blanco)

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

Explicación:

# 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

Salvia: 48 42 41 no espacios en blanco (60246 bytes en total)

Solo para ser un pinchazo:

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

Tenga en cuenta que la primera línea debe ser equivalente a s='\t', pero el bloque de código SE traduce la pestaña a 4 espacios.

El espacio en blanco se descomprime para:

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

Tenga en cuenta que mi uso de [0..len(inputs)-1]garantiza que este no sea un script de Python, ya que Sage es un superpython *. Desafortunadamente, el ejecutivo recurre a Python ... así que tengo que prepararlo.

Edición 1: división en pestañas, no en nuevas líneas: ¿qué estaba pensando? edición 2: facilitó el código para los ojos y recicló la pestaña de división presionando otra 'nueva línea' en el espacio en blanco

* ok, no del todo: rompemos xor

Pitón, 184

Por eso amo los espacios.

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 mucho más legible!

PostgreSQL - 225 caracteres no espaciales

242 → 225: Subconsultas reemplazadas con cláusulas de ventanas .

\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

probado en 9.2devel

Uso y salida:

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

Python 2 - 210203 caracteres no espaciales

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

Uso y salida:

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

AWK, 277 269 ​​caracteres no espaciales

Se usa inpara cortar 8 caracteres.

Versión espaciada y versión comentada:

{
        # 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]
        }
}

uso:

awk -f meta.awk data.txt

Ruby, 146 caracteres + 4 espacios

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 caracteres

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

Más tiempo que la mayoría de las otras soluciones ... pero lo mejor que pude encontrar en JavaScript.

Uso

La entrada debe estar en una variable J. Por ejemplo, abra una consola y escriba:

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 caracteres

Sobre la misma lógica, en 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"

Lisp común - 546

(cuando el niño golfizado consolida paréntesis, sin contar espacios)

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

Muy golfizado, mi solución común de lisp fue y es la más larga en el tablero. Así que decidí hacer un poco de trampa escribiendo un gestor de arranque significativamente más corto y reclamando eso como mi presentación.(Considero que la presentación de @ Boothby es un precedente a favor de este comportamiento)

Muchas gracias a Peter Taylor por su ayuda para exprimir hasta el último char de este bootstrapper.

BASH - 35

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

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

Joey Adams señaló que esta no es una solución justa porque puedo "aumentar arbitrariamente la complejidad de su solución sin un aumento correspondiente en el tamaño del código", un punto que no se expresa claramente en la especificación.

Scala 269 ​​266 252 sin espacios en blanco y líneas nuevas.

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

Invocación:

cat user.lst | scala -i metagolf.scala

actualizaciones:

• simplificado (l => l.foo) -> (_.foo)
• invocación
• Gareths insinuación de stdin

mi solución:

* 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

*) fuera de concurso