Il tuo compito è quello di visualizzare la lettera "A" da sola, senza nient'altro, tranne qualsiasi forma di newline finale se non puoi evitarli, farlo in un programma e / o frammento. Il codice che restituisce (invece di stampare) è consentito.

Sono accettabili sia la versione minuscola che maiuscola della lettera "A" (ovvero unicode U + 0061 o unicode U + 0041. Sono consentite altre codifiche di caratteri che non sono Unicode, ma in entrambi i casi l'output risultante del codice deve essere la lettera latina "A" e non nessun sosia o omogeneo)

È necessario non utilizzare uno dei caratteri riportati di seguito nel codice, indipendentemente dalla codifica dei caratteri che si sceglie:

• " A ", maiuscolo o minuscolo.

• " U ", minuscola o maiuscola.

• X , maiuscolo o minuscolo.

• +

• &

• #

• 0

• 1

• 4

• 5

• 6

• 7

• 9

Barare, scappatoie, ecc. Non sono ammessi.

Dato che si tratta di code-golf , la soluzione più breve, in byte, che segue tutte le regole, è il vincitore.

Validità Checker

Questo frammento di stack verifica che il codice non utilizzi i caratteri limitati. Potrebbe non funzionare correttamente per alcune codifiche di caratteri.

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

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

Questo frammento di stack che ti assicura di non avere un carattere non consentito è disponibile anche su JSFiddle .

Classifica

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 byte

o

Pluso Esolangs .

Pluso contiene un singolo accumulatore, che inizia con il valore 1. Utilizza due comandi, p che incrementa l'accumulatore (mod 27) e o che stampa il valore corrente come un carattere ASCII maiuscolo, AZ o spazio (dove 1-26 rappresenta AZ rispettivamente, e 0 rappresenta lo spazio).

L'accumulatore inizia con 1, il comando o senza precedente p volontà uscita A .

Python 2, 14 byte

print`3<3`[~3]

L'espressione 3<3dà il booleano Falsee i backtick danno la sua rappresentazione in forma di stringa 'False'. Da qui, resta da estrarre la lettera a. Python è indicizzato 0, quindi aè in indice 1, che è un carattere vietato. Può essere espresso come 3-2, ma c'è un modo più breve. Python consente l'indicizzazione dal retro, con l'indice -1per l'ultima voce, -2per quella precedente e così via. Vogliamo un indice -4, ma 4è anche un numero vietato. Ma, possiamo esprimere come ~3utilizzare il bit-complemento ~, che dà -n-1per ~n.

Pyth, 2 byte

hG

Provatelo in Pyth compilatore .

Come funziona

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

PHP, 9 6 byte

<?=O^_^Q;

Per 9 byte: ispirato alla risposta di @Ton Hospel . Inoltre, ha l'ulteriore vantaggio di sembrare un po 'un Kaomoji. :-)

La versione migliorata di 6 byte:

<?=~¾;

in cui ¾ ha il codice esadecimale di 0xBE (è importante salvare il file in codifica Latin-1 , non UTF-8!).

05AB1E, 3 2 byte

Th

Spiegazione

T   # push 10
 h  # convert to hex

Provalo online

Salvato 1 byte grazie ad Adnan

Brainfuck, 16 byte

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

Questo si basa sull'algoritmo Brainfuck di Esolang per 159 .

Provalo online!

JavaScript (ES6), 17 16 14 byte

Due byte salvati grazie a Neil!

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

Restituisce il secondo carattere di NaN, che è a.

Questo è il più breve che potrei trovare A, per 43 42 byte:

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

Chi dice che essere un offuscatore non aiuta con il golf del codice? Io no!

spiegazioni

Il primo, in profondità.

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

-_è NaN, perché _non definito. Per ottenere questo come stringa, è necessario uno dei seguenti:

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

L'ultimo è troppo lungo e il primo usa +. Quindi usiamo il secondo. Ora, aè all'indice 1. Questo non va bene, perché 1è proibito. Tuttavia, essendo una stringa di modello, possiamo mettere uno spazio lì dentro per renderlo all'indice 2, lasciandoci così con ` ${-_}`.

Il secondo, in profondità.

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

Questo era un doozy.

_=>`                                `[-~8]

