47

सभी जानते हैं कि सामग्री प्रश्न बनाती है। लेकिन एक अच्छा शीर्षक भी मदद करता है, और यह पहली चीज है जो हम देखते हैं। यह एक कार्यक्रम में पहली छाप को चालू करने का समय है, और यह पता लगाना है कि किस प्रकार के शीर्षक अधिक उत्थान प्राप्त करते हैं।

आपको एक प्रोग्राम या फ़ंक्शन लिखने के लिए चुनौती दी गई है जो इनपुट के रूप में पीपीसीजी प्रश्न का शीर्षक लेता है, और इसके स्कोर की भविष्यवाणी करता है।

उदाहरण के लिए, आप Counting Grains of Riceएक इनपुट के रूप में प्राप्त कर सकते हैं , और आप 59इस मामले में , स्कोर के कुछ करीब लौटने की कोशिश कर रहे होंगे । गैर-पूर्णांक अनुमान ठीक हैं, लेकिन नीचे या नीचे के अनुमान -20नहीं हैं।

यहाँ परीक्षण और स्कोरिंग के लिए डेटा है:

http://data.stackexchange.com/codegolf/query/244871/names-and-upvotes

स्कोरिंग: आपका कार्यक्रम इस साइट के (PPCG) इतिहास के प्रत्येक प्रश्न पर चलाया जाएगा, न कि बंद प्रश्नों की गिनती के लिए। फ़ंक्शन ln(score + 20)तब प्रत्येक स्कोर पर, और प्रत्येक अनुमान पर लागू किया जाएगा। मूल्यों के दो परिणामी सेटों के बीच मूल-माध्य-चुकता-त्रुटि आपका स्कोर है। नीचा बेहतर है।

उदाहरण के लिए, एक प्रोग्राम जिसमें 0 का अनुमान लगाया गया था, वह हर बार 0.577 स्कोर करेगा, जबकि हर बार 11 का अनुमान लगाने पर स्कोर 0.362 होगा।

कृपया अपने स्कोर की गणना करें और इसे अपने उत्तर के शीर्षक में शामिल करें। कृपया यह भी शामिल करें कि इस प्रश्न को कितने उत्थान के लिए अपने कार्यक्रम की भविष्यवाणी में शामिल करें।

प्रतिबंध:

अत्यधिक हार्ड-कोडिंग को रोकने के लिए, 1000 से अधिक वर्ण नहीं।
एक उचित मशीन पर एक मिनट के भीतर ऊपर सेट पूरे डेटा पर चलना चाहिए।
स्टैंडर्ड लोफॉल्स बंद हैं।

आपके उपयोग और / या अस्पष्टताओं को दूर करने के लिए यहां पायथन में एक परीक्षक लिखा गया है:

import sys
import math
import csv

scores_dict = {}

with open(sys.argv[1], 'r') as csv_file:
    score_reader = csv.reader(csv_file)
    for score, title in score_reader:
        if score == 'Score':
            continue
        scores_dict[title] = int(score)

def rate_guesses(guesser):
    def transform(score):
        return math.log(score + 20) if score > -20 else 0
    off_by_total = 0
    lines_count = 0
    for title in scores_dict:
        guessed_score = guesser(title)
        real_score = scores_dict[title]
        off_by_total += (transform(real_score) - transform(guessed_score)) ** 2
    return (off_by_total/len(scores_dict)) ** .5

def constant11(title):
    return 11

print(rate_guesses(constant11))

code-challenge

— isaacg
स्रोत

19

अच्छा विचार है, लेकिन यह शर्म की बात है कि डाटासेट स्थिर नहीं है, इसलिए स्कोर थोड़ी देर के बाद अमान्य हो जाएगा। रणनीतिक मतदान की एक छोटी सी संभावना भी है: जो कोई भी इस सवाल का जवाब देता है और एक ही सप्ताह में एक वॉक्स-पॉपुली बैज कमाता है उसे संदेह के साथ देखा जाना चाहिए! ;-)

— लेवल रिवर सेंट

1

शीर्षक शामिल या जैसी चीजों को बाहर निकाल देगा [closed]और [on hold]जहां लागू हो,?

— es1024

4

@steveverrill खैर, उस समय का फ़्लिप्साइड जैसे-जैसे आगे बढ़ रहा है, हम देख पाएंगे कि क्या प्रोग्राम भविष्य के पोस्टों के साथ-साथ पिछले वाले भी अच्छा करते हैं।

— इसहाक

6

हार्ड-कोडिंग को हराना मुश्किल है। प्रत्येक हार्ड-कोडेड शीर्ष-मतदान प्रश्न 0.4 स्कोर को कम कर सकता है। और लगता है बहुत सामान्य पैटर्न भी नहीं है, हाहा। मैं अनुमान लगा रहा हूं कि उत्तर केवल 1000 बाइट्स में हार्ड-कोडित परिणाम के रूप में फिट होने के लिए प्रतिस्पर्धा करेंगे।

— 9-11 को

5

आपको अपने परीक्षण सेट के रूप में प्रश्नों के पूर्ण शरीर का उपयोग नहीं करना चाहिए। आपको यादृच्छिक पर एक निश्चित संख्या (10% -20%) का चयन करना चाहिए, और उन्हें अपने परीक्षण सेट के रूप में परिभाषित करना चाहिए (लेकिन किसी को भी यह नहीं बताएं कि क्या है)। एक एल्गोरिथ्म बनाना बहुत आसान है जो पिछले इतिहास की भविष्यवाणी करता है, जिसमें भविष्य की भविष्यवाणी का मूल्य है (यानी, किसी भी उपसमुच्चय पर अच्छा काम करता है)। (उन 10% को निकालना बेहतर होगा जो हम बिल्कुल देख सकते हैं, लेकिन यह वास्तव में अच्छी तरह से काम नहीं करेगा।)

— जो

9

पायथन 2, 991 चार्ट, स्कोर 0.221854834221, 11 का अनुमान है

import base64
e={}
d=base64.decodestring('vgAcRAEVDAIsqgQYalYaggcjQKwVXAoZWAsYQg0Ckg4VlWEX9hEDRhMe0hckCBkeuhsW3CAWQiEm\nSiMZMiwgTDAZZjIcSLMZfDQDnjwCe2AVaEQCYWEBIEgnDEoXzk0e3lQb5FYVKlkVZlwB+F0XwmI/\nGmRcuGUXWmYdVGkbzmwafG8eaHMdInkggHonRn5sKoMXgIkpbowVOI4cNJAubpQdYpcydJgVypkA\nZpweMp8ZsqEcRKMghKQYkKVPPXEWMqkWHKwbjrEdzLIBNLMf1LQivrYC99UV9rxNRsABNMEiPzob\npc0ActAhn3gcrNUZYNcWYNov/t8VgOEXAuMYqOUWsqUiCPIefPWNbvtKevwWvP0Cl9UsjQMdWwQb\nfQdpJQgWYwkCZRLBjxMWWdkqHRkWNxwB6x8p2SEZyyICSyYcgysaOS0CUy8hezAaGeEVpTRQ3zUz\nZzkZRzohizwwST4c8UAdF0OqG9AXIuEYYRN6208nU1AktVEVJ1IVWeMkIVQXdY4D2VYYD/cYb1om\nG1xA0zoY3uUaRWAhWpBSHWUXQTxGe+cad20CO3AZX3EBw3IiMXcef3gecXsVGXwhw30VbX4W24BD\n6qyQ45YaYYgZ4YobbYwauY4bMY82HZEdO5YmQ5cV35sVxaMbY6gYNas576ws+bADO7QpN7hdLJ8B\n4Eoks8EYX8VU68cYWfcar82QOdAaxdEfQ9UiW/kXL9k2ddwCW90m694enqUCkeEBE+IYWvsfA1FC\nJ+spMVIjhe4WEP0fAfYax/c3MfgbgfkqP/0DLf4V\n')
for i in range(0,600,3):
 e[ord(d[i])*256+ord(d[i+1])]=ord(d[i+2])*2-8
def p(t):
 return e.get(hash(t)%256**2,11)

स्पष्टीकरण:

यह बेशर्म हार्डकोडिंग है, लेकिन इसे कुशलता से करने की कोशिश कर रहा है।

preprocessing:

एक अलग कोड में, मैंने प्रत्येक शीर्षक को 0 और 256 ^ 2-1 के बीच के मान तक पहुंचाया। चलो इन मूल्यों को डिब्बे कहते हैं। प्रत्येक बिन के लिए, मैंने औसत अंक की गणना की। (औसत की आवश्यकता होती है क्योंकि डिब्बे के एक छोटे से हिस्से के लिए, टकराव होते हैं - एक ही बिन में 1 से अधिक शीर्षक हैश। लेकिन विशाल बहुमत के लिए प्रत्येक शीर्षक मानचित्र अपने स्वयं के बिन में)।

प्रत्येक शीर्षक के लिए 2-बाइट कोड के पीछे विचार यह है कि 1 बाइट पर्याप्त नहीं है - हमें बहुत अधिक टकराव मिलते हैं, इसलिए हम वास्तव में नहीं जानते कि प्रत्येक 1-बाइट बिन को क्या स्कोर देना है। लेकिन 2-बाइट डिब्बे के साथ, लगभग कोई टक्कर नहीं होती है, और हम प्रभावी रूप से प्रत्येक शीर्षक का 2 बाइट प्रतिनिधित्व करते हैं।

फिर डिब्बे को रैंक करें - स्कोर में लाभ की गणना करें यदि हम इस बिन को इसकी गणना मूल्य देते हैं, तो केवल अनुमान लगाने के बजाय 11. शीर्ष एन डिब्बे लें, और उन्हें एक स्ट्रिंग में कोड करें (जो वास्तविक कोड में डी है)।

एन्कोडिंग: बिन की कुंजी को 2 बाइट्स के रूप में कोडित किया गया है। मान 1 बाइट का उपयोग करके एन्कोड किया गया है। मुझे -8 और 300 + कुछ के बीच मान मिला, इसलिए इसे 1 बाइट: x -> (x + 8) / 2 में लाने के लिए थोड़ा निचोड़ना पड़ा।

वास्तविक कोड:

डी बाइट ट्रिपल के रूप में पढ़ा जाता है, ऊपर वर्णित एन्कोडिंग को डिकोड करना। जब कोई शीर्षक दिया जाता है, तो उसके हैश (मॉडुलो 256 ^ 2) की गणना करें, और यदि वह कुंजी हुक में मिलती है, तो उसके द्वारा दिए गए मान को वापस कर दें। अन्यथा, 11 लौटें।

— अरी रविवि
स्रोत

3

एक सुझाव: औसत स्कोर उतना अच्छा नहीं है। फंक्शन स्कोरिंग चुनौतियों को देखें, यह गैर-रैखिक है।

— डेडुप्लिकेटर

1

@Deduplicator धन्यवाद, मुझे एहसास हुआ कि मेरे जाने के बाद। बात यह है कि 99% डिब्बे के लिए, कोई टक्कर नहीं है, इसलिए औसत वास्तव में एकल शीर्षक का केवल स्कोर है जो उस बिन पर मैप करता है।

— श्री

16

जावास्क्रिप्ट ईएस 6

स्कोर: 0.245663
लंबाई: 1000 बाइट्स Predicts
: 5

(मुझे लगता है कि सवाल एक अप्रत्याशित उतार चढ़ाव के कारण है।: पी)

minified

