Il s'agit d'une variation quine .

introduction

Nous écrivons tous du code court, car des raisons obscures , mais quoi que nous fassions, cela prendra au moins 144 pixels / octet (avec une police de 12 pixels). Mais que se passerait-il si nous encodions notre code en images? Telle est votre tâche aujourd'hui.

Défi

Votre tâche consiste à lire votre propre code source (les quines non appropriés sont autorisés, par exemple en lisant littéralement le fichier source), et à en créer une image, en définissant les composants rouge, vert et bleu d'un pixel en fonction de l'ASCII valeur du caractère.

Exemple:

Nous avons la chaîne "Hello world!"

Hello world!

Convertissons ceci en valeurs ASCII:

72 101 108 108 111 32 119 111 114 108 100 33

Mappez-y les valeurs RVB (si la longueur du code source n'est pas divisible par 3, utilisez 0 comme caractères restants):

 __________________________________________________
| R | G | B || R | G | B || R | G | B || R | G | B |
----------------------------------------------------
|72 |101|108||108|111|32 ||119|111|114||108|100|33 |
----------------------------------------------------

Nous créons ensuite l'image avec la plus petite zone. Nous avons 4 ensembles de valeurs RVB, donc la plus petite image sera une image 2 * 2, allant du pixel supérieur gauche vers la droite:

Et nous obtenons cette image terriblement colorée (redimensionnée, donc au moins visible, prouve également à quel point elle peut devenir petite)

Règlement / Informations complémentaires

• Il n'y a pas d'entrée
• La sortie doit être dans un fichier séparé ou dans une fenêtre distincte.
• Pour les caractères multi-octets, divisez le caractère en 2 octets.
• Le code source doit être d'au moins 1 octet
• L'image doit être celle parmi les tailles possibles, qui a le rapport largeur / hauteur le plus proche de 1
• Le nombre de pixels sur l'image doit être exactement ceil (nombre d'octets / 3), aucun pixel supplémentaire ne doit être ajouté

Notation

Il s'agit d'un code-golf , donc la plus petite réponse en octets l'emporte.

En fait, 12 octets

Q"P6 4 1 255

Essayez-le en ligne!

Ce programme fonctionne également dans Sérieusement.

Ce programme génère une image PPM , ce qui est acceptable par défaut .

Image de sortie (agrandie 50x):

Explication:

Q"P6 4 1 255 
Q             push source code
 "P6 4 1 255  push header for a 4x1 raw (type P6) 8-bit PPM image (the closing " is implicitly added at EOF)

MATLAB, 81 72 69 octets

@()image(shiftdim(reshape(evalin('base','char(ans)'),3,1,23)/255,1.))

Cela crée une fonction anonyme qui peut être collée dans la fenêtre de commande et exécutée à l'aide de ans(). Lorsqu'il est exécuté, cela crée une image de 23 pixels (un premier) donc la représentation la plus carrée est un simple tableau de pixels.

Explication

Lorsqu'elle est collée dans la fenêtre de commande, la fonction anonyme s'assigne automatiquement à la variable ans. Ensuite, dans la fonction anonyme, nous utilisons:

evalin('base', 'char(ans)')

qui évalue char(ans)dans l'espace de noms de la fenêtre de commande plutôt que dans l'espace de noms local de la fonction anonyme. Il est donc capable de convertir la fonction anonyme elle-même en une représentation sous forme de chaîne.

Ensuite, nous avons les opérations suivantes qui sont plus simples:

%// Reshape the result into a 3 x 1 x 23 matrix where the first dimension is RGB
%// due to column-major ordering of MATLAB
R = reshape(string, 3, 1, 23);

%// Divide the result by 255. This implicitly converts the char to a double
%// and in order for RGB interpreted properly by MATLAB, doubles must be
%// normalized between 0 and 1.
R = R / 255;

%// Shift the dimensions to the left 1 to move the RGB channel values into
%// the third dimension. Note the extra decimal point. This is because it
%// is far shorter to lengthen the code by one byte than to pad the string
%// to give us a length divisible by 3
R = shiftdim(R, 1.);

%// Display the RGB image
image(R);

Javascript (ES6) 324 312 309 octets

Je suis sûr que cela pourrait être un peu joué au golf:

f=()=>{s="f="+f;l=s.length/3;c=document.createElement('canvas');for(i=0;++i<l/i;l%i?0:w=i,h=l/w);c.s=c.setAttribute;c.s("width",w);c.s("height",h);(i=(t=c.getContext('2d')).createImageData(w,h)).data.map((a,b)=>i.data[b]=b%4<3?s.charCodeAt(b-~~(b/4)):255);t.putImageData(i,0,0);open(c.toDataURL('image/png'))}

• crée une toile
• construit l'image en elle
• Ouvre l'url de données pour l'image dans un nouvel onglet

Nouvelles lignes pour la lisibilité:

f=()=>{
    s="f="+f;l=s.length/3;
    c=document.createElement('canvas');
    for(i=0;++i<l/i;l%i?0:w=i,h=l/w);
    c.s=c.setAttribute;
    c.s("width",w);
    c.s("height",h);
    (i=(t=c.getContext('2d')).createImageData(w,h)).data.map((a,b)=>i.data[b]=b%4<3?s.charCodeAt(b-~~(b/4)):255);
    t.putImageData(i,0,0);
    open(c.toDataURL('image/png'))
}

Production

Javascript ES6 - 216 octets

f=(  )=>((d=(x=(v=document.createElement`canvas`).getContext`2d`).createImageData(v.width=9,v.height=8)).data.set([..."f="+f].reduce((p,c,i)=>(c=c.charCodeAt(0),[...p,...i%3<2?[c]:[c,255]]))),x.putImageData(d,0,0),v)

Non golfé:

f=(  )=>(                                           // define function f (extra spaces to account for missing pixel + alpha channel calculation)
 (d=(x=(v=document.createElement`canvas`).          // assign html5 canvas to v
          getContext`2d`).                          // assign graphics context to x
          createImageData(v.width=9,v.height=8)).   // create & assign ImageData to d
                                                    //   set width and height of both d and v
 data.set([..."f="+f].                              // get f's source, convert to array of chars
   reduce((p,c,i)=>(c=c.charCodeAt(0),              // convert char array to int array
                    [...p,...i%3<2?[c]:[c,255]]))), // insert alpha values 255
 x.putImageData(d,0,0),                             // draw source RGBA array to canvas
 v)                                                 // return canvas

Remarque: frenvoie un canevas.

Exemple d'exécution (suppose qu'il y a un <body>à ajouter):

document.body.appendChild(f())

Devrait vider l'image suivante sur la page (agrandie):

PowerShell v4, 64 octets

"P6 11 2 255"+[char[]](gc $MyInvocation.MyCommand.Name)|sc a.ppm

Il obtient le contenu de son propre nom de fichier, convertit la chaîne en un tableau de caractères, ajoute un en-tête PPM et définit le contenu sur a.ppm en sortie. 64 octets en fait 11x2 pixels:

Node.js, 63 octets

(F=x=>require('fs').writeFile('P6','P6 7 3 255 (F='+F+')()'))()

Exporte l'image dans un fichier nommé P6qui se trouve dans le PPM format (P6).

Voici un rendu PNG (7x3 pixels):

PHP, 226 octets

Golfé

<?$b=strlen($w=join(file('p.php')));$z=imagecreatetruecolor(5,15);for($c--;++$c<$b+1|$i%3;$i%3?:$a=!imagesetpixel($z,$x%5,(int)$x++/5,$a))$a+=($c<$b?ord($w[$c]):0)*256**(2-$i++%3);header("Content-Type:image/png");imagepng($z);

Version non golfée

<?
// Read the file into an array and join it together. Store the length of the resulting string.
$b=strlen($w=join(file('p.php')));

// Create the image. Our file is 226 bytes, 226/3 = 75 = 5 * 15
$z=imagecreatetruecolor(5,15);

// Loop through the script string, converting each character into a pixel.
// Once three characters have been converted, draw the pixel with the converted RGB value and reset the color to 0.
for($c--;++$c<$b+1|$i%3;$i%3?:$a=!imagesetpixel($z,$x%5,(int)$x++/5,$a))$a+=($c<$b?ord($w[$c]):0)*256**(2-$i++%3);

// Tell the program we're sending an image
header("Content-Type:image/png");

// And send it!
imagepng($z);

Entrez ce script dans un fichier nommé 'p.php' et exécutez-le. Vous avez besoin de votre propre méthode d'exécution du script PHP, car elle lit à partir d'un fichier local.

Image de sortie:

Caractères Java 511

La longueur de la solution conduit à une image plus grande, ce qui est cool, car ces images sont vraiment belles.

import java.awt.image.*;import java.io.*;import java.nio.file.*;import javax.imageio.*; public class Q{public static void main(String[]a)throws Throwable{int w=19,h=9;byte[]e=Files.readAllBytes(Paths.get("Q.java"));String t=new String(e);while(t.length()%3!=0)t+='\0';BufferedImage I=new BufferedImage(w,h,BufferedImage.TYPE_INT_RGB);int r,c=r=0;for(int i=0;i<t.length();i++){I.setRGB(c,r,255<<24|t.charAt(i)<< 16|t.charAt(++i)<< 8|t.charAt(++i));if(++c==w){c=0;r++;}}ImageIO.write(I,"png",new File("Q.png"));}}

Notez qu'il existe une nouvelle ligne de fin invisible! Il lit le fichier source, qui doit être "Q.java" et crée une image "Q.png" qui ressemble à ceci:

ou à l'échelle 100x

APL (Dyalog) , 33 octets

Requiert ⎕IO←0ce qui est par défaut sur de nombreux systèmes. En outre, la mise en forme automatique doit être désactivée pour conserver le programme exactement comme indiqué.

(⊂⎕NPUT⊃)'P',⍕⎕AV⍳'␍ɫ␉⍣',⊃⌽⎕NR'f'  

Hex _{^{B9 BA FD 4E 50 55 54 BB F8 0D 50 0D C2 CD FD 41 56 B2 0D 03 0B 01 FF 0D C2 BB C8 FD 4E 52 0D 16 0D}}
Unicode _{^{28 2282 2395 4E 50 55 54 2283 29 27 50 27 2C 2355 2395 41 56 2373 27 0D 026B 08 2363 27 2C 2283 233D 2395 4E 52 27 66 27}}

Crée P: _{^{P3 11 12555185186253 78 80 85 84187248 13 80 13194205253 65 86178 13 3 11 1255 13194187200253 78 82 13 22 13 que}}
vous enregistrez et déposez ici pour voir:

⎕NR'f' N ested R ePresentation du programme f

⊃⌽ choisissez le dernier (allumé premier de l'élément inversé) (ligne)

'␍ɫ␉⍣', ajouter les quatre caractères (type de fichier, largeur, hauteur, max)

⎕AV⍳ trouver des indices correspondants dans la A tomic V ecteur (le jeu de caractères

⍕ format comme texte

'P', ajouter une lettre

(… ) Appliquez la fonction tacite suivante:

 ⊂ prendre tout l'argument [et dans un]

 ⎕NPUT N atif [fichier,] Mettez- le, avec un nom de fichier composé de]

 ⊃ le premier caractère ("P")

Python, 81 octets

q=open(__file__).read()
print'P3\n9 3 256 '+' '.join(map(lambda x:str(ord(x)),q))

La sortie est au format PPM.

Voici à quoi ressemble l'image:

Élargis: