Я возился с функцией запроса 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 байт благодаря Деннису

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

В моем первоначальном ответе я использовал yesв сочетании с xargsдля эмуляции цикла for. Но 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

Гиф или этого не случилось:

Как это работает

:                      % 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свойство.

Ява 8, 197 184 182 181 байт

Golfed:

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 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 :: Simple . 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))

Рубин, 73 + 10 = 83 байта

Использует -rnet/httpфлаг.

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

Общая Шепелявость + 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))

Explaination

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

Это выполняет веб-запрос к Google и возвращает пять значений:

1. Сам веб-запрос в виде строки или байтового массива (в зависимости от типа контента)
2. Код статуса http
3. Хэш-карта заголовков ответа http
4. Объект QURI, представляющий окончательный URI после разрешения перенаправлений
5. Сокет, используемый для связи с веб-сервером (если он не был закрыт сервером или одним из необязательных аргументов функции)

(length (dex:get ...))

Если вы не сделаете запрос на явный вывод в противном случае, Common Lisp отбросит все возвращаемые значения, кроме первого, поэтому функция length видит только сам ответ http и возвращает длину этой строки.

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

Это вычисляет длину ответа n раз и добавляет их.

(/ (loop ...) n)

Это делит суммированные длины на n, чтобы вычислить среднее.

(lambda (n) ...)

Это оборачивает тело кода в анонимную функцию, которая принимает n в качестве аргумента и возвращает среднюю длину ответа для n веб-запросов на http://google.com .