E="ABCDEFGHIJKLMNOPQRSTUVWXYZ";E=E+E.toLowerCase()+"0123456789!@#$%;*()";P="RCRHIFMGPGIDQKHMJLLRMLFJGKHEqHPOgJNKGPCHPJNUPOSGJQKKKMELMIJHLKIKNcKDOfSJLFHDILGKIOUKLMLLKMKIHGHJGIIJDGJKIHIIFIGMTIHFJMIKDJGQJKGMKJHPRJPLMGIOPIIIIPBYFMGLEIKIMMRUKFLFGJFKFTHPFODEQTGTHKIJDHNJGDGiHKNYLHHDLJHGILOEViKNEKGQZfHJMIISIJFRHKLJMLPIFJILKKKJKKJESHNLLIKIGKGJJJHKJRGULLSLRONJNEeLKIQGGPQIHPLEIHHIDXjQHNBKOGWWIENRbYoHINHNMKTNKHTGMIPXFJLLMLIHPPLDJJKFUMIQMOKJLJJKIJKNLHRILJIAIbJEZOGIELGHGLOINDPJMJeJWRIIJHSOZDOsOFRRIOIOTIJSGGJKFUIDOINGOcLQEJFEITLMNIIGIGIMG7LPSNLKVOKIFGHJITGOFUJIIRN";K={};"99r1501vz076mip077myv0733it280exx081gt9118i1g279dyx102uho203ejd07433z087uje097kdg1567ft2088rk275dmu1203ez106lih1763ei126f6q101aax084owh088aid161i9y179gvn236ptn3338vf132i55080fke101l4z3789ai281ulm081blm124euz074o5m07513z14117l095qdn092gl30757n5153".replace(/(...)(...)/g,(_,a,b)=>K[a]=1*b);D=40655;N=479;H=(s,T)=>(h=7,[...s].map(c=>h=~~(h*T+c.charCodeAt(0))),h);S=s=>(y=H(s,31),K[((y%D+D)%D).toString(36)]||E.indexOf(P[(H(s,48)%N+N)%N]));

विस्तारित

E = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
E = E + E.toLowerCase() + "0123456789!@#$%;*()";
K = {};
P = "RCRHIFMGPGIDQKHMJLLRMLFJGKHEqHPOgJNKGPCHPJNUPOSGJQKKKMELMIJHLKIKNcKDOfSJL" +
    "FHDILGKIOUKLMLLKMKIHGHJGIIJDGJKIHIIFIGMTIHFJMIKDJGQJKGMKJHPRJPLMGIOPIIIIP" +
    "BYFMGLEIKIMMRUKFLFGJFKFTHPFODEQTGTHKIJDHNJGDGiHKNYLHHDLJHGILOEViKNEKGQZfH" +
    "JMIISIJFRHKLJMLPIFJILKKKJKKJESHNLLIKIGKGJJJHKJRGULLSLRONJNEeLKIQGGPQIHPLE" +
    "IHHIDXjQHNBKOGWWIENRbYoHINHNMKTNKHTGMIPXFJLLMLIHPPLDJJKFUMIQMOKJLJJKIJKNL" +
    "HRILJIAIbJEZOGIELGHGLOINDPJMJeJWRIIJHSOZDOsOFRRIOIOTIJSGGJKFUIDOINGOcLQEJ" +
    "FEITLMNIIGIGIMG7LPSNLKVOKIFGHJITGOFUJIIRN";

   ("99r1501vz076mip077myv0733it280exx081gt9118i1g279dyx102uho203ejd07433z087u" +
    "je097kdg1567ft2088rk275dmu1203ez106lih1763ei126f6q101aax084owh088aid161i9" +
    "y179gvn236ptn3338vf132i55080fke101l4z3789ai281ulm081blm124euz074o5m07513z" +
    "14117l095qdn092gl30757n5153").
        replace( /(...)(...)/g, (_,a,b) => K[a] = 1*b );

D = 40655;
N = 479;
H = (s,T) => (
    h = 7,
    [...s].map( c => h = ~~(h*T + c.charCodeAt(0)) ),
    h
);

S = s => (
    y = H( s, 31 ),
    K[((y%D + D)%D).toString( 36 )] || E.indexOf( P[(H( s, 48 )%N + N)%N] )
);

फ़ंक्शन Sएक स्ट्रिंग (शीर्षक) को स्वीकार करता है और अपना स्कोर लौटाता है।

व्यवहार पर नोट्स:

≤ 70 वोट टाइटल्स से अलग से हैंडल किए जाते हैं> 70 वोट टाइटल
Onom० वोट टाइटल्स को एक उच्च परिष्कृत होनोलॉजिक कीवर्ड का उपयोग करके संभावित ऑप्टिमाइज़ेशन एल्गोरिथ्म का उपयोग करके डिब्बे में क्रमबद्ध किया जाता है जो किसी भी तरह से एक स्ट्रिंग हैश फ़ंक्शन जैसा नहीं होता है।
थोड़ा खुश कैलकुलस के बाद यह पता चलता है कि प्रत्येक बिन के लिए इष्टतम अनुमान बस (20 + वोट) के ज्यामितीय औसत है, जो कि बिन में सभी खिताबों के लिए है, माइनस 20
सभी 479 डिब्बे के लिए इष्टतम अनुमान 479-वर्ण आधार -70 स्ट्रिंग के रूप में एन्कोड किया गया है
> 70 वोट खिताब के लिए, खिताब एक विशिष्ट हैशिंग तकनीक का उपयोग करके उत्पन्न 3-अंकों के बेस -36 कोड को निर्दिष्ट किया जाता है जो अन्य> 70 वोट खिताब के साथ कोई टकराव की गारंटी नहीं देता है और vote 70 वोट खिताब का कोई गलत पता नहीं लगाता है। यह अत्याधुनिक तकनीक बिना किसी टकराव के पैदा होने तक यादृच्छिक बिन मायने रखने की कोशिश करने से मिलती-जुलती है।
> 70 वोट शीर्षक कोड और उनके वोट काउंट्स को एक स्ट्रिंग (6 बाइट्स प्रति शीर्षक) में एन्कोड किया गया है, जिसे एक साधारण लुकअप टेबल में बदल दिया जाता है। इसलिए रूटीन में सभी> 70 वोट खिताब के लिए शून्य त्रुटि है।

— COTO
स्रोत

10

इस प्रश्न के लिए पायथन 2, स्कोर = 0.335027, 999 वर्ण, भविष्यवाणी 11.34828

बस गेंद लुढ़कने के लिए है। यह कहीं भी इष्टतम नहीं है।

फैंसी एसवीएम की बात सिर्फ मेरा यादृच्छिक विचार है और मुझे इसे लागू करने जैसा महसूस हुआ, इसलिए यहां यह है। यह 0.02 अंक से आधार रेखा में सुधार करता है, इसलिए मैं इससे काफी खुश हूं। लेकिन यह दिखाने के लिए कि इनपुट में हार्ड-कोडिंग है, जहां से अधिकांश सुधार आता है, मैं कुछ जवाब को भी हार्ड कोड कर रहा हूं।

हार्ड-कोडिंग के बिना स्कोर 0.360 है (और वास्तव में सभी पूर्वानुमान लगभग 11, हाहा हैं)

मैं scikit-learn और nltk का उपयोग कर रहा हूं

import sys
import math
import csv
from sklearn.feature_extraction.text import TfidfVectorizer as TV
from sklearn.svm import SVR
from nltk.stem.porter import PorterStemmer as PS
sd = {}
lr = None
tv = None
with open(sys.argv[1], 'r') as cf:
    sr = csv.reader(cf)
    for sc, t in sr:
        if sc == 'Score':
            continue
        sd[t] = int(sc)
ts,scs = zip(*sd.items())
s = PS()
def analyzer(st):
    r = []
    for word in st.split():
        if word.isdigit():
            r.append('<NUM>')
        elif not word.isalnum():
            r.append('<PUNCT>')
        else:
            r.append(s.stem(word.lower()))
    return r
tv = TV(min_df=25, stop_words='english', analyzer=analyzer)
ti = tv.fit_transform(ts)
lr = SVR()
lr.fit(ti, scs)
d={'4 w':378,'y 42':333,'eeta':280,'an Got':279,'s 2 ':275,"e I'":208,'r CP':203,'? No':179,'B.O':156}
def c(t):
    for s in d.keys():
        if s in t:
            return d[s]
    t = tv.transform([t])
    r = lr.predict(t)[0]+1.5
    return r

