Saya bermain-main dengan fitur permintaan url Pyth, dan memperhatikan bahwa google selalu memberikan respons dengan panjang yang sedikit berbeda untuk saya, biasanya ~10500karakter.

Jadi tugas Anda dalam tantangan ini adalah untuk mencetak panjang rata-rata respons html dari http://google.com.

Spesifikasi

• Anda akan mengambil input nyang merupakan jumlah permintaan untuk dibuat.
• Untuk setiap permintaan, Anda akan membuat permintaan dapatkan HTTP.
• Anda akan menghitung badan respons (teks html), bukan header.
• Keluarkan rata-rata aritmatika dari panjang respons.
• Anda hanya dapat mengakses url http://google.com, bukan yang lain.
• Ini adalah kode-golf , jadi kode terpendek dalam byte menang!

Output sampel untuk input 10: 10560.1

(Saya menggunakan Python urllibuntuk itu)

PS: apakah ada yang tahu mengapa google melakukan ini?

Utilitas sistem Bash +, 56 53 49 48 byte

Pembaruan: disimpan 4 byte berkat Digital Trauma dan 1 byte lebih banyak berkat Dennis

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

Dalam jawaban asli saya, saya gunakan yesdalam kombinasi dengan xargsuntuk meniru loop for. Tetapi curldapat menerima sebagai input daftar URL, sehingga hanya output dari yesyang benar-benar dibutuhkan.

Ketika curlmengakses google.com , ia menerima 302 redirection page yang memiliki URL baru di bagian body, jadi -Lopsi diperlukan untuk mengikutinya.

Jalankan contoh: jawaban dicetak ke STDOUT, saya mengarahkan STDERR hanya untuk kejelasan

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

Penjelasan: (dari kode yang awalnya dikirim)

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

Sunting: Saya diganti wc -mdengan wc, karena meskipun tanpa argumen ia mencetak 2 statistik lebih banyak daripada yang saya inginkan, dcskrip yang sama dengan output ini masih berfungsi, karena hitungan yang kami inginkan adalah, dengan senang hati, ditempatkan di atas tumpukan selama penguraian.

MATL , 28 byte

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

Gif atau tidak terjadi:

Bagaimana itu bekerja

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

Penjelasan

1. Buat rentang dari 1 ke integer input.
2. Untuk setiap nilai dalam rentang Invoke-RestMethod(irm ) beranda google. Hasilnya bukan JSON sehingga akan mengembalikan tubuh kata demi kata alih-alih deserialisasi.
3. Kirim itu ke Measure-Object( measure), dapatkan rata-rata dariLength properti dari string input (badan).
4. Perluas Averageproperti yang dihasilkan .

Java 8, 197 184 182 181 byte

Golf:

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

Tidak Disatukan:

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

Sumber daya ini bocor, tetapi itu adalah harga kecil yang harus dibayar untuk mencari byte paling sedikit.

Pyth, 25 byte

.OmslM'"http://google.com

' adalah fungsi terbuka di Pyth, dan ketika diberi string dimulai dengan http , ia melakukan GET resuest ke situs web itu. Nilai kembali adalah daftar bytesobjek. Sayangnya, Pyth stidak tahu cara menggabungkan objek-objek ini, jadi alih-alih ls, saya gunakan slMuntuk mendapatkan panjang total. Ini dilakukan beberapa kali sama dengan input oleh m, dan hasilnya dirata-rata oleh .O.

05AB1E , 15 byte

Kode:

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

Penjelasan:

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

Menggunakan pengkodean CP-1252 . Ketika dijalankan di penerjemah offline saya mendapatkan yang berikut ini:

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

• Menggunakan fungsi / variabel yang lebih pendek dan menghapus konstruksi sintaksis yang tidak perlu seperti yang disebutkan oleh komentator

Mathematica, 58 byte

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

Fungsi anonim. Mengambil nomor sebagai input, dan mengembalikan nomor sebagai output.

Python, 102 byte

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

Atau, jika kita bisa mengembalikan bilangan bulat daripada mengapung, jawabannya bisa 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,\/

Tidak bekerja pada TIO karena alasan keamanan.

Uji coba

$ 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

Bagaimana itu bekerja

 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 mengasumsikan HTTP jika tidak ditentukan.

Penjelasan

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

Tidak Disatukan:

(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")))adalah fungsi lokal yang menghitung byte dari permintaan http ke google, repeatedlymemanggil fungsi n kali dan membuat daftar dari jumlah yang dikembalikan, mengurangi jumlah hasil bersama, dan akhirnya yang dibagi dengan n untuk membuat rata-rata. Pengurangan dimulai pada 0,0 untuk memaksa hasil menjadi pelampung- jika tidak, pembagian akan menghasilkan rasional. Semuanya dibungkus dalam fungsi anonim yang membutuhkan beberapa kali untuk menyebutkan nama permintaan.

Python 3, 95 byte

Solusi rekursif

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

dimana n=i=int(input())

meminta perpustakaan

Perl, 66 byte

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

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

Solusi mudah menggunakan LWP :: Simple . Ituget Fungsi diekspor secara default dan mengembalikan konten respon pada kesuksesan.

Perl 5.14+, 94 93 byte (hanya modul inti)

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

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

Gunakan HTTP :: Tiny , yang telah menjadi inti sejak Perl 5.14.

Bagaimana itu bekerja

Ini:

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

adalah sintaks objek tidak langsung yang setara dengan ini:

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

dan menyimpan tiga byte. The getmethod mengembalikan hashref dengan konten yang disimpan di bawahcontent kunci.

Untuk mendapatkan konten respons yang sebenarnya, kami melakukan:

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

yang setara dengan:

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

tetapi menghemat satu byte saat kami menambahkan 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 %))%)

Lipatan njarak jauh. Jumlahkan panjang masing-masing permintaan, lalu bagi dengan jumlah permintaan. Karena cara Clojure menangani pembagian, ini mengembalikan sebagian, bukan desimal. Jika ini tidak dapat diterima, saya dapat memperbaikinya dengan biaya beberapa byte.

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

Ruby, 73 + 10 = 83 byte

Menggunakan -rnet/httpbendera.

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

Gangguan Umum + quicklisp / dexador , 23 + 72 = 95 byte

Jika quicklisp diinstal pada sistem, ia akan mengunduh dan menginstal dexador sebagai keharusan.

Pendahuluan:

(ql:quickload :dexador)

Kode

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

Tidak Disatukan:

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

Penjelasan

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

Ini melakukan permintaan web ke google dan mengembalikan lima nilai:

1. Permintaan web itu sendiri sebagai array string atau byte (tergantung pada jenis konten)
2. Kode status http
3. Peta hash dari header respons http
4. Objek QURI yang mewakili URI akhir setelah menyelesaikan pengalihan
5. Soket yang digunakan untuk berkomunikasi dengan server web (jika tidak ditutup oleh server atau salah satu argumen opsional untuk fungsi)

(length (dex:get ...))

Jika Anda tidak meminta sebaliknya, Common Lisp akan membuang semua nilai kembali selain yang pertama, jadi fungsi panjang hanya melihat respons http itu sendiri dan mengembalikan panjang string ini.

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

Ini menghitung panjang respons n kali dan menambahkannya.

(/ (loop ...) n)

Ini membagi panjang yang dijumlahkan dengan n untuk menghitung rata-rata.

(lambda (n) ...)

Ini membungkus tubuh kode dalam fungsi anonim yang mengambil n sebagai argumen dan mengembalikan panjang respons rata-rata untuk permintaan web ke http://google.com .