Pozdrowienia, szlachetni golfiści. Dziś rozwiążesz najstarszą i najbardziej wyróżniającą się debatę - Emacsa czy Vima?

Twoim wyzwaniem jest wprowadzenie dwóch wyszukiwanych haseł jako danych wejściowych i wyświetlenie, który z nich ma najwięcej wyników wyszukiwania Google. (Jest to oczywiście całkowicie sprawiedliwe. Co masz na myśli, stronnicze?)

Oto kilka przykładowych danych wejściowych i wyjściowych:

Wejście: emacsi vim
wyjście: vim(całkowicie nie tworząc żadnych flamewars w komentarzach)

Wejście: googlei microsoft
wyjście:google

Wejście: code golf stack exchangei code review stack exchange
wyjście: code golf stack exchange(tak!)

Oto kilka ciekawych przypadków (dla zabawy i testowania rozwiązań):

Wejście: About 1,000,000 resultsi About 100,000 results
wyjście:About 100,000 results

Dane wejściowe: This will autocotrecti dane Another testcase
wyjściowe: Another testcase(jeśli nie rozważysz autokorekty, pierwsza wygra)

W poniższych przypadkach testowych musisz najpierw usunąć #znaki z wyszukiwanych haseł, ponieważ polegają one na tym, że termin ma określoną liczbę wyników, a opublikowanie go tutaj zrujnowałoby to.

Wejście: Thissear#chter#mhasno#resultsi Another testcase
wyjście: Another testcase(tylko test dla zerowych wyników)