— justhalf
स्रोत

मुझे यकीन नहीं है कि मैं समझता हूं - आप किसी बाहरी फ़ाइल से स्कोर पढ़ते हैं? तो क्यों नहीं सिर्फ sd [t] की भविष्यवाणी करें? यह 0 का स्कोर देगा ...

— tori Raviv

2

क्योंकि यह मजेदार नहीं होगा = p

— जस्टफुल

4

पायथन 2, 986 चार्ट, स्कोर 0.3480188, 12 भविष्यवाणी

M,S=14.29,23.02
D=lambda x:[ord(y)-32 for y in x]
w='fiLoNoNuMiNoTiMoShOnLoGoLeThRantexgensuBaSqUnInPeReGaMuLinprOuThInThEvEnClOpExPyThADdiSoLiSiMaTrEqUsImAsCoManstARrePoWoReawhapoLandradeTyPaLOsoReCreprediVeReSpebeTiPrImPladaTrihelmakwhicolpaReValpaTrafoROsoumovfinfunpuzyoufaSeQuiwhecoDeChagivcouchehanpoStrdiGraconjavwricalfrowitbinbrafrabuipoi'
for i in range(26):w=w.replace(chr(65+i),chr(97+i)*2)
w=[w[i:i+3]for i in range(0,372,3)]
m=D("(+),+)+=*...+..++'(*)5)/2)*43++16+0,+33*4*/(0.'+>-)+13+(2?8+6;,3;43+4(+.('(,.*.*+56+6)0((++(B,))+E0,-7/)/*++),+***)2+(3(.*)'")
s=D("))'B)'*j+:51(*3+0')+)^'/<-+MG,-1=),-0:A+T&J&K1%,O*()4Y-%:_A.=A*C]MJ-N%)5(%%-0+).*3Q(M&0'%(+$p*)()a8:-T?%5(-*'/.'+)+@,'J&1'&&")
def G(x,m,s):s=s or 1e-9;return(.4/s)*(2.78**(-(x-m)**2./(2*s*s)))
d={w[i]:(m[i],s[i])for i in range(124)}
def Z(t,c):
 p=1
 for W in t.split():
  if len(W)>3:
   W=W[:3].lower()
   if W in d:p*=G(c,*d[W])
 return p*G(c,M,S)
def J(t):return max([(Z(t,r),r)for r in range(-9,99)])[1]

प्रासंगिक कार्य है J।

कार्यक्रम अनिवार्य रूप से सुविधाओं के रूप में शीर्षक शब्दों का उपयोग करते हुए Naive Bayes है, लेकिन यह चार सीमाओं के लिए बेहद सीमित धन्यवाद है। कैसे प्रतिबंधित? कुंआ...

प्रत्येक शीर्षक के लिए हम निचले मामले में परिवर्तित होते हैं और केवल कम से कम 4 अक्षरों के शब्दों को देखते हैं। फिर हम उन प्रत्येक शब्दों के पहले तीन अक्षरों को सुविधाओं के रूप में लेते हैं । हम चार्ट पर सहेजने के लिए स्ट्रिपिंग विराम चिह्न छोड़ते हैं।
हम केवल पत्र ट्रिपल चुनते हैं जो कम से कम 19 शब्दों की शुरुआत में हैं (ये wऊपर संग्रहीत हैं )। संपीड़न को ट्रिपल को फिर से व्यवस्थित करके किया जाता है ताकि अधिक से अधिक दोगुने अक्षर मौजूद हो सकें, और इन जोड़ियों को उनके अनुरूप ASCII अपरकेस (जैसे FiLoNoN ... → फिल, लोन, नॉन, ...) से बदल दिया जाता है।
प्रत्येक ट्रिपलेट के लिए, हम उन शीर्षकों के अंकों को देखते हैं जिनमें यह प्रकट होता है और अंकों के औसत और मानक विचलन की गणना करता है। फिर हम उन पूर्णांकों में परिवर्तित करते हैं और उन्हें ऊपर, स्टोर करते हैं m, sइस तथ्य का उपयोग करके कि मीन / एसडी अधिकतम 90 हैं (एक प्रत्यक्ष ASCII एन्कोडिंग की अनुमति देते हैं, क्योंकि 95 प्रिंट करने योग्य ASCII हैं)
G सामान्य वितरण कार्य है - हम 2dp पर चक्कर लगाते हैं और वर्णों को बचाने के लिए 2 pi से 1 dp के व्युत्क्रम वर्गमूल।

