我搞砸了Pyth的url请求功能，并注意到google总是给我一个长度稍有不同的响应，通常是~10500字符。

因此，您面临的挑战是从中打印html响应的平均长度http://google.com。

眼镜

• 您将输入一个输入n，即要发出的请求数。
• 对于每个请求，您将发出一个HTTP get请求。
• 您将计算响应正文（html文本），而不是标题。
• 输出响应长度的算术平均值。
• 您只能访问url http://google.com，而不能访问其他任何URL 。
• 这是代码高尔夫球，因此以字节为单位的最短代码胜出！

输入的样本输出10： 10560.1

（我urllib为此使用了Python ）

PS：有人知道为什么Google这样做吗？

Bash +系统实用程序，56 53 49 48字节

更新：由于数字创伤，节省了4个字节，由于丹尼斯，节省了1个字节

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

在我的原始答案中，我yes与结合使用xargs来模拟for循环。但是curl可以接受URL列表作为输入，因此yes实际上仅需要来自URL的输出。

当curl访问google.com时，它会收到一个302重定向页面，该页面的主体部分中包含新的URL，因此-L需要选项来遵循它。

运行示例：答案打印到STDOUT，为了清晰起见，我重定向了STDERR

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

说明：最初提交的代码）

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

编辑：我替换wc -m为wc，因为即使没有参数它也比我要dc输出的统计信息多出2条统计信息，此输出之后的相同脚本仍然有效，因为在分析过程中，我们想要的计数很高兴地位于堆栈的顶部。

MATL，28字节

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

Gif或它没有发生：

怎么运行的

:                      % 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字节

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

说明

1. 创建范围 1到输入整数。
2. 对于范围内的每个值Invoke-RestMethod（irm） google主页。结果不是JSON，因此它将逐字返回正文，而不是反序列化它。
3. 将其发送到Measure-Object（measure），以获得平均值Length输入字符串（主体）属性。
4. 展开结果Average属性。

Java的8，197 184 182 181字节

打高尔夫球：

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

取消高尔夫：

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

这会泄漏资源，但是这是寻找最少字节的代价。

Pyth，25个字节

.OmslM'"http://google.com

'是Pyth中的open函数，当给出以开头的字符串时http，它将对该网站执行GET resuest。返回值是bytes对象列表。不幸的是，Pyth s不知道如何连接这些对象，因此ls我使用代替slM来获取总长度。该操作执行的次数等于输入的m，并且将结果平均.O。

05AB1E，15个字节

码：

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

说明：

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

使用CP-1252编码。在脱机解释器中运行时，我得到以下信息：

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

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

• 使用较短的函数/变量，并删除了注释者提到的不必要的语法结构

Mathematica，58个字节

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

匿名函数。以数字作为输入，并返回数字作为输出。

Python，102字节

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

或者，如果我们可以返回整数而不是浮点数，则答案可以是98个字节：

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

CJam，23个字节

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

出于安全原因，不适用于TIO。

测试运行

$ 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

怎么运行的

 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个字节

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

如果未指定，CJam假定使用HTTP。

说明

{"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字节

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

取消高尔夫：

(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")))是一个本地函数，它计算从http请求到google的字节数，repeatedly调用n次该函数，并根据返回的计数创建一个列表，将结果相加后求和，最后除以n得出平均值。减少从0.0开始，将结果强制为浮点数，否则除法将导致有理数。整个内容都包装在一个匿名函数中，该函数需要多次命名请求。

Python 3，95个字节

递归解

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

哪里 n=i=int(input())

请求库

Perl，66个字节

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

51个字节+ 14个字节-MLWP::Simple<space>+的1个字节-p。

使用LWP :: Simple的简单解决方案。该get函数默认情况下导出，并在成功时返回响应内容。

Perl 5.14 +，94 93字节（仅核心模块）

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

79个字节+ 13个字节-MHTTP::Tiny<space>+的1个字节-p。

使用HTTP :: Tiny，该语言自Perl 5.14起便已成为核心。

怎么运行的

这个：

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

是个 间接对象​​语法的等效项：

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

并保存三个字节。该get方法返回一个hashref，其内容存储在content密钥下。

为了获得实际的响应内容，我们执行以下操作：

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

等效于：

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

但是当我们添加时保存一个字节length：

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

Rebol，69个字节

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

Clojure，70个字节

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

n远距离折叠。对每个请求的长度求和，然后将其除以请求数。由于Clojure处理除法的方式，它返回的是分数，而不是小数。如果不可接受，我可以花几个字节来修复它。

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

Ruby，73 + 10 = 83字节

使用-rnet/http标志。

->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个字节

如果在系统上安装了quicklisp，它将根据需要下载并安装dexador。

序幕：

(ql:quickload :dexador)

码

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

取消高尔夫：

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

讲解

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

这将执行对Google的网络请求，并返回五个值：

1. Web请求本身为字符串或字节数组（取决于内容类型）
2. http状态码
3. http响应标头的哈希图
4. 解析重定向后代表最终URI的QURI对象
5. 用于与Web服务器通信的套接字（如果服务器或该函数的可选args之一未将其关闭）

(length (dex:get ...))

如果没有其他明确要求，Common Lisp将丢弃除第一个以外的所有返回值，因此length函数仅看到http响应本身，并返回此字符串的长度。

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

这将计算响应长度n次并将其相加。

(/ (loop ...) n)

这将总长度除以n以计算平均值。

(lambda (n) ...)

这会将代码主体包装在一个匿名函数中，该函数以n作为参数，并将n个Web请求的平均响应长度返回给http://google.com。