Sono un giocatore di golf molto casual e spesso non vedo i post finché non vengono visualizzati nella barra laterale "Domande sulla rete" su StackOverflow. Di solito, sono in ritardo al gioco e poiché l'unica lingua che conosco è Python, c'è poco senso in me rispondere poiché ci sono già diverse risposte Python. La tua sfida è capire se vale la pena rispondere a una domanda.

Ingresso:

• Il tuo codice (funzione o programma) prenderà un parametro di input i

Produzione:

• Valore Verità o Falsey per ID domanda i. Output Verità se la domanda ha più di 5 risposte, più di 3 punteggio di domanda e una o meno risposte in Python (nessuna distinzione tra versione).

Regole / Chiarimenti:

• Il formato di input può essere ragionevole (stdin, file, riga di comando), ma deve essere specificato nella risposta. I tipi di dati e gli spazi bianchi iniziali / finali non contano.
• Supponiamo che l'ID domanda sia valido per codegolf.stackexchange.com.
• Ignora i requisiti delle domande specifiche della lingua. (ovvero se una domanda incontra voti e risposte e non ha risposte Python perché è solo Java, si traduce comunque in Verità).
• Una risposta si qualifica come una risposta Python se "python" (senza distinzione tra maiuscole e minuscole) si verifica ovunque prima della prima nuova riga del post.
• Questo è il codice golf, quindi vince il codice più breve in byte.

Esempi di casi *

id = 79082 => True
id = 78591 => False (less than 5 answers, also hella hard)
id = 78410 => True
id = 76428 => False (greater than 1 Python answer)
id = 78298 => False (not high enough question score)

* Verificato al momento della pubblicazione, potrebbe essere cambiato

05AB1E , 167 160 159 158 156 154 143 byte

Dannazione, quasi quanto un linguaggio normale ...

Merda ... più a lungo attualmente battendo la risposta di Ruby di 1 byte.

Ora più a lungo della risposta di Ruby, argh! .

Probabilmente dovrei andare a letto adesso.

Grazie a @wnnmaw per aver salvato 1 byte e grazie a @R. Kap per aver salvato altri 2 byte!

Codice:

’£Ø ˆå§¾.‡¢ as g;#.¾¿„–(g.ˆåƒÛ('·Ç://ÐÏg.´¢/q/'+•œ_#()).‚Ø())’.e©’„à="Ž»"’DU¢®…ƒŠ‡¡`99£þs\®X¡¦vy’„à="‚¬-„¹"’¡¦'>¡¦¦¬l’±¸’¢s\}rUV)O2‹X5›Y3›)P

O con più leggibilità:

’£Ø ˆå§¾.‡¢ as g;#.¾¿„–(g.ˆåƒÛ('·Ç://ÐÏg.´¢/q/'+•œ_#()).‚Ø())’
 .e©
’„à="Ž»"’
 DU¢®
“ƒŠ‡“
 ¡`99£þs\®X¡¦
v
 y’„à="‚¬-„¹"’¡¦'>¡¦¦¬l’±¸’¢s\}rUV)O2‹X5›Y3›)P

Spiegazione:

Prima di tutto, un sacco di testo viene compresso qui, il che si traduce in un buon vecchio Python. La versione non compressa è:

"import urllib.request as g
 f=g.urlopen('http://ppcg.lol/q/'+pop_#())
 #.append(f.read())"
.e©“class="answer"“¢®"useful and clear"¡`99£þs\®“class="answer"“¡¦vy“class="post-text"“¡¦'>¡¦¦¬l"python"¢s\}rUV)O2‹X5›Y3›)P

Questa parte:

import urllib.request as g
stack.append(g.urlopen('http://ppcg.lol/q/'+pop_stack()).read())`

apre effettivamente un valore di stack, lo copia nell'URL e recupera tutti i dati HTML. I dati HTML vengono inviati in cima allo stack usando#.append(f.read()) .

Contiamo il numero di risposte , contando il numero di occorrenze di class="answer".

Per contare il numero di voti, abbiamo semplicemente diviso i dati in "utile e chiaro" e manteniamo solo i valori delle cifre di [0:99] dell'uso ®"useful and clear"¡`99£þ. Questo è il numero di voti positivi.

Alla fine, dobbiamo controllare ogni risposta se il testo "Python"esiste prima del testo dell'intestazione di chiusura. Per ottenere tutte le risposte, abbiamo semplicemente diviso i daticlass="post-text" e divisi nuovamente ciascuno di essi <. Rimuoviamo i primi due elementi per ottenere la parte in cui viene visualizzata la lingua e controlliamo se la versione minuscola è in questa stringa.

Quindi, ora il nostro stack è simile a questo per id = 79273:

`[6, '14', 0, 0, 0, 1, 0, 0]`
  │    │   └───────┬──────┘
  │    │           │
  │    │   is python answer?
  │    │
  │    └── number of upvotes
  │
  └─── number of answers