कुल मिलाकर चरम चार सीमा ने इसे सबसे खराब विचारों में से एक बना दिया है, जो मैं कभी भी आया हूं, लेकिन मैं इस बात से बहुत खुश हूं कि मैं इसमें कितना भी सफल रहा (भले ही यह बहुत अच्छा काम न करे)। अगर किसी को संपीड़न के लिए बेहतर विचार हैं, तो कृपया मुझे बताएं :)

(मेरी व्यर्थ सम्भावनाओं को इंगित करने के लिए केनीटीएम का धन्यवाद)

— Sp3000
स्रोत

जब तक मैंने कोड को गलत तरीके से निष्पादित नहीं किया है, तब तक आपका संपीड़न कोड विघटित परिणाम से अधिक लंबा है ... w='grge…scse';w=[w[i:i+2]for i in range(0,len(w),2)]165 बाइट्स है जबकि आपका C=lambda:…;w=C('…')179 बिट्स है।

— kennytm

@KennyTM ओह धन्यवाद - मैं कोड के साथ बहुत खिलवाड़ कर रहा हूं, चार सीमा को फिट करने की कोशिश कर रहा हूं कि मैंने सभी कम्प्रेस्सिंग का ट्रैक खो दिया है। : पी

— Sp3000 15

4

पायथन 2, 535 वर्ण, स्कोर 0.330910, 11.35 की भविष्यवाणी करता है

प्रत्येक शब्द वाले शीर्षकों के लिए औसत अंक, फिर guess(title)फ़ंक्शन में बेस स्कोर को संभवतः संशोधित करने के लिए शीर्ष और निचले 50 शब्दों का उपयोग करें ।

पायथन कोड:

BASE = 11.35
word={}
for sc,ti in csv.reader(open(sys.argv[1])):
    if sc == 'Score': continue
    parts = re.findall(r"[-a-zA-Z']+", ti.lower())
    for p in parts:
        a, c = word.get(p, (0.0,0))
        word[p] = (a+int(sc), c+1)

rank = sorted([(sc/ct,wd) for wd,(sc,ct) in word.items() if ct > 2])
adjust = rank[:50] + rank[-50:]

def guess(title):
    score = BASE
    parts = re.findall(r"[-a-zA-Z']+", title.lower())
    for sc,wd in adjust:
        if wd in parts:
            score *= 0.7 + 0.3*sc/BASE
    return score

— तर्क नाइट
स्रोत

3

सी

स्कोर: अज्ञात
लंबाई: 5 बाइट्स
भविष्यवाणी: 5

golfed:

int s(char *p){return 5;}

Ungolfed:

int s(char *p)
{
   return 5;
}

स्कोर की एक क्वेरी औसतन 5 अंक देती है।

मुझे फिलहाल इसका परीक्षण करने की क्षमता नहीं मिली है, दूसरों को चलाने / संपादित करने का स्वागत है।

— Joshpbarron
स्रोत

इसके अलावा आगे बढ़े: int s () {वापसी 5;}

— जोशुआ

"आपको इसके लिए एक प्रोग्राम या फ़ंक्शन लिखने की चुनौती दी गई है, जो इनपुट के रूप में PPCG प्रश्न का शीर्षक लेता है, और इसके स्कोर की भविष्यवाणी करता है।" - क्षमा करें, लेकिन शून्य: 0

— जोशपब्रॉन 21

मैंने एक मंच देखा है जिसके द्वारा यदि आप मुख्य () भूल गए हैं, तो आपका पहला कार्य मुख्य () था। शायद वह उस पर निर्भर है।