Cosa rende la domanda ideale? Forse è semplicemente l'astrazione di un pensiero profondo e l'inizializzazione di un sogno, una speranza, un pensiero, un (... 5.024,2 caratteri omessi ). Pertanto, propongo di trovare un tale fattore per quantificare le domande. Propongo anche che questo fattore sia chiamato Q _F , o fattore Q. Determino il fattore Q di una domanda in questo modo:

(Ricordalo .)

Obiettivo Dato un numero come input, determinare il fattore Q della rispettiva domanda su PPCG.SE. Se la domanda non esiste, emetti semplicemente ;-;(l'emote che piange).

Prendi, per esempio ,. ( questa domanda ):

Il voto netto, in questo caso, significa .

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

Così:

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

Si prega di fornire almeno 2 cifre significative su Q _F .

Questo è un codice-golf , quindi vince il programma più breve in byte.

Nota: includere tre esempi del programma in esecuzione, uno dei quali deve essere questa domanda. Gli altri due sono i tuoi a decidere. (Questo è solo un controllo di conferma.) Riporta anche l'ora in cui hai inserito la query.

Julia, 411 382 367 355 353 byte

È abbastanza lungo ma sono molto contento che funzioni!

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

Ciò crea una funzione senza nome che accetta un numero intero come input e restituisce un valore float.

Richiede il Requestspacchetto, che può essere installato utilizzando Pkg.add("Requests"). Quel pacchetto fornisce metodi Base.get()per l'invio di richieste HTTP. Importa anche il JSONpacchetto (da cui dipende, quindi non è necessario installarlo separatamente) che utilizziamo per analizzare l'output JSON nella risposta.

Ungolfed:

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

Grazie a Dennis e Martin Büttner per l'aiuto nel golf!

Mathematica 10, 381 byte

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]]})&

Solo tre query API e molta indicizzazione, davvero. La parte più difficile è stata cercare di capire come ottenere editsdal disponibile revisions, spero di aver capito bene.

Python 2, 392 byte

Beh, ci ho provato.

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

Logica molto simile alla risposta Julia di Alex . Mi piacerebbe passare in rassegna questo per vedere quale domanda è la più ideale, ma preferirei non chiamare continuamente l'API per ore e ore.

Groovy, 459 457 byte

Praticamente come il resto delle risposte.

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()))}

Salvato 2 byte grazie a Cᴏɴᴏʀ O'Bʀɪᴇɴ!

Ungolfed:

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)