Questo può essere visto anche con -d bandiera ebug sull'interprete.

Quindi, è solo una questione di elaborazione dei dati:

rUV)O2‹X5›Y3›)P

r                # Reverse the stack
 U               # Pop the number of answers value and store into X
  V              # Pop the number of upvotes value and store into Y
   )O            # Wrap everything together and sum it all up
     2‹          # Check if smaller than 2
       X5›       # Push X and check if greater than 5
          Y3›    # Push Y and check if greater than 3
             )P  # Wrap everything into an array and take the product.
                   This results into 1 if and only if all values are 1 (and not 0).

Utilizza la codifica CP-1252 . Puoi scaricare l'interprete qui .

Python 3.5, 280 272 260 242 240 byte:

( Grazie ad Adnan per il trucco sull'uso *dell'operatore nei confronti risultanti in 2 byte salvati! )

def g(o):import urllib.request as u,re;R=re.findall;w=bytes.decode(u.urlopen('http://ppcg.lol/q/'+o).read());print((len(R('(?:<h[0-9]>|<p>).*python',w.lower()))<2)*(int(R('(?<="vote-count-post ">)[0-9]+',w)[0])>3)*w.count('answercell">')>5)

Abbastanza semplice. Utilizza la urlliblibreria integrata di Python per accedere al sito della domanda, quindi utilizza espressioni regolari per trovare il conteggio dei voti, il conteggio delle risposte e il conteggio delle risposte specifiche di Python nel testo decodificato restituito dal sito Web. Infine, questi valori vengono confrontati con le condizioni richieste per restituire un truthyvalore e, se soddisfano tutte le condizioni, Truevengono restituiti. Altrimenti lo Falseè.

L'unica cosa di cui potrei essere preoccupato qui è che le espressioni regolari lasciano molto spazio ai termini in termini di numero di risposte specifiche di Python per salvare byte, quindi a volte può essere un po 'inaccurato, anche se probabilmente è abbastanza buono per gli scopi di questa sfida. Tuttavia, se vuoi uno molto più preciso, ne ho aggiunto uno qui sotto, anche se è più lungo di quello sopra. Quella mostrata di seguito è attualmente di 298 byte poiché utilizza un'espressione regolare molto più lunga - una che non si può sapere quanto tempo ci ho messo a scoprire - per contare le risposte di Python rispetto alla mia funzione originale per motivi di precisione. Questo dovrebbe funzionare per circa l'80% -90% di tutti i casi di test che gli vengono lanciati.

def g(o):import urllib.request as u,re;R=re.findall;w=bytes.decode(u.urlopen('http://ppcg.lol/q/'+o).read());print(len(R('(?<=answercell">).*?(?:<h[0-9]>|<strong>)[^\n]*python[^\n]*(?=</h[0-9]>|</strong>)',w.lower()))<2and int(R('(?<="vote-count-post ">)[0-9]+',w)[0])>3and w.count('answercell">')>5)

Ma che dire di quelle domande con più pagine di risposte? Nessuna delle precedenti funzionerà molto bene in quella situazione, se, diciamo, 1 risposta di Python è nella prima pagina e un'altra è nella seconda. Bene, mi sono preso la libertà di risolvere questo problema creando un'altra versione della mia funzione (mostrata di seguito) che controlla ogni pagina di risposte, se ne esistono più, per le risposte di Python, e ha funzionato abbastanza bene su molti dei casi di test che ho l'ho lanciato. Bene, senza ulteriori indugi, ecco la funzione nuova e aggiornata:

def g(o):
 import urllib.request as u,re;R=re.findall;w=bytes.decode(u.urlopen('http://ppcg.lol/q/'+o).read());t=0if len(re.findall('="go to page ([0-9]+)">',w))<1else max([int(i)for i in re.findall('="go to page ([0-9]+)">',w)])
 if t<1:print(len(R('(?<=answercell">).*?(?:<h[0-9]>|<strong>)[^\n]*python[^\n]*(?=</h[0-9]>|</strong>)',w.lower(),re.DOTALL))<2and int(R('(?<="vote-count-post ">)[0-9]+',w)[0])>3and w.count('answercell">')>5)
 else:
  P=[];U=[];K=[]
  for i in range(2,t+2):P.append(len(R('(?<=answercell">).*?(?:<h[0-9]>|<strong>)[^\n]*python[^\n]*(?=</h[0-9]>|</strong>)',w.lower(),re.DOTALL)));U.append(int(R('(?<="vote-count-post ">)[0-9]+',w)[0]));K.append(w.count('answercell">'));w=bytes.decode(u.urlopen('http://ppcg.lol/questions/'+o+'/?page='+str(i)).read())
  print(sum(P)<2and U[0]>3and sum(K)>5);print('# Python answers: ',sum(P));print('# Votes: ',U[0]);print('# Answers: ',sum(K))

