मेटा गोल्फ चैलेंज

22

उस चुनौती पर आपको उस चुनौती को हल करना होगा।

प्रतियोगिता खत्म हो गई है! प्रश्न के अंत की जाँच करें

चश्मा:

  1. सबसे छोटा कोड (कोई भी भाषा *) लिखें।
  2. एक उत्तर का स्कोर निम्नलिखित का योग है:
    • व्हॉट्सएप के बिना कोड की लंबाई ।
    • उसी भाषा का उपयोग करके उत्तरों की संख्या।
    • प्रतियोगिता में सबसे बड़ी भाषा के नाम की लंबाई आपकी भाषा की लंबाई है।
    • डाउनवोट्स माइनस अपवोट्स (उर्फ माइनस कुल वोट)
  3. उपयोगकर्ताओं की स्थिति और स्कोर लिखें।
  4. प्रत्येक उपयोगकर्ता केवल एक उत्तर लिख सकता है।
  5. सबसे कम स्कोर जीतता है।

परिक्षण:

तो, प्रतियोगिता के अंत में, एक संभावित इनपुट (STDIN) हो सकता है:

स्तंभ हैं: उपयोगकर्ता नाम, भाषा, कोड की लंबाई (w / o व्हाट्सएप) और TotalVotes

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

यदि आपके उपयोगकर्ता नाम में "मेरा उपयोगकर्ता नाम" जैसे स्थान हैं तो यह "MyUserName" बन जाएगा, इसलिए इनपुट में हमेशा 4 कॉलम होंगे ।

आउटपुट (STDOUT) होगा:

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

स्पष्टीकरण:

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

ब्रेनफक 9 वर्णों ( 9 - 9 = 0) के साथ सबसे बड़ा नाम है ।

पर्ल और जावा में 4 वर्ण हैं ( 9 - 4 = 5)।

पायथन में 6 वर्ण हैं ( 9 - 6 = 3)।

पर्ल में 2 प्रविष्टियाँ हैं, इसलिए प्रत्येक में 4 अतिरिक्त अंक मिलते हैं।

भाषाओं के बारे में:

भाषा के नाम में केवल अंग्रेजी अक्षर (यानी [ए-ज़ा-ज़] होना चाहिए और जो फिट नहीं होते हैं उन्हें किसी और चीज़ के लिए "अनुवादित" होना चाहिए।

प्रतियोगिता के अंत तक, हर भाषा का प्रतिनिधित्व होना चाहिए (आप बेहतर प्रतिनिधित्व का प्रस्ताव कर सकते हैं)

उदाहरण:

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

समय सीमा: 20 अगस्त, 2011 00:00 यूटीसी

प्रतियोगिता के अंत में, विजेता को खोजने के लिए विजेता को अपने कार्यक्रम का उपयोग करना चाहिए। यह गैर विजेताओं को विजेता खोजने के लिए अपने कार्यक्रमों का उपयोग करने और विजेता को खोजने के लिए अपने कार्यक्रम का उपयोग करने के लिए उसे बताने की अनुमति है। :)

विजेता (ऊपर देखें) को उत्तर स्वीकार हो जाता है!

* व्हॉट्सएप भाषा में वर्ण गणना पर किसी दंड के बिना असीमित जटिलता का परिचय देने में सक्षम होने का अनुचित लाभ है। व्हाट्सएप में लिखे गए उत्तर प्रतियोगिता में हो सकते हैं लेकिन जीत नहीं सकते।

आप में अपने कार्यक्रम के तर्क कर सकते हैं व्हाइटस्पेस , आप भी नहीं जीत सकते। यह एक व्यक्तिपरक विषय है, लेकिन यदि आपके कार्यक्रम को दंडित किए बिना आकार में काफी वृद्धि हो सकती है, तो यह उस स्थिति में आता है।

अंतिम इनपुट

नामों का वर्णानुक्रम क्रम (20 अगस्त 2011 को यूटीसी 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

चूंकि मेरा और बूथबी के जवाब दोनों को जीतने की अनुमति नहीं है, इसलिए विजेता को इस प्रश्न को संपादित करके और अंतिम आउटपुट नीचे पोस्ट करके खुद को विजेता घोषित करना चाहिए।

अंतिम आउटपुट

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
code-golf  metagolf 
— JBernardo
स्रोत
8
इसका मतलब है कि व्हॉट्सएप में एक समाधान स्वचालित रूप से जीत जाएगा?
— जॉय एडम्स
1
अन्य उत्तरों के बारे में जानकारी कहाँ से आती है? क्या हमारे कार्यक्रम StackExchange से जुड़ने वाले हैं और इस प्रश्न के उत्तर देने हैं?
— जस्टिन मॉर्गन
1
@ जस्टिन प्रतियोगिता के अंत में, मैं वास्तविक कार्यक्रम इनपुट का जवाब दूंगा। मैंने प्रारूप दिया
— जेबरनार्डो
1
@ हारीपोन <> <ti dexif I! SknahT
— JBernardo
1
क्या हमें स्कोर द्वारा आउटपुट को सॉर्ट करना चाहिए? यदि हां, तो टाई के मामले में हमें क्या करना चाहिए?
— बूथ

जवाबों:

11

गोल्फस्क्रिप्ट, 83 वर्ण (82 व्हॉट्सएप की गिनती नहीं)

n/{},{' ':s/}%.{1=}%\{~~\~\-\.`{=}+4$\,,.*\,-+2${,}%$)\;+[\]}%$\;.,,]zip{~)s@~s@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
— पीटर टेलर
स्रोत
यह बहुत साफ है, मुझे गोल्फस्क्रिप्ट पर एक नज़र डालनी चाहिए ... मुझे नहीं पता कि यह कैसे सार्थक है
— shesek
3
@shesek, ने एक भारी टिप्पणी वाला संस्करण जोड़ा
— पीटर टेलर
वाह, बहुत अच्छा! धन्यवाद :-)
— shesek
15

ऋषि: 48 42 41 गैर-व्हाट्सएप (60246 बाइट्स कुल)

बस एक चुभन होना:

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

ध्यान दें कि पहली पंक्ति के बराबर होना चाहिए s='\t', लेकिन एसई कोड ब्लॉक टैब को 4 रिक्त स्थान में बदल देता है।

व्हाट्सएप अनपैक करने के लिए:

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

ध्यान दें कि मेरा उपयोग [0..len(inputs)-1]यह सुनिश्चित करता है कि यह एक पायथन स्क्रिप्ट नहीं है, क्योंकि ऋषि एक सुपरथिथॉन * है। दुर्भाग्य से, पायथन पर वापस गिर जाता है ... इसलिए मैंने इसे तैयार किया है।

संपादित करें 1: टैब पर विभाजन, नए सिरे से नहीं - मैं क्या सोच रहा था? संपादन 2: आंखों पर कोड को आसान बना दिया, और व्हॉट्सएप पर एक और 'न्यूलाइन' को धक्का देकर विभाजन पट्टी को पुनर्नवीनीकरण किया

* ठीक है, काफी नहीं: हम एक्सोर को तोड़ते हैं

— boothby
स्रोत
10

पायथन, 184

इसलिए मुझे स्पेस पसंद है।

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

यह बहुत अधिक पठनीय है!

— JBernardo
स्रोत
3
क्या यह किसी प्रकार की आस्की कला का चित्र है? यदि हाँ, तो यह कैसा दिखना चाहिए?
— oenone
@ आप मुझे बता सकते हैं।
— जेबरनार्डो
2
ऐसा लगता है कि यह चाहिए, लेकिन मैं कुछ भी नहीं पहचान सकता
— oenone
1
@oneone न तो मैं ...
— Jernernardo
7

PostgreSQL - 225 गैर-अंतरिक्ष वर्ण

242 → 225: से बदला सबक्वेरी विंडोइंग खंड ।

\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

9.2devel पर परीक्षण किया गया

उपयोग और उत्पादन:

$ psql -f meta.sql < meta.in
1 UserE 33
2 UserB 37
3 UserA 103
4 UserD 496
5 UserC 503
— जॉय एडम्स
स्रोत
4

पायथन 2 - 210 203 गैर-अंतरिक्ष वर्ण

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

उपयोग और उत्पादन:

$ cat meta.txt | python meta.py
1 UserE 33
2 UserB 37
3 UserA 103
4 UserD 496
5 UserC 503
आप केवल उपयोग कर सकते हैं x.split()(वह भी हटा देगा \n)
— JBernardo
@ जेर्नार्डो चीयर्स! 7 पात्रों को बचाया।
आप sys.stdin पर .readlines () को खोद सकते हैं .... इनपुट की किसी भी उचित लंबाई के लिए फ़ंक्शन कॉल से कोई फर्क नहीं पड़ेगा और कुछ वर्णों पर खर्च होगा। बस एक और गोल्फ में सोचा और सोचा था कि मैं साझा करूँगा।
— गिरफ्तारी
4

AWK, 277 269 ​​गैर-अंतरिक्ष वर्ण

प्रयुक्त in8 वर्ण कटौती करने के लिए।

संस्करण और टिप्पणी संस्करण:

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

उपयोग:

awk -f meta.awk data.txt
— jpjacobs
स्रोत
sed '/#/ d' meta.awk|sed ':a;$!N;s/\n//;ta;s/\s//g;'|wc -cपात्रों की गिनती के लिए उपयोग किया जाता है ।
— jpjacobs
3

रूबी, 146 अक्षर + 4 रिक्त स्थान

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]*' '}
— Lowjacker
स्रोत
3

जावास्क्रिप्ट, 243 वर्ण

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

अन्य समाधानों की तुलना में सबसे लंबे समय तक ... लेकिन सबसे अच्छा मैं जावास्क्रिप्ट में आ सकता हूं।

प्रयोग

इनपुट एक जे चर में होना चाहिए। उदाहरण के लिए, एक कंसोल खोलें और लिखें:

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

कॉफ़स्क्रिप्ट, 177 वर्ण

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"
— shesek
स्रोत
मुझे पसंद है कि आप lengthचर और सदस्यता का उपयोग करके विशेषता को कैसे संक्षिप्त करते हैं ।
— जॉय एडम्स
3

आम लिस्प - 546

(जब गोल्फ का लड़का कोष्ठक को मजबूत करता है, तो रिक्त स्थान की गिनती नहीं)

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

भारी गोल्फ, मेरा आम लिस्प समाधान था और बोर्ड पर सबसे लंबा है। इसलिए मैंने एक छोटा सा बूटलोडर लिखकर थोड़ा सा धोखा देने का फैसला किया और यह दावा किया कि मेरे प्रस्तुतिकरण के रूप में।(मैं इस व्यवहार के पक्ष में एक मिसाल के तौर पर Boothby की प्रस्तुति को मानता हूं)

इस बूटस्ट्रैपर के हर अंतिम चार को निचोड़ने में उनकी मदद के लिए पीटर टेलर को धन्यवाद ।

BASH - 35

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

उपयोग : बिल्ली ।/estest0 | bash ./btstrp.sh

जॉय एडम्स ने कहा कि यह उचित समाधान नहीं है क्योंकि मैं "कोड आकार में इसी वृद्धि के बिना आपके समाधान की जटिलता को मनमाने ढंग से बढ़ा सकता हूं", एक बिंदु जो स्पष्ट रूप से कल्पना में व्यक्त नहीं किया गया है।

— arrdem
स्रोत
1
जब तक एक के लिए लूप कम नहीं होगा?
— पीटर टेलर
यकीन नहीं होता ... लेकिन थोड़ी देर के लिए मिला!
— गिरफ्तार
1
इसके अलावा, यदि आप चर को पढ़ने के लिए निर्दिष्ट करते हैं तो आपको उपयोग करने की आवश्यकता नहीं है $REPLY। कोशिश करो while read x;do a=$x"\n"$a;done। और आपको |अंतिम पंक्ति पर s के बाद रिक्त स्थान निकालने में सक्षम होना चाहिए । एक और नोट पर, मुझे यकीन नहीं है कि आंतरिक आईपी पते का उपयोग करना बहुत उपयोगी है: यह किसी और के लिए काम नहीं करेगा।
— पीटर टेलर
या यहां तक ​​किwget -q http://url/l.lsp ;cat - |clisp l.lsp
— पीटर टेलर
ठीक है, आपने मुझे बिल्ली पर खो दिया है -
— गिरफ्तार किया
2

स्काला 269 ​​266 252 बिना रिक्त और newlines के।

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

मंगलाचरण:

cat user.lst | scala -i metagolf.scala

अपडेट:

  • सरलीकृत (l => l.foo) -> (_.foo)
  • मंगलाचरण
  • सारथि की हिम्मत संकेत करती है

मेरा समाधान:

* 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

*) प्रतियोगिता से बाहर

— अज्ञात उपयोगकर्ता
स्रोत
आप उपयोग कर सकते हैं stdinके बजाय fromFile(System.in)।
— गारेथ
1
धन्यवाद। अब मुझे 179 अपवोट की जरूरत है, और इस चुनौती को जीत लिया होगा - ceteris paribus।
— उपयोगकर्ता अज्ञात
कोई बात नहीं। हम्म ... यकीन नहीं है कि आपको 179 अपवोट्स प्राप्त करने के लिए पर्याप्त ट्रैफ़िक है ...
— गैरेथ
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.