Tôi đã loay hoay với tính năng yêu cầu url của Pyth và nhận thấy rằng google luôn đưa ra phản hồi với độ dài hơi khác nhau đối với tôi, thường là các ~10500ký tự.

Vì vậy, nhiệm vụ của bạn trong thử thách này là in ra độ dài trung bình của phản hồi html từ đó http://google.com.

Thông số kỹ thuật

• Bạn sẽ nhận một đầu vào nlà số lượng yêu cầu để thực hiện.
• Đối với mỗi yêu cầu, bạn sẽ tạo một yêu cầu nhận HTTP.
• Bạn sẽ đếm phần thân phản hồi (văn bản html), không phải tiêu đề.
• Xuất trung bình số học của độ dài của các câu trả lời.
• Bạn chỉ có thể truy cập url http://google.com, không phải bất kỳ khác.
• Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng!

Đầu ra mẫu cho đầu vào 10: 10560.1

(Tôi đã sử dụng Python urllibcho điều đó)

PS: có ai biết tại sao google làm điều này không?

Tiện ích hệ thống Bash +, 56 53 49 48 byte

Cập nhật: đã lưu 4 byte nhờ Digital Trauma và thêm 1 byte nhờ Dennis

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

Trong câu trả lời ban đầu của tôi, tôi đã sử dụng yeskết hợp với xargsđể mô phỏng một vòng lặp for. Nhưng curlcó thể chấp nhận làm đầu vào một danh sách các URL, vì vậy chỉ yesthực sự cần đầu ra từ .

Khi curltruy cập google.com , nó sẽ nhận được trang chuyển hướng 302 có URL mới trong phần nội dung, vì vậy -Lcần có tùy chọn để theo dõi nó.

Chạy ví dụ: câu trả lời được in ra STDOUT, tôi chuyển hướng STDERR chỉ cho rõ ràng

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

Giải thích: (của mã được gửi ban đầu)

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

Chỉnh sửa: Tôi đã thay thế wc -mbằng wc, vì ngay cả khi không có đối số, nó sẽ in thêm 2 số liệu thống kê tôi muốn, cùng một dctập lệnh theo kết quả đầu ra này vẫn hoạt động, bởi vì số lượng chúng tôi muốn là, vui vẻ, được đặt trên đầu ngăn xếp trong quá trình phân tích cú pháp.

MATL , 28 byte

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

Gif hoặc nó đã không xảy ra:

Làm thế nào nó hoạt động

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

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

Giải trình

1. Tạo một phạm vi từ 1đến số nguyên đầu vào.
2. Đối với mỗi giá trị trong phạm vi Invoke-RestMethod( irm) trang chủ google. Kết quả không phải là JSON nên nó sẽ trả về nguyên văn cơ thể thay vì giải tuần tự hóa nó.
3. Gửi nó tới Measure-Object( measure), lấy trung bình thuộc Lengthtính của các chuỗi đầu vào (các phần thân).
4. Mở rộng kết quả Average tài sản .

Java 8, 197 184 182 181 byte

Chơi gôn

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

Ung dung:

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

Điều này làm rò rỉ tài nguyên, nhưng đó là một cái giá nhỏ phải trả khi tìm kiếm ít byte nhất.

Bình thường, 25 byte

.OmslM'"http://google.com

'là hàm mở trong Pyth và khi được cung cấp một chuỗi bắt đầu bằng http, nó thực hiện tương tự GET cho trang web đó. Giá trị trả về là một danh sách các bytesđối tượng. Thật không may, Pyth skhông biết cách ghép các đối tượng này, vì vậy thay vì ls, tôi sử dụng slMđể có được tổng chiều dài. Điều này được thực hiện một số lần bằng với đầu vào mvà kết quả được tính trung bình theo .O.

05AB1E , 15 byte

Mã số:

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

Giải trình:

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

Sử dụng mã hóa CP-1252 . Khi chạy trong trình thông dịch ngoại tuyến, tôi nhận được như sau:

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

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

• Đã sử dụng các hàm / biến ngắn hơn và loại bỏ cấu trúc cú pháp không cần thiết như được đề cập bởi các nhà bình luận

Toán học, 58 byte

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

Chức năng ẩn danh. Lấy một số làm đầu vào và trả về một số làm đầu ra.

Python, 102 byte

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

Hoặc, nếu chúng ta có thể trả về số nguyên thay vì số float, câu trả lời có thể là 98 byte:

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

CJam , 23 byte

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

Không hoạt động trên TIO vì lý do bảo mật.

Chạy thử nghiệm

$ 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

Làm thế nào nó hoạt động

 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 byte

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

CJam giả định HTTP nếu không được chỉ định.

Giải trình

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

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

Ung dung:

(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")))là một hàm cục bộ đếm các byte từ một yêu cầu http đến google, repeatedlygọi hàm n lần và tạo một danh sách từ các số được trả về, giảm tổng các kết quả lại với nhau và cuối cùng được chia cho n để lấy trung bình. Việc giảm được bắt đầu ở mức 0,0 để buộc kết quả thành một số float - nếu không thì sự phân chia sẽ dẫn đến một tỷ lệ hợp lý. Toàn bộ điều được gói trong một hàm ẩn danh cần số lần đặt tên cho yêu cầu.

Python 3, 95 byte

Giải pháp đệ quy

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

Ở đâu n=i=int(input())

yêu cầu thư viện

Perl, 66 byte

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

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

Giải pháp đơn giản bằng cách sử dụng LWP :: Đơn giản . Các getchức năng được xuất khẩu theo mặc định và trả về nội dung trả lời trên thành công.

Perl 5.14+, 94 93 byte (chỉ các mô-đun lõi)

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

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

Sử dụng HTTP :: Tiny , vốn đã có trong lõi kể từ Perl 5.14.

Làm thế nào nó hoạt động

Điều này:

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

là cú pháp đối tượng gián tiếp tương đương với điều này:

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

và lưu ba byte. Các getphương thức trả về một hashref với nội dung được lưu trữ dướicontent then chốt.

Để có được nội dung phản hồi thực tế, chúng tôi làm:

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

tương đương với:

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

nhưng lưu một byte khi chúng ta thêm length:

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

Rebol, 69 byte

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

Clojure, 70 byte

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

Một nếp gấp trên một nphạm vi dài. Tính tổng độ dài của mỗi yêu cầu, sau đó chia cho số lượng yêu cầu. Do cách Clojure xử lý phân chia, điều này trả về một phân số, không phải là số thập phân. Nếu điều này không được chấp nhận, tôi có thể sửa nó với chi phí của một vài byte.

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

Ruby, 73 + 10 = 83 byte

Sử dụng -rnet/httpcờ.

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

Lisp + quicklisp / dexador thường gặp , 23 + 72 = 95 byte

Nếu quicklisp được cài đặt trên hệ thống, nó sẽ tải xuống và cài đặt dexador dưới dạng cần thiết.

Mở đầu:

(ql:quickload :dexador)

Mã

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

Ung dung:

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

Giải thích

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

Điều này thực hiện yêu cầu web tới google và trả về năm giá trị:

1. Bản thân yêu cầu web dưới dạng một chuỗi chuỗi hoặc byte (tùy thuộc vào loại nội dung)
2. Mã trạng thái http
3. Bản đồ băm của các tiêu đề phản hồi http
4. Một đối tượng QURI đại diện cho URI cuối cùng sau khi giải quyết các chuyển hướng
5. Ổ cắm được sử dụng để liên lạc với máy chủ web (nếu máy chủ không đóng hoặc một trong các đối số tùy chọn đối với chức năng)

(length (dex:get ...))

Nếu bạn không yêu cầu giải thích khác, Common Lisp sẽ loại bỏ tất cả các giá trị trả về khác với giá trị đầu tiên, do đó, hàm độ dài chỉ nhìn thấy phản hồi http và trả về độ dài của chuỗi này.

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

Điều này tính toán độ dài phản hồi n lần và thêm chúng.

(/ (loop ...) n)

Điều này chia độ dài tổng cho n để tính trung bình.

(lambda (n) ...)

Điều này bao bọc phần thân mã trong một hàm ẩn danh, lấy n làm đối số và trả về độ dài phản hồi trung bình cho n yêu cầu web cho http://google.com .