Ich habe mit Pyths URL-Anforderungsfunktion rumgespielt und festgestellt, dass Google mir immer eine Antwort mit einer etwas anderen Länge gab, normalerweise ~10500Zeichen.

Ihre Aufgabe bei dieser Herausforderung ist es also, die durchschnittliche Länge der HTML-Antwort von auszudrucken http://google.com.

Technische Daten

• Sie werden eine Eingabe nvornehmen, die der Anzahl der Anforderungen entspricht.
• Für jede Anforderung stellen Sie eine HTTP-Abrufanforderung.
• Sie zählen den Antworttext (den HTML-Text), nicht die Überschriften.
• Geben Sie das arithmetische Mittel der Länge der Antworten aus.
• Sie können nur auf die URL zugreifen http://google.com, nicht auf eine andere.
• Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes !

Beispielausgabe für Eingabe 10: 10560.1

(Ich habe Python's urllibdafür benutzt)

PS: weiß jemand warum google das macht?

Bash + Systemdienstprogramme, 56 53 49 48 Bytes

Update: 4 Byte dank Digital Trauma und 1 Byte mehr dank Dennis

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

In meiner ursprünglichen Antwort habe ich yesin Kombination mit xargseine for-Schleife emuliert. Aber curlkann als Eingabe eine Liste von URLs akzeptieren, so dass nur die Ausgabe von yestatsächlich benötigt wird .

Wenn curlauf google.com zugegriffen wird , wird eine 302-Umleitungsseite mit der neuen URL im Textabschnitt angezeigt. Daher ist die -LOption erforderlich, um dieser zu folgen.

Beispiel ausführen : Die Antwort wird auf STDOUT gedruckt. Ich leite STDERR nur aus Gründen der Übersichtlichkeit um

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

Erläuterung: (des ursprünglich eingereichten Codes)

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: Ich ersetzt wc -mmit wc, denn auch wenn sie ohne Argumente druckt 2 mehr Statistiken als das, was ich wollte, dasselbe dcSkript diese Ausgabe folgenden noch funktioniert, weil der Graf wir wollen , ist, glücklich, oben auf dem Stapel während des Parsing platziert.

MATL , 28 Bytes

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

Gif oder es ist nicht passiert:

Wie es funktioniert

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

Erläuterung

1. Erstellen Sie einen Bereich von 1 bis zur Eingabe-Ganzzahl.
2. Für jeden Wert im Bereich Invoke-RestMethod(irm ) die Google-Homepage. Das Ergebnis ist nicht JSON, daher wird der Body wörtlich zurückgegeben, anstatt ihn zu deserialisieren.
3. Senden Sie das an Measure-Object( measure) und erhalten Sie einen Durchschnitt vonLength Eigenschaft der Eingabezeichenfolgen (der Körper) zu erhalten.
4. Erweitern Sie die resultierende AverageEigenschaft.

Java 8, 197 184 182 181 Bytes

Golf gespielt:

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

Dies führt zu Ressourcenverlusten, ist jedoch ein geringer Preis für die Suche nach den wenigsten Bytes.

Pyth, 25 Bytes

.OmslM'"http://google.com

'ist die Open-Funktion in Pyth, und wenn eine Zeichenfolge beginnt http, wird ein GET-Befehl für diese Website ausgeführt. Der Rückgabewert ist eine Liste von bytesObjekten. Leider sweiß Pyths nicht, wie man diese Objekte verkettet, und stattdessen ermittle lsich slMdie Gesamtlänge. Dies wird eine Anzahl von Malen durchgeführt, die gleich der Eingabe von sind m, und die Ergebnisse werden gemittelt von .O.

05AB1E , 15 Bytes

Code:

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

Erläuterung:

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

Verwendet die CP-1252- Codierung. Beim Ausführen im Offline-Interpreter erhalte ich Folgendes:

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

• Verwendete kürzere Funktionen / Variablen und entfernte unnötige syntaktische Konstrukte, wie von Kommentatoren erwähnt

Mathematica, 58 Bytes

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

Anonyme Funktion. Nimmt eine Zahl als Eingabe und gibt eine Zahl als Ausgabe zurück.

Python, 102 Bytes

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

Oder wenn wir statt floats ganze Zahlen zurückgeben können, kann die Antwort 98 Bytes betragen:

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,\/

Funktioniert aus Sicherheitsgründen nicht mit TIO.

Testlauf

$ 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

Wie es funktioniert

 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 geht von HTTP aus, wenn nichts angegeben ist.

Erläuterung

{"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")))ist eine lokale Funktion, die die Bytes einer http-Anfrage an Google zählt, repeatedlydie Funktion n-mal aufruft und aus den zurückgegebenen Zählwerten eine Liste erstellt, die Ergebnisse summiert und schließlich durch n dividiert, um einen Durchschnitt zu erhalten. Die Reduktion wird bei 0.0 gestartet, um das Ergebnis in einen Float zu zwingen. Andernfalls würde die Division zu einem rationalen Ergebnis führen. Das Ganze ist in eine anonyme Funktion eingeschlossen, die die Anzahl der Namen für die Anforderung benötigt.

Python 3, 95 Bytes

Rekursive Lösung

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

woher n=i=int(input())

fordert Bibliothek an

Perl, 66 Bytes

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

51 Byte + 14 Byte für -MLWP::Simple<space>+ 1 Byte für-p .

Einfache Lösung mit LWP :: Simple . Dasget Funktion wird standardmäßig exportiert und gibt den Antwortinhalt bei Erfolg zurück.

Perl 5.14+, 94 93 Byte (nur Kernmodule)

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

79 Bytes + 13 Bytes für -MHTTP::Tiny<space>+ 1 Byte für-p .

Verwendet HTTP :: Tiny , das seit Perl 5.14 im Core enthalten ist.

Wie es funktioniert

Dies:

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

ist die indirekte Objektsyntax wie folgt :

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

und spart drei Bytes. Die getMethode gibt eine Hashref mit dem unter der gespeicherten Inhalt zurückcontent Schlüssel .

Um den tatsächlichen Inhalt der Antwort zu erhalten, führen wir Folgendes aus:

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

was äquivalent ist zu:

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

spart aber ein Byte, wenn wir hinzufügen 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 %))%)

Eine Falte über eine nlange Distanz. Summiert die Länge jeder Anforderung und teilt sie dann durch die Anzahl der Anforderungen. Aufgrund der Art und Weise, wie Clojure mit der Division umgeht, wird ein Bruch und keine Dezimalzahl zurückgegeben. Wenn dies nicht akzeptabel ist, kann ich es auf Kosten von ein paar Bytes beheben.

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

Ruby, 73 + 10 = 83 Bytes

Verwendet die -rnet/httpFlagge.

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

Wenn quicklisp auf dem System installiert ist, wird dexador heruntergeladen und bei Bedarf installiert.

Auftakt:

(ql:quickload :dexador)

Code

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

Erklärung

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

Dies führt die Webanforderung an Google aus und gibt fünf Werte zurück:

1. Die Webanforderung selbst als Zeichenfolge oder Byte-Array (je nach Inhaltstyp)
2. Der http-Statuscode
3. Eine Hash-Map der http-Antwortheader
4. Ein QURI-Objekt, das den endgültigen URI nach dem Auflösen von Umleitungen darstellt
5. Der zur Kommunikation mit dem Webserver verwendete Socket (wenn er nicht vom Server oder einem der optionalen Argumente für die Funktion geschlossen wurde)

(length (dex:get ...))

Wenn Sie keine explizite Anfrage stellen, verwirft Common Lisp alle Rückgabewerte außer dem ersten, sodass die Längenfunktion nur die http-Antwort selbst sieht und die Länge dieser Zeichenfolge zurückgibt.

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

Dadurch wird die Antwortlänge n-mal berechnet und addiert.

(/ (loop ...) n)

Dies dividiert die summierten Längen durch n, um den Durchschnitt zu berechnen.

(lambda (n) ...)

Dadurch wird der Code in eine anonyme Funktion eingeschlossen, die n als Argument verwendet und die durchschnittliche Antwortlänge für n Webanfragen an http://google.com zurückgibt .