Dies ist eine quine Variante.

Einführung

Wir alle schreiben kurzen Code, weil einige Gründe unklar sind , aber was auch immer wir tun, das wird mindestens 144 Pixel / Byte (mit einer 12px-Schriftart) in Anspruch nehmen. Aber was würde passieren, wenn wir unseren Code in Bildern verschlüsseln würden? Dies ist heute Ihre Aufgabe.

Herausforderung

Ihre Aufgabe ist es, Ihren eigenen Quellcode einzulesen (nicht korrekte Quines sind zulässig, z. B. das buchstäbliche Lesen der Quelldatei) und daraus ein Bild zu erstellen, indem Sie die roten, grünen und blauen Komponenten eines Pixels basierend auf dem ASCII-Code festlegen Wert des Zeichens.

Beispiel:

Wir haben die Zeichenfolge "Hallo Welt!"

Hello world!

Lassen Sie uns dies in ASCII-Werte konvertieren:

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

Ordnen Sie die RGB-Werte zu (Wenn die Länge des Quellcodes nicht durch 3 teilbar ist, verwenden Sie 0s als verbleibende Zeichen):

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

Wir erstellen dann das Bild mit dem kleinsten Bereich daraus. Wir haben 4 Sätze von RGB-Werten, so dass das kleinste Bild ein 2 * 2-Bild ist, das vom oberen linken Pixel nach rechts verläuft:

Und wir bekommen dieses schrecklich farbige Bild (verkleinert, so dass es zumindest sichtbar ist, beweist auch, wie klein es werden kann)

Regeln / Zusatzinformationen

• Es gibt keine Eingabe
• Die Ausgabe sollte als separate Datei oder in einem separaten Fenster erfolgen.
• Teilen Sie bei Multibyte-Zeichen das Zeichen in 2 Bytes.
• Der Quellcode muss mindestens 1 Byte lang sein
• Das Bild sollte diejenige von den möglichen Größen sein, die das engste Breiten- / Höhenverhältnis zu 1 hat
• Die Pixelanzahl auf dem Bild sollte genau Ceil (Byteanzahl / 3) sein. Es sollten keine zusätzlichen Pixel hinzugefügt werden

Wertung

Dies ist ein Code-Golf , also gewinnt die kleinste Antwort in Bytes.

Eigentlich 12 Bytes

Q"P6 4 1 255

Probieren Sie es online!

Dieses Programm funktioniert auch in Seriously.

Dieses Programm gibt ein PPM-Bild aus , das standardmäßig akzeptabel ist .

Ausgabebild (50x vergrößert):

Erläuterung:

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 Bytes

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

Dadurch wird eine anonyme Funktion erstellt, die in das Befehlsfenster eingefügt und mit ausgeführt werden kann ans(). Bei der Ausführung wird ein Bild mit 23 Pixeln (eine Primzahl) erstellt. Die quadratischste Darstellung ist daher ein einfaches Array von Pixeln.

Erläuterung

Beim Einfügen in das Befehlsfenster wird die anonyme Funktion automatisch der Variablen zugewiesen ans. Dann verwenden wir innerhalb der anonymen Funktion:

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

Dies wird char(ans)im Namespace des Befehlsfensters und nicht im lokalen Namespace der anonymen Funktion ausgewertet . Es ist daher in der Lage, die anonyme Funktion selbst in eine Zeichenfolgendarstellung umzuwandeln.

Dann haben wir die folgenden Operationen, die einfacher sind:

%// 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 Bytes

Ich bin mir sicher, dass man ein bisschen Golf spielen könnte:

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'))}

• Erstellt eine Leinwand
• baut darin ein Bild auf
• Öffnet die Daten-URL für das Bild in einem neuen Tab

Neue Zeilen für die Lesbarkeit:

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'))
}

Ausgabe

Javascript ES6 - 216 Bytes

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)

Ungolfed:

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

Hinweis: fGibt eine Leinwand zurück.

Beispiellauf (setzt voraus, dass ein <body>angehängt werden muss):

document.body.appendChild(f())

Sollte das folgende Bild auf der Seite ablegen (vergrößert):

PowerShell v4, 64 Byte

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

Es ruft den Inhalt seines eigenen Dateinamens ab, wandelt den String in ein Zeichen-Array um, fügt einen PPM-Header hinzu und setzt den Inhalt als Ausgabe auf a.ppm. 64 Bytes ergeben 11x2 Pixel:

Node.js, 63 Bytes

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

Gibt das Bild in eine Datei mit dem Namen aus, P6die im PPM- Format (P6) vorliegt.

Hier ist eine PNG-Wiedergabe (7x3 Pixel):

PHP, 226 Bytes

Golf gespielt

<?$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);

Ungolfed-Version

<?
// 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);

Geben Sie dieses Skript in eine Datei mit dem Namen 'p.php' ein und führen Sie es aus. Sie benötigen eine eigene Methode zum Ausführen von PHP-Skripten, da diese aus einer lokalen Datei lesen.

Ausgabebild:

Java 511 Zeichen

Die Länge der Lösung führt zu einem größeren Bild, das cool ist, weil diese Bilder wirklich schön sind.

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"));}}

Beachten Sie, dass es eine unsichtbare nachgestellte Zeile gibt! Es liest die Quelldatei, die "Q.java" sein muss, und erstellt ein Bild "Q.png", das so aussieht:

oder 100x skaliert

APL (Dyalog) , 33 Bytes

Benötigt, ⎕IO←0was auf vielen Systemen Standard ist. Außerdem sollte AutoFormat ausgeschaltet sein, um das Programm genau so zu erhalten, wie es angegeben ist.

(⊂⎕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}}

Erstellt P: _{^{P3 11 1 255 185 186 253 78 80 85 84 187 248 13 80 13 194 205 253 65 86 178 13 3 11 1 255 13 194 187 200 253 78 82 13 22 13}} Zum
Speichern und Ablegen hier klicken:

⎕NR'f' N sierte R ePresentation des Programms f

⊃⌽ wähle das letzte (lit. first des umgekehrten) Elements (Zeile)

'␍ɫ␉⍣', voranstellen der vier Zeichen (Dateityp, Breite, Höhe, max)

⎕AV⍳ Entsprechende Indizes finden Sie im A tomic V ector (Zeichensatz)

⍕ Format als Text

'P', einen Brief voranstellen

(… ) Wenden folgende stillschweigende Funktion an:

 ⊂ nimm das ganze Argument [und in ein]

 ⎕NPUT N ative [file,] Put [it, mit einem Dateinamen bestehend aus]

 ⊃ das erste Zeichen ("P")

Python, 81 Bytes

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

Die Ausgabe erfolgt im PPM-Format.

So sieht das Bild aus:

Skaliert: