Entonces ... eh ... esto es un poco embarazoso. Pero no tenemos un simple "¡Hola, mundo!" desafío aún (a pesar de tener 35 variantes etiquetadas con hello-world y contando). Si bien este no es el código de golf más interesante en los idiomas comunes, encontrar la solución más corta en ciertos esolangs puede ser un desafío serio. Por ejemplo, que yo sepa, aún no se sabe si se ha encontrado la solución Brainfuck más corta posible.
Además, si bien toda Wikipedia (la entrada de Wikipedia se ha eliminado pero hay una copia en archive.org
), esolangs y Rosetta Code tienen listas de "¡Hola, Mundo!" programas, ninguno de estos está interesado en tener el más corto para cada idioma (también existe este repositorio de GitHub ). Si queremos ser un sitio importante en la comunidad de golf de código, creo que deberíamos intentar crear el catálogo definitivo del más corto "¡Hola, Mundo!" programas (similar a cómo nuestro desafío básico de quine contiene algunos de los quines más cortos conocidos en varios idiomas). ¡Entonces hagamos esto!
Las normas
- Cada presentación debe ser un programa completo.
- El programa no debe ingresar nada e imprimir
Hello, World!en STDOUT (este flujo de bytes exacto, incluyendo mayúsculas y puntuación) más una nueva línea final opcional, y nada más.
- El programa no debe escribir nada en STDERR.
Si alguien quiere abusar de esto creando un lenguaje donde se imprima el programa vacío Hello, World!, luego felicidades, simplemente allanaron el camino para una respuesta muy aburrida.
Tenga en cuenta que debe haber un intérprete para que se pueda probar el envío. Se permite (e incluso se recomienda) escribir este intérprete usted mismo para un idioma previamente no implementado.
- Las presentaciones se puntúan en bytes , en una codificación apropiada (preexistente), generalmente (pero no necesariamente) UTF-8. Algunos idiomas, como las carpetas , son un poco difíciles de puntuar; si tiene dudas, pregunte por Meta .
- No se trata de encontrar el idioma con el más corto "¡Hola, mundo!" programa. Se trata de encontrar el más corto "¡Hola, mundo!" programa en todos los idiomas. Por lo tanto, no marcaré ninguna respuesta como "aceptada".
- Si su idioma de elección es una variante trivial de otro lenguaje (potencialmente más popular) que ya tiene una respuesta (piense en dialectos BASIC o SQL, shells Unix o derivados triviales de Brainfuck como Alphuck), considere agregar una nota a la respuesta existente que el La misma solución o una muy similar también es la más corta en el otro idioma.
Como nota al margen, no desestime las respuestas aburridas (pero válidas) en idiomas en los que no hay mucho para jugar al golf; estas siguen siendo útiles para esta pregunta, ya que trata de compilar un catálogo lo más completo posible. Sin embargo, hacer respuestas principalmente Upvote en los idiomas en que los autores hecho, tuvimos que poner esfuerzo en el código de golf.
Para inspirarte, mira la colección Hello World .
El catálogo
El Fragmento de pila al final de esta publicación genera el catálogo a partir de las respuestas a) como una lista de la solución más corta por idioma yb) como una tabla de clasificación general.
Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:
## Language Name, N bytes
¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:
## Ruby, <s>104</s> <s>101</s> 96 bytes
Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:
## Perl, 43 + 2 (-p flag) = 45 bytes
También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento:
## [><>](https://esolangs.org/wiki/Fish), 121 bytes
/* Configuration */
var QUESTION_ID = 55422; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 8478; // This should be the user ID of the challenge author.
/* App */
var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;
function answersUrl(index) {
return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}
function commentUrl(index, answers) {
return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}
function getAnswers() {
jQuery.ajax({
url: answersUrl(answer_page++),
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
answers.push.apply(answers, data.items);
answers_hash = [];
answer_ids = [];
data.items.forEach(function(a) {
a.comments = [];
var id = +a.share_link.match(/\d+/);
answer_ids.push(id);
answers_hash[id] = a;
});
if (!data.has_more) more_answers = false;
comment_page = 1;
getComments();
}
});
}
function getComments() {
jQuery.ajax({
url: commentUrl(comment_page++, answer_ids),
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
data.items.forEach(function(c) {
if (c.owner.user_id === OVERRIDE_USER)
answers_hash[c.post_id].comments.push(c);
});
if (data.has_more) getComments();
else if (more_answers) getAnswers();
else process();
}
});
}
getAnswers();
var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var OVERRIDE_REG = /^Override\s*header:\s*/i;
function getAuthorName(a) {
return a.owner.display_name;
}
function process() {
var valid = [];
answers.forEach(function(a) {
var body = a.body;
a.comments.forEach(function(c) {
if(OVERRIDE_REG.test(c.body))
body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
});
var match = body.match(SCORE_REG);
if (match)
valid.push({
user: getAuthorName(a),
size: +match[2],
language: match[1],
link: a.share_link,
});
else console.log(body);
});
valid.sort(function (a, b) {
var aB = a.size,
bB = b.size;
return aB - bB
});
var languages = {};
var place = 1;
var lastSize = null;
var lastPlace = 1;
valid.forEach(function (a) {
if (a.size != lastSize)
lastPlace = place;
lastSize = a.size;
++place;
var answer = jQuery("#answer-template").html();
answer = answer.replace("{{PLACE}}", lastPlace + ".")
.replace("{{NAME}}", a.user)
.replace("{{LANGUAGE}}", a.language)
.replace("{{SIZE}}", a.size)
.replace("{{LINK}}", a.link);
answer = jQuery(answer);
jQuery("#answers").append(answer);
var lang = a.language;
lang = jQuery('<a>'+lang+'</a>').text();
languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
});
var langs = [];
for (var lang in languages)
if (languages.hasOwnProperty(lang))
langs.push(languages[lang]);
langs.sort(function (a, b) {
if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
return 0;
});
for (var i = 0; i < langs.length; ++i)
{
var language = jQuery("#language-template").html();
var lang = langs[i];
language = language.replace("{{LANGUAGE}}", lang.lang)
.replace("{{NAME}}", lang.user)
.replace("{{SIZE}}", lang.size)
.replace("{{LINK}}", lang.link);
language = jQuery(language);
jQuery("#languages").append(language);
}
}
body {
text-align: left !important;
display: block !important;
}
#answer-list {
padding: 10px;
width: 290px;
float: left;
}
#language-list {
padding: 10px;
width: 500px;
float: left;
}
table thead {
font-weight: bold;
}
table td {
padding: 5px;
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/all.css?v=ffb5d0584c5f">
<div id="language-list">
<h2>Shortest Solution by Language</h2>
<table class="language-list">
<thead>
<tr><td>Language</td><td>User</td><td>Score</td></tr>
</thead>
<tbody id="languages">
</tbody>
</table>
</div>
<div id="answer-list">
<h2>Leaderboard</h2>
<table class="answer-list">
<thead>
<tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
</thead>
<tbody id="answers">
</tbody>
</table>
</div>
<table style="display: none">
<tbody id="answer-template">
<tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
</tbody>
</table>
<table style="display: none">
<tbody id="language-template">
<tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
</tbody>
</table>
"Hello, World!", es el más corto en muchos idiomas diferentes y no relacionados, ¿debería publicarse por separado?Respuestas:
Atascado, 0 bytes
Bueno, no puede ser más corto que eso ... Un programa vacío saldrá
Hello, World!en Stuck .fuente
Hello, World!cosa era simplemente algo que había puesto como marcador de posición al principio del desarrollo. No tenía la intención de dejarlo en tanto tiempo, simplemente nunca llegué a quitarlo.PHP, 13 bytes
Si. Funciona.
fuente
<?phpcódigo, lo que hace que PHP no lo interprete en absoluto :)Brainfuck, 78 bytes
Recompensa abierta: si alguien puede mejorar esta puntuación, les pasaré la recompensa (+500).¡@KSabha encontrado unasolución de7672 bytes!Pruébalo en línea!
Los primeros 28 bytes
--<-<<+[+[<+>--->->->-<<<]>]inicializan la cinta con la siguiente relación de recurrencia (mod 256):f n = 171 · (-f n-1 - f n-2 - f n-3 + 1) , con f 0 = 57 , f 1 = 123 y f 2 = 167 .
El factor de 171 surge porque 3 -1 ≡ 171 (mod 256) . Cuando el valor actual se traduce una celda hacia atrás (vía
<+>---), restando 3 cada vez multiplica efectivamente el valor por 171.En n = 220, el valor a traducir es cero, y la iteración se detiene. Los diez bytes que preceden al punto de detención son los siguientes:
Contiene todos los componentes necesarios para producir
Hello, World!, en forma de caza y picoteo, con pequeños ajustes.También he encontrado una solución alternativa de 78 bytes:
Pruébalo en línea!
Considero que este es mejor que el primero por varias razones: usa menos celdas que quedan en casa, modifica menos celdas en total y termina más rápidamente.
Mas detalle
Las relaciones de recurrencia tienen representaciones sorprendentemente concisas en Brainfuck. El diseño general es el siguiente:
que representa:
f n = c 1 · f n-1 + c 2 · f n-2 + c 3 · f n-3 + ... + k
con
f 0 = s 1 , f 1 = s 2 + c 1 · f 0 + k , f 2 = s 3 + c 2 · f 0 + c 1 · f 1 + k , etc.
Además,
<+>se puede cambiar para multiplicar el rango por una constante sin afectar el punto de parada, y se puede agregar un término antes>{k}de cambiar el rango por una constante, nuevamente sin afectar el punto de parada.Otros ejemplos
Secuencia Fibonacci
Números N-gonales
Números triangulares
Definido como f n = 2 · f n-1 - f n-2 + 1 , con f 0 = 0 , f 1 = 1 .
Números cuadrados
Números Pentagonales
etc.
BF Crunch
He publicado el código que usé para encontrar algunas de estas soluciones en github . Requiere .NET 4.0 o superior.
La salida se da en tres líneas:
Por ejemplo, el resultado final para
bfcrunch "hello world" 70 -r -i23es:Esto corresponde al programa completo:
Otros registros
¡Hola Mundo!
Envoltura, 78 bytes :
o
Sin envoltura, 87 bytes (anteriormente 92 bytes (mitchs) ):
¡Hola Mundo!
Envoltura, 80 bytes :
Sin envoltura, 81 bytes (anteriormente 92 bytes (hirose) ):
¡Hola Mundo!
Envoltura, 74 bytes :
Sin envoltura, 84 bytes :
Versión de Esolangs
Hola mundo! \ N
Envoltura, 76 bytes :
Esto usa una celda a la izquierda del hogar, y por lo tanto se consideraría 77.
Sin envoltura, 83 bytes :
Rdebath aprobado . salida de profilebf:
inversed.ru (Peter Karpov)
Hola Mundo!
Envoltura, 70 bytes (anteriormente 78 1 ):
Sin envoltura, 77 bytes (¿anteriormente 89?):
El autor afirma que el más corto "Hello World!" Codificado a mano tiene 89 bytes, pero no proporciona referencia. Por la presente también reclamo el registro de esto.
¡Hola Mundo!
Envoltura, 65 bytes (anteriormente 66 bytes):
En realidad, esto también está codificado a mano (lo mejor que pude encontrar al procesar es de 68 bytes ). La primera celda se inicializa a 259 (3), y se decrementa en 7 cada iteración, haciendo un ciclo 37 veces. La siguiente celda se reduce en 6, lo que resulta en 256 - 6 · 37 = 34 . El resto de las celdas se reducen en 4 cada vez, agregando una celda cada iteración, con cada celda nueva inicializada a 252 (-4). El resultado es el siguiente:
1 La solución dada (79 bytes) se puede reducir trivialmente en uno:
fuente
interface a{static void main(String[]A){System.out.print("No!");}}ArnoldC , 71 bytes
Solo para lols ..
fuente
IT'S SHOWTIMEyTALK TO THE HANDdebería estar en la primera y última línea.Semilla ,
601642344203 bytesEl programa Befunge-98 resultante (basado en esto ) es
fuente
Mornington Crescent ,
36143568 bytesGracias a NieDzejkob por guardar 46 bytes usando nombres de línea más cortos.
Pruébalo en línea!
Esto es ciertamente subóptimo, pero es la mitad del tamaño de la solución en esolangs.
Hello, Worldse construye cortando los siguientes nombres de estaciones y concatenando los resultados:Finalmente, estoy calculando el código de caracteres de
!as(2<<4)+1 == 33. Todas estas partes se concatenan en Paddington y finalmente se imprimen en Mornington Crescent.Nota: El idioma no especifica si es posible viajar a la misma estación dos veces seguidas, pero el intérprete lo permite, así que lo he utilizado.
fuente
mal , 70 bytes
Utiliza los siguientes cuatro comandos:
fuente
brainfuck, 72 bytes
Pruébalo en línea!
Y la solución original de 76 bytes sin envoltura :
Pruébalo en línea!
Otras soluciones más cortas conocidas (que yo sepa) que he encontrado
'¡Hola Mundo!' 77 bytes:
Pruébalo en línea!
'¡Hola Mundo!' 70 bytes:
Pruébalo en línea!
Estos se encontraron usando un programa de C ++ que escribí aquí: https://github.com/ksabry/bfbrute
Nota: Originalmente quería limpiar este código antes de publicarlo para que sea realmente legible y utilizable, pero como no lo he hecho en más de un año, creo que lo publicaré tal como está. Hace un uso intensivo de plantillas y constantes de tiempo de compilación para cualquier optimización potencial y tiene un montón de código comentado de mis pruebas, pero no hay comentarios útiles, lo siento, pero es un poco horrible.
No hay nada terriblemente inteligente sobre el código, es su fuerza bruta en su núcleo, sin embargo, está bastante optimizado. La optimización principal es que primero itera a través de todos los programas sin bucles (no
[o]) hasta una longitud especificada (16 actualmente) y almacena en caché una matriz de todos los cambios que realizará en la matriz de datos. Es sólo almacenará un solo programa por matriz única de cambios así que por ejemplo sólo una de>+<<->y<->>+<será almacenado. Luego itera a través de todos los programas posibles que se componen de cualquier programa en este caché con cualquier combinación de bucles entre ellos. Después de ejecutar cada programa, realiza una simple búsqueda codiciosa y picotea a los personajes y los agrega al final del programa.Después de ejecutar esto a través del espacio de todos los programas, noté que casi todos los programas más cortos (de hasta ~ 19) tenían la forma
*[*[*]*]. Restringir la búsqueda a programas de esta forma aceleró la búsqueda considerablemente. El poseedor del registro actual se encontró en la longitud 27. En realidad, se calculó que tenía una longitud 74, pero noté una secuencia particular.>.>.>.que tuvo la suerte de tener un 0 en la celda de datos a la derecha, lo que permite simplificarlo para[.>]<reducirlo. a 72.Lo dejé correr por bastante tiempo y completé la búsqueda con los parámetros actuales hasta 29, sospecho que será difícil superar el actual simplemente yendo más alto, creo que el enfoque más prometedor probablemente sería aumentar el espacio de búsqueda en De alguna manera inteligente.
fuente
Piet, 90 codeles
Esta es una imagen de 30 por 3. Alternativamente, en el tamaño de codel 10:
Utiliza un diseño de 3 alturas, por lo que solo necesito apuntar una vez. Si esto todavía es golfable, probablemente podría afeitarme como máximo en otra columna, ya que hay un no-op de push-pop allí.
Editar: la solución 84 codel de @primo .
fuente
Alpaca , 17 bytes
Haystack es un lenguaje de programación 2D que se ejecuta hasta que encuentra la aguja en el pajar
|, todo mientras realiza operaciones basadas en la pila. Todos los programas comienzan desde la esquina superior izquierda y pueden usar los caracteres direccionales><^vpara moverse por el programa. La dirección se hereda, por lo que no necesita seguir usando>para ir a la derecha, la dirección solo cambiará cuando toque un carácter direccional diferente.Por defecto, el intérprete lee desde la parte superior izquierda hacia la derecha, por lo que podemos simplemente decir "¡Hola, mundo!" sobre la pila, use
opara imprimirla, luego coloque la aguja para terminar de ejecutar.Bonus: una versión más emocionante:
fuente
osalidas como un número. ¿No debería sercal final? ¿Hay documentación adecuada en alguna parte? Esto es super interesante!ogenera el elemento de la pila superior tal cual, es decir, si hay un número allí, lo imprime.csimplemente lanzaría eso a un personaje. Entonces, si tienes una cadena o char en la parte superior de la pilao, sería lo que deseas :) Eventualmente, estos documentos se actualizarán ...Ayuda, WarDoq! , 1 byte
¡ Ayuda no solo ayuda, WarDoq! tiene una función integrada para la ortografía más común de la frase, incluso satisface nuestra definición habitual de lenguaje de programación.
Pruébelo en el intérprete oficial en línea (el código va en Entrada ).
fuente
"Space: Begin a comment. The next non-space character ends the comment and is interpreted as usual."¿Entonces solo puedes tener comentarios de espacios? Supongo que incluso el idioma más útil del mundo tiene que tener una característica inútil +1,MarioLANG ,
259249242240235 bytesEsto ha sido probado en la implementación de Ruby .
Después de ofuscar "¡Hola, mundo!"en MarioLANG lo estudié un poco. Lo anterior es el más corto que he encontrado hasta ahora.
Como antes, comencé con una solución Brainfuck que establece cuatro celdas al múltiplo de 10 más cercano a los caracteres
He,y el espacio y lo convirtió a MarioLANG . Luego puede acortar un poco el código haciendo uso del piso auxiliar en el bucle que casi reduce a la mitad el ancho del bucle. Tenga en cuenta que la parte inferior solo se ejecuta una vez menos que la parte superior, por lo que ya no obtiene múltiplos exactos del contador inicial en las 4 celdas.Finalmente, quería aprovechar el espacio desperdiciado en frente del circuito, así que agregué un montón de ascensores para aprovechar el espacio vertical allí. Y luego me di cuenta de que podía doblar el código después del bucle (ver la revisión anterior) debajo del bucle para utilizar un poco más de espacio vertical, lo que ahorró cinco bytes más.
Es probable que esto todavía esté lejos de ser perfecto, pero creo que es una mejora decente sobre la solución ingenua.
Metagolf
Tiempo para algo de automatización ...
He comenzado a configurar un solucionador en Mathematica para encontrar una solución óptima. Actualmente se supone que la estructura del código es fija: el contador se establece en 12, 4 celdas para imprimir, con la asignación fija
He,<space>y el mismo orden de esas celdas. Lo que varía es el número de+s en el bucle, así como las correcciones necesarias después:Resulta que para un contador inicial de 12 mi solución artesanal ya es óptima. Sin embargo, el uso de 11 ahorra dos bytes. Intenté todos los valores de contador del 6 al 20 (inclusive) con los siguientes resultados:
Nota: Este solucionador supone que el código lineal después del bucle está en la línea superior, y el código anterior es esa solución plegada. Puede haber una solución general más corta haciendo que el solucionador sea consciente del plegado, porque ahora obtengo 3
+s más en la primera parte de forma gratuita, y las siguientes 4 instrucciones costarían solo 1 byte en lugar de 2.fuente
Oscuro , 106 bytes
Solo dejaré que algunas citas de la especificación del idioma hablen de la brillantez de este esolang:
fuente
Homespring , 58 bytes
El espacio final es significativo.
Dejame contarte una historia. Había una vez una planta de energía que alimentaba un criadero de salmón cercano. El criadero de salmones incubó un salmón joven sin hogar que se embarcó en un viaje río arriba para encontrar un manantial. Encontró tal manantial, con el nombre poético "¡Hola, Mundo!", Donde maduró y generó un nuevo salmón joven. Ambos peces ahora nadaban río abajo, en busca del amplio océano. Pero justo antes de la desembocadura del río, había una red en el río: el pez maduro fue capturado y solo el joven logró deslizarse y llegar al océano y al resto del universo. Mientras tanto, la planta de incubación había eclosionado más salmón que también había viajado río arriba y engendrado, y así sucesivamente.
Sin embargo, grandes cantidades de nieve derretida habían estado viajando por un brazo diferente del río. Y justo después de nuestro primer salmón joven de los manantiales de "¡Hola, mundo!" ha llegado al océano, el deshielo golpeó el universo y ... eh ... lo destruyó. Y vivieron felices para siempre ... o supongo que no.
Esos fueron en realidad la semántica del programa anterior. Homespring es raro.
fuente
Chef , 465 bytes
Probado con el intérprete de Ruby. Hace sopa de letras.
Traté de cumplir con la especificación original como pude, por lo que, aunque el intérprete que utilicé te permite dejar caer el
thes en elPour contentsinstrucción, no lo he hecho.El tazón para mezclar es bastante caro, por lo que podría haber un mejor enfoque. Intenté usar la conversión de base para codificar el mensaje, pero desafortunadamente la especificación no aclara si
Divideusa división entera o de coma flotante, y el intérprete que tengo usa la última. Tampoco hay un operador de módulo, que tampoco ayuda.fuente
Piet, 84 codeles
28x3, aquí se muestra con el ancho de codel 10.
Creado con PietDev , probado con npiet . El diseño del programa es el siguiente:
El relleno amarillo indica los codeles donde el camino se superpone, el relleno naranja indica los codels que deben ser del mismo color, para propósitos de control de flujo.
Para ayudar en la creación de esto, escribí un intérprete rudimentario para un lenguaje basado en pila con comandos tipo piet, que he denominado "pasm" ( fuente ). La salida de este intérprete (con esta entrada ) es la siguiente:
No se utilizan punteros, interruptores ni comandos de desplazamiento. Tampoco se desperdician los códeles; de hecho dos son reutilizados.
fuente
Espacio en blanco ,
192150146 bytesEl espacio en blanco solo necesita espacios, pestañas y saltos de línea, mientras que otros caracteres se ignoran.
Lo cual puede ser problemático para mostrar aquí.
Entonces, en el código debajo de los espacios y pestañas fueron reemplazados.
Y un ';' se colocó delante de los avances de línea para mayor claridad.
Para ejecutar el código, primero reemplace. y> por espacios y tabulaciones.
Hexdump de código
Código de ensamblaje de espacios en blanco:
Observaciones:
Tuve que escribir un programa solo para calcular que sumar 107 da el golf óptimo para la oración. Dado que el tamaño de bytes que toma un entero en el código cambia. : 4 + int (abs (log2 ($ n)))
El código aún se ejecutará sin la etiqueta "e:" y la parte de salida en whitespace.kauaveel.ee . Pero eso podría invalidar el código de espacio en blanco en otros compiladores de espacio en blanco. Así que esos bytes no fueron extraídos de la solución.
Se debe notar que
Como Kevin Cruijssen señaló en los comentarios, al permitir una "salida por error" según el meta, el espacio en blanco se puede codificar con más de 126 caracteres.
Montaje:
fuente
SSN(valor de error) en lugar deSSSN(push 0 ), que está permitido según el meta . Pruébelo en línea (con resaltado y explicación adicionales) , o pruébelo en línea sin procesar .dup jumpz ey ele: exiteliminado. Pero al menos en whitespace.kauaveel.ee continúa en bucle hasta que el navegador se queja. Prefiero no cambiar mi versión a eso, a pesar de que el golf más bajo y el meta permiten "salir por error". Pero puede enviar su versión como una nueva respuesta.SSNal principio, en cuyo caso se produce un error con Can't do Infix Plus cuando solo tiene un único elemento en la pila (el 107). ( Pruébelo en línea ) . Dejaré mi comentario aquí cuando alguien tenga la misma sugerencia. Y creo que ya hice +1 en tu respuesta hace aproximadamente un año. ;)Java, 79
Las versiones anteriores de Java pueden permitirle usar un bloque estático (51 bytes), pero actualmente no conozco una forma de evitar el
mainmétodo.fuente
enumlugar declass.interfacey eliminando elpublicespecificador. He rechazado la edición. siguiente política de , pero como no pueden comentar, pensé en avisarle para que pueda usarla si lo desea.CSS, 30 bytes
Las hojas de estilo en cascada (CSS) no son un lenguaje de programación típico, pero pueden generar resultados fijos bastante bien. Esto se hace creando un pseudo-elemento después de cada elemento con el contenido
Hello, World!. Entonces, solo<html>se selecciona un elemento ( ), esto supone que estamos usando el documento HTML más básico, es decirEsto funciona en la mayoría de los principales navegadores, con la notable excepción de Firefox, que aplica el selector a los elementos
<html>y<body>. Esta es también la razón por la cual los fragmentos de pila no funcionan, porque siempre hay un elemento del cuerpo que también se estiliza. A continuación se muestra una versión ligeramente modificada para probar.fuente
* *para seleccionarbody.* :aftertambién parecía funcionar.HTML, 13 bytes
El texto se inserta automáticamente en
<body>, y se muestra.fuente
Código de máquina x86_64 para Linux, 32 bytes
Cuando Linux inicia un nuevo proceso, todos los registros (excepto RSP) son cero, por lo que podemos obtener RAX = 1 solo modificando el byte bajo. El x86-64 System V ABI no garantiza esto, pero es lo que Linux realmente hace. Este código solo funciona como
_starten un ejecutable estático.La instrucción de llamada empuja la siguiente dirección, que contiene la cadena hello world, en la pila. Introducimos la dirección de la cadena
rsi.Luego, los otros argumentos se configuran para un
syscalltosys_write, que imprime la cadena.El programa termina con un
syscalltosys_exit.sys_writedevuelve el número de bytes escritos, por lo que los bytes superiores de RAX son cero después del primerosyscall(a menos que haya devuelto un error), entoncesmov al, 60nos da RAX =__NR_exiten solo 2 bytes.Puede hacer que este programa sea predeterminado al cerrar su stdout (
./a.out >&-), porsys_write()lo que regresará-EBADF, el segundosyscallregresará-ENOSYSy luego la ejecución se caerá al final. Pero no necesitamos manejar loswrite()errores con gracia.fuente
__NR_writees 1. Esto no es estándar en diferentes sistemas Unix x86-64. También depende del comportamiento de Linux de poner a cero todos los registros, excepto RSP, antes de ingresar a un proceso nuevo (por lo que esto solo funciona si lo compila como un ejecutable estático, de lo contrario, el vinculador dinámico dejará basura en los bytes superiores derax'y' lo conseguiré-ENOSYS). El x86-64 System V ABI dice que los registros pueden contener valores de basura arbitrarios en la entrada_start, el núcleo de Linux en sí mismo elige cero para evitar fugas de información.mov al, 1/mov edi, eax(2 bytes), en lugar de necesitar un prefijo REX para DIL, porque__NR_write == STDOUT_FILENO = 1mov esi, msg(NASM), también conocido comomov esi, OFFSET msg(GAS.intel_syntax) . Pon tu cuerda después de la últimasyscall.call/popes 1 byte más corto que LEA relativo a RIP de 64 bits, pero mov es lo mejor.Hexagonía ,
3732 bytesPruébalo en línea!
Presento con orgullo mi segundo lenguaje de programación 2D y (que yo sepa) el primer lenguaje 2D en una cuadrícula hexagonal.
El código fuente no se ve muy 2D, ¿verdad? Bueno, el espacio en blanco es opcional en Hexagony. Primero, el código fuente se rellena al siguiente número hexagonal centrado con no-ops (
.). El siguiente número es 37, por lo que insertamos cinco no-ops al final. Luego, el código fuente se reorganiza en un hexágono regular:Esto también es ejecutable. Pruébalo en línea!
Hexagony tiene un montón de características bastante originales, que incluyen 6 punteros de instrucciones diferentes y un diseño de memoria que es el gráfico lineal de una cuadrícula hexagonal, pero este código usa solo una IP y un borde de memoria, así que no nos preocupemos por eso por ahora.
Aquí hay una descripción general de los comandos relevantes:
;imprime el valor actual, módulo 256, como un byte a STDOUT./es un espejo que se comporta como cabría esperar (haciendo que la IP tome un giro de 120 grados).@termina el programaAhora la captura final es que la fuente se envuelve alrededor de los 3 pares de bordes. Además, si la IP sale de la cuadrícula a través de una de las seis esquinas, hay dos filas posibles para saltar. El que se elija depende de si el valor actual es positivo o no positivo. La siguiente versión anotada muestra dónde vuelve a ingresar la IP cada vez que sale de la cuadrícula:
Entonces, si eliminamos todos los cambios de dirección, este programa se reduce al siguiente código lineal:
¿Qué pasa con
Q2,P0yP1? Las letras se imprimen fácilmente porque podemos establecer el borde en el valor correspondiente. Para la coma, el espacio y el signo de exclamación, eso no funciona. Asimismo, no podemos simplemente establecemos su valor con44,32,33, respectivamente, debido a que el borde de memoria no es cero, para empezar, y debido a la semántica de los dígitos individuales que causaría todo tipo de estragos. Si quisiéramos hacer eso, tendríamos que restablecer el valor de borde a cero con algo como*,+,-,&o^en primer lugar. Sin embargo, dado que el valor se toma el módulo 256 antes de imprimirse, no tenemos que establecer los valores exactamente en 44, 32 o 33. Por ejemplo,Q2estableceremos el valor de borde cuando se tome el módulo81*10 + 2 = 812, que es44256. De esta manera podemos guardar un byte en cada uno de esos tres caracteres. (Por desgracia, nunca es posible llegar con un solo dígito del valor de la celda ya ha. Sorprendentemente, donde se hace el trabajo es laodeWorld, porque eso también puede ser obtenido a partir deW9.)Puede usar este script CJam para encontrar todas las combinaciones de letras y dígitos que den como resultado un carácter dado.
No estoy seguro de si esto es óptimo. Dudo que sea posible hacerlo en un hexágono de longitud lateral 3 (donde solo tendría 19 caracteres disponibles), pero podría ser posible resolverlo en un hexágono con longitud lateral 4 con menos de 32 comandos, como que hay más no-ops al final de la cuadrícula.
fuente
Q2,P0yP1es muy inteligente. No conocía el módulo 256 parte.M8;(og4;), que he usado un par de veces desde entonces. Nunca se me ocurrió hasta ahora volver a visitar esta respuesta después de hacer ese cambio.H;e;P;2Q/d;l;r/l;$@;o];o;W;03&;Malbolge, 112 bytes
Voy a ver si hay uno más corto. Tengo una mejor computadora desde la última vez, por lo que puedo generar un poco más rápido.
Para el espectáculo, aquí está "¡Hola Mundo!" sin la coma
fuente
('<;_#"~6Z|{y1UTvt,PrpMo,llj"Fgge{A??P=^t:8&7YtFVqjSQ@PNM)u(I8%$#"D2AA/[TYXQu88MLp3n1Gk.D-ge(92 bytes)Fourier , 15 bytes
¡GRANDES CAMBIOS a Fourier!
Pruébalo en FourIDE!
Sí, los días de escribir el código ASCII de cada personaje se han ido para siempre: Fourier ahora menos admite cadenas. Cuando encierra una cadena en backticks, esa cadena se generará.
Tenga en cuenta que no puede hacer nada más que generar esa cadena: no puede almacenarla en una variable, no está almacenada en el acumulador y no hay herramientas de manipulación de cadenas.
Aquí, puedes encontrar el choque de trenes que era el viejo Fourier. ;)
Pruébalo en línea!
Ahora, algunos de ustedes probablemente habrán conocido a Fourier antes y pueden estar bastante familiarizados con el idioma. Todo el lenguaje se basa en un acumulador: una variable global que utilizan prácticamente todos los operadores.
La parte más importante del código es el
aoperador. Esto toma el valor numérico del acumulador y lo convierte en un carácter usando el código Pythonchr(accumulator). Esto se imprime en STDOUT.Desafortunadamente, aún no he tenido la oportunidad de usar Fourier ( empujar empujar , guiño guiño ), principalmente debido a su falta de cadenas y operadores de cadenas. Aun así, sigue siendo útil para muchos otros desafíos (consulte la sección de ejemplos de su página EsoLangs).
Tenga en cuenta que esto es más corto que mi entrada en la lista de Esolangs porque en realidad no pensé que podría seguir jugando golf. Y luego, al escribir el desafío de golf de cuerda de Fourier, me di cuenta de que podía ir un poco más corto.
Nota
Si se preguntaba sobre la sintaxis variable, Geobits escribió un programa que usa variables y tiene la misma longitud:
Pruébalo en línea!
fuente
C-- , 155 bytes
Desafortunadamente, el único compilador de C--, Quick C-- ya no se mantiene. Es un dolor en el cuello construir, pero es posible ...
fuente
C, 30 bytes
Bastante vainilla, pero no puedo pensar en una forma comúnmente compilable de hacerlo más corto (a menos que tal vez algún tipo de truco asm crudo funcione). Aún así, supera a la mayoría de esolangs!
fuente
main(){puts("Hello, World!");return 0;}y 53#include <stdio.h> int main(){puts("Hello, World!");}bytes respectivamente. Un poco más si crees que se requiere main (void).main(){return!puts("Hello, World!");}es dos bytes más corto.hes 29 bytes más corto. Nota: tendrás que compilarlo con-Dh='main(){puts("Hello, World!");}'Estoy medio trolling, mitad divertido con el abuso del compilador.__FILE__(8 bytes) y nombre el archivomain(){puts("Hello, World!");}. Entonces es totalmente no hacer trampa;)Ilegible ,
843755732666645629577 bytesSe supone que los programas ilegibles se muestran con una fuente de ancho variable, por lo que respetan el nombre del idioma. Estoy un poco decepcionado de que mis enfoques más sofisticados resultaron ser mucho más largos. Los bucles son increíblemente caros en ilegible ...
Pruébalo en línea!
Cómo funciona
Ilegible tiene solo diez funciones; seis de estos se usan en este código:
Después de usar mi notación de un solo carácter y agregar algunos espacios en blanco y comentarios, el código anterior se parece a lo siguiente. Las declaraciones de varias líneas se ejecutan de abajo hacia arriba.
He generado el código fuente real ejecutando la versión no comentada del pseudocódigo anterior a través de este programa CJam .
fuente
Befunge 98 ,
1918 BytesNueva respuesta (de undergroundmonorail)
Explicación
"inicia el modo de cadenaHello, World!@,kc"nuevo, terminando el modo de cadenac)ktoma el valor superior de stack y ejecuta el siguiente comando que el puntero de instrucción puede ver muchas veces,saca un valor de la pila y lo genera como un carácter. Ha sido ejecutado 12 veces por últimakinstrucción, y una vez más cuando el intérprete realmente lee la,instrucción@termina el programaLa diferencia con la respuesta anterior es que reutilizamos inteligentemente el
"personaje mediante el uso del comportamiento de bucle de Befunge cuando llega al final de la línea. Como puede ser menos intuitivo, también dejo el anterior. Además, es posible que haya notado que la pila todavía contiene algunos caracteres (ck,@) debido a este buen truco, dejando un poco de desorden si alguna vez quisiéramos hacer algo después de eso.Vieja respuesta
Esto funciona para funge y befunge 98
Explicación
""está en medio se empuja a la pila. ('H'ahora está en la parte superior)c(12) es empujado a la pilaktoma el valor superior de stack y ejecuta el siguiente comando que el puntero de instrucción puede ver muchas veces.,saca un valor de la pila y lo genera como un carácter. Ha sido ejecutado 12 veces por últimakinstrucción, y una vez más cuando el intérprete realmente lee la,instrucción@termina el programafuente
kcpara93+."ck,@!dlroW ,olleH"para iniciar la cadena, agrega todo el resto de la línea a esa cadena, se envuelve y golpea el mismo"para finalizar la cadena. Ahora todo el programa, excepto el que"ha sido empujado a la pila, con la!dlroW ,olleHparte superior. Luego imprime los 12 caracteres principales de la misma manera que el suyo y se detiene en@.JSFuck ,
629362896277 bytesEsto puede ser mencionado como uno de los más largos "más cortos Hello, World! " (En realidad no sé si esto es óptimo, pero es el más corto que logré obtener).
Advertencia: solo funciona en Firefox y Safari
También hay una versión un poco más larga (+4 bytes) que también funciona en Chrome y Microsoft Edge:
Mostrar fragmento de código
Para aquellos que no están familiarizados con JSFuck, se trata de escribir JavaScript como si solo hubiera seis caracteres, y a veces puede volverse bastante loco.
¡Esta tabla muestra cómo los personajes se usaron en Hello, World! programa están codificados en JSFuck. El código de texto plano es justo
alert("Hello, World!").Aquí las cadenas
"fill","fontcolor"etc. deben escribirse como"f"+"i"+"l"+"l","f"+"o"+"n"+"t"+"c"+"o"+"l"+"o"+"r"para codificarse.Los identificadores globales
self,atobybtoase escriben comoFunction("return self")().Functionen sí debería ser[]["fill"]["constructor"].La coma
","es complicada, no estoy 100% seguro de cómo funciona, pero utiliza la[]["concat"]función para crear una matriz. Publicaré una actualización cuando tenga tiempo para hacer más pruebas.Codifiqué esto usando JScrewIt: créditos para GOTO 0 por crear una herramienta tan sofisticada:
alert("Hello, World!")Esto difiere de mi respuesta a esta pregunta por la presencia de la coma después de "Hola".
Curiosamente, la sintaxis de ES6
toma incluso más bytes para codificar (+1500 más o menos) debido a la mayor complejidad de codificar dos backticks en lugar de
("y").fuente
Pada ,
8368 bytesCreo que esto es óptimo para un programa lineal (es decir, uno que no utiliza los operadores de flujo de control
?y*). Puede ser óptimo en general, pero no sé cómo hacer uso de esos operadores adicionales en una cantidad de código tan pequeña (o cómo explorar las posibilidades mediante programación).El idioma ha sufrido algunos cambios recientemente después de que comencé a discutirlo con el autor por correo electrónico. Sin embargo, he escrito una implementación de referencia para el estado actual de la especificación del idioma la semana pasada, por lo que el código anterior es realmente ejecutable.
Metagolf
Originalmente, utilicé el resultado de mi implementación de referencia para este desafío y creé una solución hecha a mano basada en eso. Sin embargo, eso fue solo un enfoque heurístico.
Entonces, en su lugar, escribí un solucionador en Mathematica que realmente conoce las estructuras de datos y operadores de Pada para encontrar una solución óptima. En promedio, crece linealmente con la longitud de la cadena (aunque algunas combinaciones de caracteres son un poco más lentas que otras) y tardó aproximadamente 1,5 horas
Hello, World!.Entonces, ¿cómo hice para escribir el solucionador? Primero, notamos que solo necesitamos considerar 6 operadores:
~.oOqQ(más lo necesariowpara cada uno de los caracteres impresos). El uso de las pilas o los bloqueos de bits no es útil en el código lineal, y no lo creo?y*se puede usar de manera efectiva en menos de 68 bytes.El estado de Pada (ignorando las pilas y cerraduras) consta de 7 interruptores y 8 bits, organizados así:
Entonces eso es posible estados. Mi primer paso de preprocesamiento fue configurar un gráfico dirigido de estados donde cada borde corresponde a una sola operación. Es decir, el gráfico tiene 32768 vértices, cada uno con un grado de salida 6 (un borde de salida para cada una de las 6 operaciones bajo consideración). Podemos usar este gráfico para encontrar el camino más corto entre dos estados (este gráfico solo puede ser bastante útil para jugar al golf en Pada).
215 = 32768Ahora para cada personaje, queremos alcanzar un estado donde
wimprima ese personaje. ¿Cuántos de esos estados hay?wlee el byte del bit en el que se suelta (cíclicamente). Entonces, hay 8 rotaciones posibles de los bits del carácter que pueden imprimir ese carácter. Para cada una de esas rotaciones, se fijan tres interruptores (para hacerwcaer en la posición correcta). Esto deja 4 interruptores arbitrarios. Entonces tenemos posibles estados para cada uno en nuestro código.8 * 24 = 128wCon ellos podemos resolver otro problema gráfico: construya un gráfico que tenga un vértice de origen, luego una "capa" para cada personaje y un vértice de sumidero. Las capas consisten en 128 estados para cada vértice, el nodo fuente corresponde al estado inicial del programa (todos los interruptores a la izquierda y todos los bits son cero). El nodo sumidero no corresponde a ningún estado en particular. Tenemos bordes dirigidos desde cada vértice en una capa a cada vértice en la siguiente capa, donde el peso del borde es la distancia entre los dos estados en nuestro gráfico anterior. Los pesos de los bordes desde la última capa hasta el sumidero son todos 0. Es decir, podemos calcular previamente todos esos pesos de borde. Este es el paso más costoso del cálculo y tomó 1,5 horas
Hello, World!.Con este gráfico configurado, podemos encontrar el camino más corto desde la fuente hasta el sumidero con bastante rapidez (tardó 0.05s en mi máquina). Para
Hello, World!los estados deseados son:donde los 7 bits menos significativos corresponden a los interruptores y los 8 bits más significativos a los bits de Pada.
Ahora volvemos al primer gráfico y encontramos los bordes reales (es decir, operaciones) correspondientes a la ruta más corta entre cada par de estados posteriores, y terminamos cada uno de ellos con a
w. Voilà, una solución óptima (basada en los supuestos anteriores).Aquí está el Mathematica completo si alguien alguna vez quiere metagolf una cadena diferente en Pada:
fuente