Salutations, golfeurs de code noble. Aujourd'hui, vous allez résoudre le débat le plus ancien et le plus distingué - Emacs ou Vim?

Votre défi consiste à prendre deux termes de recherche en entrée et à produire lequel de ces termes a le plus de résultats de recherche Google. (C'est évidemment tout à fait juste. Que voulez-vous dire, biaisé?)

Voici quelques exemples d'entrées et de sorties:

Input: emacsand vim
Output: vim(totalement pas de création de guerres de flammes dans les commentaires)

Entrée: googleet microsoft
sortie:google

Entrée: code golf stack exchangeet code review stack exchange
sortie: code golf stack exchange(ouais!)

Et voici quelques cas de pointe juste pour le plaisir (et pour tester vos solutions):

Entrée: About 1,000,000 resultset About 100,000 results
sortie:About 100,000 results

Input: This will autocotrectand Another testcase
Output: Another testcase(si vous ne pensez pas à la correction automatique, alors le premier gagnera)

Pour les cas de test suivants, vous devez d'abord supprimer les #signes dans les termes de recherche, car ils reposent sur le terme ayant un nombre spécifique de résultats et le publier ici ruinerait cela.

Entrée: Thissear#chter#mhasno#resultset Another testcase
sortie: Another testcase(juste un test pour aucun résultat)

Entrée: "These exact wo#rds do#n't exi#st# on the Internet"et Another testcase
sortie: Another testcase(test "s)

Entrée: Abo#ut 1,65#2,85#3,2#86 re#sultset Another testcase
sortie: Another testcase(celle-ci est délicate - le terme de recherche ci-dessus a un résultat)

Entrée: "Abo#ut 4#8,234,8#75,14#7 res#ults"et Another testcase
sortie: Another testcase(également délicat - aucun résultat, il affiche donc le terme de recherche)

Vous n'avez pas besoin de gérer le cas du coin des "quoted"recherches qui renvoient "Aucun résultat, affichant des résultats sans guillemets à la place" car cela serait tout simplement trop compliqué. Vous n'avez pas non plus besoin de gérer les entrées avec le même nombre de résultats.

Il s'agit de code-golf , donc le code le plus court en octets gagnera!

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

Un langage presque aussi verbeux que Java, battant Ruby ... et Powershell! :RÉ

Mieux regex, maintenant. Merci à @fede s. pour 5 octets de moins!

[ 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 si la sortie peut être comme { "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 ]

En revanche, si nous voulons être non éliminables, pour 199 196 193 octets :

[ 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 car il analyse HTML, donc beaucoup plus robuste que les réponses utilisant regex.

Rubis, 203 180 octets

->*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 octets pour l' -ropen-uriindicateur (plus l'espace).

L'entrée est considérée comme deux arguments.

Explication de l'URL:

• ?nord=1: empêcher la redirection automatique de HTTP vers HTTPS
• &q=#{URI.escape x}: échapper à la requête pour que "le travail fonctionne
• &nfpr=1: pas de correction automatique

Le tout mapse transforme ['emacs','vim']en [[2150000, 'emacs'], [14900000, 'vim']]. (Vous pouvez voir cela en changeant le .max[1]à la fin en .inspect.) Ensuite, le maxest pris, qui saisira celui avec le plus de résultats, et [1]est utilisé pour obtenir le terme de recherche.

Parmi les éditeurs de texte mentionnés dans le problème, un seul d'entre eux peut résoudre ce problème par lui-même ...

Emacs: 137 frappes

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

Il s'attend à ce que les premiers termes de recherche soient sur la première ligne et les seconds termes de recherche sur la deuxième ligne, avec le curseur au début du tampon.

Pour ceux qui ne connaissent pas Emacs,

• C-ssignifie Ctrl-S.
• M-zsignifie Alt-Z( Altest probablement votre méta-clé)
• M-<signifie Alt-<ouAlt-Shift-,
• C-S-e veux dire Ctrl-Shift-e

Pour ceux qui connaissent Emacs,

• Démarrez emacs avec emacs -q. Cela ne charge pas votre .emacsfichier, donc aucun paquet sophistiqué n'interfère avec cela.

Explication

1. Écrivez le début de la coquille de statment elisp

   • <C-o><C-u><C-k> Enregistre les arguments avec une nouvelle ligne
   • (if(<<C-y><C-y> Écrivez le début de l'instruction if et place 2 copies des arguments
   • <M-<><C-n> Passer à la deuxième ligne

2. Définissez la macro HTTP. Cela convertit l'argument en URL de recherche Google, puis renvoie le nombre de résultats de recherche.

   • <F3> Commencez à définir la macro du clavier
   • <C-a> Passez au début du terme de recherche.
   • http://google.com/search?nfpr=1&q= Ajout de l'URL de recherche
   • <C-S-e><M-x>r-st<RET> <RET>+<RET> Remplacez tous les espaces par des signes +.
   • <C-a><C-k><M-x>b-em<RET><C-y><RET>Emacs récupère le HTML brut ( b-emest l'abréviation de browse-url-emacs)
   • <C-x><C-q> Rendre le fichier accessible en écriture (requis pour que la macro ne fasse pas d'erreur ou t)
   • <C-s><RET>ts"><RET> Déplacer vers le nombre de résultats div (besoin de faire une recherche régulière car les macros emacs reposent sur isearch pour fonctionner)
   • <M-z><Coupez le texte du diff (c'est pourquoi il était nécessaire)
   • <C-x>0 Revenir au tampon d'origine
   • <C-y>0 r;; Remettez les résultats sur la ligne ('0 r' ne gère aucun résultat)
   • <C-a><C-M-s><RET>[0-9]<RET><C-b><M-z> <C-a><C-y><C-k>;; Extrayez le numéro de la chaîne.
   • <C-S-a><M-x><up><up><RET>,<RET><RET> Supprime les virgules du nombre
   • <F4> Terminer la macro du clavier

3. Descendez et exécutez la macro du clavier sur la ligne suivante.

   • <C-n> Va à la ligne suivante
   • <F4> Répétez la macro une fois.

4. Terminez l'instruction elisp et exécutez-la

   • <C-e>)(next-line)()) Terminez la déclaration elisp
   • <C-x><C-e> Évaluez la commande elisp
   • <C-n><C-a><C-k> Tuez l'argument gagnant
   • <C-x>h<DEL> Supprimer tout le reste
   • <C-y> Collez l'argument gagnant

Courir vous-même

Heureusement, vous n'avez pas besoin de saisir parfaitement toutes ces touches! La viande et les pommes de terre sont toutes dans une macro que vous pouvez simplement copier et coller. La macro peut être copiée et collée dans emacs!

1.Modifiez la macro du clavier <C-x><C-k><C-e>
2. Collez-la dans tout le tampon (la pâte devrait être <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. Tapez <C-c><C-c>pour enregistrer la macro.
4. Si vous suivez les étapes d'explication, remplacez l'étape 2 par <F4>pour exécuter la macro (ou exécutez-la simplement pour essayer)

Avertissements

1. Vous ne pouvez pas exécuter la macro sur la même recherche deux fois sans tuer le tampon dans lequel le HTML est chargé. Tuez les tampons
   • <C-x><k> search<TAB>
   • Choisissez l'un des tampons de cette liste à tuer.
   • Répétez l'opération pour tous les tampons commençant par "recherche"
2. Si vous exécutez trop la macro, Google pensera que vous êtes un robot et bloquera l'accès pendant un certain temps
   • Si la macro renvoie quelque chose comme <input type="submit" name="submit" value="Submit"...>, cela s'est probablement produit.
   • Vous pouvez le confirmer en regardant le HTML brut ( <C-x><C-b>et choisissez le tampon contenant le terme de recherche).
   • Si vous voyez des informations sur les robots et le captcha, Google vous bloque. Ce n'est pas de ma faute.

Java, 828 800 783 744 739 687 octets

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 octets

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]

Assignez le lambda à quelque chose pour l'appeler.

Utilise la bibliothèque de requêtes .

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

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

Afficher le score ainsi que le nom réduirait 2 octets supplémentaires.

Cela utilise la même unkillablefonctionnalité que la réponse 196 Byte Factor (HTML analysé) et réduit la réponse regex précédente.

Raquette, 360 337 octets

#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

Il y a une raison pour laquelle ils l'appellent Perdu dans une mer de parenthèses.

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