Wejście: "These exact wo#rds do#n't exi#st# on the Internet"i Another testcase
wyjście: Another testcase(testy ")

Dane wejściowe: Abo#ut 1,65#2,85#3,2#86 re#sultsi Dane Another testcase
wyjściowe: Another testcase(ten jest trudny - powyższy termin wyszukiwania ma jeden wynik)

Input: "Abo#ut 4#8,234,8#75,14#7 res#ults"and Another testcase
Output: Another testcase(również trudne - brak wyników, więc wyświetla wyszukiwane hasło)

Nie trzeba zajmować się przypadkiem "quoted"wyszukiwania z wynikiem „Nie ma wyników, zamiast tego wyświetla wyniki bez cudzysłowów”, ponieważ byłoby to zbyt skomplikowane. Nie musisz też obsługiwać danych wejściowych z taką samą liczbą wyników.

To jest code-golf , więc wygra najkrótszy kod w bajtach!

Współczynnik , 305 201 196 200 201 188 184 182 179 169 178 171 165 199 171 170 165 163 bajtów

Język prawie tak gadatliwy jak Java, pokonując Ruby ... i PowerShell! :RE

Lepsze wyrażenie regularne, teraz. Dzięki @fede s. za 5 bajtów off!

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

Lub 159 157, jeśli dane wyjściowe mogą być takie { "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 ]

Z drugiej strony, jeśli chcemy być nie do zabicia, dla 199 196 193 bajtów :

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

Nie do zabicia, ponieważ analizuje HTML, więc jest o wiele bardziej solidny niż odpowiedzi przy użyciu wyrażenia regularnego.

Rubinowy, 203 180 bajtów

->*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 bajtów dla -ropen-uriflagi (plus spacja).

Dane wejściowe są traktowane jako dwa argumenty.

Objaśnienie adresu URL:

• ?nord=1: zapobieganie automatycznemu przekierowywaniu z HTTP na HTTPS
• &q=#{URI.escape x}: unikaj zapytania, więc "działa
• &nfpr=1: brak autokorekty

Całość mapzamienia się ['emacs','vim']w [[2150000, 'emacs'], [14900000, 'vim']]. (Możesz to zobaczyć, zmieniając .max[1]na końcu na .inspect.) Następnie maxjest brany, który pobierze ten z największą liczbą wyników i [1]jest używany do uzyskania wyszukiwanego terminu.

Spośród edytorów tekstu wymienionych w problemie tylko jeden z nich może rozwiązać to samodzielnie ...

Emacs: 137 klawiszy

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

Oczekuje, że pierwsze wyszukiwane hasła znajdą się w pierwszym wierszu, a drugie wyszukiwane hasła w drugiej linii, z kursorem na początku bufora.

Dla tych, którzy nie znają Emacsa,

• C-sśrodki Ctrl-S.
• M-zoznacza Alt-Z( Altprawdopodobnie Twój klucz meta)
• M-<oznacza Alt-<lubAlt-Shift-,
• C-S-e znaczy Ctrl-Shift-e

Dla tych, którzy znają Emacsa,

• Uruchom emacsa za pomocą emacs -q. To nie ładuje twojego .emacspliku, więc żadne fantazyjne pakiety nie będą mu przeszkadzać.

Wyjaśnienie

1. Napisz początek skorupy instrukcji elisp

   • <C-o><C-u><C-k> Zapisuje argumenty z nową linią
   • (if(<<C-y><C-y> Napisz początek instrukcji if i umieść 2 kopie argumentów
   • <M-<><C-n> Przejdź do drugiej linii

2. Zdefiniuj makro HTTP. Konwertuje to argument na adres URL wyszukiwania Google, a następnie zwraca liczbę wyników wyszukiwania.

   • <F3> Zacznij definiować makro klawiatury
   • <C-a> Przejdź na początek wyszukiwanego terminu.
   • http://google.com/search?nfpr=1&q= Dodaj adres URL wyszukiwania
   • <C-S-e><M-x>r-st<RET> <RET>+<RET> Zastąp wszystkie spacje znakami +.
   • <C-a><C-k><M-x>b-em<RET><C-y><RET>Emacs pobiera surowy HTML ( b-emskrót od browse-url-emacs)
   • <C-x><C-q> Spraw, aby plik był zapisywalny (wymagany, aby makro nie zawierało błędów)
   • <C-s><RET>ts"><RET> Przejdź do liczby wyników div (należy przeprowadzić regularne wyszukiwanie, ponieważ makra emacs polegają na działaniu isearch)
   • <M-z><Wytnij tekst różnicy (dlatego był wymagany)
   • <C-x>0 Wróć do pierwotnego bufora
   • <C-y>0 r;; Umieść wyniki z powrotem na linii („0 r” nie obsługuje żadnych wyników)
   • <C-a><C-M-s><RET>[0-9]<RET><C-b><M-z> <C-a><C-y><C-k>;; Wyodrębnij liczbę z ciągu.
   • <C-S-a><M-x><up><up><RET>,<RET><RET> Usuwa przecinki z numeru
   • <F4> Zakończ makro klawiatury

3. Przesuń w dół i uruchom makro klawiatury w następnym wierszu.

   • <C-n> Przechodzi do następnej linii
   • <F4> Powtórz makro raz.

4. Zakończ instrukcję elisp i wykonaj ją

   • <C-e>)(next-line)()) Dokończ instrukcję elisp
   • <C-x><C-e> Oceń polecenie elisp
   • <C-n><C-a><C-k> Zabij zwycięski argument
   • <C-x>h<DEL> Usuń wszystko inne
   • <C-y> Wklej zwycięski argument

Uruchamianie samemu

Na szczęście nie musisz idealnie wpisywać wszystkich tych naciśnięć klawiszy! Mięso i ziemniaki są w makro, które można po prostu skopiować i wkleić. Makro można skopiować i wkleić do emacsa!

1. Edytuj makro klawiatury 2. <C-x><C-k><C-e>
Wklej to do całego bufora (wklej powinno być <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. Wpisz, <C-c><C-c>aby zapisać makro.
4. Jeśli postępujesz zgodnie z instrukcjami, zamień krok 2 na, <F4>aby uruchomić makro (lub po prostu uruchom go samodzielnie, aby spróbować)

Ostrzeżenia

1. Nie można uruchomić makra dwukrotnie w tym samym wyszukiwaniu bez zabicia bufora, do którego ładowany jest HTML. Zabij bufory
   • <C-x><k> search<TAB>
   • Wybierz jeden z buforów z tej listy, aby zabić.
   • Powtórz dla wszystkich buforów zaczynających się od „szukaj”
2. Jeśli uruchomisz makro zbyt dużo, Google będzie myśleć, że jesteś robotem i blokuje dostęp na czas
   • Jeśli makro zwraca coś podobnego <input type="submit" name="submit" value="Submit"...>, prawdopodobnie tak się stało.
   • Możesz to potwierdzić, patrząc na nieprzetworzony kod HTML ( <C-x><C-b>i wybierz bufor z wyszukiwanym terminem).
   • Jeśli widzisz rzeczy o robotach i captcha, Google cię blokuje. To nie moja wina.

Java, 828 800 783 744 739 687 bajtów

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 bajtów

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]

Przypisz lambda do czegoś, co można to nazwać.

Korzysta z biblioteki żądań .

Nie golfowany:

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 bajtów

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

Wyświetlanie wyniku, a także nazwy, spowodowałoby przecięcie 2 kolejnych bajtów.

Używa tej samej unkillablefunkcji co odpowiedź 196 Byte Factor (analizowany HTML) i odcina się od poprzedniej odpowiedzi wyrażenia regularnego.

Rakieta, 360 337 bajtów

#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

Jest powód, dla którego nazywają to Lost In a Sea of ​​Parentheses.

Nie golfowany:

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