Abbastanza a lungo, vero? Non stavo davvero andando molto per il golf del codice con questo, anche se, se vuoi, posso giocarci un po 'di più. Altrimenti, lo adoro e non potrei essere più felice. Oh, ho quasi dimenticato, come bonus aggiuntivo, che genera anche il numero totale di risposte Python sulla domanda, i voti totali sulla domanda e il numero totale di risposte sulla domanda se la domanda idcorrisponde a una domanda con più di 1 pagina di risposte. Altrimenti, se la domanda consiste solo in una singola pagina di risposte, restituisce semplicemente il truthy/falsyvalore. Mi sono davvero lasciata trasportare da questa sfida.

Ognuno di questi prende la domanda idsotto forma di una stringa .

Vorrei mettere i Try It Online!collegamenti qui per ogni funzione, ma sfortunatamente, repl.itné Ideonepermetterei né il recupero delle risorse tramite la urlliblibreria di Python .

Julia, 275 byte

using Requests
f(q,p=(s,t)->JSON.parse(readall(get("https://api.stackexchange.com/2.2/questions/$q$s",query=Dict(:site=>"codegolf",:filter=>"$t"))))["items"],x=p("","")[1])=x["answer_count"]>5&&x["score"]>3&&count(i->ismatch(r"python",i["body"]),p("/answers","!9YdnSMKKT"))<2

Questa è una funzione che accetta un numero intero e restituisce un valore booleano. Si collega all'API Stack Exchange e ogni esecuzione della funzione effettua 2 richieste API, quindi non eseguirla troppe volte o esaurirai la tua quota di 300 richieste / giorno.

Ungolfed:

using Requests

function f(q)
    # Define a function that takes two strings and returns a Dict
    # that connects to the SE API
    p = (s,t) -> JSON.parse(readall(get("https://api.stackexchange.com/2.2/questions/$q$s",
        query = Dict(:site => "codegolf", :filter=> "$t"))))["items"]

    # Get the question object
    x = p("", "")[1]

    # Get all answers using the `withbody` API filter
    y = p("/answers", "!9YdnSMKKT")

    x["answer_count"] > 3 && x["score"] > 5 &&
        count(i -> ismatch(r"python", i["body"], y) < 2
end

Racchetta, 339 byte

(λ(q)((λ(h)((λ(g)((λ(j)(and(>(h j'score)3)(>(h j'answer_count)5)(<(for/sum([a(g"~a/answers"q)]#:when(regexp-match #rx"(?i:python)"(h a'body)))1)2)))(car(g"~a"q))))(λ(s d)(define-values(x y b)(http-sendrecv"api.stackexchange.com"(format"/2.2/questions/~a?site=codegolf&filter=withbody"(format s d))))(h(read-json b)'items))))hash-ref))

C'è ancora molto da golf.

Rubino + HTTParty , 170 146 145 142 139 138 + 11 ( -rhttpartybandiera) = 181 157 156 153 150 149 byte

Non credo che ci siano casi limite che potrebbero rompere i miei schemi regex, spero ...

Aggiornato al collegamento fornito da @WashingtonGuedes e scoprendo che HTTParty non si lamenta se inizio con //invece di http://.

Aggiornato per regex leggermente più sicuri. Ho comunque salvato i byte scoprendo che gli oggetti di risposta HTTParty ereditano da String, il che significa che non ho nemmeno bisogno di usare.body per abbinare il regex!

@manatwork ha sottolineato un'aggiunta accidentale al personaggio che avevo lasciato, e per il bene del golf, ora ideve essere accettato come String.

Regex aggiornati. Stessa lunghezza. -1 byte tagliando una parentesi.

->i{/"up.*?(\d+)/=~s=HTTParty.get("//ppcg.lol/q/"+i)
$1.to_i>3&&(a=s.scan /st.*xt".*\n(.*)/).size>5&&a[1..-1].count{|e|e[0]=~/python/i}<2}

Note extra:

• La prima riga di una risposta (che dovrebbe contenere la lingua in base alle specifiche) è di due righe dopo il tag HTML con classe "post-text" , a cui abbiamo abbinatost.*xt" . Una versione più sicura avrebbe aggiunto uno spazio dopo di esso, ma lo stiamo sacrificando per amore del golf.
• HTTParty viene utilizzato sui net/httpmoduli nativi a causa della corretta gestione del reindirizzamento per l'URL specificato.
• "up*?\dè stata la sequenza più breve che ho trovato che corrispondeva al numero di voti. Abbiamo solo bisogno del primo, quindi per fortuna le risposte non incidono su questo.

Groovy, 179 161 157

{i->t=new URL("http://ppcg.lol/q/$i").text;a=0;p=0;(t=~/"(?i)p.{25}>\n.*python/).each{p++};(t=~/(?m)v.{13}t ">(\d+)/).each{if(it[1].toLong()>3)a++};a>5&&p<2}

Grazie a Timtech 17 caratteri salvati.

Anche la parola chiave def non è necessaria.