Écrivez un bloc carré de code de N caractères de large et de N caractères de haut, pour un entier positif N.

Par exemple, votre N peut être 5 et le bloc ressemble à ceci:

ThisI
sMy5B
y5Cod
eBloc
kOkay

Ce bloc doit se comporter comme suit:

1. Lorsque la ligne du haut est extraite et exécutée en tant que programme, le texte exact rowdoit être imprimé sur stdout.

   Par exemple, ThisIimprimerait row.

2. Lorsque la colonne de gauche est extraite et exécutée en tant que programme, le texte exact coldoit être imprimé sur stdout.

   Par exemple, Tsyekimprimerait col.

3. Lorsque la diagonale principale du coin supérieur gauche au coin inférieur droit est extraite et exécutée en tant que programme, le texte exact diadoit être imprimé sur stdout.

   Par exemple, TMCoyimprimeraitdia.

4. Lorsque le bloc entier est exécuté en tant que programme, y compris les sauts de ligne (avec un saut de ligne facultatif), le texte exact blkdoit être imprimé sur stdout.

   Par exemple,

   ThisI
   sMy5B
   y5Cod
   eBloc
   kOkay
   

   imprimerait blk.

Détails

• Les quatre programmes sont exécutés dans le même langage de programmation.
• Les N ² caractères du bloc d'origine peuvent être tout sauf des terminateurs de ligne .
• Si votre langue n'a pas de sortie standard, vous pouvez utiliser une autre méthode de sortie courante. Il doit s'agir de la même méthode pour les quatre programmes.

La soumission dont le bloc d'origine contient le moins de caractères distincts (sans compter les nouvelles lignes) gagne. Tiebreaker va à la soumission avec le plus petit N.

> <> (Poisson) , 3 caractères uniques (N = 2000)

Le code utilise 1et -pour mettre des nombres arbitraires sur la pile et ppour (auto-) modifier le code en fonction des 3 premiers chiffres de la pile. Par exemple, mettre une !position at 0 0ressemblerait 003b*pà normal> <> et avecp1- elle devient 111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--11-11-p.

Après la modification, le pointeur d'instruction (IP) entoure le code et exécute la partie modifiée. Dans le cas "bloc", l'adresse IP est redirigée pour une modification ultérieure (puis redirigée vers l'arrière) pour différer du cas "ligne". Dans le cas de la "ligne", les deux mêmes redirection se produisent mais il n'y a pas de code entre elles donc elles n'ont aucun effet.

Les codes finaux générés pour les 4 cas (en omettant les p1-parties inchangées ):

row:      "wor"\ooo;

column:   "loc"ooo;

diagonal: "dia"ooo;

block:    "wor"\"klb"ooo;

La taille du code est de 4 Mo et le code est accessible ici . (Il n'y a aucune difficulté à l'exécuter.)

Le programme générateur python3 est accessible ici .

CJam, 13 12 caractères uniques, N = 5

"row"
cd;"a
oaiaa
l"aa;
"blk"

Aussi simple que possible

MISE À JOUR : espace converti en a(no-op dans ce cas) comme indiqué par Runner112

Essayez-le en ligne ici

Bash, 19 caractères uniques, N = 19

trap echo\ row exit
t=t trap exit      
t=t echo blk       
exit               
=                  
t    e             
      c            
e      h           
c       o          
h                  
o         d        
           i       
c           a      
o                  
l                  

• La première ligne est trap echo\ row exit. Cela provoque echo rowl'exécution lorsque le script se termine (juste la première ligne)
• La première colonne est ttt=t echo col
• La diagonale est t=tt echo dia
• Le bloc complet fonctionne en annulant le gestionnaire EXIT configuré dans la première ligne, echo blkpuis quitte.

> <> , 14 caractères uniques, N = 10

"wor"\ooo;
     "    
l a  k    
o  i l    
c   db    
"    "    
o    oo   
o    o o  
o    o  o 
;    ;   ;

Assez simple dans un langage 2D. La seule partie délicate est que nous devons \distinguer entre rowet blk.

Brainfuck, 2 personnages uniques, N = 378

Avec une légère flexion possible des règles.

Le programme est un peu gros, voici donc un lien vers celui-ci sur Pastebin .

Le row, coletdia les programmes sont simples. Ils incrémentent simplement la cellule d'octets jusqu'à ce que le bon code ASCII soit atteint, puis sort. Si la lettre est déjà passée, elle incrémente jusqu'à ce que la cellule déborde afin qu'elle puisse recommencer à 0.

Le blkprogramme est l'endroit où la légère flexion des règles se produit. Afin d'imprimer le "texte exact blk" comme demandé dans le défi, des espaces arrière sont utilisés (code ASCII 8), ce qui nécessite que la console / le terminal d'affichage le prenne en charge. Chaque fois que des valeurs erronées des programmes row/ col/ diasont imprimées, je m'assure qu'elles sont supprimées en sortant quelques codes de contrôle de retour arrière. Pour simplifier les choses, je me suis assuré que toutes les valeurs erronées produites à un moment donné font partie de la plage ASCII imprimable.

C (gcc) , 26 caractères uniques, N = 29

*w;main(){printf(w?w:"row");}
ww;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;/*;;;;;;;;;;;;;;;;;;;;;;;;
m;;m;;;;;;;;;;;;;;;;;;;;;;;;;
a;;;a;;;;;;;;;;;;;;;;;;;;;;;;
i;;;;i;;;;;;;;;;;;;;;;;;;;;;;
n;;;;;n;;;;;;;;;;;;;;;;;;;;;;
(;;;;;;(;;;;;;;;;;;;;;;;;;;;;
);;;;;;;);;;;;;;;;;;;;;;;;;;;
{;;;;;;;;{;;;;;;;;;;;;;;;;;;;
p;;;;;;;;;p;;;;;;;;;;;;;;;;;;
r;;;;;;;;;;r;;;;;;;;;;;;;;;;;
i;;;;;;;;;;;i;;;;;;;;;;;;;;;;
n;;;;;;;;;;;;n;;;;;;;;;;;;;;;
t;;;;;;;;;;;;;t;;;;;;;;;;;;;;
f;;;;;;;;;;;;;;f;;;;;;;;;;;;;
(;;;;;;;;;;;;;;;(;;;;;;;;;;;;
";;;;;;;;;;;;;;;;";;;;;;;;;;;
c;;;;;;;;;;;;;;;;;d;;;;;;;;;;
o;;;;;;;;;;;;;;;;;;i;;;;;;;;;
l;;;;;;;;;;;;;;;;;;;a;;;;;;;;
";;;;;;;;;;;;;;;;;;;;";;;;;;;
);;;;;;;;;;;;;;;;;;;;;);;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
};;;;;;;;;;;;;;;;;;;;;;;};;*/
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;*w="blk";

Essayez-le en ligne!

Ruby, 24 caractères uniques, N = 17

trap(0){$><<:row}
rr=a=:blk;%;00000
a0a00000000000000
p00p0000000000000
(000(000000000000
00000000000000000
)00000)0000000000
{000000{000000000
$0000000$00000000
>00000000>0000000
<000000000<000000
<0000000000<00000
:00000000000:0000
c000000000000d000
o0000000000000i00
l;;trap(0){$><<a;
};000000000000;{}

Essayez-le en ligne!