Qu'est-ce qui fait la question idéale? Ce n'est peut-être que l'abstraction d'une pensée profonde et l'initialisation d'un rêve, d'une espérance, d'une pensée, d'un (… 5 024,2 caractères omis ). Par conséquent, je propose que nous trouvions un tel facteur pour quantifier les questions. Je propose également que ce facteur soit appelé Q _F , ou le facteur Q. Je détermine le facteur Q d'une question comme suit:

(Rappelez-vous cela .)

Objectif Étant donné un nombre en entrée, déterminez le facteur Q de la question respective sur PPCG.SE. Si la question n'existe pas, sortez simplement ;-;(l'emote qui pleure).

Prenez, par exemple ,. ( cette question ):

Les votes nets, dans ce cas, signifient .

views     = 23435
net votes = 33
edits     = 6
answers   = 30, answers^2 = 900
comments  = 19
charsIOPN = "Joe Z.".length = 6

Donc:

r_F = 6 / 6 = 1
Q_F = r_F * (23435 * 33 + 6) / (900 - 19)
    =  1  *      773361      /    881
    ~ 877.821793

S'il vous plaît fournir au moins 2 chiffres significatifs sur Q _F .

Il s'agit d'un code-golf , donc le programme le plus court en octets l'emporte.

Remarque: veuillez inclure trois exemples de votre programme en cours d'exécution, dont l'un doit être cette question. Les deux autres sont à vous de décider. (Il s'agit simplement d'une vérification de confirmation.) Indiquez également l'heure à laquelle vous avez entré la requête.

Julia, 411 382 367 355 353 octets

C'est assez long mais je suis très content que ça marche!

using Requests
n->(R(t)=readall(get(t));G(t)=JSON.parse(R("http://api.stackexchange.com/2.2/questions/$t?site=codegolf"))["items"];j=G(n)[1];d=parse(Int,match(r"<span \S+n (\d+)",R("http://codegolf.xyz/posts/$n/revisions")).captures[1]);d/length(j["owner"]["display_name"])*(j["view_count"]*j["score"]+d)/(j["answer_count"]^2-length(G("$n/comments"))))

Cela crée une fonction sans nom qui prend un entier en entrée et renvoie un flottant.

Il nécessite le Requestspackage, qui peut être installé à l'aide de Pkg.add("Requests"). Ce package fournit des méthodes Base.get()pour soumettre des requêtes HTTP. Il importe également le JSONpackage (dont il dépend, de sorte qu'il n'a pas besoin d'être installé séparément) que nous utilisons pour analyser la sortie JSON dans la réponse.

Non golfé:

using Requests

function f(n::Int)
    # Define a function to submit an HTTP request and read
    # the response, returning a string
    R(t) = readall(get(t))

    # Define a function that submits a request, reads all text
    # as JSON, parses it, and extracts the items field
    G(t) = begin
        api = "http://api.stackexchange.com/questions"
        JSON.parse(R("$api/$t?site=codegolf"))["items"]
    end

    # Get the data for the question using the API
    j = G(n)[1]

    # Scrape the number of edits from the revision history HTML
    # using minxomat's handy shortened PPCG URL
    h = R("http://codegolf.xyz/posts/$n/revisions")
    d = parse(Int, match(r"<span \S+n (\d+)", h).captures[1])

    # Compute the coefficient r_F
    r = d / length(j["owner"]["display_name"])

    # Compute the Q-factor
    Q = r * (j["view_count"] * j["score"] + d) /
        (j["answer_count"]^2 - length(G("$n/comments")))

    return Q
end

Merci à Dennis et Martin Büttner pour leur aide au golf!

Mathematica 10, 381 octets

f=(a=StringTemplate["http://api.stackexchange.com/``````?site=codegolf"];j=Import[a["questions/",#,""],"JSON"];c=Import[a["questions/",#,"/comments"],"JSON"];r=Import[a["posts/",#,"/revisions"],"JSON"];N[#5/#6*(#1*#2+#5)/(#3^2-#4)]&@@j[[3,2,1,{5,2,12},2]]~Join~{Length@c[[3,2]],Length@DeleteCases[r[[3,2]],_?(("revision_type"/.#)=="vote_based"&)],StringLength@j[[3,2,1,3,2,6,2]]})&

Juste trois requêtes API et beaucoup d'indexation, vraiment. La partie la plus difficile était d'essayer de comprendre comment obtenir editsdu disponible revisions, j'espère avoir bien compris.

Python 2, 392 octets

Eh bien, je l'ai essayé.

from requests import*;from re import*;l=len
def i(n):
 try:s,r="http://api.stackexchange.com/2.2/questions/%s?site=codegolf","http://codegolf.xyz/posts/%i/revisions"%n;q,c=s%n,s%('%i/comments'%n);i=get(q).json()['items'][0];m=float(l(findall("<span \S+n (\d+)",get(r).text)));r=m/l(i["owner"]["display_name"]);print r*(i["view_count"]*i["score"]+m)/(i["answer_count"]**2-m)
 except:print';-;'

Logique très similaire à la réponse d' Alex à Julia . Je voudrais parcourir cette question pour voir quelle question est la plus idéale, mais je préfère ne pas appeler continuellement l'api pendant des heures.

Groovy, 459 457 octets

Un peu comme le reste des réponses.

import groovy.json.JsonSlurper
import java.util.zip.GZIPInputStream
def f={n->def j,d,u={p->new JsonSlurper().parseText(new GZIPInputStream("http://api.stackexchange.com/2.2/questions/$p?site=codegolf".toURL().getContent()).getText()).items}
j=u(n)[0]
d=("http://codegolf.xyz/posts/$n/revisions".toURL().text=~/<span \S+n (\d+)/).getCount()
println((d/j.owner.display_name.length())*(j.view_count*j.score+d)/(j.answer_count**2-u("$n/comments").size()))}

Enregistré 2 octets grâce à Cᴏɴᴏʀ O'Bʀɪᴇɴ!

Non golfé:

import groovy.json.JsonSlurper
import java.util.zip.GZIPInputStream

def f = { n->

    def stackApi = "http://api.stackexchange.com/2.2"

    // Fetch json from stackexchange rest api
    def getItems = { pathParam ->
        //Stackexchange compresses data, decompress before parsing json
        def httpData = "$stackApi/questions/$pathParam?site=codegolf".toURL().getContent()
        def deCompressedData = new GZIPInputStream(httpData).getText()
        def json = new JsonSlurper().parseText(deCompressedData)
        return json.items
    }

    // Get the edit count from the html page
    def htmlPage = "http://codegolf.xyz/posts/$n/revisions".toURL()
    def editCount = (htmlPage.text=~/<span \S+n (\d+)/).getCount()

    // apply formula
    def json = getItems(n)[0]
    def r = editCount/json.owner.display_name.length()
    def Q = r * ( json.view_count * json.score + editCount) /
                (json.answer_count**2 - getItems("$n/comments").size())
    println(Q)
}

f(16327)