Sfida

Dato il numero di un fumetto XKCD, genera il testo del titolo di quel fumetto (il testo del passaggio del mouse).

Tuttavia, il programma deve generare un errore quando vengono indicati i numeri 859o 404.

Regole

Il numero indicato sarà sempre un fumetto esistente (tranne 404).

Il tuo programma non deve generare errori per numeri diversi da 859o 404.

Per riferimento, il fumetto 404non esiste ed 859è:

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

Gli accorciatori di URL non sono consentiti. È possibile utilizzare Internet per ottenere il testo del titolo.

Esempi

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.

generosità

Assegnerò un premio alla risposta più breve che non riesce sul fumetto 859 perché è scritto male invece di controllare il numero.

Il tuo programma potrebbe interrompersi su altri testi alternativi (come 744) a condizione che abbiano parentesi, virgolette ecc.

vincente

Vince il codice più breve in byte.

Python 2.7 + xkcd , 55 byte

xkcd è un pacchetto Python di terze parti. In Python, c'è un pacchetto per tutto !

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

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

Per 859: IndexError: list index out of range

Richieste Python 2 + , 104 102 95 94 byte

-2 byte grazie a Erik the Outgolfer. -1 byte grazie a Jonathan Allan.

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

Obbligatorio:

import antigravity

Script scritto male, 98 byte

Quindi, scrivere script scadenti è in realtà difficile da fare intenzionalmente ... Ciò si interrompe anche su altri fumetti perché contengono citazioni, non sono sicuro che vada bene.

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

Python 2 + xkcd, 82 byte

Sceneggiatura scritta male

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

