ฉันกำลังยุ่งกับคุณลักษณะการร้องขอ URL ของ Pyth และสังเกตว่า Google ให้การตอบสนองด้วยความยาวที่แตกต่างกันเล็กน้อยสำหรับฉันโดยปกติจะเป็น~10500ตัวอักษร

ดังนั้นงานของคุณในความท้าทายนี้คือการพิมพ์ความยาวเฉลี่ยของการตอบสนอง html http://google.comจาก

รายละเอียด

• คุณจะป้อนข้อมูลnซึ่งเป็นจำนวนคำขอที่จะทำ
• สำหรับคำขอแต่ละครั้งคุณจะได้รับคำขอ HTTP
• คุณจะนับเนื้อหาการตอบกลับ (ข้อความ html) ไม่ใช่ส่วนหัว
• เอาท์พุทค่าเฉลี่ยเลขคณิตของความยาวของการตอบสนอง
• คุณสามารถเข้าถึง url http://google.comได้เท่านั้นไม่ใช่อื่น ๆ
• นี่คือรหัส - กอล์ฟดังนั้นรหัสที่สั้นที่สุดในหน่วยไบต์ชนะ!

ตัวอย่างเอาต์พุตสำหรับอินพุต10: 10560.1

(ฉันใช้ Python urllibเพื่อสิ่งนั้น)

PS: ไม่มีใครรู้ว่าทำไม google ทำเช่นนี้?

ยูทิลิตี Bash + ของระบบ, 56 53 49 48 ไบต์

อัปเดต:บันทึกไว้ 4 ไบต์ด้วยDigital Traumaและอีก 1 ไบต์ขอบคุณDennis

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

ในคำตอบเดิมของฉันฉันใช้yesร่วมกับxargsเพื่อเลียนแบบห่วง แต่curlสามารถยอมรับในฐานะที่เป็นรายการของ URL ดังนั้นyesจำเป็นต้องใช้เอาต์พุตจากนั้นเท่านั้น

เมื่อ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เพราะแม้ว่าจะไม่มีอาร์กิวเมนต์มันพิมพ์สถิติมากกว่า 2 ตัวที่ฉันต้องการdcสคริปต์เดียวกันที่ตามหลังเอาต์พุตนี้ยังคงใช้ได้เพราะจำนวนที่เราต้องการคือวางอย่างมีความสุขวางอยู่บนสุดของสแต็กในระหว่างการแยกวิเคราะห์

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

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

การรั่วไหลของทรัพยากรนี้ แต่นั่นเป็นราคาขนาดเล็กที่ต้องจ่ายในการค้นหาไบต์ที่น้อยที่สุด

Pyth, 25 ไบต์

.OmslM'"http://google.com

'เป็นฟังก์ชั่นเปิดใน Pyth และเมื่อได้รับสตริงที่ขึ้นต้นด้วยhttpมันจะดำเนินการ GET ซ้ำกับเว็บไซต์ ส่งคืนค่าเป็นรายการของ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))

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")))เป็นฟังก์ชั่นในท้องถิ่นซึ่งนับไบต์จากคำขอ 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 :: ง่าย 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 เสียงกระเพื่อม + quicklisp / dexador , 23 + 72 = 95 ไบต์

หากติดตั้ง quicklisp บนระบบจะทำการดาวน์โหลดและติดตั้ง dexador เป็นสิ่งจำเป็น

โหมโรง:

(ql:quickload :dexador)

รหัส

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

ชี้แจง

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

สิ่งนี้ดำเนินการตามคำขอของเว็บถึง google และคืนค่าห้าค่า

1. คำขอเว็บเป็นสตริงหรืออาร์เรย์ไบต์ (ขึ้นอยู่กับประเภทเนื้อหา)
2. รหัสสถานะ http
3. แฮชแม็พของส่วนหัวการตอบกลับ http
4. วัตถุ QURI แสดง URI สุดท้ายหลังจากแก้ไขการเปลี่ยนเส้นทาง
5. ซ็อกเก็ตที่ใช้ในการสื่อสารกับเว็บเซิร์ฟเวอร์ (ถ้าไม่ได้ปิดโดยเซิร์ฟเวอร์หรือหนึ่งในตัวเลือกของฟังก์ชั่น)

(length (dex:get ...))

หากคุณไม่ขอคำอธิบายอย่างชัดเจน Common LISP จะยกเลิกค่าส่งคืนทั้งหมดที่ไม่ใช่ค่าแรกดังนั้นฟังก์ชันความยาวจะเห็นเฉพาะการตอบสนอง http เองและส่งคืนความยาวของสตริงนี้

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

สิ่งนี้คำนวณความยาวการตอบสนอง n ครั้งและเพิ่ม

(/ (loop ...) n)

สิ่งนี้หารความยาวที่รวมด้วย n เพื่อคำนวณค่าเฉลี่ย

(lambda (n) ...)

นี้ wraps ร่างกายของรหัสในฟังก์ชั่นที่ไม่ระบุชื่อซึ่งจะใช้เวลา n เป็นอาร์กิวเมนต์และผลตอบแทนการตอบสนองความยาวเฉลี่ยสำหรับการร้องขอเว็บ n เพื่อhttp://google.com