¿Qué hace la pregunta ideal? Quizás sea simplemente la abstracción de un pensamiento profundo y la inicialización de un sueño, una esperanza, un pensamiento, un (... 5.024,2 caracteres omitidos ). Por lo tanto, propongo que encontremos ese factor para cuantificar las preguntas. Propongo también que este factor se llame Q _F , o el factor Q. Determino el factor Q de una pregunta de la siguiente manera:

(Recordemos eso )

Objetivo Dado un número como entrada, determinar el factor Q de la pregunta respectiva en PPCG.SE. Si la pregunta no existe, simplemente envíe ;-;(el emoticón que llora).

Tomemos, por ejemplo ,. ( esta pregunta ):

Los votos netos, en este caso, significa .

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

Entonces:

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

Por favor proporcionar por lo menos 2 cifras significativas sobre Q _F .

Este es un código de golf , por lo que gana el programa más corto en bytes.

Nota: Incluya tres ejemplos de ejecución de su programa, uno de los cuales debe ser esta pregunta. Los otros dos son tuyos para decidir. (Esto es solo una verificación de confirmación). También informe la hora a la que ingresó la consulta.

Julia, 411 382 367 355 353 bytes

¡Es bastante largo pero estoy muy contento de que funcione!

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

Esto crea una función sin nombre que toma un entero como entrada y devuelve un flotante.

Requiere el Requestspaquete, que se puede instalar usando Pkg.add("Requests"). Ese paquete proporciona métodos Base.get()para enviar solicitudes HTTP. También importa el JSONpaquete (del que depende, por lo que no es necesario instalarlo por separado) que usamos para analizar la salida JSON en la respuesta.

Sin 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

¡Gracias a Dennis y Martin Büttner por la ayuda en el golf!

Mathematica 10, 381 bytes

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 tres consultas API y mucha indexación, de verdad. La parte más difícil fue tratar de entender cómo obtener editsde lo disponible revisions, espero haberlo hecho bien.

Python 2, 392 bytes

Bueno, lo intenté.

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

Lógica muy similar a la respuesta de Alex a Julia . Me gustaría recorrer esto para ver qué pregunta es la más ideal, pero prefiero no llamar continuamente a la API durante horas.

Groovy, 459 457 bytes

Más o menos como el resto de las respuestas.

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

¡Ahorré 2 bytes gracias a Cᴏɴᴏʀ O'Bʀɪᴇɴ!

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