Estaba jugando con la función de solicitud de URL de Pyth, y noté que Google siempre daba una respuesta con una longitud ligeramente diferente para mí, generalmente ~10500caracteres.

Entonces, su tarea en este desafío es imprimir la longitud promedio de la respuesta html de http://google.com.

Especificaciones

• Tomará una entrada nque es la cantidad de solicitudes que debe realizar.
• Para cada solicitud, realizará una solicitud de obtención de HTTP.
• Contará el cuerpo de la respuesta (el texto html), no los encabezados.
• Produzca la media aritmética de las longitudes de las respuestas.
• Solo puede acceder a la URL http://google.com, no a ninguna otra.
• Este es el código de golf , por lo que gana el código más corto en bytes .

Salida de muestra para entrada 10: 10560.1

(Usé Python urllibpara eso)

PD: ¿alguien sabe por qué google hace esto?

Bash + utilidades del sistema, 56 53 49 48 bytes

Actualización: guardado 4 bytes gracias a Digital Trauma y 1 byte más gracias a Dennis

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

En mi respuesta original que estaba usando yesen combinación con xargspara emular un bucle for. Pero curlpuede aceptar como entrada una lista de URL, por lo que solo yesse necesita la salida de .

Cuando curlaccede a google.com , recibe una página de redireccionamiento 302 que tiene la nueva URL en la sección del cuerpo, por lo que -Lse necesita la opción para seguirla.

Ejecute el ejemplo: la respuesta se imprime en STDOUT, redirijo STDERR solo por claridad

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

Explicación: (del código enviado inicialmente)

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

Editar: lo reemplacé wc -mcon wc, porque incluso si sin argumentos imprime 2 estadísticas más de la que quería, el mismo dcscript que sigue a esta salida todavía funciona, porque el conteo que queremos, felizmente, se coloca en la parte superior de la pila durante el análisis.

MATL , 28 bytes

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

Gif o no sucedió:

Cómo funciona

:                      % 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 bytes

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

Explicación

1. Crea un rango desde 1el entero de entrada.
2. Para cada valor en el rango Invoke-RestMethod( irm), la página de inicio de Google. El resultado no es JSON, por lo que devolverá el cuerpo al pie de la letra en lugar de deserializarlo.
3. Envíe eso a Measure-Object( measure), obteniendo un promedio de la Lengthpropiedad de las cadenas de entrada (los cuerpos).
4. Expande la Averagepropiedad resultante .

Java 8, 197 184 182 181 bytes

Golfizado:

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

Sin 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);
  }
}

Esto pierde recursos, pero es un pequeño precio a pagar en busca de la menor cantidad de bytes.

Pyth, 25 bytes

.OmslM'"http://google.com

'es la función abierta en Pyth, y cuando se le da una cadena que comienza http, realiza una búsqueda GET en ese sitio web. El valor de retorno es una lista de bytesobjetos. Desafortunadamente, Pyth sno sabe cómo concatenar estos objetos, por lo que, en lugar de hacerlo ls, uso slMpara obtener la longitud total. Esto se realiza varias veces igual a la entrada por m, y los resultados se promedian por .O.

05AB1E , 15 bytes

Código:

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

Explicación:

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

Utiliza la codificación CP-1252 . Cuando se ejecuta en el intérprete sin conexión me sale lo siguiente:

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

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

• Usé funciones / variables más cortas y eliminé la construcción sintáctica innecesaria como mencionan los comentaristas

Mathematica, 58 bytes

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

Función anónima. Toma un número como entrada y devuelve un número como salida.

Python, 102 bytes

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

O, si podemos devolver enteros en lugar de flotantes, la respuesta puede ser de 98 bytes:

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

CJam , 23 bytes

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

No funciona en TIO por razones de seguridad.

Prueba de funcionamiento

$ 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

Cómo funciona

 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 bytes

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

CJam asume HTTP si no se especifica.

Explicación

{"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 bytes

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

Sin 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")))es una función local que cuenta los bytes de una solicitud http a google, repeatedlyllama a la función n veces y hace una lista de los recuentos devueltos, reduce las sumas de los resultados y finalmente se divide por n para hacer un promedio. La reducción se inicia en 0.0 para forzar el resultado en un flotador; de lo contrario, la división daría como resultado un racional. Todo está envuelto en una función anónima que toma el número de veces para nombrar la solicitud.

Python 3, 95 bytes

Solución recursiva

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

dónde n=i=int(input())

biblioteca de solicitudes

Perl, 66 bytes

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

51 bytes + 14 bytes para -MLWP::Simple<space>+ 1 byte para -p.

Solución directa usando LWP :: Simple . losget función se exporta de forma predeterminada y devuelve el contenido de la respuesta en caso de éxito.

Perl 5.14+, 94 93 bytes (solo módulos principales)

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

79 bytes + 13 bytes para -MHTTP::Tiny<space>+ 1 byte para-p .

Utiliza HTTP :: Tiny , que ha estado en el núcleo desde Perl 5.14.

Cómo funciona

Esta:

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

es la sintaxis del objeto indirecto equivalente a esto:

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

y guarda tres bytes. El getmétodo devuelve un hashref con el contenido almacenado encontent clave.

Para obtener el contenido de la respuesta real, hacemos:

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

que es equivalente a:

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

pero guarda un byte cuando agregamos length:

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

Rebol, 69 bytes

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

Clojure, 70 bytes

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

Un pliegue en un nlargo rango. Suma la longitud de cada solicitud, luego la divide por el número de solicitudes. Debido a la forma en que Clojure maneja la división, esto devuelve una fracción, no un decimal. Si esto es inaceptable, puedo arreglarlo a costa de un par de bytes.

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

Ruby, 73 + 10 = 83 bytes

Usa la -rnet/httpbandera.

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

Common Lisp + quicklisp / dexador , 23 + 72 = 95 bytes

Si quicklisp está instalado en el sistema, descargará e instalará el dexador como sea necesario.

Preludio:

(ql:quickload :dexador)

Código

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

Sin golf:

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

Explicación

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

Esto realiza la solicitud web a google y devuelve cinco valores:

1. La solicitud web en sí misma como una cadena o matriz de bytes (según el tipo de contenido)
2. El código de estado http
3. Un mapa hash de los encabezados de respuesta http
4. Un objeto QURI que representa el URI final después de resolver redireccionamientos
5. El socket utilizado para comunicarse con el servidor web (si no fue cerrado por el servidor o uno de los argumentos opcionales de la función)

(length (dex:get ...))

Si no solicita explícitamente lo contrario, Common Lisp descartará todos los valores de retorno que no sean el primero, por lo que la función de longitud solo ve la respuesta http en sí misma y devuelve la longitud de esta cadena.

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

Esto calcula la longitud de respuesta n veces y las agrega.

(/ (loop ...) n)

Esto divide las longitudes sumadas por n para calcular el promedio.

(lambda (n) ...)

Esto envuelve el cuerpo del código en una función anónima que toma n como argumento y devuelve la longitud promedio de respuesta para n solicitudes web a http://google.com .