Félicitations à Dennis qui a remporté le défi des flics et des voleurs! Calvin's Hobbies a déjà tenu sa promesse et a écrit ce défi à Dennis pour avoir remporté le défi des voleurs.

Avis: Ce défi est fermé pour d'autres réponses de flic à partir du 2015-09-01 02:00:00 UTC. Toute nouvelle réponse publiée ne sera pas éligible pour gagner et ne comptera pas dans le score des voleurs si elle est fissurée. Cependant, vous pouvez toujours poster de nouvelles réponses pour le plus grand plaisir des autres utilisateurs, de sorte qu'il reste encore quelques énigmes à proposer aux futurs visiteurs. Ces nouvelles réponses sont incluses dans la section "Vulnerable Cops" du classement et leur statut non concurrentiel est indiqué séparément.

Bienvenue dans l'édition Cops-and-Robbers du Quiz Hello World ! (Si vous n'avez jamais joué au quiz, n'hésitez pas à l'essayer pendant une minute ou 30 secondes. Vous n'avez cependant pas besoin de le jouer pour ce défi.)

Le défi des flics

Choisissez un langage de programmation. Les langues valides doivent comporter un article Wikipedia anglais , un article esolangs ou un article Code Rosetta au moment de la publication du défi (notez que les listes chaînées ne sont pas nécessairement complètes car elles sont préparées manuellement). Ils doivent également satisfaire à nos normes habituelles pour les langages de programmation , de sorte que des choses comme HQ9 + sont disponibles. Enfin, un interprète ou un compilateur gratuit (comme dans la bière) doit être disponible pour la langue (au moment de la publication du défi).
Ecrivez un programme Hello World. En d’autres termes, écrivez un programme complet dans la langue choisie qui imprime Hello, World!(exactement comme cela, c’est-à-dire ce flux d’octets exact) et éventuellement un retour à la ligne simple derrière STDOUT ou l’alternative la plus proche.

Vous ne devez pas supposer un environnement REPL, un code standard existant ou des indicateurs de compilateur / interpréteur non standard. Le programme doit se présenter sous la forme d’un ou de plusieurs fichiers source (afin d’exclure des langues bizarres telles que les dossiers ) et doit s’intégrer à votre réponse dans son intégralité (il ne doit donc pas comporter plus de 30 000 caractères). toute soumission sérieuse.

Si votre code contient des octets situés en dehors de la plage ASCII imprimable, veuillez inclure un pâlage bin ou hexagonal pour vous assurer que votre code est réellement testable.

Le programme doit se terminer dans la minute qui suit sur un ordinateur de bureau classique.

C'est ça. Le problème, c'est que vous voulez masquer votre code de manière à ne pas distinguer la langue que vous avez choisie. Notez également que vous ne voulez pas que votre code soit accidentellement un programme Hello World valide dans une autre langue, bien que cela soit peu probable pour des programmes suffisamment obscurs.

Vous ne devez en aucun cas modifier le code source de votre soumission une fois publiée (car cela pourrait invalider les tentatives actives d'un voleur de déchiffrer votre réponse). Assurez-vous donc de jouer au golf aussi bien que vous le pouvez (ou osez) avant de poster. Si vous réalisez que votre réponse ne fonctionne pas après l'avoir publiée, supprimez-la simplement et publiez une version corrigée si vous le souhaitez.

Si personne ne trouve une langue de votre code est valable 7 jours, vous pouvez révéler la langue choisie (idéalement avec une explication pour votre code obscurcie), qui fera votre réponse en toute sécurité . Notez que votre soumission peut encore être fissurée jusqu'à ce que vous révéliez la langue.

La soumission sécurisée la plus courte (en octets) l'emporte.

Mise en page

(N'hésitez pas à sauter cette section et à lire le défi des Robbers si vous ne prévoyez pas de participer en tant que policier pour le moment.)

Au bas de cet article, vous trouverez un extrait de pile qui génère des classements ainsi qu'une liste de soumissions pouvant encore être déchirées. Pour que l'extrait de code fonctionne, il est important d'inclure un en-tête dans votre réponse:

Les nouvelles réponses devraient inclure un en-tête comme
```
# ???, [N] bytes
```
où [N]est la taille de votre code en octets et ???devrait apparaître littéralement.
Si la réponse n'est pas déchirée pendant 7 jours et que vous souhaitez sécuriser votre réponse en révélant la langue, remplacez simplement le ???, par exemple
```
# Ruby, [N] bytes
```
N'hésitez pas à faire en sorte que le nom de la langue renvoie à un site Web pertinent, comme une page esolangs ou un référentiel GitHub. Le lien sera ensuite affiché dans le classement.
Si un autre utilisateur a réussi à déchiffrer votre soumission (voir ci-dessous), veuillez également ajouter la langue, ainsi qu'un avis du type
```
# Ruby, [N] bytes, cracked by [user]
```
où [user]est le nom de l'utilisateur qui a soumis la première fissure valide. Si le langage utilisé dans la fissure diffère de celui que vous vouliez, je recommanderais d'utiliser la conjecture des voleurs et de mentionner dans la réponse que vous vouliez que ce soit autre chose. N'hésitez pas à faire du nom d'utilisateur un lien vers sa page de profil.

Le défi des voleurs

Trouvez une réponse vulnérable. C'est une réponse qui n'a pas encore été fissurée et qui n'est pas encore sûre .
Crack it en découvrant son langage. Autrement dit, recherchez toute langue dans laquelle le programme donné est un programme Hello World valide (sous réserve des règles décrites dans le Défi des flics ci-dessus). Peu importe si c'est le langage que le flic avait prévu.

Si vous avez trouvé une telle langue, laissez un commentaire avec le nom de la langue. Si possible, vous devez inclure un lien vers un interprète en ligne, indiquant que le code fonctionne réellement dans cette langue, selon les besoins.

Chaque utilisateur n'a qu'une réponse par réponse. Vous ne devez pas craquer votre propre réponse (évidemment ...).

L'utilisateur qui a obtenu le plus grand nombre de réponses remporte le défi des voleurs. Les égalités sont brisées par la somme des octets des réponses fissurées (plus c'est mieux).

Étant donné que le défi des voleurs est exclusivement réservé aux commentaires, il n'y aura aucune incitation à la réputation pour les voleurs. Cependant, le Grand Maître de la rédaction de défis, Calvin's Hobbies , a gentiment proposé d'écrire un défi sur l'utilisateur qui remporte le défi des voleurs!

Tableau de bord de défi

L'extrait de pile ci-dessous génère des classements pour les policiers et les voleurs et répertorie également toutes les réponses qui peuvent encore être déchiffrées. Faites-moi savoir si quelque chose semble ne pas fonctionner correctement, et je vais essayer de le réparer dès que possible. Si vous pouvez penser à des fonctionnalités supplémentaires qui rendraient le tableau de bord plus utile, laissez également un commentaire.

Afficher l'extrait de code

/* Configuration */

var QUESTION_ID = 54807; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var DAYS_TILL_SAFE = 7;
var OVERRIDE_USER = 8478;
var CUTOFF_DATE = new Date(Date.UTC(2015, 8, 1, 2));

var MS_TILL_SAFE = DAYS_TILL_SAFE * 24 * 60 * 60 * 1000;

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  // Must load over https (this comment is because I need to change 6+ chars)
  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 VULNERABLE_REG = /<h\d>[?]{3},[^\n\d,]*(\d+)[^\n,]*<\/h\d>/;
var SAFE_REG = /<h\d>\s*([^\n,]*[^\s,]),[^\n\d,]*(\d+)[^\n,]*<\/h\d>/;
var CRACKED_REG = /<h\d>\s*([^\n,]*[^\s,]),[^\n\d,]*(\d+)[^\n,]*,\s*cracked\s*by\s*(.*[^\s<])<\/h\d>/i;
var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {  
  console.log(answers);
  var vulnerable = [];
  var cops = [];
  var robbers_hash = {};
  
  var now = Date.now();
  
  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;
    if (VULNERABLE_REG.test(body)) {
      vulnerable.push({
        user: getAuthorName(a),
        size: +body.match(VULNERABLE_REG)[1],
        time_left: (a.creation_date*1000 > CUTOFF_DATE) ? Infinity : MS_TILL_SAFE - (now - a.creation_date*1000),
        link: a.share_link,
      });
    } else if (SAFE_REG.test(body)) {
      if (a.creation_date*1000 < CUTOFF_DATE) {
        match = body.match(SAFE_REG);
        cops.push({
          user: getAuthorName(a),
          size: +match[2],
          language: match[1],
          link: a.share_link,
        });
      }
    } else if (CRACKED_REG.test(body)) {
      if (a.creation_date*1000 < CUTOFF_DATE) {
        match = body.match(CRACKED_REG);
        var language = match[1];
        var size = +match[2];
        var user = match[3];
        if (/<a/.test(user)) user = jQuery(user).text();
        var robber = robbers_hash[user] || {
          user: user,
          cracks: 0,
          total_size: 0,
          languages: [],
        };
        ++robber.cracks;
        robber.total_size += size;
        robber.languages.push({
          language: language,
          link: a.share_link,
        });
        robbers_hash[user] = robber;
      }
    }
  })
  
  console.log(vulnerable);
  console.log(cops);
  console.log(robbers_hash);
  
  vulnerable.sort(function (a, b) {
    var aB = a.time_left,
        bB = b.time_left;
    return aB - bB
  });
  
  vulnerable.forEach(function (a) {
    var answer = jQuery("#vulnerable-template").html();
    var time = a.time_left;
    var time_string = "";
    if (time == Infinity)
      time_string = "Answer is not competing";      
    else if (time > 0) {
      time_string += ((time / (1000 * 60 * 60 * 24))|0) + "d ";
      time %= 1000 * 60 * 60 * 24;
      time_string += ((time / (1000 * 60 * 60))|0) + "h ";
      time %= 1000 * 60 * 60;
      time_string += ((time / (1000 * 60))|0) + "m ";
      time %= 1000 * 60;
      time_string += ((time / (1000))|0) + "s";
    }
    else
      time_string = "Cop may reveal language!";
    
    answer = answer.replace("{{NAME}}", a.user)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{TIME}}", time_string)
                   .replace("{{TIME}}", a.time_left)
                   .replace("{{HUE}}", a.time_left <= 0 ? 0 : a.time_left == Infinity ? 160 : a.time_left/MS_TILL_SAFE*80+40)
                   .replace("{{LINK}}", a.link);
    
    answer = jQuery(answer)
    
    jQuery("#vulnerable").append(answer);
  });
  
  cops.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });
  
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  cops.forEach(function (a) {
    var answer = jQuery("#cops-template").html();
    var size = a.size;
    if (size != lastSize)
      lastPlace = place;
    lastSize = size;
    ++place;
    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("#cops").append(answer);
  });

  var robbers = [];
  for (var r in robbers_hash)
    if (robbers_hash.hasOwnProperty(r))
      robbers.push(robbers_hash[r]);
  
  robbers.sort(function (a, b) {
    var aB = a.cracks,
        bB = b.cracks,
        aC = a.total_size,
        bC = b.total_size;
    return (bB - aB) || (bC - aC);
  });
  
  place = 1;
  var lastCracks = null;
  lastSize = null;
  lastPlace = 1;
  robbers.forEach(function (a) {
    var answer = jQuery("#robbers-template").html();
    var cracks = a.cracks;
    var size = a.total_size;
    if (size != lastSize || cracks != lastCracks)
      lastPlace = place;
    lastSize = size;
    lastCracks = cracks;
    ++place;
    var languages = "";
    var first = true;
    a.languages.forEach(function (l) {
      if (!first) {        
        languages += ", ";
      }
      first = false;
      var lang = l.language;
      if (/<a/.test(lang)) lang = jQuery(l.language).text();
      languages += '<a href="' + l.link + '">' + lang + '</a>';
    });
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{CRACKS}}", a.cracks)
                   .replace("{{TOTAL_SIZE}}", a.total_size)
                   .replace("{{LANGUAGES}}", languages);
    
    answer = jQuery(answer)
    
    jQuery("#robbers").append(answer);
  });
}

body { text-align: left !important}

#vulnerable-cops {
  padding: 10px;
  width: 600px;
}

#cops-leaderboard {
  padding: 10px;
  width: 600px;
}

#robbers-leaderboard {
  padding: 10px;
  width: 600px;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

.time-ms {
  display: none;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="vulnerable-cops">
  <h2>Vulnerable Cops</h2>
  <table class="vulnerable-cops">
    <thead>
      <tr><td>User</td><td>Size</td><td>Time Left</td></tr>
    </thead>
    <tbody id="vulnerable">

    </tbody>
  </table>
</div>
<div id="cops-leaderboard">
  <h2>Leaderboard of Safe Cops</h2>
  <table class="cops-leaderboard">
    <thead>
      <tr><td></td><td>User</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="cops">

    </tbody>
  </table>
</div>
<div id="robbers-leaderboard">
  <h2>Leaderboard of Robbers</h2>
  <table class="robbers-leaderboard">
    <thead>
      <tr><td></td><td>User</td><td>Cracks</td><td>Total Size</td><td>Languages (link to answers)</td></tr>
    </thead>
    <tbody id="robbers">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="vulnerable-template">
    <tr><td>{{NAME}}</td><td>{{SIZE}}</td><td style="background-color: hsl({{HUE}},100%,50%);">{{TIME}}</td><td><a href="{{LINK}}">Link</a></td><td class="time-ms">{{TIME_MS}}</td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="cops-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="robbers-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{CRACKS}}</td><td>{{TOTAL_SIZE}}</td><td>{{LANGUAGES}}</td></tr>
  </tbody>
</table>

Expand snippet

— Martin Ender
source

108

Une minute de silence pour ceux qui ne sont capables que de programmer Piet.

— user3819867

19

Voilà ma productivité!

— Luke

11

Je pense que je pourrais commencer à débattre de la question de savoir si je devrais ou non commencer à utiliser Foo comme mot de passe-partout ... "Oh, Foo! Petit petit FOO !!" Yup, va parfaitement.

— Kirbyfan64sos

38

Réveil , 17 octets

":"Hello, World!"

Selon le site officiel ,

Wake est un langage de programmation qui contient l’essence de Makefile, des expressions régulières et des correspondances de motifs de langages de programmation fonctionnels.

Wake a été créé par shinh et peut être testé sur son serveur de golf Anarchy Golf .

Le code consiste en une seule ligne contenant une cible / étiquette et une action. Comme l'action est un littéral de chaîne, elle est imprimée dans STDOUT.

Utiliser "pour la cible a deux objectifs:

Il offre une protection polyglotte.

Clip et Foo imprimer :; GolfScript et CJam provoquent une erreur de syntaxe en raison d'une chaîne inachevée.
Cela crée une petite incertitude sur la manière dont le code est censé fonctionner.

— Dennis
source

1

On dirait que cela pourrait être la soumission gagnante.

— Primo

J'ai trouvé un langage dans lequel cela fonctionne conformément à la spécification définie de manière vague, mais le seul compilateur existant, pour autant que je sache, a un bogue qui provoque son échec.

— histocrat

Mes deux théories sur ce qu'il en est sont les suivantes: 1: il pourrait s'agir d'un langage comportant des étiquettes de ligne arbitraires, ce qui en ":fait un préfixe de ligne valide et qui traite un littéral de chaîne par lui-même dans la ligne réelle en tant que commande de sortie. Ou 2: Il s’agit d’une substitution de chaîne et est <foo>:<bar>supprimée <foo>de <bar>. Ectoforte, extrait de la page wiki Fortes d'esolangs, satisfait en quelque sorte à 1, mais l'interprète lié rompt avec une double citation dans le libellé et je ne sais pas si cela compte vraiment comme langue.

— histocrat

1

Bien fait, Dennis. J'espérais que mon 20 octets était finalement assez bon pour être le grand gagnant. Quelle menace! : P C'est un nouvel avatar, non?

— mbomb007

@ mbomb007 J'ai lu votre commentaire avant de le modifier. Oui, l'avatar est flambant neuf.

— Dennis

147

TinyBF , 708 octets, fissuré par kirbyfan64sos

C'était amusant fou. Tout le monde sait que je ne peux écrire qu'une seule langue;)

I,c,o,d,e,C;i;main(){i++;for(i++;i^9;i++)putchar(((i+69)*!(i+2*~0)|(9!=9+(I=((i-1)>>(i+2*~0))+~(!(i+2*~0)+~0)))*111|115*(6>i+1)*(i>3)+~(i>(10+(9>i)+~i+(i>9)))+(5<i)+(i<5)+1|(c=(i>6))|(o=(i>=7+!i))|(d=(i>>1>3)*(i*((i+~0>5)<<2)+(i>~2+i)))|(e=(i-~0>(i|5)&&32>>i)*99)|(C=(i>>(i>>2+i/7)>0)*(i+(i<<1)+(i<<2)+(i<<3)+(i<<4)>=(i!=6)*(5>=i)*(i+(i<<5)))*(i+(i*i)+62)*((i==6)!=!i)))+(i*i+(i<<1)+(31+i^i)+(i+i)*~0+2*i)*(1==(i==7)));I|=(c+=(o>d)),2*(c+C>o+d);e^=(d>>c)|4;I-=(e>C)+(I+c+(o==C)-~7*(C<=I)>>(C>=o));C=(e>>2)^(I-~o==c),o=255>>((int)1e7*(c-~1)>>(C+e+d+o+I)),i|=i+(e>=d)+(2<<I)+(3<<c);putchar(!(I+d+c>=(C|e))?(I>o)+(d=(20*(I==c))>>(1==~I+d+e+(C==(1>=(I==C))))):(I+o+C)*((C+e)/5+C+I+20+I+I==1>>(o>>(d>=(C!=I)))));}

Explication

Tout d’abord, cela a pris de nombreuses heures, alors je suis extrêmement ravi de toutes les réactions positives et de toutes les tentatives faites pour la résoudre!

Comme indiqué dans les commentaires, une fois compilé en C, le code est imprimé Gotcha!suivi d'une nouvelle ligne, mais il est imprimé lorsque TinyBF le souhaité Hello, World!. TinyBF est un simple dérivé de Brainf ** k qui remplace ses 8 commandes avec seulement 4: + > | =. Puisque tous les autres personnages sont ignorés, je pourrais écrire un programme C avec de nombreux opérateurs inutiles pour tenter d’orienter les gens dans la mauvaise direction (qui, à ma grande surprise, a assez bien fonctionné). Voici le code TinyBF pur:

++++++++|=+=>>++++|>+>+>+>++>+++|=>|=>=+|=>>>+>+>+|=>|>>|=>>>>+>++++>==>=+++===+++++++====|=+=>+>+=>>|=>+++===>>>==>>===>>>>++++|=+>=++++>=|>+===>>==+++==>===++++++++==>>>>>==

Voici le même programme, écrit en BF ordinaire:

++++++++[->>++++[>+>+>+>++>+++[<]>-]>>>+>+>+[<]<<]>>>>+>++++>.>---.+++++++..[->+>+<<]>+++.<<<.<<.>>>>++++[-<++++>]<-.>>.+++.>.--------.<<<<<.

Vous pouvez utiliser cet interpréteur pour convertir de BF en TinyBF et exécuter le code.

— BrainSteel
source

30

Je vois une définition pour main(). Pourrait-il être C? http://codepad.org/pj9mQgyQ (Comme note: sortie Gotcha!)

— DDPWNAGE

1

Sur la base de vos réponses et de la documentation, je dirai que c’est Fission . Tout I,c,o,d,e,C;i;main()serait ignoré (à part le ;mais cela ne semble pas important), et le nombre élevé de ceux- !ci utilisés pour la sortie de caractères ASCII pourrait indiquer que c'est le cas. Je n'arrive pas à télécharger l'interprète de Fission et à vérifier pour le moment.

— Fataliser

1

@Fatalize Solid suppose, mais ce n'est pas de la fission :) Un "L" ou un "R" serait nécessaire pour démarrer le programme, car tout se trouve sur une seule ligne.

— BrainSteel

47

C'est TinyBF !!!!!!

— Kirbyfan64sos

6

Félicitations pour le badge en or pour ce post. : D

— Alex A.

113

evil , 658 bytes, fissuré par Sp3000

#!/sbin/fortran

Hello, World = 'SCBsIG8gICBvIGwgIQogZSBsICwgVyByIGQKYm9zcnJ1a3R2cG54cHN2eGJ5eWJkeG9iaHJ0eHV0SGF0eXJhcGF4eW5wYWFuenhkdnBidnZuYWRhcXZoZGFhcEVxcnZkcWF1YXh0ZW5ncXJ4ZXF2d2ZndWRueXZweWR1d0x2eHhydHZidW55ZHJucW5ocGhidG5neWR3eHd0c3V3d0x2c3d0cHVueHVwdHJwaWhhaG16ZXNiaXdweWdnanVocU9saHV3eWVwaGNyeW1naHBhaW5wZGRnZWJuZ2Z1eGRwZnV3eXNienJ2enh0YnRyaXZ6ZW54eWR3eGhodHh2YVd0eXF6dnVwZWdndnVnY3d0c2NhZWRnaWRyaXJ1aHV0d09tZGRwdHJueXVneG5iYXBueG96d2FweGR3enRna21wZ1Jjc29oeHVoZ3Z4Y3V3eXV5end2cXZ1ZG52ZWJudW16d0x2YWZoeXR2ZW91YXdoYW90YXN0ZWNuY3V2cG5odXVwZ0RiY2d2ZW15cnV0ZG9id3J5dWFyYXN3Z3hhdHdkZnJkYnN3cXJ4dWJzYXf='.decode('base64').rsplit(' ', 1)

print Hello, World

le mal est un vieil esolang un peu comme BF. Les commandes sont toutes en minuscules et les autres caractères sont simplement ignorés.

Tout d'abord, j'ai généré un programme court hello world en utilisant Python:

aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw

Puis, encore une fois en utilisant Python, je l'ai transformé en une chaîne base64:

Ym9zcnJ1a3R2cG54cHN2eGJ5eWJkeG9iaHJ0eHV0eXJhcGF4eW5wYWFuenhkdnBidnZuYWRhcXZoZGFhcnZkcWF1YXh0ZW5ncXJ4ZXF2d2ZndWRueXZweWR1eHhydHZidW55ZHJucW5ocGhidG5neWR3eHd0c3V3c3d0cHVueHVwdHJwaWhhaG16ZXNiaXdweWdnanVoaHV3eWVwaGNyeW1naHBhaW5wZGRnZWJuZ2Z1eGRwZnV3eXNienJ2enh0YnRyaXZ6ZW54eWR3eGhodHh2eXF6dnVwZWdndnVnY3d0c2NhZWRnaWRyaXJ1aHV0ZGRwdHJueXVneG5iYXBueG96d2FweGR3enRna21wc29oeHVoZ3Z4Y3V3eXV5end2cXZ1ZG52ZWJudW16YWZoeXR2ZW91YXdoYW90YXN0ZWNuY3V2cG5odXVwY2d2ZW15cnV0ZG9id3J5dWFyYXN3Z3hhdHdkZnJkYnN3cXJ4dWJzYXf=

Cela décode en lettres minuscules:

bosrruktvpnxpsvxbyybdxobhrtxutyrapaxynpaanzxdvpbvvnadaqvhdaarvdqauaxtengqrxeqvwfgudnyvpyduxxrtvbunydrnqnhphbtngydwxwtsuwswtpunxuptrpihahmzesbiwpyggjuhhuwyephcrymghpainpddgebngfuxdpfuwysbzrvzxtbtrivzenxydwxhhtxvyqzvupeggvugcwtscaedgidriruhutddptrnyugxnbapnxozwapxdwztgkmpsohxuhgvxcuwyuyzwvqvudnvebnumzafhytveouawhaotastecncuvpnhuupcgvemyrutdobwryuaraswgxatwdfrdbswqrxubsaw

J'ai ajouté quelques éléments à la chaîne base64, puis je l'ai écrit en tant que programme Python ci-dessus.

Le shebang est réellement important dans le programme. Le savant bdans sbinsautera la bcommande. Ensuite, fin fortranpassera au mcaractère suivant , qui se trouve dans la chaîne base64.

— grc
source

13

Eh bien c'est intéressant . Avoir un +1 :)

— Sp3000

6

On dirait du python ...

— Zizouz212

9

Soit il s’agit d’une version / dérivée vraiment obscure de Python où le décodage Base64 fonctionne d’une manière étrange, ou le charabia Base64 n’est pas réellement Base64 dans le bon langage. Je ne peux penser à aucune autre explication possible, mais peut-être que quelqu'un d'autre le fera.

— ETHproductions

27

À 2 heures de la fin, je parie tout sur cette hypothèse: est-ce mal ?

— Sp3000

4

@Rob evil ne décode pas la chaîne base64 - la chaîne est un programme en soi. Les caractères aeeeaeee...sont mélangés avec des caractères aléatoires de sorte que la chaîne résultante soit une chaîne base64 valide. J'ai choisi des caractères aléatoires tels que la chaîne résultante décodera en base64 en minuscules, mais la chaîne décodée est en réalité non pertinente - c'est simplement une distraction. La seule chose qui compte, c’est que le mal exécute la chaîne base64, mais ignore les lettres majuscules et quelques lettres minuscules car elles ne sont pas des commandes, ce qui laisse le programme hello world.

— grc

99

Lua, 2920 2865 octets, fissuré par jimmy23013

Je n'ai appris cette langue qu'hier, alors pardonnez les erreurs de syntaxe.

 --[[~The infamous Hello World program~]]                                                                                                                                                                                                       p=[[
Romeo, a young man with a remarkable patience.
Juliet, a likewise young woman of remarkable grace.
Ophelia, a remarkable woman much in dispute with Hamlet.
Hamlet, the flatterer of Andersen Insulting A/S.


                    Act I: Hamlets insults and flattery.

                    Scene I: The insulting of Romeo.

[Enter Hamlet and Romeo]

Hamlet:
 You lying stupid fatherless big smelly half-witted coward!
 You are as stupid as the difference between a handsome rich brave
 hero and thyself! Speak your mind!

 You are as brave as the sum of your fat little stuffed misused dusty
 old rotten codpiece and a beautiful fair warm peaceful sunny summer's
 day. You are as healthy as the difference between the sum of the
 sweetest reddest rose and my father and yourself! Speak your mind!

 You are as cowardly as the sum of yourself and the difference
 between a big mighty proud kingdom and a horse. Speak your mind.

 Speak your mind!

[Exit Romeo]

                    Scene II: The praising of Juliet.

[Enter Juliet]

Hamlet:
 Thou art as sweet as the sum of the sum of Romeo and his horse and his
 black cat! Speak thy mind!

[Exit Juliet]

                    Scene III: The praising of Ophelia.

[Enter Ophelia]

Hamlet:
 Thou art as lovely as the product of a large rural town and my amazing
 bottomless embroidered purse. Speak thy mind!

 Thou art as loving as the product of the bluest clearest sweetest sky
 and the sum of a squirrel and a white horse. Thou art as beautiful as the difference between Juliet and thyself.
 Speak thy mind! Let them]] print -- (She pauses) -- it in the streets!
 --[[Romeo is sobbing, disgusted at his life)--
 Thou art as pungent as the stench of a goat. Speak thy mind!
 [[Exeunt Romeo]]
 "Hello, World!" -- No response. "Hello!" He calls out again, but to no avail.

[[Exeunt Ophelia and Hamlet


                    Act II: Behind Hamlet's back.

                    Scene I: Romeo and Juliet's conversation.

[Enter Romeo and Juliet]

Romeo:
 Speak your mind. You are as worried as the sum of yourself and the
 difference between my small smooth hamster and my nose. Speak your
 mind!

Juliet:
 Speak YOUR mind! You are as bad as Hamlet! You are as small as the
 difference between the square of the difference between my little pony
 and your big hairy hound and the cube of your sorry little
 codpiece. Speak your mind!

[[Exit Romeo]
[[

                    Scene II: Juliet and Ophelia's conversation.

[Enter Ophelia]

Juliet:
 Thou art as good as the quotient between Romeo and the sum of a small
 furry animal and a leech. Speak your mind!

Ophelia:
 Thou art as disgusting as the quotient between Romeo and twice the
 difference between a mistletoe and an oozing infected blister! Speak
 your mind!

[Exeunt]]

Avertissement: Il affiche "Bonjour le monde!" puis quitte avec une erreur

Explication:

En Lua, - [[signifie commentaire multiligne, - signifie un commentaire ligne et [[est une chaîne multiligne.

Si vous faites défiler la première ligne jusqu'au bord, vous verrez un p = [[. Cela définit une chaîne de plusieurs lignes allant de "Romeo, un jeune homme" à "Laissez-les]]", sur lesquelles la plupart des gens jettent un coup d'œil mais met fin à la chaîne multiligne. Ensuite, nous avons print, qui est la fonction print, puis "-" transforme le reste de la ligne en commentaire. Nous devons ménager un espace entre l’imprimé et Hello World pour ne pas le lâcher. Nous avons donc un commentaire multiligne: "- [[Romeo sanglotait, dégouté de sa vie) - Tu es aussi piquant que la puanteur d'une chèvre. Parle dans ton esprit! [[Exeunt Romeo]] "Le]] à la fin met fin au commentaire multiligne, et sur la ligne après" Hello, World! " et ensuite le reste de la ligne est commenté par un -.

   Thou art as loving as the product of the bluest clearest sweetest sky
     and the sum of a squirrel and a white horse. Thou art as beautiful as the difference between Juliet and thyself.
     Speak thy mind! Let them]] print 
     "Hello, world!"

— TreFox
source

8

Est-ce Shakespeare?

— SuperJedi224

Voir l'exemple de code, c'est Shakespeare: en.wikipedia.org/wiki/…

— max_

24

C'est Lua. (au moins 15 caractères)

— jimmy23013

44

Lua déguisé en Shakespeare. Génie! +1

— ETHproductions

En fait, ça imprime Hello, world!, pas Hello, World!.

— Dennis

83

TRANSCRIPTION , 39 octets

End is here.
>End, Hello, World!
>X End

En voici une belle et simple.

Premier flic sûr! Je suis surpris que celui-ci dure jusqu'à la fin - j'ai essayé de choisir une langue difficile à lire directement, mais plus facile à comprendre si vous pouviez deviner le thème.

TRANSCRIPT est un esolang basé sur des jeux de fiction interactifs. Il a des NPC (chaînes) et des objets (entiers). IciEnd le nom d'un PNJ.

La première ligne déclare le PNJ avec la syntaxe <name> is here.. La deuxième ligne attribue ensuite la chaîne à NPC"Hello, World!" et la troisième ligne l'imprime à l'aide de la X / EXAMINEcommande. Il n'y a pas beaucoup de place pour l'obscurcissement ici, donc je n'ai fait que choisir quelque chose qui n'est généralement pas un nom pour le PNJ.

Pour prouver que TRANSCRIPT est un langage valide pour ce défi, voici un programme qui vérifie si un nombre naturel en entrée est premier ou non:

The Nineteenth Room
In the middle of the room you spot a lone figure.
Martin is here.
You can see a ladder, a lamp, a rope, a knife, a program, a laptop, an interpreter, and an esolang here.

>RESTORE
Which save file would you like to restore?

>PROGRAM.sav
Done.

>SET LAMP TO 1
You turn on the lamp.

>LIFT KNIFE
You pick up the knife, feeling powerful.

>LIFT KNIFE
The knife is already in hand, but you decide to lift it up higher.
You know knives aren't dumbbells, right?

>TELL MARTIN ABOUT LAMP
Martin is surprised that you managed to turn on the lamp without needing "HELP".

>HELP
Too bad, no hints for you.

>SHOW KNIFE TO MARTIN
You pull out the knife.
Martin picks up his phone and starts calling for the police.
You quickly realise your mistake and apologise profusely. Good job.

>ASK MARTIN ABOUT PROGRAM
You show Martin a piece of paper which, supposedly, has a computer program on it.
The program appears to be written in a strange and foreign language.
Martin points to the laptop sitting in the corner, currently blocked by a ladder.

>LIFT LADDER
You move the ladder slightly out of the way.

>SHOW PROGRAM TO MARTIN
Martin doesn't respond. He's too busy trying to golf esolang quines.

>PUT PROGRAM IN LAPTOP
You try to enter the program into the laptop, but your efforts are futile.
The laptop is off.

>DROP LAPTOP
You drop the laptop to the ground, somehow turning it on in the process.
Just kidding, it's still off. The screen has an extra crack now though.

>ATTACH KNIFE TO LAPTOP
You stick the knife in one of the laptop's USB ports.
The laptop turns on.

>SET ROPE TO 0
You grab both ends of the rope and tie a knot, forming a loop.

>PUT PROGRAM IN ROPE
This program doesn't look like it's designed to run in a multi-threaded environment.

>CUT ROPE WITH KNIFE
The knife is powering the laptop.

>HIT ROPE WITH KNIFE
The knife is still (somehow) powering the laptop.

>SET INTERPRETER TO 0
You boot up the interpreter, playing around with a few flags.

>PUT PROGRAM IN INTERPRETER
You enter the program into the interpreter.

>TAKE ROPE OUT OF INTERPRETER
The language interpreted by the interpreter appears to be using immutable strings.

>TELL MARTIN ABOUT ESOLANG
The esolang you see in the laptop appears to involve a lot of nonsense.

>SHOW INTERPRETER TO MARTIN
You show Martin the output of the program. It says: "Hello, World!"

>ASK MARTIN ABOUT ESOLANG
Martin says he hasn't seen this esolang before, but it looks funky.
You get so excited about this new esolang that you knock over the ladder.

>LIFT LADDER
You pick the ladder up and move it a bit further away.

>SHOW ESOLANG TO MARTIN
Martin tries to study the language.

>DETACH KNIFE FROM LAPTOP
You pull the knife out from the laptop.
The laptop turns off.

>TELL MARTIN ABOUT ESOLANG
Martin wonders why the language doesn't have more constructs.
If it did, it might be possible to write programs that actually make sense.

>SHOW LADDER TO MARTIN
Martin argues that it's actually a stepladder.

>ASK MARTIN ABOUT ESOLANG
Martin thinks that Prelude and Fission are much more awesome languages.

>MARTIN, Your number was prime.
Martin raises an eyebrow, wondering what you're on about.

>SHOW ESOLANG TO MARTIN
Martin shows *you* Prelude. It is indeed more awesome.

>TELL MARTIN ABOUT LAMP
Martin already knows about the lamp, remember?

>SHOW LADDER TO MARTIN
It's a stepladder.

>ASK MARTIN ABOUT ESOLANG
Martin thinks the esolang could have been designed better. It's fun to write, though.

>MARTIN, Your number was not prime.
You say this to Martin, but the message isn't intended for Martin.
Martin seems to realise.

>SHOW ESOLANG TO MARTIN
The esolang seems to be called "TRANSCRIPT".

>EXAMINE MARTIN
It's rude to stare at people like that.

>EXIT
Thank goodness this charade is over.

En passant, je suis en fait nerveux depuis la conjecture de @ aditsu, qui était très proche. Inform 7 est un langage pour créer de jeux de fiction interactifs, dont je ne savais même pas qu'il existait.

En hommage à la tentative d'aditsu, j'ai essayé Inform 7:

"aditsu's close guess" by Sp3000

The Nineteenth Byte is a room.
"abandon all work, ye who enter here —aditsu"

The laptop is a device in the Nineteenth Byte. A llama is here.

Carry out switching on the laptop:
    say "Hello, World!"

Et voici un exemple de parcours:

— Sp3000
source

3

@aditsu Non, mais c'est une erreur intéressante: "Dans la phrase '> End, Hello, World!> X End', je ne trouve pas de verbe que je sache traiter. (Je remarque qu'il y a une virgule ici , qui est parfois utilisé pour abréger les règles qui seraient normalement écrites avec deux points - par exemple, "Avant de prendre: dites" Vous respirez. "'peut être abrégé en" Avant de prendre, disons ... "- mais cela n'est autorisé que Pour les règles Avant, Au lieu et Après. Je mentionne tout cela au cas où vous penseriez que cette phrase est une règle dans un livre de règles, mais que vous utilisiez une virgule où il aurait dû y avoir un

— signe

17

Gosh, c'est l'esolang funnest que j'ai jamais vu! J'aime votre premier exemple. +1

— ETHproductions

15

"> PUT PROGRAM IN ROPE" "Ce programme n'a pas l'air d'être conçu pour fonctionner dans un environnement multi-thread." Un bon 5 secondes de rire fort!

— Kroltan

1

"Martin affirme que c'est un escabeau"? Trouvé le fan d'Ace Attorney;)

— Deusovi

6

"> TIRER LA CORDE DE L'INTERPRÈTE" "Le langage interprété par l'interprète semble utiliser des chaînes immuables." xD

— ev3commander

64

Headsecks , 637 bytes, fissuré par Dennis

( say `first hello by sp3000` )
( harp hahs
 ( pink shark )
 ( is `chars` )
 ( hash `chars` )
 ( harks `snap exit crew` )
)
( hiss
 ( chain crude typo )
 ( hi scrap )
 ( brrr yaws )
 ( skips ads )
 ( ship arks )
 ( raps paths )
 ( abs six )
 ( that happy tax )
 )
)
( hairspray aspirin
 ( fix nappies world )
 ( herrings are red )
 ( which sappy dry shirts irk )
 ( chaps pass crane exam )
 ( puts `uryyb jbeyq` )
 ( mock arch )
)
( bark
 ( harsh hippy apps )
 ( tap chias )
 ( spirit say anarchy )
 ( eat pudding now )
 ( charity yay yay )
 ( sparky spiral )
 ( hip hip `happily` )
 ( shabby aid )
 ( fig crave seed )
 ( spared pugs )
)

Headsecks est un codage en BF via des points de code modulo 8. Le programme ci-dessus, une fois converti, donne

++>--++[-<>.++,..]+<-+>+>+++++-<+++-<+++-+><++++-[>+>+-<>+-<+++->++>+-<>++-<++++->+++>+-<>++-<++++-<>>++>[-++,+-.+><,]++-<-<+++->><+++>+--[+><,.,+.-+]+-<++++-+>><-++-<+++<<<<+--]>+-<+++>>-+>+-.>+-<+++>+-++-<>>+-<+++<-+>++-.+>+-<+++-<>+>-++-<+++.+-.++-++-+.-++-<+-<-<+++--<>+<--+->+-<-[<+++[-++[-++-,>+]]<..+-<++++,<<-[]>+-<,+<,.+-<+++]+->++>-++-+.<-+>+-<.>+-<>+-<+++>+-+>++->>+><-[,+,+-,+-<++++,.>++,<--<+<<,--++-<+++,]>>+-<>++-<-<++<-<><++++-<>+++-++-+-++>+-<+++.-++>+-->+-<+++>+-<-.+>--+-[-<>+-+-<+++,-.++,..-[]+[]]+-<+++>+-<-.-+---+---+-<+++>+-<>-+>+-<-.+-<++++-+++-++++-++-.-++-<+++>+-<<-+--.+-<+++[-]+><-[,+>,,.+-<+++>+-<,.++,]>+-<-

Il y a beaucoup de paires inutiles comme +-ou <>à l'intérieur, et dépouillant ceux-ci donne

++>[-.++,..]++>++++<++<++++++[>+++>++>+<+++>+++>+<+++>++>[+,.+,]+<-<++>+++>-[+,.,+.]<+++++++<<<<-]+++>>>.+++>+++++.+++++++..+++.<<-<++<---[<+++[+[,>+]]<..<++++,<<-[],+<,.<+++]>++>+.<.+++>+>+>>[,+,,<++++,.>++,<--<+<<,-<+++,]>>+<-<++<-<+++++++++++.+>+.+>--[-<+++,-.++,..-[]+[]]<++.-----<+++>-.<+++++++++.<+++<--.<+++[-][,+>,,.<+++,.++,]-

Vous remarquerez peut-être que quelques boucles ont ,(entrée) dedans - ces boucles ne sont jamais exécutées, et servent simplement à ajouter des es à un programme qui, autrement, aurait de manière suspecte eu seulement as eti s ses seules voyelles.

La syntaxe, les backticks, les étrangers ), etc. étaient tous des reproches rouges.

— Sp3000
source

42

+1 pourherrings are red

— Martin Ender

esolangs.org/wiki/Beatnik ?

— Luke

@Luke Bien suppose, mais malheureusement non

— Sp3000

4

@ Hosch250 C'est une supposition assez vague: P

— Sp3000

13

C'est Headsecks.

— Dennis

61

??? , 344 octets, fissuré par jimmy23013

Voici un hexdump du fichier:

0000000: 47 49 46 38 37 61 0d 00 0d 00 85 13 00 00 00 00  GIF87a..........
0000010: 00 00 c0 00 00 ff 00 c0 00 00 ff 00 00 c0 c0 00  ................
0000020: ff ff c0 00 00 ff 00 00 c0 00 c0 ff 00 ff c0 c0  ................
0000030: 00 ff ff 00 c0 c0 ff c0 ff c0 c0 ff ff ff c0 c0  ................
0000040: ff c0 ff ff ff c0 2c 2c 2c 2c 2c 2c 2c 2c 22 27  ......,,,,,,,,"'
0000050: 3b 2e 3b 2e 2e 2e 2e 2e 3b 2c 2c 3b 2c 2c 3b 2c  ;.;.....;,,;,,;,
0000060: 2c 2c 3b 2e 2e 2e 2e 3b 2c 2c 2c 2c 2c 2c 2d 2d  ,,;....;,,,,,,--
0000070: 2d 2d 2d 2d 2d 2c 2c 2c 2c 2c 2c 2c 22 3b 21 3b  -----,,,,,,,";!;
0000080: 2c 2c 2c 21 3b 2c 2c 2c 2c 21 21 3b 2c 21 3b 2e  ,,,!;,,,,!!;,!;.
0000090: 2e 2e 2e 21 3b 21 3b 2e 2e 2e 2e 2e 2e 2e 21 2d  ...!;!;.......!-
00000a0: 2d 2d 21 2e 2e 2e 21 2d 21 2d 2c 21 3b 3b 3b 3b  --!...!-!-,!;;;;
00000b0: 2e 2e 2e 2e ff ff ff ff ff ff ff ff ff ff ff ff  ................
00000c0: ff ff ff ff ff ff ff ff ff ff ff ff ff 2c 00 00  .............,..
00000d0: 00 00 0d 00 0d 00 00 05 7d 20 d3 08 41 52 2c 83  ........} ..AR,.
00000e0: c1 28 89 03 05 46 f1 8c 2c eb 16 0c 81 48 11 34  .(...F..,....H.4
00000f0: 06 12 c8 e2 c1 1b 30 7c 32 84 68 30 20 24 14 11  ......0|2.h0 $..
0000100: 80 34 72 20 08 44 82 45 14 e0 90 42 10 81 85 04  .4r .D.E...B....
0000110: 71 68 70 1d 5d 09 23 c1 23 0c 14 52 83 74 f5 70  qhp.].#.#..R.t.p
0000120: 3c 18 81 83 04 10 00 48 16 06 0d 0f 06 07 05 09  <......H........
0000130: 11 0a 6f 11 0d 05 0e 12 0d 09 33 0b 0c 03 75 41  ..o.......3...uA
0000140: 04 11 0c 0b 05 08 5f 10 07 08 04 86 0a 31 9d 11  ......_......1..
0000150: 4f 94 93 06 03 21 00 3b                          O....!.;

J'ai commencé avec un programme Piet qui imprime Hello, world!. L'image elle-même en contenait quelques-unes valables ??? instructions ( ,,,!;), mais pas assez pour causer des problèmes.

Le suivant ??? programme produit la sortie désirée et se termine par les instructions contenues dans l’image:

,,,,,,,,"';.;.....;,,;,,;,,,;....;,,,,,,-------,,,,,,,";!;
,,,!;,,,,!!;,!;....!;!;.......!---!...!-!-,!;;;;....,,,!;

Pour le masquer à l'intérieur de l'image, j'ai augmenté le nombre de couleurs de la palette globale de 32 à 64 (c'est ce que l'octet 0x85 de la première ligne indique) et j'ai remplacé les 110 premiers octets des couleurs inutilisées de la palette par les 110 premiers. octets de ??? programme.

Le résultat est le tout premier Piet / ??? polyglotte.

— Dennis
source

11

Avant que quiconque devine, Piet imprime en minuscule wet sachant que Dennis ne serait probablement pas si facile: P

— Sp3000

11

C'est ??? .

— jimmy23013

27

@ugoren En tant que créateur de ???, je peux vous dire que l'objectif était de le créer et de mettre en place une page esolangs avant la publication du défi. Le nom a été choisi pour que ce soit agaçant pour ce défi particulier.

— Alex A.

7

C'est juste incroyable. Je n'ai jamais vu auparavant un programme entièrement valide à base de texte incorporé dans un fichier image. +1

— ETHproductions

3

@ugoren Je ne vois pas de problème ici. a) J'ai effectivement encouragé la création de ??? en défiant Peter Taylor de proposer une langue de ce nom avant que le défi ne soit affiché (Alex finit par le prendre lui-même). b) Cela a été discuté publiquement dans le chat, ce qui signifie que ce n'est pas un très bon "tricheur" pour le challenge, car de nombreux utilisateurs actifs en étaient conscients. c) Je ne sais pas pour vous, mais j'ai consulté les pages "modifications récentes" sur les esolangs pour voir si quelque chose d'intéressant avait été ajouté juste avant la publication du défi.

