Desafio

Dado o número de uma história em quadrinhos do XKCD, produza o texto do título dessa história em quadrinhos (o texto do mouseover).

No entanto, o programa deve gerar um erro quando receber os números 859ou 404.

Regras

O número fornecido sempre será uma história em quadrinhos existente (exceto 404).

Seu programa não deve gerar um erro para outros números que não sejam 859ou 404.

Para referência, o quadrinho 404não existe e 859é:

Brains aside, I wonder how many poorly-written xkcd.com-parsing scripts will break on this title (or ;;"''{<<[' this mouseover text."

Os encurtadores de URL não são permitidos. Você pode usar a internet para obter o texto do título.

Exemplos

Input > Output
1642 > "That last LinkedIn request set a new record for the most energetic physical event ever observed. Maybe we should respond." "Nah."
1385 > ::PLOOOOSH:: Looks like you won't be making it to Vinland today, Leaf Erikson.
1275 > If replacing all the '3's doesn't fix your code, remove the 4s, too, with 'ceiling(pi) / floor(pi) * pi * r^floor(pi)'. Mmm, floor pie.
1706 > Plus, now I know that I have risk factors for elbow dysplasia, heartworm, parvo, and mange.

Recompensa

Atribuirei uma recompensa à resposta mais curta que falhar no quadrinho 859 porque está mal escrito, em vez de procurar o número.

Seu programa pode ser interrompido por outros textos alternativos (como o 744), desde que entre parênteses, aspas, etc.

Ganhando

O menor código em bytes vence.

Python 2.7 + xkcd , 55 bytes

O xkcd é um pacote Python de terceiros. No Python, há um pacote para tudo !

lambda n:[xkcd.getComic(n).altText][n==859]
import xkcd

Para 404: urllib2.HTTPError: HTTP Error 404: Not Found

Para 859: IndexError: list index out of range

Solicitações Python 2 + , 104 102 95 94 bytes

-2 bytes graças a Erik, o Outgolfer. -1 byte graças a Jonathan Allan.

lambda n:[get('http://xkcd.com/%d/info.0.json'%n).json()['alt']][n==859]
from requests import*

Obrigatório:

import antigravity

Script mal escrito, 98 bytes

Então, escrever scripts ruins é realmente difícil de fazer intencionalmente ... Isso também ocorre em outros quadrinhos porque eles contêm aspas, não tenho certeza se está tudo bem.

from requests import*
exec'print "%s"'%get('http://xkcd.com/%d/info.0.json'%input()).json()['alt']

Python 2 + xkcd, 82 bytes

Script mal escrito

lambda n:eval("'''%s'''"%xkcd.getComic(n).altText.replace(';;',"'''"))
import xkcd

Anexos e anexos ''', que, a menos que o texto contenha ''', não serão interrompidos, mesmo para outras aspas. Ou seja, exceto se o texto contiver ;;, que será substituído por '''(eliminando re). Isso só se aplica 859e, portanto, esse código é interrompido 859. : P

Além disso, nunca se deve ter evalconteúdo aleatório na Internet, porque, de xkcd.getComic(n).altTextalguma forma '''+__import__('os').system('rm -rf / --no-preserve-root')+''', isso causaria muitas coisas ruins. Ou seja, ele excluiria tudo o que é acessível por não sudo no computador, a menos que você execute programas codegolf no sudo (também não recomendado): P

Wolfram Language / Mathematica, 118 117 bytes

salvou um byte graças ao numbermanic

If[ImportString[#,"HTML"]===#,#,$Failed]&@Import[StringTemplate["http://xkcd.com/``/info.0.json"]@#,"RawJSON"]@"alt"&

Explicação:

Use StringTemplatepara formar o URL a partir da entrada.

Import[..., "RawJSON"]importa o objeto JSON e analisa-lo em um Assocation.

Selecione o valor para a chave "alt".

Pegue esse resultado e tente interpretar a string como HTML ( Import[#,"HTML"]). Se isso não mudar nada, repasse o resultado, se ele retornar $Failed. Isso pega 859 porque

ImportString[
 "Brains aside, I wonder how many poorly-written xkcd.com-parsing 
  scripts will break on this title (or ;;\"''{<<[' this mouseover text.\"","HTML"]

resulta em:

Brains aside, I wonder how many poorly-written xkcd.com-parsing 
scripts will break on this title (or ;;"''{

404 falha porque

If[
 ImportString[$Failed["alt"], "HTML"] === $Failed["alt"], 
 $Failed["alt"],
 $Failed]

resulta em $Failed.

Java 8, 255 176 bytes

Agradeço ao @ OlivierGrégoire por me fazer sentir como um idiota e com 79 bytes de folga. ;)

i->new java.util.Scanner(new java.net.URL("http://xkcd.com/"+i+"/info.0.json").openStream()).useDelimiter("\\a").next().replaceFirst(".*\"alt\": \"","").replaceFirst("\".*","")

Isso parece muito pesado ... Ainda pesado, mas "ok" para java ...

Explicação:

• i->{...} Lambda que funciona como String <name>(int i) throws Exception
• new java.util.Scanner(...).setDelimiter("\\a").next() leia tudo desde o dado InputStream
  • new java.net.URL("http://xkcd.com/"+i+"/info.0.json").openStream() isso cria um InputStream que referencia o corpo de resposta do http://xkcd.com/{comic_id}/info.0.jsonqual é a página de informações do quadrinho desejado
  • replaceFirst(".*\"alt\": \"","").replaceFirst("\".*","") Remove tudo, exceto o texto alternativo (até a primeira aspas duplas)
• retorno implícito

Abordagem alternativa mais curta, Java + json.org, 150

i->i==859?new Long(""):new org.json.JSONObject(new org.json.JSONTokener(new java.net.URL("http://xkcd.com/"+i+"/info.0.json").openStream())).get("alt")

Esta não é a minha solução, por isso não quero postar isso como o primeiro. Todos os créditos pertencem a @ OlivierGrégoire.

PHP, 89 86 85 bytes

<?=($a=$argv[1])==859?_:@json_decode(file("http://xkcd.com/$a/info.0.json")[0])->alt;

Retorna nulo para 404 e 859

Salve como xkcd.php e corra com o número cômico ...

$ php xkcd.php 386

PHP 5.3, 280 268 262 261 180 bytes

1. Economizou 11 graças a algumas sugestões de Roman Gräf
2. Economizou 1 byte usando o link http em vez de https
3. Economizou outros 6 bytes graças a Kevin_Kinsay
4. Economizou outro byte com a sugestão de Andy
5. Uma revisão importante:

Minha primeira tentativa no golfe.

O DOMDocument quebra quando encontra o ID de dobule comicLinks, então eu tive que removê-los. Provavelmente existe uma maneira melhor de fazer isso.

Falha ao tentar não. 859;)

<?php if(($x=$argv[1])==859)throw 0;$a=new DOMDocument;$b=@$a->loadHTML(implode(0,file("http://xkcd.com/$x")));echo $a->getElementsByTagName('img')->item(1)->getAttribute('title');

Python + xkcd , 54 bytes

import xkcd
lambda n:xkcd.getComic(*{n}-{859}).altText

Verificação

>>> import sys
>>> sys.tracebacklimit = 0
>>>
>>> import xkcd
>>> f = lambda n:xkcd.getComic(*{n}-{859}).altText
>>>
>>> print f(149)
Proper User Policy apparently means Simon Says.
>>>
>>> f(404)
urllib2.HTTPError: HTTP Error 404: Not Found
>>>
>>> f(859)
TypeError: getComic() takes at least 1 argument (0 given)

O Python já venceu, mas independentemente ...

bash + ondulação + sed; 88 ~ 91 ^heh bytes

printf "$(curl -s https://xkcd.com/2048/info.0.json|sed 's/.*"alt": "//;s/", "img":.*//')\n"

Yay para regex JSON análise!

EDIT NoLongerBreathedIn observou (648 dias no futuro!) Que isso falhou no pós 2048 devido a um inesperado \"no JSON dessa entrada. O regex foi atualizado acima; costumava ser sed 's/.*alt": "\([^"]\+\).*/\1/').

O printfwrapper lida perfeitamente com o fato de que caracteres Unicode são representados na \unnnnnotação:

$ printf "$(curl -s https://xkcd.com/1538/info.0.json | sed 's/.*"alt": "//;s/", "img":.*//')\n"
To me, trying to understand song lyrics feels like when I see text in a dream but it𝔰 hอᵣd t₀ ᵣeₐd aกd 𝒾 canٖt fཱྀcu༧༦࿐༄

Isso falha nas postagens 404 e 859:

404

$ printf "$(curl -s https://xkcd.com/404/info.0.json | sed 's/.*alt": "\([^"]\+\).*/\1/')\n"
<html>
<head><title>404 Not Found</title></head>
<body bgcolor="white">
<center><h1>404 Not Found</h1></center>
<hr><center>nginx</center>
</body>
</html>

859

$ printf "$(curl -s https://xkcd.com/859/info.0.json | sed 's/.*alt": "\([^"]\+\).*/\1/')\n"
Brains aside, I wonder how many poorly-written xkcd.com-parsing scripts will break on this title (or ;;\n$

O $final da saída é o meu prompt, e o impresso literalmente\n imediatamente antes de fazer parte da string printf.

Eu usei deliberadamente printfporque ele analisaria o Unicode e cairia muito sobre esse post específico.

Python 2 , 115 106 bytes

-8 bytes graças a ovs. -1 byte graças a Jonathan Allan.

Só pensei em colocar uma resposta padrão da biblioteca lá fora.

lambda n:[json.load(urllib.urlopen('http://xkcd.com/%d/info.0.json'%n))['alt']][n==859]
import urllib,json

Bash + ondulação + jq: 73 66 bytes

Resposta mais curta que não usa uma biblioteca específica do xkcd. O jq é uma ferramenta para manipular objetos json no shell, e vem completo com uma linguagem de análise para fazer isso.

curl -Ls xkcd.com/$1/info.0.json|jq -r 'if.num==859then.num.a else.alt end'

curl -Ls xkcd.com/$1/info.0.json|jq -r '(.num!=859//.[9]|not)//.alt'

Expansão abaixo:

curl -Ls - Consulte, mas sinta-se à vontade para redirecionar (neste caso para o site https) e não dê saída não relacionada.

xkcd.com/$1/info.0.json - Vergonhosamente roubado de outra resposta.

|jq -r- Execute jqno modo "saída bruta" no seguinte comando.

if .num == 859 then .num.a # This fails because you can't get the key 'a' from a property that's an integer else .alt # And this pulls out the 'alt' key from our object. end

Agora, o script foi re-trabalhado para usar //o equivalente a or bem python, e usamos a |notpara fazer com que qualquer valor verdadeiro seja considerado falso, para que o segundo //possa ser impresso.alt

JavaScript (ES6), 177 175 bytes

p=(x)=>{eval(`console.log("${x.alt}")`)};f=(y)=>{var d=document,e=d.createElement("script");e.src=`//dynamic.xkcd.com/api-0/jsonp/comic/${y}?callback=p`;d.body.appendChild(e)}}

Cole isso no console do navegador, execute f(859)ou f(404)etc - esses dois erros no console, apesar de não serem codificados, os outros são exibidos.

Primeiro post em um tempo, desculpe se ele não atende às regras ...!

PHP, 160 bytes

<? preg_match_all('/(tle=\")(.+)(\")\sa/',join(0,file('http://xkcd.com/'.$argv[1])),$a);echo(strstr($c=$a[2][0],'Brains asid'))?$b:html_entity_decode($c,3);

Perl, 129 167 bytes

use LWP::Simple;use HTML::Entities;print decode_entities($1)if(get("http://www.xkcd.com/$ARGV[0]")=~m/text: ([^<]*)\}\}<\/div>/)

EDIT: Psyche é realmente

use LWP::Simple;use HTML::Entities;$x=$ARGV[0];if($x==404||$x==859){die}else{print decode_entities($1)if(get("http://www.xkcd.com/$x")=~m/text: ([^<]*)\}\}<\/div>/)}

Importe a decodificação HTML e o acesso HTTP e imprima o grupo correspondente ao (...)

{{Title text: (...)}}</div>

(economizando um pouco, omitindo {{Title a consulta)

Para 404 e 859, morte.

BATER, 111 108 bytes

a = $ (cat) curl -s https://xkcd.com/ $ a / | grep -oP '(? <= texto do título:) ([^}}] *)' [$ a = 404] && echo "$ a não encontrado"

a=#;curl -s https://xkcd.com/$a/ |grep -oP '(?<=Title text:)([^}}]*)';[ $a = 404 ] && echo "$a not found"

Para executar:
altere # para o número de quadrinhos. Executar a partir da linha de comando.

Obrigado @Ale pela sugestão!

Javascript (ES6), 118 96 94 bytes

f=n=>fetch(`//xkcd.com/${n}/info.0.json`).then(x=>x.json()).then(y=>eval(`alert('${y.alt}')`))

Você pode colar isso no console do navegador e executar f(123). Mas faça isso em uma página que já está no xkcd.com ou você verá um erro de CORS.

Para 404, ele falha com:

Não detectado (na promessa) SyntaxError: token inesperado <no JSON na posição 0

Para 859, ele falha com:

Não detectado (em promessa) SyntaxError: ausente) após a lista de argumentos

Atualização: a versão mais recente verifica corretamente o texto alternativo em vez de verificar apenas 859 e raspar outros 2 bytes.