Về thử thách đó bạn phải giải quyết thử thách đó.

Cuộc thi đã kết thúc! Kiểm tra kết thúc câu hỏi

Thông số kỹ thuật:

1. Viết mã nhỏ nhất (Bất kỳ ngôn ngữ *).
2. Điểm của một câu trả lời là tổng của:
   • Độ dài mã không có khoảng trắng .
   • Số câu trả lời sử dụng cùng một ngôn ngữ bình phương.
   • Độ dài của tên ngôn ngữ lớn nhất trong cuộc thi trừ đi độ dài ngôn ngữ của bạn.
   • Downvotes trừ Upvotes (còn gọi là Total Total Votes)
3. Viết vị trí của người dùng và điểm số.
4. Mỗi người dùng chỉ có thể viết một câu trả lời.
5. Điểm thấp nhất sẽ thắng.

Kiểm tra:

Vì vậy, vào cuối cuộc thi, một đầu vào khả dĩ có thể là (STDIN):

Các cột là: Tên người dùng, Ngôn ngữ, Độ dài mã (w / o khoảng trắng) và TotalVotes

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

Nếu tên người dùng của bạn có khoảng trắng như "Tên người dùng của tôi" thì nó sẽ trở thành "MyUserName" để đầu vào sẽ luôn có chính xác 4 cột .

Đầu ra sẽ là (STDOUT):

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

Giải trình:

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 là tên lớn nhất với 9 ký tự ( 9 - 9 = 0).

Perl và Java có 4 ký tự ( 9 - 4 = 5).

Python có 6 ký tự ( 9 - 6 = 3).

Perl có 2 mục để mỗi mục được thêm 4 điểm.

Về ngôn ngữ:

Tên của ngôn ngữ chỉ được chứa các chữ cái tiếng Anh (nghĩa là [A-Za-z]) và những từ không phù hợp phải được "dịch" sang thứ khác.

Vào cuối cuộc thi, mọi ngôn ngữ phải có đại diện của nó (Bạn có thể đề xuất các đại diện tốt hơn)

Ví dụ:

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

Hạn chót: ngày 20 tháng 8 năm 2011 00:00 UTC

Kết thúc cuộc thi, người chiến thắng phải sử dụng chương trình của mình để tìm ra người chiến thắng. Nó không cho phép những người không chiến thắng sử dụng các chương trình của họ để tìm ra người chiến thắng và bảo anh ấy / cô ấy sử dụng chương trình của mình để tìm ra người chiến thắng. :)

Người chiến thắng (xem ở trên) được câu trả lời chấp nhận!

* Ngôn ngữ Whitespace có lợi thế không công bằng khi có thể giới thiệu độ phức tạp không giới hạn mà không bị phạt về số lượng ký tự. Câu trả lời được viết trong Khoảng trắng có thể có trong cuộc thi nhưng không thể thắng.

Nếu bạn có thể làm cho logic chương trình của bạn trong khoảng trắng , bạn cũng không thể thắng. Đó là một chủ đề chủ quan, nhưng nếu chương trình của bạn có thể tăng kích thước đáng kể mà không bị phạt, nó sẽ rơi vào tình trạng đó.

Đầu vào cuối cùng

Thứ tự chữ cái của tên (kể từ ngày 20 tháng 8 năm 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

Vì câu trả lời của cả tôi và của gian hàng đều không được phép giành chiến thắng, người chiến thắng nên tự xưng là người chiến thắng bằng cách chỉnh sửa câu hỏi này và đăng kết quả cuối cùng bên dưới.

Đầu ra cuối cùng

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 ký tự (82 không tính khoảng trắng)

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

Giải trình:

# 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 không phải khoảng trắng (tổng cộng 60246 byte)

Chỉ là một mũi chích:

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

Lưu ý rằng dòng đầu tiên phải tương đương s='\t', nhưng khối mã SE dịch tab thành 4 khoảng trắng.

Các khoảng trắng giải nén để:

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

Lưu ý rằng việc sử dụng của tôi để [0..len(inputs)-1]đảm bảo rằng đây không phải là tập lệnh Python, vì Sage là một siêu giun *. Thật không may, exec lại rơi vào Python ... vì vậy tôi phải chuẩn bị nó.

chỉnh sửa 1: chia nhỏ trên các tab, không phải dòng mới - tôi đang nghĩ gì? chỉnh sửa 2: làm cho mã dễ nhìn hơn và tái chế tab tách bằng cách đẩy một 'dòng mới' khác vào khoảng trắng

* ok, không hoàn toàn: chúng tôi phá vỡ xor

Con trăn, 184

Đó là lý do tại sao tôi yêu không gian.

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

Nó dễ đọc hơn nhiều!

PostgreSQL - 225 ký tự không phải không gian

242 → 225: Các truy vấn con được thay thế bằng các mệnh đề cửa sổ .

\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

thử nghiệm trên 9.2

Sử dụng và đầu ra:

$ 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 ký tự không phải không gian

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

Sử dụng và đầu ra:

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

AWK, 277 269 ​​nhân vật không phải không gian

Dùng inđể cắt 8 ký tự.

Phiên bản khoảng cách và phiên bản nhận xét:

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

sử dụng:

awk -f meta.awk data.txt

Ruby, 146 ký tự + 4 dấu cách

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 ký tự

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ài hơn hầu hết các giải pháp khác ... nhưng tốt nhất tôi có thể đưa ra trong JavaScript.

Sử dụng

Đầu vào phải ở trong một biến J. Ví dụ: mở bàn điều khiển và viết:

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 ký tự

Về cùng một logic, trong 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 thường gặp - 546

(khi cậu bé chơi golf củng cố dấu ngoặc đơn, không tính khoảng trắng)

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

Chơi golf nặng, giải pháp lisp phổ biến của tôi là và là dài nhất trên bảng. Vì vậy, tôi quyết định gian lận một chút bằng cách viết một bộ tải khởi động ngắn hơn đáng kể và tuyên bố đó là bài nộp của tôi.(Tôi coi việc đệ trình của @ Boothby là tiền lệ ủng hộ hành vi này)

Xin chân thành cảm ơn Peter Taylor vì sự giúp đỡ của anh ấy đã vắt kiệt mọi char cuối cùng của bootstrapper này.

BASH - 35

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

Cách sử dụng : mèo ./test0 | bash ./btstrp.sh

Joey Adams chỉ ra rằng đây không phải là một giải pháp công bằng vì tôi có thể "tùy tiện tăng độ phức tạp của giải pháp của bạn mà không cần tăng kích thước mã tương ứng", một điểm không được thể hiện rõ ràng trong thông số kỹ thuật.

Scala 269 ​​266 252 không có khoảng trống và dòng mới.

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

Cầu nguyện:

cat user.lst | scala -i metagolf.scala

cập nhật:

• đơn giản hóa (l => l.foo) -> (_.foo)
• cầu khẩn
• Gareths gợi ý của stdin

giải pháp của tôi:

* 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

*) ra khỏi cuộc thi