Desafío

El desafío es simple: usar http://isup.me , determinar si un sitio web ingresado está activo o inactivo.

Si el sitio está activo, debe devolver un valor verdadero y si el sitio está inactivo, debe devolver un valor falso.

Reglas

La entrada será una dirección web como stackexchange.como google.co.uk. La entrada nunca tendrá http://, https://etc. al comienzo de la cadena, pero puede tener www.o codegolf.al inicio, etc.

Debe usar el sitio isup.me/URLdonde la URL es la entrada.

Cuando un sitio está activo, se verá así:

http://isup.me/codegolf.stackexchange.com

Si un sitio está caído, se verá así:

http://isup.me/does.not.exist

Los acortadores de URL no están permitidos aparte de isup.me.

Entradas de ejemplo

Probablemente arriba (dependiendo de las circunstancias actuales):

google.de
codegolf.stackexchange.com
worldbuilding.meta.stackexchange.com
tio.run
store.nascar.com
isup.me

Estará abajo:

made.up.com
fake.com.us
why.why.why.delilah
store.antarcticrhubarbassociation.an

Victorioso

El código más corto en bytes gana.

sh (+ curl + grep), 28 26 bytes

curl -L isup.me/$1|grep ^I

Salidas a través del estado de salida (0 para arriba, 1 para abajo). Busca un Ial principio de una línea, que coincide cuando el dominio está activo (incluso para el caso especial de isup.me/isup.me ).

Apilado , 44 bytes

['http://isup.me/'\+[CS'!'eq sum 2=out]curl]

Función asíncrona que se genera 0si el sitio no está activo y cualquier otro número mayor que 0si está activo.

Ejemplo a:

['http://isup.me/'\+['s u'split#'1-put]curl] @:isup

'Is google up?' put 'google.com' isup

Salida (probablemente): Is google up? 1

Kotlin REPL - 131108106 93 79 55 53 64 63 bytes

Primero intente en el golf de Kotlin.
Espera que el sitio web en una variable o valor denominado a.

Ahora con espacios en blanco reducidos.
¿Quién dijo "loo" no es suficiente?
Fijo y más corto, ya no depende de http://isup.me .
No es necesario abrir la conexión nosotros mismos, solo obtener el flujo de datos (o no).
La tarea era usar http://isup.me , ¿verdad? Además: <no es un carácter válido en una URL.
Ahora funciona isup.mecomo el sitio web
Ahora lee el sitio web como una línea, porque no se puede suponer que una variable contenga el sitio web.

"m h" !in java.net.URL("http://isup.me/"+readLine()).readText()

Lee una línea que contiene solo el sitio web.
Cheques para elm h parte defrom here eso que se envía cuando un sitio está inactivo.

Devuelve "verdadero" o "falso" respectivamente.

Como Lambda - 172 120 118 99 85 67 66 bytes

{a:String->"m h" !in java.net.URL("http://isup.me/$a").readText()}

Se puede invocar directamente:

{ ... }("google.com")

Python 2 o 3 con solicitudes ( 70 69 68 bytes)

from requests import*;lambda u:"u. "in get("http://isup.me/"+u).text

1 byte afeitado: "u. "→" u" No, no es una optimización válida.
1 byte afeitado: __import__('requests').→from requests import*;

Esto ahora es realmente una pieza de código solo REPL, y después de ejecutar esta línea se nombrará la función _.

Python3 141 133 113 192 141 bytes

Requiere Selenium (incluido webdriver) para python.

¡Gracias a @cairdcoinheringaahing por reducir 42 bytes!
¡Gracias a @ V.Courtois por señalar una solución simple!

from selenium import*
d=webdriver.Firefox();d.get("http://isup.me/"+input());print("up"in d.find_element_by_xpath("//*[@id='content']/p[1]"))

Imprime 1si el sitio está en funcionamiento, de lo contrario imprime 0.

Versión sin golf:

from selenium import webdriver
from selenium.webdriver.common.keys import Keys
urlToTest = "www.f.com"
driver = webdriver.Firefox()
driver.get("http://downforeveryoneorjustme.com/"+urlToTest)
res = driver.find_element_by_xpath("//*[@id='content']/p[1]")
print(1 if "up" in res.text else 0)

Javascript (ES6), 74 66 bytes

f=s=>fetch('//isup.me/'+s).then(r=>r.text()).then(t=>/u!/.test(t))

Gracias a @Shaggy, que me llamó la atención que una promesa resuelta cuenta como resultado.

Problema con esta solución que arrojará un error CORS a menos que lo pruebe en una página que ya está en isup.me . Pero actualmente, eso se redirige adownforeveryoneorjustme.com

Versión antigua:

f = s => fetch ('// isup.me/'+s).then(r=>r.text()).then(t=>alert(t.match(/u!/)))

Pyth , 24 bytes

}" u"s'+"http://isup.me/

Regrese Truesi el sitio está activo, de lo Falsecontrario. La URL de entrada debe ser citada. Eso no se puede probar en el intérprete en línea porque 'está deshabilitado por razones de seguridad; en su lugar, necesitará una copia local de Pyth .

Explicación

                        Q    # Implicit input
       +"http://isup.me/     # Concatenate "http://isup.me/" with the input
      '                      # Open the URL
     s                       # Concatenate all the lines of the returned HTML page
}" u"                        # Test whether " u" is in the page or not

