Votre tâche consiste à afficher la lettre "A" seule, sans rien d'autre, à l'exception de toute nouvelle ligne de fin si vous ne pouvez pas les éviter, dans un programme et / ou un extrait de code. Le code renvoyé (au lieu de l’impression) est autorisé.

Les versions minuscule et majuscule de la lettre "A" sont acceptables (c'est-à-dire unicode U + 0061 ou unicode U + 0041. Les autres encodages de caractères non Unicode sont autorisés. Toutefois, dans tous les cas, la sortie de votre code doit être la lettre latine "A", et non des sosies ou homoglyphes)

Vous ne devez utiliser aucun des caractères ci-dessous dans votre code, quel que soit le codage de caractères choisi:

• " A ", en majuscule ou en minuscule.

• " U ", en minuscule ou en majuscule.

• X , majuscule ou minuscule.

• +

• Et

• #

• 0

• 1

• 4

• 5

• 6

• sept

• 9

La triche, les échappatoires, etc., ne sont pas autorisés.

Puisqu'il s'agit de code-golf , la solution la plus courte, en octets, qui respecte toutes les règles, est gagnante.

Vérificateur de validité

Cet extrait de pile vérifie que votre code n'utilise pas les caractères restreints. Cela pourrait ne pas fonctionner correctement pour certains encodages de caractères.

var t = prompt("Input your code.");

if (/[AaUuXx+&#0145679]/.test(t)) {
  alert("Contains a disallowed character!");
} else {
  alert("No disallowed characters");
}

Cet extrait de pile garantissant que vous n'avez pas de caractère non autorisé est également disponible sur JSFiddle .

Classement

var QUESTION_ID=90349,OVERRIDE_USER=58717;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Pluso, 1 octet

o

Pluso Esolangs Page .

Pluso contient un seul accumulateur, qui commence par la valeur 1. Il utilise deux commandes, p qui incrémente l’accumulateur (mod 27) et o qui affiche la valeur actuelle sous forme de caractère majuscule ASCII, AZ ou espace (où 1-26 représente Respectivement AZ et 0 représente l’espace).

Comme l'accumulateur commence à 1, la commande o sans précédent p volonté sortie A .

Python 2, 14 octets

print`3<3`[~3]

L'expression 3<3donne le booléen Falseet les backticks donnent sa représentation sous forme de chaîne 'False'. De là, il reste à extraire la lettre a. Python est indexé sur 0, donc the aest at index 1, qui est un caractère interdit. Cela peut être exprimé ainsi 3-2, mais il existe un moyen plus court. Python permet l'indexation à partir de l'arrière, avec l'index -1pour la dernière entrée, -2pour celle qui la précède, etc. Nous voulons un index -4, mais 4c'est aussi un nombre interdit. Mais, nous pouvons l'exprimer en ~3utilisant le complément de bits ~, ce qui donne -n-1pour ~n.

Pyth, 2 octets

hG

Testez-le dans le compilateur Pyth .

Comment ça fonctionne

 G  Yield the lowercase alphabet.
h   Extract the first character.

PHP, 9 à 6 octets

<?=O^_^Q;

Pour 9 octets: Inspiré par la réponse de @Ton Hospel . De plus, il présente l'avantage supplémentaire de ressembler un peu à un Kaomoji. :-)

La version améliorée de 6 octets:

<?=~¾;

où ¾ a le code hexadécimal de 0xBE (il est important de sauvegarder le fichier en codage Latin-1 , pas en UTF-8!).

05AB1E, 3 2 octets

Th

Explication

T   # push 10
 h  # convert to hex

Essayez-le en ligne

Sauvé 1 octet grâce à Adnan

brainfuck, 16 octets

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

Ceci est basé sur l'algorithme brainfuck d'Esolang pour 159 .

Essayez-le en ligne!

JavaScript (ES6), 17 16 14 octets

Sauvé deux octets grâce à Neil!

_=>` ${-_}`[2]

Retourne le second caractère de NaN, qui est a.

C'est le plus court que j'ai pu trouver pour A, 43 42 octets:

_=>`${[][`constr${`${!_}`[2]}ctor`]}`[-~8]

Qui a dit qu'être un obfuscateur n'aidait pas le code golf? Pas moi!

Des explications

Le premier, en profondeur.

_=>` ${-_}`[2]

-_est NaN, car _est indéfini. Pour obtenir cela sous forme de chaîne, il faudrait l'une des opérations suivantes:

-_+""
`${-_}`
(-_).toString()

Le dernier est trop long, et le premier utilise +. Nous utilisons donc le second. Maintenant, le aest à l'index 1. Ce n'est pas bon, parce que 1c'est interdit. Cependant, étant une chaîne de gabarit, nous pouvons y insérer un espace pour le rendre à l'index 2, nous laissant ainsi avec ` ${-_}`.

Le second, en profondeur.

_=>`${[][`constr${`${!_}`[2]}ctor`]}`[-~8]

Celui-ci était un doozy.

_=>`                                `[-~8]

Il s'agit du neuvième caractère de la chaîne de modèle interne, -~8égal à 9. Dans ce cas, cette chaîne de modèle est uniquement destinée à la personnification. C'est l'équation interne qui est en train d'être stratifié, entre ${...}:

[][`constr${`${!_}`[2]}ctor`]

Développons ceci un peu:

(new Array())[`constr${`${!_}`[2]}ctor`]

Cela obtient la propriété d'un tableau vide. Cette propriété est, bien sûr, une chaîne de modèle, mais elle est entourée de texte. C'est à peu près équivalent à:`constr${${!""}[2]}ctor`

"constr" + `${!_}`[2] + "ctor"

L'intérieur est à son tour équivalent à:

(!_).toString()[2]

!_est true(parce que _est undefined, et !undefined === true), et stringified est "true". Nous obtenons le second caractère de celui - ci, u; nous devons l'obtenir de cette façon pour éviter de mettre explicitement udans notre code.

Donc, ce bit intérieur équivaut à:

"constr" + "u" + "ctor" === "constructor"

Nous obtenons donc le constructeur du tableau, la Arrayfonction. Je ne pouvais pas y mettre explicitement parce qu'il contient l'interdit A. Maintenant, la stringification de la Arrayfonction rend "function Array() { [native code] }".

Retour au code original:

_=>`${[][`constr${`${!_}`[2]}ctor`]}`[-~8]

Ceci est équivalent à, comme nous l'avons vu:

_=>Array.toString()[-~8]

Équivalent à:

_=>Array.toString()[9]

Enfin équivalent à:

_=>"A"

Hexagonie , 4 octets

Ayyy lmao? Tout à fait golfy pour une langue non golfique haha. Code:

B(;@

Essayez-le en ligne!

Une forme plus lisible:

 B (
; @ .
 . .

Cela met la valeur ASCII de la lettre B, qui est 66, sur le bord de la mémoire en cours. Il le soustrait par un utilisateur (et l’imprime avec ;. Après cela, le programme est arrêté avec @.

Image de chemin obligatoire:

Gelée , 3 octets

ØWḢ

Essayez-le en ligne!

Comment ça fonctionne

ØWḢ  Main link. No arguments.

ØW   Yield "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_".
  Ḣ  Head; extract the first character.

Gelée, 4 octets

l-ṾṂ

Essayez-le en ligne!

Comment ça fonctionne

l-ṾṂ  Main link. No arguments.

l-    Take the logarithm of 0 with base -1. Yields (nan+infj).
  Ṿ   Uneval; yield the string representation, i.e., "nanıinf".
   Ṃ  Take the minimum, returning 'a'.

En fait , 2 octets

úF

Essayez-le en ligne!

Explication:

úF
ú   lowercase English alphabet
 F  first element

CJam, 3 octets

'@)

Essayez-le en ligne!

Comment ça fonctionne

'@   Push the character '@' on the stack.
  )  Increment its code point, yielding 'A'.

Bubblegum , 1 octet

"

ou

B

Tout le monde semblait oublier que ça existait ...

Perl, 9 à 8 octets

xor est toujours autorisé, mais sayne l'est pas. Donc pour 9 octets:

print$/^K

Cependant, l’utilisation de la sortie vers STDERR donne 8 octets:

die~"\x9e\xf5"

Remplacer \x9eet \xf5par leurs versions littérales. Ou générez le fichier exécutable en utilisant:

perl -e 'printf q(die~"%s"),~"a\n"' > a.pl

> <> , 6 octets

'|;o-$

cela crée une chaîne de caractères, rebondit et la crée à nouveau en sens inverse, retourne les 2 premiers éléments de la pile et soustrait: '|' (124) moins ';' (59) est 'A' (65)

Essayez-le en ligne

Ruby, 15 12 octets

$><<to_s[-3]

Java, 55 octets

void f(){System.err.write('c'-2);System.err.println();}

Étant donné que le code doit l’imprimer, l’un des deux rédacteurs intégrés est requis. System.outest, eh bien, dehors, car il contient u. System.errfonctionne, cependant.

Le prochain obstacle est le traitement de Java par charet int. Dans la mesure où il n’est pas autorisé de transtyper vers charcar il contient a, et parce qu’il 'c' - 2est promu int, un autre mécanisme est requis. System.errest un PrintWriter, qui a une write(char)méthode mais pas write(int). Mettre 'c' - 2dedans force à le faire charsans casting.

Enfin, chaque fois que j’exécutais le programme, le tampon System.errne vidait pas comme il était supposé, et le programme n’imprimait rien. Je devais donc le rincer manuellement. Cependant, System.err.flush()n'est pas autorisé, j'ai donc appelé pour println()vider implicitement le flux sous-jacent.

MATL, 5 octets

YNVH)

Essayez-le en ligne

Explication

YN      % Creates a NaN value (not a number)
V       % Convert it to a string
H)      % Grab the second letter ('a')
        % Implicitly display the result

Ma réponse originale était l'approche avant droite en utilisant le littéral prédéfini lY2qui donne 'A'...'Z', puis en sélectionnant le premier élément, 'A'.

lY2l)

Javascript, 18 octets 16 octets 12 octets 11 octets

` ${!2}`[2]

Basé sur les bases de jsfuck modifiées (devait comprendre comment remplacer +par -).

Ungolfed?

Eh bien, au moins une version avec des commentaires (notez que cette version ne fonctionnera probablement pas):

` ${      // whitespace to make "a" the third letter
  !2      // returns false
}`        // convert to string "false"
[2]       // index the third letter in " false" (note the whitespace)

Ancienne solution:

`${![]}`[-(-!![])]

Vim, 16 13 11 10 frappes

Merci à H Walters pour avoir économisé deux clés

Merci à DJMcMayhem pour en avoir sauvé un autre!

:h%<cr>jvyZZp

:h%<cr> #open help for percent
jvy     #move down one char (to the letter "a"), visual mode the character, yank
ZZ      #exit help for percent
p       #put yanked character

R, 27 12 octets

EDIT: Nouvelle version, d'une excellente idée de @Jarko Dubbeldam

LETTERS[T*T]

Tout un défi amusant!

Fondamentalement, cela prend l’ 26thélément du vecteur inversé contenant les lettres majuscules ( LETTERSqui est un vecteur intégré de R )

Version précédente s (même nombre d’octets) :

L=LETTERS;rev(L)[length(L)]
rev((L=LETTERS))[length(L)]

> <> , 7 4 octets

3 octets sauvés grâce au pélican de sarcelle

"-o.

Essayez-le en ligne!

Explication

"-o."   # pushes the string "-o."
-       # subtracts the charcode of o from the charcode of . (dot), 111-46=65
o       # prints as character
.       # tries to pop 2 coordinates to jump to, but as nothing is left on the stack
        # the program ends in an error

Vim, 2 frappes

vim -u NONEpuis exécutez ce qui suit ( -u NONEdésactive la personnalisation)

i<up>

Lorsque vim est exécuté en mode compatible, les touches fléchées ne sont pas interprétées correctement. <up>est interprété, <esc>OAce qui laisse les éléments suivants en mode insertion. Ce qui laisserait (avec un couple de nouvelles lignes de fuite)

A

idémarre le mode insertion.
<up>quitte le mode insertion, ouvre une ligne au dessus et entre A dans la mémoire tampon

Exemple de personnes rencontrant cela dans la nature. https://stackoverflow.com/questions/6987317/while-moving-the-cursor-across-a-vim-process-open-in-a-tmux-session-every-now-a/6988748#6988748

Brainfuck, 192 19 octets

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

Merci à @NinjaBearMonkey de m'avoir aidé à économiser hella octets

-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -----------------------------------------.

Je ne suis pas bon chez Brainfuck, alors je suis sûr qu'il existe une solution plus courte, mais elle fonctionne en décrémentant jusqu'à 0, en renversant l'octet et en continuant jusqu'à ce que la valeur revienne à 'A', puis elle s'imprime.

JavaScript (ES6), 21 octets

_=>(8^2).toString(22)

À l’origine, j’ai essayé de convertir falseen chaîne pour le faire, mais cela me prenait 23 octets à la fois. J'ai depuis mis au point un moyen plus court, à savoir 14 octets:

_=>`!${!2}`[2]

Je ne pense pas que vous puissiez obtenir une majuscule en Avertu des règles, car vous en avez besoin d’une String.fromCharCodeou des .toUpperCase()deux qui contiennent a.

C, (19?) 24 octets

Merci à Dennis:

f(){printf("%c",88-23);}

même longueur:

f(){printf("%c",'C'-2);}

ce qui permet aussi les minuscules:

f(){printf("%c",'c'-2);}

Il existe une solution de 19 octets en tant que fonction modifiant son paramètre, ce qui présente un défaut:

g(int*p){*p='C'-2;}

//Usage:

main(){
  int c; //cannot be char
  g(&c);
  printf("%c\n",c);
}

Si a cété déclaré char, gmodifie le tout de intmanière à écraser la pile, ce qui entraîne la modification d'autres valeurs ou l'abandon du programme avec un message d'erreur. La seule façon de contourner est de déclarer int c;dans mainet imprimer avec "%c", mais qui se sent comme une échappatoire.

solutions plus anciennes

f(){printf("%c",'B'-2/2);} //26 bytes
f(i){i='B';printf("%c",--i);} //29 bytes
f(){int*i="B";int j[]={*i-(2/2),2-2};printf("%s",j);} //53 bytes

Juste une fonction, car mainest interdite.

dc, 4 octets

833P

Le débordement UCHAR_MAX parcourt la table six fois à trois reprises avant d'atterrir à 65 ans.

Lua, 36 octets

Celui - ci m'a pris un certain temps puisque plusieurs des fonctions standard de Lua sont prises loin des règles (tous math, string.char, string.match, pairs, même next)

Cela profite du fait que Lua a un global _VERSIONqui commence habituellement par "Lua" (par exemple, Lua 5.1ou similaire pour les autres versions). Ainsi, à moins que cela ne soit exécuté sur un interprète non traditionnel, le troisième caractère sera un "a"

print(({_VERSION:find("..(.)")})[3])

Le {...}[3]est de grouper les résultats, findce qui inclut également les index où il correspond, puis renvoie le troisième élément qui est le caractère correspondant (le a)

Haskell, 10 octets

En tant que fonction (ou plutôt une déclaration car aucune entrée n'est requise)

f=pred 'B'

fait le tour. Essayez-le sur Ideone. Un programme complet est impossible car il faudrait contenir un main.

Brachylog , 4 octets

@Ztw

Essayez-le en ligne!

Explication

@Z      The string "zyxwvutsrqponmlkjihgfedcba"
  tw    Write the last element to STDOUT

dc, 8 7 octets

-1B grâce à Dennis

88 23-P

Pousse 88, pousse 23, soustrait, laissant 65. Imprime le haut de la pile (65) en tant que chaîne ASCII, sans fin de nouvelle ligne.

Modifier:

Ce sont quelques-unes des autres façons que j'ai proposées. Il est devenu fondamentalement un jeu de "générer les nombres 65 et 97 en utilisant seulement [238B-F]et sans addition". Ironiquement, je trouve les plus longs les plus intéressants.

_Fdd/r-oC 2-n  # involves changing the base
2_2/8d*3*2/-P
Idd2/2/-2*on   # also changes base
2d8r^r_2/-P
8d*2_2/-P
B 3d**2-P
33 3*2-P