Appunti

• Questo thread è aperto e sbloccato solo perché la community ha deciso di fare un'eccezione . Si prega di non utilizzare questa domanda come prova che è possibile porre domande simili qui. Si prega di non creare ulteriori domande vetrina .

• Questo non è più un concorso di popolarità , né le lunghezze dei frammenti sono limitate dal conteggio dei voti. Se conosci questo thread da prima, assicurati di familiarizzare con le modifiche.

Questo thread è dedicato a mostrare funzionalità interessanti, utili, oscure e / o uniche che i tuoi linguaggi di programmazione preferiti hanno da offrire. Questa non è né una sfida né una competizione, ma uno sforzo di collaborazione per mostrare il maggior numero possibile di linguaggi di programmazione.

Come funziona

• Tutte le risposte dovrebbero includere il nome del linguaggio di programmazione nella parte superiore del post, preceduto da a #.

• Le risposte possono contenere uno (e solo uno) factoide, ovvero un paio di frasi senza codice che descrivono la lingua.

• A parte il factoide, le risposte dovrebbero consistere in frammenti di codice, che possono (ma non devono essere) programmi o funzioni.

• Non è necessario che i frammenti siano correlati. In effetti, i frammenti troppo correlati potrebbero essere ridondanti.

• Dal momento che questo non è un concorso, tutti i linguaggi di programmazione sono i benvenuti, ogni volta che sono stati creati.

• Le risposte che contengono più di una manciata di snippet di codice dovrebbero utilizzare uno snippet di stack per comprimere tutto tranne il factoid e uno dei snippet.

• Quando possibile, dovrebbe esserci una sola risposta per linguaggio di programmazione. Questa è una wiki della comunità, quindi sentiti libero di aggiungere frammenti a qualsiasi risposta, anche se non l'hai creata tu stesso. Esiste uno snippet di stack per la compressione dei post , che dovrebbe mitigare l'effetto del limite di 30.000 caratteri.

Le risposte che precedono queste linee guida dovrebbero essere modificate. Aiutate ad aggiornarli secondo necessità.

Risposte correnti, in ordine alfabetico per nome della lingua

$.ajax({type:"GET",url:"https://api.stackexchange.com/2.2/questions/44680/answers?site=codegolf&filter=withbody",success:function(data){for(var i=0;i<data.items.length;i++){var temp=document.createElement('p');temp.innerHTML = data.items[i].body.split("\n")[0];$('#list').append('<li><a href="/a/' + data.items[i].answer_id + '">' + temp.innerText || temp.textContent + '</a>');}}})

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><base href="http://codegolf.stackexchange.com"><ul id="list"></ul>

matematica

Potresti voler leggere questo dal basso verso l'alto dal momento che è l'ordine in cui è stato scritto e alcune spiegazioni faranno riferimento a frammenti precedenti o assumeranno spiegazioni da più in basso.

L'elenco sta crescendo abbastanza a lungo. Ho iniziato a rimuovere frammenti meno interessanti e ora inizierò a saltare frammenti. Consulta la cronologia delle revisioni per un elenco completo di frammenti fino a 41. Per alcune gemme vere, controlla i frammenti 81 , 64 , 44 , 23 , 19 , 12 e 8 .

Lunghezza frammenti 143 e 144

Finalmente ... lo stavo aspettando da un po '(e ci sto giocando da tanto tempo, quindi non devo aspettare ancora). Ho accennato in precedenza che puoi anche equazioni numericamente e che puoi anche risolvere equazioni differenziali. Volevo mostrare un esempio non banale di questo.

Considera un doppio pendolo su un'asta (cioè un pendolo attaccato ad un altro). Ogni asta ha una lunghezza unitaria e ciascuno dei due pesi pendolo ha una massa unitaria. Ho anche usato la gravità unitaria per abbreviare l'equazione. Il seguente frammento di 143 caratteri risolve le equazioni di moto lagrangiane per tale sistema (in termini di angoli dei pendoli e momento angolare). Una derivazione può essere trovata in questo PDF , sebbene sia un esercizio abbastanza diretto se hai familiarità con la meccanica lagrangiana.

È abbastanza illeggibile, perché ho dovuto giocare molto a golf:

