Su quella sfida devi risolvere quella sfida.

Il concorso è finito! Controlla la fine della domanda

Specifiche:

1. Scrivi il codice più piccolo (qualsiasi lingua *).
2. Il punteggio di una risposta è la somma di:
   • Lunghezza del codice senza spazi bianchi .
   • Numero di risposte utilizzando la stessa lingua al quadrato.
   • Lunghezza del nome della lingua più grande del concorso meno la lunghezza della tua lingua.
   • Downvotes meno Upvotes (aka meno il totale dei voti)
3. Scrivi la posizione degli utenti e il punteggio.
4. Ogni utente può scrivere una sola risposta.
5. Vince il punteggio più basso.

test:

Quindi, alla fine del contest, un possibile input potrebbe essere (STDIN):

Le colonne sono: nome utente, lingua, lunghezza del codice (senza spazi bianchi) e TotalVotes

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

Se il tuo nome utente ha spazi come "My User Name" diventerà "MyUserName", quindi l'input avrà sempre esattamente 4 colonne .

L'output sarà (STDOUT):

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

Spiegazione:

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 è il nome più grande con 9 caratteri ( 9 - 9 = 0).

Perl e Java hanno 4 caratteri ( 9 - 4 = 5).

Python ha 6 caratteri ( 9 - 6 = 3).

Perl ha 2 voci, quindi ognuna ottiene 4 punti extra.

Informazioni sulle lingue:

Il nome della lingua deve contenere solo lettere inglesi (cioè [A-Za-z]) e quelle che non si adattano che devono essere "tradotte" in qualcos'altro.

Entro la fine del concorso, ogni lingua deve avere la sua rappresentazione (puoi proporre rappresentazioni migliori)

Esempi:

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

Scadenza: 20 agosto 2011 00:00 UTC

Alla fine del concorso, il vincitore deve usare il suo programma per trovare il vincitore. È permesso ai non vincitori di usare i loro programmi per trovare il vincitore e dirgli di usare il suo programma per trovare il vincitore. :)

Il vincitore (vedi sopra) ottiene la risposta accettata!

* Il linguaggio degli spazi bianchi ha il vantaggio ingiusto di poter introdurre una complessità illimitata senza penalità sul conteggio dei personaggi. Le risposte scritte in Whitespace possono essere presenti nel concorso ma non possono vincere.

Se riesci a rendere la logica del tuo programma in spazi bianchi , non puoi nemmeno vincere. Questo è un argomento soggettivo, ma se il tuo programma può aumentare considerevolmente di dimensioni senza essere penalizzato, rientra in quella condizione.

Input finale

Ordine alfabetico dei nomi (al 20 agosto 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

Poiché non è consentito vincere le risposte sia della mia che della cabina, il vincitore dovrebbe proclamarsi vincitore modificando questa domanda e pubblicando il risultato finale di seguito.

Uscita finale

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 caratteri (82 senza contare gli spazi bianchi)

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

Spiegazione:

# 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

Sage: 48 42 41 non bianchi (60246 byte totali)

Solo per essere una puntura:

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

Si noti che la prima riga dovrebbe essere equivalente a s='\t', ma il blocco di codice SE traduce la scheda in 4 spazi.

Lo spazio bianco viene decompresso per:

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

Nota che il mio uso di [0..len(inputs)-1]assicura che questo non è uno script Python, dal momento che Sage è un superpython *. Sfortunatamente, exec ricade su Python ... quindi devo preparse.

modifica 1: suddivisione in schede, non in righe: cosa stavo pensando? modifica 2: ha reso il codice più semplice per gli occhi e ha riciclato la scheda di divisione spingendo un'altra "nuova riga" nello spazio bianco

* ok, non proprio: rompiamo xor

Python, 184

Ecco perché amo gli spazi.

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

È molto più leggibile!

PostgreSQL - 225 caratteri non spaziali

242 → 225: Sostituisce le sottoquery con clausole di windowing .

\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

testato su 9.2devel

Utilizzo e output:

$ 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 caratteri non spaziali

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

Utilizzo e output:

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

AWK, 277 269 ​​caratteri non spaziali

Usato inper tagliare 8 caratteri.

Versione spaziata e versione commentata:

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

utilizzo:

awk -f meta.awk data.txt

Rubino, 146 caratteri + 4 spazi

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 caratteri

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

Più a lungo della maggior parte delle altre soluzioni ... ma la migliore che ho potuto trovare in JavaScript.

uso

L'input dovrebbe essere in una variabile J. Ad esempio, apri una console e scrivi:

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 caratteri

Circa la stessa logica, 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"

Lisp comune - 546

(quando il golfista consolida la parentesi, senza contare gli spazi)

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

Fortemente golf, la mia soluzione lisp comune era ed è la più lunga sulla tavola. Così ho deciso di imbrogliare un po 'scrivendo un bootloader significativamente più breve e rivendicandolo come mio invio.(Considero l'invio di @ Boothby un precedente a favore di questo comportamento)

Un grande ringraziamento a Peter Taylor per il suo aiuto spremere ogni ultimo carattere da questo bootstrapper.

BASH - 35

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

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

Joey Adams ha sottolineato che questa non è una soluzione equa perché posso "aumentare arbitrariamente la complessità della tua soluzione senza un corrispondente aumento delle dimensioni del codice", un punto non chiaramente espresso nelle specifiche.

Scala 269 ​​266 252 senza spazi vuoti e nuove righe.

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

Invocazione:

cat user.lst | scala -i metagolf.scala

aggiornamenti:

• semplificato (l => l.foo) -> (_.foo)
• invocazione
• Gareths accenno di stdin

la mia soluzione:

* 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

*) fuori concorso