Je jouais avec la fonction de demande d'URL de Pyth et j'ai remarqué que Google donnait toujours une réponse avec une longueur légèrement différente pour moi, généralement des ~10500caractères.

Donc, votre tâche dans ce défi est d'imprimer la longueur moyenne de la réponse html de http://google.com.

Spécifications

• Vous prendrez une entrée nqui est le nombre de demandes à faire.
• Pour chaque demande, vous ferez une demande HTTP get.
• Vous compterez le corps de la réponse (le texte html), pas les en-têtes.
• Affiche la moyenne arithmétique des longueurs des réponses.
• Vous ne pouvez accéder qu'à l'URL http://google.com, pas à une autre.
• C'est le code-golf , donc le code le plus court en octets gagne!

Exemple de sortie pour entrée 10: 10560.1

(J'ai utilisé Python urllibpour cela)

PS: quelqu'un sait pourquoi google fait ça?

Utilitaires système Bash +, 56 53 49 48 octets

Mise à jour: économisé 4 octets grâce à Digital Trauma et 1 octet de plus grâce à Dennis

curl -L `yes google.com|sed $1q`|wc|dc -e1k?$1/p

Dans ma réponse d'origine, j'utilisais yesen combinaison avec xargspour émuler une boucle for. Mais curlpeut accepter en entrée une liste d'URL, donc seule la sortie de yesest réellement nécessaire.

Lorsqu'il curlaccède à google.com , il reçoit une page de redirection 302 qui a la nouvelle URL dans la section du corps, donc l' -Loption est nécessaire pour la suivre.

Exécuter l'exemple: la réponse est imprimée sur STDOUT, je redirige STDERR juste pour plus de clarté

me@LCARS:/PPCG$ ./google_length.sh "8" 2> /dev/null
10583.2

Explication: (du code soumis initialement)

yes google.com|     # repeatedly output a line containing the string "google.com"
sed $1q|            # print the first $1 lines only (shorter than head -$1)
xargs curl -sL|     # xargs reads the input lines and executes "curl -sL" with the
                    #current input line as an additional argument.
wc -m|              # count the number of characters
dc -e1k?$1/p        # dc script: set precision to 1, read input, push $1 and divide

Edit: j'ai remplacé wc -mpar wc, car même si sans arguments, il affiche 2 statistiques de plus que celle que je voulais, le même dcscript après cette sortie fonctionne toujours, car le nombre que nous voulons est, heureusement, placé au-dessus de la pile pendant l'analyse.

MATL , 28 octets

:"'http://google.com'Xin]vYm

Gif ou ce n'est pas arrivé:

Comment ça marche

:                      % Implicitly input n. Push [1 2 ... n]
"                      % For each
  'http://google.com'  %   Push this string
  Xi                   %   URL read. Gives a string
  n                    %   Number of elements
]                      % End
v                      % Concatenate stack contents into a vertical vector
Ym                     % Mean. Implicitly display

PowerShell , 48 octets

1.."$args"|%{irm google.com}|measure Le* -a|% A*

Explication

1. Créez une plage de 1à l'entier d'entrée.
2. Pour chaque valeur de la plage Invoke-RestMethod( irm), la page d'accueil Google. Le résultat n'est pas JSON donc il renverra le corps mot pour mot au lieu de le désérialiser.
3. Envoyez cela à Measure-Object( measure), obtenant une moyenne de la Lengthpropriété des chaînes d'entrée (les corps).
4. Développez la Averagepropriété résultante .

Java 8, 197 184 182 181 181 octets

Golfé:

n->{int s=0,i=0;while(i++<n)try{s+=new java.util.Scanner(new java.net.URL("http://google.com").openStream()).useDelimiter("\\A").next().length();}catch(Exception e){}return s*1f/n;}

Non golfé:

public class AverageLengthOfGoogle {

  public static void main(String[] args) {
    float bytes = f(n -> {
      int s = 0, i = 0;
      while (i++ < n) {
        try {
          s += new java.util.Scanner(new java.net.URL("http://google.com").openStream())
              .useDelimiter("\\A").next().length();
        }
        catch (Exception e) {
        }
      }
      return s * 1f / n;
    } , 10);
    System.out.println(bytes);
  }

  private static float f(java.util.function.IntFunction<Float> f, int n) {
    return f.apply(n);
  }
}

Cela fuit des ressources, mais c'est un petit prix à payer à la recherche du moins d'octets.

Pyth, 25 octets

.OmslM'"http://google.com

'est la fonction ouverte en Pyth, et lorsqu'elle reçoit une chaîne commençant par http, elle effectue une requête GET sur ce site Web. La valeur de retour est une liste d' bytesobjets. Malheureusement, Pyth sne sait pas comment concaténer ces objets, donc au lieu de cela ls, j'utilise slMpour obtenir la longueur totale. Ceci est effectué un nombre de fois égal à l'entrée par m, et les résultats sont moyennés par .O.

05AB1E , 15 octets

Code:

F’Š¹.ŒŒ’.wgO}¹/

Explication:

F           }     # Input times do..
 ’Š¹.ŒŒ’          #   Push the string "google.com"
        .w        #   Read all and wrap into a string
          g       #   Get the length
           O      #   Sum it up with the total
             ¹/   # Divide by input

Utilise l' encodage CP-1252 . Lorsqu'il est exécuté dans l'interpréteur hors ligne, j'obtiens ce qui suit:

> py -3 05AB1E.py -c test.abe
1
11039.0

> py -3 05AB1E.py -c test.abe
2
11070.0

> py -3 05AB1E.py -c test.abe
3
11046.666666666666

> py -3 05AB1E.py -c test.abe
4
11029.75

> py -3 05AB1E.py -c test.abe
5
11015.8

PHP, 90 78 octets

while($i++<$argv[1]){$s+=strlen(file_get_contents('http://google.com'));}echo $s/$argv[1];

while($i++<$argv[1])$s+=strlen(join(file('http://google.com')));echo$s/($i-1);

• Utilisé des fonctions / variables plus courtes et supprimé la construction syntaxique inutile comme mentionné par les commentateurs

Mathematica, 58 octets

N@Mean[StringLength@URLFetch@"http://google.com"~Table~#]&

Fonction anonyme. Prend un nombre en entrée et renvoie un nombre en sortie.

Python, 102 octets

import urllib2
f=lambda n:sum([len(urllib2.urlopen(x).read()) for x in ['http://google.com']*n],0.0)/n

Ou, si nous pouvons retourner des entiers plutôt que des flottants, la réponse peut être de 98 octets:

import urllib2
f=lambda n:sum([len(urllib2.urlopen(x).read()) for x in ['http://google.com']*n])/n

CJam , 23 octets

rd_"google.com"a*:gs,\/

Ne fonctionne pas sur TIO pour des raisons de sécurité.

Essai

$ echo -n 'rd_"google.com"a*:gs,\/' > google-avg.cjam
$ wc -c google-avg.cjam
23 google-avg.cjam
$ java -jar cjam-0.6.5.jar google-avg.cjam <<< 10; echo
10663.2
$ java -jar cjam-0.6.5.jar google-avg.cjam <<< 10; echo
10650.0
$ java -jar cjam-0.6.5.jar google-avg.cjam <<< 10; echo
10651.0
$ java -jar cjam-0.6.5.jar google-avg.cjam <<< 10; echo
10651.4
$ java -jar cjam-0.6.5.jar google-avg.cjam <<< 10; echo
10673.5

Comment ça marche

 rd                      e# Read a double from STDIN. Let's call it D.
   _                     e# Push a copy of D.
    "google.com"a        e# Wrap the string in an array, pushing ["google.com"].
                 *       e# Repeat the array D times.
                  :g     e# Map `get` over the array, making D requests to the URL.
                    s    e# Combine all D responses into a single string.
                     ,   e# Compute the length.
                      \  e# Swap the length with the original D.
                       / e# Perform division.

CJam, 27 octets

{"google.com"g,}ri*]_:+\,d/

CJam suppose HTTP s'il n'est pas spécifié.

Explication

{"google.com"g,}             A block which fetches from http://google.com and gets its length
                ri*          Run this block a number of times equal to the input
                   ]         Collect all the results in an array
                    _        Duplicate the array
                     :+      Sum it
                       \     Swap back to the original array
                        ,    Get its length
                         d/  Cast to double and divide 
                              (without casting, it would be integer division)

Clojure, 102 octets

(fn[n](/(reduce + 0.0(repeatedly n #(count(slurp(clojure.java.io/reader"http://www.google.com")))))n))

Non golfé:

(fn [n]
  (/
   (reduce + 0.0
           (repeatedly n
                       #(count (slurp (clojure.java.io/reader "http://www.google.com")))))
   n))

#(count (slurp (clojure.java.io/reader "http://www.google.com")))est une fonction locale qui compte les octets d'une requête http vers google, repeatedlyappelle la fonction n fois et fait une liste à partir des nombres retournés, réduit les sommes ensemble les résultats, et enfin cela est divisé par n pour faire une moyenne. La réduction est démarrée à 0,0 pour forcer le résultat dans un flottant, sinon la division entraînerait un rationnel. Le tout est enveloppé dans une fonction anonyme qui prend le nombre de fois pour nommer la demande.

Python 3, 95 octets

Solution récursive

import requests as r
f=lambda n,t:f(n-1,t+len(r.get('http://google.com').text)) if n>0 else t/i

où n=i=int(input())

bibliothèque de demandes

Perl, 66 octets

perl -MLWP::Simple -pe'map$t+=length get"http://google.com",1..$_;$_=$t/$_'

51 octets + 14 octets pour -MLWP::Simple<space>+ 1 octet pour -p.

Solution simple utilisant LWP :: Simple . La getfonction est exportée par défaut et renvoie le contenu de la réponse en cas de succès.

Perl 5.14+, 94 93 octets (modules principaux uniquement)

perl -MHTTP::Tiny -pe'map$t+=length${+get{new HTTP::Tiny}"http://google.com"}{content},1..$_;$_=$t/$_'

79 octets + 13 octets pour -MHTTP::Tiny<space>+ 1 octet pour -p.

Utilise HTTP :: Tiny , qui est dans le noyau depuis Perl 5.14.

Comment ça marche

Cette:

get{new HTTP::Tiny}"http://google.com"

est la syntaxe indirecte de l'objet équivalente à ceci:

HTTP::Tiny->new->get("http://google.com")

et enregistre trois octets. La getméthode renvoie une référence de hachage avec le contenu stocké sous la contentclé.

Pour obtenir le contenu réel de la réponse, nous faisons:

${+get{new HTTP::Tiny}"http://google.com"}{content}

ce qui équivaut à:

(get{new HTTP::Tiny}"http://google.com")->{content}

mais enregistre un octet lorsque nous ajoutons length:

length(foo)->{bar}  # wrong, equivalent to (length(foo))->{bar}
length+(foo)->{bar}
length${+foo}{bar}

Rebol, 69 octets

n: 0 loop i: do input[n: n + length? read http://www.google.com]n / i

Clojure, 70 octets

#(/(reduce(fn[a _](+ a(count(slurp"http://google.com"))))0(range %))%)

Un pli sur une nlongue portée. Additionne la longueur de chaque demande, puis la divise par le nombre de demandes. En raison de la façon dont Clojure gère la division, cela renvoie une fraction, pas une décimale. Si cela est inacceptable, je peux le réparer au prix de quelques octets.

(defn avg-request-len [n]
  (/
    (reduce (fn [acc _]
              (+ acc (count (slurp "http://google.com"))))
            0
            (range n))
    n))

Ruby, 73 + 10 = 83 octets

Utilise le -rnet/httpdrapeau.

->n{s=0.0;n.times{s+=Net::HTTP.get(URI"http://www.google.com").size};s/n}

Lisp commun + quicklisp / dexador , 23 + 72 = 95 octets

Si quicklisp est installé sur le système, il téléchargera et installera dexador si nécessaire.

Prélude:

(ql:quickload :dexador)

Code

(lambda(n)(/(loop :repeat n :sum(length(dex:get"http://google.com")))n))

Non golfé:

(lambda (n)
  (/ (loop :repeat n 
           :sum (length (dex:get "http://google.com")))
     n))

Explication

(dex:get "http://google.com")

Cela effectue la demande Web à Google et renvoie cinq valeurs:

1. La demande Web elle-même sous forme de chaîne ou de tableau d'octets (selon le type de contenu)
2. Le code d'état http
3. Une carte de hachage des en-têtes de réponse http
4. Un objet QURI représentant l'URI final après la résolution des redirections
5. Le socket utilisé pour communiquer avec le serveur Web (s'il n'a pas été fermé par le serveur ou l'un des arguments optionnels de la fonction)

(length (dex:get ...))

Si vous ne demandez pas d'explicite autrement, Common Lisp supprimera toutes les valeurs de retour autres que la première, de sorte que la fonction de longueur ne voit que la réponse http elle-même et renvoie la longueur de cette chaîne.

(loop :repeat n :sum (length ...))

Cela calcule la longueur de réponse n fois et les ajoute.

(/ (loop ...) n)

Ceci divise les longueurs additionnées par n pour calculer la moyenne.

(lambda (n) ...)

Cela encapsule le corps de code dans une fonction anonyme qui prend n comme argument et renvoie la longueur de réponse moyenne pour n requêtes Web à http://google.com .