Pyth'un url istek özelliği ile uğraşıyordum ve google'ın her zaman benim için biraz farklı uzunluklarda bir cevap verdiğini fark ettim, genellikle ~10500karakter.

Bu yüzden buradaki göreviniz, gelen html yanıtının ortalama uzunluğunu yazdırmak http://google.com.

gözlük

• nYapılması gereken istek sayısı olan bir girdi alacaksınız.
• Her istek için bir HTTP alma isteği yapacaksınız.
• Tepki gövdesini (html metni) başlıkları değil sayarsınız.
• Cevapların uzunluklarının aritmetik ortalamasını çıkar.
• Başka bir adrese yalnızca URL’ye erişebilirsiniz http://google.com.
• Bu kod-golf , bayt cinsinden en kısa kod kazanır!

Giriş için örnek çıktı 10: 10560.1

(Bunun için Python's kullandım urllib)

Not: Google bunu neden yaptığını bilen var mı?

Bash + sistem yardımcı programları, 56 53 49 48 bayt

Güncelleme: Digital Trauma sayesinde 4 bayt , Dennis sayesinde 1 bayt daha kaydetti

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

Orijinal cevabımda for for döngüsünü taklit etmek için yesbirlikte kullanıyordum xargs. Ancak curlbir URL listesini girdi olarak kabul edebilir, bu nedenle yesaslında yalnızca çıktıya ihtiyaç duyulur.

Ne zaman curlerişimler google.com nedenle, bu, vücut bölümündeki yeni URL'ye sahip bir 302 yönlendirme sayfasını aldığında -Lseçeneği takip için gereklidir.

Örnek çalıştır: cevap STDOUT'a yazdırılıyor, STDERR'yi sadece netlik için yönlendiriyorum

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

Açıklama: (başlangıçta gönderilen kodun)

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

Düzenleme: Ben yerini wc -mile wcbile kanıtlar olmaksızın bunu isteyerek olandan 2 daha fazla istatistik yazdırır, çünkü aynı dcbu çıktıyı aşağıdaki komut hala çalışır, bizim istediğimiz sayımı, çünkü mutlu, ayrıştırma sırasında yığının en üstüne yerleştirilir.

MATL , 28 bayt

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

Gif ya da olmadı:

Nasıl çalışır

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

Güç kalkanı , 48 bayt

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

açıklama

1. Aralığından bir aralık oluştur 1Giriş tamsayısından .
2. Aralıktaki her değer için Invoke-RestMethod ( irm) içindeki için google ana sayfası. Sonuç JSON değildir, bu yüzden seriyi kaldırmak yerine bedene geri dönecektir.
3. Şuna gönder Measure-Object(measureLength , girdi dizgilerinin (gövdeler) özelliğinin bir ortalamasını almak ) .
4. Sonuçta ortaya çıkan Averageözelliği genişletin .

Java 8, 197 184 182 181 bayt

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

Bu, kaynakları sızdırıyor, ancak bu en az baytı bulmak için küçük bir bedel.

Pyth, 25 bayt

.OmslM'"http://google.com

'httpPyth'daki open işlevidir ve bir dize verildiğinde, bu web sitesine bir GET başvurusu yapar. Dönüş değeri, bytesnesnelerin bir listesidir . Ne yazık ki, Pyth's sbu nesneleri nasıl birleştireceğini bilmiyor, onun yerine toplam uzunluğu elde etmek için lskullanıyorum slM. Bu, girişe eşit sayıda yapılır mve sonuçların ortalaması alınır .O.

05AB1E , 15 bayt

Kod:

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

Açıklama:

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 kodlamasını kullanır . Çevrimdışı tercümanda çalıştırıldığında aşağıdakileri alıyorum:

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

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

• Kısa işlevler / değişkenler kullanıldı ve yorumcular tarafından belirtildiği gibi gereksiz sözdizimsel yapı kaldırıldı

Mathematica, 58 bayt

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

Anonim işlev Girdi olarak bir sayı alır ve çıktı olarak bir sayı döndürür.

Python, 102 bayt

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

Veya, kayan noktalardan ziyade tamsayıları döndürürsek, cevap 98 bayt olabilir:

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

CJam , 23 bayt

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

Güvenlik nedeniyle TIO üzerinde çalışmıyor.

Test sürüşü

$ 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

Nasıl çalışır

 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 bayt

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

CJam belirtilmemişse HTTP olduğunu varsayar.

açıklama

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

(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 isteğindeki bayt sayısını google'a yönlendiren, repeatedlyişlevi n kere çağıran ve döndürülen sayılardan bir liste yapan, sonuçları bir araya getiren ve sonuç olarak n'ye bölünen bir ortalama işlevidir. Azaltım, sonucu bir dalgalanmaya zorlamak için 0.0'da başlatılır, aksi takdirde bölünme işlemi rasyonel bir sonuç verir. Her şey, isteğin adlandırılma sayısını alan adsız bir işleve sarılır.

Python 3, 95 bayt

Özyinelemeli çözüm

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

nerede n=i=int(input())

kütüphane ister

Perl, 66 bayt

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

51 bayt + 14 bayt -MLWP::Simple<space>+ 1 bayt için -p.

LWP :: Simple kullanarak basit çözüm . getFonksiyon varsayılan olarak ihraç ve başarısına tepki içeriği döndürür.

Perl 5.14+, 94 93 bayt (yalnızca temel modüller)

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

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

Perl 5.14'ten beri çekirdek olan HTTP :: Tiny'yi kullanır .

Nasıl çalışır

Bu:

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

Bunun dolaylı nesne sözdizimi karşılığıdır:

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

ve üç bayt kaydeder. Bu getyöntem, contentanahtarın altında depolanan içeriğe sahip bir karma etiketi döndürür .

Asıl yanıt içeriğini almak için şunları yaparız:

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

hangi eşdeğerdir:

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

ancak eklediğimizde bir bayt kaydeder length:

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

Rebol, 69 bayt

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

Clojure, 70 bayt

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

nUzun bir aralığın üzerinde bir kat . Her bir isteğin uzunluğunu toplar, ardından onu istek sayısına böler. Clojure bölünmeyi yönetme şeklinden dolayı, bu bir ondalık değil kesir döndürür. Bu kabul edilebilir değilse, birkaç bayt pahasına düzeltebilirim.

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

Ruby, 73 + 10 = 83 bayt

-rnet/httpBayrağı kullanır .

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

Ortak Lisp + quicklisp / deksador , 23 + 72 = 95 bayt

Eğer quicklisp sisteme kurulursa, gerekli olan dökümanı indirir ve kurar.

Prelude:

(ql:quickload :dexador)

kod

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

Açıklama

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

Bu google için web isteği gerçekleştirir ve beş değer döndürür:

1. Web, kendisini bir dize veya bayt dizisi olarak ister (içerik türüne bağlı olarak)
2. Http durum kodu
3. Http yanıt başlıklarının bir karma haritası
4. Yönlendirmeleri çözdükten sonra son URI'yı temsil eden bir QURI nesnesi
5. Web sunucusuyla iletişim kurmak için kullanılan soket (sunucu ya da isteğe bağlı işlevlerden biri tarafından kapatılmadıysa)

(length (dex:get ...))

Aksi açıkça bir talepte bulunmazsanız, Common Lisp, ilk dışındaki tüm dönüş değerlerini atar, böylece uzunluk işlevi yalnızca http yanıtının kendisini görür ve bu dizenin uzunluğunu döndürür.

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

Bu cevap uzunluğunu n kere hesaplar ve ekler.

(/ (loop ...) n)

Bu, toplamı hesaplamak için toplanan uzunlukları n'ye böler.

(lambda (n) ...)

Bu, kodun gövdesini n'yi bir argüman olarak alan ve n web istekleri için ortalama yanıt uzunluğunu http://google.com adresine döndüren adsız bir işlevde sarar .