Eu estava brincando com o recurso de solicitação de URL de Pyth e percebi que o google sempre dava uma resposta com um comprimento um pouco diferente para mim, geralmente ~10500caracteres.

Portanto, sua tarefa neste desafio é imprimir o comprimento médio da resposta html http://google.com.

Especificações

• Você receberá uma entrada nque é o número de solicitações a serem feitas.
• Para cada solicitação, você fará uma solicitação de obtenção HTTP.
• Você contará o corpo da resposta (o texto html), não os cabeçalhos.
• Emita a média aritmética dos comprimentos das respostas.
• Você só pode acessar o URL http://google.com, não qualquer outro.
• Isso é código-golfe , então o código mais curto em bytes vence!

Saída de amostra para entrada 10: 10560.1

(Eu usei Python urllibpara isso)

PS: alguém sabe por que o Google faz isso?

Bash + utilitários do sistema, 56 53 49 48 bytes

Atualização: salvou 4 bytes graças ao Digital Trauma e mais 1 byte a Dennis

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

Na minha resposta original, eu estava usando yesem combinação com xargspara emular um loop for. Mas curlpode aceitar como entrada uma lista de URLs, portanto, apenas a saída yesé realmente necessária.

Ao curlacessar o google.com , ele recebe uma página de redirecionamento 302 que possui o novo URL na seção body, portanto -Lé necessária a opção para segui-lo.

Execute o exemplo: resposta é impressa em STDOUT, redireciono STDERR apenas para maior clareza

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

Explicação: (do 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

Edit: Eu substituí wc -mpor wc, porque, mesmo sem argumentos, ele imprime mais 2 estatísticas do que o desejado, o mesmo dcscript após esta saída ainda funciona, porque a contagem que queremos é, felizmente, colocada no topo da pilha durante a análise.

MATL , 28 bytes

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

Gif ou não aconteceu:

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

Explicação

1. Crie um intervalo do 1número inteiro de entrada.
2. Para cada valor no intervalo Invoke-RestMethod( irm) a página inicial do Google. O resultado não é JSON, portanto, ele retornará o corpo literalmente, em vez de desserializar.
3. Envie isso para Measure-Object( measure), obtendo uma média da Lengthpropriedade das seqüências de entrada (os corpos).
4. Expanda a Averagepropriedade resultante .

Java 8, 197 184 182 181 bytes

Golfe:

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

Ungolfed:

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

Isso vaza recursos, mas esse é um preço pequeno a ser pago em busca do menor número de bytes.

Pitão, 25 bytes

.OmslM'"http://google.com

'é a função aberta no Pyth e, quando uma string é iniciada http, ela executa um resultado GET para esse site. O valor retornado é uma lista de bytesobjetos. Infelizmente, o Pyth's snão sabe como concatenar esses objetos, então, em vez de ls, eu uso slMpara obter o comprimento total. Isso é realizado um número de vezes igual à entrada por me os resultados são calculados em média por .O.

05AB1E , 15 bytes

Código:

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

Explicação:

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

Usa a codificação CP-1252 . Quando executado no intérprete offline, recebo o seguinte:

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

• Utilizou funções / variáveis ​​mais curtas e removeu a construção sintática desnecessária, conforme mencionado pelos comentaristas

Mathematica, 58 bytes

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

Função anônima. Pega um número como entrada e retorna um número como saída.

Python, 102 bytes

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

Ou, se podemos retornar números inteiros em vez de flutuantes, a resposta pode ser 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,\/

Não funciona no TIO por razões de segurança.

Execução de teste

$ 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

Como 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 assume HTTP se não for especificado.

Explicação

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

Ungolfed:

(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")))é uma função local que conta os bytes de uma solicitação http para o google, repeatedlychama a função n vezes e faz uma lista das contagens retornadas, reduz somas os resultados juntos e, finalmente, é dividido por n para fazer uma média. A redução é iniciada em 0,0 para forçar o resultado a flutuar - caso contrário, a divisão resultaria em um racional. Tudo está envolvido em uma função anônima que leva o número de vezes para nomear a solicitação.

Python 3, 95 bytes

Solução 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

Onde n=i=int(input())

biblioteca de solicitações

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.

Solução simples usando LWP :: Simple . A getfunção é exportada por padrão e retorna o conteúdo da resposta com êxito.

Perl 5.14+, 94 93 bytes (apenas módulos principais)

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.

Usa HTTP :: Tiny , que está no núcleo desde o Perl 5.14.

Como funciona

Este:

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

é a sintaxe indireta do objeto equivalente a isso:

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

e salva três bytes. oget método retorna um hashref com o conteúdo armazenado sob a contentchave.

Para obter o conteúdo real da resposta, fazemos:

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

que é equivalente a:

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

mas salva um byte quando adicionamos 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 %))%)

Uma dobra em nlongo alcance. Soma a duração de cada solicitação e a divide pelo número de solicitações. Devido à maneira como Clojure lida com a divisão, isso retorna uma fração, não um decimal. Se isso for inaceitável, posso corrigi-lo ao custo de alguns 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 a -rnet/httpbandeira.

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

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

Se o quicklisp estiver instalado no sistema, ele fará o download e instalará o dexador conforme necessário.

Prelúdio:

(ql:quickload :dexador)

Código

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

Ungolfed:

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

Explicação

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

Isso executa a solicitação da web para o google e retorna cinco valores:

1. A web solicita-se como uma cadeia de caracteres ou bytes (dependendo do tipo de conteúdo)
2. O código de status http
3. Um mapa de hash dos cabeçalhos de resposta http
4. Um objeto QURI que representa o URI final após resolver os redirecionamentos
5. O soquete usado para se comunicar com o servidor web (se não foi fechado pelo servidor ou por um dos argumentos opcionais para a função)

(length (dex:get ...))

Se você não solicitar explicitamente o contrário, o Common Lisp descartará todos os valores de retorno que não sejam o primeiro, portanto, a função length vê apenas a resposta http em si e retorna o comprimento dessa string.

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

Isso calcula a duração da resposta n vezes e as adiciona.

(/ (loop ...) n)

Isso divide os comprimentos somados por n para calcular a média.

(lambda (n) ...)

Isso agrupa o corpo do código em uma função anônima que recebe n como argumento e retorna o comprimento médio da resposta para n solicitações da web em http://google.com .