Aggiunge e antepone ''', che, a meno che il testo non contenga ''', non si spezzerà, nemmeno per altre virgolette. Cioè, tranne se il testo contiene ;;, che viene sostituito da '''(eliminando re). Questo vale solo per 859, e quindi questo codice si interrompe 859. : P

Inoltre, non si dovrebbe mai evalcasuali contenuti Internet, perché se in xkcd.getComic(n).altTextqualche modo diventasse '''+__import__('os').system('rm -rf / --no-preserve-root')+''', ciò causerebbe molte cose brutte. Vale a dire, eliminerebbe tutto ciò che è accessibile da non-sudo sul computer, a meno che non si eseguano programmi codegolf in sudo (anche non consigliato): P

Wolfram Language / Mathematica, 118 117 byte

salvato un byte grazie a numbermanic

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

Spiegazione:

Utilizzare StringTemplateper formare l'URL dall'input.

Import[..., "RawJSON"]importa l'oggetto JSON e lo analizza in un Assocation.

Seleziona il valore per la chiave "alt".

Prendi questo risultato e prova a interpretare la stringa come HTML ( Import[#,"HTML"]). Se ciò non cambia nulla, passa il risultato, se restituisce $Failed. Questo cattura 859 perché

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

risulta in:

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

404 fallisce perché

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

risultati in $Failed.

Java 8, 255 176 byte

Grazie a @ OlivierGrégoire per avermi fatto sentire un idiota e con 79 byte di sconto. ;)

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

Sembra troppo pesante ... Ancora pesante, ma "ok" per Java ...

Spiegazione:

• i->{...} Lambda che funziona come String <name>(int i) throws Exception
• new java.util.Scanner(...).setDelimiter("\\a").next() leggi tutto dal dato InputStream
  • new java.net.URL("http://xkcd.com/"+i+"/info.0.json").openStream()questo crea un InputStreamriferimento al corpo di risposta di http://xkcd.com/{comic_id}/info.0.jsoncui è la pagina informativa del fumetto desiderato
  • replaceFirst(".*\"alt\": \"","").replaceFirst("\".*","") Rimuove tutto tranne il testo alternativo (fino alla prima doppia citazione)
• ritorno implicito

Approccio alternativo più breve, 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")

Questa non è la mia soluzione, quindi non voglio pubblicare questo come primo. Tutti i crediti appartengono a @ OlivierGrégoire.

PHP, 89 86 85 byte

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

Restituisce null per 404 e 859

Salva come xkcd.php ed esegui con il numero comico ...

$ php xkcd.php 386

PHP 5.3, 280 268 262 261 180 byte

1. Salvate 11 grazie ad alcuni dei suggerimenti di Roman Gräf
2. Salvate 1 byte usando il collegamento http invece di https
3. Salvate altri 6 byte grazie a Kevin_Kinsay
4. Salvate un altro 1 byte con il suggerimento di Andy
5. Una revisione importante:

Il mio primo tentativo di giocare a golf.

Il DOMDocument si interrompe quando si incontrano dobule ID comicLink, quindi ho dovuto rimuoverli. C'è probabilmente un modo migliore per farlo.

Si blocca quando si tenta di ottenere no. 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 byte

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

Verifica

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

Quello di Python ha già vinto, ma a prescindere ...

bash + curl + sed; 88 ~ 91 ^heh byte

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

Yay per l'analisi regex JSON!

EDIT NoLongerBreathedIn ha notato (648 giorni nel futuro!) Che questo non è riuscito sul post 2048 a causa di un imprevisto \"nel JSON di quella voce. Il regex è stato aggiornato sopra; era una volta sed 's/.*alt": "\([^"]\+\).*/\1/').

Il printfwrapper gestisce ordinatamente il fatto che i caratteri Unicode sono rappresentati nella \unnnnnotazione:

$ 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༧༦࿐༄

Questo non riesce con i post 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$

Alla $fine dell'output c'è il mio prompt, e quello letteralmente stampato \nimmediatamente prima che faccia parte della stringa printf.

Ho usato deliberatamente printfperché analizzerebbe Unicode e cadrebbe terribilmente su questo post specifico.

Python 2 , 115 106 byte

-8 byte grazie agli ovs. -1 byte grazie a Jonathan Allan.

Ho pensato di mettere una risposta standard in biblioteca.

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

Bash + curl + jq: 73 66 byte

Risposta più breve che non utilizza una libreria specifica per xkcd. jq è uno strumento per manipolare oggetti json nella shell e viene fornito completo di un linguaggio di analisi per farlo.

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'

Espansione di seguito:

curl -Ls - Interroga, ma sentiti libero di reindirizzare (in questo caso verso il sito https) e non fornire alcun output non correlato.

xkcd.com/$1/info.0.json - Spudoratamente rubato da un'altra risposta.

|jq -r- Esegui jqin modalità "output non elaborato" con il seguente 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

Ora lo script è stato rielaborato per usare il //quale è l'equivalente di a or bin Python, e usiamo a |notper fare in modo che qualsiasi valore vero sia considerato falso, quindi il secondo //può stampare.alt

JavaScript (ES6), 177 175 byte

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

Incollalo nella tua console del browser, quindi esegui f(859)o f(404)ecc. - quei due dovrebbero errori nella console, nonostante non siano codificati, gli altri visualizzano.

Primo post tra un po ', scusate se non soddisfa del tutto le regole ...!

PHP, 160 byte

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

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

EDIT: Psiche è in realtà

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

Importa la decodifica HTML e l'accesso HTTP, quindi stampa il gruppo corrispondente al (...) in

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

(salvando un po 'omettendo {{Title dalla query)

Per 404 e 859, morte.

BASH, 111 108 byte

a = $ (cat) curl -s https://xkcd.com/ $ a / | grep -oP '(? <= Testo del titolo:) ([^}}] *)' [$ a = 404] && echo "$ a non trovato"

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

Per eseguire:
cambia # in numero di fumetti. Esegui dalla riga di comando.

Grazie @Ale per il suggerimento!

Javascript (ES6), 118 96 94 byte

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

Puoi incollarlo nella console del tuo browser ed eseguirlo f(123). Ma fallo su una pagina che è già su xkcd.com altrimenti vedrai un errore CORS.

Per 404, non riesce con:

Uncaught (promessa) SintassiError: token imprevisto <in JSON nella posizione 0

Per 859, fallisce con:

Uncaught (in promessa) SintassiError: mancante) dopo l'elenco degli argomenti

Aggiornamento: l'ultima versione controlla correttamente il testo alternativo invece di controllare solo 859 e si rade di altri 2 byte.