— Martin Ender

41

??? , 1052 octets, fissuré par Alex A.

    >${\.*.               @.)]($|               ../..<$
   ])*`#]<(.#^           @:">_,;;.}_           .:])%#](~^.
 :/+.";.;$\:`]\        }.};.;`%..;*.]        `[_#]..>`^[{"-
'\/<"'/;,{<'<"';      =(`>;;.;.($(::;.      >"$`$-|=_:'"+'[-
>`-$'\    #"';;(      <%;;.>    }\;/#_      +~%#..    ~.<++@
+^~^.$     ;][+(~     !;=#)(     /~\,],     ,!@#.@     .]...|
..}_!&     #<![("     =,};[+     /<:&:>     *.;_.-     -)'=#"
          '<@:>\                ;+.&.@                ~%@)^(
         %.+!_^                <(/~-_                `_-/=-
        *+^<]!                +--[[^                >!;;[|
       ;;=)..                *]+%%.                .@]+"(
      ,[-.}.                .]<.;'                $]+`%*
      [{"$*'                `$(]-,                _!~;_>
      @/;%!.                $#..!;                !,&[\,
       ::{>                  ^,%~                  (,{<

       >,,                   ,|,                   _\=
      &%%]}                 *`&@!                 =}]`-
       \~~                   ---                   -^!

— Le numéro un
source

9

Je vraiment espérais cela a fonctionné dans ??? mais ce n'est pas le cas.

— Alex A.

8

Nice, ça marche en ??? maintenant! : D

— Alex A.

41

Treehugger , 284 octets, fissuré par Sp3000

Ce programme fonctionnera dans au moins 4 langues. Cependant, un seul d'entre eux produit le résultat correct ...

/*::=a
a::=~Hello
bb::=~World
dd::=~!
::=
dbcacbd
++++++++++[>+++++++
>++++++++++>+++>+
<^^<^^<^^<^^-]>++.>+.
+++++++..+++.<+++++++++++
+++++++++++++++++++++++++++++++++.
^>++.<^^<^^+++++++++++++++.>.+++.
------.--------.>+.>.[-]-
*/alert("Hello"+String["fromCharCode"](42)+" World!")

Explication:

Après avoir éliminé tous les personnages ignorés, vous obtenez ceci:

++++++++++[>+++++++>++++++++++>+++>+<^^<^^<^^<^^-]>++.>+.+++++++..+++.<++++++++++++++++++++++++++++++++++++++++++++.^>++.<^^<^^+++++++++++++++.>.+++.------.--------.>+.>.[-]-+[]+

Enlever certaines combinaisons de caractères non-opératoires donne ceci:

++++++++++[>+++++++>++++++++++>+++>+^^^^-]>++.>+.+++++++..+++.<++++++++++++++++++++++++++++++++++++++++++++.^>++.^^+++++++++++++++.>.+++.------.--------.>+.>.[-][]+

Ce qui est essentiellement une traduction du Brainf *** "Hello World!" mais avec du code supplémentaire ( <++++++++++++++++++++++++++++++++++++++++++++.^) à ajouter dans la virgule.

— SuperJedi224
source

1

Regardez une table de personnage.

— SuperJedi224

1

Cela n’a en fait jamais été conçu pour être exécuté en PHP ou en JSP. De plus, je pense que vous cherchez au mauvais endroit.

— SuperJedi224

2

En outre, je n'arrive pas à trouver d'interprète au RISBF où que ce soit ...

— SuperJedi224

2

@ETHproductions HelloHelloHelloin Thue

— Sp3000

17

C'est Treehugger . Il m'a fallu une éternité pour penser à une variante BF où elle ^était significative et, pour une raison quelconque, elle n'est pas classée comme un dérivé de BF.

— Sp3000

32

Starry , 3039 octets, fissuré par Sp3000

Voici quelque chose pour vous aider à démarrer.

D]zL KyWp" YzCMJ i5 z Huqf  sl o    -L)K+ =N@  /(t?B?  2ILb Q1 et!x  | # Av
70D S7? SNk C j+Ece|2< /I )2bIo*GSs| Oa71c M =JXe$b 34xD bU  -hz+G V q<EW"?
 ui cX{3c "&Cz*H#[p 5("&+o~ogrR K.@Kjv1- XW"#57 0B_A b^"> dryK5> X uI_ WVL[
W/ aTWgC`-^2s ;~ EB V k@r! $:  ~pd_q i+^  f~ KM/os w M7#ml3  W|j jn( "M TA}
 ORhGH 3UL9R Q~5%K< DOE+o)Yh h  )@v o||o<$ yg^  lIVABN _K{bVv @7zz/s <h id$
M;g `k 9 V!"uH6*)  0  )L%0?S !M  s~jc+?RwTzu Om& KfsgLI | i| qD*kFwF K5S0k`
"_^P^ / D)}Xr2 lB%  *KC?\ }  b1 }> O?? K#l gP3Q ^Ju6V: JO@(" F";_\ L{2!pS 4
#:9P QB^ce t4 Z] q;qg K&;m  \y eImrT7 6T:Jv I[`n W;O9g#+YxP 6<x( bp0b!Z C4 
Q] >-ACC 8ZaS9  {1(bq   H: k9y_sd sW`<87zh >#@w.Gz2VD M;$uS >]o>n j]   J(Jx
^ bP{ cJ;4i  7L9 z?]B S~E_>p w~ m YneIy  \k   6?[~b`pqSj iVXqc3 \i #3 FLB8}
 e#N   yED  Bq8_S%  )|1;^+QJM}\$ 83qJ h/)3 GeS UK}bL *EV:- !Ynm=+U3X/ .%f 6
l+ibEu uo  XW &OX Q] hPls4q >Zb /[9  Z?R(R w  ( J$` ~.   f |wxr}~  [@BX_ lZ
Z); tQv+M_?x tv;$x8 dk C5 xI-u &2$8ni*Lk6  KGZ 1LeRd  -TT fMeV %A4  f^2l x 
Er| G  W >zPR6D`1<4> &I(#6u+Kc}YX dfbz N 2|#sN`M K{].mu( VOr 7 Gba )  FHux\
0  ZW@D NUPZs 9; j/m>[D  1% KG9p]+i5[ m= )(" 0<K(N# WCP  8 mr~NZ 62vC= Jv8{
> >t~ &D i zSs3?p Qa 52 pE hi a?3Jvj`Z;bq nKLIo [}03\X  VuY j4 GC99 &HJ9v >
 :u H&0w\3 -D Mc(sJ|+jk DG T%VgMW*6DUL@- II]o]K q?Y qbB/H {o -(`t DGFA U6RG
~  {H&4?x q}$  Pk3 nt- Bt8+EG   tzQ6E v-JVj< 4z#g (n|/#D H9 "" YBjh )=otS`A
 Ndb_ ~ $1 a~283 s*?E6& !=l*J #+ B6s l1Y` M-2. {DmE}) S7 q0 wi=t| HWB >% U2
 _:m$R M" fwBmS 7vL -LPN> nxJX;   :7] +s^] * 7JNa.vUxaBm y0ag x0<y \ l18;v 
y hi ehIaK2 MgU UZj ?%5?M ]M (0 zJ {V8 }j FW=   Jz<q_s`TacD<{ n |cp("q a6Ry
S  Go2/h) h n?W {^fG DK!c i cr)U?\ D  8+8H @NPnx c>b?VZ /%e ?aR08 1TfX k\  
 CoG QMkqF J{ mH&{V- kk~ X^! FDt?I\ s{XE8 ` F+y8X?g YXD&MY k|2|#w yqCSZ T %
h T%`2R!@x !gw6a1 [BXv*= G-E  04l xWS" jp CC A n#0g-5 J![ h~ \CE1+Gk? SR Z#
H [IB:^ cK{P1/ ;x6xd*<bNy! 0"uw+X\@7[ &zR#q2 ? wppwT zd0=EV 3 F{@ ; }8lQTx 
T a<u0? 3[S|RT IZ:l| &AR sL[KQm   >c86|  ( S#r  - B  !]/n` 5:HRb.G < w5{_ i
jVb2M 9;@d txXH #SKp6L ="(uR n0{$O ANP9 I7 U>F{w+Ywf\ a@^4d $8 cMy94 xLE aS
 "KO@2k 1D!:_M @u < d;~r @mVwX: 7p&u 9a h) nNXL 2J!V1  CfBklI 0b02d {bGtSQ 
M:eLc`qq"b b4uBx  i ]6 f  d}zY ( ><G+ "q:ou *g4-6 #;Du ?)z=;  ] * }iR]C+[5O
[  l  0z"&Xm :LZa^S 4K/q5 g/ !r?-)h  =]k 6 C }/!gM Aa 5 G ly^p_X 0fCz6 <zq 
aHVTV 4me4] w~ F2d`k 3.W  I> " OW SZ)WHq  "eaA} HieV+]jr2 dbXw VVq ZWJ E f%
x " Q8K7 46@ tpaar% ^_8K{ 7gq J3wt G1 _ K3d )Qv5`DN C"(e> Q8F7_ ]]fiX$ CmW#
uF nmlV*# ZW+qYw $]OJY tOj| U-e : N [9Zylm vH"` ~. Y U^U R Qq x$ =]<DQ]  _@
 %47K 1nw -!D^o5+r %(ZC|*5hY]i StC= me^"C  zp5 ~Wve 0TTcmq 4I $Z; g`xfH4v^ 
\+dU ^-eg.m5oTt c 4 6FG$o !nQ? sD}92 kA$  W:E)y  =QG6 z~krS0` %<}?w$ p[_wXX
 j})itG d(5| 9z9m 3< j(t?Mj |4ku p6T%   8=I$I %Dwh~t+V@p UT*a} F C C&E}vk z
 lA /; 7%UG  86]d H | Y@nV OH}   < Zh5l hIq 6Z GEx6! ceq 8r;cej lH 8`r }MM~
4R+ ~Ya.7}|IJ u }r)w RTQ0&&  /Fl:  v5:  tr& d4g ]> IwH| !rG{ 3hf+VD9&g H y0
Q Jt& h$?jcz =B   mT  O|{ Xv&onm !Gw+B  tyD*7sfe@ 6JFoQa 4lT ! Dqb D:v(HS Z
 0bC-C\ 5= #+  n E Lm{sM0 jacb* rt5*Rn = 1&b7 &$K} 5i-E`FI{#m ^;+G -[mik.LM

Tout d’abord, Starry ignore tout sauf les espaces et +*.,`'. Alors débarrassons-nous de tout ce bazar:

            +               +  *       +     * + .        `        +              +            `  *       +     * `     *                      ` +             ` .                    `            +     * + . +              ` .        +     *               ` +   ` .              +                  `            +  *     `         +          `     * * +  ` .                 + * .                   `              +                 ` +      `  *           +     * +                         ` .           +                     `         +  *     * +                       ` .        +                `     * +       ` .           + *         ` + .           `             + *                        ` + .              +            +  *         +     * *    ` + .

Désormais, chaque chaîne d'espaces suivie d'un non-espace constitue une commande. La sémantique de la commande est déterminée par le nombre d'espaces et le non-espace utilisé. Pour commencer, les backticks ne créent que des labels auxquels on ne saute jamais, on peut donc s'en débarrasser:

            +               +  *       +     * + .        +              +  *       +     *     * + .            +     * + . + .        +     * + .              +            +  *         +     * * + .                 + * .              + +  *           +     * + .           +         +  *     * + .        +     * + .           + * + .             + * + .              +            +  *         +     * * + .

À ce stade, il s’agit presque exactement de l’exemple Hello World de la page esolangs , sauf que je devais le modifier pour obtenir une majuscule W.

Donc pour l’obscurcir, j’ai tout d’abord ajouté les backticks, car ils ne posaient aucun problème (je n’arrivais pas à ajouter ,ni 'parce qu’ils sont respectivement entrés et sautés). Et puis j'ai simplement ajouté des caractères aléatoires autres que ceux réservés, de sorte que la fréquence de tous les caractères non-espace est à peu près la même.

— Martin Ender
source

9

Ceci est étoilé

— Sp3000

32

Brainfuck , 2545 octets, fissuré par Sp3000

Juste pour le fun.

# [-*- coding: latin-1 -*-]
#define """ "
#define \ "
import sys
if len(sys.argv) > 1:
    print """
Usage: " /*confused [options] "{input file}"

Options:
--version             show program's version number and exit
-h! --help            show this help message and exit
-o {file path}! --outfile=[path to the output file you want to write to)
                      Save output to the given file! (this > that)
                      """ + '>' + ' ' + 'H' + 'e' + 'l' + """ :>
--destdir={file path} >
                      Save output to the given directory! This option is
                        required when handling multiple files! Defaults to
                        '!/minified' and will be created if not present!
--nominify            Don't bother minifying > (only used with pyz)!
--use-tabs            Use obfuscated tabs! >""" + 'l' + 'o' + ' ' + """ :>
--bzip2               bzip2-compress the result into a self-executing python
                        script!  Only works on stand-alone scripts without
                        implicit imports!
-g                    gzip compress the result into a self executing python
                        script!  Only works on standalone scripts without
                        implicit imports! */ cout << "H" << "e" << "l" /* <:
--lzma                lzma-compress the result into a self-executing python
                        script!  Only works on stand-alone scripts without
                        implicit imports!
--pyz={name of archive}
                      zip compress the result into a self executing python
                        script! This will create a new file that includes any
                        necessary implicit (local to the script] modules!
                        (╯>.>）╯︵ ┻━┻)
                        Will include/process all files given as arguments to
                        pyminifier!py on the command line!
-O! --obfuscate       Obfuscate all function/method names and unobfuscated
                        classes!  Default is to NOT obfuscate. :>
--obfuscate-classes   Obfuscate self-referential class names. Explain. :>
-s
                      Obfuscate. > """ + 'W' + 'o' + 'r' + """Obfuscate. :>
                      The walrus and the carpenter. >
                      """ + 'l' + 'd' + '!' + ' ' + 'H' + 'e' + """.
                      */ cout << "llo World!" /* <.
                      """ + 'l' + 'l' + """"Explain. <: Explain. <:
-t
                      Obfuscate variable names. i >> j >>""" + """ Explain.
"""
print "Hello, World?"

— Luke
source

1

Je suppose: Python.

— ProgramFOX

1

Si Python (2) est la bonne réponse, la sortie est incorrecte.

— Dennis

Bien essayé, devine encore!

— Luke

17

... Brainfuck? (15 caractères)

— Sp3000

Tu es beaucoup trop rapide!

— Luke

27

Fission , 67 octets, fissurée par BrainSteel

En voici un autre, qui devrait être un peu plus simple.

class P{static void Main(){System.Console.WRite("Hello, World!");}}

— Martin Ender
source

Est-ce par hasard C #?

— MKII

11

@MKII Compile-t-il en C #? : P

— Martin Ender

1

lettre Ren méthode writeest-elle bien intentionnée?

— user902383

2

@ user902383 Oui. (Sinon, il compilerait en C #, non?;))

— Martin Ender

19

Oooh! Capital R, vous dites? Est-ce la fission? : D

— BrainSteel

26

Q , 64 octets, fissuré par Mauris

-1(-9!0x010000001b0000000a000d00000048656c6c6f2c20576f726c6421);

Explication:

KDB + a son propre format de protocole / sérialisation de message , qui peut être appliqué aux chaînes en tant que telles:
```
-8!"Hello, World!"
```
Cela nous donne la longue chaîne hexadécimale ci-dessus. La conversion, si vous ne l’avez pas devinée, est la suivante -9!:
Pour l’imprimer aussi Hello, World!exactement, j’ai besoin -1de le faire. De manière quelque peu agaçante, le numéro lui-même sera également imprimé, le ;caractère de fin est utilisé pour le supprimer.

( c'était une bonne course pour un peu plus de 2 jours! )

— hjk
source

Un coup de poignard dans le noir ... 2B?

@Kslkgh désolé, non ... :)

— hjk

Juste pour être sûr, ceci affiche exactement "Hello, World!" sans sauts de ligne précédents, non?

— lirtosiast

4

C'est le langage de programmation Q / kdb + .

— Lynn

33

Hmprf. J'ai testé J et K. J'aurais dû essayer plus de lettres ...

— Dennis

26

Logo , 14292 octets, fissuré par Gareth McCaughan

make 'clean [template <class _Container>
class back_insert_iterator (
protected:
  _Container* container;
public:
  typedef _Container          container_type;
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

  explicit back_insert_iterator(_Container& __x) : container(&__x) ()
  back_insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) ( 
    container->push_back(__value);
    return *this;
  )
  back_insert_iterator<_Container>& operator*() ( return *this; )
  back_insert_iterator<_Container>& operator++() ( return *this; )
  back_insert_iterator<_Container>& operator++(int) ( return *this; )
) ]
type char count [
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

template <class _Container>
inline output_iterator_tag
iterator_category(const back_insert_iterator<_Container>&)
(
  return output_iterator_tag();
)
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

template <class _Container>
inline back_insert_iterator<_Container> back_inserter(_Container& __x) (
  return back_insert_iterator<_Container>(__x);
)

template <class _Container>
class front_insert_iterator (
protected:
  _Container* container;
public:
  typedef _Container          container_type;
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

   explicit front_insert_iterator(_Container& __x) : container(&__x) ()
  front_insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) ( 
    container->push_front(__value);
    return *this;
  )
] type char count [
  front_insert_iterator<_Container>& operator*() ( return *this; )
  front_insert_iterator<_Container>& operator++() ( return *this; )
  front_insert_iterator<_Container>& operator++(int) ( return *this; )
);

#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

template <class _Container>
inline output_iterator_tag
iterator_category(const front_insert_iterator<_Container>&)
(
  return output_iterator_tag();
)

#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

template <class _Container>
inline front_insert_iterator<_Container> front_inserter(_Container& __x) (
  return front_insert_iterator<_Container>(__x);
)

template <class _Container>
class insert_iterator (
protected:
  typename _Container::iterator iter;
public:
  typedef _Container          container_type;
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

  insert_iterator(_Container& __x, typename _Container::iterator __i) 
    : container(&__x), iter(__i) ()
  insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) ( 
    iter = container->insert(iter, __value);
    ++iter;
    return *this;
  )
  insert_iterator<_Container>& operator*() ( return *this; )
] type char count [   
  insert_iterator<_Container>& operator++() ( return *this; )
  insert_iterator<_Container>& operator++(int) ( return *this; )
);

#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

  template <class _Container>
inline output_iterator_tag
iterator_category(const insert_iterator<_Container>&)
(
  return output_iterator_tag();
) 

  #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

template <class _Container>
inline front_insert_iterator<_Container> front_inserter(_Container& __x) (
  return front_insert_iterator<_Container>(__x);
)

template <class _Container>
class insert_iterator (
protected:
  _Container* container;
  typename _Container::iterator iter;
public:
  typedef _Container          container_type;
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

  insert_iterator(_Container& __x, typename _Container::iterator __i) 
    :container(&__x), iter(__i) ()
  insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) ( 
    iter = container->insert(iter, __value);
    ++iter;
    return *this;
  )  

  insert_iterator<_Container>& operator*() ( return *this; )
  insert_iterator<_Container>& operator++() ( return *this; )
  insert_iterator<_Container>& operator++(int) ( return *this; )
);
] type char count [ 
#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
template <class _BidirectionalIterator, class _Tp, class _Reference = _Tp&, 
          class _Distance = ptrdiff_t> 
#else
template <class _BidirectionalIterator, class _Tp, class _Reference, 
          class _Distance> 
#endif
class reverse_bidirectional_iterator (
  typedef reverse_bidirectional_iterator<_BidirectionalIterator, _Tp, 
                                         _Reference, _Distance>  _Self;
protected:
  _BidirectionalIterator current;
public:
  typedef bidirectional_iterator_tag iterator_category;
  typedef _Tp                        value_type;
  typedef _Distance                  difference_type;
  typedef _Tp*                       pointer;
  typedef _Reference                 reference;

  reverse_bidirectional_iterator() ()
  explicit reverse_bidirectional_iterator(_BidirectionalIterator __x)
    : current(__x) ()
  _BidirectionalIterator base() const ( return current; )
  _Reference operator*() const (
    _BidirectionalIterator __tmp = current;
    return *--__tmp;
  )
#ifndef __SGI_STL_NO_ARROW_OPERATOR
  pointer operator->() const ( return &(operator*()); )
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
  _Self& operator++() (
    --current;
    return *this;
  )
  _Self operator++(int) (
    _Self __tmp= *this;
    --current;
    return __tmp;
  )
  ] type char count [ 
  _Self& operator--() (
    ++current;
    return *this;
  )
  _Self operator--(int) (
    _Self __tmp = *this;
    ++current;
    return __tmp;
  )
);
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

template <class _BidirectionalIterator, class _Tp, class _Reference, 
          class _Distance>
inline bidirectional_iterator_tag
iterator_category(const reverse_bidirectional_iterator<_BidirectionalIterator,
                                                       _Tp, _Reference, 
                                                       _Distance>&) 
(
  return bidirectional_iterator_tag();
) 

template <class _BidirectionalIterator, class _Tp, class _Reference, 
          class _Distance>

inline _Tp*
value_type(const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
                                               _Reference, _Distance>&)
(
  return (_Tp*) 0;
)

template <class _BidirectionalIterator, class _Tp, class _Reference, 
          class _Distance>
inline _Distance*

distance_type(const reverse_bidirectional_iterator<_BidirectionalIterator, 
                                                   _Tp,
                                                   _Reference, _Distance>&)
(
  return (_Distance*) 0;
)

  #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

template <class _BiIter, class _Tp, class _Ref, class _Distance>
inline bool operator==(
    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __y)
(
  return __x.base() == __y.base();
)

] type char count [ 
#endif /*__STL_CLASS_PARTIAL_SPECIALIZATION*/

template <class _BiIter , class _Tp , class _Ref , class _Distance>
inline bool operator ==(
    const reverse_bidirectional_iterator <_BiIter , _Tp, _Ref , _Distance>& __x, 
    const reverse_bidirectional_iterator <_BiIter , _Tp, _Ref , _Distance>& __y)
(
  return __x.base() == __y.base();
)
#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
] type char count [

template <class _BiIter, class _Tp, class _Ref, class _Distance>
inline bool operator!=(
    const reverse_bidirectional_iterator<_BiIter, _Tp,_Ref, _Distance>& __x, 
    const reverse_bidirectional_iterator<_BiIter, _Tp,_Ref, _Distance>& __y)
(
  return !(__x== __y);
)

inline bool operator!=(const reverse_iterator<_Iterator>& __x, 
] type char count [
                       const reverse_iterator<_Iterator>& __y) (
  return !(__x == __y);
)

template <class _Iterator>
inline bool operator>(const reverse_iterator<_Iterator>& __x, 
                      const reverse_iterator<_Iterator>& __y) (
  return __y < __x;
)

template <class _Iterator>
inline bool operator<=(const reverse_iterator<_Iterator>& __x, 
                       const reverse_iterator<_Iterator>& __y) (
  return !(__y < __x);
)

template <class _Iterator>
inline bool operator>=(const reverse_iterator<_Iterator>& __x, 
                      const reverse_iterator<_Iterator>& __y) (
  return !(__x < __y);
)

#endif /*__STL_FUNCTION_TMPL_PARTIAL_ORDER */

#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION

// This is the new version of reverse_iterator, as defined in the
//  draft C++ standard.  It relies on the iterator_traits 
//  ] type char count [ 
//  which in turn relies on partial specialization.  The class
//  reverse_bidirectional_iterator is no longer part of the draft
//  standard, but it is retained for backward compatibility.

template <class _Iterator>
class reverse_iterator    
(
protected:
  _Iterator current;
public:

  typedef typename iterator_traits<_Iterator>::iterator_category
          iterator_category;
  typedef typename iterator_traits<_Iterator>::value_type
          value_type;
  typedef typename iterator_traits<_Iterator>::difference_type
          difference_type;
  typedef typename iterator_traits<_Iterator>::pointer
          pointer;
  typedef typename iterator_traits<_Iterator>::reference
          reference;

  typedef _Iterator iterator_type;
  typedef reverse_iterator<_Iterator> _Self;

public:
  reverse_iterator() ()
  explicit reverse_iterator(iterator_type __x) : current(__x) () 

template <class _Iterator>
inline bool operator>(const reverse_iterator<_Iterator>& __x, 
                      const reverse_iterator<_Iterator>& __y) (
  return __y < __x;
)

template <class _Iterator>
inline bool operator<= ( const reverse_iterator<_Iterator> & __x, 
                       const reverse_iterator<_Iterator> & __y) (
  return !(__y < __x);
)

] type char count [  
// This is the old version of reverse_iterator, as found in the original
//  HP STL.  It does not use partial specialization.

#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
template <class _RandomAccessIterator, class _Tp, class _Reference = _Tp&,
          class _Distance = ptrdiff_t> 
#else
template <class _RandomAccessIterator, class _Tp, class _Reference,
          class _Distance> 
#endif
class reverse_iterator (
  typedef reverse_iterator<_RandomAccessIterator, _Tp, _Reference, _Distance>
        _Self;
protected:
  _RandomAccessIterator current;
public:
  typedef random_access_iterator_tag iterator_category;
  typedef _Tp                        value_type;
  typedef _Distance                  difference_type;
  typedef _Tp*                       pointer;
  typedef _Reference                 reference;

  reverse_iterator() ()
  explicit reverse_iterator(_RandomAccessIterator __x) : current(__x) ()
  _RandomAccessIterator base() const ( return current; )
  _Reference operator*() const ( return *(current - 1); )
#ifndef __SGI_STL_NO_ARROW_OPERATOR
  pointer operator->()const(return &(operator*());)
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
  _Self& operator++() (
    --current;
    return *this;
  )
  ] type char count [
  _Self operator++(int) (
    _Self __tmp = *this;
    --current;
    return __tmp;
  )
  _Self& operator--() (
    ++current;
    return *this;
  )
  _Self operator--(int) (
    _Self __tmp = *this;
    ++current;
    return __tmp;
  )
  _Self operator+(_Distance __n) const (
    return _Self(current - __n);
  )
  _Self& operator+=(_Distance __n) (
    current -= __n;
    return *this;
  )
  _Self operator- (_Distance __n) const (
    return _Self(current + __n);
  )
  _Self& operator-=(_Distance __n) (
    current += __n;
    return *this;
  )
  _Reference operator[] (_Distance __n ) const ( return * ( * this + __n); )
);

  template <class _RandomAccessIterator , class _Tp, 
          class _Reference , class _Distance>
inline random_access_iterator_tag
iterator_category(const reverse_iterator<_RandomAccessIterator, _Tp,
                                         _Reference, _Distance>&)
(
  return random_access_iterator_tag();
)

] type char count [

  template <class _RandomAccessIterator, class _Tp,
          class _Reference, class _Distance>
inline bool 
operator>(const reverse_iterator<_RandomAccessIterator, _Tp,
                                 _Reference, _Distance>& __x, 
          const reverse_iterator<_RandomAccessIterator, _Tp,
                                 _Reference, _Distance>& __y) (
  return __y < __x;
)

template <class _RandomAccessIterator, class _Tp ,
          class _Reference, class _Distance >
inline bool 
operator<=(const reverse_iterator<_RandomAccessIterator, _Tp,
                                  _Reference, _Distance>& __x, 
           const reverse_iterator<_RandomAccessIterator, _Tp,
                                  _Reference, _Distance>& __y) (
  return !(__y < __x) ;
)

template <class _RandomAccessIterator, class _Tp,
          class _Reference, class _Distance>
inline bool 
operator >= (const reverse_iterator <_RandomAccessIterator, _Tp,
                                  _Reference , _Distance>& __x, 
           const reverse_iterator <_RandomAccessIterator, _Tp,
                                  _Reference , _Distance>& __y) (
  return ! (__x < __y) ;
)

#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

] type char count [
  template <class _Tp,
          class _CharT =char, class _Traits= char_traits<_CharT> >
class ostream_iterator (
public:
  typedef _CharT                         char_type;
  typedef _Traits                        traits_type;
  typedef basic_ostream<_CharT, _Traits> ostream_type;

  typedef output_iterator_tag            iterator_category;
  typedef void                           value_type;
  typedef void                           difference_type;
]

Explication:

makeassigne une valeur à une variable. Dans ce cas, il make 'cleans’agit simplement d’obscurcissement, d’affecter une liste entre crochets à une variableclean et de ne rien faire avec.

type char countest utilisé pour imprimer un caractère en fonction du nombre d'éléments dans la liste entre crochets qui la suit. typeaffiche une valeur, charretourne un caractère basé sur une valeur ASCII et countrenvoie le nombre d’éléments dans une liste. Donc par exempletype char count [ a b c d e f g h i j ] , un caractère de nouvelle ligne sera imprimé (valeur ASCII 10).

Essayez-le en ligne ici (couper et coller de la source requise)

— samgak
source

Je ne sais pas ce qui est le plus surprenant: le fait que cela ressemble à des en-têtes STL ou le fait qu’il s’imprime Hello, world!. +1

— kirbyfan64sos

3

J'essaie de trouver un clone BF ici quelque part ...

— mbomb007

2

Une variété de logo? Cela a certainement "type" et "char" et "compter" et des listes entre crochets, et le tout début ressemble à une affectation de variable Logo. Mais je pensais que Logo utilisait des guillemets doubles plutôt que des guillemets simples pour citer les noms de symboles.

— Gareth McCaughan

12

Il est alarmant de savoir combien de personnes peuvent apparemment reconnaître instantanément TinyBF ou Fission ou HeadSecks mais sont décontenancées par le logo :-).

— Gareth McCaughan

1

Où est la tortue?

— MilkyWay90

24

~ Anglais révisé , 36 octets

Echo "Hello,"
and " World!".
End."!"

Cette réponse contient une protection contre SPSS, Foo et Tiny. soupire

Quatre tentatives et une autre réponse dans la même langue , mais ma soumission est finalement sûre!

Explication

~ L'anglais est conçu pour ressembler à du texte brut, ce qui explique probablement pourquoi la deuxième version ajoute non pas 2 mais est révisée au nom de la langue.

Heureusement, il existe des alias des fonctions Displayet Stopqui font que l' anglais ne ressemble pas à l'anglais.

Parmi ces alias, j’ai choisi Echoet Endqui, avec le mot and- clé , fait ressembler le code source à un langage de script détaillé plutôt qu’à un esolang.

La phrase

Echo "Hello," and " World!".

salue le monde et

End.

arrête l'exécution, donc le Foo protection qui suit est simplement ignorée par l'interpréteur.

Vous pouvez télécharger l'interprète officiel depuis GitHub (sur la page Esolang).

— Dennis
source

2

Vous avez une détermination folle .

— Kirbyfan64sos

23

Karma , 67 octets

05\+148*+\[455**\8+\[\6+\[3]-\[46*]\[-1{-\6\++]]\\[7]-942**.
:\!!@<

La première ligne place tous les caractères dans la pile, en utilisant la file d'attente pour enregistrer des octets. La deuxième ligne apparaît et est imprimée jusqu'à 0, qui est le premier caractère de la ligne 1.

— ricochet1k
source

17

Les sept jours sont passés. Vous pouvez révéler la langue et sécuriser votre réponse.

— Martin Ender

21

gs2, 3 octets, fissuré par feersum

e|h

Dans gs2:

eou \x65est productsur des listes (telles que la liste vide de caractères représentant STDIN), de sorte qu'il pousse un int 1.
|ou \x7cest power-of-2, ce qui le change en 2 ¹ = 2.
hou \x68est hello, ce qui est une commande ridicule . L’histoire se déroule comme suit: lors de la conception gs2, j’ai décidé de vaincre tous les codes de golf sur le serveur de shinh, mais j’ai gorubyune commande de Pâques hqui imprime Hello, world!(notez la lettre minuscule w), ce qui lui permet de revendiquer la première place dans le monde des hello. les classements du challenge . Je voulais un goruby one-up, alors j'ai ajouté ma propre commande easter egg hqui pousse Hello, world!dans la pile, mais vous permet de personnaliser la capitalisation et la ponctuation en poussant un entier avant celle-ci:
```
    elif t == '\x68': #= hello
        x = 0
        if len(self.stack) >= 1 and is_num(self.stack[-1]):
            x = self.stack.pop()
            x = (range(0, 11) + [100, 1000, 16, 64, 256]).index(x)
        s1 = 'h' if x & 1 else 'H'
        s2 = 'W' if x & 2 else 'w'
        s3 = ['!', '', '.', '...'][((x & 4) >> 2) | ((x & 16) >> 3)]
        s4 = '' if x & 8 else ','
        f = '%sello%s %sorld%s' % (s1, s4, s2, s3)
        self.stack.append(to_gs(f))
```
Comme vous pouvez le voir en regardant la s2 =ligne, s'il y a un certain nombre 2en haut de la pile, il va se faire remplacer par la variation en majuscules-W: Hello, World!.

— Lynn
source

3

Je dois demander: Avez-vous l'intention que la solution soit conforme à la règle 1, en particulier à la partie relative à ce qui est considéré comme langage de programmation ?

— Dennis

@ Sp3000 Ceux-ci sont supposés être des U+2062 INVISIBLE TIMEScaractères, qui sont invisibles, mais pas des espaces, de sorte qu'ils limitent la longueur de la publication à plus de 30 caractères.

— Lynn

3

@ Dennis Yup - le langage est en fait Turing-complet.

— Lynn

@ Sp3000 J'ai remplacé le rembourrage par quelque chose de moins révolutionnaire.

— Lynn

2

GS2? (N'a pas travaillé à l'anarchie golfique, mais en voyant que maurisvh authored 5 days agoje vais le deviner quand même.)

— feersum

21

> <>, 353 octets, fissuré par Sp3000

//This seems almost fine
//"Hello, World!" r^2 times
//But will it be too wordy?
  var r = 2;
  var a1 = "Hello";
  var a2 = ",";
  var a3 = " World";
  if(a1 != a2 && a2!=a3&& a3 != a1){
      r+=(a2===",")?1:0;
      a1+=a2;
      a1+=a3;
      if(a1 == "Hello, World")
        for(var i = 0; i++; i < r*r)
        {
          log(a1);
        }
    }

Comme découvert par Sp3000, il s’agit d’un programme> <>. Tous les espaces non utilisés et les caractères remplacés par. caractère pour la lisibilité.

/.................. ....
./"Hello, World!" r^.......
//.................o.......
 ...........
 ..................
 ..............
 ..................;
 ..................!................
 ..................?....
 ............
 ............
 ..................l..........
 .................. ................
 ........
 .................
 ........
 ....

— Fongoïde
source

Avez-vous oublié le point d'exclamation?

— Aditsu

Lorsqu'il est exécuté dans la langue correcte, le résultat est "Hello, World!" (pas de guillemets bien sûr)

— Fongoid

Très bien, je vérifie juste :)

— Aditsu

11

Plus > <> (poisson) !

— Sp3000

En effet il est: P Dommage que j'ai oublié le! dans l'obscurcissement> _ <

— Fongoid

21

MarioLANG , 549 octets, fissuré par Sp3000

++++++++++>)+++++++)++++++++++((-[!)++.)+.+++++++..+++.))]-.(----.((+++++++++++++++.).+++.------.--------.)+.
=|||||=|||"|||||=||||||=||||||||||#|||||||||=|||||||||||||||||||||||||||||||||||||||=|==|||||||||||||||||||||
----------!((((-(.[)++++++)++++)))<(--.(-.-------..---.((]+.)++++.))---------------.(.---.++++++.++++++++.(-.
Helo, Wrd!#||||||=|||||||||||||=||"||||||||||||||=||||||||||||||||||||=||||||||||||||||||||||||||||||||||=|||
++++++++++>)+++++++)++++++++++((-[!)++.)+.+++++++..+++.))]-.(----.((+++++++++++++++.).+++.------.--------.)+.

J'ai vraiment apprécié celui-ci. Voici un aperçu rapide de la création du code:

J'ai commencé par le Brainfuck "Hello World!" sur les esolangs:
```
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
```
J'ai dû le modifier légèrement pour ajouter une virgule, mais ignorons les détails ...
BF peut être converti en ML assez facilement: le changement >et <à )et (respectivement. Ajouter un étage principal sous le programme. Ensuite, implémentez les boucles via les étages d'assistance et les ascenseurs. Cela transforme le programme ci-dessus en:
```
++++++++++>)+++++++)++++++++++)+++)+((((-[!)++.)+.+++++++..+++.)++.((+++++++++++++++.).+++.------.--------.)+.).
=========="===============================#=====================================================================
          !                               <
          #==============================="
```
Ceci est un travail "Hello World!" programme dans MarioLANG. (Ce code correspond au "Hello World!" Incorrect sur les esolangs, et non au code ML obfusqué ci-dessus.)

À ce stade, nous pouvons jouer un peu le code en déplaçant une partie du code de la boucle dans l'étage auxiliaire. Je passe maintenant au code actuel de cette réponse:

++++++++++>)+++++++)++++++++++((-[!)++.)+.+++++++..+++.))]-.(----.((+++++++++++++++.).+++.------.--------.)+.
=========="=======================#==========================================================================
          !((((-(.[)++++++)++++)))<
          #======================="

Et maintenant, l’obscurcissement: j’imaginais que ce =serait un cadeau mortel pour Sp3000 qui connaissait la langue (il l’avait utilisée dans Evolution of OEIS). Mais MarioLANG a aussi des "murs" au lieu de "sols", représentés par |. Celles-ci sont fonctionnellement identiques cependant, j'ai donc utilisé le caractère moins commun. J'ai aussi pensé que le sol suspendu aurait l'air suspicieux, alors j'ai complété les deux lignes avec d'autres personnages. Pour faire bonne mesure, j'ai ajouté à nouveau la première ligne à la fin, et le remplissage de la ligne du milieu correspond aux caractères opposés de la première ligne. J'ai également ajouté des crochets correspondants (qui sont ignorés par MarioLANG), car je pensais qu'un [indice inégalé pourrait être un autre indice fort. Enfin, j’ai écrit un script CJam pour saupoudrer exactement 13 ) et modifié les caractères de remplissage de la quatrième ligne en= en positions aléatoires au sol (13, car celaHello, World!Helo, Wrd!pour faire croire que je lis les caractères du code source, comme le ferait une réponse Befunge. Voilà MarioLANG obscurci! :)

— Martin Ender
source

1

Je vais deviner TinyBF mais c'est probablement une autre langue déguisée en tinyBF: p. Je ne peux pas dire avec certitude parce que l' interprète plante mon navigateur.

— Downgoat

@ vihan Ce serait une coïncidence assez folle si cela fonctionnait avec TinyBF. Ce n'est certainement pas ce que je voulais. ;)

— Martin Ender

1

@Alexa. Non, malheureusement, vous ne pouvez pas déguiser Rail de la sorte (sinon j’aurais déjà posté une réponse Rail: D).

— Martin Ender

1

@aditsu (et toute autre personne souhaitant exclure la fission de façon aléatoire): la fission nécessite au moins un des 4 caractères (majuscules) ULDRpour déclencher un flux de contrôle. Donc non. ;)

— Martin Ender

6

C'est MarioLANG , mais c'était si bien obscurci que ça ne ressemble à rien.

— Sp3000

21

UNBABTIZED , 77 octets

$0,0
.:72
.:101
.:108
.:108
.:111
.:44
.:32
.:87
.:111
.:114
.:108
.:100
.:33

Vérification

Vous pouvez trouver le site officiel et l'interprète ici .

Comme indiqué sur le site Web, l'interpréteur a été écrit pour Python 2.2, qui autorisait les caractères non-ASCII dans le code source. Vous pouvez télécharger Python 2.2.3 ¹ ou le réparer pour Python 2.7 en insérant la ligne suivante au début de l'interpréteur:

# coding: latin1

Comment ça fonctionne

Tout d'abord, les espaces ne devraient pas être autorisés dans le code source selon le site Web, mais les espaces après une instruction complète ne semblent poser aucun problème.

La commande $0,0s'exécute memory[0] = memory[0] == memory[0], ce qui n'aide en rien à saluer le monde. J'ai ajouté cette commande uniquement pour détourner l'attention du fait qu'il s'agit d' .un séparateur de déclaration.

Le reste du code est composé de treize :xcommandes, qui écrivent le caractère avec le point de code x dans STDOUT.

Une version non obscurcie du code source ressemblerait à ceci:

:72.:101.:108.:108.:111.:44.:32.:87.:111.:114.:108.:100.:33

¹ _{Compiler Python 2.2.3 s’était étonnamment bien passé sous openSUSE 13.2. make,make install Et l'exécutable résultant tout imprimé beaucoup d'avertissements, mais UNBABTIZED a fonctionné comme prévu.}

— Dennis
source

esolangs.org/wiki/Fueue ?

— Downgoat

@ vihan Non, désolé. Fueue imprime alors FUEUE: UNKNOWN , OP14 fois HHeelllloo,, WWoorrlldd!!sans quitter le programme.

— Dennis

Pyth ... Mais pas sur l'interprète en ligne?

— Beta Decay

@BetaDecay Non, désolé. $commence un littéral Python, ce qui entraîne une erreur de syntaxe.

— Dennis

14

@ kirbyfan64sos Dennis connaît beaucoup de tout.

— Alex A.

19

Higher Subleq , 52 octets, fissuré par John WH Smith

int puts(char*);int main(){puts("Hello, World!\n");}

Cela ne ressemble pas vraiment à un esolang, mais aucun dérivé C sensé ne pourrait être implémenté putssans un retour à la ligne implicite.

— Dennis
source

1

Est-ce que ça ne marche pas en C?

— jcai

@Arcinde Non, ce n'est pas le cas.

— Dennis

6

Ah, deux nouvelles lignes.

— Peter Taylor

Est-ce objectif c?

— vaches charlatan

5

Wow, je vais en fait commenter ici: D Est-ce que cela pourrait être ... Higher Subleq ?

— John WH Smith

19

Mascarpone, 30 octets, fissuré par Sp3000

[!dlroW ,olleH]$.............

Basé sur la pile? Peut être...

[!dlroW ,olleH]place tous ces caractères dans la pile (oui, y compris les délimiteurs); $apparaît le ]; puis .chacun imprime un caractère. Le programme se termine avec un [personnage encore sur la pile.

J'aurais fait la sortie utiliser une boucle, mais je ne peux pas comprendre comment ils fonctionnent ...

— Peter Taylor
source

1

@ETHproductions, ce n'est pas destiné à être orthogonal. L'interprète ne compile pas pour moi, donc je ne peux pas prouver avec certitude que non.

— Peter Taylor

1

@nimi, cela ne fonctionne pas dans STXTRM. (Et je ne suis pas sûr que STXTRM réponde même aux critères du défi: il ne semble pas avoir de moyen d'imprimer. J'ai dû en ajouter un pour le test).

— Peter Taylor

2

( ou est-ce ce qu'ils veulent que vous pensiez ?? joue de la musique dramatique)

— Lynn

4

@nimi, garde le silence et je te donnerai la moitié du prix.

— Peter Taylor

3

Semble fonctionner dans le mascarpone , qui est en fait basé sur la pile et$ affiche la ]qui , pour une raison quelconque est poussé

— SP3000

17

Whirl , 12302 octets, fissuré par Artyom

3.141592653589793288462643383279207884697269399375705845974944595347816486286788
99262883192534210706798214888651326231664709384460255058223879585940892848425745
72845027259385711356596446299474149373219244288149756659334467284756582337867838
65290203309945648566923460348630458326848283390605263242149273724387006606305588
17688152992197288925489171536436729259066006733053554682146652138414195194155260
94330572703655599939530920867773809328677934055585480744623799627495623598880527
24891227938383069449529853677362440656643086026394946395224737790772179866943722
77753919727629377675238467487846766940533204456812714526359282678571134275778966
91336346707244684405062249534709465459853763597922796832289235478169561899890259
60864034418759863524774774309960578707288349994968372978069966059761732846096388
59502445945534691833264252238825334468583526193118812846000913783875288658753300
83864206877776699473035982539904287554687375595627688823537875937599577858577805
32776236806644850927876620695909236420498932095257201465485963278875956453483837
96838034695203531186296899577362259941389124975177528347993759558285724245455065
59507295336268647288558590750983897546374649398592550644919277416611334898488242
52838361603563707660104090588242945596698926767837469448255372774726847604447334
64620804668425906949629339367707038955200475226235696602405803475079754225338243
75355870402474964432539147992726042692227957823547896360097417216412199245863150
30286182974555706749838505494548586926995690927680797503302955321165344987902755
96923648066549926988983429775356636980742654052787255181841757467289597779279388
41818470600361452491928732372847723507474409737685487603695573585520334747338494
68438523623907394243330547762486862528983569585562099235222984272650254256887658
79049466135346680466862723279578604578438382596797668145416375388858636395568364
42251252351173929838960843284886269456042419752853222166612863067442786220391949
45847123123786260956364373937287457764657573963453890065832645995413397478427592
49946576497895826996831835259574982582262952248949772471947826848260647699090264
09363944374253057682834962524517493996554334298297906592509472256964625557098583
37419517885979772975598339164753928428533268683862942774953993855905255953959433
04997252488324598727364469584868383677642782609902460824124388439242124413654976
27857977456914354977731296960898346948685558404663534220722658284886485584560285
06516842769452237467678895252138528549954666727823386476596121354886233577456498
53559363456817482408253507616947545609659699402822887973680364886963686722878894
00645535933186179256819228747829638249385894397149996759952213655497888938297849
25682998948722258804857566604270477555132379641450523746336364742858444795565807
82175714135473573952311842716670243596953633544295248293746788084546540359027993
44537423173125785399621983874478584784896823214457738687563439064302584530960484
87305879614689674913278191797939952969449663428754440643746423778392379998379085
94956886467544269323974894090748649493596256794520219514655322523160388893091219
37621378559566319377876834399667921793467221825629996638035205930680382477345492
82665414663925211497442854732518666002332434088198710486339734649450453935796268
56189555844665879699826397473658445757425913289786155082097220628043903975931567
71577914253378699360072305587631763594248738252472205369284988263864258673235795
98424848829560980659575972695722393256711632291998169481528077350679274858322287
98652093539657255280835792573698820614442122675192346712331432676373699086585463
98575019707656549685279407657668755556588879099699597833873455283386355276479285
35898206485489632952933029857164253675279278915488497559859865635880270988994309
22448095757728089059232332609729971288443357326848938239119326274536679058060424
23038630324382499675828524374417224132865518093773444030757489218291913921335385
19762408389044929329526084244485963766983895228384783125552678218141957385726243
44418930396864262434407732269780281731891844660964468232527262070226522722986803
96665573092547140557853769466820653509896523948620564769332570536356629185580007
29360659876486117940453348850346363255686753249444668639626579787788556084552965
41366542853961434443185867697514566130980072243782763913240575274947042056223053
89645673099719270004078547332699392894546649458807972708266830634328587858983359
35838713165757446795357163775259203074755765588405250676228534932266474550979259
23599479654737612551765675135759787966645487937450842696848903746399473329621073
40437578997859624589019389413111540429782856475037031986915141287080859904806094
12147221617947647982622434254854540332957685306842288937583043063321751829798662
23717215916977196925474873808665494945057465406284386639379033976926567214618733
67362965712191843638327106496274688260786925602902284725043318211869829413000422
96597849637292533707520475958456609663386294726547364253308077033754590673562350
72835405670402667435436222207725897504958098444893335973438788769625993968334193
41447377641845631298608029088687463260472756952624965860573221681694103795667353
82297436372947867242292465436630198367692823828568996441484436463741456344966894
94092432378969070627790223625382216889573837986235345937364765512289357865158416
37557828735263446542695326972037343546538967774860316996655418733879293344195216
41343899484448736567383962499347983883480927777303863873243077217545654542237772
92121155316609628008592636219759882716133231668397286193366863360627356763035447
76280350450777235757105859548702790844356240545587806246436267945622753399340783
30336254232783994975382437205835369477389926063883346776279695970304835923077909
87040854943748484408227726346564704745878477872009277652807387679077073572534447
30685749733492436231338252443163128484251219256567780694763528083047713747816437
84718509092852520756783934596562834994347595625865865570502290492529985893385572
24264829397285847831634577775626888764462482461579463395352773487354892939587617
48256047470996439643626760449256274204208924856611966254543372137535958450687724
60290161836677524661634252257749542996299593064553779924437340432875262888963995
87947572917464263574152549793916513571053694049609393251890760208252726987985318
87705842972490677863299629009049256697373727047684726860849003372724242916513715
00536832336435038901692989392234451722413412596965316784408745896012122859997662
34593773444826409038905449544400679869075485060263275252983461874078668088183385
11228334592584865855539152133289776528430635655002668282949344539765527989721754
61395398368939363839474211996653855352842056853386249672523340283067642328278929
25077926294632295669898989354288629562701621835646227134967152883900737381198934
97346223961136854066439939509790190699639552453072453585685521956733229299119439
48568034490398255935305226353436592042994745558563860234395544959778377972774411
77271117238434354394782908585986040837400635344339588856486795731547129658424589
89332323342117351545940536556790686627333799585135625734322988273723198997576406
80781119635833565944873168223602876496286744404774649779950549737425626951049007
78698683593814657712684492964871855614537233786733539066883834363565537949864092
70563692934738723920837607023029860367938627089438799262066295954973764248928307
22812690945546684760357626477379467520519475715552781965362132392649616023635832
59074227282931872735052772790055676542552487925303435039885253323215762530906425
46392291522865627169535919565897514836034822769306247435366256916378154785799528
43667957063208615391514452527473924544945423682886064340848486377670896170783024
93404341725946376484393414334123518975769352164637679693374950297085759869239798
82936429939949074362366467411833940326590840443780503332945257423995482965912285
08555722572503017125749296837242292652522711472676756222415420506884863484756836
99983966400136299627838698929165372884222691441407728862750784375167197878326992
82120660418371846535567252532567532863291742487721825399764157959847835622262914
86003465872298053298965322129174878823273427922224533985666472691495556284251693
27574202840379980663658254809269880254566181729678266427655914225194568550654653
05873825462703369316785177699747718667114965583434340693385880740386455433676323
08458768722660348943909562019939361831529168645288738437909904236747336394904555
93845304054974347574811935678913073775572902823555912885309066920376749520332299
94464676851422144772793937517834436689910433365456735475998550468450263655128862
28824462575946333039607225383742882049883538457391771519682887478265669599574494
66175634410752239709683478755355984617541738868379944697486762555665897648483588
45344277568790029065176283529416344262129642435231176006652012412526598558512861
78583823204497684423608007593045761891234982927965619875687228726750798025547695
49245563573212214333966974992356312549478024985340934923827553799830791738622515
22742995888072473625906785451333123948749675791195532673430282448860454263639548
75944822267789624825179289647669758358327438425630296924488962566874332326092752
49603579964692565049368083609003238002934595889706953653494060340286654437588909
45632882253545259661564882465151875471196258443965832397543885690945030335090261
79278332974127766514793942295298969594699576576121845609673378623625692624632086
28692257032748492186543640021947807058656459446320469279068232073883688142435698
13621963208088222468042248264977685896387439283903673672424888321513255623376798
39495215297822845337667494347456813455641725437090696939612257942986467254657846
83886244458823445934789849225284786050490252424770292547205734551050086198819769
33924638787581085754407593079422243908663938330529425786965376431116383808834389
34659653685634784699556978303829309716465143840705727468411237359984345225161050
70679562352368127648483080176918371355279121542716283548360367456286790570651748
82256981579368897669743205750596834408397550201418286724585725871457253326513490
55924009127421624843919535998953533559594427646912691409387001564563216225428832
61927645773106579329552498472758465082648369998922569596888592056007416552563796
78566722796619887782794948355834357516744585522975634434893966420527984936804352
25297598469423253312257634680002947609415979159453766955224829336655566156787364
22536665641654733770439036223295935292694445990416087532018683793792348836894591
51571637852992345292446773659495233510073270878426834974595645838408723727047131
72795431542296526667621449863746459528682436944578977233254876576524133507592043
40495340398349220233807550952290156825634274716463243354456515212669024934396739
77042595783756555506730203923749729736354964533288869574161116496362773449598273
69558822075735247665658985529098266539354948006887320685990754079234240230092590
07067389603622547564789476475483466479604994632339056518453368449569697799335234
62461477961696886885004083470405462542953699118296782468185780393889065695036650
83243297440477184567893282336943106808702742809736248093996278617472645531925385
44280858373694738872940630782655955954626296297070625948258698341116729964090894
38059534393251236235548124949824364278527138385932563989295896427487573946944272
53736694953236200453730488828556756594420735246258954873016769829886592578662242
12496655235338294287854256404838833071165372285633591525347844598183134532904299
99959823522053273365856407826484940764411376393866924883118962453698589175442647
39988228462174492087776977638679572267265556259628254276535830913407092238436577
91681284981794007680985998338492354956400572995585611349892524593669869333973513
58148918568552653087099570899527328709258487994436860256418892256917835258607859
56298848272953509537885574573742608592298817651557803905949408738065932266220593
73108048548546312228257682614165514846626744459831262548524978449254843469414627
54864932709304434039302432227488545975054742178289711277792376822578873477088091
52142298226868586705074227255126332834497627789442362167411918677943965067558577
35867364823993907604260076338704549907760436482046921823717648869341968968645895
58708736062938603890576205855272368341823834546564758834351385921633639874026374
40643549556836896423228274975330265580793453469678352858829924367497488711815893
34945331442622876228809400736877054586596877746194176964323909206248594

Whirl ignore tout sauf 1 et 0. J'ai également modifié d'autres chiffres au hasard, mais ils ne sont pas pertinents. Lorsque vous ne gardez que les 1 et les 0, vous obtenez un "Bonjour le monde!" exemple :)

— Aditsu
source

1

Pi ?

— Alephalpha

@alephalpha hehe, non, c'est juste déguisé pour ressembler à Pi

— aditsu

Est-ce par hasard NULL ?

— Alex A.

@Alexa. non, ce n'est pas

— aditsu

2

Joli! C'est Whirl .

— Artyom

16

GNU bc, 36 octets

main = do
  print "Hello, World!\n"

Une Foo Version -immune de ma précédente tentative .

Cela nécessite la version GNU (ou toute autre version comportant la printfonction) de bc. La première ligne concerne l'obscurcissement: dans bc, les variables ne doivent pas être déclarées et sont initialisées avec 0, nous avons donc une affectation inutile mais avec une syntaxe valide. La deuxième ligne est simplement imprimée Hello, World!.

— nimi
source

Est-ce Frege ?

— alephalpha

@alephalpha: Je ne connais pas Frege, mais tous les programmes que j'ai vus ont un mot module- packageclé ou un mot - clé, donc je suppose qu'il ne compilera pas. Peut-être que cela fonctionne dans le REPL, mais ce n'est pas autorisé.

— nimi

1

@oopbase: non, ce n'est pas Haskell. Il compile, mais donne le mauvais résultat.

— nimi

1

Je suis sûr que ce n'est pas la langue prévue, mais cela fonctionne dans Cyan , si vous ignorez les messages envoyés à stderr (la syntaxe sans erreur nécessiterait un signe deux-points après main = do:).

— Primo

1

(Vous vous moquez de moi! J'ai cherché sur Internet tout ce que j'ai sur mon ordinateur ...) Comment invoquez-vous cela? Je n'arrive pas à convaincre BC de lire un fichier.

— Dennis

15

Chef, 1943 octets, craqué par Angew

Hello World Cake with Chocolate sauce.

This prints hello world, while being tastier than Hello World Souffle. The main
chef makes a " World!" cake, which he puts in the baking dish. When he gets the
sous chef to make the "Hello" chocolate sauce, it gets put into the baking dish
and then the whole thing is printed when he refrigerates the sauce. When
actually cooking, I'm interpreting the chocolate sauce baking dish to be
separate from the cake one and Liquify to mean either melt or blend depending on
context.

Ingredients.
33 g chocolate chips
100 g butter
54 ml double cream
2 pinches baking powder
114 g sugar
111 ml beaten eggs
119 g flour
32 g cocoa powder
0 g cake mixture

Cooking time: 25 minutes.

Pre-heat oven to 180 degrees Celsius.

Method.
Put chocolate chips into the mixing bowl.
Put butter into the mixing bowl.
Put sugar into the mixing bowl.
Put beaten eggs into the mixing bowl.
Put flour into the mixing bowl.
Put baking powder into the mixing bowl.
Put cocoa  powder into the mixing bowl.
Stir the mixing bowl for 1 minute.
Combine double cream into the mixing bowl.
Stir the mixing bowl for 4 minutes.
Liquify the contents of the mixing bowl.
Pour contents of the mixing bowl into the baking dish.
bake the cake mixture.
Wait until baked.
Serve with chocolate sauce.

chocolate sauce.

Ingredients.
111 g sugar
108 ml hot water
108 ml heated double cream
101 g dark chocolate
72 g milk chocolate

Method.
Clean the mixing bowl.
Put sugar into the mixing bowl.
Put hot water into the mixing bowl.
Put heated double cream into the mixing bowl.
dissolve the sugar.
agitate the sugar until dissolved.
Liquify the dark chocolate.
Put dark chocolate into the mixing bowl.
Liquify the milk chocolate.
Put milk chocolate into the mixing bowl.
Liquify contents of the mixing bowl.
Pour contents of the mixing bowl into the baking dish.
Refrigerate for 1 hour.

5

Ce serait chef , je suppose.

— Angew

@Angew Bien joué! :)

15

APL, 39 octets, fissuré par Mauris

"Helo, Wrd!"[0,1,2,2,3,4,5,6,3,7,2,8,9]

L'efficacité est tout.

Cela fonctionne dans la démo ngn-apl .

L'obstruction de l'APL n'est pas une tâche facile si l'intention est de la rendre moins visible à APL.

Voici ce que j'ai réalisé:

Les guillemets doubles ne fonctionnent pas dans tous les dialectes. Dyalog, par exemple, ne les prend pas en charge.
ngn / apl est le seul dialecte que je connaisse qui utilise l'indexation à base zéro par défaut.
Les virgules ne sont pas censées être là.

Les éléments vectoriels sont généralement séparés par des espaces lors de l'écriture APL. Cependant, ,concatène ainsi le code entre crochets concatène 13 singletons.

Une version (légèrement) peu obscurcie et plus portable du code ressemblerait à

⎕IO←0⋄'Helo, Wrd!'[0 1 2 2 3 4 5 6 3 7 2 8 9]

qui fonctionne dans TryAPL , GNU APL.js et la démonstration ngn / apl .

— Dennis
source

Fonctionne en kdb +. Je pense que le nom de la langue est Q, mais je ne l'ai pas trouvé mentionné nulle part dans le téléchargement. Et je ne sais pas comment l'exécuter en tant que fichier source autonome.

— jimmy23013

1

Non je me trompe, il a également imprimé les citations ...

— jimmy23013

Quelqu'un connaît-il des langues dans lesquelles l'indexation par tableau d'une chaîne est autorisée?

— mbomb007

@ mbomb007 Python et Ruby, mais ce n'est pas non plus. Je ne peux pas penser à un langage qui n'imprimera pas de guillemets autour de la chaîne.

— lirtosiast

4

Ceci est APL. (Cela fonctionne ngn-aplau moins)

— Lynn

15

Souris , 105 octets

1[10Y:Y.Y.*X:108Z:33X.X.8+X.Y.+4+X.Y.+1+X.Y.2*-7+Y.3*2+44X.Y.+1+Z.Z.Y.10*1+72!'!'!'!'!'!'!'!'!'!'!'!'!']$

Vous pouvez obtenir un interprète pour Mouse écrit en C ici .

La souris utilise la notation polonaise inversée pour que les opérateurs suivent les opérandes. (Pensez Lisp à l’arrière.) L’affectation des variables est effectuée à l’aide <variable>:et le rappel de la valeur d’une variable s’effectue comme suit:<variable>. . Toutes les valeurs dans Mouse sont des entiers.

! sort un entier et !' le caractère ASCII associé à cet entier. Toutes les sorties vont à STDOUT.

Pour une raison quelconque, tous les programmes valides doivent se terminer par $.

1 [ ~ If true, do

    ~ Variable assignments
    10 Y:
    Y. Y. * X:
    108 Z:

    ~ Push values onto the stack
    33               ~ 33  "!"
    X.               ~ 100 "d"
    X. 8 +           ~ 108 "l"
    X. Y. + 4 +      ~ 114 "r"
    X. Y. + 1 +      ~ 111 "o"
    X. Y. 2 * - 7 +  ~ 87  "W"
    Y. 3 * 2 +       ~ 32  " "
    44               ~ 44  ","
    X. Y. + 1 +      ~ 111 "o"
    Z.               ~ 108 "l"
    Z.               ~ 108 "l"
    Y. 10 * 1 +      ~ 101 "e"
    72               ~ 72  "H"

    ~ Pop values and output as characters
    !' !' !' !' !' !' !' !' !' !' !' !' !'

]   ~ End if
$   ~ End program

— Alex A.
source

Est-ce que c'est Headsecks?

— mbomb007

@ mbomb007 Nope.

— Alex A.

Est-ce Nybbleist ?

— BrainSteel

@BrainSteel Nope.

— Alex A.

Juste une conjecture sauvage, Julia?

— Beta Decay

15

Haskell , 637 octets

(program, main)= script $init

string= struct( \ 
  char(show)-> do show; putChar(char); while 1 ) (return 0)

script
  stack= auto $string("!dlroW ,olleH")

struct buffer (public) = share%: \ 
  align->flip
  (field public buffer) align

auto buffer= (init, buffer)

share from = select x where x = from x

while skip=return 1; skip= skip+1

select x | ~"World"<-
            "Hello"=x

loop k for[]
  buffer=(const ($k) ($skip) id)

loop while not(-- $x) {
  unsigned: i{-1}
  terminal.write(buffer{eval $i--})
  x= not (unsigned) $x
  $i `const `skip{-2}
}

memorize{+,-}

(goal, field)= auto loop

finish%:
  goal= finish $goal

Vidéo de désobfuscation

— a cessé de tourner dans le sens antihoraire
source

On dirait un jeu de sport, lol.

— mbomb007

Pour une raison quelconque, j’ai le sentiment que c’est une langue qui ignore les caractères alphabétiques et que tous les mondes ne sont là que pour confondre les gens.

— Kirbyfan64sos

@ kirbyfan64sos: non, seuls quelques caractères sont ignorés. La plupart des modifications aléatoires que vous pourriez apporter à ce programme le freineraient.

— cessé de tourner dans

1

Les sept jours sont passés. Vous pouvez révéler la langue et sécuriser votre réponse. (Tant que vous ne le ferez pas, les gens risquent toujours de casser votre réponse.)

— Martin Ender

Une supposition: c'est zsh?

— georgeunix

14

Wordfuck , 1063 octets, fissuré par Martin Büttner

Thus men; die. Here meet prepar'd thrice be." Down his
 with lab'ring forg'd and And retir'd Now universal Phoebus at
 Hesperian living, off fields fierce cries, assail'd not for These
 foe. Spread, indulgent quarry headlong prince your bloody side crew.
 Elated call humble yield, his yield, boys camp men, cruel
 all the loudly trusty won, winter spouts they crown. Had
 what long long upon fram'd. Declare back throat, tossing his
 enters, the Nor Aeneas; said from flowing the enclose th'
 match'd Receive with neither threat. From seas painted His oppos'd,
 cried, Thus mortal the his and combine form and, wine.
 And but Let absent, sums to guest, you to spear
 to greedy of First, with love bear." path Whom heav'n
 That by Argive need they to blood, wert eyes the
 this To large, with Some Jove (The from hosts, the
 yoke with horses' when sail is purple at wintry his
 with more camp with have to Earth, to oppose of
 the troops with various but so, thirty well perform by
 the and waves- man! from fear victory too at fire,
 If recess banish'd transfer.

Notez que les fins de ligne doivent être de type Unix.

— jcai
source

3

Perl? (Probablement très faux ...)

— kirbyfan64sos

40

@ kirbyfan64sos Non, beaucoup trop lisible pour Perl.

— jcai

2

Au début, j'ai pensé que ça pourrait être ??? et je suis super excité, mais il s'avère que ça ne marche pas dans ???. : /

— Alex A.

1

@Caltor AlexA. vient de le publier hier soir;)

— ETHproductions

4

C'est Wordfuck .

— Martin Ender

13

Wordy , 3279 octets

#_>^ +7K1 }OU8 4>Fk ry\g 9Ff] A}kY ,6Fo IK`k C'td dbJ[ 0j]l MBp[ \">| R\JY %+T_
)*`7 @[{j ;x-+ _H\= ;D@& />p? h,mx 1m;7 p+yL -#&9 0(^! ,i9^ Q%_! +&$Q %#|e %:~A
%T</ }-(r ]_$p g&|" *w#= @++j \)U` <:W< _t{( c\#< :f@~ >[+6 ,B%? S6d} HSm" b=Yz
c[(; @n*# ;`,Z >~K) D"<% <}h" #>N. I0:o >c"+ '>S! pQX[ U#gu $Ei0 6`>~ -/4: ,3;%
\c(? h;TQ LN)o 5`#; }{V* '-E. 7:5u d]0y s|JJ u+>` `|8? y,<0 \(d! 1^*, &U`_ U/@"
*&7. M|f% |C#? \{4` ,k<+ %*'D h~=_ W_+{ [#_[ %"-r #~_F _:u. N|W6 awH' JMm, }%=R
a>*= *z+' {@"A ,'3\ m;}@ (I<. "044 '}A` =K'? puB[ R<ka nrR: S<>= ;`(e (\*p N$"?
u1c} eI%L O$*~ ]O+{ 7"@! vU%n 'MIs E`VV ,/~q p}\? ^DM, k:-! ,3:$ D*~< "}T^ /z}%
\|h< 'Y@? }M%0 {/c. |";P /I"` "[(v ~>l- #2]! j~af rZ(J 9zv` {`T, M`'& (H+: {G+>
A#~` /_%6 4"}! 9|rs [;$m ]J|? IZx; ^xaf WuB) =^+s |+%t [;^U ])A! H;Jb @STw x^`,
=9~< %Z). @v3o h;Tz M9~t {'|O {J`. u^t> 9<-? )/4- `/v| )>O] /(E' ,};X ;&0. 0`o:
(#o? ,D]< X%|* ;}*h [%C` &(A' ^@J^ {O[| &%&Q -;9` |j}) |z]+ :4:. 03(4 <Bhz N$mY
R$~< -M#' C)$$ /=[J 9@^" [*}a :%R. T1,W Y=}` O=&. D;ms Mi=c (Stg >|}1 __^B P};{
&{1. y(Wq T&Nq $^'D />@M @u^? $2Pd n4~d 19j/ X>#> #s[. 0-@P $B%? %w}% x=<[ =}r_
\#=8 ~~R> P']! }8a+ *;j! w<_` %;T: #0({ -_8< A(]^ @1`/ )@f` /=m\ e"~@ ~4$' (z]&
/C|? wtn; HFe^ Gzn* @K}/ >1+{ 7/-{ 2&{} }X-% T=:> O,;. qR8; ;*0: s|>. -bFs DK^y
jk}O =~g/ B%:{ 9;@` K%}? `Xvi "vI4 c+$) =<(b %g#. Tt'w P\ID M`fI %#^M E#=. B&)v
;9:? (+/7 <%q" =,U{ -`/G r[*^ Y;@! H&d> ))@% &S,! |B*[ ~^-p 6+,~ N#&\ ;]K* 6}=^
/|Q) *y:\ ,M*| %&'f =U>@ }~@Y >~3~ `P<: K\+? WUD= |4x5 sox} /6;> [&r{ p@", :'D}
g{^} -]$H _B-! fJ5< p;&@ {a~! Ra+M OKo+ ydJ+ *~-T :W=; @*#, ^_e- k=_. M@QY (fQn
X<,] >(C/ [A/. {nNT {tXg vy@e *1+} (G,. +2m[ X[=! s$,/ [@y! :l+9 -@2. :(P- +a~#
,p%) %*)0 }*=F +"T( Q&~@ <c*; }(\E 3@_* I):( \:2? ~CqL 5$TC ,ARH ;*p/ <~0` _B';
;=>A (%T, d&[; #`g. N*u1 @LEE zPP[ ;<)4 ,1%= [#1# =6^! IL\e 0t@f ~}h< j'{+ <_B!
wFE; lyr` Ja\V '[,J 2_^! Rb;% I>$? F#-{ %+j. fB>2 J7P# Kj~n }#C> T*%` Q=/@ T;%>
_c|{ :&$1 %Q}. rFl> #A,` `Z^! Ks"L hUI: 6_MV ^Q-- `M/> #3/= #'n. MID{ vdn, @_l{
v_@; `s@? H#eZ ]9my oP#e {|R# '(k! d#d; :s,? $+H@ :#=e }2-] 8,-< &1$! l(`7 e:-!
%\X$ k_>' <7], ~%N| r)]] -"$u &0\! SR:z ly]b K(wa q*@- ]{~c )}x% &@&Y >~;j #R)=
%V*. %L1F j'~; +_0. Yz-x @kVV 0G:a `,p] (>n< >{{z /#m! S~CS #Foq %$h( +*{B G#@?
fwr< %OQt K"Cx @0}+ b${. F]R* k=/! C$=, @#/b 4[$* y`,^ $|*R 6,%! Z*c@ ;0\. [&f-
$"/k -L{, \@7{ ^]k\ v$>% v#-; +G># -F@} :=R@ Z<|^ )H-~ o#~^ E#$) :a{. i52: :svA
q&NY #g"< )r]{ "p%& %P}@ 'k|, #m)' ]6$. :@{& |Rcr \]|T ;^8! b2{F rv<i N>VP D>~_
)'A_ G(}- Y&^? 64-A %klM %Q=@ }J:; _b<? ^jjo v[5V {gyQ y)`[ }|l. '0B` A`{. >]@M
#},y C"_} s]@' \9|- _#$o _w"? %&43 k}". >}u- ^]b? z%Cg f+aT vr$A /:\z #);I $*F,
+7^# \%T( ,*a{ &>n? t8J( >*|F @{4? >X4T o7r+ bQ:L *^C_ ;#8& `w(( >,v. a<dY D52+
1_+: "-i) }&f? *LNO %d5F yu{O $}&x 'v]? *b{m &*i! W\#( <%i+ }=o" 9=#& \@1{ @4-?
O])U :`Z? T{`> &>}0 <[T+ `w|{ *"k* >@b^ ~,8+ "{;n &-X* "l{+ [V_" ^8$. $Ppv MY7%
1e;R ={g# |N}_ )`[d *U\~ "@L# &o{, ^Y[! m13= z@\$ /\o. VdO" %EBr h,cD &^(6 )t(`
'S%, @L(? zd{g 0YR" n;}_ 9$~^ N`$! hz>G iM_A JT8+ K)-] g[`? 1J@~ -l*? {<n& w{+:
;r`& ,9-> (}r| M$<? I"0* H|=. =[:T (^#y V~-/ 6(:? K{GF RzF^ V^4d ;#>d ~C}@ b(^\
(_B- /)_K >;^i V#%! c5H^ 'R@> <M:. ee\0 jPH( JV=4 >{&k "T#\ y';) {^e? :gq7 2B(3
+P-| s\%( 'e~? TE8^ V6U> mB<q 'K&( {u|! y@<A ]f&. "K~+ =o(? 5+u^ u>(? a_%. *</>

Comme je l'ai laissé entendre dans les commentaires, cette botte de foin est principalement une aiguille.

Nous pouvons saluer le monde en exécutant les instructions suivantes:

ASSIGN NOP LITERAL 16
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 4 LITERAL 8
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 5
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 15
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 2 LITERAL 12
OUTCHAR MULTIPLY VALUE NOP LITERAL 2
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 5 LITERAL 7
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 15
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 7 LITERAL 2
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 4
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 2 LITERAL 1

Wordy code toutes les instructions sous forme de phrases, la fraction de mots plus longue et plus courte que la moyenne arrondie sélectionnant la commande.

Les phrases les plus courtes que j'ai pu trouver pour les instructions utilisées sont:

ASSIGN xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx x x x x x x x.
VALUE xxx xxx x x x.
ADD xxx x x.
MULTIPLY xxx xxx xxx x x x x.
OUTCHAR xxx xxx xxx x x x x x x x.
NOP xxx xxx xxx x x.
LITERAL xx x.

Mais comment cacher le fait que la longueur des mots est la seule chose importante dans le code source?

Ni l'ordre des mots, ni les mots choisis ne sont importants, tant qu'ils sont alphanumériques. J'ai donc décidé d'ajouter des caractères aléatoires non alphanumériques à chaque mot pour qu'ils soient tous de la même longueur. J'ai également ajouté quelques non-mots (aucun caractère alphanumérique) pour donner au code source sa forme rectangulaire agréable.

J'ai généré le code source final en utilisant ce programme CJam .

— Dennis
source

3

C'est une grosse meule de foin.

— Sp3000

4

Je suppose que cela dépend de la taille de l'aiguille.

— Dennis

6

En parlant de meules de foin. S'il n'y a pas actuellement un langage appelé "Haystack", ce serait un excellent nom pour un ...

— mbomb007

@ mbomb007 y travaille;)

— Kade

Je suis à peu près sûr que ce n'est pas le cas, mais l33t ?

— MickyT

Le Quiz Langage De Programmation

Le défi des flics

Mise en page

Le défi des voleurs

Tableau de bord de défi

Réveil , 17 octets

TinyBF , 708 octets, fissuré par kirbyfan64sos

Explication

evil , 658 bytes, fissuré par Sp3000

Lua, 2920 2865 octets, fissuré par jimmy23013

Explication:

TRANSCRIPTION , 39 octets

Headsecks , 637 bytes, fissuré par Dennis

??? , 344 octets, fissuré par jimmy23013

??? , 1052 octets, fissuré par Alex A.

Treehugger , 284 octets, fissuré par Sp3000

Explication:

Starry , 3039 octets, fissuré par Sp3000

Brainfuck , 2545 octets, fissuré par Sp3000

Fission , 67 octets, fissurée par BrainSteel

Q , 64 octets, fissuré par Mauris

Logo , 14292 octets, fissuré par Gareth McCaughan

~ Anglais révisé , 36 octets

Explication

Karma , 67 octets

gs2, 3 octets, fissuré par feersum

> <>, 353 octets, fissuré par Sp3000

MarioLANG , 549 octets, fissuré par Sp3000

UNBABTIZED , 77 octets

Vérification

Comment ça fonctionne

Higher Subleq , 52 octets, fissuré par John WH Smith

Mascarpone, 30 octets, fissuré par Sp3000

Whirl , 12302 octets, fissuré par Artyom

GNU bc, 36 octets

Chef, 1943 octets, craqué par Angew

APL, 39 octets, fissuré par Mauris

Souris , 105 octets

Haskell , 637 octets

Vidéo de désobfuscation

Wordfuck , 1063 octets, fissuré par Martin Büttner

Wordy , 3279 octets