Questo è il nono carattere della stringa del modello interno, -~8pari a 9. In questo caso, questa stringa del modello è solo per la stringa. Questa è l'equazione interna che si sta stringendo, tra ${...}:

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

Espandiamolo un po ':

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

Questo ottiene la proprietà da un array vuoto. Questa proprietà è, ovviamente, una stringa di modello, ma contiene del testo. È approssimativamente equivalente a:`constr${${!""}[2]}ctor`

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

L'interno è a sua volta equivalente a:

(!_).toString()[2]

!_è true(perché _è undefinede !undefined === true) e è rigoroso "true". Ne otteniamo il secondo personaggio u,; dobbiamo farlo in questo modo per evitare di inserire esplicitamente il unostro codice.

Quindi, questo bit interno equivale a:

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

Quindi stiamo ottenendo il costruttore dell'Array, la Arrayfunzione. Non ho potuto dirlo esplicitamente perché contiene il proibito A. Ora, stringendo i Arrayrendimenti della funzione "function Array() { [native code] }".

Torna al codice originale:

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

Questo è equivalente a, come abbiamo visto:

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

Equivalente a:

_=>Array.toString()[9]

Finalmente equivalente a:

_=>"A"

Esagonia , 4 byte

Ayyy Lmao? Abbastanza golfy per un linguaggio non golf haha. Codice:

B(;@

Provalo online!

Un modulo più leggibile:

 B (
; @ .
 . .

Questo mette il valore ASCII della lettera B, che è 66, sul bordo di memoria corrente. Lo sottrae da uno usando (e lo stampa con ;. Successivamente, il programma viene terminato utilizzando @.

Immagine del percorso obbligatorio:

Gelatina , 3 byte

ØWḢ

Provalo online!

Come funziona

ØWḢ  Main link. No arguments.

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

Gelatina, 4 byte

l-ṾṂ

Provalo online!

Come funziona

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

In realtà , 2 byte

úF

Provalo online!

Spiegazione:

úF
ú   lowercase English alphabet
 F  first element

CJam, 3 byte

'@)

Provalo online!

Come funziona

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

Bubblegum , 1 byte

"

o

B

Tutti sembravano dimenticare che esistesse ...

Perl, 9 8 byte

xor è ancora consentito, ma saynon lo è. Quindi per 9 byte:

print$/^K

Tuttavia, l'utilizzo dell'output su STDERR fornisce 8 byte:

die~"\x9e\xf5"

Sostituisci \x9ee \xf5con le loro versioni letterali. O genera il file eseguibile usando:

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

> <> , 6 byte

'|;o-$

questo crea una serie di caratteri, rimbalza e la crea nuovamente al contrario, capovolge i primi 2 oggetti dello stack e sottrae: '|' (124) meno ";" (59) è 'A' (65)

Provalo online

Rubino, 15 12 byte

$><<to_s[-3]

Java, 55 byte

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

Poiché il codice deve stamparlo, è necessario uno dei due writer integrati. System.outè, beh, fuori, perché contiene u. System.errfunziona, comunque.

Il prossimo ostacolo è la gestione di Java di chare int. Poiché non è consentito eseguire il cast in charquanto contiene ae poiché 'c' - 2viene promosso int, è necessario un altro meccanismo. System.errè un PrintWriter, che ha un write(char)metodo ma non write(int). Mettendolo 'c' - 2lì lo costringe a charsenza un cast.

Alla fine, ogni volta che eseguivo il programma, il buffer System.errnon si scaricava come dovrebbe, e il programma non stampa nulla. Quindi ho dovuto sciacquarlo manualmente. Tuttavia, System.err.flush()non è consentito, quindi ho chiamato println()che scarica implicitamente il flusso sottostante.

MATL, 5 byte

YNVH)

Provalo online

Spiegazione

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

La mia risposta originale era l'approccio diretto usando il letterale predefinito lY2che produce 'A'...'Z'e quindi selezionando il primo elemento 'A'.

lY2l)

Javascript, 18 byte 16 byte 12 byte 11 byte

` ${!2}`[2]

Sulla base modificati jsfuck basi (dovuto capire come sostituire +con -).

Ungolfed?

Bene, almeno una versione con commenti (nota che questa versione probabilmente non funzionerà):

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

Vecchia soluzione:

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

Vim, 16 13 11 10 sequenze di tasti

Grazie a H Walters per aver salvato due chiavi

Grazie a DJMcMayhem per averne salvato un altro!

: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 byte

EDIT: nuova versione, da un'idea eccellente di @Jarko Dubbeldam

LETTERS[T*T]

Piuttosto una sfida divertente!

Fondamentalmente, questo prende l' 26thelemento del vettore invertito contenente le lettere maiuscole ( LETTERS, che è un vettore incorporato di una R )

Versione precedente s (stesso numero di byte) :

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

> <> , 7 4 byte

Salvato 3 byte grazie al pellicano Teal

"-o.

Provalo online!

Spiegazione

"-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 sequenze di tasti

vim -u NONEquindi esegui quanto segue ( -u NONEdisattiva la personalizzazione)

i<up>

Quando vim viene eseguito in modalità compatibile, i tasti freccia non vengono interpretati correttamente. <up>viene interpretato il <esc>OAche lascia quanto segue in modalità inserimento. Che lascerebbe (con un paio di newline finali)

A

iavvia la modalità di inserimento.
<up>esce dalla modalità di inserimento, apre una riga sopra e inserisce A nel buffer

Esempio di persone che incontrano questo in natura. 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 byte

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

Grazie a @NinjaBearMonkey per avermi aiutato a salvare i byte hella

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

Non sono bravo con Brainfuck, quindi sono sicuro che esiste una soluzione più breve, ma funziona decrementando sotto 0, facendo rotolare il byte e continuando fino a quando non scende fino ad "A", quindi stampa.

JavaScript (ES6), 21 byte

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

Inizialmente ho provato a convertire falsein stringa per farlo, ma in quel momento mi ci sono voluti 23 byte. Da allora ho escogitato un modo più breve, che è questo per 14 byte:

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

Non penso che tu possa ottenere maiuscole in Abase alle regole, dal momento che hai bisogno di una String.fromCharCodeo .toUpperCase()entrambe, che contengono a.

C, (19?) 24 byte

Grazie a Dennis:

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

stessa lunghezza:

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

che consente anche le lettere minuscole:

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

Esiste una soluzione di 19 byte come funzione che modifica il suo parametro, che presenta un difetto:

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

//Usage:

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

Se è cstato dichiarato char, gmodifica il tutto in intmodo da distruggere lo stack causando la modifica di altri valori o l'interruzione del programma con un messaggio di errore. L'unico modo per aggirare è quello di dichiarare int c;in maine stampare con "%c", ma che si sente come una scappatoia.

soluzioni più vecchie

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

Solo una funzione, poiché mainè vietato.

dc, 4 byte

833P

L'overflow di UCHAR_MAX rotola attraverso la tabella sei tre volte prima di atterrare a 65.

Lua, 36 byte

Questo mi ha portato un po 'che molte delle funzioni standard Lua sono portati via dalle regole (tutti math, string.char, string.match, pairs, anche next)

Questo sfrutta il fatto che Lua ha un globale _VERSIONche di solito inizia con "Lua" (ad esempio, Lua 5.1o simile per altre versioni), quindi a meno che questo non sia eseguito su un interprete non tradizionale, il terzo personaggio sarà una "a"

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

La {...}[3]è di raggruppare i risultati di findche include anche gli indici dove abbinato, e quindi tornare il terzo elemento che è il carattere corrispondente (la a)

Haskell, 10 byte

Come funzione (o piuttosto un'istruzione in quanto non è richiesto alcun input)

f=pred 'B'

fa il trucco. Provalo su Ideone. Un programma completo è impossibile in quanto ciò dovrebbe contenere a main.

Brachylog , 4 byte

@Ztw

Provalo online!

Spiegazione

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

dc, 8 7 byte

-1B grazie a Dennis

88 23-P

Spinge 88, spinge 23, sottrae, lasciando 65. Stampa la parte superiore dello stack (65) come una stringa ASCII, senza riga finale.

Modificare:

Questi sono alcuni degli altri modi in cui mi sono inventato. Fondamentalmente è diventato un gioco di "generare i numeri 65 e 97 usando solo [238B-F]e senza aggiunta". Ironia della sorte, trovo i più lunghi più interessanti.

_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