हानिपूर्ण ASCII कला संपीड़न

Question

पृष्ठभूमि

PICASCII एक साफ उपकरण है जो छवियों को ASCII कला में परिवर्तित करता है।

यह निम्नलिखित दस ASCII वर्णों का उपयोग करके चमक की विभिन्न डिग्री प्राप्त करता है:

@#+';:,.` 

हम कहेंगे कि इन charxels (वर्ण तत्वों) में 1 (एट-साइन) से लेकर 10 (स्पेस) तक की चमक है।

नीचे, आप एक छोटे कोड को बदलने के परिणाम देख सकते हैं, वेल्श ध्वज, एक ओवरहैंड भग्न, एक बड़ा ट्राउट और थोड़ा गोल्फ, सही फ़ॉन्ट के साथ प्रदर्शित:

आप इस फ़ाइल में चित्र देख सकते हैं और उन्हें Google ड्राइव से डाउनलोड कर सकते हैं ।

कार्य

जबकि PICASCII के अंतिम परिणाम नेत्रहीन मनभावन हैं, सभी पांच छवियों को मिलाकर 153,559 बाइट्स का वजन होता है। यदि हम उनकी गुणवत्ता के हिस्से का त्याग करने को तैयार हैं तो ये चित्र कितने संकुचित हो सकते हैं?

आपका कार्य एक ऐसा प्रोग्राम लिखना है जो ASCII कला छवि जैसे कि ऊपर वाले और इनपुट के रूप में एक न्यूनतम गुणवत्ता को स्वीकार करता है और छवि के एक हानिपूर्ण संपीड़न को प्रिंट करता है - एक पूर्ण कार्यक्रम या एक एकल स्ट्रिंग को लौटाने वाले फ़ंक्शन के रूप में - जो संतुष्ट करता है। गुणवत्ता की आवश्यकता।

इसका मतलब है कि आपको एक अलग डिकम्प्रेसर लिखने के लिए नहीं मिलता है; इसे प्रत्येक संपीड़ित चित्रों में अंतर्निहित होना चाहिए।

मूल छवि 1 और 10 के बीच चमक के साथ charxels से मिलकर बनेगी, एक ही लंबाई की रेखाओं में फीडफ़ीड द्वारा अलग। संकुचित छवि में समान आयाम होने चाहिए और समान वर्णों का उपयोग करना चाहिए।

N charxels से मिलकर एक असम्पीडित छवि के लिए, छवि के एक संपीड़ित संस्करण की गुणवत्ता को परिभाषित किया गया है

जहां ग _मैं की चमक है मैं ^वें संकुचित छवि उत्पादन का charxel और यू _मैं की चमक मैं ^वें असम्पीडित छवि के charxel।

स्कोरिंग

आपका कोड ऊपर की पाँच छवियों और 0.50, 0.60, 0.70, 0.80 और 0.90 की न्यूनतम गुणवत्ता सेटिंग्स के साथ चलाया जाएगा।

आपका स्कोर सभी संपीड़ित छवियों के आकार का ज्यामितीय माध्य है, अर्थात, सभी पच्चीस संकुचित छवियों की लंबाई के उत्पाद का पच्चीसवाँ मूल।

सबसे कम स्कोर जीतता है!

अतिरिक्त नियम

• आपके कोड को मनमानी छवियों के लिए काम करना है, न कि केवल स्कोरिंग के लिए इस्तेमाल होने वाले।

  यह उम्मीद की जाती है कि आप अपने कोड को परीक्षण के मामलों के लिए अनुकूलित करते हैं, लेकिन एक प्रोग्राम जो मनमाने ढंग से छवियों को संपीड़ित करने का प्रयास भी नहीं करता है, वह मुझसे नहीं मिलेगा।

• आपका कंप्रेसर अंतर्निहित बाइट स्ट्रीम कंप्रेशर्स (जैसे, gzip) का उपयोग कर सकता है, लेकिन आपको उन्हें संपीड़ित छवियों के लिए स्वयं को लागू करना होगा।

  बाइट-इन आमतौर पर बाइट स्ट्रीम डिकम्प्रेसर (जैसे, आधार रूपांतरण, रन-लंबाई डिकोडिंग) में उपयोग किया जाता है।

• कंप्रेसर और संपीड़ित छवियां एक ही भाषा में नहीं होती हैं।

  हालाँकि, आपको सभी संपीड़ित चित्रों के लिए एक ही भाषा चुननी चाहिए।

• प्रत्येक संकुचित छवि के लिए, मानक कोड गोल्फ नियम लागू होते हैं।

सत्यापन

मैंने सभी गुणवत्ता आवश्यकताओं को आसानी से सत्यापित करने और सबमिशन के स्कोर की गणना करने के लिए सीजेएम स्क्रिप्ट बनाई है।

आप यहाँ या यहाँ से जावा दुभाषिया डाउनलोड कर सकते हैं ।

e# URLs of the uncompressed images.
e# "%s" will get replaced by 1, 2, 3, 4, 5.

"file:///home/dennis/codegolf/53199/original/image%s.txt"

e# URLs of the compressed images (source code).
e# "%s-%s" will get replaced by "1-50", "1-60", ... "5-90".

"file:///home/dennis/codegolf/53199/code/image%s-%s.php"

e# URLs of the compressed images (output).

"file:///home/dennis/codegolf/53199/output/image%s-%s.txt"

e# Code

:O;:C;:U;5,:)
{
    5,5f+Af*
    {
        C[IQ]e%g,X*:X;
        ISQS
        [U[I]e%O[IQ]e%]
        {g_W=N&{W<}&}%
        _Nf/::,:=
        {
            {N-"@#+';:,.` "f#}%z
            _::m2f#:+\,81d*/mq1m8#
            _"%04.4f"e%S
            @100*iQ<"(too low)"*
        }{
            ;"Dimension mismatch."
        }?
        N]o
    }fQ
}fI
N"SCORE: %04.4f"X1d25/#e%N

उदाहरण

बैश → PHP, स्कोर 30344.0474

cat

सभी इनपुट के लिए 100% गुणवत्ता प्राप्त करता है।

$ java -jar cjam-0.6.5.jar vrfy.cjam
1 50 1.0000 
1 60 1.0000 
1 70 1.0000 
1 80 1.0000 
1 90 1.0000 
2 50 1.0000 
2 60 1.0000 
2 70 1.0000 
2 80 1.0000 
2 90 1.0000 
3 50 1.0000 
3 60 1.0000 
3 70 1.0000 
3 80 1.0000 
3 90 1.0000 
4 50 1.0000 
4 60 1.0000 
4 70 1.0000 
4 80 1.0000 
4 90 1.0000 
5 50 1.0000 
5 60 1.0000 
5 70 1.0000 
5 80 1.0000 
5 90 1.0000 

SCORE: 30344.0474

Comments

मुझे इस भाग को समझने में थोड़ी परेशानी हो रही है: यदि कोई q = 0.5 चुनता है, तो इनपुट फ़ाइल में प्रत्येक चार को आउटपुट में आधी चमक के साथ चार द्वारा प्रतिस्थापित किया जाना चाहिए, है ना? जाहिर है कि व्हाट्सएप को छोड़कर पूरी छवि को गड़बड़ कर देगा।

— निकोलस सिप्लिस

यह सब बहुत भ्रामक और शिथिल है। आप एक mattmahoney.net/dc/barf.html प्रविष्टि को कैसे रोक सकते हैं ? क्या डिकम्प्रेसर संपीड़ित छवि के अलावा किसी भी फ़ाइल को पढ़ सकता है? क्या आप एक पायथन स्क्रिप्ट या ऐसा कुछ प्रदान कर सकते हैं जो वास्तव में एक छवि की गुणवत्ता की जांच करता है और एक अंक की गणना करता है ताकि उस मोर्चे पर भी कोई प्रश्न न हो सके? आदि

— विल

बहक रही है? शायद। लेकिन मुझे नहीं लगता कि यह शिथिल है। प्रत्येक संकुचित छवि को एक कार्यक्रम या फ़ंक्शन होना चाहिए, इसलिए BARF जैसे निराधार चुटकुलों को स्वचालित रूप से बाहर रखा गया है। मैं अजगर को नहीं जानता, लेकिन मैं सरल सत्यापन के लिए कुछ सोचूंगा।

— डेनिस

"मैंने सभी गुणवत्ता आवश्यकताओं को आसानी से सत्यापित करने और सबमिशन के स्कोर की गणना करने के लिए सीजेएम स्क्रिप्ट बनाई है।" क्या लोग वास्तव में सामान्य लिपियों को करने के लिए इस चीज़ का उपयोग करते हैं? प्रिय प्रभु ...

— घातक

Answer 1

जावा → सीजाम, स्कोर 174417.89

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import net.aditsu.cjam.CJam;

public class Compress {
    protected static final char[] DIGITS = "0123456789ABCDEFGHIJK".toCharArray();
    protected static final String CHARS = "@#+';:,.` ";
    protected static final char[] CHR = CHARS.toCharArray();

    private static class Img {
        public final int rows;
        public final int cols;
        public final int[][] a;

        public Img(final int rows, final int cols) {
            this.rows = rows;
            this.cols = cols;
            a = new int[rows][cols];
        }

        public Img(final List<String> l) {
            rows = l.size();
            cols = l.get(0).length();
            a = new int[rows][cols];
            for (int i = 0; i < rows; ++i) {
                for (int j = 0; j < cols; ++j) {
                    a[i][j] = CHARS.indexOf(l.get(i).charAt(j));
                }
            }
        }

        public static Img read(final Reader r) {
            try {
                final BufferedReader br = new BufferedReader(r);
                final List<String> l = new ArrayList<>();
                while (true) {
                    final String s = br.readLine();
                    if (s == null || s.isEmpty()) {
                        break;
                    }
                    l.add(s);
                }
                br.close();
                return new Img(l);
            }
            catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        public static Img read(final File f) {
            try {
                return read(new FileReader(f));
            }
            catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        public Img scaleDown(final int fr, final int fc) {
            final int r1 = (rows + fr - 1) / fr;
            final int c1 = (cols + fc - 1) / fc;
            final Img x = new Img(r1, c1);
            final int[][] q = new int[r1][c1];
            for (int i = 0; i < rows; ++i) {
                for (int j = 0; j < cols; ++j) {
                    x.a[i / fr][j / fc] += a[i][j];
                    q[i / fr][j / fc]++;
                }
            }
            for (int i = 0; i < r1; ++i) {
                for (int j = 0; j < c1; ++j) {
                    x.a[i][j] /= q[i][j];
                }
            }
            return x;
        }

        public Img scaleUp(final int fr, final int fc) {
            final int r1 = rows * fr;
            final int c1 = cols * fc;
            final Img x = new Img(r1, c1);
            for (int i = 0; i < r1; ++i) {
                for (int j = 0; j < c1; ++j) {
                    x.a[i][j] = a[i / fr][j / fc];
                }
            }
            return x;
        }

        public Img crop(final int r, final int c) {
            if (r == rows && c == cols) {
                return this;
            }
            final Img x = new Img(r, c);
            for (int i = 0; i < r; ++i) {
                for (int j = 0; j < c; ++j) {
                    x.a[i][j] = a[i][j];
                }
            }
            return x;
        }

        public Img rescale(final int fr, final int fc) {
            return scaleDown(fr, fc).scaleUp(fr, fc).crop(rows, cols);
        }

        public double quality(final Img x) {
            if (x.rows != rows || x.cols != cols) {
                throw new IllegalArgumentException();
            }
            double t = 0;
            for (int i = 0; i < rows; ++i) {
                for (int j = 0; j < cols; ++j) {
                    final int y = a[i][j] - x.a[i][j];
                    t += y * y;
                }
            }
            t /= 81 * rows * cols;
            t = 1 - Math.sqrt(t);
            return Math.pow(t, 8);
        }

        @Override
        public String toString() {
            final StringBuilder sb = new StringBuilder();
            for (int i = 0; i < rows; ++i) {
                for (int j = 0; j < cols; ++j) {
                    sb.append(CHR[a[i][j]]);
                }
                sb.append('\n');
            }
            return sb.toString();
        }

        public Array toArray() {
            final Array x = new Array(rows * cols);
            int k = 0;
            for (int i = 0; i < rows; ++i) {
                for (int j = 0; j < cols; ++j) {
                    x.a[k++] = a[i][j];
                }
            }
            return x;
        }

        public String compress(final double quality) {
            int bi = 1;
            int bj = 1;
            int bs = rows * cols;
            Img bx = this;

            for (int i = 1; i < 3; ++i) {
                for (int j = 1; j < 3; ++j) {
                    Img x = rescale(i, j);
                    if (quality(x) >= quality) {
                        x = scaleDown(i, j);
                        if (x.rows * x.cols < bs) {
                            bi = i;
                            bj = j;
                            bs = x.rows * x.cols;
                            bx = x;
                        }
                    }
                }
            }

            Array a = bx.toArray();
            int bf = 0;
            for (int i = 1; i <= 20; ++i) {
                final int t = a.rle11(i).n;
                if (t < bs) {
                    bs = t;
                    bf = i;
                }
            }

            int b = 10;
            if (bf > 0) {
                b = 11;
                a = a.rle11(bf);
            }

            String s = null;
            for (int i = 92; i < 97; ++i) {
                for (char c = ' '; c < '$'; ++c) {
                    final String t = a.cjamBase(b, i, c);
                    boolean ok = true;
                    for (int j = 0; j < t.length(); ++j) {
                        if (t.charAt(j) > '~') {
                            ok = false;
                            break;
                        }
                    }
                    if (!ok) {
                        continue;
                    }
                    if (s == null || t.length() < s.length()) {
                        s = t;
                    }
                }
            }

            if (bf > 0) {
                s += "{(_A={;()";
                if (bf > 1) {
                    s += DIGITS[bf] + "*";
                }
                s += "\\(a@*}&\\}h]e_";
            }
            if (bi * bj == 1) {
                return s + '"' + CHARS + "\"f=" + cols + "/N*";
            }
            s += bx.cols + "/";
            if (bi > 1) {
                s += bi + "e*";
                if (rows % 2 == 1) {
                    s += "W<";
                }
            }
            if (bj > 1) {
                s += bj + "fe*";
                if (cols % 2 == 1) {
                    s += "Wf<";
                }
            }
            return s + '"' + CHARS + "\"ff=N*";
        }

        public void verify(final String s, final double quality) {
            final String t = CJam.run(s, "");
            final Img x = read(new StringReader(t));
            final double q = quality(x);
            if (q < quality) {
                throw new RuntimeException(q + " < " + quality);
            }
//          System.out.println(q + " >= " + quality);
        }
    }

    private static class Array {
        public final int[] a;
        public final int n;

        public Array(final int n) {
            this.n = n;
            a = new int[n];
        }

        public Array(final int[] a) {
            this.a = a;
            n = a.length;
        }

        public String join() {
            final StringBuilder sb = new StringBuilder();
            for (int x : a) {
                sb.append(x).append(' ');
            }
            sb.setLength(sb.length() - 1);
            return sb.toString();
        }

//      public String cjamStr() {
//          final StringBuilder sb = new StringBuilder("\"");
//          for (int x : a) {
//              sb.append(DIGITS[x]);
//          }
//          sb.append("\":~");
//          return sb.toString();
//      }

        public String cjamBase(final int m, final int b, final char c) {
            final boolean zero = a[0] == 0;
            String s = join();
            if (zero) {
                s = "1 " + s;
            }
            s = CJam.run("q~]" + m + "b" + b + "b'" + c + "f+`", s);
            s += "'" + c + "fm" + b + "b" + DIGITS[m] + "b";
            if (zero) {
                s += "1>";
            }
            return s;
        }

        public Array rle11(final int f) {
            final int[] b = new int[n];
            int m = 0;
            int x = -1;
            int k = 0;
            for (int i = 0; i <= n; ++i) {
                final int t = i == n ? -2 : a[i];
                if (t == x && m < 11 * f) {
                    m++;
                }
                else {
                    if (m >= f && m > 3) {
                        b[k++] = 10;
                        b[k++] = m / f - 1;
                        b[k++] = x;
                        for (int j = 0; j < m % f; ++j) {
                            b[k++] = x;
                        }
                    }
                    else {
                        for (int j = 0; j < m; ++j) {
                            b[k++] = x;
                        }
                    }
                    m = 1;
                    x = t;
                }
            }
            return new Array(Arrays.copyOf(b, k));
        }
    }

    private static void score() {
        double p = 1;
        for (int i = 1; i < 6; ++i) {
            final File f = new File("image" + i + ".txt");
            final Img img = Img.read(f);
            final int n = (int) f.length();
            for (int j = 5; j < 10; ++j) {
                final double q = j / 10.0;
                final String s = img.compress(q);
                System.out.println(f.getName() + ", " + q + ": " + n + " -> " + s.length());
                img.verify(s, q);
                p *= s.length();
            }
        }
        System.out.println(Math.pow(p, 1 / 25.0));
    }

    public static void main(final String... args) {
        if (args.length != 2) {
            score();
            return;
        }
        final String fname = args[0];
        final double quality = Double.parseDouble(args[1]);
        try {
            final Img img = Img.read(new File(fname));
            final String s = img.compress(quality);
            img.verify(s, quality);
            final FileWriter fw = new FileWriter(fname + ".cjam");
            fw.write(s);
            fw.close();
        }
        catch (IOException e) {
            throw new RuntimeException();
        }
    }
}

क्लासपाथ में सीजेम जार की आवश्यकता है। यदि आप इसे 2 कमांड लाइन तर्क (फ़ाइल नाम और गुणवत्ता) देते हैं, तो यह फ़ाइल नाम के लिए ".cjam" को जोड़ता है और वहां संपीड़ित छवि लिखता है। अन्यथा यह 5 परीक्षण छवियों पर अपने स्कोर की गणना करता है, जिन्हें वर्तमान निर्देशिका में माना जाता है। कार्यक्रम हर संपीड़ित छवि को स्वचालित रूप से सत्यापित करता है। यदि कोई विसंगति है, तो आप स्कोर गणना को दोबारा जांच सकते हैं।

उपयोग की जाने वाली तकनीकें (अब तक): आधी (क्षैतिज, लंबवत या दोनों) तक स्केलिंग होती हैं, अगर यह गुणवत्ता को बहुत कम नहीं करती है, तो एक कस्टम-कोडेड RLE और आधार रूपांतरण, शेष में रहते हुए प्रत्येक वर्ण में अधिक डेटा पैक करने के लिए। मुद्रण योग्य ASCII रेंज।

Comments

क्या आप मुझे इसे चलाने के बारे में संक्षिप्त जानकारी दे सकते हैं? मैंने इसे (सफलतापूर्वक, मुझे लगता है) के साथ संकलित किया javac -cp cjam-0.6.5.jar Compress.java, लेकिन सीजेएम वर्ग नहीं java -cp cjam-0.6.5.jar Compressकहता Error: Could not find or load main class Compressऔर java Compressनहीं पाता।

— डेनिस

@ डेनिस आपको उस डायरेक्टरी को जोड़ना होगा जिसमें कंप्रेस।क्लास टू द क्लासपाथ (-सीपी) है। यदि यह वर्तमान निर्देशिका में है, तो उपयोग करें -cp .:cjam-0.6.5.jar(विंडोएज़ में मुझे लगता है कि आपको एक बृहदान्त्र के बजाय अर्धविराम की आवश्यकता है)

— aditsu

वह चाल चली, धन्यवाद।

— डेनिस

Answer 2

पायथन 3.5 (मुख्य और आउटपुट) (वर्तमान में नॉनकंपेटिंग)

जन्मदिन मुबारक हो, चुनौती! यहाँ आपका वर्तमान है: एक उत्तर!

EDIT: पाइथन कोड में परिवर्तित आउटपुट, कम्प्रेशन कम्प्रेशन रेट (थोड़ा) EDIT2: इसे तब प्रिंट किया जाता है जब sizeयह 1. बेहतर स्कोर होता है, लेकिन स्कोर को फिर से गणना करने की आवश्यकता होती है। EDIT3: @ डेनिस ने बताया कि मुझे अभी भी ठीक करने के लिए कीड़े हैं, इसलिए मैंने जवाब को नॉनकंपेटिंग के रूप में चिह्नित किया

कोड:

import sys
LIST = [' ','`','.',',',':',';',"'",'+','#','@']

def charxel_to_brightness(charxel):
    return LIST.index(charxel)

def brightness_to_charxel(bright):
    return LIST[bright]

def image_to_brightness(imagetext):
    return [list(map(charxel_to_brightness,line)) for line in imagetext.split("\n")]

def brightness_to_image(brightarray):
    return '\n'.join([''.join(map(brightness_to_charxel,line)) for line in brightarray])

def split_into_parts(lst,size):
    return [lst[x:x+size] for x in range(0, len(lst), size)]

def gen_updown(startxel,endxel,size):
    return [[int((size-r)*(endxel-startxel)/size+startxel) for c in range(size)] for r in range(size)]

def gen_leftright(startxel,endxel,size):
    return [[int((size-c)*(endxel-startxel)/size+startxel) for c in range(size)] for r in range(size)]

def gen_tlbr(startxel,endxel,size):
    return [[int((2*size-r-c)/2*(endxel-startxel)/size+startxel) for c in range(size)] for r in range(size)]

def gen_bltr(startxel,endxel,size):
    return [[int((size-r+c)/2*(endxel-startxel)/size+startxel) for c in range(size)] for r in range(size)]

def gen_block(code,startxel,endxel,size):
    if code==0:return gen_updown(startxel,endxel,size)
    if code==1:return gen_leftright(startxel,endxel,size)
    if code==2:return gen_bltr(startxel,endxel,size)
    if code==3:return gen_tlbr(startxel,endxel,size)

def vars_to_data(code,startxel,endxel):
    acc=endxel
    acc+=startxel<<4
    acc+=code<<8
    return acc

def data_to_vars(data):
    code=data>>8
    startxel=(data>>4)&15
    endxel=data&15
    return code,startxel,endxel

def split_into_squares(imgarray,size):
    rows = split_into_parts(imgarray,size)
    allsquares = []
    for rowblock in rows:
        splitrows = []
        for row in rowblock:
            row = split_into_parts(row,size)
            splitrows.append(row)
        rowdict = []
        for row in splitrows:
            for x in range(len(row)):
                if len(rowdict)<=x:
                    rowdict.append([])
                rowdict[x].append(row[x])
        allsquares.append(rowdict)
    return allsquares

def calc_quality(imgarray,comparray):
    acc=0
    for row in range(len(imgarray)):
        for col in range(len(imgarray[row])):
            acc+=pow(imgarray[row][col]-comparray[row][col],2)
    return (1-(acc/81.0/sum([len(row) for row in imgarray]))**.5)**8

def fuse_squares(squarray):
    output=[]
    counter=0
    scounter=0
    sqrow=0
    while sqrow<len(squarray):
        if scounter<len(squarray[sqrow][0]):
            output.append([])
            for square in squarray[sqrow]:
                output[counter].extend(square[scounter])
            scounter+=1
            counter+=1
        else:
            scounter=0
            sqrow+=1
    return output

def main_calc(imgarray,threshold):
    imgarray = image_to_brightness(imgarray)
    size = 9
    quality = 0
    compimg=[]
    datarray=[]
    testdata = [vars_to_data(c,s,e) for c in range(4) for s in range(10) for e in range(10)]
    while quality<threshold:
        squares = split_into_squares(imgarray,size)
        compimg = []
        datarray = []
        testblock = [gen_block(c,s,e,size) for c in range(4) for s in range(10) for e in range(10)]
        for row in squares:
            comprow = []
            datrow=[]
            for square in row:
                quality_values = [calc_quality(square,block) for block in testblock]
                best_quality = quality_values.index(max(quality_values))
                comprow.append(testblock[best_quality])
                datrow.append(testdata[best_quality])
            compimg.append(comprow)
            datarray.append(datrow)
        compimg = fuse_squares(compimg)
        quality = calc_quality(imgarray,compimg)
        print("Size:{} Quality:{}".format(size,quality))
        size-=1
    return brightness_to_image(compimg),datarray,size+1

template = '''def s(d,s,e,z):
 x=range(z)
 return d<1 and[[int((z-r)*(e-s)/z+s)for c in x]for r in x]or d==1 and[[int((z-c)*(e-s)/z+s)for c in x]for r in x]or d==2 and[[int((2*z-r-c)/2*(e-s)/z+s)for c in x]for r in x]or d>2 and[[int((z-r+c)/2*(e-s)/z+s)for c in x] for r in x]
i=lambda a:'\\n'.join([''.join(map(lambda r:" `.,:;'+#@"[r],l))for l in a])
def f(a):
 o=[];c=0;s=0;r=0
 while r<len(a):
  if s<len(a[r][0]):
   o.append([])
   for q in a[r]:
    o[c].extend(q[s])
   s+=1;c+=1
  else:
   s=0;r+=1
 return o
t={};z={}
print(i(f([[s(D>>8,(D>>4)&15,D&15,z)for D in R]for R in t])))'''

template_size_1 = '''print("""{}""")'''   

def main(filename,threshold):
    print(filename+" "+str(threshold))
    file = open(filename,'r')
    compimg,datarray,size = main_calc(file.read(),threshold)
    file.close()
    textoutput = open(filename.split(".")[0]+"-"+str(threshold*100)+".txt",'w')
    textoutput.write(compimg)
    textoutput.close()
    compoutput = open(filename.split(".")[0]+"-"+str(threshold*100)+".py",'w')
    datarray = str(datarray).replace(" ","")
    code = ""
    if size==1:
        code = template_size_1.format(compimg)
    else:
        code= template.format(datarray,str(size))
    compoutput.write(code)
    compoutput.close()
    print("done")

if __name__ == "__main__":
    main(sys.argv[1],float(sys.argv[2]))

यह उत्तर बहुत सारे सुधारों का उपयोग कर सकता है , इसलिए मैं संभवत: सप्ताहांत में इस पर काम करूंगा।

यह कैसे काम करता है:

• छवि को आकार के ब्लॉक में विभाजित करें size।
• सबसे अच्छा मिलान ब्लॉक का पता लगाएं
  • ब्लॉक अब ढाल हो सकता है!
• संपूर्ण छवि के लिए गुणवत्ता (सूत्र के अनुसार) की गणना करें।
• यदि सही है, तो फ़ाइल में ज़िपित छवि लिखें।
• अन्यथा, क्षय sizeऔर फिर से प्रयास करें।

यह एल्गोरिथ्म कम गुणवत्ता (0.5, 0.6) के लिए अच्छी तरह से काम करता है, लेकिन उच्च गुणवत्ता वाली छवियों (वास्तव में फुलाता है) पर बहुत अच्छा काम नहीं करता है। यह वास्तव में धीमा भी है।

यहां मेरे पास सभी जेनरेट की गई फाइलें हैं, इसलिए आपको उन्हें फिर से जेनरेट नहीं करना पड़ेगा।

Comments

अंत में, एक जवाब! यह तकनीकी रूप से गैर-प्रतिस्पर्धात्मक है, क्योंकि मैंने इस चुनौती को पोस्ट करने के बाद बबलगम बनाया ... मैं बाद में स्कोरिंग स्क्रिप्ट चलाऊंगा और शायद इसे कम गूढ़ भाषा में पोर्ट करूंगा।

— डेनिस

@ डेनिस आह, अच्छी तरह से एक अजगर स्क्रिप्ट के लिए आउटपुट पोर्ट करना बहुत मुश्किल नहीं होना चाहिए। हेड-अप के लिए धन्यवाद

— ब्लू

मैं अपनी चुनौती को फिर से पढ़ता हूं (एक साल के बाद, मैं विवरणों पर थोड़ा फजी था), और यह कहता है कि आपका कंप्रेसर बिल्ट-इन बाइट स्ट्रीम कंप्रेशर्स (जैसे, जीज़िप) का उपयोग कर सकता है, लेकिन आपको उन्हें खुद के लिए लागू करना होगा। संकुचित चित्र। इसका मतलब है कि बबलगम वैसे भी बाहर है।

— डेनिस

मुझे अंत में याद आया कि मैंने यह स्कोर करने का वादा किया था; विलंब के लिए क्षमा चाहते हैं। आपके कोड में एक टाइपो ( compingहोना चाहिए compimg) लगता है, जिसे मैंने प्रोग्राम चलाने के लिए तय किया है। जब तक आपके कोड को चलाते समय मैंने कोई गलती नहीं की है, कुछ उत्पन्न छवियों के आयाम गलत हैं (उदाहरण के लिए, 33,164 image2.txtबाइट्स हैं, लेकिन image2-50.0.txt33,329 हैं) और अन्य उत्पन्न प्रोग्राम चलाने के दौरान समान फ़ाइल उत्पन्न नहीं करते हैं ( 0.5110 कीimage3-50.0.txt गुणवत्ता है ) , लेकिन उत्पन्न कार्यक्रम का परिणाम 0.4508 की गुणवत्ता में है )।

— डेनिस

परिशिष्ट: मैंने image3-50.0.pyआपके ड्रॉपबॉक्स से डाउनलोड किया है और यह मेरे द्वारा बनाई गई फ़ाइल से मेल खाता है।

— डेनिस