Saudações, jogadores nobres de código. Hoje você resolverá o mais antigo e distinto dos debates - Emacs ou Vim?

Seu desafio é usar dois termos de pesquisa como entrada e gerar qual desses termos tem mais resultados de pesquisa no Google. (Isso é obviamente completamente justo. Como assim, tendencioso?)

Aqui estão alguns exemplos de entradas e saídas:

Entrada: emacse vim
Saída: vim(totalmente não criando nenhuma guerra de chamas nos comentários)

Entrada: googlee microsoft
Saída:google

Entrada: code golf stack exchangee code review stack exchange
Saída: code golf stack exchange(sim!)

E aqui estão alguns casos extremos apenas por diversão (e para testar suas soluções):

Entrada: About 1,000,000 resultse About 100,000 results
Saída:About 100,000 results

Entrada: This will autocotrecte Another testcase
Saída: Another testcase(se você não considerar a correção automática, a primeira vencerá)

Para os casos de teste a seguir, você deve remover os #sinais nos termos da pesquisa primeiro, pois eles dependem do termo com uma quantidade específica de resultados e a publicação do termo aqui estragaria isso.

Entrada: Thissear#chter#mhasno#resultse Another testcase
Saída: Another testcase(apenas um teste para zero resultados)

Entrada: "These exact wo#rds do#n't exi#st# on the Internet"e Another testcase
Saída: Another testcase(testes ")

Entrada: Abo#ut 1,65#2,85#3,2#86 re#sultse Another testcase
Saída: Another testcase(este é complicado - o termo de pesquisa acima tem um resultado)

Entrada: "Abo#ut 4#8,234,8#75,14#7 res#ults"e Another testcase
Saída: Another testcase(também complicado - sem resultados, para exibir o termo de pesquisa)

Você não precisa lidar com o caso de canto das "quoted"pesquisas retornando "Nenhum resultado, mostrando resultados sem aspas", porque isso seria muito complicado. Você também não precisa manipular entradas com o mesmo número de resultados.

Isso é código-golfe , então o código mais curto em bytes vencerá!

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

Uma linguagem quase tão detalhada quanto Java, superando Ruby ... e Powershell! : D

Regex melhor, agora. Graças a @fede s. por 5 bytes de desconto!

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

Ou 159 157, se a saída puder 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 outro lado, se queremos ser imbatíveis, 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 ]

Inominável porque analisa HTML, muito mais robusto que as respostas usando 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 o -ropen-urisinalizador (mais espaço).

A entrada é aceita como dois argumentos.

Explicação do URL:

• ?nord=1: impedir o redirecionamento automático de HTTP para HTTPS
• &q=#{URI.escape x}: escapar da consulta para que "funcione
• &nfpr=1: sem autocorreção

O todo mapse ['emacs','vim']transforma [[2150000, 'emacs'], [14900000, 'vim']]. (Você pode ver isso alterando o .max[1]no final para .inspect.) Em seguida, maxé tirado o que [1]obtém o que tiver mais resultados e é usado para obter o termo de pesquisa.

Dos editores de texto mencionados no problema, apenas um deles pode resolver isso sozinho ...

Emacs: 137 pressionamentos 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>

Ele espera que os primeiros termos de pesquisa estejam na primeira linha e os segundos termos de pesquisa estejam na segunda linha, com o cursor no início do buffer.

Para quem não conhece o Emacs,

• C-smeios Ctrl-S.
• M-zsignifica Alt-Z( Altprovavelmente sua meta-chave)
• M-<meios Alt-<ouAlt-Shift-,
• C-S-e significa Ctrl-Shift-e

Para aqueles familiarizados com o Emacs,

• Inicie o emacs com emacs -q. Isso não carrega seu .emacsarquivo, portanto, qualquer pacote sofisticado não interfere nisso.

Explicação

1. Escreva o início do shell de declaração elisp

   • <C-o><C-u><C-k> Salva os argumentos com uma nova linha
   • (if(<<C-y><C-y> Escreva o início da instrução if e coloque 2 cópias dos argumentos
   • <M-<><C-n> Mover para a segunda linha

2. Defina a macro HTTP. Isso converte o argumento em um URL de pesquisa do Google e retorna o número de resultados da pesquisa.

   • <F3> Comece a definir a macro do teclado
   • <C-a> Vá para o início do termo de pesquisa.
   • http://google.com/search?nfpr=1&q= Anexe o URL da pesquisa
   • <C-S-e><M-x>r-st<RET> <RET>+<RET> Substitua todos os espaços com sinais de +.
   • <C-a><C-k><M-x>b-em<RET><C-y><RET>O Emacs recupera o HTML bruto ( b-emé a abreviação de browse-url-emacs)
   • <C-x><C-q> Torne o arquivo gravável (necessário para que a macro não se engane)
   • <C-s><RET>ts"><RET> Mover para o número de resultados div (precisa fazer uma pesquisa regular porque as macros do emacs dependem do isearch para funcionar)
   • <M-z><Recorte o texto do diff (é por isso que foi necessário)
   • <C-x>0 Volte para o buffer original
   • <C-y>0 r;; Coloque os resultados de volta na linha ('0 r' não lida com resultados)
   • <C-a><C-M-s><RET>[0-9]<RET><C-b><M-z> <C-a><C-y><C-k>;; Extraia o número da sequência.
   • <C-S-a><M-x><up><up><RET>,<RET><RET> Retira vírgulas do número
   • <F4> Conclua a macro do teclado

3. Mova para baixo e execute a macro do teclado na próxima linha.

   • <C-n> Vai para a próxima linha
   • <F4> Repita a macro uma vez.

4. Conclua a instrução elisp e execute-a

   • <C-e>)(next-line)()) Concluir a instrução elisp
   • <C-x><C-e> Avalie o comando elisp
   • <C-n><C-a><C-k> Mate o argumento vencedor
   • <C-x>h<DEL> Excluir todo o resto
   • <C-y> Cole o argumento vencedor

Executando você mesmo

Felizmente, você não precisa digitar todas essas teclas perfeitamente! A carne e as batatas estão todas em uma macro que você pode copiar e colar. A macro pode ser copiada e colada no emacs!

1.Editar a macro do teclado <C-x><C-k><C-e>
2.Pare isso em todo o buffer (a pasta deve 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. Digite <C-c><C-c>para salvar a macro.
4. Se seguir as etapas de explicação, substitua a etapa 2 por <F4>para executar a macro (ou apenas execute-a por conta própria para tentar)

Ressalvas

1. Você não pode executar a macro na mesma pesquisa duas vezes sem matar o buffer no qual o HTML é carregado. Mate os buffers
   • <C-x><k> search<TAB>
   • Escolha um dos buffers nesta lista para matar.
   • Repita para todos os buffers que começam com "search"
2. Se você executar muito a macro, o Google pensará que você é um robô e bloqueará o acesso por um tempo
   • Se a macro retornar algo como <input type="submit" name="submit" value="Submit"...>, provavelmente isso ocorreu.
   • Você pode confirmá-lo olhando o HTML bruto ( <C-x><C-b>e escolher o buffer com o termo de pesquisa).
   • Se você vê coisas sobre robôs e captcha, o Google está bloqueando você. Não é minha 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]

Atribua o lambda a algo para chamá-lo.

Usa a biblioteca de solicitações .

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 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 a pontuação e o nome reduziria mais 2 bytes.

Isso usa o mesmo unkillablerecurso da resposta do 196 Byte fator (HTML analisado) e diminui a resposta da regex anterior.

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

Há uma razão pela qual eles chamam de 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 <))