W tym wyzwaniu musisz rozwiązać to wyzwanie.

Konkurs się skończył! Sprawdź koniec pytania

Okular:

1. Wpisz najmniejszy kod (dowolny język *).
2. Wynik odpowiedzi jest sumą:
   • Długość kodu bez spacji .
   • Liczba odpowiedzi w tym samym języku do kwadratu.
   • Długość nazwy największego języka w konkursie minus długość Twojego języka.
   • Upvotes minus Upvotes (aka minus Suma głosów)
3. Napisz pozycję użytkowników i wynik.
4. Każdy użytkownik może napisać tylko jedną odpowiedź.
5. Najniższy wynik wygrywa.

Testowanie:

Pod koniec konkursu możliwe dane wejściowe mogą być (STDIN):

Kolumny to: nazwa użytkownika, język, długość kodu (bez białych znaków) i TotalVotes

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

Jeśli w nazwie użytkownika znajdują się spacje, takie jak „Moja nazwa użytkownika”, zmieni się ona w „MyUserName”, więc dane wejściowe zawsze będą miały dokładnie 4 kolumny .

Wyjście będzie (STDOUT):

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

Wyjaśnienie:

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 to największa nazwa z 9 znakami ( 9 - 9 = 0).

Perl i Java mają 4 znaki ( 9 - 4 = 5).

Python ma 6 znaków ( 9 - 6 = 3).

Perl ma 2 wpisy, więc każdy otrzymuje 4 dodatkowe punkty.

O językach:

Nazwa języka musi zawierać tylko litery angielskie (tj. [A-Za-z]), a te, które nie pasują, muszą zostać „przetłumaczone” na coś innego.

Do końca konkursu każdy język musi mieć swoją reprezentację (możesz zaproponować lepszą reprezentację)

Przykłady:

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

Termin: 20 sierpnia 2011 r. 00:00 UTC

Na koniec konkursu zwycięzca musi użyć swojego programu, aby znaleźć zwycięzcę. Osoby, które nie wygrywają, mogą korzystać ze swoich programów, aby znaleźć zwycięzcę, i powiedzieć mu, aby używał swojego programu do znalezienia zwycięzcy. :)

Zwycięzca (patrz wyżej) otrzymuje odpowiedź zaakceptowaną!

* Język Białej Przestrzeni ma tę niesprawiedliwą zaletę, że jest w stanie wprowadzić nieograniczoną złożoność bez kary za liczbę znaków. Odpowiedzi napisane w Whitespace mogą być w konkursie, ale nie mogą wygrać.

Jeśli potrafisz logikę swojego programu w białych znakach , nie możesz wygrać. To jest subiektywny temat, ale jeśli twój program może znacznie zwiększyć swój rozmiar bez ponoszenia kary, to spełnia ten warunek.

Ostateczne dane wejściowe

Alfabetyczna kolejność nazw (stan na 20 sierpnia 2011 r. 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

Ponieważ zarówno moje, jak i odpowiedzi Boothby'ego nie mogą wygrać, zwycięzca powinien ogłosić się zwycięzcą, edytując to pytanie i zamieszczając poniżej końcowe wyniki.

Ostateczne wyjście

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 znaki (82 nie licząc białych znaków)

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

Wyjaśnienie:

# 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 bez białych znaków (łącznie 60246 bajtów)

Żeby być kutasem:

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

Zauważ, że pierwszy wiersz powinien być równoważny s='\t', ale blok kodu SE tłumaczy tabulator na 4 spacje.

Biała spacja rozpakowuje się do:

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

Zauważ, że moje użycie [0..len(inputs)-1]gwarantuje, że nie jest to skrypt w Pythonie, ponieważ Sage jest superpytonem *. Niestety, exec powraca do Pythona ... więc muszę go przygotować.

edycja 1: dzielenie na zakładki, a nie na nowe wiersze - o czym myślałem? edycja 2: ułatwił kod dla oczu i ponownie przetworzył kartę podziału, przesuwając kolejną „nową linię” do białych znaków

* ok, niezupełnie: łamiemy Xor

Python, 184

Dlatego kocham spacje.

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

Jest o wiele bardziej czytelny!

PostgreSQL - 225 znaków spacji

242 → 225: Zastąpiono podzapytania klauzulami okienkowania .

\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

testowany na wersji 9.2

Zastosowanie i wydajność:

$ 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 znaków spacji

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

Zastosowanie i wydajność:

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

AWK, 277 269 ​​znaków spacji

Służy indo cięcia 8 znaków.

Wersja rozproszona i wersja z komentarzem:

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

stosowanie:

awk -f meta.awk data.txt

Rubinowy, 146 znaków + 4 spacje

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 znaki

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

Dłuższy niż większość innych rozwiązań ... ale najlepsze, co mogłem wymyślić w JavaScript.

Stosowanie

Dane wejściowe powinny znajdować się w zmiennej J. Na przykład otwórz konsolę i napisz:

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 znaków

O tej samej logice w 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

(gdy chłopiec golfowy utrwala nawias, nie licząc spacji)

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

Mocno grałem w golfa, moje najczęstsze rozwiązanie seplenienia było i jest najdłuższe na planszy. Postanowiłem więc oszukać trochę, pisząc znacznie krótszy bootloader i twierdząc, że to moje przesłanie.(Uważam oświadczenie @ Boothby za precedens na korzyść tego zachowania)

Ogromne podziękowania dla Petera Taylora za jego pomoc w wyciskaniu każdego ostatniego chara z tego bootstrappera.

BASH - 35

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

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

Joey Adams wskazał, że nie jest to uczciwe rozwiązanie, ponieważ mogę „dowolnie zwiększyć złożoność twojego rozwiązania bez odpowiedniego zwiększenia rozmiaru kodu”, co nie zostało wyraźnie określone w specyfikacji.

Scala 269 ​​266 252 bez spacji i znaków nowej linii.

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

Wezwanie:

cat user.lst | scala -i metagolf.scala

aktualizacje:

• uproszczony (l => l.foo) -> (_.foo)
• wezwanie
• Wskazówka Garetha na standardowe wejście

moje rozwiązanie:

* 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

*) poza konkursem