Saludos, nobles golfistas de código. Hoy resolverás el debate más antiguo y distinguido: ¿Emacs o Vim?

Su desafío es tomar dos términos de búsqueda como entrada y salida, cuál de esos términos tiene la mayor cantidad de resultados de búsqueda de Google. (Esto es obviamente completamente justo. ¿Qué quieres decir con parcialidad?)

Aquí hay algunos ejemplos de entradas y salidas:

Entrada: emacsy vim
Salida: vim(totalmente sin crear ninguna guerra de llamas en los comentarios)

Entrada: googley microsoft
Salida:google

Entrada: code golf stack exchangey code review stack exchange
Salida: code golf stack exchange(¡sí!)

Y aquí hay algunos casos extremos solo por diversión (y para probar sus soluciones):

Entrada: About 1,000,000 resultsy About 100,000 results
Salida:About 100,000 results

Entrada: This will autocotrecty Another testcase
Salida: Another testcase(si no considera la autocorrección, entonces el primero ganará)

Para los siguientes casos de prueba, #primero debe eliminar los signos en los términos de búsqueda, ya que dependen del término que tiene una cantidad específica de resultados y publicar el término aquí arruinaría eso.

Entrada: Thissear#chter#mhasno#resultsy Another testcase
Salida: Another testcase(solo una prueba para cero resultados)

Entrada: "These exact wo#rds do#n't exi#st# on the Internet"y Another testcase
Salida: Another testcase(prueba "s)

Entrada: Abo#ut 1,65#2,85#3,2#86 re#sultsy Another testcase
Salida: Another testcase(este es complicado, el término de búsqueda anterior tiene un resultado)

Entrada: "Abo#ut 4#8,234,8#75,14#7 res#ults"y Another testcase
Salida: Another testcase(también complicado, sin resultados, por lo que muestra el término de búsqueda)

No necesita manejar el caso de las "quoted"búsquedas que devuelven "Sin resultados, mostrando resultados sin comillas" porque eso sería demasiado complicado. No necesita manejar entradas con el mismo número de resultados tampoco.

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

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

Un lenguaje casi tan detallado como Java, que supera a Ruby ... y Powershell. :RE

Mejor expresión regular, ahora. Gracias a @fede s. por 5 bytes de descuento!

[ 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 si la salida puede ser como { "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 ]

Por otro lado, si queremos ser imposible de matar, por 199 196 193 bytes :

[ 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 ]

No se puede matar porque analiza HTML, por lo que es mucho más robusto que las respuestas que usan regex.

Ruby, 203 180 bytes

->*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 bytes para la -ropen-uribandera (más espacio).

La entrada se toma como dos argumentos.

Explicación de URL:

• ?nord=1: evitar el redireccionamiento automático de HTTP a HTTPS
• &q=#{URI.escape x}: escapar de la consulta para que "funcione
• &nfpr=1: sin autocorrección

Todo se mapconvierte ['emacs','vim']en [[2150000, 'emacs'], [14900000, 'vim']]. (Puede ver esto cambiando el .max[1]al final a .inspect). Luego, maxse toma el que tomará el que tenga más resultados y [1]se usará para obtener el término de búsqueda.

De los editores de texto mencionados en el problema, solo uno de ellos puede resolver esto por sí solo ...

Emacs: 137 pulsaciones de teclas

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

Espera que los primeros términos de búsqueda estén en la primera línea y los segundos términos de búsqueda estén en la segunda línea, con el cursor al comienzo del búfer.

Para aquellos que no están familiarizados con Emacs,

• C-ssignifica Ctrl-S.
• M-zsignifica Alt-Z( Altes probable que sea su meta clave)
• M-<significa Alt-<oAlt-Shift-,
• C-S-e medio Ctrl-Shift-e

Para aquellos familiarizados con Emacs,

• Comience emacs con emacs -q. Eso no carga su .emacsarchivo, por lo que cualquier paquete elegante no interferirá con esto.

Explicación

1. Escribe el comienzo del caparazón de declaración de elisp

   • <C-o><C-u><C-k> Guarda los argumentos con una nueva línea
   • (if(<<C-y><C-y> Escriba el comienzo de la declaración if y coloque 2 copias de los argumentos.
   • <M-<><C-n> Pasar a la segunda línea

2. Defina la macro HTTP. Esto convierte el argumento en una URL de búsqueda de Google y luego devuelve el número de resultados de búsqueda.

   • <F3> Comience a definir la macro del teclado
   • <C-a> Ir al inicio del término de búsqueda.
   • http://google.com/search?nfpr=1&q= Anteponer la URL de búsqueda
   • <C-S-e><M-x>r-st<RET> <RET>+<RET> Reemplaza todos los espacios con signos +.
   • <C-a><C-k><M-x>b-em<RET><C-y><RET>Emacs recupera el HTML sin formato ( b-emes la abreviatura de browse-url-emacs)
   • <C-x><C-q> Haga que el archivo sea editable (requerido para que la macro no se equivoque)
   • <C-s><RET>ts"><RET> Mover al número de resultados div (necesita hacer una búsqueda regular porque las macros de emacs dependen de isearch para funcionar)
   • <M-z><Corte el texto de la diferencia (esta es la razón por la cual se requería)
   • <C-x>0 Vuelva al búfer original
   • <C-y>0 r;; Ponga los resultados nuevamente en la línea ('0 r' no maneja resultados)
   • <C-a><C-M-s><RET>[0-9]<RET><C-b><M-z> <C-a><C-y><C-k>;; Extrae el número de la cadena.
   • <C-S-a><M-x><up><up><RET>,<RET><RET> Elimina comas del número
   • <F4> Termina la macro del teclado

3. Mover hacia abajo y ejecutar la macro de teclado en la siguiente línea.

   • <C-n> Va a la siguiente línea
   • <F4> Repita la macro una vez.

4. Termine la instrucción elisp y ejecútela

   • <C-e>)(next-line)()) Termina la declaración de elisp
   • <C-x><C-e> Evaluar el comando elisp
   • <C-n><C-a><C-k> Mata el argumento ganador
   • <C-x>h<DEL> Eliminar todo lo demás
   • <C-y> Pega el argumento ganador

Ejecutándolo usted mismo

¡Por suerte no tienes que escribir todas esas pulsaciones de teclas perfectamente! La carne y las papas están en una macro que puedes copiar y pegar. ¡La macro se puede copiar y pegar en emacs!

1.Edite la macro del teclado <C-x><C-k><C-e>
2.Pegue esto en todo el búfer (pegar debe ser <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. Escriba <C-c><C-c>para guardar la macro.
4. Si sigue los pasos explicativos, reemplace el paso 2 con <F4>para ejecutar la macro (o simplemente ejecútelo solo para intentarlo)

Advertencias

1. No puede ejecutar la macro en la misma búsqueda dos veces sin eliminar el búfer en el que se carga el HTML. Mata los tampones
   • <C-x><k> search<TAB>
   • Elige uno de los buffers de esta lista para matar.
   • Repita para todos los búferes que comienzan con "buscar"
2. Si ejecuta la macro demasiado, Google pensará que es un robot y bloqueará el acceso por un tiempo
   • Si la macro devuelve algo así <input type="submit" name="submit" value="Submit"...>, entonces esto probablemente ocurrió.
   • Puede confirmarlo mirando el HTML sin formato ( <C-x><C-b>y elija el búfer con el término de búsqueda).
   • Si ves cosas sobre robots y captcha, Google te está bloqueando. No es mi culpa.

Java, 828 800 783 744 739 687 bytes

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 bytes

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]

Asigne el lambda a algo para llamarlo.

Utiliza la biblioteca de solicitudes .

Sin golf:

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 bytes

($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]

Mostrar la puntuación y el nombre reduciría 2 bytes más.

Esto usa la misma unkillablecaracterística que la respuesta 196 Byte Factor (HTML analizado) y reduce la respuesta anterior de expresiones regulares.

Raqueta, 360 337 bytes

#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

Hay una razón por la que lo llaman Perdido en un mar de paréntesis.

Sin golf:

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