Longitud promedio de Google

24

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

Maltysen
fuente
1
Extraño, http://google.comsiempre devuelve 261 bytes para mí ... https://google.com/ncraunque podría devolver más.
Neil
@Neil Odd, http://google.comsiempre devuelve 10422 bytes para mí ...
LegionMammal978
¿Se puede devolver una razón de enteros (es decir, una fracción exacta)?
LegionMammal978
55
@Neil Obtiene 261 bytes porque en realidad recibe una redirección de URL, código 302, que tiene en el cuerpo la nueva URL a seguir. Algunos programas, como curl on linux, necesitan un argumento específico para seguir esa nueva URL automáticamente.
seshoumara
3
@seshoumara TBH, el desafío no especifica seguir las redirecciones, por lo que esperaría que la respuesta de Neil sea la respuesta correcta por defecto, ya que maneja la respuesta HTTP real que http://google.comenvía. Por supuesto, este no es el objetivo del desafío, por lo que el desafío debería editarse en la OMI para reflejarlo.
Aaron

Respuestas:

20

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.

seshoumara
fuente
@ DigitalTrauma Muy agradable, no es necesario xargs. Gracias, actualicé la respuesta.
seshoumara
2
No es necesario -s. La salida extraviada a STDERR está permitida por defecto.
Dennis
@ Dennis Gracias, respuesta actualizada.
seshoumara
17

MATL , 28 bytes

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

Gif o no sucedió:

ingrese la descripción de la imagen aquí

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
Luis Mendo
fuente
12

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 .
briantista
fuente
no sabía |% A*que era posible, yo siempre he evitado measureporque pensé que no podía comodín el nombre de propiedad ...
colsw
2
@ConnorLSW sí, esto es algo que descubrí recientemente mientras preparaba una presentación sobre el código de golf en PowerShell. Echa un vistazo a |? A*algunas cosas interesantes también. Necesito mirar mis archivos de presentación y agregar estas cosas al hilo de consejos.
briantist
10

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.


fuente
1
Posibles mejoras: 1. doble -> flotante 2. google.com -> google.com 3. tal vez no sea necesario especificar la codificación, debería haber algún método obsoleto Debe guardar unos 20 bytes
kukis
@kukis gracias, eso redujo 13 bytes.
n->{int s=0,i=0;for(;i<n;++i)try{...}catch(Exception e){}return s*1.0/n;}. No estoy seguro de si puede reemplazar s*1.0/nen el regreso s*1f/n, pero vale la pena intentarlo
Roman Gräf
@ RomanGräf sí, eso funciona. ¡Gracias!
for(;i<n;++i)se puede cambiar for(;i++<n;)por -1 byte.
Kevin Cruijssen
7

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.

isaacg
fuente
7

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
Adnan
fuente
¡O tienes un incorporado para google.com o algo más está sucediendo!
Pureferret
@Pureferret Es en realidad una cadena comprimida de diccionario. Puedes probarlo aquí :).
Adnan
¿Se permite el uso de idiomas dedicados al golf? Si es así, teóricamente puedo inventar un lenguaje que haga todas estas cosas en un byte
kukis
@kukis El uso de idiomas de golf dedicados está permitido, si y solo si la versión de idioma utilizada no es posterior al desafío. Si crea un lenguaje que puede hacer todas estas cosas en un byte, pero el compilador se creó después del desafío, es una violación tanto de esto como de esto .
Adnan
7

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
Michael Tsang
fuente
2
Bienvenido a codegolf.se! join(file())en lugar de file_get_contents()ahorrarte unos pocos bytes.
Christoph
2
Además, puede soltar las llaves y el espacio después de echo. También puede usar en $ilugar de $argv[1]como divisor.
usuario59178
6

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.

LegionMammal978
fuente
¿Por qué lo necesitas N@? No lo está imprimiendo, por lo que no hay razón para formatearlo bien.
Pavel
@Pavel OP especificó que las fracciones exactas no están permitidas.
LegionMammal978
3

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
totalmente invitado
fuente
1
Puede eliminar un par de espacios allí. )for x in[. Además, si se restringe a Python 3, la división será automáticamente una división flotante, y puede eliminarla 0.0.
mbomb007
1
Tampoco necesita []en el segundo caso - sumtoma ungenerator
Bahrom
3

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.
Dennis
fuente
1

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)
Gato de negocios
fuente
1

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.

djeis
fuente
¡Juro que no copié esta respuesta! La mía terminó bastante cerca de la tuya. La (clojure.java.io/reader)parte es innecesaria por cierto. Se hace automáticamente detrás de escena si pasa una cadena.
Carcigenicate
1

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

Miguel
fuente
Las solicitudes parecen ser una biblioteca externa, por lo que querrá agregar un enlace a eso. Algo así comoPython 3 + [Requests](http://docs.python-requests.org/en/master/user/install/#install), 95 bytes
Value Ink
@ValueInk, agregado, sin embargo, no es necesario instalarlo, viene con python3 (al menos vino por defecto para mí). ¿Por qué la otra respuesta de Python no necesita hacerlo?
Miguel
urllib2es una biblioteca nativa de Python (preinstalada) docs.python.org/2/library/urllib2.html para que cualquiera que descargue Python pueda ejecutar su código de inmediato. No puedo ejecutar su código en mi Python 3 sin esa biblioteca.
Value Ink
@ValueInk no hay problema, mi primera contribución aquí, no lo sabía
Miguel
1

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}
ThisSuitIsBlackNot
fuente
0

Rebol, 69 bytes

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

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))
Carcigenicate
fuente
0

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}
Tinta de valor
fuente
0

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 .

djeis
fuente