क्यूआर कोड के रूप में आउटपुट 2015

Question

मिशन सरल है। बस क्यूआर कोड के रूप में आउटपुट नंबर 2015 और इसे newyear.pngपीएनजी प्रारूप में नाम दर्ज करने के लिए लिखें । कोड किसी भी दिन मान्य होना चाहिए, इसलिए शायद आप वर्तमान वर्ष का उपयोग नहीं करेंगे।

क्यूआर कोड पाठ जैसा दिखता है:

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

परिणाम में लिखा newyear.pngहोना चाहिए कि सफेद 5 पिक्सेल सीमाओं और एक पिक्सेल आकार के डॉट्स के साथ QR कोड। इसमें QR कोड के अलावा और कुछ नहीं होना चाहिए।

Comments

क्या यह हार्डकोड किया जा सकता है, या आपको क्यूआर कोड उत्पन्न करना चाहिए?

— अंडरग्राउंडोरेल

बहुत अधिक उत्तर आएंगे यदि यह आस्की कला आउटपुट आधारित है न कि इमेज आउटपुट।

— ऑप्टिमाइज़र

क्या कोड को बिना किसी त्रुटि के ठीक होना चाहिए, या क्या यह पर्याप्त है कि यह सही तरीके से स्कैन हो? (QR कोड, जानबूझकर अतिरेक और त्रुटि सुधार का एक बहुत है, इसलिए आप पिक्सल का एक बहुत फ्लिप कर सकते हैं और वे अभी भी काम करते हैं। जाएगा) इसके अलावा, यह करता है पीएनजी हो सकता है, या हम दूसरे छवि प्रारूपों का उपयोग कर सकते हैं (मैं सोच रहा हूँ विशेष रूप से पीबीएम के बारे में यहाँ)?

— इल्मरी करोनें

Answer 1

कच्ची फ़ाइल, 184 बाइट्स = 173-बाइट फ़ाइल + 11-बाइट फ़ाइल नाम

मुझे उम्मीद है कि यह किसी भी मानक खामियों को नहीं तोड़ता है। लेकिन उत्पादन "एक उच्च kolmogorov-complexity है और इसे बनाने का सबसे छोटा तरीका (सबसे अधिक संभावना है) बस इसे शाब्दिक रूप से प्रिंट करना होगा ..."।

फ़ाइल का आधार 64:

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

---

एक प्रोग्राम को गोल्फ के बजाय मैंने परिणामस्वरूप पीएनजी छवि को गोल्फ दिया। QR कोड एक बहुत ही लचीला प्रारूप है, ऐसे कई पैरामीटर हैं जिन्हें फ़िड किया जा सकता है: इनपुट की एन्कोडिंग, त्रुटि सुधार स्तर और मास्किंग छवि। ये सभी अलग-अलग प्रतीकों को उत्पन्न करेंगे और इस प्रकार विभिन्न आकारों की फ़ाइलों को संपीड़ित करेंगे।

इसलिए मैंने इन सभी संयोजनों (जिसके परिणामस्वरूप 6720 फाइलें) को उत्पन्न करने के लिए एक कार्यक्रम लिखा है, और फिर सबसे छोटी फ़ाइल को संकुचित करने के लिए PNGOUT का उपयोग करें। यह एक फ़ाइल है कि:

• पहले अल्फान्यूमेरिक मोड में "20" लिखें
• फिर संख्यात्मक मोड में "1" लिखें
• फिर संख्यात्मक मोड में "5" लिखें
• "H" (उच्च) त्रुटि सुधार स्तर का उपयोग करें
• "110" डेटा मास्किंग का उपयोग करें

यह कहा जाता है test-3-1-H-Diamonds.bmpयदि आप नीचे दिए गए प्रोग्राम का उपयोग करते हैं। PNGOUT चलाने के बाद यह छवि 175-बाइट लंबी है। "संस्करण 1" क्यूआर कोड में "उच्च" त्रुटि सुधार स्तर के साथ, हम डेटा को बर्बाद किए बिना डेटा भाग में 8 पिक्सेल तक संशोधित कर सकते हैं। मैनुअल परीक्षण और त्रुटि के एक बिट के साथ, मैं इसे ऊपर प्रस्तुत किए गए 173 बाइट्स को कम कर सकता हूं। यह शायद छोटा हो सकता है लेकिन सभी संयोजनों को समाप्त करने के लिए ²⁰⁸ सी ₈ ~ 7.5 × 10 ¹³ चेक की आवश्यकता होती है जो मैं नहीं करने जा रहा हूं;)

---

द रस्ट (0.13.0-nightly (5ba610265)) प्रोग्राम जो सभी संयोजनों को उत्पन्न करता है:

/* 

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

Comments

मुख्य समस्या जो मैं यहां देख रहा हूं, वह यह है कि आपका सबमिशन खुद एक प्रोग्रामिंग भाषा में नहीं लिखा गया है ।

— मार्टिन एंडर

@ MartinBüttner यह कुछ चुनिंदा लोगों की एक व्यक्तिपरक राय है। कहा जा रहा है, जिस तरह से फ़ाइल प्राप्त की गई थी उसे प्रोग्राम किया गया था, इसलिए मैं कहूंगा कि यह पूरी तरह से वैध सबमिशन है। इसके अलावा, यह एक भयावह भयानक दृष्टिकोण है।

— नीट

@ यह बिना मेटाविट के एक मेटा पोस्ट है, जो मूल रूप से एसई (पीपीसीजी पर कम से कम) पर समुदाय की सहमति कैसे काम करता है। यदि आप असहमत हैं, तो आप उस उत्तर को अस्वीकार कर सकते हैं या एक विकल्प प्रदान कर सकते हैं। यह कहा जा रहा है, मैं शायद एक अलग मेटा पोस्ट बनाऊंगा, विशेष रूप से कोलमोगोरोव जटिलता चुनौतियों के बारे में, क्योंकि यह बहुत अधिक आ रहा है।

— मार्टिन एंडर

@ नीट डन। बेझिझक मेटा पर इस पर चर्चा करें।

— मार्टिन एंडर

जिफ़ से परिवर्तित होना कम लग रहा था।

— jimmy23013

Answer 2

गणितज्ञ, 217 177 176 166 बाइट्स

यहाँ एक शुरुआत है:

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

कम गोल्फ:

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

QR कोड को आधार 36 नंबर में एनकोड किया गया है। बेशक, मैं इसे विस्तारित ASCII (बेस 256) में एनकोड कर सकता था, लेकिन यह केवल 30 बाइट्स द्वारा स्ट्रिंग को छोटा कर देगा, और मुझे यकीन नहीं है कि मैं इससे कम लागत पर रूपांतरण कर सकता हूं।

बेशक, यह गणितज्ञ है, इसलिए 63-बाइट भी है

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

लेकिन मुझे लगता है कि यह एक मानक खामी है। ;) (यह चुनौती में एक से एक अलग क्यूआर कोड का उत्पादन करता है, इसलिए मुझे लगता है कि क्यूआर कोड अद्वितीय नहीं है?)

Comments

हां, क्यूआर कोड में एक ही स्ट्रिंग को एनकोड करने के कई तरीके हैं, उदाहरण के लिए त्रुटि जांच, एन्कोडिंग योजना, मास्किंग छवि, आदि के विभिन्न स्तरों का उपयोग करना। संपीड़न पर विचार नहीं करना ओपी कोड फिर भी सबसे छोटा ("संस्करण 1") में से एक है।

— kennytm

FromDigits? आप 36^^fl6ibg25c8z00uef53p4657dgd6hjzg41e5joead1qgz0l2xchqgso5r1a51v5no4zkw9v22okklg0cymmy2इसके बजाय उपयोग कर सकते हैं ।

— kennytm

@ केनीटीएम ओह वाह, नीट ट्रिक। धन्यवाद :) मुझे लगता है कि इसके साथ, बेस 256 वास्तव में इसके लायक नहीं है (मुझे दोनों की आवश्यकता होगी ToCharacterCodeऔर FromDigitsफिर।)

— मार्टिन एंडर

Answer 3

मतलाब 545 बाइट्स

श्रमसाध्य मैनुअल काम में हार्डकोड और बिना किसी फैंसी बिलिन स्ट्रिंग संपीड़न / वार्तालाप के । मुझे पता है कि यह अभी भी अन्य उत्तरों की तरह अच्छा नहीं है लेकिन मैं अभी भी खुश हूं =)

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

अधिक अपठनीय (वास्तविक 545 संस्करण):

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

हम एक 31 x 31 शून्य मैट्रिक्स बनाने के लिए, लेकिन के सूचकांकों के साथ सभी कोशिकाओं स्थापित करने के लिए वेक्टर के रूप में इसे का उपयोग bकरने के लिए 1। मैंने जो तरकीबें इस्तेमाल कीं उनमें लगातार पूर्णांक (जैसे) के अंकन थे[1,2,3,4] = 1:4 ) और वेक्टर के प्रत्येक मान में एक स्केलर जोड़कर 100 अंकों को हटा देती ।

चलो देखते हैं कि किसी को भी हरा सकते हैं =)

Comments

इसलिए मैंने unreadableसही ढंग से शब्द नहीं पढ़ा ... निश्चित रूप से पढ़ा readable। देखा कि यह सुझाव देने के बाद सही था और उम्मीद कर रहा था कि जो कोई भी मेरे संपादन को पढ़ेगा वह इसे अस्वीकार कर देगा, लेकिन वे इसे बहुत स्पष्ट रूप से याद करते थे। खराब संपादन के बारे में खेद ...

— pseudonym117

IMHO से कोई फर्क नहीं पड़ता, बस पहले संस्करण को शामिल करना चाहता था क्योंकि स्पष्टीकरण में संदर्भित करना आसान है।

— दोष

Answer 4

बैश, 206 252 257 बाइट्स

46 अधिक बाइट्स convertको imagemagickसहेजने में बंडल कमांड का उपयोग करना ।

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

धर्मान्तरित base64 एनकोडेड pbmएक करने के लिए छवि pngके साथ छवि imagemagickकी convert।

आपको decode (-d)पैरामीटर को अपने विशिष्ट base64बाइनरी में समायोजित करने की आवश्यकता हो सकती है । मेरे Ubuntu 14.04 LTS पर परीक्षण किया गया।

<<</ यहां-स्ट्रिंग का उपयोग करके 5 बाइट्स सहेजे गए ।

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

पुराना संस्करण (257 बाइट्स):
echo iVBORw0KGgoAAAANSUhEUgAAAB4AAAAeAQMAAAAB/jzhAAAABlBMVEX///8AAABVwtN+AAAAX0lEQVQI12PACdi/7G9gYJFUaGBgvaIHJG6CiMvrgGJyCxoY2H/tBxJ3rgIVekxnYGCU9WtgYDokBWSFezcwMPA/ARrwZwMDA4vwUwYG1nuTYMRdP6CYjDRQ9q8fbrsBLRkaYOOP83wAAAAASUVORK5CYII=|base64 -d > newyear.png

बस एक साधारण शेल कमांड चेन जो बेस 64 एनकोडेड pngफाइल को स्टाइन में लिखता है base64, उसे -dझंडे के कारण डिकोड करता है और अपने स्टडआउट को newyear.png लिखता है।

Comments

शायद कुछ के साथ पात्रों को बचा सकता है, base64 -d>newyear.png<<<[the long string]लेकिन मैं एक linux मशीन आरएन पर नहीं हूं और मुझे नहीं पता कि व्हॉट्सएप अनिवार्य है

— भूमिगत

base64 -d>newyear.png<<<[base64 string]14.04 उबंटू के साथ काम करने की पुष्टि की ।

— पुरकाकूदरी

यदि आप सुझाए गए कोड का उपयोग करने जा रहे हैं, तो बस कुछ विशिष्ट जैसे बश, क्ष या ज़श के उत्तर शीर्षक को संपादित करें। सामान्य रूप से शेल (जैसे POSIX संगत श, ऐश या डैश) यहां-स्ट्रिंग सिंटैक्स का समर्थन नहीं करता है ।

— 17

हम netpbm दिनचर्या का उपयोग कर सकते हैं, तो हम संकुचित बिटमैप फ़ीड और खोना 40 बाइट्स कर सकते हैं: गूंज UDQKMzEgMzEKAAAAAAAAAAAAAAAAAAAAAAAAAAAH95 / ABBBQQAXWV0AF0VdABdFXQAQQEEAH9V / AAAWAAAUzMUADqtLABbv0QAcMPAAH1JSAAADwAAfxbUAEFDwABdCUgAXSfAAF1W1ABBMdwAf0FUAAAAA AAAAAAAAAAAAAAAAAAAAAAA == | base64 -d | pnmtopng> newyear.png

— swstephe

@manatwork अभी-अभी संपादित किया गया है, बैश पर काम करना चाहिए क्योंकि मैंने इसे अपने एंड्रॉइड फोन पर परीक्षण किया।

— विशालकाय डिक

Answer 5

अजगर 2 + पीआईएल, 216 215

मूल रूप से गणितज्ञ समाधान का एक बंदरगाह।

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

Answer 6

आम शैल उपकरण + इमेजमैजिक, 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

थोड़ा और जटिल , लेकिन अन्य शेल उत्तर से कम ।

• Base64 बेस 64 से बेस 256 (विस्तारित ASCII) में परिवर्तित होता है
• xxd हेक्स में कनवर्ट करता है
• tr डीसी के लिए उपयुक्त हेक्स अपरकेस बनाता है
• dc हेक्स पढ़ता है और 1s और 0s के बाइनरी स्ट्रिंग को प्रिंट करता है
• tr \ _ व्हाट्सएप को हटाता है
• तह 21 वर्णों (21 पिक्सल) को लंबी बनाता है
• यह आउटपुट, PBM P1 प्रारूप के साथ P1\n21 21है
• कन्वर्ट (इमेजमैजिक) इसे 5 पिक्सेल बॉर्डर के साथ .png में कनवर्ट करता है: