Saluti, nobili golfisti. Oggi risolverai i dibattiti più antichi e distinti: Emacs o Vim?

La tua sfida è quella di prendere due termini di ricerca come input e produrre quale di questi termini ha il maggior numero di risultati di ricerca di Google. (Questo è ovviamente del tutto corretto. Cosa vuoi dire, di parte?)

Ecco alcuni esempi di ingressi e uscite:

Input: emacse vim
Output: vim(totalmente non creando alcuna fiamma-guerra nei commenti)

Ingresso: googlee microsoft
uscita:google

Input: code golf stack exchangee code review stack exchange
Output: code golf stack exchange(sì!)

E qui ci sono alcuni casi limite solo per divertimento (e per testare le tue soluzioni):

Ingresso: About 1,000,000 resultse About 100,000 results
uscita:About 100,000 results

Input: This will autocotrecte Another testcase
Output: Another testcase(se non consideri la correzione automatica, allora il primo vincerà)

Per i seguenti casi di test, è necessario rimuovere prima i #segni nei termini di ricerca, poiché si basano sul fatto che il termine abbia una quantità specifica di risultati e la pubblicazione del termine qui lo rovinerebbe.

Input: Thissear#chter#mhasno#resultse Another testcase
Output: Another testcase(solo un test per zero risultati)

Input: "These exact wo#rds do#n't exi#st# on the Internet"e Another testcase
Output: Another testcase(test ")

Input: Abo#ut 1,65#2,85#3,2#86 re#sultse Another testcase
Output: Another testcase(questo è complicato - il termine di ricerca sopra ha un risultato)

Input: "Abo#ut 4#8,234,8#75,14#7 res#ults"e Another testcase
Output: Another testcase(anche difficile - nessun risultato, quindi visualizza il termine di ricerca)

Non è necessario gestire il caso angolare delle "quoted"ricerche che restituiscono "Nessun risultato, mostrando invece i risultati senza virgolette" perché sarebbe troppo complicato. Non è nemmeno necessario gestire input con lo stesso numero di risultati.

Questo è code-golf , quindi vincerà il codice più breve in byte!

Fattore , 305 201 196 200 201 188 184 182 179 169 178 171 165 199 171 170 165 163 byte

Un linguaggio quasi prolisso come Java, che batte Ruby ... e Powershell! : D

Meglio regex, ora. Grazie a @fede s. per 5 byte di sconto!

[ dup [ url-encode "google.com/search?nfpr=1&q="prepend http-get R/ s">About [\d,]+/ first-match " "split second 10 >base ] map zip [ last ] sort-with last first ]

O 159 157 se l'output può essere simile a { "vim" 9782948234 }:

[ dup [ url-encode "google.com/search?nfpr=1&q="prepend http-get R/ s">About [\d,]+/ first-match " "split second 10 >base ] map zip [ last ] sort-with last ]

D'altra parte, se vogliamo essere inammissibili, per 199 196 193 byte :

[ dup [ url-encode "google.com/search?nfpr=1&q="prepend scrape-html nip dup "resultStats"find-by-id-between second text>> " "split second string>number ] map zip [ last ] sort-with last first ]

Immutabile perché analizza l'HTML, quindi molto più robusto delle risposte usando regex.

Rubino, 203 180 byte

->*s{s.map{|x|[(open("http://www.google.com/search?nord=1&q=#{URI.escape x}&nfpr=1").read.match(/s">(About )?([\d,]+) result/)||[?0])[-1].split(?,).join.to_i,x]}.max[1]}

+11 byte per il -ropen-uriflag (più spazio).

L'input è preso come due argomenti.

Spiegazione URL:

• ?nord=1: impedisce il reindirizzamento automatico da HTTP a HTTPS
• &q=#{URI.escape x}: sfugge alla query, quindi "funziona
• &nfpr=1: nessuna correzione automatica

Il tutto mapsi trasforma ['emacs','vim']in [[2150000, 'emacs'], [14900000, 'vim']]. (Puoi vedere questo cambiando .max[1]alla fine in .inspect.) Quindi, maxviene preso, che afferrerà quello con il maggior numero di risultati e [1]viene usato per ottenere il termine di ricerca.

Degli editor di testo menzionati nel problema, solo uno di loro può risolverlo da solo ...

Emacs: 137 sequenze di tasti

<C-o><C-u><C-k>(if(<<C-y><C-y><M-<><C-n><F3><C-a>http://google.com/search?nfpr=1&q=<C-S-e><M-x>r-st<RET> <RET>+<RET><C-a><C-k><M-x>b-em<RET><C-y><RET><C-x><C-q><C-s><RET>ts"><RET><M-z><<C-x>0<C-y>0 r<C-a><C-M-s><RET>[0-9]<RET><C-b><M-z> <C-a><C-y><C-k><C-S-a><M-x><up><up><RET>,<RET><RET><F4><C-n><F4><C-e>)(next-line)())<C-x><C-e><C-n><C-a><C-k><C-x>h<DEL><C-y>

Si aspetta che i primi termini di ricerca siano sulla prima riga e i secondi termini di ricerca sulla seconda riga, con il cursore all'inizio del buffer.

Per chi non ha familiarità con Emacs,

• C-ssignifica Ctrl-S.
• M-zsignifica Alt-Z( Altè probabilmente la tua meta chiave)
• M-<significa Alt-<oAlt-Shift-,
• C-S-e si intende Ctrl-Shift-e

Per chi ha familiarità con Emacs,

• Inizia emacs con emacs -q. Questo non carica il tuo .emacsfile, quindi qualsiasi pacchetto di fantasia non si integra con questo.

Spiegazione

1. Scrivi l'inizio della shell di istruzioni elisp

   • <C-o><C-u><C-k> Salva gli argomenti con una nuova riga
   • (if(<<C-y><C-y> Scrivi l'inizio dell'istruzione if e posiziona 2 copie degli argomenti
   • <M-<><C-n> Passa alla seconda riga

2. Definire la macro HTTP. Ciò converte l'argomento in un URL di ricerca di Google e quindi restituisce il numero di risultati della ricerca.

   • <F3> Inizia a definire la macro della tastiera
   • <C-a> Passa all'inizio del termine di ricerca.
   • http://google.com/search?nfpr=1&q= Prepara l'URL di ricerca
   • <C-S-e><M-x>r-st<RET> <RET>+<RET> Sostituisci tutti gli spazi con i segni +.
   • <C-a><C-k><M-x>b-em<RET><C-y><RET>Emacs recupera il codice HTML non elaborato ( b-emè l'abbreviazione di browse-url-emacs)
   • <C-x><C-q> Rendi il file scrivibile (richiesto in modo che la macro non si guasti)
   • <C-s><RET>ts"><RET> Passa al numero di risultati div (devi fare una ricerca regolare perché le macro di emacs si basano sull'isearch per funzionare)
   • <M-z><Taglia il testo del diff (ecco perché era richiesto)
   • <C-x>0 Torna al buffer originale
   • <C-y>0 r;; Rimetti i risultati sulla linea ('0 r' non gestisce risultati)
   • <C-a><C-M-s><RET>[0-9]<RET><C-b><M-z> <C-a><C-y><C-k>;; Estrai il numero dalla stringa.
   • <C-S-a><M-x><up><up><RET>,<RET><RET> Strisce virgole fuori dal numero
   • <F4> Termina la macro della tastiera

3. Spostati verso il basso ed esegui la macro della tastiera sulla riga successiva.

   • <C-n> Passa alla riga successiva
   • <F4> Ripeti la macro una volta.

4. Termina l'istruzione elisp ed eseguila

   • <C-e>)(next-line)()) Termina la frase elisp
   • <C-x><C-e> Valuta il comando elisp
   • <C-n><C-a><C-k> Uccidi l'argomento vincente
   • <C-x>h<DEL> Elimina tutto il resto
   • <C-y> Incolla l'argomento vincente

Esegui te stesso

Fortunatamente non è necessario digitare perfettamente tutte queste battute! La carne e le patate sono tutte in una macro che puoi semplicemente copiare e incollare. La macro può essere copiata e incollata in emacs!

1.Modifica la macro della tastiera <C-x><C-k><C-e>
2.Invia questo in tutto il buffer (incolla dovrebbe essere <C-y>)

;; Keyboard Macro Editor.  Press C-c C-c to finish; press C-x k RET to cancel.
;; Original keys: C-a http://google.com/search?nfpr= 1&q= S-C-e M-x r-st RET SPC RET + RET C-a C-k M-x b-em RET C-y RET C-x C-q C-s RET ts"> RET M-z < C-x 0 C-y 0 SPC r C-a M-C-s [0-9] 5*DEL RET [0-9] RET C-b M-z SPC C-a C-y C-k S-C-a M-x 2*<up> RET , 2*RET
Command: last-kbd-macro
Key: none
Macro:
C-a         ;; move-beginning-of-line
http://google.com/search?nfpr=  ;; self-insert-command * 30
1&q=            ;; self-insert-command * 4
S-C-e
M-x         ;; execute-extended-command
r-st            ;; self-insert-command * 4
RET         ;; newline
SPC         ;; self-insert-command
RET         ;; newline
+           ;; self-insert-command
RET         ;; newline
C-a         ;; move-beginning-of-line
C-k         ;; kill-line
M-x         ;; execute-extended-command
b-em            ;; self-insert-command * 4
RET         ;; newline
C-y         ;; yank
RET         ;; newline
C-x C-q         ;; read-only-mode
C-s         ;; isearch-forward
RET         ;; newline
ts">            ;; self-insert-command * 4
RET         ;; newline
M-z         ;; zap-to-char
<           ;; self-insert-command
C-x 0           ;; delete-window
C-y         ;; yank
0           ;; self-insert-command
SPC         ;; self-insert-command
r           ;; self-insert-command
C-a         ;; move-beginning-of-line
M-C-s           ;; isearch-forward-regexp
RET         ;; newline
[0-9]           ;; self-insert-command * 5
RET         ;; newline
C-b         ;; backward-char
M-z         ;; zap-to-char
SPC         ;; self-insert-command
C-a         ;; move-beginning-of-line
C-y         ;; yank
C-k         ;; kill-line
S-C-a
M-x         ;; execute-extended-command
2*<up>          ;; previous-line
RET         ;; newline
,           ;; self-insert-command
2*RET           ;; newline

3. Digitare <C-c><C-c>per salvare la macro.
4. Se segui i passaggi della spiegazione, sostituisci il passaggio 2 con <F4>per eseguire la macro (o eseguila da sola per provare)

Avvertenze

1. Non è possibile eseguire la macro sulla stessa ricerca due volte senza uccidere il buffer in cui viene caricato l'HTML. Uccidi i buffer
   • <C-x><k> search<TAB>
   • Scegli uno dei buffer in questo elenco per uccidere.
   • Ripetere l'operazione per tutti i buffer che iniziano con "cerca"
2. Se esegui troppo la macro, Google penserà che sei un robot e bloccherà l'accesso per volta
   • Se la macro restituisce qualcosa del genere <input type="submit" name="submit" value="Submit"...>, probabilmente si è verificato.
   • Puoi confermarlo guardando l'HTML grezzo ( <C-x><C-b>e scegliere il buffer con il termine di ricerca in esso).
   • Se vedi cose su robot e captcha, Google ti sta bloccando. Non è colpa mia.

Java, 828 800 783 744 739 687 byte

import java.net.*;import java.util.*;import java.util.regex.*;interface G{static Scanner s(String a)throws Exception{URL u=new URL("http://google.com/search?q="+a);HttpURLConnection c=(HttpURLConnection)u.openConnection();c.addRequestProperty("User-Agent","Mozilla/4.0");return new Scanner(c.getInputStream());}static void main(String[]r)throws Exception{String a,b;String c=s(a=r[0]).useDelimiter("\\Z").next(),d=s(b=r[1]).useDelimiter("\\Z").next();Matcher m=Pattern.compile("ut ([0-9,]+) res").matcher(c);m.find();long i=new Scanner(m.group(1)).nextLong();m=Pattern.compile("ut ([0-9,]+) res").matcher(d);m.find();long j=new Scanner(m.group(1)).nextLong();System.out.print(i>j?a:b);}}

Python 3, 227 226 208 213 226 220 221 206 202 200 198 byte

import re,requests as r,urllib.parse as u
lambda*t:sorted(zip(map(lambda a:int(re.findall("s\">About ([\d,]+)",r.get("http://google.com/search?q="+u.quote(a)).text)[0].replace(",","")),t),t))[-1][1]

Assegna il lambda a qualcosa per chiamarlo.

Utilizza la libreria di richieste .

Ungolfed:

import re, requests as r, urllib.parse as u
lambda*t:
  sorted(
  list(
      zip(map(
              lambda a: int(re.findall("About ([\d,]+)",
               r.get("http://google.com/search?q="+u.quote(a)).text)[0].replace(",","")),
              t
          ),
       t)
   )
)[-1][1]

Powershell, 175 , 172 byte

($args|%{[pscustomobject]@{'a'=$_;'b'=[int]((iwr "google.com/search?nord=1&q=$_&nfpr=1").parsedhtml.getelementbyid('resultstats').innertext-split" ")[1]}}|sort -des b).a[0]

Mostrando il punteggio e il nome, si taglierebbero altri 2 byte.

Questo utilizza la stessa unkillablefunzionalità della risposta 196 Byte Factor (Parsed HTML) e riduce la risposta regex precedente.

Racchetta, 360 337 byte

#lang racket(require net/url net/uri-codec)(λ(t)(cddr(sort(map list t(map(lambda(a)(string->number(string-replace(list-ref(string-split(car(regexp-match#px"s\">About [\\d,]+ res"(call/input-url(string->url(string-append"http://google.com/search?nfpr=1&q="(uri-encode a)))(curry get-pure-port)port->string)))" ")1)",""")))))#:key cdr <)))

0.o

C'è un motivo per cui lo chiamano Lost In a Sea of ​​Parentheses.

Ungolfed:

#lang racket
(require net/url)
(require net/uri-codec)

(define (open-url term)
  (call/input-url
   (string->url (string-append "http://" term))
   (curry get-pure-port #:redirections 5)
   port->string))

(define (get-result term)
  (string->number
   (string-replace
    (list-ref
     (string-split
      (car (regexp-match #px"s\">About [\\d,]+ results" (open-url (string-append "google.com/search?nfpr=1&q=" (uri-encode term)))))
      " ")
     1)
    "," "")))

(define (zip a b) (map list a b))

(define (google-fite terms) (cddr (sort (zip terms (map get-result terms))) #:key cdr <))