Notas

• Este hilo está abierto y desbloqueado solo porque la comunidad decidió hacer una excepción . Por favor, no use esta cuestión como prueba de que usted puede hacer preguntas similares aquí. Por favor, no crear adicionales escaparate preguntas.

• Esto ya no es un concurso de popularidad , ni las longitudes de fragmentos están limitadas por el recuento de votos. Si conoce este hilo de antes, asegúrese de familiarizarse con los cambios.

Este hilo está dedicado a mostrar características interesantes, útiles, oscuras y / o únicas que sus lenguajes de programación favoritos tienen para ofrecer. Esto no es un desafío ni una competencia, sino un esfuerzo de colaboración para mostrar tantos lenguajes de programación como sea posible.

Como funciona esto

• Todas las respuestas deben incluir el nombre del lenguaje de programación en la parte superior de la publicación, con el prefijo a #.

• Las respuestas pueden contener un (y solo un) factoide, es decir, un par de oraciones sin código que describan el lenguaje.

• Aparte del hecho real, las respuestas deben consistir en fragmentos de código, que pueden (pero no tienen que ser) programas o funciones.

• Los fragmentos no necesitan estar relacionados. De hecho, los fragmentos que están demasiado relacionados pueden ser redundantes.

• Como esto no es un concurso, todos los lenguajes de programación son bienvenidos, siempre que se hayan creado.

• Las respuestas que contienen más de un puñado de fragmentos de código deben usar un fragmento de pila para colapsar todo, excepto el factoid y uno de los fragmentos.

• Siempre que sea posible, solo debe haber una respuesta por lenguaje de programación. Esta es una wiki comunitaria, así que siéntase libre de agregar fragmentos a cualquier respuesta, incluso si no la ha creado usted mismo. Hay un fragmento de pila para comprimir publicaciones , que debería mitigar el efecto del límite de 30,000 caracteres.

Se deben editar las respuestas anteriores a estas pautas. Por favor, ayuda a actualizarlos según sea necesario.

Respuestas actuales, ordenadas alfabéticamente por nombre de idioma

$.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>

Mathematica

Es posible que desee leer esto de abajo hacia arriba, ya que ese es el orden en que se escribió, y algunas explicaciones se referirán a fragmentos anteriores o asumirán explicaciones de más abajo.

La lista está creciendo bastante larga. He comenzado a eliminar fragmentos menos interesantes, y comenzaré a omitir fragmentos ahora. Consulte el historial de revisiones para obtener una lista completa de fragmentos hasta 41. Para algunas gemas reales, consulte los fragmentos 81 , 64 , 44 , 23 , 19 , 12 y 8 .

Longitud 143 y 144 fragmentos

Finalmente ... He estado esperando esto por un tiempo (y he estado jugando al golf durante el mismo tiempo, así que no tengo que esperar aún más). Mencioné anteriormente que también puedes ecuaciones numéricas, y que también puedes resolver ecuaciones diferenciales. Quería mostrar un ejemplo no trivial de eso.

Considere un péndulo doble en una barra (es decir, un péndulo unido a otro). Cada barra tiene una unidad de longitud y cada uno de los dos pesos de péndulo tiene una unidad de masa. También he usado la unidad de gravedad para acortar la ecuación. El siguiente fragmento de 143 caracteres resuelve las ecuaciones de movimiento lagrangianas para dicho sistema (en términos de ángulos de péndulo y momentos angulares). Se puede encontrar una derivación en este PDF , aunque es un ejercicio bastante sencillo si está familiarizado con la mecánica lagrangiana.

Es bastante ilegible, porque tuve que jugar mucho 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}]

Lo bueno es que Mathematica muestra inmediatamente un diagrama en miniatura de cómo se ven las soluciones:

Está bien, pero eso es un poco cojo. Queremos saber cómo se ve realmente el movimiento de la péndula. Así que aquí hay un fragmento de 144 caracteres, que anima la péndula mientras traza la trayectoria del péndulo inferior:

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}

La animación resultante se ve así:

^{Tuve que hacer trampa levemente: si trazas más allá t = 30, ParametricPlotpor defecto usa muy pocos puntos de trama y la línea se vuelve bastante irregular. Pero la mayoría de las dinámicas interesantes ocurren después de ese tiempo, así que utilicé la opción PlotPoints -> 200para que la segunda mitad de la animación se vea más fluida. No es nada sustancialmente diferente, y la primera mitad parecería indistinguible de todos modos.}

Creo que este será mi último fragmento, a menos que se me ocurra algo realmente alucinante. ¡Espero que hayas disfrutado esto!

Fragmento de longitud 100

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

Estaba pensando en algunas Geofunciones agradables para el fragmento 100, pero finalmente encontré algo realmente ingenioso en Tweet-a-Program , que solo tuve que robar. Lo anterior genera un mapa solar de la Tierra muy bonito para la hora y el día actuales, al superponer una forma semiopaca del hemisferio nocturno sobre un mapa en relieve:

Longitud 81 fragmento

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

Prometo que es el último autómata celular. Pero eso justo allí es Wireworld en 81 caracteres. Esta vez no codifiqué la regla en un solo número, a) porque creo que sería ridículamente enorme (no me molesté en descifrarlo) yb) para mostrarle otro uso más CellularAutomaton. Esta vez, la regla simplemente se especifica como una función pura, que recibe una vecindad de celdas y devuelve el nuevo valor de la celda. Este es un enfoque mucho más factible para autómatas celulares con más de 2 colores / estados.

De todos modos, configuré el ejemplo de Wikipedia en i(dos relojes que generan señales y una puerta XOR) y lo dejé correr por unos 50 pasos:

Si está interesado, el trazado y la animación reales podrían haber sido el fragmento 77:

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

Fragmento de longitud 69

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

De vuelta a algo útil. Además de los sistemas normales de ecuaciones, Mathematica también puede resolver sistemas de ecuaciones diferenciales. Lo anterior es técnicamente solo una ecuación diferencial con condiciones de contorno, pero también puede proporcionarla como un sistema de tres ecuaciones. Similar a las funciones integradoras DSolvees para soluciones exactas, mientras NDSolveque resolverá el sistema numéricamente. Lo anterior produce una solución única

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

que ahora podría usarse fácilmente para cálculos adicionales o trazarse.

Fragmento de longitud 64

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

¡Te prometí más CellularAutomatonmagia! Este fragmento calcula el juego de la vida de Conways con la condición inicial ide los npasos y le brinda el resultado para todos los pasos intermedios.

Algunas palabras sobre los parámetros: 2es el número de estados de la celda. {{2,2,2},{2,1,2},{2,2,2}}da los pesos para las 9 celdas en el vecindario 3x3. Asegura que la celda en sí es distinguible de la suma de los 8 vecinos. {1,1}dice que la regla de CA depende de las celdas a 1 paso en cualquier dirección. Finalmente, 224la regla de actualización real está codificada en un solo número. Determinar este número puede ser un poco complicado, pero hay un tutorial bastante útil en la documentación . Para autómatas más complicados, un solo número no lo cortará (porque el número sería enorme). ¡Quizás lleguemos mañana! ;)

De todos modos, si introduzco una cuadrícula aleatoria iy 200 n, y envío el resultado a través de una animación ArrayPlot, podemos ver que realmente está funcionando:

Fragmento de longitud 59

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

¿Recuerdas la trama polar del fragmento 26? ¡Podemos hacer lo mismo en 3D! (De hecho, hay dos funciones: RevolutionPlot3Dpara polares cilíndricos y SphericalPlot3Dpara polares esféricos). Al igual que Graphics3Dtodas las tramas tridimensionales pueden rotarse automáticamente en Mathematica, por lo que no tiene que preocuparse por un buen ángulo de cámara por adelantado. Lo anterior traza algo así como un armónico esférico (aunque no del todo) y se ve así:

Fragmento de longitud 52

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

Este es bastante ingenioso. Manipulatetoma cualquier expresión, la parametriza con un montón de variables y luego le proporciona un widget, donde puede ajustar los parámetros y ver en vivo cómo cambia la expresión. Como expresión, generalmente tendrás algún tipo de trama. Esto es particularmente útil si está usando Mathematica en conferencias para demostrar cómo las familias de soluciones responden a la modificación de los parámetros. Lo anterior muestra cómo las ay bescalan coeficientes y el cambio de una parábola:

Longitud 48 fragmento

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

ImportEs un comando bastante poderoso. Se usa tanto para cargar archivos desde el disco como desde la web. Conoce muchos formatos de archivo diferentes, y para algunos de ellos (como las páginas HTML) en realidad puede extraer datos de inmediato. Lo anterior descarga todas las imágenes de la página del doodle de Google.

Fragmento de longitud 45

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

Tiempo para un poco de procesamiento de imágenes. Mathematica viene con una gran cantidad de datos de ejemplo, que incluyen imágenes (como Lena), texturas, modelos 3D y fragmentos de audio. Primero, cargamos uno de esos:

¿Quieres detectar bordes? Es una llamada de función única:

Longitud 44 fragmento

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

Finalmente, tengo suficientes caracteres para usar CellularAutomatony también renderizo el resultado. :) Hasta donde yo sé, CellularAutomatones la única función en Mathematica relacionada con las CA. Pero Stephen Wolfram parece considerarse el hombre número uno cuando se trata de autómatas celulares, por lo que esta función es increíblemente poderosa. Lo anterior muestra más o menos su uso más simple. Esto simula un autómata celular 1D para 100 pasos, y en realidad devolverá el estado del autómata en cada uno de esos pasos, por lo que el resultado es bidimensional. La regla es el primer parámetro, que puede especificarse en detalle a través de listas o simplemente codificarse en un solo número. Para este ejemplo, he elegido la Regla 110 bastante famosa, completa de Turing . {{1},0}define la condición inicial: una sola1delante de un fondo de ceros. Quizás muestre algunas características más CellularAutomatonen el futuro cuando tenga más caracteres disponibles: puede simular AC en dimensiones más altas, utilizando vecindarios más grandes y con más de dos estados.

ArrayPlotes otra buena utilidad de trazado que simplemente traza una lista 2D como una cuadrícula de colores sólidos que indica su valor. En el caso más simple, 0es mappend al blanco y 1al negro. El resultado del fragmento es:

Fragmento de longitud 43

HighlightGraph[graph,FindVertexCover@graph]

Ha pasado un tiempo desde que mencioné los gráficos. Existen muchos problemas teóricos gráficos comunes en Mathematica, junto con buenas herramientas de visualización. Lo anterior, para un determinado graph, encontrará una cobertura mínima de vértice del gráfico, y luego renderizará el gráfico con esos vértices resaltados. Por ejemplo, si graphestá PetersenGraph[7,2]detrás de fragmento 18, obtenemos:

Fragmento de longitud 42

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

Es bastante simple animar cosas en Mathematica (y ni siquiera tienen que ser imágenes). Simplemente le da la expresión que se evaluará para cada cuadro y un grupo de parámetros que deberían variar en los cuadros. Lo anterior simplemente anima una trama de una onda sinusoidal en movimiento. La animación se verá como el siguiente GIF:

Fragmento de longitud 40

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

SortByhace lo que espera: ordena una lista en función de los valores obtenidos al asignar una función determinada a cada elemento de la lista. Pero espera, la llamada anterior no contiene una lista en absoluto. Desde Mathematica 10, hay soporte para curry o aplicación parcial para algunas funciones. Esta no es una característica del lenguaje como en los lenguajes funcionales más puristas, sino que solo se implementa manualmente para un montón de funciones donde esto a menudo es útil. Significa que el fragmento anterior devuelve una nueva función, que solo toma una lista y luego la ordena por la función dada. Esto puede ser muy útil si este orden de clasificación es algo que usará con más frecuencia en todo el código.

Y sí, hay otra buena *Datafunción: lo anterior ordenará los nombres de los planetas por las velocidades de escape de los planetas .

Longitud 39 fragmento

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

Prometí hacer que la función de Fibonacci sea más eficiente. Este fragmento muestra cuán trivial es la memorización en Mathematica. Tenga en cuenta que todo lo que ha cambiado es un adicional f[n]=en la tercera línea. Entonces, cuando fse solicita un nuevo valor (por ejemplo f[3]), f[3]=f[3-1]+f[3-2]se evaluará. Esto calcula f[2]+f[1], luego lo asigna a f[3](con =, no con :=!), Y finalmente devuelve el valor de nuestra llamada inicial. Entonces, llamar a esta función agrega una nueva definición para este valor, que obviamente es más específica que la regla general y, por lo tanto, se utilizará para todas las llamadas futuras fcon ese valor.

¿Recuerdas que la otra función de Fibonacci tomó 4 segundos para 30 valores? Esto necesita 3 segundos para 300,000 valores.

Longitud 37 fragmento

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

En el último fragmento mencioné patrones. Estos se usan con mayor frecuencia en reglas , que (entre otras cosas) se pueden usar para modificar estructuras que coinciden con un cierto patrón. Así que echemos un vistazo a este fragmento.

{a___,x_,b___,x_,c___}:>{a,x,b,c}Es una regla. x_con un solo guión bajo es un patrón que se refiere a un único valor arbitrario (que podría ser una lista o similar). a___es un patrón de secuencia (véase también el fragmento 15), que se refiere a una secuencia de 0 o más valores. Tenga en cuenta que estoy usando x_dos veces, lo que significa que esas dos partes de la lista tienen que tener el mismo valor. Entonces, este patrón coincide con cualquier lista que contenga un valor dos veces, llama a ese elemento xy llama a las tres secuencias alrededor de esos dos elementos a, by c. Esto se reemplaza por {a,x,b,c}, es decir, el segundo xse descarta.

Ahora //.aplicará una regla hasta que el patrón ya no coincida. Por lo tanto, el fragmento anterior elimina todos los duplicados de una lista l. Sin embargo, es un poco más poderoso que eso: //.aplica la regla en todos los niveles. Por lo tanto, si lcontiene listas (a cualquier profundidad), también se eliminarán los duplicados de esas sublistas.

Fragmento de longitud 36

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

¡Hora de nuevas funciones de lenguaje! Mathematica tiene algunas cosas buenas sobre la definición de funciones. Para empezar, puede proporcionar varias definiciones de funciones para el mismo nombre, para diferentes números o tipos de argumentos. Puede usar patrones para describir a qué tipo de argumentos se aplica una definición. Además, incluso puede agregar definiciones para valores individuales. Mathematica elegirá la definición aplicable más específica para cualquier llamada de función y dejará las llamadas indefinidas sin evaluar. Esto permite (entre otras cosas) escribir funciones recursivas de una manera mucho más natural que usar un Ifinterruptor para el caso base.

Otra cosa a tener en cuenta sobre el fragmento anterior es que estoy usando ambos =y :=. La diferencia es que el lado derecho de =se evalúa solo una vez, en el momento de la definición, mientras que :=se vuelve a evaluar cada vez que se hace referencia al lado izquierdo. De hecho, :=incluso funciona al asignar variables, que luego tendrán un valor dinámico.

Entonces, lo anterior, por supuesto, es solo una función de Fibonacci. Y muy ineficiente en eso. Calcular los primeros 30 números lleva unos 4 segundos en mi máquina. En breve veremos cómo podemos mejorar el rendimiento sin tener que deshacernos de la definición recursiva.

Fragmento de longitud 35

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

Un gráfico muy ordenado, que genera las líneas de flujo de un campo vectorial 2D. Esto es similar a un gráfico vectorial normal, ya que cada flecha es tangente al campo vectorial. Sin embargo, las flechas no se colocan en una cuadrícula fija sino que se unen en líneas (las líneas de corriente). La importancia de estas líneas es que indican la trayectoria de una partícula (por ejemplo, en un fluido) si el campo vectorial era un campo de velocidad. La entrada anterior se ve así:

Fragmento de longitud 34

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

Mathematica también puede resolver ecuaciones (o sistemas de ecuaciones, pero solo tenemos tantos caracteres en este momento). El resultado será, como siempre, simbólico.

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

Tenga en cuenta que las soluciones se dan como reglas , que probablemente mostraré con más detalle en algún fragmento futuro.

Fragmento de longitud 33

Dynamic@EdgeDetect@CurrentImage[]

Gracias a benwaffle por esta idea. CurrentImage[]carga la imagen actual de tu cámara web. EdgeDetectconvierte una imagen en una imagen en blanco y negro donde los bordes son blancos y el resto es negro (vea el fragmento 45 para un ejemplo). La verdadera diversión viene con lo Dynamicque hace que la expresión se actualice. Entonces, el resultado de esto en realidad transmitirá imágenes desde su cámara web y hará una detección de bordes en vivo en ellas.

Fragmento de longitud 32

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

Un tipo de trama bastante inusual. Puede trazar un montón de cosas diferentes a lo largo de la recta numérica, como puntos e intervalos. También puede darle una condición, y le mostrará la región donde esa condición es verdadera:

La flecha indica que la región continúa hasta el infinito. Los círculos blancos indican que esos son intervalos abiertos (los puntos finales no son parte del intervalo). Para los extremos cerrados, los círculos se llenarían.

Fragmento de longitud 28

Graphics3D@{Sphere[],Cone[]}

Tiempo para algunos gráficos en 3D. Lo anterior representa una esfera y cono superimpuestos con parámetros predeterminados, que se parece a una bola de cristal:

En Mathematica, puedes hacer clic y arrastrar este pequeño widget para rotarlo.

Fragmento de longitud 27

CountryData["ITA", "Shape"]

Más *Data! CountryDataes bastante loco Obtener la forma de un país ni siquiera es la punta del iceberg. Hay tantos datos sobre países que probablemente podría escribir un libro completo sobre esta función. Como ... hay FemaleLiteracyFraction. También puede consultar esos datos para diferentes puntos en el tiempo. Para obtener una lista completa, consulte la referencia.

Longitud 26 fragmento

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

Tiempo para una trama más interesante. PolarPlotes simplemente una trama en coordenadas polares. En lugar de especificar y para una x dada, especifique un radio r para un ángulo dado θ:

Fragmento de longitud 25

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

Finalmente tenemos suficientes caracteres para algunas matemáticas vectoriales. Lo anterior calcula la multiplicación de matrices de una matriz de 2x3 y un vector de fila 2:

{53, 43, 92}

Fragmento de longitud 23

Rotate[Rectangle, Pi/2]

Je Jeje. Crees que sabes lo que hace esto. Pero tu no. Rectanglepor sí solo es una función con nombre. Para obtener un objeto que represente un rectángulo, necesitará llamar a esa función con algunos parámetros. Entonces, ¿qué crees que sucede cuando tratas de rotar Rectangle? Esta:

Fragmento de longitud 22

30~ElementData~"Color"

Otra de las *Datafunciones integradas. Sí, para elementos químicos, no solo obtienes cosas como su número atómico, punto de fusión y nombre ... en realidad puedes obtener su color a temperatura ambiente. Lo anterior da el color del zinc:

SlateGray

Fragmento de longitud 21

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

Tuvimos diferenciación hace algún tiempo. Tiempo de integración. Mathematica puede manejar integrales definidas e indefinidas. En particular, Integratele dará una solución exacta, y puede manejar un montón de integrales estándar y técnicas de integración (para obtener resultados numéricos, hay NIntegrate). Si conoce su cálculo, habrá notado que la integral gaussiana anterior en realidad no tiene una forma cerrada integral indefinida ... a menos que considere la forma cerrada de la función de error , es decir. Mathematica devuelve:

1/2 Sqrt[π] Erf[x]

Fragmento de longitud 20

"Sun"~StarData~"Age"

Volver a los datos integrados . Debe haber al menos dos docenas de *Datafunciones para todo lo que se te ocurra. Cada uno de ellos toma un identificador de la cosa para la que desea obtener los datos y una propiedad (o lista de propiedades) para recuperar. Lo anterior es solo uno de los más cortos que puede obtener Sun, Stary Agetodo es bastante corto, porque no podía esperar para mostrar esta función.

Ah sí, y ¿mencioné que Mathematica (desde 9) admite cantidades con unidades? (Más sobre eso más adelante). Lo anterior evalúa a:

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

que se muestra como

Fragmento de longitud 19

MandelbrotSetPlot[]

Sí ... función muy útil ... Lo uso todo el tiempo. (A veces, su deseo de admitir cualquier cosa que sea computable puede llegar un poco lejos ...)

En su defensa, la función es un poco más útil que eso: puede darle una sección particular del gráfico que desea trazar.

Longitud 18 fragmento

PetersenGraph[7,2]

Desde Mathematica 8, entiende qué son los gráficos, por lo que viene con todo tipo de funciones relacionadas con la teoría de gráficos. Y no era Mathematica si no incluyera un montón de elementos integrados. Lo anterior genera los datos del gráfico para un gráfico de Petersen generalizado . Produce la estructura de datos real que se puede manipular, pero Mathematica muestra de inmediato esos datos gráficos ... gráficamente:

Fragmento de longitud 17

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

Finalmente suficientes personajes para hacer algunas tramas. Lo anterior es realmente el ejemplo más simple de una trama unidimensional. Prometo mostrar tramas más frías más adelante

Fragmento de longitud 15

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

Esto muestra dos de las características más potentes (y también útiles para jugar al golf). Todo es una función pura sin nombre , comparable con lambdas en Python o Procs en Ruby. La función pura simplemente termina en a &. Este operador tiene muy poca prioridad, por lo que generalmente incluye casi todo lo que queda de él. Se hace referencia a los argumentos de una función pura #, a veces seguidos de otras cosas. El primer argumento es #o #1, el segundo es #2, y así sucesivamente.

La otra característica es Sequences. Estos son básicamente como símbolos en otros idiomas. Una secuencia es como una lista sin la lista que la rodea: es literalmente solo una secuencia de valores, que se puede usar en listas, argumentos de función, etc. ##en particular es una secuencia de todos los argumentos de función pura. ##2es una secuencia de todos los argumentos que comienzan desde el segundo. Entonces, si nombramos la función anterior fy la llamamos como

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

Nosotros obtendriamos

{4,5,1,2,3}

entonces la función gira los argumentos de entrada 3 elementos a la izquierda. Tenga en cuenta que se ##4refiere a los 4,5que se aplanaron en la lista.

Longitud 12 fragmento

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

Diferenciación parcial Ddiferenciará la primera expresión sucesivamente con respecto a sus otros argumentos, proporcionándole una expresión simbólica como resultado. Entonces lo anterior es d² (x ^ y ^ x) / dxdy (donde las d s son parciales), que Mathematica informa que es

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

Fragmento de longitud 9

Exp[I*Pi]

¡Todavía no hemos hecho ninguna aritmética compleja! Como puede ver, en πrealidad era solo un alias para Pi. De todos modos, lo anterior en realidad devolverá correctamente el entero -1 .

Fragmento de longitud 8

Sunset[]

Sí. Habla sobre locos incorporados. Sin parámetros que realmente le brinden un objeto de fecha y hora de la próxima puesta de sol en su ubicación actual. También toma parámetros para otras fechas, otras ubicaciones, etc. Esto es lo que me parece en este momento:

Fragmento de longitud 7

9!/43!!

Este fragmento muestra algunas cosas geniales.

Mathematica no solo tiene un operador factorial incorporado !, también tiene un factorial doble !!(que multiplica cada número de nabajo a abajo 1). Además, admite enteros de precisión arbitraria. El 43!!será evaluado exactamente, hasta el último dígito. Además, los números racionales también se evaluarán exactamente. Entonces, dado que tanto el numerador como el denominador son enteros, Mathematica reducirá las fracciones lo más posible y luego le presentará

128/198893132162463319205625

Por supuesto, puede usar flotantes cuando lo desee, pero en general, si su entrada no contiene flotantes, su resultado será exacto.

Fragmento de longitud 4

Here

Ya es hora de que empecemos con la gran cantidad de locos complementos de Mathematica. Lo anterior hace lo que dice en la lata y (para mí) se evalúa GeoPosition[{51.51, -0.09}].

Fragmento de longitud 3

x-x

Solo para mostrar el Factoid original : lo anterior funciona incluso si aún xno está definido y realmente dará como resultado 0en ese caso.

Fragmento de longitud 2

3x

Multiplicación por yuxtaposición! Si está claro que un identificador finaliza y comienza otro, no necesita un *espacio en blanco para multiplicarlos. Esto funciona con casi todo, incluidas cadenas y variables que aún no tienen valores. Muy conveniente para jugar al golf. ;)

Fragmento de longitud 1

π

Adivina qué, es Pi. Y, de hecho, no se trata de una representación aproximada de punto flotante, es Pi exactamente, por lo que todo tipo de funciones complejas y trigonométricas en las que se utiliza producirá resultados exactos si se conocen.

Factoid

Mathematica puede realizar manipulación simbólica, por lo que las variables no necesitan valores para trabajar con ellas.

El infame lenguaje de programación de Shakespeare

Shakespeare Programming Language fue creado en 2001 por dos estudiantes suecos, Karl Hasselström y Jon Åslund, y combina, como proclaman los autores ,

La expresividad de BASIC con la facilidad de uso del lenguaje ensamblador.

Las respuestas van de arriba a abajo. Además, es común verme referirme a fragmentos anteriores o anteriores.

( enlace para mí: editar )

Hecho:

El código de Shakespeare se asemeja, como cabría esperar, a una obra de Shakespeare, donde las variables son personajes de la obra y su valor cambia a medida que son "insultados" o alabados.

Fragmento de longitud 1:

I

El código de Shakespeare se divide en Actos, y los actos se dividen en Escenas, para las causalidades de "salto a". Definir un acto como Act Isignifica que será la primera parte del código que se ejecutará, por ejemplo, pero no solo.

Fragmento de longitud 2:

as

Utilizado en una comparativa entre dos "personajes".

Fragmento de longitud 3:

day

A estas alturas, puede tener la sensación de que SPL es muy detallado. Y raro Y aún no has visto nada. day, en SPL, es 1. Todos los sustantivos "positivos" y "neutros" se consideran 1, así como todos los sustantivos "negativos" -1.

Fragmento de longitud 4:

rich

¿Qué es rich? Un adjetivo. En SPL, los adjetivos hacen que el valor del sustantivo al que están unidos se multiplique por dos. Ver implementación en el fragmento 14.

Fragmento de longitud 5:

Act I

Implementación del primer fragmento. A todos los actos se les puede dar un título, como Act I: Hamlet must die!, ya que el analizador ignora todo después del número romano.

Fragmento de longitud 6:

better

Cada idioma tiene condiciones, y SPL no es una excepción. Excepto que, dado que este es un lenguaje con una larga sintaxis (¿lo mencioné como extraño?), Sus declaraciones condicionales serán largas. Hacer que Ophelia le pregunte a Juliet Am I better than you?es como tener la if (Ophelia > Juliet)mayoría de los idiomas "normales". Y, por supuesto, puede preguntar al revés: Am I not better than you?es el equivalente de if (Ophelia < Juliet). Y ya puede adivinar cómo =se traduce al SPL: as good as- uso del fragmento de código 2.

Sin embargo, good/betterno es la única forma de hacer comparaciones en este lenguaje shakesperiano, puede usar cualquier adjetivo. El mismo principio del fragmento 3 también se aplica aquí, con adjetivos "positivos" que tienen el valor >, mientras que los "negativos" significan <.

Fragmento de longitud 7:

Juliet:

Esta es la invocación de una variable; después de esto, sus instrucciones / declaraciones / lo que sea que siga.

Una limitación de SPL es que tiene un número limitado de variables: Romeo, Juliet, Hamlet, Ophelia, MacBeth, etc., son algunos ejemplos de "personajes" que aparecerán en un programa de Shakesper.

Fragmento de longitud 8:

[Exeunt]

[Exeunt]se coloca cuando todos los "personajes" salen del "escenario". Espero poder elaborar un poco más adelante sobre la interacción entre los personajes. Generalmente es la última instrucción de cualquier programa SPL, aunque [Exeunt]no es específicamente el "carácter" terminal del lenguaje. Para otro ejemplo, vea el fragmento 27.

Fragmento de longitud 9:

as bad as

Nueve caracteres solo para representar un mero =uso del fragmento 2. ¿He mencionado que SPL es extraño? Ver fragmento 30 para ejemplos. (y sí, hay más de una forma de generarlo)

Fragmento de longitud 10:

difference

Una forma elegante de representar -, una resta. Puede realizar operaciones matemáticas en SPL, aunque probablemente necesite un día completo para hacerlo bien.

Factoid (ya que de alguna manera logré alcanzar diez fragmentos de código, tomemos un descanso y tengamos otro factoid sobre SPL)

Si desea ejecutar su código shakesperiano en todo su esplendor, existe este sitio , aún lo estoy probando, ya que lo descubrí hace apenas cinco minutos. También hay una manera de traducirlo a C usando un traductor .

Otro sitio para ejecutar código SPL es este que funciona traduciendo internamente el código SPL a otro lenguaje esotérico: Oracle PL / SQL.

Fragmento de longitud 11:

[Exit Romeo]

¡Si! ¡Por fin puedo hablar sobre la interacción entre los personajes! Para que su valor cambie o para interactuar con otros, un "personaje" debe estar en el escenario, entrando con [Enter Romeo]. Si se dirige a un personaje pero no está presente, hay un error de tiempo de ejecución y el programa se detiene. Porque, en SPL, el valor de las variables se establece por la cantidad de nombres con los que los elogian, o los insultan, los otros personajes en el escenario. Siento que debería poner un ejemplo para aclarar la confusión que puede generar mi cojera explicación, pero tal vez sea mejor retrasar algunos fragmentos.

Fragmento de longitud 12:

Remember me.

SPL es bastante "básico", está bien, ¡pero tiene pilas! Cuando, por ejemplo, Romeo le dice a Juliet que "lo recuerde", en realidad le dice a su ser querido que empuje el valor del Romeo a su pila. Hacer estallar el valor se hace con Recall your happy childhood!, o Recall your love for me, básicamente, cualquier oración que comience Recall; el resto es solo tontería artística, como el fragmento 22.

Fragmento de longitud 13

Let us return

La forma shakesperiana de tener un goto. Y aquí es donde los actos y escenas son útiles. Si Romeo le dice a Julieta we shall return to Act II(sí, de nuevo, hay varias formas de escribirlo), el programa saltará a esa parte específica del código. También se ve junto con declaraciones condicionales.

Fragmento de longitud 14

my little pony

Sí, fue una serie en los años 80. Aquí está 2*1. ¿Por qué? Porque a ponyes un sustantivo (algo) positivo y littlees un adjetivo. Entonces, recordando los fragmentos 3 y 4, tenemos little = "2 *"y pony = "1".

Fragmento de longitud 15

Speak thy mind!

En un programa SPL, verá esto (o lo Speak your mind!que es lo mismo) mucho . Básicamente, esto genera el valor de cada "carácter" en dígitos, letras o cualquier otra cosa, dependiendo del juego de caracteres que esté utilizando su computadora. También hay Open your mind.que hace casi lo mismo, aunque solo se genera en forma numérica.

Fragmento de longitud 16

You are nothing!

Cuando alguien te dice esto en la vida real, te sentirás deprimido. Cuando Ophelia le dice esto a Hamlet en la programación de Shakespeare, Hamlet se siente inútil. ¿Qué significa esto? Eso Hamlet = 0.

Fragmento de longitud 17

Ophelia, a wench.

En un guión, antes de que comience la obra, los personajes deben ser presentados. En la mayoría de los lenguajes de programación, las variables también deben declararse antes de su uso. Al ver que SPL es un lenguaje de programación que se asemeja a un guión, así es como declara sus variables, indicando cuáles son las que aparecen durante el programa.

Pero, ¿qué significa "una moza"? ¿Significa que es un nombre de tipo de datos específico (y genial)? Bueno ... odio decepcionarte, pero no significa nada: todo después de que la coma es ignorada por el analizador, lo que significa que puedes poner allí la tontería más escandalosa que puedas imaginar.

Longitud 18 fragmento

lying sorry coward

-4para todas las criaturas terrenales. ¿Por qué? Debido 2*2*(-1) = -4.

Fragmento de longitud 19

Romeo:
 Remember me.

¡¡¡Al final!!! ¡Finalmente puedo generar una instrucción de sintaxis correcta completa (aunque sea breve)! Así es como usas el fragmento 12: primero declaras quién está hablando, luego en la siguiente línea escribes el "diálogo". Normalmente, solo dos "personajes" están en el escenario, para evitar que el analizador esté triste y confundido. Cuando necesitas otro "personaje", tomas uno del escenario y lo reemplazas por uno nuevo.

Fragmento de longitud 20

cube of thy codpiece

Quería elaborar un poco más para este, pero, a decir verdad, las cosas que se me ocurren todavía son demasiado cortas para esta longitud de fragmento. Y, entonces, les traigo esto, que termina siendo -1- porque (-1) ³ = -1 (y codpiecees un sustantivo "negativo", ya que son incómodos y todo). SPL entiende algunas operaciones aritméticas más elaboradas como algunas exponenciaciones y raíces cuadradas.

Factoid (otro más, ya que hemos alcanzado otro hito)

El "Programa Hello World" en Shakesperian tiene 89 líneas y más de 2400 caracteres de largo, como se ve aquí .

Fragmento de longitud 21

Listen to your heart.

En el fragmento 15, sacaste algo; aquí, ingresa un número al programa. Si desea ingresar un carácter, lo usará Open your mind.en su lugar. Y, no hace falta decir que este valor se almacenará en el "personaje" con el que se habla.

Fragmento de longitud 22

Recall your childhood!

Hacer estallar un número entero de una pila, como se explica en el fragmento 12. Cuando, por ejemplo, Ofelia le dice a Hamlet la oración antes mencionada, hace que Hamlet tome un número entero de su pila y asuma ese valor.

Por supuesto que, siempre que la palabra recallcomience la oración, puedes completar el resto con casi cualquier cosa que tu creativa mente shakesperiana desee.

Fragmento de longitud 23

Are you better than me?

Implementación del fragmento 6. Cuando un "personaje" le hace una pregunta como esta a otro, lo que él / ella está haciendo equivale a if (x > y)los lenguajes de programación más comunes. El seguimiento de esta instrucción debe retrasarse hasta que tenga más caracteres disponibles.

Longitud 24 fragmento

[Enter Romeo and Juliet]

Sí, los "caracteres" pueden ingresar en pares. No es necesario tener un "personaje" entrando en el escenario, seguido de otro.

Fragmento de longitud 25

remainder of the quotient

25 caracteres solo para escribir a %. 25 personajes para tener el resto de una división. ¿Y para usarlo? Bueno, eso es aún más grande: vea el fragmento 75.

Longitud 26 fragmento

Let us return to scene II.

Aquí está, un gotoen SPL, que funciona como cabría esperar en un lenguaje de programación. Una cosa es: puedes saltar entre escenas en el mismo acto, y entre actos; pero no puedes saltar entre escenas en diferentes actos.

Fragmento de longitud 27

[Exeunt Ophelia and Hamlet]

Cuando más de un "personaje" abandona el escenario, en lugar de Exitseguir la tradición con la naturaleza teatral de SPL, se usa la palabra latina "Exeunt". A veces se puede reemplazar solo por el fragmento 8.

Fragmento de longitud 28

Scene I: Ophelia's flattery.

Declarando una escena. Como ya puede esperar si me ha estado haciendo frente, lo importante es que Scene I, el resto es una pelusa artística.

Se han realizado algunos compiladores (como este que compila de SPL a C, escritos en Python ) que, en cambio, hacen referencia al texto después de la numeración de Act / Scene. Si bien es más lógico (después de todo, durante una obra, hacer que los personajes digan líneas como "volvamos al Acto I" puede considerarse una tontería), me mantengo en la forma original.

Fragmento de longitud 29

You pretty little warm thing!

Sí, otra constante más (ya que necesitamos muchos más caracteres para tener operaciones aritméticas). Este es igual a 8, porque 2*2*2*1 = 8.

Fragmento de longitud 30

You are as cowardly as Hamlet!

Decir esto a, por ejemplo, Romeo, significa eso Romeo = Hamlet. Como fragmento 9.

Factoid (sí, ¡otro hito alcanzado!)

Este lenguaje fue creado para una tarea en un curso de Análisis de sintaxis, por lo tanto, los autores no crearon ningún compilador SPL. Más: parece que los autores de SPL han roto sus lazos con su creación, ya que nada parece haber sido modificado en el lenguaje desde 2001 ...

Fragmento de longitud 31

Am I as horrid as a flirt-gill?

Sí, lo sé, es un fragmento 23 algo repetitivo, aunque, aquí, estamos comparando el "personaje" que habla con un "coqueteo" (de, si lo prefiere if (Ophelia == -1)). La cosa es...

Fragmento de longitud 32

If so, let us return to scene I.

... ahora puedo presentar el thenSPL, el salto condicional y la forma Shakesperiana de implementar bucles. Puede, por ejemplo, hacer que Romeo asuma el valor 0, incremente su valor mientras realiza alguna otra tarea y se detenga cuando llegue a 10, luego continúe con el programa.

Fragmento de longitud 33

If not, let us return to scene I.

Solo un recordatorio de que, en cambio, podemos avanzar a otra escena si la condición que probamos es falsa .

Fragmento de longitud 34

Open your mind! Remember yourself.

¡Dos instrucciones seguidas, yippie! El primero lee un personaje, el segundo lo empuja a la pila de memoria del otro personaje.

Fragmento de longitud 35

Act I: Death!

Scene I: Oh, shit.

La forma correcta de declarar un acto y una escena. Agregue papilla artística con buen gusto.

Fragmento de longitud 36

Thou art as sweet as a summer's day!

Otra forma de decir que el "personaje" con el que se habla recibirá el valor 1, porque los días de verano son agradables y agradables.

Longitud 37 fragmento

Art thou more cunning than the Ghost?

Ofelia hacer esta pregunta a los medios de Hamlet, que se traduce a un lenguaje de programación menos legible, if (Hamlet > the Ghost). Es el fragmento 23 de nuevo, sí, pero demuestra que no es necesario preguntar a los "personajes" si son mejores entre sí: cualquier otra pregunta también funcionará.

Longitud 38 fragmento

[Enter the Ghost, Romeo and the Ghost]

Sí, estoy llamando a un "personaje" dos veces, porque quería que el programa me diera un error. Llamar a un "personaje" que ya está en el escenario, o decirle a uno que está ausente que salga, causará un gran dolor al analizador / compilador.

Longitud 39 fragmento

the sum of a fat lazy pig and yourself!

La instrucción completa se ve mejor que esto, te daré eso, pero ... ¡aquí está nuestra primera operación aritmética! ¿Qué significa todo en realidad? Bueno, piges un animal sucio (aunque sabroso), por lo que es equivalente a -1, tiene dos adjetivos, lo que significa fat lazy pigigual 2*2*(-1) = -4. ¿Pero que pasa yourself? Es un pronombre reflexivo, no un nombre ni un adjetivo. Bueno, recuerde que SPL se basa en diálogos entre "personajes"; así, se yourselfrefiere al otro "personaje" en el escenario. Entonces, llegamos al final y descubrimos que "la suma de un cerdo gordo y perezoso y usted mismo" es, de hecho -4 + x,.

Fragmento de longitud 40

the sum of a squirrel and a white horse.

Sí, otra suma, pero éste es más sencillo que fragmento 39. Esto es simplemente 1 + 2- 3, si mis matemáticas son correctas.

Factoid (¿sigues conmigo después de estos cuarenta fragmentos de pelusa artística? Te mereces un premio).

SPL, en su versión 1.2.1, se puede descargar aquí .

Fragmento de longitud 41

Juliet:
 Speak thy mind!

[Exit Romeo]

A veces, los "personajes" solo son llamados al escenario para cambiar su valor, lo que, en una obra de teatro real, sería algo bastante extraño. De todos modos, aquí, Julieta hace que su amado Romeo imprima su valor almacenado, después de lo cual sale del escenario.

Fragmento de longitud 42

Speak YOUR mind! You are as bad as Hamlet!

De nuevo dos instrucciones en una línea (podemos tener múltiples, pero la longitud del fragmento aún no lo permite); aquí tenemos un "personaje" que le dice a otro que muestre su valor y asuma el valor que tenga Hamlet. ¿Confuso? Quizás.

Fragmento de longitud 43

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

Juliet preguntando esto no significa que tenga baja estima (aunque podría tenerla en la vida real); es simplemente otro if, como los fragmentos 23 y 37. Oh, casi lo olvido: esto se traduce en if (Juliet == -2).

Longitud 44 fragmento

You are as evil as the square root of Romeo!

Sí, las raíces cuadradas son malvadas, ¿no lo sabías? De todos modos, esta instrucción es lo suficientemente sencilla como para comprender lo que hace: atribuye el "carácter" que se habla al valor de la raíz cuadrada del valor almacenado en Romeo.

Fragmento de longitud 45

Hamlet:
 Art thou more cunning than the Ghost?

Fragmento 37 escrito correctamente con el personaje que habla la línea.

Fragmento de longitud 46

the product of a rural town and my rich purse.

De acuerdo ... de todos modos, SPL puede ser el único idioma en el mundo que te permite multiplicar ciudades con monederos. Esto significa (2*1)*(2*1)que, si no estoy muy equivocado, es igual a 4.

Fragmento de longitud 47

Romeo:
 Speak your mind.

Juliet:
 Speak YOUR mind!

Te lo diré: puede ser uno de los diálogos más extraños de la historia. Pero es lo que obtienes cuando eliges un idioma extraño para mostrar. Romeo y Julieta se están diciendo, en resumen, que expresen sus valores.

Longitud 48 fragmento

You lying fatherless useless half-witted coward!

Traducirlo directamente 2*2*2*2*(-1). -16, ¿derecho?

Fragmento de longitud 49

Scene V: Closure.

Hamlet:
 Speak your mind!

[Exeunt]

Un ejemplo de cómo terminar un programa en SPL. Puedes declarar una escena específicamente para ella (aunque no es obligatorio), luego Hamlet le pide a otro "personaje" que muestre su valor, y luego todos salen del escenario. Y sí, se requiere que todos salgan del escenario.

Fragmento de longitud 50

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

Más presentación de "personaje", antes de las instrucciones adecuadas. Como siempre, lo único que le importa al compilador es Othelloy Lady Macbeth, por lo que el resto de la línea está en juego ...

Una cosa más: los "personajes" no tienen que estar relacionados entre sí para aparecer en un programa SPL, por lo que puedes tener a Romeo, Othello y Hamlet en la misma jugada.

Factoid (¿medio siglo de estas cosas? ¡Uf! Después de esto creo que voy a odiar a William Shakespeare ...)

El traductor de SPL a C, mencionado hace un tiempo y desarrollado por los creadores de SPL, se basó en Flex y Bison .

Fragmento de longitud 51

Othello:
 Recall your great dreams. Speak your mind!

(Tan harto de Romeo, Julieta y Hamlet ... ¡traigamos a Othello, para variar!)

Recall, como puedes adivinar, es la clave aquí. El "personaje" al que se dirige Othello tomará un valor de su pila, asumirá ese valor y, luego, lo generará.

Fragmento de longitud 52

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

Otra suma Bostezo. Asumir que este está dirigido a Hamlet, significa eso Hamlet = Hamlet + 1. O Hamlet += 1. O Hamlet++.

Fragmento de longitud 53

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

Ah, sí, algo que olvidé mencionar antes: los "personajes" que hablan pueden mencionarse en sus propias líneas.

Fragmento de longitud 54

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

Otro ejemplo del fragmento anterior, incluido en una condición. Entonces lo que tenemos aquí es if (Romeo + Juliet == 0).

Fragmento de longitud 55

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

Entonces, aquí, Juliet está elogiando al "personaje" con el que está hablando (supongamos que es Romeo, por el bien de Shakespeare), declarando que él / ella tiene 4. Sí, otra asignación de valores.

Fragmento de longitud 56

Othello:
 You lying fatherless useless half-witted coward!

Fragmento 48 hecho correctamente, con un "personaje". Si eres demasiado vago para desplazarte hacia arriba (como lo estaría yo), esto significa que el que está siendo insultado está recibiendo el valor -16.

Fragmento de longitud 57

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

Ya he explicado cómo funcionan las condiciones en SPL de forma general; sin embargo, se necesita un análisis más en línea. No tenemos elseaquí: por ejemplo, en este ejemplo, si la condición falla, el programa volverá al Acto I; pero si fuera cierto, continuaría con la siguiente instrucción, que es Recallun pop de la pila, es decir.

Longitud 58 fragmento

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

Agarrando el fragmento 44 y presentando cómo se debe presentar la instrucción. Si se tratara de un diálogo entre Romeo y Othello, podríamos traducirlo a Java como Othello = Math.sqrt(Juliet).

Fragmento de longitud 59

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

Bien, si Othello está hablando con Romeo, esto sería equivalente a Romeo+(-1); Romeo--, para abreviar. Bastante básico, ¿verdad? Eso es SPL para ti.

Fragmento de longitud 60

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

Para abreviar, if (The Ghost/Hamlet == 0)suponiendo que el "yo" pertenece a Hamlet.

Fragmento de longitud 61

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

Una vez que despega las capas y capas de palabras e insultos, nota que SPL es prácticamente una cosa básica, sin funciones y cosas geniales. Entonces tenemos montones y montones de funciones aritméticas en el cuerpo del programa. Entonces, si este fuera dirigido a Julieta, sería equivalente a Juliet++.

Fragmento de longitud 62

twice the difference between a mistletoe and a oozing blister!

Sí, sí, más operaciones aritméticas. Aproximadamente, estos 62 bytes de SPL se pueden traducir a 2*(1-2*(-1)). Este sería un lenguaje de golf bastante impresionante, ¿verdad? Derecha.

Fragmento de longitud 63

You lying stupid fatherless rotten stinking half-witted coward!

Fragmento de 48 da salida -16, éste es igual a -64: 2*2*2*2*2*2*(-1).

Fragmento de longitud 64

your coward sorry little stuffed misused dusty oozing rotten sky

Por lo que entiendo de SPL, esto es perfectamente legítimo. Tienes muchos adjetivos insultantes que dan lugar a un sustantivo "positivo". Dado que los adjetivos no tienen una distinción especial si son negativos o no (su único valor es multiplicar el número a la derecha por dos), podemos tener oraciones completamente tontas como esta. Lo que equivale a 256. Porque 2*2*2*2*2*2*2*2*1=256.

Fragmento de longitud 65

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

Hmm, tanto odio, ¿no? Entonces, lo que tenemos aquí es equivalente a y=0; y=y+(-1);Probablemente podría haber sido "golfizado" You are a pig!, pero je.

Fragmento de longitud 66

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

Entonces, resta a Juliet de ti, ¿eh? Este es bastante simple de decodificar: Romeo=Juliet-Romeo;suponiendo que se esté hablando con Romeo.

Fragmento de longitud 67

Juliet:
 Am I better than you?

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

Cómo funcionan la mayoría de las condiciones en SPL. Usted prueba la expresión y, si es verdadera (o no: vea el fragmento 33), salta a otra parte del programa; de lo contrario, continuará con la siguiente oración.

Fragmento de longitud 68

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

Sí, sí, me estoy volviendo un poco monótono. Pero SPL es así. Como dije un poco antes, sus expresiones son una mezcla de operaciones aritméticas. Por lo tanto, este es otro incremento más, ya que stone walles un "sustantivo" neutral.

Fragmento de longitud 69

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

En lugar de una suma, tenemos la resta entre dos personajes, Othello y con quien se le está hablando.

Fragmento de longitud 70

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

Volvemos a las adiciones, sí, llámame formulaic, je. Traducimos esto a Romeo + 2*2*1.

Longitud 71 fragmento

Scene I: Dialogues.

[Enter Juliet]

Othello:
 Speak your mind!

[Exit Juliet]

Una escena puede ser tan pequeña como esta. Julietentra al escenario, Othello le dice que muestre su valor almacenado, luego se baja del escenario nuevamente.

Fragmento de longitud 72

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

Una operación aritmética más, porque SPL está plagado de ellos. Podemos traducir esto a 2*(1-2*2*(-1)).

Fragmento de longitud 73

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

¿Cuatro instrucciones seguidas? Estoy bastante orgulloso de mí mismo, en realidad. De todos modos, supongamos que este es un diálogo entre Romeo y Julieta (y él está hablando): esto significa que el valor de Julieta comienza en 0; luego, Juliet empujará el valor de Romeo en su pila de memoria, lo abrirá y lo mostrará en su forma ingresada. Simple, verdad?

Fragmento de longitud 74

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

Sí, sí, ejemplo aburrido, lo sé. Pero esto es X = (Romeo + 1) + 1.

Fragmento de longitud 75

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

Bueno, esto es bastante sencillo. Si sus habilidades de decodificación no funcionan correctamente, se traduce en if (Othello % X == 0).

Fragmento de longitud 76

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

El salto del fragmento 26 con una expresión delante. A gotoen SPL no siempre se encuentra cerca de una condición, puede ser así, y, por supuesto, este tipo de gotosiempre se encontrará al final de un Acto o Escena, ya que las instrucciones posteriores nunca se compilarán / ejecutarán. La primera instrucción es bastante simple: x=x+1.

Longitud 77 fragmento

[Exit Hamlet]

[Enter Romeo]

Juliet:
 Open your heart.

[Exit Juliet]

[Enter Hamlet]

Entonces, tenemos a Juliet y Hamlet en el escenario; pero necesitamos el valor de Romeo. Por lo tanto, para evitar que el compilador tenga un dolor de cabeza muy desagradable, en primer lugar eliminamos a Hamlet del escenario (aunque podría haber sido Juliet quien fuera), le decimos a Romeo que suba al escenario, Juliet le da instrucciones para emitir un número (vea la explicación del fragmento 21), luego Romeo sale del escenario y Hamlet regresa. Bastante sencillo y simple.

Longitud 78 fragmento

The Ghost:
 Speak thy mind.

Lady Macbeth:
 Listen to thy heart! Remember thyself.

Entonces, The Ghost (el padre fallecido de Hamlet) le está diciendo a Lady Macbeth que muestre su valor, mientras ella le ordena a The Ghost que lea un número y lo meta en su pila.

Piet

Factoid

Piet es un lenguaje de programación donde el código fuente consiste en imágenes. El flujo del programa comienza con el píxel superior izquierdo y se mueve alrededor de la imagen entre píxeles y grupos de píxeles hasta que termina.

Para legibilidad, los programas de Piet se muestran comúnmente en una versión ampliada. En tal caso, el término codelse utiliza para describir un grupo de píxeles del mismo color que corresponden a un píxel individual en la imagen de origen.

Para este desafío, dado que Piet no usa caracteres, se usará un códec por voto para los programas de muestra.

1 Codel

Este es un programa válido, no hace nada y termina. El flujo de control comienza en el píxel superior izquierdo (solo) y no tiene salida, lo que finaliza el programa.

El píxel en este caso puede ser de cualquier color para el mismo efecto exacto.

2 codeles

Esto leerá continuamente caracteres de stdin y mantendrá un total acumulado de sus valores Unicode (aunque no se hace nada con este total y no se muestra).

El flujo del programa se mueve hacia adelante y hacia atrás entre los 2 códeles, ya que la única forma de salir de cada uno es hacia el otro. Los comandos en piet se ejecutan mediante el movimiento de un códec o región a otro, dependiendo de la diferencia de tono y claridad de las 2 regiones. El inputes el comando que se mueve de izquierda a derecha y luego el de addderecha a izquierda. En el primer addcomando, no sucederá nada, ya que solo hay un valor en la pila, y la especificación dice que los comandos sin suficientes valores disponibles se ignoran.

Este programa es un ciclo que nunca terminará, ya que la mayoría de los programas piet tendrán tamaños extremadamente pequeños, ya que se necesitan al menos algunos códeles para "atrapar" adecuadamente el flujo del programa y finalizarlo.

3 codeles

Este es un programa básico de tipo echo, leerá un carácter a la vez desde stdin y lo imprimirá en stdout.

De nuevo, este es un bucle infinito. El programa comienza viajando de izquierda a derecha, lo que hace inputentonces output. El programa continuará fluyendo en la misma dirección siempre que pueda. En el códec verde claro, la única salida es comenzar a moverse hacia el otro lado. Cuando viaja de derecha a izquierda, intenta ejecutar subtracty addcomandos, pero la pila está vacía, por lo que se convierten en no-ops.

4 codeles

Imprime 2 en stdout indefinidamente.

No es un programa particularmente interesante funcionalmente, pero ahora que finalmente tenemos un número compuesto de códeles podemos mostrar un flujo un poco más avanzado que de izquierda a derecha. Cuando el flujo del programa intenta salir de un codel, primero intenta la dirección actual. Si no puede (en este caso debido al borde de la imagen), gira 90 grados en el sentido de las agujas del reloj e intenta salir nuevamente. En este caso, el programa gira en sentido horario 1 codel a la vez, pushcolocando 1 en la pila dos veces, addjuntando los dos y luego outputobteniendo el resultado.

5 codeles

Lee repetidamente un carácter a la vez desde stdin y rastrea la suma de sus valores unicode.

Esta es esencialmente la misma funcionalidad que la versión de 2 códecs, pero este desafío se trata de mostrar el idioma, y ​​una de las cosas interesantes de piet es cómo puedes tener imágenes de aspecto diferente que hagan lo mismo.

Aquí vemos el códec blanco por primera vez, lo que permite que el flujo del programa se deslice a través de él sin ejecutar instrucciones. Los codeles magenta y azul hacen todo el trabajo aquí. Viajar de azul a rojo no hace nada porque cruza el códec blanco en el medio. Los 2 rojos son solo pushel número 1 en la pila y popretrocede cuando viaja de izquierda a derecha, luego de derecha a izquierda a través de ellos, y luego a través del códec blanco para que no se ejecute ninguna instrucción.

6 codeles

Nuevamente, repitiendo la funcionalidad anterior con un aspecto diferente. Este es otro programa de eco que lee un carácter a la vez de stdin a stdout.

Aquí vemos nuestro primer códec negro. El flujo del programa no puede ingresar un códec negro, por lo que desde el códec magenta claro en la esquina superior derecha, el programa no podrá salir a la derecha debido al borde de la imagen, no podrá salir hacia abajo debido al códec negro y rebotará de nuevo a la izquierda en el códec rojo . Los codeles azul y verde son puramente decorativos, el programa nunca los ingresará.

7 codeles

Sin embargo, otro programa de eco con un aspecto diferente.

Aquí vemos nuestros primeros bloques de codeles más grandes que el tamaño 1. En piet, cualquier bloque contiguo de codels del mismo color se trata como un solo bloque. El tamaño del bloque no importa, excepto al ejecutar la pushinstrucción, por lo que este programa se trata exactamente como la versión de 3 códeles, excepto con diferentes colores.

8 codeles

Lee un número de stdin y genera el cuadrado en stdout, repetidamente.

El flujo de control es un patrón básico en el sentido de las agujas del reloj, como en el programa de 4 códeles. A partir de la parte superior izquierda, las operaciones en orden son input, duplicate(empuja una copia extra del valor superior de la pila en la pila), multiply, output. Luego pushes el valor 1 en la pila, se desliza a través del blanco para que no se ejecute ningún comando, y luego popes ese 1 fuera de la pila cuando se mueve del códec inferior izquierdo a superior izquierdo. Esto lo devuelve al comienzo del programa con una pila vacía y se repite.

9 codeles

Agrega 1 + 2 = 3, y luego termina.

Ahora que tenemos un programa con más de 2 códeles en ambas dimensiones, finalmente podemos configurar una región que atrapará el programa y lo terminará en lugar de repetirlo para siempre. La primera operación que se mueve del códec rojo a la región roja oscura es un push1, luego el programa gira y fluye hacia el códec rojo claro en el medio y tiene pushun valor de 2. Fluyendo del rojo claro al amarillo claro se ejecuta una addoperación La barra amarilla de luz inferior hace que el programa finalice ya que no hay forma de que salga ya que todas las esquinas están bloqueadas.

Los programas de 1 y 2 niveles se están volviendo rápidamente feos y poco interesantes, por lo que a partir de este momento me enfocaré en los números que permiten al menos algunos códeles en cada dirección.

12 codeles

Finalmente, un programa que hace algo que podría considerarse útil (aunque todavía es un poco exagerado). Lee 2 números de stdin secuencialmente y luego genera su suma, y ​​lo hace repetidamente.

El programa fluye de izquierda a derecha a través de las 4 barras de colores que representan 2 inputsseguidas de un addcomando. Luego se mueve al códec inferior derecho y realiza un output, y luego vuelve a la izquierda a través de la región blanca hasta el inicio.

Esto podría haberse hecho en 8 códeles, pero dado que tenemos el espacio extra, podemos hacer algo que esté un poco inspirado en una vieja pantalla de TV sin señal.

15 codeles

Lee un número de stdin y genera su 'cuadrado.

Esto usa un par de trucos para darle un aspecto simétrico a un programa que realmente hace algo. La barra roja más a la izquierda tiene un color diferente en el códec inferior que el resto, aprovechando el hecho de que (al menos para mí) estos 2 tonos de rojo se ven muy similares. el programa se moverá desde la región roja más clara hacia el códec azul claro, y luego directamente a través del medio del programa hacia el verde claro en el lado derecho donde está atrapado. Se lleva a cabo input, duplicate, multiply, y outputoperaciones.

El codel rojo más oscuro, junto con los codeles verdes medianos en la parte superior e inferior de la columna central, son decorativos y el programa nunca los alcanzará.

20 codeles

Lee números de stdin hasta que se lee un 0, momento en el cual genera la suma de todos los números ingresados ​​y sale.

Finalmente tenemos suficiente espacio para controlar el flujo en la forma de la pointeroperación. Los 4 códeles a lo largo de la parte superior realizan input, duplicatey notoperaciones, y luego otra notoperación que se mueve desde el magenta en la parte superior derecha al amarillo de 2 códeles debajo. La notoperación extrae el valor superior de la pila y empuja un 1 si el valor superior era un 0 y un 1 en caso contrario. Por lo tanto, un doble notreemplaza cualquier valor distinto de cero con un 1. Al pasar de la barra amarilla hacia abajo al azul oscuro, se realiza una pointeroperación, que saca el valor superior de la pila y mueve el puntero de dirección en el sentido de las agujas del reloj tantas veces.

Si el valor superior es un 1 (es decir, no ingresamos un cero), el puntero de dirección apuntará a la izquierda, moviéndose a los codeles magenta para una addoperación (que se ignorará la primera vez debido a un solo valor en la pila) y luego a través del blanco de regreso al inicio del programa.

Si el valor superior de la pila es un cero en la operación del puntero, el puntero de dirección no cambiará y el programa continuará hacia abajo. Al pasar a la banda azul más clara, popel 0 que se ingresó fuera de la pila, dejando solo la suma de los números acumulados. Mover hacia la barra cian en la parte inferior hará outputque esa suma, y ​​luego termine ya que el flujo del programa está atrapado.

25 codeles

¡Cuenta regresiva! Lee un número de stdin, y luego imprime una cuenta regresiva a 1 para stdout un número a la vez. Por ejemplo, si se lee 5, imprimirá 54321.

La primera operación de cian a amarillo es la input. Entonces el amarillo es donde comienza el programa "loop". Amarillo> Magenta> Azul es un duplicateentonces un output, por lo que imprime el valor superior en la pila pero conserva una copia. Descendiendo por el lado derecho, que pushel valor 1 en la pila continuación, realizar una subtraction, disminuyendo nuestro valor introducido en 1. Lo siguiente es duplicate, noty otra noten movimiento desde el magenta claro en la parte inferior derecha de la oscuridad de color amarillo junto a él. Esta es la misma verificación cero / no cero que el programa anterior. Moverse a la izquierda hacia el códec azul claro realiza una pointeroperación, que se moverá hacia la izquierda hacia el cian oscuro para finalizar el programa si hemos terminado o hacia el amarillo para reiniciar nuestro bucle sin la entrada inicial, pero el valor original disminuyó por 1.

Los 3 codeles rojos son decorativos y pueden ser de cualquier color.

30 codeles

Generador de Fibonacci. Imprime los términos de la secuencia de Fibonacci en stdout y no se detiene.

Esta es la primera introducción del rolloperador, así como la primera vez que se utiliza un tamaño de región mayor que 1 con el pushoperador para obtener un valor específico en la pila.

Como siempre comienza en la esquina superior izquierda moviéndose a la derecha. Las primeras 2 operaciones pushun 1 en la pila y luego outputya que la secuencia de Fibonacci comienza con dos 1, pero el ciclo principal del programa solo imprimirá 1 una vez. Luego pushquedan 2 1s más en la pila para terminar en el magenta oscuro en la esquina superior derecha para iniciar el ciclo principal del programa.

Desplazándonos por el lado derecho duplicatee outputimprimimos el siguiente término de la secuencia, luego duplicatenuevamente para obtener una copia del valor de secuencia actual. Mover a la izquierda por la parte inferior ejecuta 2 pushoperaciones. Dado que la región roja clara en la esquina inferior derecha tiene un tamaño de 3 codeles, el primero pushempujará un 3 en la pila en lugar de un 1.

Ascender a la luz azul es una rolloperación. Esto extrae los 2 valores superiores de la pila y realiza una cantidad de rollos igual al primer valor reventado, a una profundidad igual al segundo valor reventado. En este caso, realizará 1 tirada a una profundidad de 3. Una tirada a profundidad ntoma el valor más alto de la pila (nuestro valor actual duplicado) y lo entierra nprofundamente. Nuestra pila tiene solo 3 de profundidad en este momento, por lo que enterrará el valor superior en la parte inferior.

Subir una vez más realiza una addoperación que suma el valor de secuencia actual con el valor de secuencia anterior. Nuestra pila ahora tiene el siguiente valor de secuencia (nuevo actual) en la parte superior y el último valor debajo. El programa ahora se mueve a través del blanco hacia el magenta oscuro para comenzar el ciclo nuevamente.

El patrón amarillo en el medio nunca se usa.

54 codeles

Imprime "hola!" stdout

No es un mensaje particularmente largo, pero imprimir en piet requiere una cantidad sorprendente de espacio. La impresión se realiza mediante el uso de valores Unicode, y los enteros se insertan en la pila utilizando el tamaño de la región que se está saliendo. Como tenemos un número muy limitado de códeles para este desafío, utilizamos algunas matemáticas para llegar al rango de impresión que queremos.

El programa comienza con un push5 de la región cian a la izquierda. A partir de aquí, fluye a lo largo de la parte superior con 6 duplicateoperaciones para preparar la pila con un montón de 5s. El siguiente es push1, subtractpara poner un 4 en la parte superior de la pila, luego 2 multiplyoperaciones para poner 4 * 5 * 5 = 100 en la parte superior de la pila. Luego a duplicatepor 2 100s.

Ahora el programa rebota en el negro y comienza a trabajar hacia la izquierda en la parte inferior. Pushoperaciones de 3 y 2 y luego a rollpara enterrar los 2 100 bajo un 5. Luego sigue push1, resta y suma para obtener 100 + 5-1 = 104 en la parte superior de la pila, que es unicode "h". Las siguientes 2 operaciones son push1 y pointerdar la vuelta a la esquina y comenzar a moverse a la derecha en el medio, y luego outputimprimir "h".

El siguiente es add100 + 5 = 105 en la parte superior de la pila, y outputpara imprimir "i". La pila ahora contiene dos 5s. Push1, add, multiplyda (1 + 5) * 5 = 30. Finalmente push3 y addpara 33, y outputpara el final "!". El programa luego pasa a la derecha a través del espacio en blanco restante para terminar en el verde a la derecha.

> <> (Pescado)

(Nota: algunos fragmentos se basan en fragmentos anteriores, por lo que, a diferencia de la mayoría de las respuestas, he decidido ponerlas de la primera a la última).

Hecho:

Al igual que Befunge,> <> es un lenguaje 2D basado en pila. Esto significa que las instrucciones no se ejecutan linealmente como la mayoría de los lenguajes tradicionales: ¡el flujo del programa puede ser arriba, abajo, izquierda o derecha!

Fragmento de longitud 1:

X

Xes un comando no válido en> <>, por lo que something smells fishy...se imprime el mensaje de error . De hecho, este es el único mensaje de error en> <>, ya sea que la causa sea la división por cero o que intente reventar una pila vacía.

Fragmento de longitud 2:

1n

El flujo del programa en> <> comienza desde la parte superior izquierda e inicialmente es hacia la derecha. 1empuja un 1 en la pila, luego lo nimprime como un número (en oposición a un carácter ASCII). Pero los programas> <> son toroidales, lo que significa que el puntero de instrucción se ajusta cuando llega al final de una línea. Entonces, después del najuste al principio, presione un 1, imprima, ajuste al principio, presione un 1, imprima ... ¡y terminamos imprimiendo 1s para siempre!

Fragmento de longitud 3:

"o;

Aquí "está el análisis de cadenas, osale como un carácter ASCII y ;termina el programa. Pero, ¿qué hace realmente el programa en su conjunto?

Bueno, primero comenzamos el análisis de cadenas, empujando todos los caracteres que vemos en la pila hasta que encontramos un cierre ". Presionamos un o, luego un ;... y ajustamos el puntero de instrucción de nuevo al inicio. Pero ahora estamos en un "modo de detener el análisis de cadenas, y finalmente ejecutamos oy, ;como de costumbre, para imprimir la parte superior de la pila (the ;) y terminar.

Sí, ¡acabamos de utilizar el mismo carácter de comillas para iniciar y finalizar una cadena!

Fragmento de longitud 4:

42n;

Según lo que hemos visto hasta ahora, puede esperar que esto empuje 42, la salida como un número y luego termine. Pero todas las instrucciones en> <> son caracteres únicos, por lo que esto realmente empuja un 4 y un 2 , luego genera la parte superior de la pila como un número (solo el 2) y termina.

Fragmento de longitud 5:

<v
;>

Recuerde,> <> es un lenguaje 2D. ¡Esto significa que tiene que haber formas de cambiar la dirección del flujo del programa!

Al igual que Befunge, una forma de hacerlo es a través de las flechas >^v<. Para ilustrar cómo funcionan, veamos el programa anterior:

• El flujo del programa es inicialmente hacia la derecha
• < hace que el programa fluya hacia la izquierda: salimos por la izquierda y nos acercamos al v
• v hace que el programa fluya hacia abajo - bajamos al >
• > hace que el programa fluya hacia la derecha: salimos de la derecha y nos acercamos al ;
• Finalmente terminamos.

Fragmento de longitud 6:

";"00p

Otra característica interesante de> <> es que es reflexivo: ¡el programa puede modificar su propio código fuente sobre la marcha!

Aquí presionamos a ;, seguido de dos ceros. pa continuación, hace estallar los tres primeros elementos y, x, v( ysiendo la parte superior de la pila) y lugares ven la posición x,y. En otras palabras, el pen este programa pone un punto y coma en la posición 0,0, convirtiendo el código en ;;"00p. Esto permite que el programa finalice, ya que el puntero de instrucción ahora se ajusta y ejecuta el recién colocado ;.

Fragmento de longitud 7:

\7*n;
6

A diferencia de Befunge,> <> también tiene espejos ( \/|_#) que reflejan la dirección del flujo del programa. Entonces aquí nosotros:

• Comienza hacia la derecha, pero \nos refleja hacia abajo
• Empuja un 6 y envuelve
• Golpea la parte trasera del \y reflexiona de nuevo a la derecha
• Empuja un 7
• Multiplica los dos primeros de la pila
• Salida y terminación

Moverse horizontalmente a través de un _espejo o verticalmente a través de un |espejo es un no-op.

Fragmento de longitud 8:

"r00g>o<

Posiblemente el más simple> <> quine si se permite lanzar un error. Las dos nuevas instrucciones aquí son:

• r: Invierte la pila
• g: Get - pop y, xy empuja al personaje a x,yla pila (contraparte de p)

Usando el truco de ajuste de cadena de antes, el programa inicialmente empuja y r00g>o<luego golpea la primera cita nuevamente. La pila se invierte, dando <o>g00r. Después de eso, empujamos el char a 0,0, the ", para dar <o>g00r". Finalmente, atrapamos una oentre dos flechas, sacando la parte superior de la pila hasta que no quede nada y obtengamos un error.

Fragmento de longitud 9:

x0\>
\1n>

x(minúscula) mueve el puntero de instrucciones en una dirección aleatoria, y el programa muestra esta funcionalidad al imprimir bits aleatorios para siempre. ¡Intenta seguir las flechas y los espejos para descubrir cómo funciona esto! (No te olvides de revisar las cuatro direcciones, incluyendo arriba y izquierda)

Fragmento de longitud 10:

;a comment

No hay sintaxis de comentarios en> <>: no necesita uno. ¡Solo escribe lo que quieras en cualquier lugar y asegúrate de que no se ejecute como código!

Fragmento de longitud 11:

1!X2!X+!Xn;

!es un trampolín que omite las instrucciones. Es particularmente útil cuando se usa con ?un trampolín condicional que aparece en la parte superior de la pila y ejecuta la siguiente instrucción si el elemento emergente no es cero. Veremos cómo funciona esto más adelante.

El código anterior imprime 3 saltando sobre Xs, solo ejecutándose 1! 2! +! n;.

Fragmento de longitud 12:

01v
ao>:@+:n

Imprime los números de Fibonacci para siempre a partir del segundo 1, uno en cada línea. Los nuevos comandos son:

• a: Presione 10, que necesitamos para la nueva línea. a-fempuje 10 a 15 respectivamente.
• :: Duplicar la parte superior de la pila
• @: Rotar los tres primeros elementos de la pila, por ejemplo [5 4 3 2 1] -> [5 4 1 3 2].

Rastreo de las primeras iteraciones:

Fragmento de longitud 13:

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

Un programa "tac" que lee en una línea de entrada y las salidas invertidas. Gracias a @tomsmeding por el fragmento.

=muestra los dos elementos superiores y empuja 1 si son iguales, 0 de lo contrario. La primera línea sigue leyendo en la entrada hasta que se encuentra ASCII char 13 (retorno de carro), en cuyo punto se mueve a la segunda línea.

El l?!;obucle es una construcción importante en> <> que genera la pila completa. A diferencia >o<, no causa ningún error. Así es como funciona:

• l empuja la longitud de la pila
• Verificamos la longitud con ?:
  • Si la longitud no es cero, !se ejecuta la siguiente instrucción , omitiendo;
  • Si la longitud era cero, entonces no ejecutamos !y terminamos debido a la;

Tenga en cuenta que en realidad no se produce ninguna salida hasta que se alcanza el retorno de carro.

Fragmento de longitud 14:

32.

   X67*n;

Además de cambiar la dirección del flujo del programa, ¡puedes mover el puntero de instrucciones a donde quieras!

.pops y, xy se teletransporta el puntero de instrucción a x,y, manteniendo la dirección. Sin embargo, tenga en cuenta que debe moverse a un cuadrado antes de donde desea ir: el puntero de la instrucción se actualiza antes de que se ejecute la siguiente instrucción. Entonces, aquí el puntero de instrucción aterriza en el inválido X, pero todo está bien ya que el puntero se mueve al 6antes de continuar la ejecución.

.hace posible convertir la mayoría de los programas> <> en una sola línea, pero ¿por qué querrías perder la diversión del 2D? :)

Fragmento de longitud 15:

01+:aa*=?;:nao!

Imprime los números 0a 99, uno en cada línea. Este programa demuestra un uso ordenado del !trampolín, para garantizar que el 0 inicial solo se presione una vez.

Fragmento de longitud 16:

"r00g!;oooooooo|

Una quine adecuada que no arroja errores, inspirada en la quine en la página de esolang .

Si te preguntaste cómo modificar la quine anterior (fragmento # 8) para que no causara un error y pensaste "¿por qué no agrego un montón de oinstrucciones?", Entonces podrías darte cuenta de eso por cada oadición. , necesitas dar salida a otro o! Esta quine resuelve perfectamente el problema al colocar un |espejo al final, lo que permite que cada uno ose use dos veces .

Si cambiamos a comillas simples (que también son para el análisis de cadenas), entonces una quine alternativa que no usa ges

'r3d*!;oooooooo|

Fragmento de longitud 17:

b2,63,.

   17,n;

Tenemos suma ( +), resta ( -), multiplicación ( *), módulo ( %) ... pero ¿qué pasa con la división? Está allí, pero como ya /es un espejo, a la división se le ha asignado el ,símbolo. Curiosamente, la división es división de flotación , no división entera.

El programa anterior explora algunos comportamientos indefinidos al intentar saltar 11/2, 6/3. El intérprete de Python parece estar bien si la primera coordenada no es un número entero (aunque salta al lugar equivocado), pero se ahoga si la segunda no lo es.

Fragmento de longitud 18:

123456${{$}nnnnnn;

Hemos visto rqué invierte la pila y @qué rota los tres elementos superiores. Aquí hay algunos comandos más que mueven elementos en la pila:

• $: Intercambia los dos elementos superiores
• {: Desplazar toda la pila a la izquierda
• }: Desplaza toda la pila a la derecha

Para mostrar cómo funciona esto, aquí está el seguimiento del programa:

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

Luego salimos, dando 256431.

Fragmento de longitud 19:

"reward"4[roooo]oo;

Hasta ahora he estado diciendo "la pila", "la pila" ...

Aunque la mayoría de los programas usan solo una pila,> <> en realidad puede tener múltiples pilas. Aquí están las instrucciones relevantes:

• [: Hace estallar xy mueve los xelementos superiores a una nueva pila
• ]: Elimina la pila actual y mueve sus valores a la pila subyacente.

Aquí está el rastro para el programa anterior:

       [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

Tenga en cuenta que simplemente presionando rewardy luego volviendo a ooooooimprimirlo se imprimiría drawer, debido a la naturaleza de "primero en entrar , último en salir" de las pilas.

Fragmento de longitud 20:

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

Una característica poco conocida de> <> es que, como Python, las barras invertidas pueden usarse para la continuación de línea en muchos casos. *

El código anterior es funcionalmente el mismo que

aa*5+7a*2+oo;

^{* Descargo de responsabilidad: la razón por la que esto funciona puede o no ser por una razón completamente diferente}

Fragmento de longitud 22:

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

Además de las pilas,> <> también tiene registros (uno para cada pila) que se pueden usar para almacenar valores. Llamar &por primera vez mueve el valor superior de la pila al registro, y ejecutar &nuevamente mueve el valor hacia atrás. Esto puede ser muy útil cuando se acumula un valor, por ejemplo, sumas y factoriales.

El programa anterior calcula el factorial de f(15), imprimiendo 1307674368000. Aquí está el rastro para freemplazar con 4:

Fragmento de longitud 24:

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

¡Tenemos suficientes caracteres para el programa favorito de todos! Aquí usamos el .teletransportador para el bucle de salida.

Fragmento de longitud 25:

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

Desafortunadamente> <> solo permite leer de STDIN un carácter a la vez, lo que hace que la lectura de números sea un poco complicada. Para la entrada que consta de dígitos 0-9, este programa es esencialmente atoi, y convierte una cadena de dígitos de STDIN en un número en la pila (que luego se imprime).

Otra nota es que en EOF, iempuja -1 en la pila. Esto facilita la comprobación de EOF al comparar con 0 usando (, o "menor que".

Este fragmento también usa ~, que muestra y descarta el elemento superior de la pila.

Fragmento de longitud 33:

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

Hasta ahora, la mayoría de los fragmentos han sido relativamente lineales, o eran simples ejemplos que demuestran la funcionalidad de> <>. Ahora puedo dar un ejemplo que destaca lo fácil que es visualizar el flujo del programa en> <> con un programa bien diseñado.

El programa lee en un solo carácter ASCII y ejecuta el 3x+1algoritmo en su punto de código (En> <>, los caracteres son básicamente enteros). Cada paso del algoritmo se imprime hasta llegar a 1.

Aquí hay un seguimiento de las primeras iteraciones con entrada a(punto de código 97):

Fragmento de longitud 44:

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

No creo que haya hecho pjusticia al comando, ya que solo lo he usado una vez en el fragmento # 6, así que aquí hay una función atoi diferente. ¿Qué tiene de bueno este? ¡El programa escribe la expresión necesaria para calcular el número mientras lee la entrada!

Entonces, para entradas como 573, después de leer todos los caracteres, se verá el final de la tercera línea \0a*5+a*7+a*3+, que se evalúa como 573.

Una vez más, se espera que la entrada sea solo dígitos. Traza GIF aquí .

Fragmento de longitud 74:

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

Si has logrado llegar hasta aquí, entonces podrías estar de acuerdo conmigo cuando digo que este es un programa ROT13 muy legible. Dado un carácter c1, encontramos el primer carácter c2en AN[an{, de modo que c1 < c2, luego, aplicamos el desplazamiento apropiado sumando / restando d(13). Tenga en cuenta que [y {son los caracteres directamente después Zy zrespectivamente.

¡Pruébalo en la consola y observa cómo se transforman las letras mientras escribes!

^{(También puede canalizar la entrada, pero como me falta la verificación EOF, :0(?;se detendrá con un error cuando intente imprimir -1 como un carácter)}

C - editar

Gracias por los votos! En comparación con otros lenguajes y lo que pueden hacer en bytes limitados, C parece obsoleto, exigente y demasiado dependiente del desarrollador. En muchos sentidos lo es: los lenguajes de secuencias de comandos y de nivel superior con administración automática de memoria son mucho más expresivos y más rápidos de producción que C.

Entonces, ¿por qué característica C?

El secreto oculto detrás de todos esos lenguajes de script es que los intérpretes probablemente estén escritos en C (o más recientemente, C ++ o Java). Los primeros compiladores de C ++ realmente compilados en código C. De hecho, hasta que haya un mercado para un compilador directo, generalmente es más rentable escribir un compilador para generar C y luego compilarlo.

Si está trabajando en plataformas muy pequeñas, tal vez incluso sin un sistema operativo disponible, es probable que esté trabajando en C. En estos días, casi todos los dispositivos tienen un microcontrolador incorporado, sin duda programado en C. Cuando lo necesitan pequeño y rápido, C es el camino a seguir. (También FORTH, para los masoquistas).

Saber C te lleva lo más cerca posible del metal sin entrar en el ensamblador, y te ayuda en otros idiomas. Tienes una buena idea de cómo funciona probablemente una función virtual de C ++. Cuando escribe esas funciones recursivas de paso por valor en PHP, sabe que internamente está haciendo mucha asignación y copia de memoria, por lo que instintivamente prueba pasar por referencia. Las devoluciones de llamada y las referencias no asustan a los desarrolladores de C, aunque tal vez Haskell sí.

Como Kernighan y Ritchie mencionaron en su prefacio del clásico lenguaje de programación C , segunda edición, C no es un gran lenguaje, y no está bien servido por un gran libro. Estoy tratando de seguir este consejo: los ejemplos hacen doble, triple o más tareas si es posible.

Todos los fragmentos son al menos compilables por sí mismos. Los que son vinculables y ejecutables se indican como tales. Sé que esto no es un requisito, pero lo hace más simple que tratar de explicar el marco requerido para que cualquier fragmento de código funcione.

También traté de asegurarme de que cada fragmento de código fuera lo más corto posible para que no esté introduciendo espacios adicionales solo para rellenar a una cierta longitud. En los casos en que el código está sangrado, las sangrías no se incluyen en la longitud, solo un carácter para cada nueva línea.

Factoid

C rocas.

Longitud 0 fragmento

El programa de autorreproducción más corto del mundo http://www.ioccc.org/1994/smr.hint

Fragmento de longitud 1

;

C hace una distinción entre compilar y vincular. Muchas entidades en C simplemente se compilan y vinculan más tarde; un ejemplo son todas las bibliotecas estáticas y dinámicas.

Otras entidades simplemente se incluyen y no generan código por sí mismas.

¡El punto y coma anterior ciertamente se compilará en código objeto, y no hará nada!

Fragmento de longitud 2

x;

C, al ser un lenguaje de programación más antiguo, ha pasado por varias iteraciones. El primero en uso generalizado fue desarrollado por Kernighan y Ritchie y abreviado K&R. K&R C es notable por hacer muchas suposiciones sobre su código si no las proporciona explícitamente.

En particular, en K&R C, se supone que el código anterior es un entero global xinicializado a 0. Compilarlo en modo K&R producirá un archivo de objeto que proporciona cualquier programa que vincule esta variable para su uso.

Fragmento de longitud 3

??/

C está tan extendido que necesita proporcionar características de compatibilidad para sistemas que no tienen todos los caracteres que usa. Lo anterior es un trigrafo para la barra diagonal inversa, que se utiliza en C como un carácter de continuación de línea. Lo anterior se compilará, probablemente con una advertencia de que no hay una línea siguiente.

Una cultura común en C es ignorar las advertencias de compilación, y muchas bases de código grandes invariablemente tienen algunas o más advertencias cuando se están construyendo.

Fragmento de longitud 4

f();

De nuevo con K&R, lo anterior se "completa" para que signifique en la compilación que "Existe, con un enlace global, una función fque se proporcionará más adelante, que toma un número fijo pero no especificado de argumentos y devuelve un número entero".

Tenga en cuenta las diferencias fundamentales entre esto y f;.

Fragmento de longitud 5

s="";

K&R C es notable por ser verdaderamente indulgente. Tras la compilación, este código proporcionará un número entero spara el enlace global que se inicializa en la dirección inicial de una cadena vacía (creo). K&R maneja silenciosamente todas las coacciones, incluido el truncamiento si un número entero no es lo suficientemente grande como para contener la dirección.

Son construcciones como estas las que han generado muchos errores difíciles de encontrar y han proporcionado mucha inspiración en las competiciones de IOCCC.

Fragmento de longitud 6

o=042;

Un truco de incluso antiguos temporizadores, un 0 inicial en un número literal significa que los siguientes dígitos están en la base octal. El código anterior, una vez compilado, proporcionará un número entero opara el enlace global inicializado al decimal 34.

¡Esta característica de C ha mordido a muchos desarrolladores que se esfuerzan por rellenar sus números para que se alineen de manera agradable e incluso!

Fragmento de longitud 7

f(){f;}

El código anterior es una función con un cuerpo. Pero, ¿qué hace? ¡Recupera la dirección de la función y no hace nada con ella! Normalmente, lo que devolverá la función no está definido. Un código sin sentido como este a menudo puede compilarse sin previo aviso.

Fragmento de longitud 8

main(){}

Esto representa el código compilable y enlazable más corto en C. Mientras que en las versiones modernas de C, las funciones generalmente no pueden definirse implícitamente, por razones históricas esta restricción es relajada main.

Esta maravilla de un programa, que no hace más que devolver 0, se compilará a un tamaño no despreciable y se vinculará en varias rutinas de tiempo de ejecución de C. Puede compilar y vincular con un nivel de verbosidad completo para ver lo que sucede debajo del capó.

Fragmento de longitud 9

#define Z

Un pilar de los archivos de encabezado C es la #definedirectiva de preprocesador. Los programas C se compilan en varias etapas, y en una de estas etapas estas definiciones se sustituyen con sus valores reales.

Cuando falta un argumento, C implicará 1, por lo que lo anterior sustituirá 1donde Zse use en el código fuente.

Lo anterior normalmente se colocaría en un archivo de encabezado #includeyd según sea necesario.

Fragmento de longitud 10

enum{P,Q};

La enumpalabra clave proporciona una forma a veces segura de escribir para definir una serie de constantes. Como define, a menudo se usan en archivos de encabezado. El código anterior cuando se incluye se definiría Pcomo un entero de 0 y Qde 1.

Fragmento de longitud 11

volatile v;

La volatilepalabra clave es informar al compilador que otros agentes pueden cambiar una variable y no hacer suposiciones de que permanecerá constante entre los accesos.

Longitud 12 fragmento

#pragma once

#pragma once es una directiva de preprocesador no estándar pero ampliamente compatible para indicar que el archivo fuente actual se incluya solo una vez en una sola compilación.

La técnica tradicional y totalmente compatible es utilizar #includeguardias con las desventajas de agregar código y posibles conflictos de nombres.

Fragmento de longitud 13

w(){for(;;);}

Existen numerosas convenciones en C, y una de ellas es cómo representar bucles infinitos. En este caso, for(;;)indica que no hay inicialización, no hay verificación de salida, que por defecto es 1, lo que significa verdadero, es decir, no se rompe y no hay código de bucle.

En algún momento es posible hacer todo dentro del ()bucle y no necesita cuerpo. En este caso, se agrega un punto y coma al final.

En el código anterior, cuando se compila, proporcionará una función que entrará en un ciclo de ocupado apretado, uno de los no-no en el diseño de software, y nunca regresará.

Fragmento de longitud 14

int a[]={1,2};

Las matrices en C no necesitan las longitudes especificadas. Los corchetes vacíos le []dicen al compilador que "lo descubras tú mismo". Sin embargo, en C, a diferencia de otros lenguajes, no hay una forma integrada de evitar el acceso a una matriz fuera de estos límites, lo que lleva a la metáfora "disparate en el pie" por la que C es conocido.

El código anterior, cuando se compila, proporcionará una matriz global mutable ade dos enteros inicializados con 1 y 2.

Fragmento de longitud 15

const long k=7;

El constespecificador es una adición posterior a C prestada de C ++. Una pregunta común de la entrevista es "¿Tiene sentido definir una variable como volatile const?". constjunto con enumy inlineestán destinados a reducir la dependencia de los #defineproblemas de seguridad de tipo.

Fragmento de longitud 16

extern void **q;

externse utiliza para indicar que una variable se declara en otro lugar. El void *tipo es el tipo genérico estándar en C, lo que significa que no es necesario convertirlo explícitamente ni en las declaraciones de asignación. La **secuencia del operador significa puntero a un puntero, que a menudo hace volar las mentes de los novatos, pero es perfectamente válido y a menudo se usa C.

Fragmento de longitud 17

double d=4/3-1/3;

Si imprimieras lo anterior, el resultado sería uno, y pensarías, ¡super! Cambiar double d=4/3-2/3;y ¿cuál es la respuesta? ¡Sigue siendo uno! ¡C está usando aritmética de enteros para calcular 4/3 → 1 y 2/3 → 0, y 1 - 0 → 1!

Longitud 18 fragmento

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

¡Finalmente llegamos a un código que realmente hace algo! putses un favorito de los golfistas de C porque no requiere un archivo de encabezado para usar.

putstambién agregará un avance de línea a la salida. Por el contrario, su contraparte getseliminará los avances de línea. Nunca se debe usar, getsexcepto en circunstancias muy controladas: no tiene protección para los desbordamientos del búfer y es la causa principal de muchos exploits.

Fragmento de longitud 19

#include <stdlib.h>

La inclusión de archivos de encabezado suele ser una firma personal de los desarrolladores. Muchos incluyen libe ioindependientemente de si son necesarios. Algunos ordenan los archivos de encabezado para que las longitudes aumenten o disminuyan. La mayoría pone <>antes "". Personalmente, he usado esta firma en mis días de asistencia técnica para comprobar si hay trampa entre los estudiantes: ¿la misma firma de encabezado? ¡mira más de cerca!

Fragmento de longitud 20

char*p=(char*)0x300;

C está diseñado para ser utilizado en plataformas rudimentarias de muy bajo nivel. En algunos casos, es posible que necesite acceder a puertos especiales asignados a memoria directamente.

En el código anterior, la dirección de un puerto se define como hexadecimal 300. Para acceder al valor del puerto *p, use , como *p=0xff;para activar todos los bits o v=*p;para recuperar el valor actual.

Fragmento de longitud 21

int w=sizeof(double);

El sizeofoperador proporciona el tamaño en bytes de un tipo. Con nombres de variables, los corchetes no son necesarios, por ejemplo double d;int w=sizeof d;.

Fragmento de longitud 22

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

El asmcompilador define cómo se utilizará. Lo anterior es un ejemplo de código en línea gcc de Linux en una plataforma Intel.

El Unix original tenía una fracción pequeña pero no despreciable de su código en ensamblador. Incluso hoy, si la velocidad es la principal preocupación y la portabilidad no lo es, verá que se usa.

En sistemas compatibles, el código anterior se compilará, ¡y será literalmente una instrucción de ensamblaje aislada sin medios convencionales para acceder a ella! Por cierto, xor R,Res un lenguaje común de lenguaje ensamblador para borrar un registro rápidamente.

Fragmento de longitud 23

union u{char c;int i;};

A unionproporcionará al menos suficiente espacio para el elemento más grande. Puede ver que se usa junto con void *para proporcionar un tipo "opaco" común en ciertas bibliotecas. En este caso, la unión generalmente será parte de una estructura más grande, con la estructura con un campo para identificar el tipo de unión.

Longitud 24 fragmento

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

El comentario original de C se delimitó como /* comment */, y tomó prestado el // comment to end of lineformato de C ++.

Fragmento de longitud 25

int main(void){return 1;}

Esta es la versión más compatible del fragmento de longitud 8 anterior. Se especifican el tipo de retorno y los tipos de función, y tiene un valor devuelto explícitamente.

La convención en C es usar un valor de retorno de 0para el éxito y el 1fracaso, o si desea ser estrictamente conforme EXIT_SUCCESSy EXIT_FAILUREcomo se define en stdlib.h.

Longitud 26 fragmento

typedef struct{int x,y;}P;

typedefes extremadamente útil, en particular, typedef struct. En términos modernos, podría llamarlo "luz de orientación a objetos".

Después de incluir lo anterior, el código puede usarse Pcomo un tipo regular en declaraciones y funciones, con verificación de tipo completa. Sin embargo, a diferencia de C ++, no puede definir operadores como +, * o <<, por lo tanto, "objeto-orientación-luz".

Fragmento de longitud 27

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

C tiene una conveniente #definesintaxis macro .

Un error de novato común es omitir los corchetes internos y / o externos, lo que resulta en errores de precedencia del operador difíciles de encontrar.

Fragmento de longitud 28

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

C puede definir explícitamente campos de bits que pueden asignarse, leerse y manipularse como cualquier número entero.

Lo anterior es una aproximación de una estructura de datos de coma flotante de ancho único IEEE.

Fragmento de longitud 36

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

En muchos idiomas, no necesita preocuparse por cómo se representan los números. En C, debe ser íntimamente consciente de su representación interna.

El mejor ejemplo de esto que puedo pensar es determinar si un entero es una potencia de dos {1, 2, 4, 8, ...}. Aquellos que no estén familiarizados con C harán bucles y cambios y todo tipo de cosas para el tiempo de ejecución de O (log (n)), no está mal, pero arriba es una función que hará lo mismo en el tiempo de ejecución de O (1). Lo dejaré como ejercicio para que el lector confirme que funciona, pero realmente funciona ...

La !!convención se usa a menudo para obligar a un entero de distinto de cero y cero a 1 y 0 respectivamente. A muchos desarrolladores de C les gusta usar este tipo de trucos (a menudo en desacuerdo con aquellos que valoran la claridad del código).

Los desarrolladores súper entusiastas de C pueden confirmar que lo anterior funcionará en hardware complementario y firmado. Para aquellos que se preguntan, es casi seguro que trabajarán en hardware de dos complementos en este momento. ¡Solo los realmente afortunados (o desafortunados según su perspectiva) deben preocuparse por esto!

Longitud 48 fragmento

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

C99 incluye soporte para números complejos. Como puede ver en el código, toma la forma de un modificador para un tipo real. También podría usar, int complex c=3+I*4;pero internamente coacciona a un tipo de punto flotante. El código anterior se compilará en gcc usando gcc -std=c99 -c length-48.c.

Si desea ver más aspectos internos, intente compilar con el modificador -E. Para mi versión de gcc, la declaración anterior se convierte en double _Complex c=3.0+(__extension__ 1.0iF)*4.0;. Tenga en cuenta que el tipo complejo es una adición significativa al lenguaje, no solo unas pocas macros baratas.

¡Esto es solo un adelanto, cuando llegamos a más de 125 caracteres, entonces podemos comenzar a divertirnos realmente con números complejos!

Fragmento de longitud 51

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

Por varias razones, C no se vincula automáticamente a las funciones matemáticas estándar como sin, cos, tan, sqrt, etc. Por lo tanto, si se usan, pero no están vinculadas, se mostrará al desarrollador la referencia indefinida de error del vinculador a 'sqrt' , o algún otro error.

En gcc, el código anterior se compilará y vinculará usando gcc length-51.c -lm.

Note sin(3.2)devolverá un número negativo, del cual la raíz cuadrada no es legal en el dominio real. En C, NaNse devuelve un valor especial para indicar este error, que el programa puede ignorar.

En C99, hay muchas nuevas funciones de manejo de excepciones para proporcionar un control muy seguro y detallado de este tipo de errores matemáticos, ¡que casi nadie usa!

Fragmento de longitud 63

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

O formateado de manera más sensata:

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

Como habrás adivinado, se trata de la palabra clave staticque tiene más de un significado en C.

En los primeros dos casos, staticle dice al compilador que el entero wy la función Xno son visibles fuera de este archivo o unidad de compilación, es decir, son internos.

Estas funciones no están destinadas a ser llamadas externamente, por lo que podrían no verificar la validez de los argumentos y cortar otras esquinas. Debido a que tienen un alcance interno, puede redefinir wy Xen otros archivos, y generalmente estarán separados.

En el último caso, staticindica que el entero sretiene su valor entre llamadas a funciones. La primera vez que Xse llama sserá su valor inicial 7, cuando se ordene con exclusividad, se retendrá xel nuevo valor.

Internamente, aunque depende de la implementación, la organización de memoria habitual es la que sreside en el montón, específicamente la memoria inicializada, mientras que el argumento xreside en la pila. Donde residen las variables es importante si desea implementar algoritmos recursivos, por ejemplo.

Un gotcha en C son choques con variables globales. Hasta wy Xen realidad están definidos como static, si se definen globalmente en algún lugar, a continuación, wy Xse referirán a las entidades globales en su lugar.

Aquí qy wno se puede inicializar con el mismo valor, porque wse está utilizando un global para establecer q:

static int q = w;
static int w;

Si wno existe un global , la compilación debería fallar.

Aquí qy wse inicializará con el mismo valor:

static int w;
static int q = w;

Por lo general, los diseñadores reducirán los conflictos de nombres al agregar un prefijo o sufijo distintivo a sus variables y funciones globales.

En C99, staticha ganado otro uso, por ejemplo, lo int Y(int a[static 10]);que significa que hay una función Yque toma una matriz de al menos 10 enteros.

Fragmento de longitud 74

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

O bien presentado:

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

La palabra clave registerproporciona una pista al compilador de que el uso de registros de hardware sería beneficioso aquí. La función anterior copiará lenteros de qa p, utilizando registros de hardware si es posible.

A veces las aceleraciones pueden ser significativas. Por ejemplo, en la familia de microprocesadores 68K, la línea *p++ = *q++podría traducirse a una sola instrucción MOVE.W (Ap)+,(Aq)+frente a seis u ocho si no la usó register. El microprocesador 68K tenía modos explícitos de post-incremento y pre-decremento, por lo que el desarrollador inteligente, si conocía la plataforma, adaptaría el código usando x++y --yvs. ++xy y--.

En la actualidad, los compiladores ignoran la mayoría de las veces register, aparte de no permitir que se les tomen direcciones (por ejemplo, en lo anterior &lse produciría un error del compilador).

Fragmento de longitud 88

#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 diseño más sano:

#include <stdio.h>

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

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

¡Ah, recursión! El fragmento es un programa completo para compilar, vincular y ejecutar. La función fcalcula el factorial de su argumento xutilizando la fórmula recursiva f (x) = x * f (x - 1). Los factoriales crecen muy rápido, por lo que, por ejemplo, f(12)es el valor más grande que puede obtener en un entero de 32 bits con signo.

Para ver un ejemplo de código realmente recursivo, busque implementaciones ingenuas de la función de Ackermann .

Los compiladores inteligentes pueden optimizar la función, utilizando la sugerencia inliney "desenrollar" la función cuando se proporcionan constantes como argumentos para que:

f(12)

Se convierte en:

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

¡Sin ninguna función se requieren llamadas!

Otros compiladores pueden reorganizar la función:

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

E implementar algo llamado cola-recursión. En efecto, esto reemplaza la última llamada de función a un simple goto y permite que esa función se ocupe del retorno. El beneficio es menos intercambio de fichas, código más rápido y más pequeño.

En lenguaje ensamblador, este tipo de oportunidades de optimización son realmente fáciles de detectar y pueden implementarse mediante algo llamado "optimizador de ojo de cerradura", que básicamente busca pequeños patrones y los reemplaza por algo más rápido y / o más pequeño.

Fragmento de longitud 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 tomó prestado de los lenguajes contemporáneos de la época, el concepto de una E / S universal que se podía aplicar de manera consistente a cualquier dispositivo, ya sea consola, tarjeta perforada, cinta, disco o impresora, pero en forma verdadera de C, permitió al desarrollador crear declaraciones muy concisas pero poderosas.

En el fragmento anterior, tomará la entrada de la línea de comandos, analizará dos enteros separados por espacios, tabulaciones o comas y los generará. Aprovecha un scanfespecificador más nuevo %*[\t ,]que: [\t ,]extraerá todas las pestañas, espacios y comas, y los *ignorará.

Recuerdo haber revisado algún código de C ++ donde el desarrollador estaba haciendo todo de la manera "pura" de C ++ <<y un arsenal de métodos como findy substr. Era al menos una docena de líneas y todavía no podía manejar comas como delimitadores. ¡Reemplacé todo ese código torpe con una sola sscanflínea como la de arriba!

Longitud 132 fragmento

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

Las funciones printf, sprintf, fprintfespecificadores etc. formato utilizar para definir el ancho y el relleno de la salida.

Compile y ejecute lo anterior usando argumentos de línea de comando para ver las diferentes salidas:

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

Tenga en cuenta que la .5salida del especificador se limita a un máximo de cinco caracteres, mientras que el encabezado 5garantiza que la salida sea de al menos cinco caracteres, con -indicación de alineación a la izquierda. Combinarlos establece la salida en exactamente cinco caracteres.

Código de máquina x86

Hecho:

x86 Machine Code es la versión ensamblada de x86 Assembly que el procesador realmente ejecuta. Fue desarrollado cuando la memoria y el espacio de almacenamiento eran caros, y fue diseñado para ser algo compatible con Intel 8008. Mantener el código ejecutable pequeño era uno de los objetivos, y utiliza instrucciones de longitud variable y una arquitectura CISC para ayudar lograr esto (que ha tenido el inconveniente de hacer que sea más complicado mejorar el rendimiento en los procesadores modernos). Esto, junto con la naturaleza básica del ensamblaje y el código de máquina en general, le da a los programas x86 la capacidad de ser extremadamente compactos.

Longitud 1:

Ahora para el primer programa:

0xC3

Abra un editor hexadecimal, ingrese ese byte y guárdelo como test.com.

Ahora tiene un programa válido de MS-DOS que regresa inmediatamente sin hacer nada, ya que 0xC3 es la instrucción 'RET'. Sin embargo, esto muestra otro aspecto interesante para jugar golf con x86: el formato de archivo .com. Este formato ejecutable no tiene absolutamente ningún encabezado: el archivo simplemente se carga en la memoria comenzando en la dirección 0x100, y luego la ejecución se inicia en 0x100. ¡Esto significa que no se desperdician bytes en los metadatos!

Longitud 2:

Nuestro proximo programa:

0x4D 0x5A

o 'MZ' en ASCII.

Ok, hice trampa un poco, eso realmente no es un programa útil, ya que corresponde a las instrucciones

DEC     BP
POP     DX

Que en realidad no son útiles para iniciar un programa .com. De hecho, ese es el objetivo de esos dos valores: ¡ningún archivo .com razonable debería comenzar con ellos! Los archivos .com estaban limitados a 65280 bytes de tamaño (64KiB - 0x100), por lo que cuando comenzaron a necesitarse programas más grandes, se tuvo que desarrollar un nuevo formato. Este era el formato de archivo .exe, que tiene un encabezado. Sin embargo, MS-DOS necesitaba mantener la extensión .com en ciertos componentes para la compatibilidad con versiones anteriores, por lo que necesitaba una forma de detectar si un archivo .com era realmente un .exe. Eligieron la picadura 'MZ' como este número mágico, y hasta el día de hoy, si abre un archivo .exe (o .dll) de Windows en un editor hexadecimal, verá que comienzan con esos dos bytes. Me divierte que incluso el programa de Windows más moderno comienza con una restricción de compatibilidad de los años 70.

Longitud 3:

Ahora para un bucle infinito:

41 E2 FD

Lo que se traduce en

start:
inc cx
loop start 

Este programa incrementa el valor de CX (que será> 0 para comenzar), luego ejecuta la instrucción de bucle. Loop es un excelente ejemplo de una instrucción CISC, ya que combina 3 operaciones simples en una operación de propósito especial: disminuye el valor de CX, comprueba si es 0 y salta a la etiqueta de destino si no. También hay formas de bucle que comprueban otras banderas además de terminar cuando CX es 0. Podríamos haber hecho simplemente 'salto de arranque' para un bucle infinito de 2 bytes, pero esto fue más interesante.

Longitud 4:

Un programa que es mínimamente útil:

40 CD 10 C3

Traducido al ensamblaje:

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

Este programa establece la consola en 40x25 caracteres, borra la pantalla y luego vuelve a la línea de comando. AX está configurado en el modo de video que queremos (1), luego se llama a la interrupción del BIOS 10h para configurar realmente el modo de video y borrar la ventana, antes de regresar. Espere ver más de estas interrupciones de BIOS en el futuro.

Longitud 5:

Ahora podemos implementar un programa de pausa:

B4 01 CD 21 C3

Traducido al ensamblaje:

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

Este programa le dice al BIOS que espere a que se presione una tecla y lo muestra en la pantalla antes de regresar. Esto también demuestra cómo en el x86, algunos de los registros pueden leerse o escribirse parcialmente. En este caso, establecemos el byte superior de AX (AH) en 1. En los procesadores de 32 bits, también puede operar en los 16 bits bajos sin afectar los 16 bits superiores. Esta capacidad de modificar registros parciales puede ser útil para los programadores de ensamblaje, pero tiene inconvenientes para los procesadores modernos que intentan realizar una ejecución fuera de orden , ya que pueden introducir dependencias de datos falsos.

Longitud 9:

Ahora para mostrar realmente la salida:

68 00 B7 07 AB 40 79 FC C3

Traducido al ensamblaje:

; 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

La salida es el juego de caracteres predeterminado que se repite en diferentes colores. El byte bajo de AX es el código de caracteres, y el byte alto especifica los colores a usar.

Los programas de 16 bits solo pueden direccionar hasta 64 KB directamente. Para evitar esto, el x86 utilizaba 'segmentos': registros especiales que se multiplicarían por 16 y se agregarían a todos los accesos de memoria para proporcionar 20 bits de memoria direccionable. Un programa podría cambiar los valores de estos registros de segmento para acceder a más memoria, o áreas especiales de memoria: este programa modifica el segmento adicional para escribir en la memoria de video. Los diferentes tipos de acceso a la memoria utilizaron diferentes registros de segmentos, permitiendo que el código, los datos y la pila estén accesibles en diferentes fragmentos de memoria al mismo tiempo. El segmento predeterminado también podría anularse para muchas instrucciones.

Longitud 20:

Hagamos algo reconocible: utilizaremos la 'Regla 90' para dibujar triángulos de Sierpinski.

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

En asamblea:

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

Salida de muestra:

Para este programa, utilizamos el famoso 'Modo 13', un modo gráfico que tiene una resolución de 320x200 con 256 colores. Fue utilizado por muchos juegos populares de DOS , como Doom.

Longitud 21

Veamos quién fabricó la CPU en la que estamos corriendo

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

Traducido al ensamblaje:

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

Salida de muestra:

c:\misc>cpuid.com
GenuineIntel

Este programa utiliza la instrucción CPUID para obtener información sobre el procesador en el que se está ejecutando, en particular, la cadena de identificación del proveedor. La mayoría de las personas verá 'GenuineIntel' o 'AuthenticAMD', a menos que tengan un fabricante de CPU poco común o se ejecuten en ciertas máquinas virtuales.

Longitud 26

Ahora podemos hacer animaciones interesantes.

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

En asamblea

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 

Y la salida se verá así:

La función X pos ^ Y pos produce un fractal interesante, especialmente cuando está animado

Longitud 27

No solo puede generar texto y gráficos en un pequeño programa x86 .com, también puede generar sonido y música:

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

En asamblea:

    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  

Este programa usa la tarjeta midi para convertir el teclado en un piano. Para hacer esto, la tarjeta midi se configura en modo UART, que reproduce notas midi tan pronto como se reciben. A continuación, el programa espera a que se presione un carácter y muestra el valor ASCII como una nota en la tarjeta midi. El programa se ejecuta hasta que se presiona escape.

Longitud 29

Usemos un sistema de funciones iteradas para generar un fractal de curva de dragón:

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

Traducido al ensamblaje:

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  

Salida:

Al presionar una tecla sin control, el programa saldrá. Esto se basa en Fire Coral by Desire en Pouet.net.

Longitud 52

Este programa es una característica doble, muestra un poco del coprocesador de coma flotante x87 y el código de auto modificación.

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

Cuando se ejecuta, el programa generará varias constantes matemáticas:

1.00000000000000000
3.32192809488736235
1.44269504088896341
3.14159265358979324
0.30102999566398120
0.69314718055994531
0.00000000000000000

Estos son One, Log2 (10), Log2 (e), Pi, Log10 (2), Log e (2) y Zero.

En asamblea:

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 matemática de punto flotante en los sistemas x86 fue manejada originalmente por el coprocesador x87 opcional, no fue hasta el 486 que se movió al mismo chip. El x87 también tenía una arquitectura bastante diferente, estaba basado en la pila, con 8 registros de 80 bits disponibles. También tenía una variedad de modos de redondeo, precisión y excepciones enmascarables que se podían configurar.

Este programa imprime los valores de siete constantes cocidas en los procesadores. Puede parecer extraño que el espacio de instrucciones se desperdicie en constantes simples como 0 y 1, pero tenga en cuenta que el conjunto de instrucciones se creó cuando la memoria era pequeña, y estas instrucciones suelen ser 2 bytes más pequeñas que las operaciones equivalentes. El programa también utiliza una instrucción oscura, FBSTP -'Store BCD Integer and Pop '. Cuando se desarrolló el x86, las operaciones con números BCD eran más comunes, y el x86 / x87 tiene varias instrucciones específicamente para simplificar las matemáticas BCD, como la instrucción AAM 'ASCII Adjust for Multiple' también utilizada en el programa.

En el modelo de memoria desprotegida utilizado por los primeros programas x86, no hay distinción entre datos y código. Debido a esto, es fácil iterar a través de las instrucciones 'Load Constant' codificadas secuencialmente simplemente incrementando el valor apropiado.

Longitud 64

Al publicar mi entrada para el Reto Mandelbrot , se puede escribir un programa que muestre un fractal Mandelbrot de 320x200 colores en solo 64 bytes.

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

En asamblea:

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

El resultado final es esta imagen:

Este programa usa matemática de punto fijo para generar el fractal, ya que toma menos bytes. Los 6 bits más bajos de los registros de 16 bits se consideran la parte fraccionaria del número, y los valores se reescalan después de multiplicarse.

Haskell

Es posible que desee leer de abajo hacia arriba. A veces me refiero a fragmentos más bajos, pero nunca a los más altos, por lo que podría ayudar a comprender.

Lectores que no conocen a Haskell: ¿estoy claro? ¿Cuándo no estoy claro? No puedo decirlo

Fragmento de longitud 86

Una instancia plegable para nuestra estructura de datos de árbol (fragmento 23). Plegable es una clase de tipo, como en una clase (/ grupo) de tipos. Estos son paralelos a las interfaces en Java. Básicamente se generalizan sobre tipos, unificando tipos que tienen características comunes; por ejemplo, se pueden agregar juntos ( Monoid), contenedores ( Functor), se pueden imprimir como texto ( Showque ya conocimos, en la showfunción), etc. Éste unifica los tipos de datos que son parecidos a una lista, ya que se pueden iterar o aplanar en una lista.

En este fragmento, definimos la instancia definiendo foldr, que esencialmente itera sobre el tipo de datos de derecha a izquierda. Ahora, podemos usar un montón de código preescrito general. En primer lugar, se define una función auxiliar para conseguir un árbol único, para evitar todo el desorden: s a = N E a E. Ahora:

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]

y así.

Aquí hay una foto de nuestro árbol:

7
| \
3  5
    \
     8

Fragmento de longitud 70

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

Este es un tamiz de primera!

(nota: /=es lo que !=hay en otros idiomas)

Esto funciona definiendo una función sieveque filtra la lista y mantiene solo los números que no son divisibles por ningún primo anterior. Se define de forma recursiva: sievese define como dividir la lista en un primer elemento py una cola, filtrar de la cola cualquier número divisible por p, sieveel bit restante, adjuntar pal inicio de eso y volver.

Una vez más, estamos trabajando con listas infinitas aquí, pero el cálculo se detendrá con el tiempo siempre que no requiera una cantidad infinita de primos para calcular.

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

Fragmento de longitud 68

Finalmente, una quine!

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

En la primera vez que lees esto, podrías pensar que a la salida de este quine le faltarían comillas, y ¿por qué escribirías putStruna vez print? Suena igual

En Haskell, putStres una función que simplemente imprime el contenido de la cadena que llega a stdout; print, sin embargo, imprime cosas en stdout. Entonces, print 4es equivalente a putStr "4\n", pero no putStr 4tiene sentido, ¡ 4no es una cadena! Entonces, cuando printobtiene un valor, primero lo convierte en una cadena y luego imprime esa cadena. En general, la forma de convertir cosas en cadenas es encontrar la forma en que lo escribiría en código. Entonces, la forma en que escribiría la cadena abcen una cadena en el código Haskell es "abc", por lo que en print "abc"realidad se imprime "abc", no abc.

_{Qué afortunado tengo suficientes votos ahora, no tendré que jugar golf estas cosas}

Fragmento de longitud 33:

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

Lo importante a tener en cuenta es que no usamos un bucle. Haskell no se repite. Haskell recurre. Haskell no tiene bucles. Es más profundo que eso: Haskell ni siquiera tiene flujo de Control . ¿Cómo, podrías preguntar? Bueno, no necesita ninguno.

Con los detalles. Este programa imprime una secuencia infinita de números enteros, comenzando desde 0. los goimprime comenzando con su entrada, luego mainlo activa 0.

doEs un poder sintáctico especial de Haskell. En este escenario, solo combina acciones de E / S, al igual que lo >>hace (ver fragmento 22).

Fragmento de longitud 26:

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

Esto define la mapfunción, probablemente familiar para todos, usando foldr. Tenga en cuenta que aunque no declaramos mapel tipo, la computadora de alguna manera sabe que su tipo es (a -> b) -> [a] -> [b], es decir, dada una función de aa b, y una lista de as, devuelve una lista de bs.

¿Cómo lo supo? ;-)

Fragmento de longitud 25:

main=putStr"Hello World"

El estándar Hello World. Tenga en cuenta los tipos: maintiene tipo de IO ()y putStrtiene tipo de String -> IO ()(una función desde cadenas hasta acciones de E / S que no devuelven nada).

Fragmento de longitud 23:

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

Esta es una definición estándar de un árbol. Cuánto más fácil que todas esas líneas requeridas para definir un árbol en Java, C o cualquier otra cosa.

(ver fragmento 10)

Vamos a desglosarlo:

data- esta declaración declara un tipo de datos. T a- un árbol que contiene elementos de tipo a. Este es el tipo que estamos definiendo. =- cada valor de T aserá cualquiera de los siguientes, separados por una tubería |. E- uno de los posibles valores de T s- el árbol vacío. N (T a) a (T a)- el otro valor posible de un árbol - un nodo. Cada nodo consta del (T a)elemento secundario izquierdo ( ), el elemento ( a) y el elemento secundario derecho ( (T a)).

Fragmento de longitud 22:

main=putStrLn"y">>main

Una yesfunción de Haskell . >>es un operador que combina y secuencia dos acciones de E / S. Tiene tipo de >> :: IO a -> IO b -> IO b.

mainse define recursivamente por sí mismo, como la acción de E / S que primero imprime "y"y luego hace lo que sea que mainhaga.

Fragmento de longitud 18:

fix f=r where r=f r

Una mejor definición para fix. (Ver fragmento 14.) El problema con la primera definición, fix f = f(fix f)es que cada vez que llamamos fix f fixretiros fix f, que retiros fix f, generan infinitas copias del mismo cálculo. Esta versión lo arregla definiendo r(resultado) como el resultado; como tal f r = r,. Entonces, definamos r = f r. Ahora volvemos r.

Fragmento de longitud 17:

f n=product[1..n]

Esta es la forma funcional de definir factorial.

Fragmento de longitud 16:

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

(\x -> x + x + x)es una lambda (alguien pensó que se \parece a la letra).

(\x -> x + x + x) nes la lambda aplicada n(esto es exactamente lo mismo que n + n + n).

fes la función multiplicar por tres (también f = (*3))

Fragmento de longitud 15:

sum=foldl (+) 0

Esto define la sumfunción usando un pliegue. Un pliegue es básicamente un ciclo sobre los elementos de una lista con un acumulador.
foldltoma como argumentos alguna función fy algún valor inicial xpara el acumulador y una lista xs. La función fdebe obtener como entrada el valor del acumulador anterior y el valor actual de la lista, y devuelve el siguiente acumulador.
Luego, el pliegue itera en los valores de la lista, aplicando fel acumulador anterior, y luego devuelve el último acumulador.

Otra forma de pensar sobre los pliegues es como los pliegues 'insertos' fentre los valores de la lista y con el acumulador inicial en uno de los lados. Por ejemplo, foldl (*) 1 [4,2,5]evalúa a 1 * 4 * 2 * 5.

Fragmento de longitud 14:

fix f=f(fix f)

El ycombinador. Generalmente se llama fixporque encuentra el punto fijo de la ecuación f x = x. Tenga en cuenta que a x = infinite loopveces también puede ser una solución, por fix (\x -> x^2 + 5*x + 7)lo que no resolverá la ecuación, x^2 + 4*x + 7 = 0sino que devolverá un bucle infinito.

También puede notar que no siempre x = infinite loopes una solución, debido a la pereza de Haskell.

Esta versión es una fuga de tiempo y espacio; Lo redefiniremos en un fragmento más largo.

Fragmento de longitud 13:

f=sum.map(^2)

Esto define la función f que da una lista devuelve la suma de sus cuadrados. Es la función de la composición de la función sum y la funciónmap(^2) , que a su vez es la función map aplicada a la función (^2) (el cuadrado función ), que es a su vez una sección de la función ^ (secciones se introdujeron en fragmento 2, y composición en fragmento 3 )

Como puede ver, las funciones son bastante importantes en un lenguaje funcional como Haskell. De hecho, se ha dicho que Haskell es el lenguaje con las funciones de biblioteca más estándar que obtiene funciones como entradas o funciones de retorno como salidas (esto se conoce comúnmente como una función de orden superior .

Por cierto, técnicamente, cada función de argumento de dos o más es una función que devuelve funciones como salidas (esto se llama curry).

Fragmento de longitud 10:

data B=T|F

Esta es una definición de booleanos Haskell con diferentes nombres. El tipo booleano se llama B.
Esta definición introduce dos constructores: verdadero ( T) y falso ( F).
Este fragmento de código básicamente le dice al compilador que cada booleano ( B) es verdadera ( T) o falso ( F), o en otras palabras, B=T|F.

De hecho, todos los tipos de datos pueden definirse en Haskell, cuando en otros idiomas el número, las referencias y los tipos de datos de matriz necesitan un soporte especial del compilador. En la práctica, hay un soporte especial en Haskell, ya que de lo contrario sería muy inconveniente, pero, por ejemplo, el Booltipo de datos se define completamente en lenguaje.

Fragmento de longitud 9:

main=main

Este programa sin sentido se definirá maincomo principal. Debido a que Haskell es vago, los valores que requerirían un bucle infinito para evaluar pueden usarse libremente si no usamos su valor real. Dichos valores que contienen bucles infinitos, como el nuestro main, se denominan "fondos".

Un hecho divertido es que el compilador GHC Haskell puede detectar este tipo de bucles infinitos y generar una excepción atrapable (!) Cuando se ejecuta.

Fragmento de longitud 8:

f(x:_)=x

Esto define la función fque, dada una lista no vacía, devolverá su encabezado.

Los patrones en Haskell son como el desempaque de secuencias de Python, pero generalizados para todos los tipos. Los patrones pueden rechazar o hacer coincidir un valor y, si coincide, pueden vincular variables a valores.

Los patrones en este fragmento son:

• _: el patrón que coincide con cualquier cosa y no se une a ninguna variable.
• x: el patrón que une cualquier cosa y lo une a la variable x.
• :: este patrón llega a los patrones secundarios, es decir, uno para la cabeza y otro para la cola. Si la lista no está vacía, los empareja con la cabeza y la cola.

La coincidencia de patrones es muy generalizada. De hecho, solo definir nuevos tipos de datos introducirá automáticamente patrones para trabajar con ellos.

Fragmento de longitud 5:

x=2:x

Whoa, hay mucho que explicar sobre esto.

En primer lugar, Haskell es vago. Esto significa que las subexpresiones se evaluarán solo cuando sea estrictamente necesario.

Nota: este fragmento de código no muestra la asignación, sino la definición. Haskell no tiene tarea.

Este fragmento de código definido x, una lista infinita compuesta en su totalidad por 2. Por lo general, en otros idiomas xdebe evaluarse antes de 2:xpoder evaluarse, pero en Haskell podemos hacer esto.

Las listas infinitas de Haskell son una especie de mezcla de iteradores y listas enlazadas regulares: actúan como ambos (una iteración en un rango utilizará memoria constante, por ejemplo).

Fragmento de longitud 4:

2:[]

Este fragmento solo codifica la lista singleton [2]. :es el operador de Contras en Haskell. De hecho, la sintaxis de la lista regular es solo azúcar sintáctica para el operador contras y el literal de la lista vacía. Esto se relaciona estrechamente con la forma en que Haskell trata con la coincidencia de patrones y los tipos de datos (particularmente el concepto de constructor).

Fragmento de longitud 3:

f.g

En Haskell, .significa composición de funciones. Haskell se puede escribir en un estilo "sin puntos", que se caracteriza por no nombrar argumentos de función y en su lugar usar el .operador para manipular el flujo de datos.

Fragmento de longitud 2:

1-

Cuando este código se envuelve entre paréntesis (por razones sintácticas) se llama una "sección". Es entonces una función que dado un número, "llena" el espacio vacío y devuelve uno menos ese número. Esta noción a veces es útil en un lenguaje funcional como Haskell, donde de lo contrario se necesitaría una lambda.

Fragmento de longitud 1:

1

En Haskell, 1puede ser tanto un Int, Float, Double, Wordy así sucesivamente. De hecho, puede escribir código para definir una versión de 1cualquier tipo y usarlo libremente.
Esto también se hace en JavaScript, Python, etc., pero a diferencia de ellos, se hace con total seguridad de tipo.

hecho:

Originalmente, el comité de Haskell tenía la intención de llamar al idioma "Curry" después del nombre de Haskell B. Curry, pero decidió cambiar el nombre a Haskell porque podrían surgir algunos juegos de palabras. ¡Solo después notaron la similitud de Haskell con "Pascal" y "Hassle"!

C#

C # es una combinación divertida y loca de características de Java, C, Haskell, SQL y muchos otros lenguajes, y ofrece muchas características y API realmente agradables. También es conocido por aquí por ser bastante detallado, ¡pero veremos qué podemos hacer!

Ignoraré el habitual repetitivo:

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

Longitud 1:

;

¡Los comandos terminan con punto y coma en C #! Una línea vacía es una sintaxis perfectamente válida.

Longitud 5:

x=5f;

Cuando especifique números literales en C #, el compilador asumirá que son ints o dobles (en función de si tienen un punto decimal). Si desea utilizar un flotante literal, debe especificarlo agregando 'f' al número, o se lanzará en tiempo de ejecución, incurriendo en un pequeño costo.

Longitud 7 (bytes):

s=@"
";

Si prefijas un literal de cadena con un signo @, se convierte en un literal de cadena "literal". Los literales de cadena normales analizan secuencias de escape como '\ n' en caracteres especiales, pero los literales literales no lo hacen, lo que le permite usar el carácter de barra diagonal inversa sin escapar de él. También pueden incluir retornos de línea, como se muestra. Eso podría ahorrarle unos pocos bytes en el golf o hacer que sus literales de cadena de varias líneas sean más legibles. Solo ten cuidado con la sangría que se incluye en la cadena.

Longitud 8:

()=>x=y;

Esta expresión es una función anónima. Devuelve un objeto de tipo Actionque se puede pasar y también se llama como una función. Las funciones anónimas heredan el alcance en el que se declararon, y extraen cualquier variable local en ese alcance con ellas a donde sea que vayan.

Longitud 9:

(a)=>a.p;

Aquí hay otra función anónima que usa un parámetro y un valor de retorno. La expresión devuelve un objeto de tipo Func(el Func en sí mismo devuelve el tipo de a.p. Usará Funcmucho para interactuar con Linq.

Longitud 10:

enm.Any();

Esta es nuestra primera introducción a Linq! Linq es un conjunto de métodos de extensión a los que se puede llamar en cualquier objeto enumerable (implementando la interfaz IEnumerable), como Arrayy List. IEnumerable emplea una evaluación perezosa: revisa la colección un elemento a la vez, sin conocer la colección en su conjunto, ¡incluso podría ser infinito!

Ahí es donde Anyentra: regresa truesi el Enumerable contiene al menos 1 elemento. Mucho mejor que calcular toda la longitud.

Longitud 11:

var a=1.5f;

La varpalabra clave indica al compilador que determine automáticamente el tipo de a. aen este caso se escribirá como Single. Muy útil para el golf de código, ya que es mucho más corto que casi cualquier nombre de tipo, aunque a muchos no les gusta usarlo en el código de producción.

Longitud 15:

yield return 0;

Aquí hay una declaración loca con la que puede estar menos familiarizado. Usted sabe que los objetos pueden ser enumerables heredando IEnumerable, pero ¿sabía que las funciones pueden ser enumerables? Declare una función con un tipo de retorno de IEnumerable, y téngala yield returntantas veces como desee. Cuando obtiene un Enumerator para la función, cada llamada a GetNexthará que el programa ejecute todo el código hasta el siguiente yield return, devuelva ese valor y luego haga una pausa hasta que avance de nuevo. Usas yield breakpara finalizar la iteración.

Longitud 16:

[Obsolete]int a;

Este fragmento muestra un atributo. Un atributo es un tipo de etiqueta que puede pegar en cualquier declaración en su código. Algunos le indican al compilador que haga ciertas cosas, como esta que emite una advertencia obsoleta si llama a. Puede crear el suyo extendiéndolo Attribute, y puede consultarlos usando Reflection (quizás más sobre eso más adelante). Puede ir a meta y restringir en qué tipo de declaraciones se puede usar un atributo con el AttributeUsageatributo.

Longitud 17

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

Aquí hay un práctico método de golf. Dado Funcque asigna un elemento de lo enumerable ca bool, devuelve el número de elementos cpara los que eso Funcdevuelve true. Mucho mejor que escribir un bucle.

Longitud 18:

foreach(T t in c);

Este es un ciclo para cada uno. Con toda esta charla de cosas enumerables, esta es una estructura muy necesaria. foreaches un azúcar sintáctico que configurará un enumerador para c(que debe ser enumerable) e iterará a través de él un elemento ta la vez. Puede alterar o examinar cada elemento individual, pero alterar la colección en sí invalidará el enumerador.

Longitud 19

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

Esta es su función de "mapa", para los fanáticos de la programación funcional. Seleccionar es una forma concisa y agradable de realizar una conversión arbitraria (definida por un Funcpaso) en cada elemento de un enumerable. Devuelve un IEnumerable que escupirá los elementos "convertidos" cuando lo itere.

Longitud 21

Console.Write("Hi!");

Esta línea escribe texto en stdout, y es probablemente una de las principales razones por las que C # no se usa mucho para jugar al golf.

Longitud 23

typeof(T).GetMethods();

C # admite una característica muy poderosa llamada Reflection. Reflection le permite examinar la estructura de su código en tiempo de ejecución. Por ejemplo, esta llamada devolverá una matriz de todos los métodos en el tipo especificado. Puede examinar esos métodos, llamarlos o incluso modificar los valores de los campos y propiedades. Los atributos (ver Longitud 16) son una buena manera de etiquetar partes de su código para usar con Reflection.

Longitud 25

from t in c select t.a/2;

¿Eso es SQL? En el código C #? Muy cerca. Esta expresión hace lo mismo que la de Longitud 19.

Longitud 27

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

C # es un lenguaje recolectado de basura, lo que significa que cualquier memoria que asigne (usando la newpalabra clave) puede liberarse automáticamente siempre que no existan referencias a ella. Este código se ejecutará feliz para siempre aunque nunca libere explícitamente la memoria creada. Sin embargo, la recolección de basura tiene costos: busque en la web para obtener más información.

Longitud 29

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

Enumerable.RangeEs una función de golf potencialmente útil. Devuelve una estructura que se puede enumerar y producirá cada número en el rango especificado, en orden. El segundo parámetro es un recuento, no un índice.

Longitud 31

public int pr{get;private set;}

Aquí, podemos mostrar una 'propiedad' simple, una función OOP y otro sello distintivo de C #. Si alguna vez usó Java, probablemente haya realizado los métodos 'obtener' y 'establecer' para un campo con el fin de separar su accesibilidad o ejecutar el código cuando se cambia. Bueno, C # le permite declarar ese código justo en la parte superior del campo y también establecer modificadores de acceso separados para obtener y configurar. Este fragmento particular crea automáticamente un getter y setter predeterminado, pero hace que el setter sea privado.

Longitud 32

public static void m(this T o){}

Este fragmento muestra una característica de C # que es agradable para el diseño de API. Al aplicar el thismodificador al primer parámetro de un método estático, ese método se convierte en un método de "extensión". Una vez que se declara esto, T.mahora se puede invocar en cualquier objeto de tipo T como si en realidad fuera un método de T. Esto se puede usar para agregar nueva funcionalidad a cualquier clase existente, sin modificar o incluso tener acceso a su código fuente.

Longitud 38

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

Este método muestra diferentes tipos de paso de parámetros que puede tener en C #. Los parámetros no modificados se pasan por valor . Los parámetros prefijados por refse pasan por referencia: puede asignarles un objeto completamente nuevo y lo sacarán del método. Los parámetros con el prefijo outson como valores de retorno adicionales: debe asignarles un valor en el método, y se vuelven a ejecutar como parámetros de referencia.

Longitud 42

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

El nuevo estándar C # 6 puede ahorrarle algunos caracteres cuando tiene que generar cadenas ensambladas, utilizando la interpolación de cadenas. Esta característica le permite escribir cualquier expresión entre llaves dentro de un literal de cadena, y la cadena se ensamblará automáticamente con los valores de esas expresiones en tiempo de ejecución.

Longitud 48

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

¡Solo suficientes personajes ahora para hacer algo con un propósito real! Este método utiliza algunas de las ideas que exploramos anteriormente para crear un Enumerable infinito que simplemente devolverá los enteros, uno por uno, comenzando con 0. Recuerde que C # emplea una evaluación perezosa con Enumerables, por lo que una secuencia infinita es perfectamente válida: puede itere la mayor cantidad de secuencia que desee y explote en cualquier momento.

Longitud 56

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

Aquí hay otro ejemplo de una 'propiedad' (ver fragmento 31). Aquí, he definido diferentes fragmentos de código para gety en setlugar de usar los automáticos como antes. Este ejemplo demuestra cómo puede usar una propiedad para validar el valor asignado a una variable; aquí, no se permite que el valor sea menor que 0. Otros usos buenos de las propiedades incluyen la notificación de un evento cuando se cambia un valor o la reconstrucción de valores almacenados en caché eso podría basarse en este.

Longitud 65

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

Esta característica se llama un elenco implícito. Es como un método de extensión en el sentido de que es un código estático que opera en una clase específica (vea el fragmento 32). Sin embargo, el reparto implícito no se usa al llamarlo, se usa simplemente tratando un Programobjeto como un entero (por ejemplo int i=new Program()). Cuando haga esto, el objeto se convertirá silenciosamente en el tipo con el que lo está utilizando, según el código en la conversión implícita. La mejor práctica dice que solo haga esto cuando no se pierda información como resultado de la conversión.

Java

Longitud 44 fragmento

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

Imprime Hello, World!en STDOUT.

Fragmento de longitud 43

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

acontiene 10 matrices que contienen cada una 2 matrices que contienen cada una 7 matrices que contienen cada una 3 matrices que contienen cada una 5 floats.

Fragmento de longitud 42

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

Un programa completo Como todo en un interfacees inherentemente public, podemos omitir la palabra publicdel método principal.

Fragmento de longitud 36

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

ATiene una clase interna B. Esto significa que podemos declarar una variable de tipo A.B.

Pero Bes una subclase de A, lo que significa que tiene todos los métodos, campos y clases internas de A. Por lo tanto, también podemos referirnos al tipo B.B.

En este código, llevamos esto un paso más allá y le damos Buna variable de instancia de tipo B.B.B.

La moraleja: seguir preguntas importantes sobre SO puede enseñarle muchas técnicas interesantes, aunque sin sentido.

Fragmento de longitud 35

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

Si les una lista de cadenas, esto nos dice cuántos son iguales "a".

Fragmento de longitud 34

public static void main(String[]a)

Firma del método del método principal de un programa. ¡Solo 11 personajes más y podemos hacer un programa completo!

Fragmento de longitud 33

enum D {NORTH, EAST, SOUTH, WEST}

NORTH, EAST, SOUTH, Y WESTson todas las constantes de tipo D.

Fragmento de longitud 32

Files.readAllBytes("hello.txt");

Lee un archivo completo y devuelve uno byte[]de los contenidos.

Fragmento de longitud 31

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

Equivalente a "hi". Útil si la "llave está rota.

Fragmento de longitud 30

new JFrame().setVisible(true);

Crea un nuevo marco visible, en el que puede colocar otros componentes.

Fragmento de longitud 29

throws ClassNotFoundException

Obliga a todos los métodos que llaman a esto a usar un bloque try- catcho bien a pasar el error a la pila. Las excepciones marcadas son una de las decisiones más controvertidas de los diseñadores de Java.

Fragmento de longitud 28

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

Esta función no se ejecuta para siempre; de hecho, en una computadora típica se tarda menos de un segundo. Gracias, desbordamiento de pila.

Fragmento de longitud 27

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

Crea una nueva matriz de cadenas.

Longitud 26 fragmento

Object.class.newInstance()

Crea un nuevo Object.

Fragmento de longitud 25

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

Es mejor evitar constantes de codificación dura. Esta es una forma orientada a objetos de obtener el valor 1sin usar constantes que no sean 0.

Longitud 24 fragmento

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

La función sucesora.

Fragmento de longitud 23

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

Si les una lista de enteros, esto elimina todos los valores divisibles por 10.

Fragmento de longitud 22

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

Crea una nueva matriz de siete enteros y obtiene el quinto elemento.

Fragmento de longitud 21

Arrays.asList(2L,"a")

Crea una ArrayList con estos elementos.

Fragmento de longitud 20

System.out.print(s);

Impresiones s.

Fragmento de longitud 19

import java.util.*;

Permite el uso concisa de clases como List, Map, Scanner, Timer, y Random.

Longitud 18 fragmento

Math.addExact(x,y)

Agrega dos enteros xy y. Si se produce un desbordamiento, el método arroja una excepción en lugar de dar una respuesta incorrecta.

Fragmento de longitud 17

Double.MIN_NORMAL

El valor positivo más pequeño de tipo double, donde el bit inicial del significado es 0.

Fragmento de longitud 16

System.in.read()

Lee un solo personaje de la consola.

Fragmento de longitud 15

Long.reverse(x)

Invierte los bits en la representación binaria de x.

Fragmento de longitud 14

int x=050+120;

xahora es 160, ya que todo lo que comienza 0se trata como octal.

Fragmento de longitud 13

private C(){}

Un constructor privado evita que otras clases lo instancian. Este patrón es utilizado por las clases Systemy Math, entre otros. Un constructor privado también se puede utilizar para aplicar el patrón Singleton.

Longitud 12 fragmento

static class

Permite la creación de clases internas sin una clase externa que encierra - una solución a un problema enfrentado por muchos programadores .

Fragmento de longitud 11

throw null;

A menudo es necesario lanzar un NullPointerException, pero también es bastante prolijo. Esta es una alternativa mucho más simple.

Fragmento de longitud 10

int[]a,b[]

Define dos variables: ay b. aes de tipo int[]y bes de tipo int[][].

Fragmento de longitud 9

switch(x)

Va a un lugar, dependiendo del valor de x.

Fragmento de longitud 8

break a;

Se escapa del bloque etiquetado a.

Fragmento de longitud 7

goto x;

La gotopalabra clave está reservada en C, C ++ y Java. Si xes una etiqueta, entonces este código envía el programa a la etiqueta apropiada, en C y C ++. Pero es Java, desencadena un misterioso RuntimeException. De hecho, no hay forma de usar la gotopalabra clave en Java.

Fragmento de longitud 6

\u003b

Termina una declaración. Java es raro .

Fragmento de longitud 5

a-=-a

Se duplica arestando su negación.

Fragmento de longitud 4

a&=b

Establece el valor de aa bit a bit y de ay b.

Fragmento de longitud 3

...

Cualquier número de argumentos, consolidados en una matriz.

Fragmento de longitud 2

<>

Permite que el compilador descubra a qué tipo genérico se refiere probablemente. Muy poco parecido a Java.

Fragmento de longitud 1

@

Indica una anotación para permitir que se muestre información adicional sobre métodos y clases.

Factoid

En Java, los bucles infinitos a veces causan errores de compilación. Por ejemplo, el ciclo while(true);no se puede finalizar sin salir del método, por lo que cualquier código posterior provocará un error de "declaración inalcanzable". Como señaló @Optimizer, solo se capturarán algunos bucles infinitos de esta manera.

Pitón

¡Ahora comienza con lo más nuevo para tu comodidad! Para leer la longitud 30 comenzando con el primero, vaya al historial de revisiones.

Si alguien tiene sugerencias, siéntase libre de comentar.

Longitud 52:

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

Tomado de mi entrada en el desafío Fake Marquee Text . sy ndebe establecerse en una cadena y un entero antes de tiempo. En realidad, no funciona bien en el intérprete gratuito de Python 2 que estaba usando, así que agregué paréntesis (' '*n+s)[i:n+i], y puedes ver que se ejecuta en el intérprete de Python 3 aquí .

Longitud 43:

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

En Python puede codificar la fuente con un códec específico. Esto muestra cómo se puede escribir la fuente en Rot13. La sintaxis general es la siguiente: # -*- coding: <codec-name-goes-here> -*-.

Aquí está traducido:

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

Las uespecifica que la siguiente cadena literal es una cadena Unicode. Esto es necesario si desea que sus cadenas también estén en Rot13, de lo contrario cada cadena en la fuente es fácilmente legible a pesar del cifrado. Alternativamente, puede usar .encode("Rot13")después de cada cadena (no olvide usar Rot13 también en esto). Según este artículo , algunas codificaciones alternativas son "base64", "uuencode", "zlib" o "bz2".

Longitud 33:

import cmath
print cmath.sqrt(-1)

Este es el módulo de Python para números complejos (imaginarios) . Esto se imprime 1j, ya que Python se ajusta a los estándares y usos de ingeniería jcomo la unidad imaginaria, aunque prefiero i, que se usa más comúnmente en matemáticas, y usa jy kademás ide los cuaterniones , pero estoy divagando. Lea el error / orden de cambio aquí (no se cambiará).

Longitud 30:

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

¡Ahora definimos nuestra propia función factorial usando la recursión y el ternario if-else! Hasta donde yo sé, esto es tan golfístico como se pone en Python. También podría escribirse de esta manera:, f=lambda n:n and f(n-1)*n or 1mostrando un par de operadores booleanos de Python (y también hecho en 30 caracteres). Consulte el fragmento de longitud 15 para obtener información sobre la lambdasintaxis.

Longitud 29:

import math
math.factorial(7)

Encuentra el factorial de 7, regresando 5040.

Longitud 25:

import math
print math.pi

El módulo matemático de Python proporciona muchas funciones y constantes útiles. Aquí está PI. Las devoluciones 3.14159265359. (En el código anterior, conté la nueva línea como un personaje).

Longitud 24:

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

Este es un ejemplo de cierre. Llamar cube = f(3)hará una función cúbica que luego se puede llamar con print cube(24), imprimiendo 13824.

Longitud 19:

print"Hello World!"

Finalmente, ¡suficiente espacio para imprimir algunos resultados básicos! Aquí no se requiere espacio, porque las comillas y paréntesis también son delimitadores. Esto solo funcionará en Python 2, ya que Python 3 cambió la printfunción para que se llame como cualquier otra función. En Python 3, use print("Hello World!"). Para obtener más información sobre la función de impresión y la diferencia entre Python 2 y 3, consulte Novedades de Python 3.0 .

Longitud 16:

[x*3 for x in l]

Una vez más, suponga que les una lista o cualquier otro objeto iterable, como una cadena o un generador. Esta declaración se conoce como una lista de comprensión . Es mucho más corto que usar el estándar para la estructura de bucle. Aquí, devuelve una lista con todos los números multiplicados por 3. ¡TAMBIÉN, las cadenas se pueden multiplicar! Por lo tanto, cualquier cadena de la lista se agregará (concatenada a sí misma) esa cantidad de veces.

Longitud 15:

import this #:)

¡Esto es en realidad un fragmento de longitud 11, pero me di cuenta de que me había olvidado de mostrar el (increíble) huevo de Pascua de Python ! La importación de este módulo imprime The Zen of Python (Ver Factoid). Dato interesante: el módulo this.pyfue codificado en rot13, que espero presentar más adelante.

Longitud 14:

lambda x:x**.5

Esto define una función de raíz cuadrada usando la lambdasintaxis de Python para una función literal. Los literales de función en Python solo pueden contener expresiones, no declaraciones. Esta lambda podría asignarse a una variable, pasar a una función o ejecutarse en línea con (lambda x:x**.5)(9), lo que devuelve 3.0. El uso de exponentes para una raíz cuadrada es una alternativa a la importación de la sqrtfunción en el mathmódulo.

Longitud 13:

1 if x else 0

Este es un ejemplo del operador if ternario de Python. Esto se agregó en Python 2.5 para disuadir a los codificadores de implementarlo manualmente con operaciones booleanas. Aquí, 1se devuelve si se xevalúa True, de lo contrario 0se devuelve.

Longitud 12:

s=input(">")

Esto imprimirá >el texto de solicitud y permitirá al usuario ingresar un valor. Python 2 interpreta cualquier valor que se ingrese, por lo que cualquier cadena necesita comillas. Python 3 cambió esto, por lo que la entrada ingresada no se interpreta automáticamente. Para ingresar una entrada sin interpretarla en Python 2, use raw_input(). En Python 2, input()es equivalente a eval(raw_input()).

Longitud 11:

eval("2e3")

2e3Es una notación científica para el flotador 2 x 10³. La evalfunción interpreta y evalúa cualquier cadena como una expresión. En este caso, tiene el mismo resultado que usar el literal 2e3o float("2e3"). Vuelve 2000.0.

Longitud 10:

range(013)

Esta función devuelve una lista de enteros desde 0el valor octal 013, que es 11(exclusivo), lo que significa que la lista será [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]. La función toma hasta tres parámetros similares a la slicefunción que revisamos anteriormente: range(start, stop[, step]). La diferencia es que, con solo un parámetro, el parámetro representa el valor de detención.

Tenga en cuenta que Python 3.x no tiene equivalente. Es rangesimilar, pero en realidad es lo mismo que Python 2 xrange, devolviendo un objeto generador en lugar de una lista.

Longitud 9:

a,b = b,a

Asignación múltiple Esta es una característica simple pero elegante, que le permite asignar múltiples valores al mismo tiempo. En el fragmento proporcionado, se intercambia ay b. ¿Qué pasa con el orden de evaluación, preguntas? Todas las expresiones a la derecha del operador de asignación se evalúan antes de realizar cualquiera de las asignaciones. Esto supera muchos idiomas que requieren una asignación intermedia a una variable temporal.

Longitud 8:

#comment

Sabes lo que es ... Espera, ¿no? Ya sabes, esas cosas que te permiten escribir texto arbitrario para describir una línea de código, lo que hace que sea más fácil de entender. ¿No? Ah, esta bien...

Longitud 7:

l[::-1]

Una vez más, suponiendo que les una lista, esto devolverá la lista en orden inverso. El tercer argumento indica el tamaño del paso. Dado que los tres argumentos pueden ser valores negativos, un tamaño de paso negativo significa iterar en orden inverso. Los argumentos primero y segundo vacíos muestran que estamos iterando sobre toda la lista.

¡Estamos llegando a donde podemos comenzar a usar algunas construcciones más interesantes!

Longitud 6:

l[-6:]

Esto se llama una operación de corte . Si les una lista, devolverá una nueva lista que contiene los últimos seis elementos lcomo una lista. -6representa el índice inicial (6 desde el final), y los dos puntos significan continuar hasta el índice final después (que dejamos en blanco, hasta el final). Si nuestra lista contuviera los números del 1 al 10, esto volvería [5, 6, 7, 8, 9, 10].

Longitud 5:

1<x<5

Una de las increíbles características de Python es permitirle encadenar operadores de comparación. En muchos otros idiomas, esto se escribiría como 1 < x && x < 5. Se pone aún mejor cuando considera múltiples comparaciones: ¡ 1 < x < y < 5es perfectamente válido!

Longitud 4:

0256

Un número entero con un cero inicial es un valor octal literal. Este es un buen truco para la ofuscación de código también. Esto devuelve el valor decimal 174. En Python 3.x, el valor octal se escribiría como 0o256.

Longitud 3:

`3`

Rodear una expresión en backticks es lo mismo que usar repr(), que devuelve la representación de cadena de un objeto. La función intenta devolver la cadena de tal manera que cuando se pasa como argumento a la evalfunción, devolverá el objeto original. No es lo mismo que usar str(), aunque los resultados a veces son los mismos. Para esta entrada, '3'se devuelve en ambos casos. Este es uno de mis favoritos para el golf de código!

¡Funciona solo en Python 2!

Longitud 2:

[]

Una lista vacia.

Longitud 1:

_

El carácter de subrayado es un nombre de variable desechable muy utilizado. Sin embargo, si está utilizando un intérprete de Python (intérprete interactivo), contiene el resultado de la última instrucción ejecutada (y la devolvería nuevamente). Además, de acuerdo con este hilo , también se usa para la búsqueda de traducción en i18n.

Factoid : Python es un lenguaje similar a Java y C. Fue construido con una filosofía de diseño específica (tomado de " PEP 20 - The Zen of Python ":

• Hermoso es mejor que feo
• Explícito es mejor que implícito
• Simple es mejor que complejo
• Complejo es mejor que complicado
• La legibilidad cuenta

Debido a esto, aunque los puntos y coma se permiten como delimitador de enunciados, generalmente se omiten a favor del uso de líneas múltiples para facilitar la lectura. Además, la sangría de línea es muy importante.

JavaScript

Esto va más nuevo al más antiguo. Enlace para mí: [ editar ]

Fragmento de longitud 51:

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

Un Node.JS quine esta vez, aunque fallaría cualquier requisito de "quine estricto", debido a la lectura de su propio código fuente.

Fragmento de longitud 50:

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

¡Finalmente! Una solicitud AJAX (usando Vanilla.JS ). Inicializamos, abrimos y enviamos la solicitud, pero me quedé sin espacio para agregar controladores y realmente hacer cualquier cosa con el resultado.

Fragmento de longitud 49:

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

Prepare un vocal "¡Hola mundo!". Será un poco más de trabajo hablarlo realmente. También podemos ajustar el volumen, el tono, la frecuencia y el acento. Ver API de síntesis de voz en HTML5Rocks . Todavía no es compatible con Firefox, ciertamente no con IE .

Fragmento de longitud 48:

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

Simule setIntervalrecursivamente setTimeouting.

Fragmento de longitud 47:

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

NodeJS nuevamente, pero el principio es el mismo en todas partes en JS. Esta es una función constructora muy básica, que crea un objeto con una propiedad ( a). La configuración module.exportsexporta la función para usarla require().

Fragmento de longitud 46:

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

Esto requiere un <canvas id="canvas"></canvas>elemento. Aprovecha el hecho de que los elementos con ID se rellenan como variables globales, por lo que se puede acceder al elemento canvasdesde JS. Luego lo llenamos con un cuadrado de 46x46 en x = 46, y = 46.

Fragmento de longitud 45:

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

De vuelta al nodo. Aquí, analizamos un archivo JSON nombrado jsndesde el directorio actual.

Fragmento de longitud 44:

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

Sobre la base del n. ° 39. Ahora creamos un elemento y asignamos un atributo. Sin embargo, todavía no está en el DOM.

Fragmento de longitud 43:

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

Crea una matriz de los primeros 5 cuadrados, usando map().

Fragmento de longitud 42:

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

Esto funciona en el mismo principio que este , pero carece de JS #definey así termina más feo. Devuelve, por supuesto, la respuesta a la vida, el universo y todo .

Fragmento de longitud 41:

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

El comienzo de un cierre. cahora es una función (la interna) con acceso a la variable interna i, pero no hace nada.

Fragmento de longitud 40:

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

Estamos eliminando totalmente esos párrafos y usando jQuery.

Fragmento de longitud 39:

script=document.createElement('script')

Este es el comienzo de agregar un nuevo script externo. Cree un <script>elemento vacío y mantenga una referencia a él.

Fragmento de longitud 38:

document.getElementsByClassName('abc')

Encuentra todos los .abcelementos en el documento. Por supuesto, con jQuery, es solo $('.abc')...

Fragmento de longitud 37:

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

Crea dos objetos idénticos, pero desacoplados a, y b. Si tu hicieras

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

terminarías con a=={a:3}, porque ay bseñalarías el mismo objeto. Usamos JSON para desacoplarlos.

Fragmento de longitud 36:

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

Una quine . Imprime su propio código fuente.

Fragmento de longitud 35:

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

Ver # 32. Este solo oculta el documento, sin sobrescribir el contenido.

Fragmento de longitud 34:

Object.prototype.toString.call(34)

Llamar Object.prototype.toStringes una buena forma de saber el tipo de un objeto. Mientras 34..toString()es "34", el fragmento es [object Number].

Fragmento de longitud 33: (el crédito para este es para un usuario anónimo )

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

¿Crees que esto no es JavaScript válido? Mejor inténtalo ... (usa Chrome);)

Fragmento de longitud 32:

document.body.innerHTML="hacked"

Halp! ¡Hazxxors! ¡Once! ¡11!

Fragmento de longitud 31:

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

No es broma, ¡he estado esperando tanto tiempo para poder usar un forbucle! Este crea una matriz de 0-30.

Fragmento de longitud 30:

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

Primera vez que usa el operador ternario. No podría incluir más de esto en 30 caracteres, por lo que solo sabemos si hoy es domingo o algo más. :PAGS

Fragmento de longitud 29:

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

Object.keys(window)obtendrá una matriz de las variables globales (propiedades de window). .push()agregará un elemento a esa matriz. ¿Crees que esto es el equivalente de window.i=undefined? ¡No!

Fragmento de longitud 28:

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

Esperar 28 milisegundos no es tan útil, excepto para crear un nuevo hilo.

Fragmento de longitud 27:

document.querySelector('a')

Es una pena que los nombres DOM sean tan largos. Solo pude obtener un enlace aquí.

Fragmento de longitud 26:

JSON.stringify({twenty:6})

Ver # 16. Ahora obtenemos JSON real: una cadena.

Fragmento de longitud 25:

new Badge("Good Answer");

Suponiendo Badge()que una función de constructor toma un argumento ... ¡ se acaba de crear una insignia de Buena respuesta !

Fragmento de longitud 24:

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

En realidad no uso do..whilemucho, pero algunos sí. Si este fuera un whileciclo ordinario , no alertaría nada, porque siempre es falso. do..whilesiempre se ejecutará al menos una vez, así que podemos ver 24.

Fragmento de longitud 23:

window.parent==self.top

Todos estos se refieren al mismo objeto, generalmente conocido como window. Si llamas a una función normalmente, también hay this. ¡Son 5 formas de acceder al objeto global!

Fragmento de longitud 22:

for(i in self)alert(i)

Alerta a todas las variables globales. Resulta ser eso self==window. (Ver el siguiente fragmento).

Fragmento de longitud 21:

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

Oh mira, son las reglas de lanzamiento de JS nuevamente. Esta afirmación es cierta, por cierto.

Fragmento de longitud 20:

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

Elija un número aleatorio del 0 al 1 y redondee con el operador ternario. Aunque sería más fácil de usar Math.round...

Fragmento de longitud 19:

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

Este es nuevo. Como, realmente nuevo. Utiliza las funciones de flecha ES6 para calcular los cuadrados de 1, 2 y 3. Actualmente, parece que solo es compatible con Firefox.

Fragmento de longitud 18:

location.href="/";

Como # 15, pero esta vez, va a la página de inicio de PPCG, no SE.

Fragmento de longitud 17:

(function(){})()

Es el fragmento de 14, ¡pero mejor! Ahora es un IIFE.

Fragmento de longitud 16:

obj={not:'json'}

Esto explica una de mis manías. Este es un objeto , no JSON ! JSON es un formato de intercambio de datos basado en objetos JavaScript, pero que adopta un formato más estricto.

Fragmento de longitud 15:

open('//s.tk/')

Imagina eso. Abra la página de inicio de SE, utilizando el http://s.tk/ redirect.

Fragmento de longitud 14:

function f(){}

W00t! Funciones! Lástima que no hay espacio para hacer nada.

Fragmento de longitud 13:

Math.random()

Genere un número aleatorio del 0 al 1. ¿Desea definir sus propios límites? Mala suerte (En realidad no, es fácil).

Fragmento de longitud 12:

new Date<=12

Esta afirmación nunca ha sido cierta en JS. JS no se creó hasta el '95 (ver factoid), mucho después del 1/1/1970 00: 00: 00.012.

Fragmento de longitud 11:

Math.PI*121