Görev basit. 2015 numarasını QR kodu olarak çıktılayın ve newyear.pngPNG formatında adlandırılan dosyaya yazın . Kod her gün geçerli olmalıdır, bu nedenle cari yılı kullanamazsınız.

Metin olarak QR kodu şuna benzer:

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

Yazılan sonuç newyear.pngbeyaz 5 piksel kenarlıklı ve bir piksel boyutlu nokta içeren QR kodunu içermelidir. QR kodundan başka bir şey içermemelidir.

Ham dosya, 184 bayt = 173 bayt dosya + 11 bayt dosya adı

Umarım bu herhangi bir standart boşluk bırakmaz. Ancak çıktı "yüksek bir kolmogorov karmaşıklığına sahiptir ve onu üretmenin en kısa yolu (büyük olasılıkla) kelimenin tam anlamıyla yazdırmak olacaktır ...".

Dosyanın 64 tabanı:

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

Bir programı golf oynamak yerine ortaya çıkan PNG görüntüsünü golf oynadım. QR kodu çok esnek bir formattır, değiştirilebilecek birçok parametre vardır: girişin kodlanması, hata düzeltme seviyesi ve maskeleme görüntüsü. Bunların hepsi farklı semboller üretecek ve böylece farklı boyutlardaki dosyalara sıkıştırılacaktır.

Bu yüzden tüm bu kombinasyonları (sonuç olarak 6720 dosya) oluşturmak için bir program yazdım ve daha sonra en küçük dosyaya sıkıştırılmış olanı seçmek için PNGOUT'u kullandım. Bir dosya olduğu ortaya çıkıyor:

• Önce alfasayısal modda "20" yazın
• Sonra sayısal modda "1" yazın
• Sonra sayısal modda "5" yazın
• "H" (Yüksek) hata düzeltme seviyesini kullanın
• "110" veri maskelemesini kullanma

test-3-1-H-Diamonds.bmpAşağıdaki programı kullandıysanız buna denir . Bu görüntü PNGOUT çalıştırıldıktan sonra 175 bayt uzunluğundadır. "Sürüm 1" QR kodunda "yüksek" hata düzeltme seviyesiyle, verileri bozmadan veri bölümünde 8 piksele kadar değişiklik yapabiliriz. Biraz manuel deneme-yanılma ile, yukarıda sunulan 173 bayta daha da düşürebilirim. Muhtemelen daha küçük olabilir, ancak tüm kombinasyonları tüketmek ²⁰⁸ C ₈ ~ 7.5 × 10 ¹³ kontrol gerektirir;

Tüm kombinasyonları oluşturan Rust (0.13.0 gecelik (5ba610265)) programı:

/* 

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 bayt

İşte bir başlangıç:

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

Daha az golf:

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

QR kodu bir baz 36 numarasında kodlanmıştır. Tabii ki, onu genişletilmiş ASCII (temel 256) kodlayabilir, ancak bu sadece dizeyi 30 bayt kısaltır, ve ben çok daha az maliyetle dönüşüm yapabilirsiniz emin değilim.

Tabii ki, bu Mathematica, yani 63 bayt var

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

ama sanırım bu standart bir boşluk. ;) (Bu, meydan okumadaki koddan farklı bir QR kodu üretir, bu yüzden QR kodu benzersiz değil mi?)

Matlab 545 Bayt

Zorlayıcı manuel işlerde ve herhangi bir süslü yerleşik dize sıkıştırma / konuşma olmadan sabit kodlanmıştır . Hala diğer cevaplar kadar iyi olmadığını biliyorum ama hala mutluyum =)

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

Daha okunamaz (gerçek 545 sürümü):

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

Bir 31 x 31 sıfır matris oluşturmak, ama indekslerine sahip bütün hücreleri ayarlamak için vektör olarak erişmek biçin 1. Kullandığım hileler, ardışık tamsayıların (örneğin [1,2,3,4] = 1:4) gösterimi ve vektörün her değerine bir skaler ekleyerek 100 basamaklı bir sayının kaldırılmasıydı.

Bakalım kimse bunu yenebilir mi =)

Baş, 206252257 Bayt

Birlikte verilen convertkomutu kullanmak imagemagick46 bayt daha kaydeder.

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

Dönüştürür base64 ile kodlanmış pbmbir görüntü pngile görüntünün imagemagick's convert.

decode (-d)Parametreyi özel base64ikilinize ayarlamanız gerekebilir . Ubuntu 14.04 LTS'mde test edildi.

<<</ Here-string kullanılarak 5 bayt kaydedildi .

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

Eski sürüm (257 bayt):
echo iVBORw0KGgoAAAANSUhEUgAAAB4AAAAeAQMAAAAB/jzhAAAABlBMVEX///8AAABVwtN+AAAAX0lEQVQI12PACdi/7G9gYJFUaGBgvaIHJG6CiMvrgGJyCxoY2H/tBxJ3rgIVekxnYGCU9WtgYDokBWSFezcwMPA/ARrwZwMDA4vwUwYG1nuTYMRdP6CYjDRQ9q8fbrsBLRkaYOOP83wAAAAASUVORK5CYII=|base64 -d > newyear.png

Base64 kodlanmış pngdosyayı stdin'e base64, -dbayrak nedeniyle kodunu çözen ve stdout'unu newyear.png'ye yazan basit bir kabuk komut zinciri .

Python 2 + PIL, 216 215

Temelde Mathematica çözümünün bir portu.

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

Ortak Kabuk araçları + 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

Biraz kıvrık , ancak diğer kabuk cevabından daha kısa .

• Base64, base64'ten base 256'ya dönüştürülür (genişletilmiş ASCII)
• xxd onaltılık biçime dönüştürür
• tr, hex için büyük harf yapar, dc için uygundur
• dc hex'i okur ve 1s ve 0s ikili dizesini yazdırır
• tr \ ve boşlukları kaldırır
• katlama çizgileri 21 karakter (21 piksel) uzunluğunda
• İle birlikte bu çıkış, P1\n21 21bir PBM P1 biçimi
• convert (Imagemagick) bunu 5 piksel kenarlıklı .png biçimine dönüştürür: