Mission ist einfach. Geben Sie einfach die Nummer 2015 als QR-Code aus und schreiben Sie sie in eine Datei newyear.pngim PNG-Format. Der Code muss jeden Tag gültig sein, daher sollten Sie möglicherweise das aktuelle Jahr nicht verwenden.

QR-Code als Text sieht so aus:

# # # # # # #   # # # #     # # # # # # #
#           #           #   #           #
#   # # #   #   # #     #   #   # # #   #
#   # # #   #       #   #   #   # # #   #
#   # # #   #       #   #   #   # # #   #
#           #               #           #
# # # # # # #   #   #   #   # # # # # # #
                #   # #
#   #     # #     # #     # #       #   #
  # # #   #   #   #   # #   #     #   # #
#   # #   # # #   # # # # # #   #       #
# # #         # #         # # # #
# # # # #   #   #     #     #   #     #
                      # # # #
# # # # # # #       #   # #   # #   #   #
#           #   #         # # # #
#   # # #   #         #     #   #     #
#   # # #   #     #     # # # # #
#   # # #   #   #   #   # #   # #   #   #
#           #     # #       # # #   # # #
# # # # # # #   #           #   #   #   #

Das eingeschriebene Ergebnis newyear.pngmuss den QR-Code mit weißen 5-Pixel-Rändern und 1-Pixel-Punkten enthalten. Es darf nichts anderes als QR-Code enthalten.

Raw-Datei, 184 Bytes = 173-Byte-Datei + 11-Byte-Dateiname

Ich hoffe das bricht keine Standardlücken. Aber die Ausgabe "hat eine hohe Kolmogorov-Komplexität und der kürzeste Weg, sie zu produzieren, wäre (höchstwahrscheinlich), sie nur im wörtlichen Sinne zu drucken ...".

Basis 64 der Datei:

iVBORw0KGgoAAAANSUhEUgAAAB8AAAAfAQAAAAA31SuUAAAAdElEQVR4XnXOMQ5BQRRA0euVRFgGCq1ubIyJpSh11I
qJWIjo+fnt/JnJe55WornlycXMVAB+Qp49A7U/J8rqlIQReG5Quz6Rx8eA6VaF5R7a5arooXg2LaKvd8KGRyBPJLoy
D640pxZ3pay/creL5KnEvwcfvE46ggJMibIAAAAASUVORK5CYII=

Anstatt ein Programm zu spielen, habe ich das resultierende PNG-Bild gespielt. QR-Code ist ein sehr flexibles Format, es gibt viele Parameter, an denen gefummelt werden kann: die Codierung der Eingabe, die Fehlerkorrekturstufe und das Maskierungsbild. Diese erzeugen alle unterschiedliche Symbole und werden so zu Dateien unterschiedlicher Größe komprimiert.

Also habe ich ein Programm geschrieben, um alle diese Kombinationen (die 6720 Dateien ergeben) zu generieren und dann mit PNGOUT diejenige auszuwählen, die auf die kleinste Datei komprimiert wurde. Es stellt sich heraus, dass es sich um eine Datei handelt, die:

• Schreiben Sie zuerst "20" im alphanumerischen Modus
• Dann schreiben Sie "1" im numerischen Modus
• Dann schreiben Sie "5" im numerischen Modus
• Verwenden Sie die Fehlerkorrekturstufe "H" (Hoch)
• Verwenden Sie die Datenmaskierung "110"

Dies wird aufgerufen, test-3-1-H-Diamonds.bmpwenn Sie das folgende Programm verwendet haben. Dieses Image ist 175 Byte lang, nachdem PNGOUT ausgeführt wurde. Mit der "hohen" Fehlerkorrekturstufe im QR-Code "Version 1" können wir bis zu 8 Pixel im Datenteil ändern, ohne die Daten zu beschädigen. Mit ein bisschen manuellem Ausprobieren kann ich es weiter auf 173 Bytes reduzieren, die oben dargestellt wurden. Es kann wahrscheinlich kleiner sein, aber für die Erschöpfung aller Kombinationen sind ²⁰⁸ C ₈ ~ 7,5 × 10 ¹³ Prüfungen erforderlich , die ich nicht ausführen werde;)

Das Programm Rust (0.13.0-nightly (5ba610265)), das alle Kombinationen generiert:

/* 

Also put these into your Cargo.toml: 

[dependencies]
qrcode = "0.0.3"
bmp = "0.0.3"

*/

extern crate qrcode;
extern crate bmp;

use qrcode::bits::Bits;
use qrcode::optimize::Segment;
use qrcode::types::{Version, EcLevel, Mode};
use qrcode::ec::construct_codewords;
use qrcode::canvas::{Canvas, MaskPattern, Module};

use bmp::{Image, Pixel};

use std::num::Int;

const BLACK: Pixel = Pixel { r: 0, g: 0, b: 0};
const WHITE: Pixel = Pixel { r: 255, g: 255, b: 255 };

static SEGMENT_SEPARATIONS: [&'static [(uint, uint)]; 8] = [
    &[(0, 1), (1, 2), (2, 3), (3, 4)],
    &[(0, 1), (1, 2), (2, 4)],
    &[(0, 1), (1, 3), (3, 4)],
    &[(0, 2), (2, 3), (3, 4)],
    &[(0, 1), (1, 4)],
    &[(0, 2), (2, 4)],
    &[(0, 3), (3, 4)],
    &[(0, 4)],
];

const ALL_EC_LEVELS: &'static [EcLevel] = &[EcLevel::L, EcLevel::M, EcLevel::Q, EcLevel::H];
const ALL_MODES: &'static [Mode] = &[Mode::Numeric, Mode::Alphanumeric, Mode::Byte];
const ALL_MASK_PATTERNS: &'static [MaskPattern] = &[
    MaskPattern::Checkerboard,
    MaskPattern::HorizontalLines,
    MaskPattern::VerticalLines,
    MaskPattern::DiagonalLines,
    MaskPattern::LargeCheckerboard,
    MaskPattern::Fields,
    MaskPattern::Diamonds,
    MaskPattern::Meadow,
];

fn run(ec_level: EcLevel, mask_pattern: MaskPattern, segments: &[Segment], filename: &str) {
    let version = Version::Normal(1);
    let mut bits = Bits::new(version);
    if bits.push_segments(b"2015", segments.iter().map(|s| *s)).is_err() {
        return;
    }
    if bits.push_terminator(ec_level).is_err() {
        return;
    }
    let data = bits.into_bytes();
    let (encoded_data, ec_data) = construct_codewords(&*data, version, ec_level).unwrap();
    let mut canvas = Canvas::new(version, ec_level);
    canvas.draw_all_functional_patterns();
    canvas.draw_data(&*encoded_data, &*ec_data);
    canvas.apply_mask(mask_pattern);
    let canvas = canvas;

    let width = version.width();
    let real_image_size = (width + 10) as uint;
    let mut image = Image::new(real_image_size, real_image_size);
    for i in range(0, real_image_size) {
        for j in range(0, real_image_size) {
            image.set_pixel(i, j, WHITE);
        }
    }
    for i in range(0, width) {
        for j in range(0, width) {
            if canvas.get(i, j) == Module::Dark {
                image.set_pixel((i + 5) as uint, real_image_size - (j + 6) as uint, BLACK);
            }
        }
    }
    image.save(filename);
}

fn main() {
    for (z, separations) in SEGMENT_SEPARATIONS.iter().enumerate() {
        let mut segments = separations.iter().map(|&(b, e)| Segment {
            mode: Mode::Numeric, begin: b, end: e
        }).collect::<Vec<_>>();

        let variations_count = ALL_MODES.len().pow(segments.len());
        for i in range(0, variations_count) {
            let mut var = i;
            for r in segments.iter_mut() {
                r.mode = ALL_MODES[var % ALL_MODES.len()];
                var /= ALL_MODES.len();
            }
            for ec_level in ALL_EC_LEVELS.iter() {
                for mask_pattern in ALL_MASK_PATTERNS.iter() {
                    let filename = format!("results/test-{}-{}-{}-{}.bmp", z, i, *ec_level, *mask_pattern);
                    run(*ec_level, *mask_pattern, &*segments, &*filename);
                }
            }
        }
        println!("processed {}/{}", z, 8u);
    }
}

Mathematica, 217 177 176 166 Bytes

Hier ist ein Anfang:

"newyear.png"~Export~ImagePad[Image[IntegerDigits[36^^fl6ibg25c8z00uef53p4657dgd6hjzg41e5joead1qgz0l2xchqgso5r1a51v5no4zkw9v22okk‌​lg0cymmy2,2,441]~Partition~21],5,1]

Weniger Golf:

"newyear.png"~Export~ImagePad[
 Image[
  IntegerDigits[
    36^^fl6ibg25c8z00uef53p4657dgd6hjzg41e5joead1qgz0l2xchqgso5r1a51v5no4zkw9v22okk‌​lg0cymmy2,
    2,
    441
  ]~Partition~21
 ],
 5,
 1
]

Der QR-Code ist in einer Basis 36-Nummer codiert. Natürlich könnte ich es in erweitertem ASCII (Basis 256) codieren, aber das würde die Zeichenfolge nur um 30 Byte verkürzen, und ich bin nicht sicher, ob ich die Konvertierung zu einem viel geringeren Preis durchführen kann.

Das ist natürlich Mathematica, also gibt es auch das 63-Byte

"newyear.png"~Export~ImagePad[BarcodeImage["2015","QR",21],5,1]

aber ich denke, das ist eine Standardlücke. ;) (Dies erzeugt einen anderen QR-Code als der in der Challenge, also denke ich, dass der QR-Code nicht eindeutig ist?)

Matlab 545 Bytes

In mühsamer Handarbeit und ohne ausgefallene eingebaute Komprimierung / Konversation fest programmiert . Ich weiß, es ist immer noch nicht so gut wie die anderen Antworten, aber ich bin immer noch glücklich =)

b=[[61:67,69,71:73,75:81,92,98]+100,
    1,3:4,6,12,23,25:27,29,31:35,37,39:41,43,54,56:58,60,63:64,66,68,70:72,74,85,87:89,91,97,99]+200,
    [1:3,5,16,22,24:26,30,36,47:53,55,57,59,61:67,87:89]+300,
    [9,11,15:16,20:21,24,27,29,40,42,48:50,57,59,71,74:75,77:79,81,85,89:90]+400,
    [2,9,11:12,14:15,18,34:37,39,42:43,46:47,50:51,72,74:75,77:79,81:82,95:99]+500,
    [0:1,3:8,10:12,14:15,26,32,37,40:41,43:45,57,59:61,63,67:69,71:77,88,90:92,94,97]+600,
    [19,21:23,25,27,33,37:39,50,56,59,62,66,69,81:87,89:91,95,99:101]+700];
z=zeros(31);z(b)= 1;imwrite(~z,'newyear.png')

Unleserlicher (die aktuelle 545-Version):

z=zeros(31);
z([
    [61:67, 69, 71:73, 75:81, 92, 98] + 100,
    [1, 3:4, 6, 12, 23, 25:27, 29, 31:35, 37, 39:41, 43, 54, 56:58, 60, 63:64, 66, 68, 70:72, 74, 85, 87:89, 91, 97, 99] + 200,
    [1:3, 5, 16, 22, 24:26, 30, 36, 47:53, 55, 57, 59, 61:67, 87:89] + 300,
    [9, 11, 15:16, 20:21, 24, 27, 29, 40, 42, 48:50, 57, 59, 71, 74:75, 77:79, 81, 85, 89:90] + 400,
    [2, 9, 11:12, 14:15, 18, 34:37, 39, 42:43, 46:47, 50:51, 72, 74:75, 77:79, 81:82, 95:99] + 500,
    [0:1, 3:8, 10:12, 14:15, 26, 32, 37, 40:41, 43:45, 57, 59:61, 63, 67:69, 71:77, 88, 90:92, 94, 97] + 600,
    [19, 21:23, 25,27, 33, 37:39, 50, 56, 59, 62, 66, 69, 81:87, 89:91, 95, 99:101] + 700
])= 1;
imwrite(~z,'newyear.png')

Wir erstellen eine 31 x 31-Nullmatrix, greifen aber als Vektor darauf zu, um alle Zellen mit den Indizes von bbis zu setzen 1. Die Tricks, die ich benutzte, waren die Notation von aufeinanderfolgenden ganzen Zahlen (wie[1,2,3,4] = 1:4 ) und das Entfernen einer der 100 Stellen durch Hinzufügen eines Skalars zu jedem Wert des Vektors.

Mal sehen, ob das jemand schlagen kann =)

Bash, 206 252 257 Bytes

Die Verwendung des in convertPaketen enthaltenen Befehls imagemagickspart 46 weitere Bytes.

base64 -d<<<UDQKMzAgMzAKAAAAAAAAAAAAAAAAAAAAAAAAAAAH9L+ABBkggAXULoAF2S6ABdOugAQeoIAH+r+AB9zVAABIlwABHU6AAsIaAAFXS4AAD+QAB/ywAAQT5QAF3pIABd6SAAXdTgAEHBsAB/1OAAAAAAAAAAAAAAAAAAAAAAAAAAAA|convert - newyear.png

Konvertiert das Base64-kodierte pbmBild in ein pngBild mit imagemagick's convert.

Möglicherweise müssen Sie den decode (-d)Parameter an Ihre spezielle base64Binärdatei anpassen . Getestet auf meinem Ubuntu 14.04 LTS.

5 Bytes mit <<</ here-string gespeichert .

base64 -d>newyear.png<<<iVBORw0KGgoAAAANSUhEUgAAAB4AAAAeAQMAAAAB/jzhAAAABlBMVEX///8AAABVwtN+AAAAX0lEQVQI12PACdi/7G9gYJFUaGBgvaIHJG6CiMvrgGJyCxoY2H/tBxJ3rgIVekxnYGCU9WtgYDokBWSFezcwMPA/ARrwZwMDA4vwUwYG1nuTYMRdP6CYjDRQ9q8fbrsBLRkaYOOP83wAAAAASUVORK5CYII=

Alte Version (257 Bytes):
echo iVBORw0KGgoAAAANSUhEUgAAAB4AAAAeAQMAAAAB/jzhAAAABlBMVEX///8AAABVwtN+AAAAX0lEQVQI12PACdi/7G9gYJFUaGBgvaIHJG6CiMvrgGJyCxoY2H/tBxJ3rgIVekxnYGCU9WtgYDokBWSFezcwMPA/ARrwZwMDA4vwUwYG1nuTYMRdP6CYjDRQ9q8fbrsBLRkaYOOP83wAAAAASUVORK5CYII=|base64 -d > newyear.png

Nur eine einfache Shell-Befehlskette, die die base64-kodierte pngDatei in stdin schreibt base64, dekodiert sie aufgrund des -dFlags und schreibt ihre stdout in newyear.png.

Python 2 + PIL, 216 215

Grundsätzlich ein Port der Mathematica-Lösung.

from PIL import*
b=Image.new("1",[21]*2)
b.putdata(map(int,'0'*7+bin(int('FL6IBG25C8Z00UEF53P4657DGD6HJZG41E5JOEAD1QGZ0L2XCHQGSO5R1A51V5NO4ZKW9V22OKKLG0CYMMY2',36))[2:]))
ImageOps.expand(b,5,255).save("newyear.png")

Gemeinsame Shell-Tools + Imagemagick, 215

(echo "P1
21 21"
base64 -d<<<H95/ggoN1lduirt0VdggIP9V/ALAFMzFdVpdu/R4YeH1JSAB4H8W1goeF0JSuk+F1W1gmO/9BVA=|xxd -c99 -p|tr a-f A-F|dc -e2o16i?p|tr -d '\n\\'|fold -21)|convert -border 5 -bordercolor white - newyear.png

Ein bisschen verschlungen , aber kürzer als die andere Shell-Antwort .

• Base64 konvertiert von Base64 zu Base 256 (erweitertes ASCII)
• xxd konvertiert in hex
• tr macht hex großbuchstaben, geeignet für dc
• dc liest hexadezimal und gibt eine Binärzeichenfolge mit 1 und 0 aus
• tr entfernt \ und Leerzeichen
• Falte macht Zeilen 21 Zeichen (21 Pixel) lang
• Diese Ausgabe ist zusammen mit P1\n21 21dem PBM P1-Format
• convert (Imagemagick) konvertiert dies in .png mit einem 5 Pixel Rand: