Grüße, edle Code-Golfer. Heute werden Sie die ältesten und angesehensten Debatten lösen - Emacs oder Vim?

Ihre Herausforderung besteht darin, zwei Suchbegriffe als Eingabe zu verwenden und auszugeben, welcher dieser Begriffe die meisten Google-Suchergebnisse aufweist. (Dies ist offensichtlich völlig fair. Was meinst du, voreingenommen?)

Hier sind einige Beispiele für Ein- und Ausgänge:

Input: emacsund vim
Output: vim(überhaupt keine Flamewars in den Kommentaren erstellen)

Eingabe: googleund microsoft
Ausgabe:google

Input: code golf stack exchangeund code review stack exchange
Output: code golf stack exchange(ja!)

Und hier sind einige Randfälle nur zum Spaß (und zum Testen Ihrer Lösungen):

Eingabe: About 1,000,000 resultsund About 100,000 results
Ausgabe:About 100,000 results

Eingabe: This will autocotrectund Another testcase
Ausgabe: Another testcase(Wenn Sie keine Autokorrektur in Betracht ziehen, gewinnt die erste)

Für die folgenden Testfälle müssen Sie zuerst die #Zeichen in den Suchbegriffen entfernen , da diese davon abhängen, dass der Begriff eine bestimmte Anzahl von Ergebnissen aufweist und das Posten des Begriffs hier das ruinieren würde.

Input: Thissear#chter#mhasno#resultsund Another testcase
Output: Another testcase(nur ein Test für null Ergebnisse)

Eingabe: "These exact wo#rds do#n't exi#st# on the Internet"und Another testcase
Ausgabe: Another testcase(Testen von "s)

Eingabe: Abo#ut 1,65#2,85#3,2#86 re#sultsund Another testcase
Ausgabe: Another testcase(dies ist schwierig - der obige Suchbegriff hat ein Ergebnis)

Eingabe: "Abo#ut 4#8,234,8#75,14#7 res#ults"und Another testcase
Ausgabe: Another testcase(auch schwierig - keine Ergebnisse, daher wird der Suchbegriff angezeigt)

Sie müssen den Eckfall der "quoted"Suche mit der Rückgabe "Keine Ergebnisse, stattdessen Ergebnisse ohne Anführungszeichen anzeigen" nicht behandeln, da dies einfach zu kompliziert wäre. Sie müssen auch keine Eingaben mit der gleichen Anzahl von Ergebnissen verarbeiten.

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes!

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

Eine Sprache, die fast so ausführlich ist wie Java und Ruby und Powershell schlägt! : D

Besser jetzt Regex. Danke an @fede s. für 5 Bytes aus!

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

Oder 159 157, wenn die Ausgabe wie folgt aussehen kann { "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 ]

Wenn wir dagegen nicht tötbar sein wollen, für 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 ]

Unkillable, weil es HTML analysiert, also viel robuster als die Antworten mit 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 für das -ropen-uriFlag (plus Leerzeichen).

Die Eingabe erfolgt als zwei Argumente.

URL Erklärung:

• ?nord=1: Automatische Umleitung von HTTP zu HTTPS verhindern
• &q=#{URI.escape x}: Entkomme der Abfrage, damit es "funktioniert
• &nfpr=1: keine Autokorrektur

Das Ganze mapverwandelt sich ['emacs','vim']in [[2150000, 'emacs'], [14900000, 'vim']]. (Sie können dies sehen, indem Sie das .max[1]am Ende in ändern .inspect.) Dann wird das maxgenommen, das das mit den meisten Ergebnissen ergreift, und [1]wird verwendet, um den Suchbegriff zu erhalten.

Von den in dem Problem erwähnten Texteditoren kann nur einer dies alleine lösen ...

Emacs: 137 Tastenanschläge

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

Es wird erwartet, dass sich die ersten Suchbegriffe in der ersten Zeile und die zweiten Suchbegriffe in der zweiten Zeile befinden, wobei sich der Cursor am Anfang des Puffers befindet.

Für diejenigen, die mit Emacs nicht vertraut sind,

• C-sbedeutet Ctrl-S.
• M-zbedeutet Alt-Z( Altist wahrscheinlich dein Metaschlüssel)
• M-<bedeutet Alt-<oderAlt-Shift-,
• C-S-e meint Ctrl-Shift-e

Für diejenigen, die mit Emacs vertraut sind,

• Emacs starten mit emacs -q. .emacsDadurch wird Ihre Datei nicht geladen , sodass keine ausgefallenen Pakete dies beeinträchtigen.

Erläuterung

1. Schreiben Sie den Anfang der Elisp-Statment-Shell

   • <C-o><C-u><C-k> Speichert die Argumente mit einer neuen Zeile
   • (if(<<C-y><C-y> Schreiben Sie den Anfang der if-Anweisung und platzieren Sie 2 Kopien der Argumente
   • <M-<><C-n> In die zweite Zeile wechseln

2. Definieren Sie das HTTP-Makro. Dadurch wird das Argument in eine Google-Such-URL konvertiert und anschließend die Anzahl der Suchergebnisse zurückgegeben.

   • <F3> Beginnen Sie mit der Definition des Tastaturmakros
   • <C-a> Zum Anfang des Suchbegriffs springen.
   • http://google.com/search?nfpr=1&q= Stellen Sie die Such-URL voran
   • <C-S-e><M-x>r-st<RET> <RET>+<RET> Ersetzen Sie alle Leerzeichen durch + Zeichen.
   • <C-a><C-k><M-x>b-em<RET><C-y><RET>Emacs rufen das rohe HTML ab ( b-emAbkürzung für browse-url-emacs)
   • <C-x><C-q> Machen Sie die Datei beschreibbar (erforderlich, damit das Makro keine Fehler verursacht)
   • <C-s><RET>ts"><RET> Zur Anzahl der Ergebnisse wechseln div
   • <M-z><Schneiden Sie den Text des Differentials aus (aus diesem Grund wurde das benötigt)
   • <C-x>0 Wechseln Sie zurück zum ursprünglichen Puffer
   • <C-y>0 r;; Stellen Sie die Ergebnisse wieder in die Zeile ('0 r' behandelt keine Ergebnisse)
   • <C-a><C-M-s><RET>[0-9]<RET><C-b><M-z> <C-a><C-y><C-k>;; Extrahieren Sie die Zahl aus der Zeichenfolge.
   • <C-S-a><M-x><up><up><RET>,<RET><RET> Entfernt die Kommas von der Zahl
   • <F4> Beenden Sie das Tastaturmakro

3. Gehen Sie nach unten und führen Sie das Tastaturmakro in der nächsten Zeile aus.

   • <C-n> Geht zur nächsten Zeile
   • <F4> Wiederholen Sie das Makro einmal.

4. Beenden Sie die elisp-Anweisung und führen Sie sie aus

   • <C-e>)(next-line)()) Beenden Sie die elisp-Anweisung
   • <C-x><C-e> Bewerten Sie den Befehl elisp
   • <C-n><C-a><C-k> Töte das siegreiche Argument
   • <C-x>h<DEL> Alles andere löschen
   • <C-y> Fügen Sie das Siegerargument ein

Laufen Sie es selbst

Zum Glück müssen Sie nicht alle diese Tastenanschläge perfekt eingeben! Das Fleisch und die Kartoffeln befinden sich alle in einem Makro, das Sie einfach kopieren und einfügen können. Das Makro kann kopiert und in Emacs eingefügt werden!

1. Bearbeiten Sie das Tastaturmakro <C-x><C-k><C-e>
2. Fügen Sie dies in den gesamten Puffer ein (Einfügen sollte sein <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. Geben Sie ein <C-c><C-c>, um das Makro zu speichern.
4. Wenn Sie den Erklärungsschritten folgen, ersetzen Sie Schritt 2 durch <F4>, um das Makro auszuführen (oder führen Sie es einfach selbst aus, um es zu versuchen).

Vorbehalte

1. Sie können das Makro nicht zweimal mit derselben Suche ausführen, ohne den Puffer zu löschen, in den der HTML-Code geladen wird. Töte die Puffer
   • <C-x><k> search<TAB>
   • Wählen Sie einen der Puffer in dieser Liste aus, die Sie löschen möchten.
   • Wiederholen Sie diesen Vorgang für alle Puffer, die mit "search" beginnen.
2. Wenn Sie das Makro zu oft ausführen, wird Google Sie für einen Roboter halten und den Zugriff für eine bestimmte Zeit blockieren
   • Wenn das Makro so etwas zurückgibt <input type="submit" name="submit" value="Submit"...>, ist dies wahrscheinlich geschehen.
   • Sie können dies bestätigen, indem Sie sich das unformatierte HTML ansehen ( <C-x><C-b>und den Puffer mit dem Suchbegriff darin auswählen).
   • Wenn Sie Informationen zu Robotern und Captcha sehen, werden Sie von Google blockiert. Es ist nicht meine Schuld.

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]

Weisen Sie das Lambda einer Bezeichnung zu.

Verwendet die Anforderungsbibliothek .

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]

Das Zeigen der Kerbe sowie des Namens würde 2 weitere Bytes schneiden.

Dies verwendet die gleiche unkillableFunktion wie die 196 Byte Faktor- Antwort (Parsed HTML) und schneidet von der vorherigen Regex-Antwort ab.

Schläger, 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

Es gibt einen Grund, warum sie es Lost In a Sea of ​​Parentheses nennen.

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