d=θ@t-φ@t;NDSolve[{#''@t==-#4#2''[t]Cos@d-##3#2'@t^2Sin@d-Sin@#@t&@@@{{θ,φ,1,.5},{φ,θ,-1,1}},θ@0==2,φ@0==1,θ'@t==φ'@t==0/.t->0},{θ,φ},{t,0,60}]

La cosa bella è che Mathematica mostra immediatamente una trama in miniatura di come appaiono approssimativamente le soluzioni:

Va bene, ma è un po 'zoppo. Vogliamo sapere che aspetto ha effettivamente il movimento della pendola. Quindi ecco uno snippet di 144 caratteri, che anima la pendula mentre traccia la traiettoria del pendolo inferiore:

Graphics@{Line@{{0,0},p=θ~(h={Sin@#@#2,-Cos@#@#2}&)~t,p+φ~h~t},White,{0,0}~Circle~2.2}~Show~ParametricPlot[θ~h~u+φ~h~u,{u,0,t}]~Animate~{t,0,60}

L'animazione risultante è simile al seguente:

^{Ho dovuto imbrogliare leggermente: se tracci oltre t = 30, ParametricPlotper impostazione predefinita usa troppi punti trama e la linea diventa piuttosto frastagliata. Ma la maggior parte delle dinamiche interessanti si verificano dopo quel tempo, quindi ho usato l'opzione PlotPoints -> 200per rendere la seconda metà dell'animazione più fluida. Non è nulla di sostanzialmente diverso, e la prima metà sembrerebbe comunque indistinguibile.}

Penso che questo sarà il mio ultimo frammento, a meno che non mi venga in mente qualcosa di veramente sconvolgente. Spero ti sia piaciuto!

Lunghezza 100 frammento

GeoGraphics[{GeoStyling[Opacity[0.5]], NightHemisphere[]}, GeoBackground -> GeoStyling["ReliefMap"]]

Stavo pensando ad alcune belle Geofunzioni per lo snippet 100, ma alla fine ho trovato qualcosa di veramente elegante su Tweet-a-Program , che dovevo solo rubare. Quanto sopra genera una bella mappa solare della Terra per l'ora e il giorno attuali, sovrapponendo una forma semi-opaca dell'emisfero notturno su una mappa in rilievo:

Lunghezza frammento 81

CellularAutomaton[{{0,2,3,If[0<Count[#,1,2]<3,1,3]}[[#[[2,2]]+1]]&,{},{1,1}},i,n]

Prometto che è l'ultimo automa cellulare. Ma proprio lì c'è Wireworld in 81 personaggi. Questa volta non ho codificato la regola in un singolo numero, a) perché penso che sarebbe ridicolmente enorme (non mi sono preoccupato di capirlo) eb) per mostrarti l'ennesimo uso di CellularAutomaton. Questa volta, la regola viene semplicemente specificata come una funzione pura, che riceve un vicinato di celle e restituisce il nuovo valore della cella. Questo è un approccio molto più fattibile per gli automi cellulari con più di 2 colori / stati.

Ad ogni modo, ho impostato l'esempio di Wikipedia in i(due orologi che generano segnali e un gate XOR) e l'ho lasciato correre per circa 50 passaggi:

Se sei interessato, la trama e l'animazione effettive potrebbero essere state snippet 77:

ListAnimate[ArrayPlot[#,ColorRules->{0->Black,1->Blue,2->Red,3->Yellow}]&/@w]

Snippet di lunghezza 69

DSolve[r^2*R''[r]+2r*R'[r]-R[r]==0&&(R[r]==1&&R'[r]==2/.r->1),R[r],r]

Torna a qualcosa di utile. Oltre ai normali sistemi di equazioni, Mathematica può anche risolvere sistemi di equazioni differenziali. Quanto sopra è tecnicamente solo un'equazione differenziale con condizioni al contorno, ma puoi anche fornirla come un sistema di tre equazioni. Simile alle funzioni integrative DSolveè per soluzioni esatte mentre NDSolverisolverà il sistema numericamente. Quanto sopra produce un'unica soluzione

{{R[r] -> 1/2 r^(-(1/2) - Sqrt[5]/2) (1 - Sqrt[5] + r^Sqrt[5] + Sqrt[5] r^Sqrt[5])}}

che ora potrebbe essere facilmente utilizzato per ulteriori calcoli o tracciato.

Lunghezza 64 frammento

CellularAutomaton[{224,{2,{{2,2,2},{2,1,2},{2,2,2}}},{1,1}},i,n]

Ti ho promesso più CellularAutomatonmagia! Questo frammento calcola il gioco della vita di Conways con le condizioni iniziali iper i npassaggi e fornisce il risultato per tutti i timestep intermedi.

Qualche parola sui parametri: 2è il numero di stati di cella. {{2,2,2},{2,1,2},{2,2,2}}fornisce i pesi per le 9 celle nel quartiere 3x3. Assicura che la cella stessa sia distinguibile dalla somma degli 8 vicini. {1,1}afferma che la regola CA dipende dalle celle 1 passo in entrambe le direzioni. Infine, 224la regola di aggiornamento effettiva è codificata in un singolo numero. Capire questo numero può essere un po 'complicato, ma c'è un tutorial abbastanza utile nella documentazione . Per automi più complicati, un singolo numero non lo taglierà (perché il numero sarebbe enorme). Forse ci arriveremo domani! ;)

Ad ogni modo, se inserisco una griglia casuale in ie 200 in ne invio il risultato tramite un'animazione ArrayPlot, possiamo vedere che funziona davvero:

Lunghezza 59 frammento

SphericalPlot3D[Re[Sin[θ]Cos[θ]Exp[2I*φ]],{θ,0,π},{φ,0,2π}]

Ricordi il diagramma polare dello snippet 26? Possiamo fare la stessa cosa in 3D! (In effetti, ci sono due funzioni: RevolutionPlot3Dper le polari cilindriche e SphericalPlot3Dper le polari sferiche.) Proprio come Graphics3Dtutti i grafici tridimensionali sono automaticamente ruotabili in Mathematica, quindi non devi preoccuparti di un buon angolo di ripresa frontale. Quanto sopra traccia qualcosa di simile a un'armonica sferica (non del tutto) e sembra:

Lunghezza frammento 52

Manipulate[Plot[x^2a+x*b,{x,-3,3}],{a,.1,3},{b,0,3}]

Questo è piuttosto elegante. Manipulateprende qualsiasi espressione, la parametrizza con un mucchio di variabili e quindi ti dà un widget, dove puoi modificare i parametri e vedere dal vivo come cambia l'espressione. Come espressione di solito avrai una sorta di trama. Ciò è particolarmente utile se stai usando Mathematica nelle lezioni per dimostrare come le famiglie di soluzioni rispondono alla modifica dei parametri. Quanto sopra dimostra come i aei bcoefficienti scalare e spostano una parabola:

Lunghezza frammento 48

Import["http://www.google.com/doodles","Images"]

Importè un comando abbastanza potente. È usato sia per caricare file dal disco che dal web. Conosce molti formati di file diversi e per alcuni di essi (come le pagine HTML) può effettivamente estrarre i dati immediatamente. Quanto sopra scarica tutte le immagini dalla pagina doodle di Google.

Lunghezza frammento 45

EdgeDetect@ExampleData@{"TestImage","Splash"}

Tempo per l'elaborazione di alcune immagini. Mathematica include molti dati di esempio, tra cui immagini (come Lena), trame, modelli 3D e frammenti audio. Innanzitutto, cariciamo uno di quelli:

Vuoi rilevare i bordi? È una singola chiamata di funzione:

Lunghezza 44 frammento

ArrayPlot@CellularAutomaton[110,{{1},0},100]

Alla fine, ho abbastanza personaggi da usare CellularAutomatone anche renderizzare il risultato. :) Per quanto ne so, CellularAutomatonè l'unica funzione in Mathematica relativa alle CA. Stephen Wolfram sembra considerarsi il numero uno quando si tratta di automi cellulari, quindi questa funzione è incredibilmente potente. Quanto sopra mostra praticamente il suo utilizzo più semplice. Questo simula un automa cellulare 1D per 100 passi - e in realtà restituirà lo stato dell'automa in ciascuno di quei passi, quindi il risultato è bidimensionale. La regola è il primo parametro, che può essere specificato in dettaglio tramite elenchi o semplicemente codificato in un singolo numero. Per questo esempio, ho scelto la regola di Turing piuttosto famosa, regola 110 . {{1},0}definisce la condizione iniziale: una singola1davanti a uno sfondo di zeri. Forse CellularAutomatonin futuro mostrerò alcune caratteristiche in più quando avrò più personaggi disponibili: può simulare CA in dimensioni più elevate, usando quartieri più grandi e con più di due stati.

ArrayPlotè un'altra bella utility per la stampa che traccia semplicemente un elenco 2D come una griglia di colori solidi che ne indica il valore. Nel caso più semplice, 0è mappend al bianco e 1al nero. Il risultato dello snippet è:

Lunghezza 43 frammento

HighlightGraph[graph,FindVertexCover@graph]

È passato un po 'di tempo da quando ho citato i grafici. Ci sono molti problemi teorici sui grafici comuni integrati in Mathematica, insieme a strumenti di visualizzazione gradevoli. Quanto sopra, per un dato motivo graph, troverà una copertura minima del vertice del grafico, quindi eseguirà il rendering del grafico con quei vertici evidenziati. Ad esempio, se graphè PetersenGraph[7,2]tornato dallo snippet 18, otteniamo:

Lunghezza 42 frammento

Animate[Plot[Sin[t-x],{x,0,10}], {t,0,10}]

È abbastanza semplice animare le cose in Mathematica (e non devono nemmeno essere immagini). Devi solo dargli l'espressione da valutare per ogni frame e un mucchio di parametri che dovrebbero variare sui frame. Quanto sopra semplicemente anima una trama di un'onda sinusoidale in movimento. L'animazione sarà simile alla seguente GIF:

Lunghezza 40 frammento

SortBy[PlanetData[#, "EscapeVelocity"]&]

SortByfa quello che ti aspetti: ordina un elenco in base ai valori ottenuti mappando una determinata funzione su ciascun elemento dell'elenco. Ma aspetta, la chiamata sopra non contiene affatto un elenco. Da Mathematica 10, esiste il supporto per il curry o l' applicazione parziale per alcune funzioni. Questa non è una caratteristica del linguaggio come nei linguaggi funzionali più puristi, ma è solo implementata manualmente per un sacco di funzioni in cui ciò è spesso utile. Significa che il frammento di cui sopra restituisce una nuova funzione, che accetta solo un elenco e quindi ordina per la funzione specificata. Questo può essere molto utile se questo ordinamento è qualcosa che userai più spesso in tutto il tuo codice.

E sì, c'è un'altra bella *Datafunzione: quanto sopra ordinerà i nomi dei pianeti in base alle velocità di fuga dei pianeti .

Lunghezza 39 frammento

f[1]=1
f[2]=1
f[n_]:=f[n]=f[n-1]+f[n-2]

Ho promesso di rendere la funzione di Fibonacci più efficiente. Questo frammento mostra quanto sia banale la memoria in Mathematica. Si noti che tutto ciò che è cambiato è un ulteriore f[n]=nella terza riga. Quindi, quando fviene richiesto un nuovo valore (diciamo f[3]), f[3]=f[3-1]+f[3-2]verrà valutato. Questo calcola f[2]+f[1], quindi lo assegna a f[3](con =, non con :=!) E alla fine restituisce il valore per la nostra chiamata iniziale. Quindi la chiamata a questa funzione aggiunge una nuova definizione per questo valore, che è ovviamente più specifica della regola generale - e quindi verrà utilizzata per tutte le chiamate future fcon quel valore.

Ricorda che l'altra funzione di Fibonacci ha impiegato 4 secondi per 30 valori? Ciò richiede 3 secondi per 300.000 valori.

Lunghezza 37 frammento

l//.{a___,x_,b___,x_,c___}:>{a,x,b,c}

Nell'ultimo frammento ho menzionato i modelli. Questi sono spesso usati nelle regole , che (tra le altre cose) possono essere usate per modificare strutture che corrispondono ad un certo schema. Quindi diamo un'occhiata a questo frammento.

{a___,x_,b___,x_,c___}:>{a,x,b,c}è una regola. x_con un singolo carattere di sottolineatura è un modello che si riferisce a un singolo valore arbitrario (che potrebbe essere esso stesso un elenco o simile). a___è un modello di sequenza (vedi anche frammento 15), che fa riferimento a una sequenza di 0 o più valori. Nota che sto usando x_due volte, il che significa che quelle due parti dell'elenco devono avere lo stesso valore. Quindi questo modello corrisponde a qualsiasi lista che contiene un valore due volte, chiama quell'elemento xe chiama le tre sequenze di tutto questi due elementi a, be c. Questo è sostituito da {a,x,b,c}- ovvero il secondo xviene eliminato.

Ora //.verrà applicata una regola fino a quando il modello non corrisponde più. Quindi lo snippet sopra rimuove tutti i duplicati da un elenco l. Tuttavia, è un po 'più potente di così: //.applica la regola a tutti i livelli. Pertanto, se lcontiene elenchi (a qualsiasi profondità), verranno rimossi anche i duplicati da tali elenchi.

Lunghezza 36 frammento

f[1]=1
f[2]=1
f[n_]:=f[n-1] + f[n-2]

È tempo di nuove funzionalità linguistiche! Mathematica ha alcune cose carine sulla definizione delle funzioni. Per cominciare, è possibile fornire più definizioni di funzioni per lo stesso nome, per numeri o tipi di argomenti diversi. È possibile utilizzare i modelli per descrivere a quali tipi di argomenti si applica una definizione. Inoltre, puoi anche aggiungere definizioni per singoli valori. Mathematica sceglierà quindi la definizione applicabile più specifica per qualsiasi chiamata di funzione e lascerà non valutate le chiamate non definite. Ciò consente (tra le altre cose) di scrivere funzioni ricorsive in un modo molto più naturale rispetto all'uso di un Ifinterruttore per il case base.

Un'altra cosa da notare sullo snippet sopra è che sto usando entrambi =e :=. La differenza è che il lato destro di =viene valutato solo una volta, al momento della definizione, mentre :=viene rivalutato ogni volta che si fa riferimento al lato sinistro. In effetti :=funziona anche quando si assegnano variabili, che avranno quindi un valore dinamico.

Quindi quanto sopra, ovviamente, è solo una funzione di Fibonacci. E molto inefficiente. Il calcolo dei primi 30 numeri richiede circa 4 secondi sulla mia macchina. Vedremo tra poco come possiamo migliorare le prestazioni senza nemmeno dover eliminare la definizione ricorsiva.

Lunghezza 35 frammento

StreamPlot[{x^2,y},{x,0,3},{y,0,3}]

Un diagramma molto pulito, che genera le linee di flusso di un campo vettoriale 2D. Questo è simile a un normale diagramma vettoriale, in quanto ogni freccia è tangente al campo vettoriale. Tuttavia, le frecce non sono posizionate su una griglia fissa ma unite in linee (le linee di flusso). Il significato di queste linee è che indicano la traiettoria di una particella (in un fluido, diciamo) se il campo vettoriale era un campo di velocità. L'input sopra appare come:

Lunghezza 34 frammento

Solve[a*x^4+b*x^3+c*x^2+d*x==0, x]

Mathematica può anche risolvere equazioni (o sistemi di equazioni, ma al momento abbiamo solo così tanti caratteri). Il risultato sarà, come al solito, simbolico.

{
  {x -> 0}, 
  {x -> -(b/(3 a)) - (2^(1/3) (-b^2 + 3 a c))/(3 a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) + (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)/(3 2^(1/3) a)}, 
  {x -> -(b/(3 a)) + ((1 + I Sqrt[3]) (-b^2 + 3 a c))/(3 2^(2/3) a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) - ((1 - I Sqrt[3]) (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3))/(6 2^(1/3) a)}, 
  {x -> -(b/(3 a)) + ((1 - I Sqrt[3]) (-b^2 + 3 a c))/(3 2^(2/3) a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) - ((1 + I Sqrt[3]) (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3))/( 6 2^(1/3) a)}
}

Tieni presente che le soluzioni sono fornite come regole , che probabilmente mostrerò più in dettaglio in alcuni frammenti futuri.

Lunghezza frammento 33

Dynamic@EdgeDetect@CurrentImage[]

Grazie a benwaffle per questa idea. CurrentImage[]carica l'immagine corrente della tua webcam. EdgeDetecttrasforma un'immagine in un'immagine in bianco e nero in cui i bordi sono bianchi e il resto è nero (vedere lo snippet 45 per un esempio). Il vero divertimento deriva dal fatto Dynamicche l'espressione si aggiorna da sola. Quindi il risultato di questo sarà effettivamente lo streaming di immagini dalla tua webcam e il rilevamento dei bordi dal vivo su di esse.

Lunghezza 32 frammento

NumberLinePlot[x^2<2^x,{x,-2,5}]

Un tipo piuttosto insolito di trama. Può tracciare un sacco di cose diverse lungo la linea numerica, come punti e intervalli. Puoi anche dargli una condizione e ti mostrerà la regione in cui quella condizione è vera:

La freccia indica che la regione continua all'infinito. I cerchi bianchi indicano che quelli sono intervalli aperti (i punti finali non fanno parte dell'intervallo). Per le estremità chiuse, i cerchi sarebbero riempiti.

Lunghezza frammento 28

Graphics3D@{Sphere[],Cone[]}

Tempo per un po 'di grafica 3D. Quanto sopra rende una sfera e un cono super-imposti con parametri predefiniti, che assomigliano a una sfera di cristallo:

In Mathematica, puoi effettivamente fare clic e trascinare questo piccolo widget per ruotarlo.

Lunghezza del frammento 27

CountryData["ITA", "Shape"]

Di più *Data! CountryDataè abbastanza pazzo. Ottenere la forma di un paese non è nemmeno la punta dell'iceberg. Ci sono così tanti dati sui paesi, probabilmente potresti scrivere un intero libro su questa funzione. Come ... c'è FemaleLiteracyFraction. È inoltre possibile eseguire query su tali dati per diversi punti nel tempo. Per un elenco completo, consultare il riferimento.

Lunghezza 26 frammento

PolarPlot[Sin[5θ],{θ,0,π}]

Tempo per una trama più interessante. PolarPlotè semplicemente un diagramma in coordinate polari. Invece di specificare y per una data x, si specifica un raggio r per un determinato angolo θ:

Lunghezza frammento 25

{{1,5},{2,3},{7,4}}.{8,9}

Finalmente abbiamo abbastanza personaggi per alcuni matematici vettoriali. Quanto sopra calcola la moltiplicazione della matrice di una matrice 2x3 e della riga 2-vettore:

{53, 43, 92}

Snippet di lunghezza 23

Rotate[Rectangle, Pi/2]

Eh. Hehe. Pensi di sapere cosa fa questo. Ma tu no. Rectangledi per sé è solo una funzione denominata. Per ottenere effettivamente un oggetto che rappresenta un rettangolo, dovresti chiamare quella funzione con alcuni parametri. Quindi cosa pensi che accada quando provi a ruotare Rectangle? Questo:

Lunghezza frammento 22

30~ElementData~"Color"

Un'altra delle *Datafunzioni integrate. Sì, per gli elementi chimici, non solo ottieni cose come il loro numero atomico, punto di fusione e nome ... puoi effettivamente ottenere il loro colore a temperatura ambiente. Quanto sopra dà il colore di zinco:

SlateGray

Lunghezza frammento 21

Integrate[E^(-x^2),x]

Abbiamo avuto differenziazione qualche tempo fa. Tempo per l'integrazione. Mathematica è in grado di gestire integrali sia definiti che indefiniti. In particolare, Integrateti fornirà una soluzione esatta e può gestire un sacco di integrali standard e tecniche di integrazione (per risultati numerici, c'è NIntegrate). Se conosci il tuo calcolo, avrai notato che l'integrale gaussiano sopra non ha effettivamente un integrale indefinito in forma chiusa ... a meno che tu non consideri la funzione di errore in forma chiusa, cioè. Mathematica restituisce:

1/2 Sqrt[π] Erf[x]

Lunghezza 20 frammento

"Sun"~StarData~"Age"

Torna ai dati integrati . Ci devono essere almeno due dozzine di *Datafunzioni per tutto ciò a cui potresti pensare. Ognuno di loro prende un identificatore per la cosa per cui desideri che i dati vengano recuperati e una proprietà (o un elenco di proprietà) da recuperare. Quanto sopra è solo uno dei più brevi si può ottenere con Sun, Stare Agetutto l'essere piuttosto breve, perché non vedevo l'ora di mostrare questa caratteristica.

Oh sì, e ho già detto che Mathematica (dal 9) supporta quantità con unità? (Ne parleremo più avanti). Quanto sopra valuta:

Quantity[4.57*10^9, "Years"]

che viene visualizzato come

Lunghezza 19 frammento

MandelbrotSetPlot[]

Sì ... funzione molto utile ... La uso sempre . (A volte, il loro desiderio di supportare tutto ciò che è probabilmente calcolabile potrebbe andare un po 'lontano ...)

A loro difesa, la funzione è un po 'più utile di così: puoi dargli una sezione particolare del grafico che vuoi tracciare.

Lunghezza 18 frammento

PetersenGraph[7,2]

Da Mathematica 8, capisce cosa sono i grafici, quindi viene fornito con ogni sorta di funzioni relative alla teoria dei grafi. E non era Mathematica se non includesse un sacco di built-in. Quanto sopra genera i dati del grafico per un grafico di Petersen generalizzato . Produce la struttura dati effettiva che può essere manipolata, ma Mathematica mostra immediatamente i dati del grafico ... graficamente:

Lunghezza frammento 17

Plot[x^x,{x,0,2}]

Finalmente abbastanza personaggi per fare qualche complotto. Quanto sopra è in realtà solo l'esempio più semplice di un diagramma unidimensionale. Prometto di sfoggiare trame più fresche in seguito

Lunghezza frammento 15

{##4,#,#2,#3}&

Questo mostra due delle funzionalità più potenti (e anche utili per il golf). L'intera cosa è una funzione pura senza nome , paragonabile a lambdas in Python o Procs in Ruby. Le funzioni pure sono semplicemente terminate da a &. Questo operatore ha una precedenza molto bassa, quindi di solito include quasi tutto ciò che ne rimane. Si fa riferimento agli argomenti di una funzione pura #, a volte seguiti da altre cose. Il primo argomento è #o #1, il secondo è #2e così via.

L'altra caratteristica è Sequences. Questi sono fondamentalmente come simboli in altre lingue. Una sequenza è come una lista senza la lista attorno ad essa - è letteralmente solo una sequenza di valori, che può essere usata in liste, argomenti di funzioni ecc. ##In particolare è una sequenza di tutti gli argomenti di pura funzione. ##2è una sequenza di tutti gli argomenti a partire dalla seconda. Quindi, se abbiamo chiamato la funzione sopra fe la abbiamo chiamata come

f[1,2,3,4,5]

Vorremmo

{4,5,1,2,3}

quindi la funzione ruota gli argomenti di input di 3 elementi a sinistra. Si noti che ##4a 4,5cui si fa riferimento sono stati appiattiti nell'elenco.

Lunghezza 12 frammento

D[x^y^x,x,y]

Differenziazione parziale. Ddifferenzierà la prima espressione in successione rispetto agli altri argomenti, dandoti come risultato un'espressione simbolica. Quindi quanto sopra è d² (x ^ y ^ x) / dxdy (dove i d sono parziali), che Mathematica riferisce di essere

x^y^x (y^(-1 + x) + y^(-1 + x) Log[x] + x y^(-1 + x) Log[x] Log[y]) + 
  x^(1 + y^x) y^(-1 + x) Log[x] (y^x/x + y^x Log[x] Log[y])

Lunghezza frammento 9

Exp[I*Pi]

Non abbiamo ancora fatto nessuna complessa aritmetica! Come puoi vedere, in πrealtà era solo un alias per Pi. Ad ogni modo, quanto sopra restituirà effettivamente il numero intero -1 .

Lunghezza 8 frammento

Sunset[]

Si. Parla di folli built-in. Senza parametri che in realtà ti danno un oggetto datetime del prossimo tramonto nella posizione corrente. Prende anche parametri per altre date, altre posizioni, ecc. Ecco come si presenta in questo momento:

Lunghezza frammento 7

9!/43!!

Questo frammento mostra alcune cose interessanti.

Mathematica non ha solo un operatore fattoriale incorporato !, ma ha anche un doppio fattoriale !!(che moltiplica ogni altro numero da ngiù a 1). Inoltre, supporta numeri interi di precisione arbitraria. Il valore 43!!verrà valutato esattamente, fino all'ultima cifra. Inoltre, anche i numeri razionali saranno valutati esattamente. Quindi, poiché sia ​​il numeratore che il denominatore all'interno sono numeri interi, Mathematica ridurrà il più possibile le frazioni e quindi ti presenterà

128/198893132162463319205625

Ovviamente, puoi usare i float quando vuoi, ma in generale, se il tuo input non contiene float, il risultato sarà esatto.

Lunghezza 4 frammento

Here

È giunto il momento di iniziare con la ricchezza di folli incorporati di Mathematica. Quanto sopra fa quello che dice sulla scatola e (per me) valuta GeoPosition[{51.51, -0.09}].

Lunghezza frammento 3

x-x

Giusto per mostrare il Factoid originale : quanto sopra funziona anche se xnon è stato ancora definito e si tradurrà effettivamente 0in quel caso.

Lunghezza 2 frammento

3x

Moltiplicazione tramite giustapposizione! Se è chiaro che un identificatore termina e ne inizia un altro, non è necessario uno *spazio bianco o addirittura per moltiplicarli insieme. Funziona praticamente con tutto, comprese stringhe e variabili che non hanno ancora valori. Molto comodo per giocare a golf. ;)

Lunghezza 1 frammento

π

Indovina un po ', sono Pi. E in effetti, non è una rappresentazione approssimativa in virgola mobile, è esattamente Pi - quindi tutti i tipi di funzioni complesse e trigonometriche in cui viene utilizzato produrranno risultati esatti se noti.

factoid

Mathematica può eseguire manipolazioni simboliche, quindi le variabili non hanno bisogno di valori per lavorare con esse.

Il famigerato linguaggio di programmazione di Shakespeare

Shakespeare Programming Language è stato creato nel 2001 da due studenti svedesi, Karl Hasselström e Jon Åslund, e combina, come proclamano gli autori ,

l'espressività di BASIC con la facilità d'uso del linguaggio assembly.

Le risposte vanno dall'alto verso il basso. Inoltre, è comune vedermi riferirsi a frammenti precedenti o precedenti.

( link per me stesso: modifica )

factoid:

Il codice di Shakespeare ricorda, come ci si aspetterebbe, un gioco di Shakespeare, in cui le variabili sono personaggi del gioco e il loro valore cambia quando vengono "insultati" o elogiati ".

Lunghezza frammento 1:

I

Il codice di Shakespeare è diviso in Atti, e gli atti sono essi stessi divisi in Scene, per causalità "da saltare a". Definire un atto Act Isignifica che sarà il primo pezzo del codice da eseguire, per esempio, ma non solo.

Snippet di lunghezza 2:

as

Utilizzato in un confronto tra due "caratteri".

Snippet di lunghezza 3:

day

Ormai, potresti avere la sensazione che SPL sia molto prolisso. E strano. E non hai ancora visto niente. day, in SPL, è 1. Vengono considerati tutti i nomi "positivi" e "neutri" 1, così come tutti quelli "negativi" -1.

Snippet di lunghezza 4:

rich

Che cosa è rich? Un aggettivo. In SPL, gli aggettivi fanno moltiplicare per due il valore del nome a cui sono associati. Vedi l'implementazione sullo snippet 14.

Snippet di lunghezza 5:

Act I

Implementazione del primo frammento. A tutti gli atti può essere assegnato un titolo, ad esempio Act I: Hamlet must die!, poiché tutto ciò che segue il numero romano viene ignorato dal parser.

Snippet di lunghezza 6:

better

Ogni lingua ha condizioni e SPL non fa eccezione. Ad eccezione del fatto che questo è un linguaggio con una sintassi lunga (e l'ho già detto strano?), Le sue dichiarazioni condizionali saranno lunghe. Chiedere a Ofelia Juliet Am I better than you?è come avere la if (Ophelia > Juliet)maggior parte delle lingue "normali". E, naturalmente, puoi chiedere il contrario: Am I not better than you?è l'equivalente di if (Ophelia < Juliet). E puoi già indovinare come =viene tradotto in SPL: as good as- utilizzo dello snippet di codice 2.

Tuttavia, good/betternon è l'unico modo per fare confronti in questa lingua shakesperiana, puoi usare qualsiasi aggettivo. Lo stesso principio dello snippet 3 si applica anche qui, con aggettivi "positivi" che hanno il valore >, mentre quelli "negativi" significano <.

Lunghezza frammento 7:

Juliet:

Questa è l'invocazione di una variabile; dopo questo, le sue istruzioni / dichiarazioni / qualunque cosa seguiranno.

Una limitazione di SPL è che ha un numero limitato di variabili: Romeo, Giulietta, Amleto, Ofelia, MacBeth e così via sono alcuni esempi di "personaggi" che appariranno in un programma shakesperiano.

Lunghezza frammento 8:

[Exeunt]

[Exeunt]viene posizionato quando tutti i "personaggi" escono dallo "stage". Spero di poter approfondire un po 'più avanti l'interazione tra i personaggi. Generalmente è l'ultima istruzione di qualsiasi programma SPL, sebbene [Exeunt]non sia specificamente il "carattere" terminale della lingua. Per un altro esempio, vedi lo snippet 27.

Snippet di lunghezza 9:

as bad as

Nove personaggi solo per rappresentare un semplice =- usando lo snippet 2. Ho già detto che SPL è strano? Vedi lo snippet 30 per esempi. (e sì, c'è più di un modo per produrlo)

Snippet di lunghezza 10:

difference

Un modo elegante di rappresentare -, una sottrazione. Puoi eseguire operazioni matematiche su SPL, anche se probabilmente avrai bisogno di un'intera giornata per farlo bene.

Factoid (dato che sono riuscito in qualche modo a raggiungere dieci frammenti di codice, facciamo una pausa e facciamo un altro factoid su SPL)

Se vuoi eseguire il tuo codice shakesperiano in tutto il suo splendore, c'è questo sito - lo sto ancora testando, dal momento che l'ho scoperto nemmeno cinque minuti fa. C'è anche un modo per tradurlo in C usando un traduttore .

Un altro sito per l'esecuzione del codice SPL è questo che funziona traducendo internamente il codice SPL in un altro linguaggio esoterico: Oracle PL / SQL.

Lunghezza frammento 11:

[Exit Romeo]

Sì! Finalmente posso parlare dell'interazione tra i personaggi! Per cambiare il suo valore o interagire con gli altri, un "personaggio" deve essere sul palco - entrare con [Enter Romeo]. Se un personaggio è indirizzato ma non è presente, c'è un errore di runtime e il programma si arresta. Perché, in SPL, il valore delle variabili è impostato dalla quantità di nomi con cui sono elogiati - o insultati - dagli altri personaggi sul palco. Sento che dovrei fare un esempio per chiarire un po 'di confusione che la mia spiegazione zoppa può creare, ma forse è meglio ritardare qualche frammento.

Lunghezza frammento 12:

Remember me.

SPL è piuttosto "semplice", va bene - ma ha pile! Quando, per esempio, Romeo dice a Juliet di "ricordarlo", in realtà sta dicendo alla sua amata di spingere il valore di Romeo nel suo stack. Interrompere il valore viene fatto con Recall your happy childhood!, o, o Recall your love for me, fondamentalmente, qualsiasi frase che inizia con Recall- il resto è solo una svolta artistica, come lo snippet 22.

Lunghezza 13 frammento

Let us return

Il modo shakesperiano di avere un goto. Ed è qui che gli Atti e le Scene sono utili. Se Romeo lo dice a Juliet we shall return to Act II(sì, ancora, ci sono molti modi per scriverlo), il programma passerà a quella parte specifica del codice. È anche visto accanto a dichiarazioni condizionali.

Lunghezza frammento 14

my little pony

Sì, era una serie negli anni '80. Ecco qui 2*1. Perché? Perché a ponyè un nome (in qualche modo) positivo ed littleè un aggettivo. Quindi, ricordando i frammenti 3 e 4, abbiamo little = "2 *"e pony = "1".

Lunghezza frammento 15

Speak thy mind!

In un programma SPL, vedrai questo (o Speak your mind!, che è lo stesso) molto . Questo in pratica genera il valore di ciascun "carattere" in cifre, lettere o quant'altro, a seconda del set di caratteri utilizzato dal computer. C'è anche Open your mind.quello che fa quasi la stessa cosa, anche se emette solo in forma numerica.

Lunghezza 16 frammento

You are nothing!

Quando qualcuno ti dice questo nella vita reale, ti sentirai depresso. Quando Ofelia lo dice ad Amleto nella programmazione shakespeariana, Amleto si sente senza valore. Cosa significa questo? Quello Hamlet = 0.

Lunghezza frammento 17

Ophelia, a wench.

In una sceneggiatura, prima che inizi la riproduzione effettiva, i personaggi devono essere presentati. Nella maggior parte dei linguaggi di programmazione, anche le variabili devono essere dichiarate prima dell'uso. Visto che SPL è un linguaggio di programmazione che ricorda una sceneggiatura, ecco come dichiarare le sue variabili, affermando quali sono quelle che appaiono durante il programma.

Ma cosa significa "una donna"? Significa che è un nome di tipo di dati specifico (e interessante)? Beh ... odio deluderti, ma non significa nulla: tutto dopo la virgola viene ignorato dal parser, il che significa che puoi mettere lì la dritta più oltraggiosa che ti viene in mente.

Lunghezza 18 frammento

lying sorry coward

-4per tutte le creature terrene. Perché? A causa 2*2*(-1) = -4.

Lunghezza 19 frammento

Romeo:
 Remember me.

Alla fine!!! Posso finalmente emettere un'istruzione di sintassi completamente corretta (anche se breve)! È così che usi lo snippet 12: prima dichiari chi sta parlando, poi nella riga successiva scrivi il "dialogo". Normalmente, solo due "personaggi" sono sul palco, per evitare di rendere il parser triste e confuso. Quando hai bisogno di un altro "personaggio", ne prendi uno dal palco e lo sostituisci con quello nuovo.

Lunghezza 20 frammento

cube of thy codpiece

Volevo elaborare un po 'di più per questo, ma, a dire la verità, le cose che mi vengono in mente sono ancora troppo brevi per questo frammento. E quindi ti porto questo, che finisce per essere -1- perché (-1) ³ = -1 (ed codpieceè un sostantivo "negativo", dato che sono scomodi e tutti). SPL capisce alcune operazioni aritmetiche più elaborati come un po ' elevamento a potenza e radici quadrate.

Factoid (ancora un altro, dal momento che abbiamo raggiunto un altro traguardo)

Il "Hello World Program" di Shakesperian ha 89 righe e più di 2400 caratteri, come mostrato qui .

Lunghezza frammento 21

Listen to your heart.

Nel frammento 15 hai emesso qualcosa; qui, inserisci un numero per il programma. Se vuoi inserire un personaggio, userai Open your mind.invece. E, inutile dirlo, questo valore verrà memorizzato nel "personaggio" con cui si parla.

Lunghezza frammento 22

Recall your childhood!

Con questo, l'interruzione di un numero intero da uno stack viene eseguita, come spiegato nello snippet 12. Quando, per esempio, Ofelia dice ad Amleto la frase sopra menzionata, fa sì che Amleto prenda un numero intero dal suo stack e assuma quel valore.

Ovviamente, finché la parola recallinizia la frase, puoi riempire il resto con qualsiasi cosa desideri la tua mente shakesperiana creativa.

Snippet di lunghezza 23

Are you better than me?

Implementazione dello snippet 6. Quando un "personaggio" pone una domanda del genere a un altro, ciò che sta facendo equivale a if (x > y)linguaggi di programmazione più comuni. Il seguito di queste istruzioni deve essere ritardato fino a quando non avrò più caratteri disponibili.

Lunghezza 24 frammento

[Enter Romeo and Juliet]

Sì, i "caratteri" possono entrare in coppia. Non è necessario che un "personaggio" entri nel palco, seguito da un altro.

Lunghezza frammento 25

remainder of the quotient

25 caratteri solo per scrivere a %. 25 personaggi per avere il resto di una divisione. E usarlo? Bene, questo è ancora più grande - vedi frammento 75.

Lunghezza 26 frammento

Let us return to scene II.

Eccolo, a gotoin SPL, che funziona come ci si aspetterebbe in un linguaggio di programmazione. Una cosa è: puoi saltare tra le scene nello stesso atto e tra gli atti; ma non puoi saltare tra le scene in diversi atti.

Lunghezza del frammento 27

[Exeunt Ophelia and Hamlet]

Quando più di un "personaggio" lascia il palco, invece di Exit, e mantenendo la tradizione con la natura teatrale di SPL, viene usata la parola latina "Exeunt". A volte può essere sostituito solo dallo snippet 8.

Lunghezza frammento 28

Scene I: Ophelia's flattery.

Dichiarare una scena. Come puoi già aspettarti se hai affrontato me, l'importante è il Scene I, il resto è lanugine artistica.

Sono stati realizzati alcuni compilatori (come questo che compila da SPL a C, scritti in Python ) che invece si riferiscono al testo dopo la numerazione dell'Atto / della Scena. Mentre più logico (dopo tutto, durante una commedia, con i personaggi che dicono linee come "torniamo all'Atto I" può essere considerato sciocco), mi sto attenendo al modo originale.

Lunghezza frammento 29

You pretty little warm thing!

Sì, un'altra costante (dal momento che abbiamo bisogno di più personaggi per eseguire operazioni aritmetiche). Questo è uguale a 8, perché 2*2*2*1 = 8.

Lunghezza 30 frammento

You are as cowardly as Hamlet!

Dire questo, ad esempio, a Romeo, significa che Romeo = Hamlet. Come lo snippet 9.

Factoid (sì, un altro punto di riferimento raggiunto!)

Questo linguaggio è stato creato per un incarico in un corso di analisi della sintassi, pertanto gli autori non hanno creato alcun compilatore SPL. Inoltre: sembra che gli autori di SPL abbiano reciso i loro legami con la loro creazione, dal momento che nulla sembra essere stato modificato nella lingua dal 2001 ...

Lunghezza frammento 31

Am I as horrid as a flirt-gill?

Sì, lo so, è un po 'ripetendo lo snippet 23, sebbene, qui, stiamo confrontando il "personaggio" che parla con un "flirt-gill" (di, se preferisci, if (Ophelia == -1)). La cosa è...

Lunghezza 32 frammento

If so, let us return to scene I.

... ora posso presentare thenSPL, il condizionale jump-to e il modo shakesperiano di implementare i loop. Ad esempio, puoi fare in modo che Romeo assuma il valore 0, aumenti il ​​suo valore mentre fa qualche altra attività e si ferma quando raggiunge i 10, procedendo successivamente con il programma.

Lunghezza frammento 33

If not, let us return to scene I.

Solo un promemoria che, invece, possiamo invece procedere ad un'altra scena se la condizione per cui abbiamo testato è falsa .

Lunghezza 34 frammento

Open your mind! Remember yourself.

Due istruzioni di fila, yippie! Il primo legge un personaggio, il secondo lo inserisce nello stack di memoria dell'altro personaggio.

Lunghezza 35 frammento

Act I: Death!

Scene I: Oh, shit.

Il modo corretto di dichiarare un atto e una scena. Aggiungi poltiglia artistica con gusto.

Lunghezza 36 frammento

Thou art as sweet as a summer's day!

Un altro modo di dire che il "personaggio" con cui viene parlato riceverà il valore 1, perché le giornate estive sono piacevoli e piacevoli.

Lunghezza 37 frammento

Art thou more cunning than the Ghost?

Ophelia questa domanda ai mezzi Hamlet, traducendo questo per un linguaggio di programmazione meno leggibile, if (Hamlet > the Ghost). È di nuovo lo snippet 23, sì - ma ti mostra che non è necessario chiedere ai "personaggi" se sono migliori l'uno dell'altro: anche qualsiasi altra domanda funzionerà.

Lunghezza 38 frammento

[Enter the Ghost, Romeo and the Ghost]

Sì, sto chiamando un "personaggio" due volte, perché volevo che il programma mi desse un errore. Chiamare un "personaggio" che è già sul palco, o dire a uno che è assente di uscire, causerà un grande dolore al parser / compilatore.

Lunghezza 39 frammento

the sum of a fat lazy pig and yourself!

L'istruzione completa ha un aspetto migliore di questo, te lo darò, ma ... ecco la nostra prima operazione aritmetica! Cosa significa tutto, in realtà? Bene, pigè un animale sporco (anche se gustoso), quindi equivale a -1, ha due aggettivi, che significa fat lazy piguguale 2*2*(-1) = -4. Ma che dire yourself? È un pronome riflessivo, non un nome né un aggettivo. Bene, ricorda che SPL si basa su dialoghi tra "personaggi"; quindi, si yourselfriferisce all'altro "personaggio" sul palco. Quindi, arriviamo alla fine e scopriamo che "la somma di un grasso maiale pigro e te stesso" è, in realtà -4 + x,.

Lunghezza 40 frammento

the sum of a squirrel and a white horse.

Sì, un'altra somma, ma questa è più semplice dello snippet 39. Questo è semplicemente 1 + 2- 3, se la mia matematica è corretta.

Factoid (ancora con me dopo questi quaranta frammenti di lanugine artistica? Ti meriti un premio.)

SPL, nella sua versione 1.2.1, può essere scaricato qui .

Lunghezza del frammento 41

Juliet:
 Speak thy mind!

[Exit Romeo]

A volte, i "personaggi" vengono chiamati sul palco solo per cambiare il loro valore - che, in una vera commedia, sarebbe qualcosa di piuttosto bizzarro. Comunque, qui, Juliet fa stampare alla sua amata Romeo il suo valore memorizzato, dopo di che esce dal palco.

Lunghezza 42 frammento

Speak YOUR mind! You are as bad as Hamlet!

Ancora una volta due istruzioni in una riga (possiamo avere più, ma la lunghezza del frammento non lo consente ancora); qui abbiamo un "personaggio" che dice a un altro di produrre il suo valore e assumere qualunque valore abbia Amleto. Confondere? Mayhap.

Lunghezza 43 frammento

Am I as horrid as a half-witted flirt-gill?

Giulietta che chiede questo non significa che abbia poca stima (anche se potrebbe accadere nella vita reale); è semplicemente un altro if, come i frammenti 23 e 37. Oh, quasi dimenticavo: questo si traduce in if (Juliet == -2).

Lunghezza 44 frammento

You are as evil as the square root of Romeo!

Sì, le radici quadrate sono cattive, non lo sapevi? Ad ogni modo, questa istruzione è abbastanza semplice da capire cosa fa: attribuisce il "carattere" che viene pronunciato al valore della radice quadrata del valore memorizzato in Romeo.

Lunghezza frammento 45

Hamlet:
 Art thou more cunning than the Ghost?

Snippet 37 correttamente scritto con il personaggio che sta parlando la linea.

Lunghezza 46 frammento

the product of a rural town and my rich purse.

Va bene ... comunque, SPL potrebbe essere l'unica lingua al mondo che ti consente di moltiplicare le città con le borse. Ciò significa (2*1)*(2*1)che, se non sbaglio, è uguale a 4.

Lunghezza frammento 47

Romeo:
 Speak your mind.

Juliet:
 Speak YOUR mind!

Ti do questo: potrebbe essere uno dei dialoghi più bizzarri della storia. Ma è quello che ottieni quando scegli una strana lingua da mostrare. Romeo e Giulietta si dicono l'un l'altro, in breve, di esprimere i loro valori.

Lunghezza frammento 48

You lying fatherless useless half-witted coward!

Traducendo direttamente, 2*2*2*2*(-1). -16, giusto?

Lunghezza frammento 49

Scene V: Closure.

Hamlet:
 Speak your mind!

[Exeunt]

Un esempio di come terminare un programma in SPL. Puoi dichiarare una scena appositamente per essa (anche se non è richiesta), quindi Amleto chiede a un altro "personaggio" di emetterne il valore, quindi tutti escono dal palco. E sì, è necessario che tutti scendano dal palco.

Lunghezza frammento 50

Othello, a young squire.
Lady Macbeth, an old fart.

Più presentazione "carattere", prima delle istruzioni adeguate. Come sempre, l'unica cosa che conta per il compilatore è Othelloe Lady Macbeth, quindi il resto della linea è in palio ...

Ancora una cosa: i "personaggi" non devono essere collegati tra loro per apparire in un programma SPL - quindi puoi avere Romeo, Otello e Amleto nella stessa commedia.

Factoid (mezzo secolo di queste cose? Accidenti! Dopo questo penso che odierò William Shakespeare ...)

Il traduttore da SPL a C, menzionato qualche tempo fa e sviluppato dai creatori di SPL, era basato su Flex e Bison .

Snippet di lunghezza 51

Othello:
 Recall your great dreams. Speak your mind!

(Così stufo di Romeo, Giulietta e Amleto ... portiamo Otello, per cambiare!)

Recall, come puoi immaginare, è la chiave qui. Il "personaggio" che Otello sta affrontando prenderà un valore dal suo stack, assumerà quel valore e, successivamente, lo produrrà.

Lunghezza frammento 52

Thou art as pretty as the sum of thyself and my dog!

Un'altra somma. Sbadiglio. Supponendo che questo sia indirizzato ad Amleto, significa che Hamlet = Hamlet + 1. Or Hamlet += 1. Or Hamlet++.

Snippet di lunghezza 53

Romeo:
 You are as vile as the sum of me and yourself!

Ah, sì, qualcosa che ho dimenticato di menzionare prima: i "personaggi" parlanti possono menzionarsi sulla propria linea.

Lunghezza 54 frammento

Juliet:
 Is the sum of Romeo and me as good as nothing?

Un altro esempio dello snippet precedente, incluso in una condizione. Quindi quello che abbiamo qui è if (Romeo + Juliet == 0).

Lunghezza frammento 55

Juliet:
 You are as lovely as the sweetest reddest rose.

Quindi, qui, Juliet sta lodando il "personaggio" con cui sta parlando (supponiamo che sia Romeo, per l'amor di Shakespeare), dichiarando che lui / lei è 4. Sì, un'altra assegnazione di valori.

Lunghezza 56 frammento

Othello:
 You lying fatherless useless half-witted coward!

Snippet 48 correttamente eseguito, con un "personaggio". Se sei troppo pigro per scorrere verso l'alto (come sarei io), questo significa che quello che viene insultato riceve il valore -16.

Lunghezza 57 frammento

Romeo:
 If not, let us return to Act I. Recall thy riches!

Ho già spiegato come funzionano le condizioni su SPL su base generale; tuttavia, è necessaria un'analisi più approfondita. Non abbiamo elsequi: per esempio, in questo esempio, se la condizione non fosse riuscita, il programma tornerebbe all'Atto I; ma se fosse vero, continuerebbe con l'istruzione successiva, che è un Recall- un pop dallo stack, cioè.

Lunghezza frammento 58

Romeo:
 You are as disgusting as the square root of Juliet!

Afferrare lo snippet 44 e presentare come devono essere presentate le istruzioni. Se questo fosse un dialogo tra Romeo e Otello, allora potremmo tradurlo in Java come Othello = Math.sqrt(Juliet).

Lunghezza 59 frammento

Othello:
 You are as vile as the sum of yourself and a toad!

OK, se Otello stesse parlando con Romeo, ciò equivarrebbe a Romeo+(-1); Romeo--, in breve. Abbastanza semplice, vero? Questo è SPL per te.

Lunghezza 60 frammento

Is the quotient between the Ghost and me as good as nothing?

In breve, if (The Ghost/Hamlet == 0)supponendo che l'io appartenga ad Amleto.

Lunghezza frammento 61

Thou art as handsome as the sum of yourself and my chihuahua!

Dopo aver rimosso gli strati e gli strati di parole e insulti, noti che SPL è praticamente una cosa di base, senza funzioni e cose interessanti. Quindi abbiamo un sacco di funzioni aritmetiche sul corpo del programma. Quindi, se questo fosse indirizzato a Giulietta, sarebbe equivalente a Juliet++.

Lunghezza frammento 62

twice the difference between a mistletoe and a oozing blister!

Sì, sì, più operazioni aritmetiche. All'incirca, questi 62 byte di SPL possono essere tradotti in 2*(1-2*(-1)). Sarebbe un linguaggio da golf davvero fantastico, vero? Giusto.

Lunghezza frammento 63

You lying stupid fatherless rotten stinking half-witted coward!

Snippet 48 emesso -16, questo è pari a -64: 2*2*2*2*2*2*(-1).

Lunghezza 64 frammento

your coward sorry little stuffed misused dusty oozing rotten sky

Da quello che ho capito di SPL, questo è perfettamente legittimo. Hai un sacco di aggettivi offensivi che procede un nome "positivo". Dal momento che gli aggettivi non hanno alcuna distinzione speciale se sono negativi o meno (il loro unico valore è moltiplicare il numero alla loro destra per due), possiamo avere frasi completamente stupide come questa. Ciò equivale a 256. Perché 2*2*2*2*2*2*2*2*1=256.

Lunghezza frammento 65

You are nothing! You are as vile as the sum of thyself and a pig.

Hmm, così tanto odio, vero? Quindi, ciò che abbiamo qui è equivalente a y=0; y=y+(-1);Probabilmente avrebbe potuto essere "giocato a golf" You are a pig!, ma eh.

Lunghezza frammento 66

You are as beautiful as the difference between Juliet and thyself.

Quindi, sottrarre Juliet da te stesso, eh? Questo è abbastanza semplice da decodificare: Romeo=Juliet-Romeo;supponendo che si tratti di Romeo.

Lunghezza 67 frammento

Juliet:
 Am I better than you?

Romeo:
 If so, let us proceed to Act V.

Come funzionano la maggior parte delle condizioni su SPL. Provi l'espressione e, se è vero (o no: vedi snippet 33), salti a un'altra parte del programma; altrimenti, passerai alla frase successiva.

Lunghezza frammento 68

The Ghost:
 You are as small as the sum of yourself and a stone wall!

Sì, sì, sto diventando un po 'monotono. Ma SPL è così. Come ho affermato un po 'prima, le sue espressioni sono un misto di operazioni aritmetiche. Quindi, questo è ancora un altro incremento - poiché stone wallè un "nome" neutrale.

Snippet di lunghezza 69

Thou art as disgusting as the difference between Othello and thyself!

Invece di una somma, abbiamo la sottrazione tra due personaggi, Otello e chiunque si parli.

Lunghezza frammento 70

You are as handsome as the sum of Romeo and his black lazy squirrel!

Torniamo alle aggiunte, sì - chiamami formulaico, eh. Lo traduciamo in Romeo + 2*2*1.

Lunghezza frammento 71

Scene I: Dialogues.

[Enter Juliet]

Othello:
 Speak your mind!

[Exit Juliet]

Una scena può essere piccola come questa. Julietentra sul palco, Otello le dice di produrre il suo valore memorizzato, quindi scende di nuovo dal palco.

Lunghezza 72 frammento

twice the difference between a mistletoe and an oozing infected blister!

Un'altra operazione aritmetica - perché SPL è pieno di loro. Possiamo tradurre questo in 2*(1-2*2*(-1)).

Snippet di lunghezza 73

You are nothing! Remember me. Recall your unhappy story! Speak your mind!

Quattro istruzioni di fila ?! Sono abbastanza orgoglioso di me stesso, in realtà. Comunque, supponiamo che questo sia un dialogo tra Romeo e Giulietta (e sta parlando): questo significa che il valore di Giulietta inizia da 0; quindi, Juliet spingerà il valore di Romeo nella sua memoria, lo aprirà e lo produrrà nella sua forma inserita. Semplice vero?

Lunghezza frammento 74

You are as sweet as the sum of the sum of Romeo and his horse and his cat!

Sì, sì, esempio noioso, lo so. Ma questo è X = (Romeo + 1) + 1.

Lunghezza frammento 75

Is the remainder of the quotient between Othello and me as good as nothing?

Bene, questo è piuttosto semplice. Se le tue abilità di decodifica non funzionano correttamente, si traduce in if (Othello % X == 0).

Lunghezza 76 frammento

Thou art as rich as the sum of thyself and my dog! Let us return to scene I.

Il salto dallo snippet 26 con un'espressione prima di esso. A gotosu SPL non si trova sempre vicino a una condizione, può essere così - e, naturalmente, questo tipo di gotosarà sempre trovato alla fine di un atto o di una scena, poiché le istruzioni dopo non verranno mai compilate / eseguite. La prima istruzione è piuttosto semplice: x=x+1.

Lunghezza 77 frammento

[Exit Hamlet]

[Enter Romeo]

Juliet:
 Open your heart.

[Exit Juliet]

[Enter Hamlet]

Quindi, abbiamo Juliet e Amleto sul palco; ma abbiamo bisogno del valore di Romeo. Quindi, al fine di risparmiare il compilatore da un brutto mal di testa, in primo luogo rimuoviamo Amleto dal palcoscenico (anche se potrebbe essere stato Juliet a salire), diciamo a Romeo di salire sul palco, Juliet gli dà un'istruzione per produrre un numero (vedi la spiegazione dello snippet 21), poi Romeo esce dal palco e Amleto ritorna. Abbastanza semplice e diretto.

Lunghezza frammento 78

The Ghost:
 Speak thy mind.

Lady Macbeth:
 Listen to thy heart! Remember thyself.

Quindi, The Ghost (il defunto padre di Amleto) sta dicendo a Lady Macbeth di produrre il suo valore, mentre ordina a The Ghost di leggere un numero e inserirlo nel suo stack.

Piet

factoid

Piet è un linguaggio di programmazione in cui il codice sorgente è costituito da immagini. Il flusso del programma inizia con il pixel in alto a sinistra e si sposta attorno all'immagine tra pixel e gruppi di pixel fino al termine.

Per leggibilità, i programmi Piet sono comunemente visualizzati in una versione ingrandita. In tal caso, il termine codelviene utilizzato per descrivere un gruppo di pixel dello stesso colore che corrispondono a un singolo pixel nell'immagine di origine.

Per questa sfida, poiché Piet non utilizza i caratteri, verrà utilizzato un codice per voto per i programmi di esempio.

1 Codel

Questo è un programma valido, non fa nulla e termina. Il flusso di controllo inizia nel pixel in alto a sinistra (solo) e non ha via d'uscita, il che termina il programma.

In questo caso il pixel può essere di qualsiasi colore per lo stesso effetto.

2 codici

Questo leggerà continuamente i caratteri da stdin e manterrà un totale parziale dei loro valori unicode (anche se non viene fatto nulla con questo totale e non viene visualizzato).

Il flusso di Progam si muove avanti e indietro tra i 2 codici, poiché l'unica via di uscita da ciascuno è nell'altra. I comandi nel piet vengono eseguiti dal movimento da un codice o regione in un altro, a seconda della differenza di tonalità e leggerezza delle 2 regioni. Il inputè il comando lo spostamento a destra da sinistra a e poi la addè da destra a sinistra. Al primo addcomando, non accadrà nulla poiché nello stack è presente un solo valore e la specifica dice che i comandi senza valori sufficienti disponibili vengono ignorati.

Questo programma è un ciclo che non finirà mai, poiché la maggior parte dei programmi piet avrà dimensioni estremamente ridotte, dal momento che ci vogliono almeno alcuni codici per "intercettare" correttamente il flusso del programma e terminarlo.

3 codici

Questo è un programma base di tipo eco, leggerà un carattere alla volta da stdin e lo stamperà su stdout.

Ancora una volta questo è un ciclo infinito. Il programma inizia viaggiando da sinistra a destra, il che fa inputpoi output. Il programma continuerà a fluire nella stessa direzione ogni volta che può. Al codice verde chiaro l'unica uscita è iniziare a tornare indietro nell'altro modo. Quando si viaggia da destra a sinistra, tenta di eseguire subtracte addcomandi, ma lo stack è vuoto, quindi diventano non operativi.

4 codici

Stampa da 2 a stdout a tempo indeterminato.

Funzionalmente non è un programma particolarmente interessante, ma ora che finalmente abbiamo un numero composto di codici possiamo mostrare un flusso leggermente più avanzato rispetto a sinistra-destra. Quando il flusso del programma tenta di uscire da un codice, prova prima la direzione corrente. Se non è in grado (in questo caso a causa del bordo dell'immagine) ruota di 90 gradi in senso orario e tenta di uscire di nuovo. In questo caso, il programma gira in senso orario 1 codice alla volta, inserendo push1 nello stack due volte, inserendo addquelli insieme, quindi outputil risultato.

5 codici

Legge ripetutamente un carattere alla volta dallo stdin e tiene traccia della somma dei loro valori unicode.

Questa è essenzialmente la stessa funzionalità della versione 2-codel, ma questa sfida è mostrare il linguaggio e una delle cose più belle di Piet è come puoi avere immagini di aspetto diverso che fanno la stessa cosa.

Qui vediamo per la prima volta il codice bianco, che consente al flusso del programma di scorrere attraverso di esso senza eseguire le istruzioni. I codici magenta e blu fanno tutto il lavoro qui. Viaggiare dal blu al rosso non fa nulla perché attraversa il codice bianco nel mezzo. I 2 rossi solo pushil numero 1 sulla pila e popindietreggiano mentre viaggia da sinistra a destra, poi da destra a sinistra attraverso di loro, quindi attraverso il codice bianco, quindi non viene eseguita alcuna istruzione.

6 codici

Ancora una volta, ripetendo le funzionalità precedenti con un aspetto diverso. Questo è un altro programma di eco che legge un personaggio alla volta da stdin a stdout.

Qui vediamo il nostro primo codel nero. Il flusso del programma non può inserire un codice nero, quindi dal codice magenta chiaro in alto a destra il programma non si chiuderà a destra a causa del bordo dell'immagine, non riuscirà a uscire in basso a causa del codice nero e rimbalzerà a sinistra nel codice rosso . I codici blu e verde sono puramente decorativi, il programma non li inserirà mai.

7 codici

Ancora un altro programma di eco con un aspetto diverso.

Qui vediamo i nostri primi blocchi di codice più grandi della dimensione 1. Nel piet, qualsiasi blocco contiguo di codici dello stesso colore viene trattato come un singolo blocco. La dimensione del blocco non ha importanza se non quando si esegue l' pushistruzione, quindi questo programma viene trattato esattamente come la versione a 3 codici, tranne che con colori diversi.

8 codici

Legge un numero da stdin e invia il quadrato a stdout, ripetutamente.

Il flusso di controllo è un modello di base in senso orario, proprio come nel programma a 4 codici. Partendo dall'alto a sinistra, le operazioni in ordine sono input, duplicate(spinge una copia in più del valore superiore dello stack sulla pila), multiply, output. Quindi è pushil valore 1 nella pila, scorre attraverso il bianco in modo che non venga eseguito alcun comando, quindi si popallontana da quella pila quando si sposta dal codice in basso a sinistra a in alto a sinistra. Questo lo riporta all'inizio del programma con uno stack vuoto e si ripete.

9 codici

Aggiunge 1 + 2 = 3, quindi termina.

Ora che abbiamo un programma con più di 2 codici in entrambe le dimensioni, possiamo finalmente impostare una regione che intrappolerà il programma e lo terminerà invece di eseguire il ciclo per sempre. La prima operazione che si sposta dal codice rosso alla regione rosso scuro è una pushdi 1, quindi il programma ruota e scorre verso il basso nel codice rosso chiaro al centro ed è pushun valore di 2. Esegue il flusso dal rosso chiaro al giallo chiaro addun'operazione. La barra gialla chiara in basso fa terminare il programma poiché non è possibile che fuoriesca poiché tutti gli angoli sono bloccati.

I programmi 1 e 2 stanno rapidamente diventando brutti e poco interessanti, quindi da questo punto in poi mi concentrerò su numeri che consentono almeno alcuni codici in ciascuna direzione.

12 codici

Finalmente un programma che fa qualcosa che potrebbe essere considerato utile (anche se è ancora un po 'lungo). Legge 2 numeri dallo stdin in sequenza, quindi emette la loro somma e lo fa ripetutamente.

Il programma scorre da sinistra a destra attraverso le 4 barre colorate che compongono 2 inputsseguite da un addcomando. Quindi si sposta nel codice in basso a destra ed esegue un output, quindi torna a sinistra attraverso la regione bianca.

Questo avrebbe potuto essere fatto in 8 codici, ma dato che abbiamo lo spazio extra possiamo fare qualcosa che sia un po 'ispirato da un vecchio display TV senza segnale.

15 codici

Legge un numero dallo stdin e genera il suo 'quadrato.

Questo utilizza un paio di trucchi per ottenere un aspetto un po 'simmetrico in un programma che effettivamente fa qualcosa. La barra rossa più a sinistra ha un colore diverso sul codice inferiore rispetto al resto, sfruttando il fatto che (almeno per me) queste 2 tonalità di rosso sembrano molto simili. il programma si sposterà dalla regione rossa più chiara a destra nel codice azzurro, e poi dritto attraverso la metà del programma al verde chiaro sul lato destro in cui è intrappolato. Svolge input, duplicate, multiply, e outputle operazioni.

Il codice rosso più scuro, insieme ai codici verde medio nella parte superiore e inferiore della colonna centrale, sono decorativi e il programma non li raggiungerà mai.

20 codici

Legge i numeri dallo stdin fino a quando non viene letto uno 0, a quel punto emette la somma di tutti i numeri immessi ed esce.

Finalmente abbiamo abbastanza spazio per fare il controllo del flusso sotto forma pointerdell'operazione. I 4 codici nella parte superiore eseguono input, duplicatee notoperazioni, quindi un'altra notoperazione che si sposta dal magenta in alto a destra al giallo a 2 codici sotto di esso. L' notoperazione estrae il valore superiore dallo stack e invia un 1 se il valore superiore era uno 0 e un 1 altrimenti. Pertanto, un doppio notsostituisce qualsiasi valore diverso da zero con un 1. Spostandosi dalla barra gialla verso il blu scuro, esegue pointerun'operazione che estrae il valore superiore dalla pila e sposta il puntatore di direzione in senso orario per molte volte.

Se il valore superiore è 1 (ovvero non abbiamo inserito uno zero) il puntatore di direzione punterà a sinistra, spostandosi sui codici magenta per addun'operazione (che verrà ignorata la prima volta a causa di un solo valore nello stack) e poi attraverso il bianco torna all'inizio del programma.

Se il valore massimo dello stack è zero nell'operazione del puntatore, il puntatore di direzione non cambierà e il programma continuerà verso il basso. Spostandosi nella banda blu più chiara, poplo 0 inserito fuori dallo stack, lasciando solo la somma dei numeri accumulati. Lo spostamento nella barra ciano in basso comporterà outputtale somma, e quindi terminerà poiché il flusso del programma è intrappolato.

25 codici

Conto alla rovescia! Legge un numero da stdin, quindi stampa un conto alla rovescia su 1 per stdout un numero alla volta. Ad esempio, se viene letto 5, verrà stampato 54321.

La prima operazione dal ciano al giallo è la input. Quindi il giallo è dove inizia il programma "loop". Giallo> Magenta> Blu è un duplicatequindi un output, quindi stampa il valore più alto nella pila ma ne conserva una copia. Scendendo destra, abbiamo pushil valore 1 nello stack poi effettuare una subtraction, diminuendo il nostro valore immesso 1. Il prossimo è duplicate, note un'altra notpassando dal magenta chiaro in basso a destra al giallo scuro accanto. Questo è lo stesso controllo zero / diverso da zero del programma precedente. Spostarsi a sinistra nel codice azzurro esegue pointerun'operazione, che si sposterà a sinistra nel ciano scuro per terminare il programma se abbiamo finito, o fino al giallo per riavviare il nostro loop senza l'input iniziale ma il valore originale è diminuito di 1.

Tutti e 3 i codici rossi sono decorativi e possono essere di qualsiasi colore.

30 codici

Generatore di Fibonacci. Stampa i termini della sequenza di Fibonacci su stdout e non si ferma.

Questa è la prima introduzione rolldell'operatore, nonché la prima volta che una dimensione della regione maggiore di 1 viene utilizzata con l' pushoperatore per ottenere un valore specifico nello stack.

Come sempre inizia in alto a sinistra spostandosi a destra. Le prime 2 fanno funzionare pushuno 1 nello stack e poi outputda quando la sequenza di Fibonacci inizia con due 1, ma il ciclo del programma principale stamperà 1 solo una volta. Quindi sono pushaltri 2 1 nello stack per finire nel magenta scuro in alto a destra per avviare il ciclo del programma principale.

Spostandoci verso il basso sul lato destro duplicatee outputstampando il termine successivo della sequenza, quindi di duplicatenuovo per ottenere una copia del valore attuale della sequenza. Muovendosi a sinistra nella parte inferiore si eseguono 2 pushoperazioni. Poiché la regione rosso-chiaro in basso a destra ha una dimensione di 3 codici, la prima pushspingerà un 3 sulla pila anziché un 1.

Passare al blu chiaro è rollun'operazione. Questo fa uscire i primi 2 valori dallo stack ed esegue un numero di tiri pari al primo valore saltato, ad una profondità pari al secondo valore saltato. In questo caso, eseguirà 1 tiro a una profondità di 3. Un tiro a profondità nprende il massimo valore dello stack (il nostro valore corrente duplicato) e lo seppellisce nposizionandolo in profondità. Il nostro stack ha solo 3 punti in questo momento, quindi seppellirà il valore più alto in fondo.

Salire ancora una volta esegue addun'operazione sommando il valore della sequenza corrente con il valore della sequenza precedente. Il nostro stack ora ha il prossimo (nuovo attuale) valore di sequenza in alto e l'ultimo valore al di sotto di esso. Il programma ora si sposta attraverso il bianco nel magenta scuro per ricominciare il ciclo.

Il motivo giallo nel mezzo non viene mai utilizzato.

54 codici

Stampa "ciao!" a stdout

Non è un messaggio particolarmente lungo, ma la stampa in piet richiede uno spazio sorprendente. La stampa viene eseguita utilizzando valori unicode e gli interi vengono inseriti nello stack utilizzando le dimensioni della regione in uscita. Dal momento che abbiamo un numero molto limitato di codici per questa sfida, usiamo un po 'di matematica per arrivare alla gamma stampabile che vogliamo.

Il programma inizia con un pushdi 5 dalla regione ciano a sinistra. Da qui, scorre lungo la parte superiore con 6 duplicateoperazioni per adescare la pila con un mazzo di 5 secondi. Il prossimo è push1, subtractper mettere un 4 in cima allo stack, quindi 2 multiplyoperazioni per mettere 4 * 5 * 5 = 100 in cima allo stack. Quindi a duplicateper 2 100s.

Ora il programma rimbalza sul nero e inizia a lavorare verso sinistra lungo il fondo. Pushoperazioni di 3 e 2 e poi a rollper seppellire i 2 100 sotto un 5. Il prossimo è push1, sottrarre e aggiungere per ottenere 100 + 5-1 = 104 in cima alla pila, che è unicode "h". Le successive 2 operazioni sono push1 e pointerper aggirare l'angolo e iniziare a muoversi proprio lungo il centro, quindi outputstampare "h".

Il prossimo è add100 + 5 = 105 in cima alla pila e outputper stampare "i". Lo stack ora contiene due 5. Push1, add, multiplydà (1 + 5) * 5 = 30. Finalmente push3 e addper 33, e outputper il finale "!". Il programma passa quindi attraverso lo spazio bianco rimanente per finire nel verde a destra.

> <> (Pesce)

(Nota: alcuni frammenti si basano su frammenti precedenti, quindi, a differenza della maggior parte delle risposte, ho deciso di metterli dal primo all'ultimo.)

factoid:

Come Befunge,> <> è un linguaggio 2D basato su stack. Ciò significa che le istruzioni non vengono eseguite in modo lineare come la maggior parte delle lingue tradizionali: il flusso del programma può essere su, giù, a sinistra o a destra!

Lunghezza frammento 1:

X

Xè un comando non valido in> <>, quindi something smells fishy...viene stampato il messaggio di errore . In realtà, questo è l'unico messaggio di errore in> <>, sia che la causa sia divisione per zero o che cerchi di far apparire uno stack vuoto.

Snippet di lunghezza 2:

1n

Il flusso del programma in> <> inizia da in alto a sinistra ed è inizialmente verso destra. 1spinge un 1 nella pila, quindi lo nstampa come un numero (anziché come un carattere ASCII). Ma i programmi> <> sono toroidali, il che significa che il puntatore dell'istruzione si avvolge quando raggiunge la fine di una linea. Quindi, dopo aver terminato n, premiamo un 1, stampiamo, finiamo all'inizio, premiamo un 1, stampiamo ... e finiamo per stampare 1s per sempre!

Snippet di lunghezza 3:

"o;

Ecco l' "analisi delle stringhe, viene oemessa come carattere ASCII e ;termina il programma. Ma cosa fa effettivamente il programma nel suo insieme?

Bene, prima iniziamo l'analisi delle stringhe, spingendo tutti i caratteri che vediamo nello stack fino a quando non troviamo una chiusura ". Spingiamo un o, poi un ;... e riavvolgiamo il puntatore dell'istruzione all'inizio. Ma ora siamo in un "modo che si fermano all'analisi delle stringhe, e, infine, eseguiamo la oe ;come normale per stampare la cima della pila (la ;) e terminare.

Sì, abbiamo appena usato lo stesso carattere virgolette per iniziare e terminare una stringa!

Snippet di lunghezza 4:

42n;

Sulla base di ciò che abbiamo visto finora, potresti aspettarti che questo spinga 42, produca come numero e termini. Ma tutte le istruzioni in> <> sono singoli caratteri, quindi questo in realtà spinge un 4 e un 2 , quindi emette la parte superiore dello stack come un numero (solo il 2) e termina.

Snippet di lunghezza 5:

<v
;>

Ricorda,> <> è un linguaggio 2D. Ciò significa che ci devono essere modi per cambiare la direzione del flusso del programma!

Come Befunge, un modo per farlo è tramite le frecce >^v<. Per illustrare come funzionano, diamo un'occhiata al programma sopra:

• Il flusso del programma è inizialmente verso destra
• < fa scorrere il programma verso sinistra - andiamo a sinistra e ci spostiamo verso v
• v fa scorrere il programma verso il basso - scendiamo al >
• > fa scorrere il programma verso destra - andiamo a destra e ci spostiamo sul ;
• Alla fine, terminiamo.

Snippet di lunghezza 6:

";"00p

Un'altra caratteristica interessante di> <> è che è riflessiva: il programma può modificare il proprio codice sorgente al volo!

Qui spingiamo a ;, seguito da due zero. ppoi apre i primi tre elementi y, x, v( yessendo la parte superiore della pila) e posti vnella posizione x,y. In altre parole, pin questo programma mette un punto e virgola nella posizione 0,0, trasformando il codice in ;;"00p. Ciò consente quindi al programma di terminare, poiché il puntatore dell'istruzione ora si avvolge ed esegue il nuovo posizionamento ;.

Lunghezza frammento 7:

\7*n;
6

A differenza di Befunge,> <> ha anche i mirror ( \/|_#) che riflettono la direzione del flusso del programma. Quindi qui:

• Inizia verso destra, ma ciò \ci riflette verso il basso
• Spingere un 6 e avvolgere
• Colpisci il retro del \e rifletti verso destra
• Premere un 7
• Moltiplica i primi due della pila
• Emetti e termina

Spostarsi orizzontalmente attraverso uno _specchio o verticalmente attraverso uno |specchio non è consentito.

Lunghezza frammento 8:

"r00g>o<

Molto probabilmente il più semplice> <> quine se è consentito lanciare un errore. Le due nuove istruzioni qui sono:

• r: Inverte la pila
• g: Get - pop y, xe spingere il carattere x,ynello stack (controparte p)

Usando il trucco di avvolgimento delle stringhe di prima, il programma preme inizialmente, r00g>o<quindi preme di nuovo la prima citazione. Lo stack viene quindi invertito, dando <o>g00r. Dopodiché spingiamo il carattere a 0,0, il ", per dare <o>g00r". Alla fine, intercettiamo una otra due frecce, emettendo la parte superiore della pila fino a quando non rimane più nulla e otteniamo un errore.

Snippet di lunghezza 9:

x0\>
\1n>

x(lettere minuscole) sposta il puntatore dell'istruzione in una direzione casuale e il programma mostra questa funzionalità stampando bit casuali per sempre. Prova a seguire le frecce e gli specchi per capire come funziona! (Non dimenticare di controllare tutte e quattro le direzioni, comprese quelle su e sinistra)

Snippet di lunghezza 10:

;a comment

Non c'è sintassi di commento in> <> - non ne ha bisogno. Scrivi quello che vuoi ovunque e assicurati che non venga eseguito come codice!

Lunghezza frammento 11:

1!X2!X+!Xn;

!è un trampolino che salta le istruzioni. È particolarmente utile se utilizzato con ?un trampolino condizionale che fa apparire la parte superiore dello stack ed esegue l'istruzione successiva se l'elemento saltato è diverso da zero. Vedremo come funziona in seguito.

Il codice sopra stampa 3 saltando su Xs, eseguendo solo 1! 2! +! n;.

Lunghezza frammento 12:

01v
ao>:@+:n

Stampa i numeri di Fibonacci per sempre a partire dal secondo 1, uno su ogni riga. I nuovi comandi sono:

• a: Push 10, necessario per newline. a-fspingere da 10 a 15 rispettivamente.
• :: Parte superiore dello stack duplicata
• @: Ruota i primi tre elementi della pila, ad es [5 4 3 2 1] -> [5 4 1 3 2].

Traccia per le prime iterazioni:

Snippet di lunghezza 13:

i:d=?v
l?!;o>

Un programma "tac" che legge in una riga di input e lo emette invertito. Grazie a @tomsmeding per lo snippet.

=apre i primi due elementi e preme 1 se sono uguali, 0 altrimenti. La prima riga continua a leggere in input fino a quando non viene trovato il carattere ASCII 13 (ritorno a capo), a quel punto passa alla seconda riga.

Il l?!;oloop è un costrutto importante in> <> che genera l'intero stack. Diversamente >o<, non causa errori. È così che funziona:

• l spinge la lunghezza della pila
• Controlliamo la lunghezza con ?:
  • Se la lunghezza era diversa da zero, !viene eseguita l'istruzione successiva , saltando la;
  • Se la lunghezza era zero, non eseguiamo e non terminiamo a !causa di;

Si noti che in realtà non si verifica alcun output fino a quando si preme il ritorno a capo.

Snippet di lunghezza 14:

32.

   X67*n;

Oltre a cambiare la direzione del flusso del programma, puoi effettivamente spostare il puntatore delle istruzioni ovunque tu voglia!

.pop y, xe teletrasporta il puntatore di istruzione x,y, mantenendo direzione. Si noti, tuttavia, che è necessario spostarsi su un quadrato prima di dove si desidera andare: il puntatore dell'istruzione viene aggiornato prima dell'esecuzione dell'istruzione successiva. Quindi qui il puntatore dell'istruzione finisce sull'invalido X, ma tutto va bene poiché il puntatore si sposta su 6prima di continuare l'esecuzione.

.rende possibile convertire la maggior parte dei programmi> <> in una linea, ma perché dovresti perdere il divertimento del 2D? :)

Lunghezza frammento 15:

01+:aa*=?;:nao!

Stampa i numeri 0su 99, uno su ogni riga. Questo programma dimostra un uso accurato del !trampolino - per garantire che lo 0 iniziale venga premuto una sola volta.

Lunghezza frammento 16:

"r00g!;oooooooo|

Un quine corretto che non genera errori, ispirato al quine nella pagina esolang .

Se ti chiedi come modificare il quine precedente (snippet n. 8) in modo che non causi un errore e pensi "perché non aggiungo solo un sacco di oistruzioni?", Allora potresti rendertene conto per ogni ocosa che aggiungi , devi produrne un altro o! Questo quine risolve ordinatamente il problema mettendo uno |specchio all'estremità, che consente a ciascuno odi essere utilizzato due volte .

Se passiamo alle virgolette singole (che sono anche per l'analisi delle stringhe), allora un quine alternativo che non usa gè

'r3d*!;oooooooo|

Lunghezza frammento 17:

b2,63,.

   17,n;

Abbiamo add ( +), sottrazione ( -), moltiplicazione ( *), modulo ( %) ... ma per quanto riguarda la divisione? È lì, ma poiché /è già uno specchio, è stato assegnato il ,simbolo alla divisione . È interessante notare che la divisione è divisione float , non divisione intera!

Il programma sopra esplora alcuni comportamenti indefiniti cercando di saltare a 11/2, 6/3. L' intero Python sembra a posto se la prima coordinata non è un numero intero (anche se salta nel punto sbagliato), ma soffoca se la seconda non lo è.

Lunghezza frammento 18:

123456${{$}nnnnnn;

Abbiamo visto rche inverte la pila e @che ruota i primi tre elementi. Ecco alcuni altri comandi che spostano gli elementi nello stack:

• $: Scambia i primi due elementi
• {: Sposta l'intero stack a sinistra
• }: Sposta l'intero stack a destra

Per mostrare come funziona, ecco la traccia del programma:

123456 ------> 123465 ------> 234651 ------> 346512 ------> 346521 ------> 134652
       $ Swap        { L shift      { L shift       $ Swap        } R shift

Quindi usciamo, dando 256431.

Lunghezza frammento 19:

"reward"4[roooo]oo;

Fino ad ora ho detto "la pila", "la pila" ...

Sebbene la maggior parte dei programmi utilizzi solo uno stack,> <> può effettivamente avere più stack! Ecco le istruzioni pertinenti:

• [: Apre xe sposta gli xelementi superiori in un nuovo stack
• ]: Rimuove lo stack corrente e sposta i suoi valori nello stack sottostante.

Ecco la traccia per il programma sopra:

       [r e w a r d]       Push "reward"
4[     [r e] [w a r d]     Move four elements to a new stack
r      [r e] [d r a w]     Reverse the current stack
oooo   [r e] []            Output "ward"
]      [r e]               Remove the current stack, no values to move
oo     []                  Output "er", giving "warder" altogether

Si noti che semplicemente spingendo rewarde poi emettendolo di nuovo con ooooooverrebbe stampato drawer, a causa della natura "first in, last out" delle pile.

Snippet di lunghezza 20:

aa*5+\
7a*2+\
oo;  \

Una caratteristica poco nota di> <> è che, come Python, le barre rovesciate possono essere utilizzate per la continuazione della linea in molti casi. *

Il codice sopra è funzionalmente uguale a

aa*5+7a*2+oo;

^{* Dichiarazione di non responsabilità: il motivo per cui funziona o meno potrebbe essere per un motivo completamente diverso}

Snippet lunghezza 22:

1&fv ;n&<
&1->:0=?^:&*

Oltre agli stack,> <> ha anche dei registri (uno per ogni stack) che possono essere utilizzati per memorizzare i valori. La chiamata &per la prima volta sposta il valore superiore dello stack nel registro e l'esecuzione di &nuovo sposta il valore indietro. Questo può essere molto utile quando si accumula un valore, ad esempio somme e fattoriali.

Il programma sopra calcola il fattoriale di f(15), stampando 1307674368000. Ecco la traccia per fsostituita con 4:

Lunghezza frammento 24:

"Hello, World!"rl?!;of0.

Abbiamo abbastanza caratteri per il programma preferito da tutti! Qui usiamo il .teletrasporto per il circuito di uscita.

Snippet di lunghezza 25:

0i:0(?v$a*$"0"-+!
   ;n~<

Sfortunatamente> <> consente di leggere da STDIN solo un carattere alla volta, il che rende la lettura in numeri un po 'complicata. Per input composto da cifre 0-9, questo programma è essenzialmente atoi, convertendo una stringa di cifre da STDIN in un numero sullo stack (che viene quindi stampato).

Un'altra nota è che su EOF, ispinge -1 nello stack. Ciò semplifica il controllo di EOF confrontandolo con 0 utilizzando (o "minore di".

Utilizza anche questo frammento ~, che apre e scarta l'elemento superiore dello stack.

Snippet lunghezza 33:

i>:nao:1=?;\
 ^  ,2v?%2:/
 ^+1*3<

Fino ad ora, la maggior parte dei frammenti sono stati relativamente lineari o erano solo semplici esempi che dimostravano la funzionalità di <<>. Ora posso fare un esempio che evidenzia quanto sia facile visualizzare il flusso del programma in> <> con un programma ben strutturato.

Il programma legge un singolo carattere ASCII ed esegue l' 3x+1algoritmo sul suo punto di codice (In> <>, i caratteri sono sostanzialmente numeri interi). Ogni passaggio dell'algoritmo viene stampato fino a quando non si preme 1.

Ecco una traccia per le prime iterazioni con input a(codice 97):

Lunghezza 44 frammento:

a&>i:0(?v"+"$\
/&^?=0l< "a*"/
\:1+&2p/\0
n
;

Non mi sento di aver reso pgiustizia al comando, dopo averlo usato solo una volta nel frammento n. 6, quindi ecco una diversa funzione Atoi. Cosa c'è di bello in questo? Il programma scrive l'espressione necessaria per calcolare il numero mentre legge l'input!

Quindi, per un input simile 573, dopo che tutti i caratteri sono stati letti, la fine della terza riga sarà simile \0a*5+a*7+a*3+a 573!

Ancora una volta, si suppone che l'input sia solo cifre. Traccia GIF qui .

Lunghezza frammento 74:

>i:'A'(?v:'N'(?v:'['(?v\
  :'a'(?v:'n'(?v:'{'(?v\
^      o<    +d<  -d-d<o

Se sei riuscito a venire qui, potresti essere d'accordo con me quando dico che questo è un programma ROT13 molto leggibile. Dato un carattere c1, troviamo il primo carattere c2in AN[an{, tale che c1 < c2, quindi, applichiamo l'offset appropriato aggiungendo / sottraendo d(13). Si noti che [e {sono i caratteri direttamente dopo Ze zrispettivamente.

Provalo nella console e guarda le lettere trasformarsi mentre scrivi!

^{(È anche possibile reindirizzare l'input, ma poiché mi manca il controllo EOF, :0(?;si fermerà con un errore quando tenta di stampare -1 come carattere)}

C - modifica

Grazie per i voti! Rispetto ad altre lingue e cosa possono fare in byte limitati, C sembra obsoleto, pignolo e troppo dipendente dallo sviluppatore. Sotto molti aspetti: i linguaggi di script e di livello superiore con gestione automatica della memoria sono molto più espressivi e più rapidi nella produzione di quanto lo sarà mai il C.

Quindi perché la caratteristica C?

Il segreto nascosto dietro tutti quei linguaggi di scripting è che gli interpreti sono probabilmente scritti in C (o più recentemente, C ++ o Java). I primi compilatori C ++ sono stati effettivamente compilati in codice C. In effetti, fino a quando non c'è un mercato per un compilatore diretto, di solito è più conveniente scrivere un compilatore per generare C, quindi compilarlo.

Se stai lavorando su piattaforme molto piccole, forse anche senza un sistema operativo disponibile, probabilmente stai lavorando in C. In questi giorni, praticamente ogni apparecchio ha un microcontrollore incorporato, senza dubbio programmato in C. Quando ne hanno bisogno piccolo e veloce, C è la strada da percorrere. (Anche FORTH, per i masochisti.)

Conoscere C ti porta il più vicino possibile al metallo senza entrare nell'assemblatore e ti aiuta in altre lingue. Hai una buona idea di come funzioni probabilmente una funzione virtuale C ++. Sai quando scrivi quelle funzioni ricorsive pass-by-value in PHP, internamente sta facendo molta allocazione e copia della memoria, quindi provi istintivamente il pass-by-reference. Callback e riferimenti non impazziscono gli sviluppatori C, forse Haskell lo fa.

Come hanno menzionato Kernighan e Ritchie nella prefazione del classico linguaggio di programmazione C , 2a edizione, C non è un grande linguaggio e non è ben servito da un grande libro. Sto cercando di seguire questo consiglio: gli esempi fanno doppio, triplo o più dovere, se possibile.

Tutti i frammenti sono almeno compilabili da soli. Quelle che sono collegabili ed eseguibili sono indicate come tali. So che questo non è un requisito, ma rende più semplice il tentativo di spiegare il framework richiesto per far funzionare qualsiasi frammento di codice.

Ho anche cercato di assicurarmi che ogni frammento di codice fosse il più corto possibile in modo da non introdurre spazi extra solo per riempire una certa lunghezza. Nei casi in cui il codice è rientrato, i rientri non sono inclusi nella lunghezza, ma solo un carattere per ogni nuova riga.

factoid

C rocce.

Lunghezza 0 frammento

Il programma di riproduzione automatica più breve del mondo http://www.ioccc.org/1994/smr.hint

Lunghezza 1 frammento

;

C fa una distinzione tra compilazione e collegamento. Molte entità in C sono appena compilate e collegate in un secondo momento - un esempio sono tutte le librerie statiche e dinamiche.

Altre entità sono appena incluse e non generano alcun codice da sole.

Il punto e virgola sopra verrà sicuramente compilato in codice oggetto e non farà nulla!

Lunghezza 2 frammento

x;

C, essendo un vecchio linguaggio di programmazione, ha subito diverse iterazioni. Il primo in uso diffuso fu sviluppato da Kernighan e Ritchie e abbreviato K&R. K&R C è noto per fare molte ipotesi sul tuo codice se non le fornisci esplicitamente.

In particolare, in K&R C, si presume che il codice sopra sia un intero globale xinizializzato su 0. La compilazione in modalità K&R produrrà un file oggetto che fornisce qualsiasi programma che lo collega a questa variabile per il suo uso.

Lunghezza frammento 3

??/

C è così diffusa che deve fornire funzionalità di compatibilità per sistemi che non hanno tutti i caratteri che utilizza. Quanto sopra è una trigrafia per la barra rovesciata, che viene utilizzata in C come carattere di continuazione della linea. Quanto sopra verrà compilato, probabilmente con un avviso che non esiste una riga seguente.

Una cultura comune in C consiste nell'ignorare gli avvisi di compilazione e molte basi di codice di grandi dimensioni invariabilmente hanno alcuni o più avvisi quando vengono creati.

Lunghezza 4 frammento

f();

Sempre con K&R, quanto sopra viene "compilato" per indicare, al momento della compilazione, che "Esiste, con un collegamento globale, una funzione fda fornire in seguito, che accetta un numero fisso ma non specificato di argomenti e restituisce un numero intero".

Nota le differenze fondamentali tra questo e f;.

Lunghezza 5 frammento

s="";

K&R C è noto per essere veramente perdonatore. Al momento della compilazione, questo codice fornirà un numero interos per il collegamento globale che viene inizializzato all'indirizzo iniziale di una stringa vuota (credo). K&R gestisce tranquillamente tutte le coercizioni, incluso il troncamento se un numero intero non è abbastanza grande da contenere l'indirizzo.

Sono costrutti come questi che hanno generato molti bug difficili da trovare e hanno fornito molta ispirazione nelle competizioni IOCCC.

Lunghezza 6 frammento

o=042;

Un gotcha di timer anche vecchi, uno 0 iniziale in un numero letterale significa che le cifre seguenti sono nella base ottale. Il codice sopra, al momento della compilazione, fornirà un numero intero oper il collegamento globale inizializzato al decimale 34.

Questa caratteristica di C ha morso molti sviluppatori che si sforzano di riempire i loro numeri per renderli allineati bene e persino!

Lunghezza frammento 7

f(){f;}

Il codice sopra è una funzione con un corpo. Ma che cosa fa? Recupera l'indirizzo della funzione e non fa nulla con essa! In genere ciò che la funzione restituirà non è definito. Codice non sensato come questo spesso può essere compilato senza preavviso.

Lunghezza 8 frammento

main(){}

Questo rappresenta il codice compilabile e collegabile più breve in C. Mentre nelle versioni moderne di C, le funzioni di solito non possono essere definite implicitamente, per ragioni storiche per cui questa restrizione è attenuata main.

Questa meraviglia di un programma, che non fa altro che restituire 0, verrà compilata in dimensioni non trascurabili e verrà collegata in varie routine di runtime C. Puoi compilare e collegare con verbosità impostata su full per vedere cosa sta succedendo sotto il cofano.

Lunghezza frammento 9

#define Z

Un pilastro dei file di intestazione C è la #definedirettiva preprocessore. I programmi C vengono compilati in varie fasi e in una di queste fasi queste definizioni vengono sostituite con i loro valori effettivi.

Quando manca un argomento, C implicherà 1, quindi quanto sopra sostituirà 1ovunque Zsia usato nel codice sorgente.

Quanto sopra verrebbe tipicamente inserito in un file di intestazione e #included come richiesto.

Lunghezza frammento 10

enum{P,Q};

La enumparola chiave fornisce un modo talvolta sicuro per definire una serie di costanti. Come definito, vengono spesso utilizzati nei file di intestazione. Il codice sopra riportato, quando incluso, definirebbe Pun numero intero di 0 e Qdi 1.

Lunghezza 11 frammento

volatile v;

La volatileparola chiave è far sapere al compilatore che una variabile può essere modificata da altri agenti e non fare ipotesi che rimarrà costante tra gli accessi.

Lunghezza 12 frammento

#pragma once

#pragma once è una direttiva preprocessore non standard ma ampiamente supportata per indicare che il file di origine corrente deve essere incluso solo una volta in una singola compilazione.

La tecnica tradizionale e pienamente supportata consiste nell'utilizzare le #includeprotezioni con gli svantaggi del codice aggiunto e dei possibili scontri con i nomi.

Lunghezza 13 frammento

w(){for(;;);}

Esistono numerose convenzioni in C, e una di queste è come rappresentare loop infiniti. In questo caso, for(;;)indica nessuna inizializzazione, nessun controllo di uscita che per impostazione predefinita è 1 che significa vero, ovvero non si interrompe e nessun codice di loop.

A volte è possibile fare tutto all'interno di ()e il ciclo stesso non ha bisogno di un corpo. In questo caso viene aggiunto un punto e virgola fittizio alla fine.

Nel codice sopra, una volta compilato, fornirà una funzione che entrerà in un circuito affollato - uno dei no-no nella progettazione del software - e non tornerà mai più.

Lunghezza frammento 14

int a[]={1,2};

Le matrici in C non necessitano delle lunghezze specificate. Le parentesi quadre vuote []indicano al compilatore di "capirlo da soli". Tuttavia, in C, a differenza di altre lingue, non esiste un modo integrato per impedire l'accesso a un array al di fuori di questi limiti, portando alla metafora "sparati nel piede" per cui C è noto.

Il codice sopra, una volta compilato, fornirà un array mutabile globale adi due numeri interi inizializzati con 1 e 2.

Lunghezza frammento 15

const long k=7;

Lo constspecifer è un'aggiunta successiva a C presa in prestito da C ++. Una domanda di intervista comune è "Ha senso definire una variabile come volatile const?". constinsieme enume inlineintendono ridurre la dipendenza #defineda problemi con la sicurezza dei tipi.

Lunghezza 16 frammento

extern void **q;

externè usato per indicare che una variabile è dichiarata altrove. Il void *tipo è il tipo generico standard in C, il che significa che non è necessario eseguire il cast esplicito o il cast da nelle istruzioni di assegnazione. La **sequenza dell'operatore significa puntatore a un puntatore, che spesso fa esplodere le menti dei neofiti, ma è perfettamente valido e spesso usato C.

Lunghezza frammento 17

double d=4/3-1/3;

Se dovessi stampare quanto sopra, il risultato sarebbe uno e penseresti super! Passare a double d=4/3-2/3;e qual è la risposta? È ancora uno! C sta usando l'aritmetica intera per calcolare 4/3 → 1 e 2/3 → 0 e 1 - 0 → 1!

Lunghezza 18 frammento

main(){puts("!");}

Finalmente arriviamo ad un codice che fa davvero qualcosa! putsè un favorito dei golfisti C perché non richiede un file di intestazione per l'uso.

putsaggiungerà anche un feed di riga all'output. Al contrario, la sua controparte getseliminerà i feed di linea. Non si dovrebbe mai usare getsse non in circostanze molto controllate: non ha protezione per sovraccarichi del buffer ed è la causa principale di molti exploit.

Lunghezza 19 frammento

#include <stdlib.h>

L'inclusione dei file di intestazione è spesso una firma personale degli sviluppatori. Molti includono libe ioindipendentemente dal fatto che siano necessari. Alcuni ordinano i file di intestazione in modo che le lunghezze aumentino o diminuiscano. Più messo <>prima "". Personalmente ho usato questa firma nei miei giorni TA per verificare la presenza di imbrogli tra gli studenti: la stessa firma dell'intestazione? dai un'occhiata più da vicino!

Lunghezza 20 frammento

char*p=(char*)0x300;

C è progettato per essere utilizzato su piattaforme rudimentali di livello molto basso. In alcuni casi potrebbe essere necessario accedere direttamente alle porte mappate memoria speciali.

Nel codice sopra l'indirizzo di una porta è definito come esadecimale 300. Si accede al valore della porta utilizzando *p, come in *p=0xff;per attivare tutti i bit o v=*p;per recuperare il valore corrente.

Lunghezza frammento 21

int w=sizeof(double);

L' sizeofoperatore fornisce la dimensione in byte di un tipo. Con i nomi delle variabili le parentesi non sono richieste ad es double d;int w=sizeof d;.

Lunghezza frammento 22

asm("xorl %ecx,%ecx");

La modalità asmdi utilizzo è definita dal compilatore. Quanto sopra è un esempio di codice in linea gcc Linux su una piattaforma Intel.

L'unico Unix aveva una piccola ma non trascurabile parte del suo codice nell'assemblatore. Anche oggi, se la velocità è di primaria importanza e la portabilità non lo è assolutamente, la vedrai utilizzata.

Su sistemi compatibili, il codice sopra verrà compilato e sarà letteralmente un'istruzione di assemblaggio isolata senza mezzi convenzionali per accedervi! BTW xor R,Rè un linguaggio linguaggio assembly comune per cancellare rapidamente un registro.

Snippet di lunghezza 23

union u{char c;int i;};

A unionfornirà almeno lo spazio sufficiente per l'elemento più grande. Potresti vederlo usato insieme void *a fornire un tipo "opaco" comune in certe librerie. In questo caso, l'unione di solito farà parte di una struttura più grande, con la struttura che ha un campo per identificare il tipo di unione.

Lunghezza 24 frammento

/*INTS*/int i,j,k;//INTS

Il commento originale in C è stato delimitato da /* comment */e preso in prestito il // comment to end of lineformato da C ++.

Lunghezza frammento 25

int main(void){return 1;}

Questa è la versione più conforme dello snippet di lunghezza 8 sopra. Il tipo restituito e i tipi di funzione sono specificati e ha un valore restituito esplicitamente.

La convenzione in C consiste nell'utilizzare un valore di ritorno di 0per successo e 1per fallimento, o se si desidera essere rigorosamente conformi EXIT_SUCCESSe EXIT_FAILUREcome definito in stdlib.h.

Lunghezza 26 frammento

typedef struct{int x,y;}P;

typedefè estremamente utile, in particolare typedef struct,. In termini moderni potresti chiamarlo "orientamento all'oggetto-luce".

Dopo aver incluso quanto sopra, il codice può essere utilizzato Pcome tipo normale nelle dichiarazioni e nelle funzioni, con controllo completo del tipo. A differenza di C ++, tuttavia, non è possibile definire operatori come +, * o <<, quindi "luce-orientamento-oggetto".

Lunghezza del frammento 27

#define C(x,y)(((x)+1)*(y))

C ha una #definesintassi macro conveniente .

Un errore novizio comune è l'omissione di parentesi interne e / o esterne, con conseguenti errori di precedenza dell'operatore difficili da trovare.

Lunghezza frammento 28

struct f{int s:1,e:8,m:23;};

C può definire esplicitamente campi di bit che possono essere assegnati, letti e manipolati come qualsiasi numero intero.

Quanto sopra è un'approssimazione di una struttura di dati IEEE a virgola mobile a larghezza singola.

Lunghezza 36 frammento

f(unsigned x){return!!x&!(x&(x-1));}

In molte lingue, non è necessario preoccuparsi di come sono rappresentati i numeri. In C, devi essere intimamente consapevole della loro rappresentazione interna.

Il miglior esempio di ciò che mi viene in mente è determinare se un numero intero è una potenza di due {1, 2, 4, 8, ...}. Coloro che non hanno familiarità con C eseguiranno cicli e turni e qualsiasi altra cosa per il runtime O (log (n)), non male, ma sopra c'è una funzione che farà lo stesso nel runtime O (1). Lascio che sia un esercizio per il lettore per confermare che funziona, ma lo fa davvero ...

La !!convenzione viene spesso utilizzata per forzare un numero intero da diverso da zero e zero a 1 e 0 rispettivamente. A molti sviluppatori C piace usare questo tipo di trucchi (spesso in contrasto con coloro che apprezzano la chiarezza del codice).

Gli sviluppatori di Super C possono confermare che quanto sopra funzionerà su hardware a complemento e firmato. Per quelli che si chiedono, sei quasi sicuro di lavorare su hardware a due complementi in questo momento. Solo i più fortunati (o sfortunati a seconda della tua prospettiva) devono preoccuparsi di questo!

Lunghezza frammento 48

#include<complex.h>
double complex c=3.0+I*4.0;

C99 include il supporto per numeri complessi. Come puoi vedere dal codice, assume la forma di un modificatore per un tipo reale. Puoi anche usare int complex c=3+I*4;ma internamente si costringe a un tipo a virgola mobile. Il codice sopra verrà compilato in gcc usando gcc -std=c99 -c length-48.c.

Se vuoi vedere più interni, prova a compilare con l'opzione -E. Per la mia versione di gcc, la dichiarazione sopra diventa double _Complex c=3.0+(__extension__ 1.0iF)*4.0;. Si noti che il tipo complesso è un'aggiunta significativa alla lingua, non solo alcune macro economiche.

Questo è solo un teaser, quando arriviamo a più di 125 caratteri, allora possiamo iniziare a divertirci davvero con numeri complessi!

Snippet di lunghezza 51

#include <math.h>
main(){double d=sqrt(sin(3.2));}

Per vari motivi, C non si collega automaticamente alle funzioni matematiche standard come sin, cos, tan, sqrt, ecc. Quindi, se vengono utilizzati, ma non collegati, allo sviluppatore verrà presentato l'errore del linker un riferimento indefinito a 'sqrt' o qualche altro errore.

In gcc, il codice sopra compilerà e collegherà usando gcc length-51.c -lm.

Nota sin(3.2)restituirà un numero negativo, di cui la radice quadrata non è legale nel dominio reale. In C, NaNviene restituito un valore speciale per indicare questo errore, che il programma è libero di ignorare!

In C99, ci sono molte nuove funzioni di gestione delle eccezioni per fornire un controllo molto sicuro e dettagliato di questo tipo di errori matematici, che quasi nessuno usa!

Lunghezza frammento 63

static int w;static int X(int x){static int s=0;s^=x;return s;}

O formattato in modo più sano:

static int w;
static int X(int x)
{
    static int s=7;
    s^=x;
    return s;
}

Come avrai intuito, si tratta della parola chiave staticche ha più di un significato in C.

Nei primi due casi, staticsta dicendo al compilatore che numeri interi we funzioni Xnon sono visibili al di fuori di questo file o unità di compilazione, cioè sono interni.

Queste funzioni non sono pensate per essere chiamate esternamente, quindi potrebbero non verificare la validità degli argomenti e tagliare altri angoli. Poiché hanno un ambito interno, è possibile ridefinire we Xin altri file e di solito saranno separati.

Nell'ultimo caso, staticindica che il numero intero smantiene il suo valore tra le chiamate di funzione. La prima volta che Xviene chiamato, ssarà il suo valore iniziale 7, quando viene eseguito l' OR esclusivo con x, il nuovo valore verrà mantenuto.

Internamente, sebbene dipenda dall'implementazione, la consueta organizzazione della memoria srisiede nell'heap, memoria specificamente inizializzata, mentre l'argomento xrisiede nello stack. Dove risiedono le variabili è importante se si desidera implementare algoritmi ricorsivi, ad esempio.

Un gotcha in C sono scontri con variabili globali. Fino a quando we Xsono in realtà definiti static, se sono definiti a livello globale da qualche parte, quindi we Xsi riferiranno alle entità globali, invece.

Qui qe wnon può essere inizializzato sullo stesso valore, perché un globale wviene utilizzato per impostare q:

static int q = w;
static int w;

Se wnon esiste un globale , la compilazione dovrebbe fallire.

Qui qe wverrà inizializzato allo stesso valore:

static int w;
static int q = w;

In genere, i progettisti ridurranno gli scontri con i nomi aggiungendo un prefisso o suffisso distintivo alle loro variabili e funzioni globali.

In C99, staticha guadagnato un altro uso, ad esempio, il int Y(int a[static 10]);che significa che esiste una funzione Yche accetta un array di almeno 10 numeri interi.

Lunghezza frammento 74

void f(register int*p,register int*q,register int l){while(l--)*p++=*q++;}

O ben disposti:

void f(register int *p, register int *q, register int l)
{
    while (l--)
        *p++ = *q++;
}

La parola chiave registerfornisce un suggerimento al compilatore che l'utilizzo dei registri hardware sarebbe utile qui. La funzione sopra copierà lnumeri interi da qa p, se possibile utilizzando i registri hardware.

A volte le accelerazioni potrebbero essere significative. Ad esempio, nella famiglia di microprocessori 68K, la linea *p++ = *q++potrebbe essere tradotta in una singola istruzione MOVE.W (Ap)+,(Aq)+rispetto a sei o otto se non la si utilizzava register. Il microprocessore 68K aveva esplicite modalità post-incremento e pre-decremento, quindi lo sviluppatore esperto, se avesse conosciuto la piattaforma, avrebbe adattato il codice usando x++e --yvs. ++xe y--.

In questi giorni i compilatori ignorano per lo più register, oltre a non consentire che vengano presi degli indirizzi (ad es. In quanto sopra &lcauserebbe un errore del compilatore).

Lunghezza 88 frammento

#include<stdio.h>
int f(int x){return(x>1)?x*f(x-1):1;}int main(){printf("%d\n",f(12));}

O con un layout più igienico:

#include <stdio.h>

int f(int x)
{
    return (x > 1)? x * f(x - 1): 1;
}

int main()
{
    printf("%d\n", f(12));
}

Ah, ricorsione! Lo snippet è un programma completo per la compilazione, il collegamento e l'esecuzione. La funzione fcalcola il fattoriale del suo argomento xusando la formula ricorsiva f (x) = x * f (x - 1). I fattoriali si ingrandiscono molto rapidamente, quindi ad esempio f(12)è il valore più grande che puoi ottenere in un intero con segno a 32 bit.

Per un esempio di codice veramente ricorsivo, esamina le implementazioni ingenue della funzione Ackermann .

I compilatori intelligenti possono ottimizzare la funzione, usando il suggerimento inlinee "srotolano" la funzione quando le costanti vengono fornite come argomenti in modo che:

f(12)

diventa:

12 * 11 * 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1

Senza alcuna chiamata di funzione richiesta!

Altri compilatori possono riorganizzare la funzione:

int f(int x)
{
    return (x < 2)? 1: f(x - 1);
}

E implementare qualcosa chiamato ricorsione della coda. Questo in effetti sostituisce l'ultima chiamata di funzione a un semplice goto e consente a quella funzione di gestire il ritorno. Il vantaggio è meno thrashing dello stack, codice più veloce e più piccolo.

Nel linguaggio assembly, questo tipo di opportunità di ottimizzazione è davvero facile da individuare e può essere implementato da qualcosa chiamato "ottimizzatore del buco della serratura", che sostanzialmente cerca piccoli schemi e li sostituisce con qualcosa di più veloce e / o più piccolo.

Snippet di lunghezza 117

#include<stdio.h>
int main(int c,char**v){int a,b;sscanf(v[1],"%d%*[\t ,]%d",&a,&b);printf("%d\t%d\n",a,b);return 0;}

O:

#include <stdio.h>

int main(int c, char **v)
{
    int a, b;

    sscanf(v[1], "%d%*[\t ,]%d", &a, &b);
    printf("%d\t%d\n", a, b);

    return 0;
}

C preso in prestito dalle lingue contemporanee all'epoca, il concetto di I / O universale che poteva essere applicato in modo coerente a qualsiasi dispositivo, che fosse console, scheda perforata, nastro, disco o stampante, ma in vero formato C, permetteva allo sviluppatore di creare dichiarazioni molto concise ma potenti.

Nello snippet precedente, prenderà l'input dalla riga di comando, analizzerà due numeri interi separati da spazi, tabulazioni o virgole e li emetterà. Sfrutta un nuovo scanfidentificatore %*[\t ,]che: [\t ,]estrarrà tutte le schede, gli spazi e le virgole e *li ignorerà.

Ricordo di aver rivisto un po 'di codice C ++ in cui lo sviluppatore stava facendo tutto in modo "puro" con C ++ <<e un arsenale di metodi come finde substr. Era almeno una dozzina di righe e non era ancora in grado di gestire le virgole come delimitatori. Ho sostituito tutto quel codice goffo con una sola sscanfriga come sopra!

Snippet di lunghezza 132

#include<stdio.h>
int main(int c,char**v){while(--c){++v;printf("|%s|\n|%5s|\n|%-5s|\n|%.5s|\n|%5.5s|\n",*v,*v,*v,*v,*v);}return 0;}

O:

#include <stdio.h>

int main(int c, char **v)
{
    while (--c)
    {
        ++v;
        printf("|%s|\n|%5s|\n|%-5s|\n|%.5s|\n|%5.5s|\n", *v, *v, *v, *v, *v);
    }

    return 0;
}

Le funzioni printf, sprintf, fprintfspecificatori ecc formato utilizzare per definire la larghezza e imbottitura dell'uscita.

Compilare ed eseguire quanto sopra usando gli argomenti della riga di comando per vedere i vari output:

> main xyz 123456
|xyz|                                                                                                                                                
|  xyz|                                                                                                                                              
|xyz  |                                                                                                                                              
|xyz|                                                                                                                                                
|  xyz|                                                                                                                                 
|123456|                                                                                                                                             
|123456|                                                                                                                                             
|123456|                                                                                                                                             
|12345|                                                                                                                                              
|12345| 

Notare che l' .5output per l'identificatore limita al massimo cinque caratteri, mentre il primo 5assicura che l'output sia di almeno cinque caratteri, -indicando l'allineamento a sinistra. La combinazione di questi imposta l'output a esattamente cinque caratteri.

x86 Codice macchina

factoid:

x86 Machine Code è la versione assemblata di x86 Assembly che il processore esegue effettivamente. È stato sviluppato quando la memoria e lo spazio di archiviazione erano costosi ed è stato progettato per essere un po 'retrocompatibile fino all'Intel 8008. Mantenere il codice eseguibile piccolo era uno degli obiettivi e utilizza istruzioni di lunghezza variabile e un'architettura CISC per aiutare raggiungere questo obiettivo (che ha avuto lo svantaggio di rendere più complicato migliorare le prestazioni sui processori moderni). Questo, insieme alla natura spoglia dell'assemblaggio e del codice macchina in generale, offre ai programmi x86 la capacità di essere estremamente compatto.

Lunghezza 1:

Ora per il primo programma:

0xC3

Apri un editor esadecimale, inserisci quel byte e salvalo come test.com.

Ora hai un programma MS-DOS valido che ritorna immediatamente senza fare nulla, poiché 0xC3 è l'istruzione 'RET'. Ciò mostra tuttavia un altro aspetto interessante per giocare a golf con x86: il formato di file .com. Questo formato eseguibile non ha assolutamente intestazione: il file viene semplicemente caricato in memoria a partire dall'indirizzo 0x100 e quindi l'esecuzione viene avviata a 0x100. Questo significa che nessun byte sprecato in metadati!

Lunghezza 2:

Il nostro prossimo programma:

0x4D 0x5A

o "MZ" in ASCII.

Ok, ho barato un po ', non è davvero un programma utile, poiché corrisponde alle istruzioni

DEC     BP
POP     DX

Che non sono effettivamente utili per l'avvio di un programma .com. In effetti, questo è il punto centrale di questi due valori: nessun file .com ragionevole dovrebbe iniziare con loro! I file .com avevano dimensioni limitate a 65280 byte (64 KiB - 0x100), quindi quando sono stati necessari programmi più grandi, è stato necessario sviluppare un nuovo formato. Questo era il formato di file .exe, che ha un'intestazione. Tuttavia, MS-DOS doveva mantenere l'estensione .com su alcuni componenti per la compatibilità con le versioni precedenti, quindi aveva bisogno di un modo per rilevare se un file .com era davvero un file .exe. Hanno scelto la puntura "MZ" come questo numero magico, e fino ad oggi, se apri un file .exe (o .dll) di Windows in un editor esadecimale, vedrai che iniziano con quei due byte. Mi diverte che anche il più moderno programma Windows inizi con un limite di compatibilità degli anni '70.

Lunghezza 3:

Ora per un ciclo infinito:

41 E2 FD

Che si traduce in

start:
inc cx
loop start 

Questo programma incrementa il valore di CX (che sarà> 0 per cominciare), quindi esegue l'istruzione loop. Loop è un eccellente esempio di istruzione CISC poiché combina 3 semplici operazioni in un'unica operazione speciale: diminuisce il valore di CX, controlla se è 0 e salta all'etichetta di destinazione in caso contrario. Esistono anche forme di loop che controllano altri flag oltre alla fine quando CX è 0. Avremmo potuto fare semplicemente "jump start" per un loop infinito di 2 byte, ma questo era più interessante.

Lunghezza 4:

Un programma che è minimamente utile:

40 CD 10 C3

Tradotto in assembly:

inc ax    ; 1 byte
int 10h   ; 2 bytes
ret       ; 1 byte

Questo programma imposta la console su 40x25 caratteri, cancella lo schermo, quindi torna alla riga di comando. AX è impostato sulla modalità video che vogliamo (1), quindi viene chiamato l'interrupt 10h del BIOS per impostare effettivamente la modalità video e cancellare la finestra, prima di tornare. Aspettatevi di vedere più di questi interrupt del BIOS in futuro.

Lunghezza 5:

Ora possiamo implementare un programma di pausa:

B4 01 CD 21 C3

Tradotto in assembly:

mov ah,1  ; 2 bytes
int 21h   ; 2 bytes
ret       ; 1 byte

Questo programma dice al BIOS di attendere che un tasto venga premuto e lo riecheggia sullo schermo prima di tornare. Ciò dimostra anche come su x86, alcuni dei registri possano essere parzialmente letti o scritti. In questo caso, impostiamo il byte superiore di AX (AH) su 1. Su processori a 32 bit, è anche possibile operare sui 16 bit bassi senza influire sui 16 bit superiori. Questa capacità di modificare registri parziali può essere utile per i programmatori di assembly, ma presenta degli svantaggi per i moderni processori che cercano di eseguire l' esecuzione fuori servizio , poiché possono introdurre dipendenze di dati falsi.

Lunghezza 9:

Ora per visualizzare effettivamente l'output:

68 00 B7 07 AB 40 79 FC C3

Tradotto in assembly:

; These two instructions set up ES, the 'extra segment'
push 0xb700 ; 3 bytes
pop  es     ; 1 byte
label:
stosw       ; 1 byte, Store Word - Copy AX to [ES:DI] then add 2 to DI
inc  ax     ; 1 byte
jns  label  ; 2 bytes, Jump Not Signed - Jump unless the sign flag is set (when inc AX yields 0x8000
ret         ; 1 byte

L'output è il set di caratteri predefinito ripetuto in diversi colori. Il byte basso di AX è il codice carattere e il byte alto specifica i colori da usare.

I programmi a 16 bit potevano indirizzare solo fino a 64 KiB direttamente. Per ovviare a questo, l'x86 utilizzava "segmenti" - registri speciali che sarebbero stati moltiplicati per 16 e aggiunti a tutti gli accessi alla memoria per dare 20 bit di memoria indirizzabile. Un programma potrebbe cambiare i valori di questi registri di segmento per accedere a più memoria - o aree speciali di memoria: questo programma modifica il segmento aggiuntivo per scrivere sulla memoria video. Diversi tipi di accesso alla memoria hanno utilizzato registri di segmenti diversi, consentendo a codice, dati e stack di essere accessibili contemporaneamente in diversi blocchi di memoria. Il segmento predefinito potrebbe anche essere ignorato per molte istruzioni.

Lunghezza 20:

Facciamo qualcosa di riconoscibile - useremo 'Rule 90' ​​per disegnare triangoli Sierpinski.

B0 13 CD 10 68 0F A0 1F AC 31 C2 88 94 3E 01 87 D3 93 EB F4

Nel montaggio:

mov al,13h      ; 2b
int 10h         ; 2b - Set the video mode to 13h

push    0xA00F  ; 3b
pop     ds      ; 1b - Set the data segment to video memory

start:          ; This loop runs 'Rule 90' to draw Sierpinski triangles
lodsb           ; 1b - load al with [ds:si] then increment si

xor     dx,ax   ; 2b - xor the left and right values of the previous row of pixels
mov     [si+318],dl ;4b - store result to memory

xchg    dx,bx   ; 2b - swap register values
xchg    ax,bx   ; 1b - swapping with ax is 1 byte shorter

jmp     start   ; 2b - infinite loop

Uscita campione:

Per questo programma, utilizziamo la famosa "Modalità 13", una modalità grafica che ha una risoluzione di 320x200 con 256 colori. È stato usato da molti popolari giochi DOS , come Doom.

Lunghezza 21

Vediamo chi ha prodotto la CPU su cui siamo in esecuzione.

0F A2 66 60 BB EE FF B9 0C 00 8A 17 43 B4 02 CD 21 E2 F7 FF E1

Tradotto in assembly:

cpuid         ; 2b  CPU ID - retrieve processor information based on the value in AX. For AX=0,
              ;     the 12 bytes in EBX, ECX, and EDX are loaded with a vendor identification string
pushad        ; 2b  Push all registers on the stack (32 bit version)
mov  bx,0xffee; 3b  Start of the vendor identification string on the stack
mov  cx,12    ; 3b  12 characters to print
print:    
mov  dl,[bx]  ; 2b  Character to print
inc  bx       ; 1b  Advance string position
mov  ah,2     ; 2b  Set AH to the 'Print character to STDOUT' value
int  21h      ; 2b  Call the bios interrupt to print
loop print    ; 2b  Decrement CX and jump if it is not zero
jmp  cx       ; 2b  Instead of restoring the stack, just jump right to the exit point

Uscita campione:

c:\misc>cpuid.com
GenuineIntel

Questo programma utilizza l'istruzione CPUID per ottenere informazioni sul processore su cui è in esecuzione, in particolare sulla stringa di identificazione del fornitore. La maggior parte delle persone vedrà "GenuineIntel" o "AuthenticAMD", a meno che non abbiano un produttore di CPU non comune o siano in esecuzione su determinate macchine virtuali.

Lunghezza 26

Ora possiamo fare animazioni interessanti

B0 13 CD 10 C4 07 BB 40 01 59 99 89 F8 F7 F3 31 D0 AA E2 F6 26 FE 05 47 EB FA

In Assemblea

mov al,13h     ;2b
int 10h        ;2b Enter Video Mode 13h

les ax,[bx]    ;2b Set ES to (roughtly) video memory
mov     bx,320 ;3b Set up  BX asdivisor
pop     cx     ;1b Zeroize CX

start:
cwd            ;1b Sign extend AX to DX, AX will never have the sign bit set so this zeroizes DX in 1 byte
mov     ax,di  ;2b Copy video memory pointer
div     bx     ;2b Divide by width to get AX = Y pos, DX = X pos
xor     ax,dx  ;2b X pos ^ Y pos
stosb          ;1b Store and increment video pointer
loop    start  ;2b CX starts at 0, so this will loop until it wraps around

cycle:
inc     byte [es:di];3b Increment value in video memory to animate
inc     di     ;1b Increment video memory pointer
jmp     cycle  ;2b Infinite loop 

E l'output sarà simile al seguente:

La funzione X pos ^ Y pos produce un frattale interessante, specialmente se animato

Lunghezza 27

Non solo puoi generare testo e grafica in un piccolo programma x86 .com, ma puoi anche generare suono e musica:

BA 31 03 B0 3F EE BA 30 03 B0 93 EE B4 01 CD 21 3C 1B EE 3C 1B B0 7F EE 75 EC C3

Nel montaggio:

    mov dx,0x331            ; value for the midi control port
    mov al,0x3F             ; command value to set midi mode to UART
    out dx,al               ; output the command to the midi control port
play_loop:
    mov dx,0x330            ; value for the midi data port
    mov al,0x93             ; midi instrument value (piano)
    out dx,al               ; output to midi data port
    mov ah,1
    int 0x21                ; read character from stdin, with echo
    cmp al,27               ; test if it is escape
    out dx,al               ; output the ascii value as the midi note to play
    mov al,0x7F             ; note duration
    out dx,al               ; output note duration
    jne play_loop           ; loop if escape was not pressed
    ret  

Questo programma utilizza la scheda midi per trasformare la tastiera in un piano. Per fare ciò, la scheda midi è impostata sulla modalità UART, che suona le note midi non appena vengono ricevute. Successivamente, il programma attende la pressione di un carattere e genera il valore ASCII come nota sulla scheda midi. Il programma funziona fino a quando non viene premuto Esc.

Lunghezza 29

Usiamo un sistema di funzioni iterate per generare un frattale Dragon Curve:

B0 13 CD 10 89 D0 01 CA 29 C1 D1 FA D1 F9 73 03 83 E9 7A B4 01 CD 16 B8 02 0C 74 E6 C3

Tradotto in assembly:

mov  al,13h
start:
int  0x10    ; This does double duty, setting the video mode to 13h at program start,
             ; and calling the 'draw pixel at coordinates' interrupt when looping
mov  ax,dx   ; The next couple instructions are our IFS, the algorithm is aproximately
add  dx,cx   ; f(y) = 0.5x + 0.5y
sub  cx,ax   ; f(x) = 0.5x - 0.5y OR f(x) = 0.5x - 0.5y - 1
sar  dx,1    ;
sar  cx,1    ;
jnc  skip    ; This jump handles pseudo-randomly switching between the two functions for x,
             ; based on if the previous value of x was odd or not.
sub  cx,122  ; Magic number, chosen since it provides sufficent 'randomness' for a filled in
             ; fractal and a good scale to the fractal. 102 and 130 also work.
skip:
mov  ah,1
int  0x16    ; Get keyboard state, zero flag will be set if no key has been pressed
mov  ax,0xC02; Set up AH for the draw pixel function when int 0x10 is executed,
             ; AL = color, CX = column, DX = row
jz   start   ; Loop if a key hasn't been pressed
ret  

Produzione:

Premendo un tasto non di controllo, il programma verrà chiuso. Questo è basato su Fire Coral di Desire su Pouet.net.

Lunghezza 52

Questo programma è un po 'una doppia funzionalità, mostra un po' del coprocessore a virgola mobile x87 e il codice di auto-modifica.

B3 07 D9 E8 B1 11 DE 0E 32 01 E2 FA BE 0A 24 56 B1 09 DF 34 AC D4 10 
86 E0 05 30 30 50 E2 F5 44 B4 2E 50 89 E2 B4 09 CD 21 FE 06 03 01 4B
75 D2 CD 20 0A 00

Quando eseguito, il programma produrrà diverse costanti matematiche:

1.00000000000000000
3.32192809488736235
1.44269504088896341
3.14159265358979324
0.30102999566398120
0.69314718055994531
0.00000000000000000

Questi sono One, Log2 (10), Log2 (e), Pi, Log10 (2), Log e (2) e Zero.

Nel montaggio:

org 100h

mov     bl,7         ;Counter for the total number of constants to print
start:
fld1                 ;Floating point constant to load on the FP stack,
                     ;start with 1 since it's op-code is the lowest

mov     cl,17        ;Multiply the constant by 10, 17 times to get the
mult:                ;printing part as an integer
fimul   word[ten]
loop    mult

mov     si,10+'$'*256;ASCII new line (10) and the end-of-string ($)
                     ;characters. These are used both as
push    si           ;a constant memory location, and stored to the
                     ;stack to format and printing

mov     cl,9         ;print 18 digits (9 pairs)
fbstp   [si]         ;store the integer part of the floating point
                     ;number on top of the FP stack as a packed
                     ;binary-coded decimal number (1 digit/nibble),
                     ;and then pop the number off the FP stack

convert:
lodsb                ;load a pair of packed digits

db 0xd4,16 ; AAM 16  ;ASCII Adjust For Multiply instruction using
                     ;non-standard base 16. This puts AL/16 in AH,
                     ;and AL%16 in AL, unpacking the digit pair.

xchg    ah,al        ;Swap the digit order
add     ax,'00'      ;Convert the digits to ASCII values
push    ax           ;Store digits on the stack
loop    convert

inc     sp           ;AX now holds the 1st 2 digits to print,
mov     ah,'.'       ;so to insert a decimal point, the 2nd digit
push    ax           ;is replaced with a '.', the stack pointer
                     ;is adjusted to overwrite 1 byte, and then
                     ;AX is pushed on the stack

mov     dx,sp        ;Load DX with the start of the print string
mov     ah,9         ;Load AH with the 'Print String' constant
int     21h          ;Call the 'Print String' interrupt to display
                     ;the constant

inc     byte[start+1];Self-modifying code - increment the load
                     ;floating point constant op-code to iterate
                     ;through all of them

dec     bx
jnz     start        ;Exit when all 7 constants have been printed
int     20h


ten: dw  10

La matematica in virgola mobile su sistemi x86 era originariamente gestita dal coprocessore x87 opzionale, non è stato fino al 486 che è stato spostato sullo stesso chip. L'x87 aveva anche un'architettura piuttosto diversa, era basato su stack, con 8 registri a 80 bit disponibili. Aveva anche una varietà di modalità di arrotondamento, precisione ed eccezioni mascherabili che potevano essere impostate.

Questo programma stampa i valori di sette costanti inseriti nei processori. Può sembrare strano che lo spazio delle istruzioni venga sprecato su costanti semplici come 0 e 1, ma tieni presente che il set di istruzioni è stato creato quando la memoria era piccola e queste istruzioni sono in genere 2 byte più piccole di operazioni equivalenti. Il programma utilizza anche un'istruzione oscura, FBSTP -'Store BCD Integer and Pop '. Ai tempi dello sviluppo di x86, le operazioni sui numeri BCD erano più comuni e x86 / x87 ha diverse istruzioni specifiche per semplificare la matematica BCD, come l'istruzione AAM "ASCII Adjust for Multiple" utilizzata anche nel programma.

Nel modello di memoria non protetto utilizzato dai primi programmi x86, non vi è alcuna distinzione tra dati e codice. Per questo motivo, è facile scorrere le istruzioni "Carica costante" codificate in sequenza semplicemente incrementando il valore appropriato.

Lunghezza 64

Pubblicando in modo incrociato la mia partecipazione alla Mandelbrot Challenge , è possibile scrivere un programma che visualizza un frattale Mandelbrot a colori 320x200 in soli 64 byte.

B0 13 CD 10 C4 07 99 89 F8 B9 40 01 F7 F1 83 E8 64 FE CE 31 DB 31 F6 
89 F5 0F AF F3 01 F6 0F AF DB 70 19 0F AF ED 70 14 01 EB 70 10 29 EB
29 EB C1 FB 06 01 D3 C1 FE 06 01 C6 E2 DB 91 AA EB C6

Nel montaggio:

mov al,13h ; set up graphics mode 13
int 10h

les ax,[bx]; trick to set video memory

FillLoop:
cwd
mov ax,di  ; di is the current position on screen
mov cx,320 ; convert di int x,y screen coordinates
div cx     ; CX is the iteration counter, exit the loop if it hits
           ; zero before the value escapes.
sub ax,100 ; center the fractal vertically
dec dh     ; center the fractal horizontally

xor bx,bx
xor si,si

MandelLoop: ; Fairly standard Mandelbrot routine,
mov bp,si   ; exits if the values overflow
imul si,bx
add si,si
imul bx,bx
jo MandelBreak
imul bp,bp
jo MandelBreak
add bx,bp
jo MandelBreak
sub bx,bp
sub bx,bp

sar bx,6   ; We use fixed point math with the lowest 6
add bx,dx  ; bits being the fractional portion, so this
sar si,6   ; rescales the values after multiplication
add si,ax

loop MandelLoop

MandelBreak:
xchg ax,cx ; Write the escape itteraction as the color
stosb
jmp FillLoop

Il risultato finale è questa immagine:

Questo programma utilizza la matematica a virgola fissa per generare il frattale, poiché richiede meno byte. I 6 bit più bassi dei registri a 16 bit sono considerati la parte frazionaria del numero e i valori vengono riscalati dopo essere stati moltiplicati.

Haskell

Potresti voler leggere dal basso verso l'alto. A volte mi riferisco a frammenti inferiori, ma mai a quelli superiori, quindi potrebbe aiutare a capire.

Lettori che non conoscono Haskell: sono chiaro? Quando non sono chiaro? Non so dirlo.

Lunghezza 86 frammento

Un'istanza pieghevole per la nostra struttura di dati dell'albero (snippet 23). Foldable è una classe di tipo - come in, una classe (/ gruppo) di tipi. Questi sono paralleli alle interfacce in Java. Si generalizzano essenzialmente sui tipi, unificando tipi che hanno caratteristiche comuni; ad esempio, possono essere aggiunti insieme ( Monoid), contenitori (Functor ), possono essere stampati come testo ( Show, che abbiamo già incontrato, nella showfunzione) e così via. Questo unifica tipi di dati che sono simili a una lista in quanto possono essere ripetuti o appiattiti in una lista.

In questo frammento, definiamo l'istanza definendo foldr, che essenzialmente scorre il tipo di dati da destra a sinistra. Ora possiamo usare un sacco di codice generale pre-scritto. Innanzitutto, definiamo una funzione di supporto per ottenere un albero singleton, per evitare tutto il disordine:s a = N E a E . Adesso:

sum (N (s 3) 7 (N E 5 (s 8))     === 23
product (N (s 3) 7 (N E 5 (s 8)) === 840
toList (N (s 3) 7 (N E 5 (s 8))  === [3,7,5,8]

e così via.

Ecco una foto del nostro albero:

7
| \
3  5
    \
     8

Lunghezza frammento 70

primes=sieve[2..] where
 sieve(p:xs)=p:sieve(filter(\x->x`mod`p/=0)xs)

Questo è un setaccio perfetto!

(nota: /=è cosa!= è in altre lingue)

Funziona definendo una funzione sieveche filtra l'elenco e mantiene solo i numeri che non sono divisibili per nessun precedente precedente. È definito in modo ricorsivo - to sieveè definito come dividere l'elenco in un primo elemento pe una coda, filtrare dalla coda qualsiasi numero divisibile per p, sieveil bit rimanente, collegarsi pall'inizio di quello e tornare.

Ancora una volta, stiamo lavorando con elenchi infiniti qui, ma il calcolo si interromperà nel tempo fino a quando non è necessario calcolare una quantità infinita di numeri primi.

take 4 primes === [2,3,5,7]

Lunghezza frammento 68

Finalmente un quine!

main=do putStr s;print s where s="main=do putStr s;print s where s="

Nella tua prima lettura, potresti pensare che all'output di questo quine manchino le virgolette, e perché dovresti scrivere putStruna volta e una volta print? Sembra lo stesso.

In Haskell, putStrè una funzione che stampa solo il contenuto della stringa che arriva a stdout; print, tuttavia, stampa le cose su stdout. Quindi, print 4è equivalente a putStr "4\n", ma putStr 4è privo di senso - 4non è una stringa! Quindi, quando printottiene un valore, prima lo converte in una stringa, quindi stampa quella stringa. Generalmente il modo per convertire le cose in stringhe è trovare il modo in cui le scriverei nel codice. Quindi, il modo in cui scriveresti la stringa abcin una stringa nel codice Haskell è "abc", quindi in print "abc"realtà stampa "abc", no abc.

_{Che fortuna ho abbastanza voti adesso, non dovrò giocare a golf queste cose}

Snippet lunghezza 33:

main=go 0
go n=do print n;go(n+1)

La cosa importante da notare è che non abbiamo usato un loop. Haskell non esegue il loop. Haskell recluta. Haskell non ha anelli. È più profondo di così: Haskell non ha nemmeno il flusso di controllo . Come potresti chiedere? Bene, non ne ha bisogno.

Dai dettagli. Questo programma stampa una sequenza infinita crescente di numeri interi, a partire da 0. goli stampa a partire dal suo input, quindi lo mainchiama 0.

doè un potere sintattico speciale di Haskell. In questo scenario, combina solo le azioni I / O, proprio come >>fa (vedi snippet 22).

Lunghezza frammento 26:

map f=foldr(\x y->f x:y)[]

Questo definisce la mapfunzione, probabilmente familiare a tutti, utilizzando foldr. Si noti che sebbene non abbiamo dichiarato mapil tipo, il computer in qualche modo sa che il suo tipo è (a -> b) -> [a] -> [b], cioè dato una funzione da aa b, e un elenco di as, restituisce un elenco dib s.

Come lo sapeva ?? ;-)

Snippet di lunghezza 25:

main=putStr"Hello World"

Lo standard Hello World. Nota i tipi: mainha tipo di IO ()e putStrha tipo diString -> IO () (una funzione da stringhe ad azioni I / O che non restituiscono nulla).

Snippet di lunghezza 23:

data T a=E|N(T a)a(T a)

Questa è una definizione standard di un albero. Quanto più facile di tutte quelle linee richieste per definire un albero in Java, C o qualsiasi altra cosa.

(vedi frammento 10)

Analizziamolo:

data- questa dichiarazione dichiara un tipo di dati. T a- un albero contenente elementi di tipo a. Questo è il tipo che stiamo definendo. =- ogni valore di T asarà uno dei seguenti, separati da una pipe |. E- uno dei possibili valori di T s- l'albero vuoto. N (T a) a (T a)- l'altro possibile valore di un albero - un nodo. Ogni nodo è costituito dal figlio sinistro ( (T a)), dall'elemento ( a) e dal figlio destro ( (T a)).

Snippet lunghezza 22:

main=putStrLn"y">>main

Una yesfunzione di Haskell . >>è un operatore che combina e sequenzia due azioni I / O. Ha tipo di >> :: IO a -> IO b -> IO b.

mainè definito in modo ricorsivo da solo, come l'azione I / O che prima stampa "y"e poi fa qualunque cosa mainstessa.

Lunghezza frammento 18:

fix f=r where r=f r

Una definizione migliore per fix. (Vedi snippet 14.) Il problema con la prima definizione fix f = f(fix f)è che ogni volta che chiamiamo fix f fixrichiami fix f, che richiama fix f, generando infinite copie dello stesso calcolo. Questa versione lo risolve definendo r(risultato) come risultato; come tale f r = r,. Quindi, definiamolo r = f r. Ora torniamo r.

Lunghezza frammento 17:

f n=product[1..n]

Questo è il modo funzionale di definire fattoriale.

Lunghezza frammento 16:

f n=(\x->x+x+x)n

(\x -> x + x + x)è un lambda (qualcuno ha pensato che \assomigli alla lettera).

(\x -> x + x + x) nè la lambda applicata n(è esattamente la stessa n + n + n).

fè la funzione moltiplica per tre (anche f = (*3))

Lunghezza frammento 15:

sum=foldl (+) 0

Questo definisce la sumfunzione usando una piega. Una piega è fondamentalmente un ciclo sugli elementi di una lista con un accumulatore.
foldlprende come argomenti una funzione fe un valore iniziale xper l'accumulatore e un elenco xs. La funzione fdovrebbe ottenere come input il valore dell'accumulatore precedente e il valore corrente dell'elenco e restituisce l'accumulatore successivo.
Quindi piega scorre i valori dell'elenco, applicando fl'accumulatore precedente, quindi restituisce l'ultimo accumulatore.

Un altro modo di pensare alle pieghe è come la piega 'inserisce' ftra i valori dell'elenco e con l'accumulatore iniziale in uno dei lati. Ad esempio, foldl (*) 1 [4,2,5]valuta 1 * 4 * 2 * 5.

Snippet di lunghezza 14:

fix f=f(fix f)

Il ycombinatore. Di solito è chiamato fixperché trova il punto fisso dell'equazione f x = x. Nota che a x = infinite loopvolte può anche essere una soluzione, quindi fix (\x -> x^2 + 5*x + 7)non risolverà l'equazione x^2 + 4*x + 7 = 0ma restituirà invece un ciclo infinito.

Puoi anche notare che non sempre x = infinite loopè una soluzione, a causa della pigrizia di Haskell.

Questa versione è una perdita di tempo e spazio; lo ridefiniremo in uno snippet più lungo.

Snippet di lunghezza 13:

f=sum.map(^2)

Questo definisce la funzione f che ha dato un elenco restituisce la somma dei suoi quadrati. È la funzione composizione della funzione sum e la funzionemap(^2) , che a sua volta è la funzione map applicata alla funzione (^2) (il quadrato funzione ), che è a sua volta una sezione della funzione ^ (sezioni sono stati collocati a frammento 2, e composizione al frammento 3 ).

Come puoi vedere, le funzioni sono abbastanza importanti in un linguaggio funzionale come Haskell. In effetti, è stato detto che Haskell è il linguaggio con le funzioni di libreria più standard che ottengono funzioni come input o restituiscono funzioni come output (questo è comunemente noto come una funzione di ordine superiore .

A proposito, tecnicamente, ogni due o più argomenti- funzione è una funzione che restituisce funziona come uscite (questo è chiamato currying).

Snippet di lunghezza 10:

data B=T|F

Questa è una definizione di booleani di Haskell con nomi diversi. Il tipo booleano è chiamato B.
Questa definizione introduce due costruttori: true ( T) e false ( F).
Questo frammento di codice fondamentalmente dice al compilatore che ogni booleana ( B) o è vera ( T) o false ( F), o in altre parole, B=T|F.

In effetti, tutti i tipi di dati possono mai essere definiti in Haskell, quando in altre lingue il numero, i riferimenti e i tipi di dati dell'array richiedono un supporto speciale da parte del compilatore. In pratica c'è un supporto speciale in Haskell poiché sarebbe molto scomodo altrimenti, ma per esempio il Booltipo di dati è definito interamente in lingua.

Snippet di lunghezza 9:

main=main

Questo programma senza senso definirà mainprincipale. Poiché Haskell è pigro, i valori che richiederebbero un ciclo infinito per essere valutati possono essere usati liberamente se non utilizziamo il loro valore reale. Tali valori che contengono anelli infiniti, come il nostro main, sono chiamati "fondi".

Un fatto divertente è che il compilatore GHC Haskell è in grado di rilevare questo tipo di loop infiniti e di generare un'eccezione accettabile (!) Quando viene eseguito.

Lunghezza frammento 8:

f(x:_)=x

Questo definisce la funzione fche, dato un elenco non vuoto, restituirà la sua testa.

I pattern in Haskell sono come la sequenza di decompressione di Python, ma generalizzati per tutti i tipi. I pattern possono rifiutare o abbinare un valore e, se corrisponde, possono associare le variabili ai valori.

I modelli in questo frammento sono:

• _: il modello che corrisponde a qualsiasi cosa e non lega alcuna variabile.
• x: il modello che lega qualsiasi cosa e la lega alla variabile x.
• :: questo modello arriva ai modelli del bambino, cioè uno per la testa e uno per la coda. Se l'elenco non è vuoto, li abbina alla testa e alla coda.

La corrispondenza dei motivi è altamente generalizzata. In effetti, la sola definizione di nuovi tipi di dati introdurrà automaticamente schemi per lavorare con essi.

Snippet di lunghezza 5:

x=2:x

Whoa, c'è così tanto da spiegare su questo.

Prima di tutto, Haskell è pigro. Ciò significa che le sottoespressioni saranno valutate solo quando strettamente necessario.

Nota: questo frammento di codice non mostra l'assegnazione, ma la definizione. Haskell non ha un incarico.

Questo frammento di codice definito x, un elenco infinito composto interamente da 2. Di solito in altre lingue xdeve essere valutato prima che 2:xpossa mai essere valutato, ma in Haskell possiamo farlo.

Gli elenchi infiniti di Haskell sono una sorta di mix di iteratori e normali elenchi collegati: agiscono come entrambi (un'iterazione su un intervallo utilizzerà memoria costante, per esempio).

Snippet di lunghezza 4:

2:[]

Questo frammento codifica solo l'elenco singleton [2]. :è l' operatore Contro di Haskell. In effetti, la sintassi dell'elenco normale è solo zucchero sintattico per l'operatore contro e l'elenco vuoto letterale. Ciò si lega strettamente al modo in cui Haskell si occupa della corrispondenza dei modelli e dei tipi di dati (in particolare il concetto di costruttore).

Snippet di lunghezza 3:

f.g

In Haskell, .sta per composizione delle funzioni. Haskell può essere scritto in uno stile "privo di punti", che è caratterizzato dal non nominare argomenti di funzioni e invece .dall'operatore per manipolare il flusso di dati.

Snippet di lunghezza 2:

1-

Quando questo codice è racchiuso tra parentesi (per motivi sintattici) viene chiamato "sezione". È quindi una funzione che, dato un certo numero, "riempie" il punto vuoto e restituisce meno un numero. Questa nozione è talvolta utile in un linguaggio funzionale come Haskell, dove altrimenti sarebbe necessaria una lambda.

Lunghezza frammento 1:

1

In Haskell, 1può essere sia un Int, Float, Double, Worde così via. In effetti, puoi scrivere codice per definire una versione di 1qualsiasi tipo e usarlo liberamente.
questo viene fatto anche in JavaScript, Python e così via, ma a differenza di quelli, viene eseguito con la massima sicurezza del tipo.

factoid:

Inizialmente, il comitato di Haskell intendeva chiamare la lingua "Curry" dopo il nome di Haskell B. Curry, ma decise di cambiare il nome in Haskell perché potevano sorgere alcuni giochi di parole. Solo più tardi notarono la somiglianza di Haskell con "Pascal" e "Hassle"!

C #

C # è un mix divertente e folle di funzionalità di Java, C, Haskell, SQL e un sacco di altre lingue, e offre molte funzioni e API davvero interessanti. È anche conosciuto da queste parti per essere piuttosto prolisso, ma vedremo cosa possiamo fare!

Ignorerò il solito boilerplate richiesto:

class Program { public static void Main(string[] args) { ... } }

Lunghezza 1:

;

I comandi sono terminati con punto e virgola in C #! Una riga vuota è una sintassi perfettamente valida.

Lunghezza 5:

x=5f;

Quando si specificano i numeri letterali in C #, il compilatore supporrà che siano ints o doppi (in base al fatto che abbiano un punto decimale). Se si desidera utilizzare un valore letterale float, è necessario specificarlo aggiungendo 'f' al numero, altrimenti verrà lanciato in fase di esecuzione, sostenendo un leggero costo.

Lunghezza 7 (byte):

s=@"
";

Se si antepone una stringa letterale con un segno @, questa diventa una stringa letterale "alla lettera". I letterali stringa normali analizzano sequenze di escape come '\ n' in caratteri speciali, ma i letterali letterali no, consentendo di utilizzare il carattere barra rovesciata senza sfuggirlo. Possono anche includere ritorni di riga, come mostrato. Ciò potrebbe farti risparmiare qualche byte nel golf o rendere più leggibili i tuoi letterali di stringa multilinea. Fai attenzione al rientro incluso nella stringa.

Lunghezza 8:

()=>x=y;

Questa espressione è una funzione anonima. Restituisce un oggetto di tipo Actionche può essere passato in giro e anche chiamato come una funzione. Le funzioni anonime ereditano l'ambito in cui sono state dichiarate e trascinano con sé qualsiasi variabile locale in quell'ambito ovunque vadano.

Lunghezza 9:

(a)=>a.p;

Ecco un'altra funzione anonima che utilizza un parametro e un valore restituito. L'espressione restituisce un oggetto di tipo Func(Func stessa restituisce il tipo di a.p. Userai Funcmolto per interfacciarti con Linq.

Lunghezza 10:

enm.Any();

Questa è la nostra prima introduzione a Linq! Linq è un insieme di metodi di estensione che possono essere richiamati su qualsiasi oggetto enumerabile (implementando l'interfaccia IEnumerable) - like Arraye List. IEnumerable si avvale di una valutazione pigra: passa attraverso la collezione un oggetto alla volta, senza conoscere la collezione nel suo insieme - potrebbe persino essere infinita!

Ecco dove Anyentra: ritorna truese l'Enumerable contiene almeno 1 elemento. Molto meglio che calcolare l'intera lunghezza.

Lunghezza 11:

var a=1.5f;

La varparola chiave indica al compilatore di determinare automaticamente il tipo di a. ain questo caso verrà digitato come Single. Molto utile per il golf del codice, in quanto è di gran lunga più breve di quasi qualsiasi nome di tipo, anche se a molti non piace usarlo nel codice di produzione.

Lunghezza 15:

yield return 0;

Ecco un'affermazione folle che potresti avere meno familiarità. Sai che gli oggetti possono essere enumerabili ereditando IEnumerable, ma sapevi che le funzioni possono essere enumerabili? Dichiarare una funzione con un tipo restituito di IEnumerablee averla yield returntutte le volte che vuoi. Quando si ottiene un Enumeratore per la funzione, ogni chiamata a GetNextfarà eseguire al programma tutto il codice fino al successivo yield return, restituisce quel valore e quindi mette in pausa fino a quando non lo si fa avanzare di nuovo. Utilizzi yield breakper terminare l'iterazione.

Lunghezza 16:

[Obsolete]int a;

Questo frammento mostra un attributo. Un attributo è un tipo di tag che puoi applicare a qualsiasi dichiarazione nel tuo codice. Alcuni danno istruzioni al compilatore di fare determinate cose, come questa che emette un avviso obsoleto se chiami a. Puoi crearne uno tuo estendendolo Attributee puoi interrogarlo usando Reflection (più avanti, forse). Puoi andare meta e limitare il tipo di dichiarazioni su cui un attributo può essere usato con l' AttributeUsageattributo.

Lunghezza 17

c.Count(t=>t==3);

Ecco un pratico metodo da golf. Dato Funcche associa un elemento dell'enumerabile ca bool, restituisce il numero di elementi in ccui Funcrestituisce true. Molto più bello che scrivere un ciclo.

Lunghezza 18:

foreach(T t in c);

Questo è un ciclo per ogni. Con tutto questo parlare di cose enumerabili, questa è una struttura molto necessaria. foreachè zucchero sintattico che imposterà un Enumeratore per c(che deve essere enumerabile) e itererà attraverso di esso un elemento talla volta. È possibile modificare o esaminare ogni singolo elemento, ma la modifica della raccolta stessa invaliderà l'enumeratore.

Lunghezza 19

c.Select(t=>t.a/2);

Questa è la tua funzione "mappa", per i fan della programmazione funzionale. Select è un bel modo conciso per eseguire una conversione arbitraria (definita da un Funcpassato) su ciascun elemento di un enumerabile. Restituisce un IEnumerable che sputerà gli elementi "convertiti" quando lo ripeterai.

Lunghezza 21

Console.Write("Hi!");

Questa riga scrive del testo su stdout ed è probabilmente uno dei motivi principali per cui C # non è molto utilizzato per giocare a golf!

Lunghezza 23

typeof(T).GetMethods();

C # supporta una funzionalità molto potente chiamata Reflection. Reflection consente di esaminare la struttura del codice in fase di esecuzione. Ad esempio, questa chiamata restituirà una matrice di tutti i metodi sul tipo specificato. È possibile esaminare tali metodi, chiamarli o persino modificare i valori di campi e proprietà. Gli attributi (vedi Lunghezza 16) sono un buon modo per taggare parti del tuo codice da usare con Reflection.

Lunghezza 25

from t in c select t.a/2;

Quello è SQL? Nel codice C #? Molto vicino. Questa espressione fa la stessa cosa di Lunghezza 19.

Lunghezza 27

for(var l;;l=new object());

C # è un linguaggio garbage collection, il che significa che qualsiasi memoria allocata (utilizzando la newparola chiave) può essere rilasciata automaticamente purché non esistano riferimenti ad essa. Questo codice funzionerà felicemente per sempre anche se non ho mai liberato esplicitamente la memoria creata. La raccolta dei rifiuti comporta tuttavia dei costi: cerca nel Web per saperne di più.

Lunghezza 29

var e=Enumerable.Range(0,99);

Enumerable.Rangeè una funzione da golf potenzialmente utile. Restituisce una struttura che può essere enumerata e produrrà ogni numero nell'intervallo specificato, in ordine. Il secondo parametro è un conteggio, non un indice.

Lunghezza 31

public int pr{get;private set;}

Qui, possiamo mostrare una semplice "proprietà", una funzione OOP e un altro segno distintivo di C #. Se hai mai usato Java, probabilmente hai creato metodi 'get' e 'set' per un campo al fine di separare la loro accessibilità o eseguire il codice quando viene modificato. Bene, C # ti consente di dichiarare quel codice in cima al campo e anche di impostare modificatori di accesso separati per ottenere e impostare. Questo particolare frammento crea automaticamente un getter e un setter predefiniti, ma rende il setter privato.

Lunghezza 32

public static void m(this T o){}

Questo frammento mostra una funzionalità C # che è utile per il design delle API. Applicando il thismodificatore al primo parametro di un metodo statico, quel metodo diventa un metodo di "estensione". Una volta dichiarato questo, T.mora può essere chiamato su qualsiasi oggetto di tipo T come se fosse in realtà un metodo di T. Questo può essere usato per aggiungere nuove funzionalità a qualsiasi classe esistente, senza modificare o persino avere accesso al suo codice sorgente.

Lunghezza 38

int f(int a,ref int b,out int c){c=0;}

Questo metodo mostra diversi tipi di passaggio di parametri che puoi avere in C #. I parametri non modificati vengono passati per valore . I parametri con prefisso refvengono passati per riferimento: è possibile assegnare loro un oggetto completamente nuovo e lo riporteranno fuori dal metodo. I parametri con prefisso outsono come valori di restituzione aggiuntivi: è necessario assegnare loro un valore nel metodo e vengono eseguiti come parametri di riferimento.

Lunghezza 42

Console.Write("It is \{DateTime.Now()}.");

Il nuovo standard C # 6 può farti risparmiare alcuni caratteri quando devi produrre stringhe assemblate, usando l'interpolazione di stringhe. Questa funzione consente di scrivere qualsiasi espressione tra parentesi graffe all'interno di una stringa letterale e la stringa verrà automaticamente assemblata con i valori di quelle espressioni in fase di esecuzione.

Lunghezza 48

IEnumerable f(){for(int a=0;;)yield return a++;}

Sono appena abbastanza personaggi per fare qualcosa con uno scopo reale! Questo metodo utilizza alcune delle idee che abbiamo esplorato sopra per creare un Enumerable infinito che restituirà semplicemente gli interi, uno per uno, a partire da 0. Ricorda che C # impiega una valutazione pigra con Enumerables, quindi una sequenza infinita è perfettamente valida - puoi iterare tutta la sequenza desiderata e scoppiare in qualsiasi momento.

Lunghezza 56

int p{get{return mP;}set{mP=Math.Max(value,0);}};int mP;

Ecco un altro esempio di "proprietà" (vedi frammento 31). Qui, ho effettivamente definito diversi frammenti di codice per gete setpiuttosto che usare quelli automatici come prima. Questo esempio dimostra come è possibile utilizzare una proprietà per convalidare il valore assegnato a una variabile: qui il valore non può diventare inferiore a 0. Altri buoni usi delle proprietà includono la notifica di un evento quando un valore viene modificato o la ricostruzione dei valori memorizzati nella cache che potrebbe essere basato su questo.

Lunghezza 65

int v;public static implicit operator int(Program o){return o.v;}

Questa funzione si chiama cast implicito. È un po 'come un metodo di estensione in quanto è un codice statico che opera su una classe specifica (vedi snippet 32). Tuttavia, il cast implicito non viene usato chiamandolo - viene usato semplicemente trattando un Programoggetto come intero (es int i=new Program().). Quando lo fai, l'oggetto verrà convertito silenziosamente nel tipo in cui lo stai usando, in base al codice nel cast implicito. Le migliori pratiche dicono di farlo solo quando nessuna informazione viene persa a causa della conversione.

Giava

Lunghezza 44 frammento

Object a=System.out.append("Hello, World!");

Stampa Hello, World!su STDOUT.

Lunghezza 43 frammento

float[][][][][]a=new float[5][3][7][2][10];

acontiene 10 matrici che contengono ciascuna 2 matrici che contengono ciascuna 7 matrici che contengono ciascuna 3 matrici che contengono ciascuna 5 floats.

Lunghezza 42 frammento

interface A{static void main(String[]a){}}

Un programma completo Poiché tutto in un interfaceè intrinsecamente public, possiamo omettere la parola publicdal metodo principale.

Lunghezza 36 frammento

class A{class B extends A{B.B.B b;}}

Aha una classe interiore B. Questo significa che possiamo dichiarare una variabile di tipo A.B.

Ma Bè una sottoclasse di A, il che significa che ha tutti i metodi, i campi e le classi interne di A. Pertanto, possiamo fare riferimento anche al tipo B.B.

In questo codice, facciamo un ulteriore passo avanti e forniamo Buna variabile di istanza di tipo B.B.B.

La morale: seguire domande a caldo su SO può insegnarti molte tecniche interessanti, anche se inutili.

Lunghezza 35 frammento

l.stream().map("a"::equals).count()

Se lè un elenco di stringhe, questo ci dice quante di esse sono uguali "a".

Lunghezza 34 frammento

public static void main(String[]a)

Firma del metodo del metodo principale di un programma. Ancora altri 11 personaggi e possiamo creare un programma completo!

Lunghezza frammento 33

enum D {NORTH, EAST, SOUTH, WEST}

NORTH, EAST, SOUTH, E WESTsono tutte le costanti di tipo D.

Lunghezza 32 frammento

Files.readAllBytes("hello.txt");

Legge un intero file, restituendo un byte[]contenuto.

Lunghezza frammento 31

new String(new char[]{'h','i'})

Equivalente a "hi". Utile se la "chiave è rotta.

Lunghezza 30 frammento

new JFrame().setVisible(true);

Crea una nuova cornice visibile, in cui è possibile posizionare altri componenti.

Lunghezza frammento 29

throws ClassNotFoundException

Forza tutti i metodi che lo chiamano a usare un blocco try- catch, oppure a passare l'errore nello stack. Le eccezioni verificate sono una delle decisioni più controverse dei progettisti Java.

Lunghezza frammento 28

int f(int x){return f(x-1);}

Questa funzione non è attiva per sempre; infatti, su un tipico computer ci vuole meno di un secondo. Grazie, Stack Overflow.

Lunghezza del frammento 27

Object a=new String[]{"a"};

Crea un nuovo array di stringhe.

Lunghezza 26 frammento

Object.class.newInstance()

Crea un nuovo Object.

Lunghezza frammento 25

((Supplier)()->-~0).get()

È meglio evitare costanti codificanti. Questo è un modo orientato agli oggetti per ottenere il valore 1senza usare costanti diverse da 0.

Lunghezza 24 frammento

(Function<Long,?>)x->x+1

La funzione successiva.

Snippet di lunghezza 23

l.removeIf(x->x%10==0);

Se lè un elenco di numeri interi, questo rimuove tutti i valori divisibili per 10.

Lunghezza frammento 22

int i=(new int[7])[5];

Crea un nuovo array di sette numeri interi e ottiene il quinto elemento.

Lunghezza frammento 21

Arrays.asList(2L,"a")

Crea una ArrayList con questi elementi.

Lunghezza 20 frammento

System.out.print(s);

Stampe s.

Lunghezza 19 frammento

import java.util.*;

Permette l'uso di classi come concisa List, Map, Scanner, Timer, e Random.

Lunghezza 18 frammento

Math.addExact(x,y)

Aggiunge due numeri interi xe y. Se si verifica un overflow, il metodo genera un'eccezione anziché fornire una risposta errata.

Lunghezza frammento 17

Double.MIN_NORMAL

Il più piccolo valore positivo di tipo double, dove il bit iniziale del significato è 0.

Lunghezza 16 frammento

System.in.read()

Legge un singolo personaggio dalla console.

Lunghezza frammento 15

Long.reverse(x)

Inverte i bit nella rappresentazione binaria di x.

Lunghezza frammento 14

int x=050+120;

xè ora 160, poiché tutto ciò che inizia con 0viene trattato come ottale.

Lunghezza 13 frammento

private C(){}

Un costruttore privato impedisce ad altre classi di istanziarlo. Questo modello viene utilizzato dalle classi Systeme Math, tra gli altri. Un costruttore privato può anche essere usato per imporre il Singleton Pattern.

Lunghezza 12 frammento

static class

Consente la creazione di classi interne senza una classe esterna chiusa - una soluzione a un problema affrontato da molti programmatori .

Lunghezza 11 frammento

throw null;

Spesso è necessario lanciare un NullPointerException, ma è anche abbastanza prolisso. Questa è un'alternativa molto più semplice.

Lunghezza frammento 10

int[]a,b[]

Definisce due variabili: ae b. aè di tipo int[]ed bè di tipo int[][].

Lunghezza frammento 9

switch(x)

Va in un luogo, a seconda del valore di x.

Lunghezza 8 frammento

break a;

Scoppia fuori dal blocco etichettato a.

Lunghezza frammento 7

goto x;

La gotoparola chiave è riservata in C, C ++ e Java. Se xè un'etichetta, questo codice invia il programma all'etichetta appropriata, in C e C ++. Ma è Java, innesca un misterioso RuntimeException. In effetti, non c'è modo di usare la gotoparola chiave in Java.

Lunghezza 6 frammento

\u003b

Termina una dichiarazione. Java è strano .

Lunghezza 5 frammento

a-=-a

Raddoppia asottraendo la sua negazione.

Lunghezza 4 frammento

a&=b

Imposta il valore di aa bit a bit e di ae b.

Lunghezza frammento 3

...

Qualsiasi numero di argomenti, consolidato in un array.

Lunghezza 2 frammento

<>

Consente al compilatore di capire quale tipo generico intendi probabilmente. Molto poco simile a Java.

Lunghezza 1 frammento

@

Indica un'annotazione per consentire la visualizzazione di ulteriori informazioni su metodi e classi.

factoid

In Java, i cicli infiniti a volte causano errori del compilatore. Ad esempio, il ciclo while(true);non può essere terminato senza uscire dal metodo, quindi qualsiasi codice successivo provoca un errore di "istruzione irraggiungibile". Come ha sottolineato @Optimizer, solo alcuni loop infiniti verranno catturati in questo modo.

Pitone

Ora a partire dal più recente per la tua convenienza! Per leggere la lunghezza 30 a partire dalla prima, vai alla cronologia delle revisioni.

Se qualcuno ha suggerimenti, sentiti libero di commentare.

Lunghezza 52:

i=0
while s[i-n:]:print(' '*n+s)[i:n+i];i+=1;i**7**7

Tratto dalla mia partecipazione alla sfida Fake Marquee Text . se ndevono essere impostati prima su una stringa e un numero intero. In realtà non funziona bene nell'interprete gratuito di Python 2 che stavo usando, quindi ho aggiunto parentesi in giro (' '*n+s)[i:n+i]e puoi vederlo funzionare nell'interprete Python 3 qui .

Lunghezza 43:

#-*-coding:rot13-*-
cevag h"Una fubg svefg"

In Python puoi codificare il sorgente con un codec specifico. Questo mostra come la fonte può essere scritta in Rot13. La sintassi generale è questo: # -*- coding: <codec-name-goes-here> -*-.

Qui è tradotto:

#-*-coding:rot13-*-
print u"Han shot first"

I uspecifica che la seguente stringa letterale è una stringa Unicode. Questo è necessario se vuoi che anche le tue stringhe siano in Rot13, altrimenti ogni stringa nella sorgente è facilmente leggibile nonostante la crittografia. In alternativa, puoi usare .encode("Rot13")dopo ogni stringa (non dimenticare di usare Rot13 anche su questo.) Secondo questo articolo , alcune codifiche alternative sono “base64 ″,“ uuencode ”,“ zlib ”o“ bz2 ″.

Lunghezza 33:

import cmath
print cmath.sqrt(-1)

Questo è il modulo di Python per numeri complessi (immaginari) . Questo stampa 1j, dal momento che Python è conforme agli standard di ingegneria e utilizza jcome unità immaginaria, anche se preferisco i, che è più comunemente usato in matematica e usando je kin aggiunta a iper i quaternioni , ma sto divagando. Leggi il bug / ordine di modifica qui (non verrà modificato).

Lunghezza 30:

f=lambda n:n*f(n-1)if n else 1

Ora definiamo la nostra funzione fattoriale usando la ricorsione e il se-altro ternario! Per quanto ne so, questo è golf come in Python. Potrebbe anche essere scritto in questo modo: in f=lambda n:n and f(n-1)*n or 1mostra un paio di operatori booleani di Python (e anche composto da 30 caratteri). Vedi lo snippet di lunghezza 15 per informazioni sulla lambdasintassi.

Lunghezza 29:

import math
math.factorial(7)

Trova il fattoriale di 7, di ritorno 5040.

Lunghezza 25:

import math
print math.pi

Il modulo matematico di Python fornisce molte utili funzioni e costanti. Ecco PI. Ritorni 3.14159265359. (Nel codice sopra, ho contato la nuova riga come carattere.)

Lunghezza 24:

f=lambda y:lambda x:x**y

Questo è un esempio di chiusura. La chiamata cube = f(3)renderà una funzione cubica che può quindi essere chiamata con la print cube(24)stampa 13824.

Lunghezza 19:

print"Hello World!"

Finalmente abbastanza spazio per stampare un po 'di output di base! Lo spazio non è richiesto qui, perché anche le virgolette e le parentesi sono delimitatori. printFunzionerà solo in Python 2, poiché Python 3 ha cambiato la funzione per essere chiamata come qualsiasi altra funzione. In Python 3, usa print("Hello World!"). Per ulteriori informazioni sulla funzione di stampa e sulla differenza tra Python 2 e 3, vedere Novità di Python 3.0 .

Lunghezza 16:

[x*3 for x in l]

Ancora una volta, assume lsia un elenco o qualsiasi altro oggetto iterabile come una stringa o un generatore. Questa affermazione è nota come comprensione dell'elenco . È molto più breve rispetto all'uso dello standard per la struttura ad anello. Qui, restituisce un elenco con tutti i numeri moltiplicati per 3. ANCHE, le stringhe possono essere moltiplicate! Quindi qualsiasi stringa nell'elenco verrà aggiunta (concatenata a se stessa) quel numero di volte.

Lunghezza 15:

import this #:)

Questo è in realtà un frammento di lunghezza 11, ma mi sono reso conto di aver dimenticato di mostrare l' uovo di Pasqua (fantastico) di Python ! L'importazione di questo modulo stampa The Zen of Python (Vedi Factoid.) Fatto interessante: il modulo è this.pystato codificato in rot13, che spero di presentare in seguito.

Lunghezza 14:

lambda x:x**.5

Questo definisce una funzione radice quadrata usando la lambdasintassi di Python per una funzione letterale. I letterali di funzione in Python possono contenere solo espressioni, non istruzioni. Questo lambda può essere assegnato a una variabile, passato a una funzione o eseguito in linea con (lambda x:x**.5)(9), che restituisce 3.0. L'uso di esponenti per una radice quadrata è un'alternativa all'importazione della sqrtfunzione nel mathmodulo.

Lunghezza 13:

1 if x else 0

Questo è un esempio dell'operatore se ternario di Python. Questo è stato aggiunto in Python 2.5 per scoraggiare i programmatori dall'implementarlo manualmente con operazioni booleane. Qui, 1viene restituito se viene xvalutato True, altrimenti 0viene restituito.

Lunghezza 12:

s=input(">")

Questo stamperà >per il testo del prompt e consentirà all'utente di inserire un valore. Python 2 interpreta qualunque valore sia inserito, quindi ogni stringa necessita di virgolette. Python 3 lo ha modificato, in modo che l'input immesso non venga interpretato automaticamente. Per inserire l'input senza interpretarlo in Python 2, utilizzare raw_input(). In Python 2, input()è equivalente a eval(raw_input()).

Lunghezza 11:

eval("2e3")

2e3è una notazione scientifica per il galleggiante 2 x 10³. La evalfunzione interpreta e valuta qualsiasi stringa come espressione. In questo caso, ha lo stesso risultato dell'uso del valore letterale 2e3o float("2e3"). Ritorna 2000.0.

Lunghezza 10:

range(013)

Questa funzione restituisce un elenco di numeri interi dal 0valore ottale 013, che è 11(esclusivo), il che significa che l'elenco sarà [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]. La funzione richiede fino a tre parametri simili alla slicefunzione di che abbiamo recensito in precedenza: range(start, stop[, step]). La differenza è che con un solo parametro il parametro rappresenta il valore di arresto.

Nota che Python 3.x non ha equivalenti. È rangesimile, ma in realtà è lo stesso di Python 2 xrange, restituendo un oggetto generatore invece di un elenco.

Lunghezza 9:

a,b = b,a

Assegnazione multipla. Questa è una funzionalità semplice ma elegante, che consente di assegnare più valori contemporaneamente. Nello snippet fornito, scambia ae b. Che dire dell'ordine di valutazione, chiedi? Tutte le espressioni a destra dell'operatore di assegnazione vengono valutate prima di eseguire qualsiasi assegnazione. Questo batte molte lingue che richiedono un'assegnazione intermedia a una variabile temporanea.

Lunghezza 8:

#comment

Sai cos'è ... Aspetta, no? Sai, quelle cose che ti permettono di digitare un testo arbitrario per descrivere una riga di codice, facilitando la comprensione? No? Oh ok...

Lunghezza 7:

l[::-1]

Supponendo nuovamente che lsia un elenco, questo restituirà l'elenco in ordine inverso. Il terzo argomento indica la dimensione del passo. Dal momento che tutti e tre gli argomenti possono essere valori negativi, una dimensione del passo negativa significa iterare in ordine inverso. Il primo e il secondo argomento vuoti mostrano che stiamo ripetendo l'intera lista.

Stiamo arrivando a dove possiamo iniziare a usare alcuni costrutti più interessanti!

Lunghezza 6:

l[-6:]

Questa si chiama operazione slice . Se lè un elenco, verrà restituito un nuovo elenco contenente gli ultimi sei elementi lcome elenco. -6rappresenta l'indice iniziale (6 dalla fine) e i due punti significano continuare fino all'indice finale dopo di esso (che abbiamo lasciato vuoto, quindi fino alla fine). Se la nostra lista contenesse i numeri da 1 a 10, ciò ritornerebbe [5, 6, 7, 8, 9, 10].

Lunghezza 5:

1<x<5

Una delle fantastiche funzionalità di Python ti consente di concatenare gli operatori di confronto. In molte altre lingue, questo verrebbe digitato come 1 < x && x < 5. È ancora meglio se si considerano più confronti: 1 < x < y < 5è perfettamente valido!

Lunghezza 4:

0256

Un numero intero con uno zero iniziale è un valore ottale letterale. Questo è un bel trucco anche per l'offuscamento del codice. Questo restituisce il valore decimale 174. In Python 3.x, il valore ottale sarebbe scritto come 0o256.

Lunghezza 3:

`3`

Circondare un'espressione nei backtick è lo stesso dell'uso repr(), che restituisce la rappresentazione in forma di stringa di un oggetto. La funzione tenta di restituire la stringa in modo tale che quando viene passata come argomento alla evalfunzione, restituirà l'oggetto originale. E ' non è lo stesso che utilizzare str(), se i risultati sono a volte gli stessi. Per questo input, '3'viene restituito in entrambi i casi. Questo è uno dei miei preferiti per il codice golf!

Funziona solo in Python 2!

Lunghezza 2:

[]

Un elenco vuoto.

Lunghezza 1:

_

Il carattere di sottolineatura è un nome variabile usa e getta molto usato. Se stai usando una shell Python (interprete interattivo), tuttavia, contiene il risultato dell'ultima istruzione eseguita (e la restituirà di nuovo.) Inoltre, secondo questo thread , è anche usato per la ricerca della traduzione in i18n.

Factoid : Python è un linguaggio simile a Java e C. Fu costruito con una specifica filosofia di progettazione (tratta da " PEP 20 - The Zen of Python ":

• Bello è meglio che brutto
• Esplicito è meglio che implicito
• Semplice è meglio di complesso
• Complesso è meglio che complicato
• La leggibilità conta

Per questo motivo, sebbene i punti e virgola siano consentiti come delimitatore di istruzioni, in genere vengono omessi a favore dell'utilizzo di più righe per la leggibilità. Inoltre, il rientro di riga è molto importante!

JavaScript

Questo va dal più recente al più vecchio. Link per me stesso: [ modifica ]

Snippet di lunghezza 51:

console.log(require('fs').readFileSync(__filename))

A Node.JS questa volta, anche se non soddisferebbe alcun requisito "rigoroso", a causa della lettura del proprio codice sorgente.

Lunghezza frammento 50:

a=new XMLHttpRequest;a.open('GET','file');a.send()

Finalmente! Una richiesta AJAX (utilizzando Vanilla.JS ). Inizializziamo, apriamo e inviamo la richiesta, ma ho esaurito lo spazio per aggiungere gestori e effettivamente fare qualsiasi cosa con il risultato.

Snippet di lunghezza 49:

msg=new SpeechSynthesisUtterance('Hello World!');

Prepara una voce "Hello World!". Sarà un po 'più di lavoro per parlarne davvero. Possiamo anche regolare volume, intonazione, frequenza e accento. Vedi API di sintesi vocale su HTML5Rocks . Non ancora supportato da Firefox, sicuramente non IE .

Lunghezza frammento 48:

function repeat(){setTimeout(repeat,48)}repeat()

Simula setIntervalricorsivamente setTimeouting.

Lunghezza frammento 47:

module.exports=function MyModule(a) {this.a=a};

Di nuovo NodeJS, ma il principio è lo stesso ovunque in JS. Questa è una funzione di costruzione molto semplice, che crea un oggetto con una proprietà ( a). L'impostazione module.exportsesporta la funzione per usarla require().

Lunghezza 46 frammento:

canvas.getContext('2d').fillRect(46,46,46,46);

Ciò richiede un <canvas id="canvas"></canvas>elemento. Sfrutta il fatto che gli elementi con ID sono popolati come variabili globali, quindi l'elemento è accessibile come canvasda JS. Quindi lo riempiamo con un quadrato 46x46 a x = 46, y = 46.

Lunghezza frammento 45:

JSON.parse(require('fs').readFileSync('jsn'))

Torna al nodo. Qui, analizziamo un file JSON chiamato jsndalla directory corrente.

Lunghezza 44 frammento:

(a=document.createElement('a')).href="/url";

Basandosi sul n. 39. Ora creiamo un elemento e assegniamo un attributo. Tuttavia non è ancora nel DOM.

Lunghezza 43 frammento:

sq=[1,2,3,4,5].map(function(n){return n*n})

Crea una matrice dei primi 5 quadrati, usando map().

Lunghezza 42 frammento:

six="1+5",nine="8+1";eval(six+' * '+nine);

Questo funziona sullo stesso principio come questo , ma JS manca #definee così finisce più brutto. Restituisce, ovviamente, la risposta alla vita, all'universo e a tutto .

Snippet di lunghezza 41:

c=function(){var i;return function(){}}()

L'inizio di una chiusura. cè ora una funzione (quella interna) con accesso alla variabile interna i, ma non fa nulla.

Lunghezza 40 frammento:

$('p').click(function(){$(this).hide()})

Stiamo abbandonando totalmente quei paragrafi e usando jQuery.

Lunghezza 39 frammento:

script=document.createElement('script')

Questo è l'inizio dell'aggiunta di un nuovo script esterno. Crea un <script>elemento vuoto e mantieni un riferimento ad esso.

Lunghezza 38 frammento:

document.getElementsByClassName('abc')

Trova tutti gli .abcelementi nel documento. Certo, con jQuery, è solo $('.abc')...

Lunghezza frammento 37:

b=JSON.parse(JSON.stringify(a={3:7}))

Crea due oggetti identici, ma disaccoppiati a, e b. Se lo faresti

a={a:1};
b=a;
b.a=3;

finiresti con a=={a:3}, perché ae bpunta allo stesso oggetto. Usiamo JSON per disaccoppiarli.

Snippet di lunghezza 36:

(function f(){return "("+f+")()"})()

Un quine . Stampa il proprio codice sorgente.

Lunghezza frammento 35:

document.body.style.display="none";

Vedi # 32. Questo nasconde semplicemente il documento, senza sovrascrivere il contenuto.

Snippet lunghezza 34:

Object.prototype.toString.call(34)

La chiamata Object.prototype.toStringè un buon modo per dire il tipo di un oggetto. Mentre 34..toString()è "34", lo snippet è [object Number].

Snippet di lunghezza 33: (il merito per questo va a un utente anonimo )

+0%-0.&(v\u0061r=~void[{}<<!(0)])

Pensi che questo non sia JavaScript valido? Meglio provarlo ... (usa Chrome);)

Lunghezza 32 frammento:

document.body.innerHTML="hacked"

Halp! Hazxxors! Undici !! 11!

Snippet di lunghezza 31:

a=[];for(i=0;i<31;i++)a.push(i)

Non sto scherzando, ho aspettato così tanto tempo per poter effettivamente utilizzare un forloop! Questo crea un array da 0-30.

Lunghezza frammento 30:

new Date().getDay()==1?"S":"E"

Prima volta usando l'operatore ternario. Non potrei adattarmi più di questo in 30 caratteri, quindi sappiamo solo se oggi è domenica o qualcos'altro. : P

Lunghezza frammento 29:

Object.keys(window).push('i')

Object.keys(window)otterrà una matrice delle variabili globali (proprietà di window). .push()aggiungerà un elemento a quell'array. Pensi che questo sia l'equivalente di window.i=undefined? No!

Lunghezza frammento 28:

setTimeout("a=confirm()",28)

Attendere 28 millisecondi non è così utile, tranne per la creazione di un nuovo thread.

Snippet di lunghezza 27:

document.querySelector('a')

È un peccato che i nomi DOM siano così lunghi. Potrei ottenere solo un singolo link qui.

Lunghezza frammento 26:

JSON.stringify({twenty:6})

Vedi # 16. Ora otteniamo il vero JSON - una stringa.

Snippet di lunghezza 25:

new Badge("Good Answer");

Supponendo che Badge()sia una funzione di costruzione che accetta un argomento ... è stato appena creato un badge di buona risposta !

Lunghezza frammento 24:

do {alert(24)} while(!1)

In realtà non uso do..whilemolto, ma alcuni lo fanno. Se questo fosse un normale whileciclo, non avviserebbe nulla, perché è sempre falso. do..whilefunzionerà sempre almeno una volta, quindi vedremo 24.

Snippet di lunghezza 23:

window.parent==self.top

Tutti si riferiscono allo stesso oggetto, generalmente noto come window. Se chiamate una funzione normalmente, c'è anche this. Ecco 5 modi per accedere all'oggetto globale!

Snippet lunghezza 22:

for(i in self)alert(i)

Avvisa tutte le variabili globali. Capita di essere quello self==window. (Vedi il frammento successivo.)

Snippet di lunghezza 21:

"2"+1==21 && 2+1=="3"

Oh guarda, sono di nuovo le regole di casting di JS. Questa affermazione è vera, a proposito.

Snippet di lunghezza 20:

Math.random()<.5?0:1

Scegli un numero casuale da 0-1 e arrotondalo usando l'operatore ternario. Anche se sarebbe più facile da usare Math.round...

Lunghezza frammento 19:

[1,2,3].map(i=>i*i)

Questo è nuovo. Davvero nuovo. Utilizza le funzioni della freccia ES6 per calcolare i quadrati di 1, 2 e 3. Attualmente, sembra essere supportato solo da Firefox.

Lunghezza frammento 18:

location.href="/";

Come il n. 15, ma questa volta va sulla homepage di PPCG, non su SE.

Lunghezza frammento 17:

(function(){})()

È lo snippet del 14, ma meglio! Ora è un IIFE.

Lunghezza frammento 16:

obj={not:'json'}

Questo spiega uno dei miei animali domestici. Questo è un oggetto , non JSON ! JSON è un formato di scambio di dati basato su oggetti JavaScript, ma in un formato più rigoroso.

Lunghezza frammento 15:

open('//s.tk/')

Immaginalo. Apri la home page di SE, utilizzando il http://s.tk/ reindirizzamento.

Snippet di lunghezza 14:

function f(){}

W00t! Funzioni! Peccato che non ci sia spazio per fare nulla.

Snippet di lunghezza 13:

Math.random()

Genera un numero casuale da 0 a 1. Vuoi definire i tuoi limiti? Buona fortuna (Non proprio, è facile.)

Lunghezza frammento 12:

new Date<=12

Questa affermazione non è mai stata vera in JS. JS non è stato creato fino al '95 (vedi factoid), molto tempo dopo il 1/1/1970 00: 00: 00.012.

Lunghezza frammento 11:

Math.PI*121

L'area di un cerchio con raggio 11.

Snippet di lunghezza 10:

if('j')9+1