Bałam się z funkcją żądania adresu URL Pyth'a i zauważyłem, że Google zawsze udzielało mi odpowiedzi o nieco innej długości, zwykle ~10500znaków.

Twoim zadaniem w tym wyzwaniu jest wydrukowanie średniej długości odpowiedzi HTML http://google.com.

Okular

• Podejmiesz dane, nktóre są liczbą żądań do złożenia.
• Dla każdego żądania utworzysz żądanie HTTP get.
• Policzysz treść odpowiedzi (tekst HTML), a nie nagłówki.
• Wyprowadza średnią arytmetyczną długości odpowiedzi.
• Możesz uzyskać dostęp tylko do adresu URL http://google.com, a nie do żadnego innego.
• To jest golf golfowy , więc wygrywa najkrótszy kod w bajtach !

Przykładowe dane wyjściowe dla danych wejściowych 10: 10560.1

(Użyłem urllibdo tego Pythona )

PS: czy ktoś wie, dlaczego Google to robi?

Bash + narzędzia systemowe, 56 53 49 48 bajtów

Aktualizacja: zapisano 4 bajty dzięki Digital Trauma i 1 bajt więcej dzięki Dennis

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

W mojej oryginalnej odpowiedzi użyłem yesw połączeniu z xargsemulacją pętli for. Ale curlmoże zaakceptować jako dane wejściowe listę adresów URL, więc tylko dane wyjściowe yessą faktycznie potrzebne.

Gdy curluzyskuje dostęp do google.com , otrzymuje stronę przekierowującą 302, która ma nowy adres URL w sekcji treści, więc -Lkonieczne jest skorzystanie z tej opcji.

Uruchom przykład: odpowiedź jest wypisywana na STDOUT, przekierowuję STDERR tylko dla jasności

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

Objaśnienie: (pierwotnie przesłanego kodu)

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: Wymieniłem wc -mz wc, bo nawet jeśli bez argumentów drukuje 2 więcej niż jednego statystyk chciałem, ten sam dcskrypt po to wyjście nadal działa, ponieważ chcemy liczyć się, szczęśliwie, umieszczone na górze stosu podczas parsowania.

MATL , 28 bajtów

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

Gif lub tak się nie stało:

Jak to działa

:                      % 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 bajtów

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

Wyjaśnienie

1. Utwórz zakres od 1 do całkowitej liczby wejściowej.
2. Dla każdej wartości w zakresie Invoke-RestMethod (irm ) strona główna Google. Wynikiem nie jest JSON, więc zwróci ciało dosłownie zamiast deserializować.
3. Wyślij to do Measure-Object(measure ), uzyskując średnią zLength właściwości ciągów wejściowych (obiektów).
4. Rozwiń uzyskaną Averagewłaściwość.

Java 8, 197 184 182 181 bajtów

Gra w golfa:

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

Nie golfowany:

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

To przecieka zasoby, ale jest to niewielka cena do zapłacenia w poszukiwaniu najmniejszej ilości bajtów.

Pyth, 25 bajtów

.OmslM'"http://google.com

'jest funkcją otwartą w Pyth, a gdy otrzyma ciąg rozpoczynający się od http, wykonuje żądanie GET dla tej witryny. Zwracana wartość to lista bytesobiektów. Niestety, Pyth snie wie, jak połączyć te obiekty, więc zamiast tego lsużywam slMdo uzyskania całkowitej długości. Odbywa się to kilka razy równa wartości wejściowej przez m, a wyniki są uśredniane przez .O.

05AB1E , 15 bajtów

Kod:

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

Wyjaśnienie:

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

Wykorzystuje kodowanie CP-1252 . Po uruchomieniu w tłumaczu offline otrzymuję następujące informacje:

> 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 bajtów

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

• Użyto krótszych funkcji / zmiennych i usunięto niepotrzebną konstrukcję składniową, o czym wspominali komentatorzy

Mathematica, 58 bajtów

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

Funkcja anonimowa. Pobiera liczbę jako dane wejściowe i zwraca liczbę jako dane wyjściowe.

Python, 102 bajty

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

Lub, jeśli możemy zwrócić liczby całkowite zamiast liczb zmiennoprzecinkowych, odpowiedź może wynosić 98 bajtów:

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

CJam , 23 bajty

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

Nie działa na TIO ze względów bezpieczeństwa.

Testowe uruchomienie

$ 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

Jak to działa

 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 bajtów

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

CJam zakłada HTTP, jeśli nie jest określony.

Wyjaśnienie

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

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

Nie golfowany:

(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")))jest funkcją lokalną, która zlicza bajty z żądania HTTP do Google, repeatedlywywołuje funkcję n razy i tworzy listę ze zwróconych zliczeń, zmniejsza sumy wyników razem, a na koniec jest dzielona przez n, aby uzyskać średnią. Zmniejszenie rozpoczyna się od wartości 0,0, aby wymusić wynik na liczbę zmiennoprzecinkową - w przeciwnym razie podział byłby racjonalny. Całość jest zapakowana w anonimową funkcję, która tyle razy nazywa nazwę żądania.

Python 3, 95 bajtów

Rozwiązanie rekurencyjne

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

gdzie n=i=int(input())

biblioteka żądań

Perl, 66 bajtów

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

51 bajtów + 14 bajtów dla -MLWP::Simple<space>+ 1 bajtu dla-p .

Proste rozwiązanie za pomocą LWP :: Proste . getFunkcja jest domyślnie eksportowane i zwraca zawartość odpowiedzi na sukces.

Perl 5.14+, 94 93 bajty (tylko moduły podstawowe)

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

79 bajtów + 13 bajtów dla -MHTTP::Tiny<space>+ 1 bajtu dla -p.

Używa HTTP :: Tiny , który jest rdzeniem od Perla 5.14.

Jak to działa

To:

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

jest pośrednim odpowiednikiem składni obiektowej tego:

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

i oszczędza trzy bajty. getMetoda zwraca hashref z treścią przechowywane pod contentkluczem.

Aby uzyskać rzeczywistą treść odpowiedzi, wykonujemy:

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

co jest równoważne z:

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

ale oszczędza jeden bajt, gdy dodajemy length:

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

Rebol, 69 bajtów

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

Clojure, 70 bajtów

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

Krotnie w ndługim zasięgu. Podsumowuje długość każdego żądania, a następnie dzieli je przez liczbę żądań. Ze względu na sposób, w jaki Clojure obsługuje podział, zwraca to ułamek, a nie dziesiętny. Jeśli jest to nie do przyjęcia, mogę to naprawić kosztem kilku bajtów.

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

Rubinowy, 73 + 10 = 83 bajty

Używa -rnet/httpflagi.

->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 bajtów

Jeśli Quicklisp jest zainstalowany w systemie, pobierze i zainstaluje dexador w razie potrzeby.

Preludium:

(ql:quickload :dexador)

Kod

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

Nie golfowany:

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

Wyjaśnienie

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

Spowoduje to wykonanie żądania internetowego do Google i zwrócenie pięciu wartości:

1. Samo żądanie sieciowe jako tablica ciągów lub bajtów (w zależności od typu zawartości)
2. Kod stanu http
3. Mapa skrótowa nagłówków odpowiedzi http
4. Obiekt QURI reprezentujący końcowy identyfikator URI po rozwiązaniu przekierowań
5. Gniazdo używane do komunikacji z serwerem WWW (jeśli nie zostało zamknięte przez serwer lub jeden z opcjonalnych argumentów funkcji)

(length (dex:get ...))

Jeśli nie zażądasz inaczej jawności, Common Lisp odrzuci wszystkie zwracane wartości inne niż pierwsza, więc funkcja długości widzi tylko odpowiedź HTTP i zwraca długość tego ciągu.

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

Oblicza to długość odpowiedzi n razy i dodaje je.

(/ (loop ...) n)

Dzieli to zsumowane długości przez n, aby obliczyć średnią.

(lambda (n) ...)

To zawija treść kodu w anonimowej funkcji, która bierze n jako argument i zwraca średnią długość odpowiedzi dla n żądań internetowych na http://google.com .