05AB1E , 22 bytes

"isup.me/ÿ".w#214è'‚‰Q

Pruébalo en línea!

Lamentablemente "isup.me/ÿ".w§„ uåno parece funcionar.

PowerShell, 32 bytes

(iwr isup.me/$args)-notmatch'u!'

PowerShell, 25 bytes

!(irm isup.me/$args).html

Utiliza el hecho de que Invoke-RestMethoddevuelve la página con una .htmlpropiedad solo en caso de error. (No tengo idea de por qué sucede esto exactamente ...)

invierte la línea para convertir a bool, salidas Truepara un sitio en vivo o Falsepara un sitio inactivo.

PS C:\Users\sweeneyc\Desktop> .\Test-SiteUp.ps1 "connorlsw.com"
True
PS C:\Users\sweeneyc\Desktop> .\Test-SiteUp.ps1 "connorlsw.notawebsite"
False
PS C:\Users\sweeneyc\Desktop> .\Test-SiteUp.ps1 "google.com"
True
PS C:\Users\sweeneyc\Desktop> .\Test-SiteUp.ps1 "isthisreallyasite.com"
False

Halovi , 20 bytes

oisup.me/⁰
\p
ye$hd0

Salidas p. si el sitio está inactivo y e.si está activo.

Explicación:

oisup.me/⁰  ~# Open the concatination of "isup.me/" and arg0
\p          ~# Select first p element
ye$hd0      ~# Edit text with neovim and output result:
            ~#   Go one character before the end of the line and ..
            ~#   delete until beginning

Haskell (Lambdabot), 157 bytes

import Data.ByteString.Lazy.Char8
import Network.HTTP.Simple
f s=httpLBS(parseRequest_$"http://isup.me/"++s)>>=print.not.isInfixOf"u!".unpack.getResponseBody

Lamentablemente no se puede importar Network.HTTP.Simpleen tio.runla forma más fácil de prueba sería para ejecutar este script (que necesita stack):

#!/usr/bin/env stack
-- stack --install-ghc --resolver lts-8.19 runghc --package http-conduit

import Data.ByteString.Lazy.Char8
import Network.HTTP.Simple
import Data.List

main :: IO ()
main = mapM_ test [ "google.de", "made.up.com"]
  where test url = print ("testing "++url) >> f url

f :: String -> IO ()
f s=httpLBS(parseRequest_$"http://isup.me/"++s)
 >>=print.not.isInfixOf"u!".unpack.getResponseBody

Go, 111 bytes

En la moda típica de Go, el método más corto es desembolsarlo.

import"os/exec"
func h(a string)bool{return exec.Command("sh","-c","curl -L isup.me/"+a+"|grep ^I").Run()!=nil}

Otras implementaciones aquí: https://play.golang.org/p/8T5HSDQFmC

Clojure, 63 bytes

#(clojure.string/includes?(slurp(str"http://isup.me/"%))"'s j")

Comprueba si el HTML devuelto por slurpcontiene la cadena "'s j"(como en "Es sj ust you"). Podría encontrar una cadena más pequeña que sea exclusiva de la página, pero a lo sumo me ahorraría 2 bytes. Potencialmente, también lo haría menos preciso. "'s j" no aparecerá en el marcado en ninguna parte, excepto en ese escenario. Una cadena como "u". sin embargo, podría aparecer en la URL, lo que lo rompería.

(defn is-up? [site]
  (clojure.string/includes?
    (slurp (str "http://isup.me/" site))
    "'s j"))

Nim, 108 bytes

import httpclient,strutils
echo newhttpclient().getcontent("//isup.me/"&stdin.readline.string).find("ks ")<0

Por desgracia que strutilsse necesita para contains.

Aprendizaje Nim, consejos apreciados!

PHP 82 78 bytes

<?=$i=$argv[1],+!preg_match("/!.*$i/",file_get_contents("http://isup.me/$i"));

Ejemplo de ejecución de E / S:

$ php script.php google.com
> google.com1

Ejemplo 2

$ php script.php does.not.exist
> does.not.exist0