Stavo scherzando con la funzione di richiesta dell'URL di Pyth e ho notato che google ha sempre dato una risposta con una lunghezza leggermente diversa per me, di solito ~10500personaggi.

Quindi il tuo compito in questa sfida è stampare la lunghezza media della risposta html da http://google.com.

Specifiche

• Riceverai un input nche è il numero di richieste da effettuare.
• Per ogni richiesta, farai una richiesta get HTTP.
• Conterai il corpo della risposta (il testo html), non le intestazioni.
• Emette la media aritmetica delle lunghezze delle risposte.
• Puoi accedere solo all'URL http://google.com, non a nessun altro.
• Questo è code-golf , quindi vince il codice più breve in byte !

Esempio di output per input 10: 10560.1

(Ho usato Python urllibper quello)

PS: qualcuno sa perché Google lo fa?

Utilità di sistema Bash +, 56 53 49 48 byte

Aggiornamento: risparmiato 4 byte grazie a Digital Trauma e 1 byte in più grazie a Dennis

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

Nella mia risposta originale stavo usando yesin combinazione con xargsper emulare un ciclo for. Ma curlpuò accettare come input un elenco di URL, quindi yesè effettivamente necessario solo l'output di .

Quando curlaccede a google.com , riceve una pagina di reindirizzamento 302 che ha il nuovo URL nella sezione del corpo, quindi -Lè necessaria l' opzione per seguirlo.

Esegui esempio: la risposta viene stampata su STDOUT, reindirizzo STDERR solo per chiarezza

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

Spiegazione: (del codice inizialmente inviato)

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

Modifica: ho sostituito wc -mcon wc, perché anche se senza argomenti stampa 2 statistiche in più rispetto a quella che volevo, lo stesso dcscript che segue questo output funziona ancora, perché il conteggio che vogliamo è, felicemente, posto in cima allo stack durante l'analisi.

MATL , 28 byte

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

GIF o non è successo:

Come funziona

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

Spiegazione

1. Crea un intervallo da 1al numero intero di input.
2. Per ogni valore nell'intervallo Invoke-RestMethod( irm) la home page di Google. Il risultato non è JSON, quindi restituirà il corpo alla lettera invece di deserializzarlo.
3. Invialo a Measure-Object( measure), ottenendo una media della Lengthproprietà delle stringhe di input (i corpi).
4. Espandi la Averageproprietà risultante .

Java 8, 197 184 182 181 byte

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

Ciò perde risorse, ma è un piccolo prezzo da pagare alla ricerca del minor numero di byte.

Pyth, 25 byte

.OmslM'"http://google.com

'è la funzione aperta in Pyth, e quando viene data una stringa che inizia con http, esegue un GET resuest a quel sito web. Il valore restituito è un elenco di bytesoggetti. Sfortunatamente, Pyth's snon sa come concatenare questi oggetti, quindi invece di lsusare slMla lunghezza totale. Questo viene eseguito un numero di volte uguale all'input di me i risultati sono mediati da .O.

05AB1E , 15 byte

Codice:

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

Spiegazione:

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

Utilizza la codifica CP-1252 . Quando eseguito nell'interprete offline ottengo quanto segue:

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

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

• Ha usato funzioni / variabili più brevi e rimosso costrutti sintattici non necessari, come indicato dai commentatori

Mathematica, 58 byte

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

Funzione anonima. Accetta un numero come input e restituisce un numero come output.

Python, 102 byte

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

Oppure, se possiamo restituire numeri interi anziché float, la risposta può essere 98 byte:

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

CJam , 23 byte

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

Non funziona su TIO per motivi di sicurezza.

Prova

$ 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

Come funziona

 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 byte

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

CJam assume HTTP se non specificato.

Spiegazione

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

(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")))è una funzione locale che conta i byte da una richiesta http a google, repeatedlychiama la funzione n volte e crea un elenco dai conteggi restituiti, riduce insieme i risultati e infine viene diviso per n per fare una media. La riduzione viene avviata a 0,0 per forzare il risultato in un float, altrimenti la divisione si tradurrebbe in un razionale. Tutto è racchiuso in una funzione anonima che impiega il numero di volte per nominare la richiesta.

Python 3, 95 byte

Soluzione ricorsiva

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

dove n=i=int(input())

richiede la libreria

Perl, 66 byte

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

51 byte + 14 byte per -MLWP::Simple<space>+ 1 byte per -p.

Soluzione semplice usando LWP :: Semplice . La getfunzione viene esportata per impostazione predefinita e restituisce il contenuto della risposta in caso di successo.

Perl 5.14+, 94 93 byte (solo moduli core)

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

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

Utilizza HTTP :: Tiny , che è stato fondamentale sin dal Perl 5.14.

Come funziona

Questo:

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

è la sintassi dell'oggetto indiretto equivalente a questo:

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

e salva tre byte. Il getmetodo restituisce un hashref con il contenuto archiviato sotto la contentchiave.

Per ottenere il contenuto della risposta effettiva, facciamo:

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

che equivale a:

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

ma salva un byte quando aggiungiamo length:

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

Rebol, 69 byte

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

Clojure, 70 byte

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

Una piega su una nlunga distanza. Somma la lunghezza di ogni richiesta, quindi la divide per numero di richieste. A causa del modo in cui Clojure gestisce la divisione, questo restituisce una frazione, non un decimale. Se questo è inaccettabile, posso risolverlo al costo di un paio di byte.

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

Rubino, 73 + 10 = 83 byte

Usa la -rnet/httpbandiera.

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

Se quicklisp è installato sul sistema, scaricherà e installerà dexador come necessario.

Preludio:

(ql:quickload :dexador)

Codice

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

spiegazione

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

Ciò esegue la richiesta Web a Google e restituisce cinque valori:

1. La richiesta Web stessa come stringa o array di byte (a seconda del tipo di contenuto)
2. Il codice di stato http
3. Una mappa hash delle intestazioni di risposta http
4. Un oggetto QURI che rappresenta l'URI finale dopo aver risolto i reindirizzamenti
5. Il socket utilizzato per comunicare con il server Web (se non è stato chiuso dal server o da uno degli argomenti opzionali alla funzione)

(length (dex:get ...))

Se non esplicitamente richiedi diversamente, Common Lisp eliminerà tutti i valori di ritorno diversi dal primo, quindi la funzione lunghezza vede solo la risposta http stessa e restituisce la lunghezza di questa stringa.

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

Questo calcola la lunghezza della risposta n volte e le aggiunge.

(/ (loop ...) n)

Ciò divide le lunghezze sommate per n per calcolare la media.

(lambda (n) ...)

Questo avvolge il corpo del codice in una funzione anonima che accetta n come argomento e restituisce la lunghezza media della risposta per n richieste web a http://google.com .