লসী এএসসিআইআই আর্ট কম্প্রেশন

Question

পটভূমি

পিকাসসিআইআই একটি ঝরঝরে সরঞ্জাম যা চিত্রগুলিকে ASCII আর্টে রূপান্তর করে।

এটি নিম্নলিখিত দশটি ASCII অক্ষর ব্যবহার করে উজ্জ্বলতার বিভিন্ন ডিগ্রি অর্জন করে:

@#+';:,.` 

আমরা বলব যে এই চার্সেলগুলির (চরিত্রের উপাদানগুলি) 1 (এট-সাইন) থেকে 10 (স্পেস) পর্যন্ত উজ্জ্বলতা রয়েছে।

নীচে, আপনি একটি সামান্য কোড রূপান্তর করার ফলাফল দেখতে পারেন, ওয়েলশ পতাকা, একটি ওভারহ্যান্ড ফ্র্যাক্টাল, একটি বিশাল ট্রাউট এবং একটি সামান্য গল্ফ, সঠিক ফন্টের সাথে প্রদর্শিত:

আপনি এই ফ্রিডલમાં চিত্রগুলি দেখতে এবং Google ড্রাইভ থেকে এগুলি ডাউনলোড করতে পারেন ।

কার্য

পিকাসিএসআইআইয়ের শেষ ফলাফলগুলি দৃষ্টি আকর্ষণীয় হওয়ার সাথে সাথে, পাঁচটি ছবি মিলিয়ে 153,559 বাইট ওজনের। এই চিত্রগুলি কতটা সংকুচিত হতে পারে যদি আমরা তাদের মানের অংশের ত্যাগ করতে ইচ্ছুক?

আপনার কাজটি এমন একটি প্রোগ্রাম লিখুন যা উপরোক্ত চিত্রগুলির মতো কোনও ASCII আর্ট চিত্র গ্রহণ করে এবং ইনপুট হিসাবে ন্যূনতম মানের এবং চিত্রটির একটি ক্ষতিকারক সংকোচনাকে মুদ্রণ করে - একটি সম্পূর্ণ প্রোগ্রাম বা কোনও ফাংশন একটি একক স্ট্রিং ফিরিয়ে দেয় - যা সন্তুষ্ট করে মানের প্রয়োজন।

এর অর্থ হল যে আপনি পৃথক ডিকম্প্রেসার লিখতে পারবেন না; এটি প্রতিটি সংকুচিত চিত্রের অন্তর্নির্মিত হতে হবে।

মূল চিত্রটিতে 1 থেকে 10 এর মধ্যে উজ্জ্বলতা সহ চার্জেল থাকবে, একই দৈর্ঘ্যের লাইনে লাইনফিড দ্বারা আলাদা করা হবে। সংকুচিত চিত্রের একই মাত্রা থাকতে হবে এবং একই অক্ষরের সেট ব্যবহার করতে হবে।

এন চারক্সেল সমন্বিত একটি সঙ্কোচিত চিত্রের জন্য, চিত্রটির একটি সংকোচিত সংস্করণের মান হিসাবে সংজ্ঞায়িত করা হয়

যেখানে সি _i উজ্জ্বলতা হয় আমি ^তম সংকুচিত চিত্রের আউটপুট charxel এবং তোমার দর্শন লগ করা _আমি উজ্জ্বলতা আমি ^তম ডিকম্প্রেস করা ইমেজ charxel।

স্কোরিং

আপনার কোডটি উপরের পাঁচটি চিত্রের সাথে ইনপুট হিসাবে এবং প্রতিটি চিত্রের জন্য 0.50, 0.60, 0.70, 0.80 এবং 0.90 ন্যূনতম মানের সেটিংস হিসাবে পরিচালিত হবে।

আপনার স্কোর হ'ল সমস্ত সংকুচিত চিত্রের আকারের জ্যামিতিক গড়, অর্থাত্ সমস্ত পঁচিশটি সংক্ষিপ্ত চিত্রের দৈর্ঘ্যের পণ্যের পঁচিশতম মূল।

সর্বনিম্ন স্কোর জয়!

অতিরিক্ত বিধি

• আপনার কোডটি কেবল স্কোরিংয়ের জন্য ব্যবহৃত নয়, স্বেচ্ছাসেবী চিত্রগুলির জন্য কাজ করতে হবে।

  আশা করা যায় যে আপনি পরীক্ষার ক্ষেত্রে আপনার কোডটি সর্বোত্তম করে তোলেন, তবে এমন একটি প্রোগ্রাম যা স্বেচ্ছাসেবী চিত্রগুলি সংকোচনের চেষ্টাও করে না, আমার কাছ থেকে উত্সাহ পাবেন না।

• আপনার সংক্ষিপ্তকারী বিল্ট-ইন বাইট স্ট্রিম সংকোচকারী (যেমন, জিজিপ) ব্যবহার করতে পারে তবে সংক্ষেপিত চিত্রগুলির জন্য আপনাকে সেগুলি নিজেই প্রয়োগ করতে হবে।

  বাইট স্ট্রিম ডিকম্প্রেসারগুলিতে সাধারণত বুলেট-ইনগুলি ব্যবহার করা হয় (যেমন, বেস রূপান্তর, রান-লেংথ ডিকোডিং)।

• সংক্ষিপ্তকারী এবং সংকোচিত চিত্রগুলি একই ভাষায় থাকতে হবে না।

  তবে, সমস্ত সংকুচিত চিত্রগুলির জন্য আপনাকে অবশ্যই একটি ভাষা বেছে নিতে হবে।

• প্রতিটি সংকুচিত চিত্রের জন্য, স্ট্যান্ডার্ড কোড গল্ফ বিধি প্রযোজ্য।

প্রতিপাদন

আমি সহজেই সমস্ত মানের প্রয়োজনীয়তা যাচাই করতে এবং জমা দেওয়ার স্কোর গণনা করতে একটি সিজেএম স্ক্রিপ্ট তৈরি করেছি।

আপনি এখানে বা এখান থেকে জাভা ইন্টারপ্রেটার ডাউনলোড করতে পারেন ।

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

উদাহরণ

বাশ → পিএইচপি, স্কোর 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 বেছে নেয় তবে ইনপুট ফাইলের প্রতিটি চরকে আউটপুটে অর্ধেক উজ্জ্বলতার সাথে চরটি প্রতিস্থাপন করা উচিত, তাই না? স্পষ্টতই সাদা স্থান বাদ দিলে এটি পুরো চিত্রটিকে বিশৃঙ্খলা করবে।

— নিকোলের সিপলিস

এটি সমস্ত খুব বিভ্রান্তিকর এবং লুফোলি। কীভাবে থামবেন a ম্যাটমাহোনি.নেট / ডিসি / বার্ফ.এইচটিএমএল প্রবেশ ? সংক্রামক সংক্ষিপ্ত চিত্র ছাড়া অন্য যে কোনও ফাইল পড়তে পারেন? আপনি কি একটি অজগর স্ক্রিপ্ট বা এমন কিছু সরবরাহ করতে পারেন যা প্রকৃতপক্ষে কোনও চিত্রের গুণমানটি পরীক্ষা করে এবং একটি স্কোর গণনা করে যাতে সেই সামনের দিকেও কোনও বাজে থাকতে পারে না? ইত্যাদি

— উইল

@ উইল বিভ্রান্ত করবেন? হতে পারে. তবে আমি মনে করি না এটি লুপফোলি। প্রতিটি সংকুচিত চিত্র একটি প্রোগ্রাম বা ফাংশন হতে হবে, সুতরাং BARF এর মত অস্বাভাবিক রসিকতা স্বয়ংক্রিয়ভাবে বাদ দেওয়া হয়। আমি পাইথন জানি না, তবে আমি সাধারণ যাচাইয়ের জন্য কিছু চিন্তা করব।

— ডেনিস

"আমি সহজেই সমস্ত মানের প্রয়োজনীয়তা যাচাই করতে এবং জমা দেওয়ার স্কোর গণনা করতে একটি সিজেএম স্ক্রিপ্ট তৈরি করেছি" " লোকেরা কি সত্যই সাধারণ স্ক্রিপ্টগুলি করতে এই জিনিসটি ব্যবহার করে? প্রিয় প্রভু ...

— অনুঘটক করুন

Answer 1

জাভা → সিজেম, স্কোর ≈4417.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 টি পরীক্ষার চিত্রগুলিতে তার স্কোর গণনা করে, যা বর্তমান ডিরেক্টরিতে অনুমান করা হয়। প্রোগ্রামটি প্রতিটি সংকুচিত চিত্র স্বয়ংক্রিয়ভাবে যাচাই করে। কোনও তাত্পর্য থাকলে আপনি স্কোর গণনা ডাবল-চেক করতে চাইতে পারেন।

ব্যবহৃত কৌশলগুলি (এখনও অবধি) হ'ল: স্কেলিংটি অর্ধেক (আনুভূমিকভাবে, উল্লম্বভাবে বা উভয়) যদি এটি মানকে খুব বেশি হ্রাস না করে তবে একটি কাস্টম-কোডেড আরএলই এবং প্রতিটি চরিত্রের মধ্যে আরও ডেটা প্যাক করার জন্য বেস রূপান্তরটি অবশিষ্ট থাকাকালীন থাকে মুদ্রণযোগ্য এএসসিআইআই ব্যাপ্তি।

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 CompressCJam বর্গ খুঁজে নেই।

— ডেনিস

@ ডেনিস আপনাকে ক্লাসপথ (-cp) তে কমপ্রেস.ক্লাসযুক্ত ডিরেক্টরি যুক্ত করতে হবে। যদি এটি বর্তমান ডিরেক্টরিতে থাকে তবে ব্যবহার করুন -cp .:cjam-0.6.5.jar(উইন্ডোজটিতে আমার মনে হয় আপনার কোনও কোলনের পরিবর্তে অর্ধবৃত্ত প্রয়োজন)

— অ্যাডিটসু

কৌতুকটি করেছে, আপনাকে ধন্যবাদ।

— ডেনিস

Answer 2

পাইথন 3.5 (প্রধান এবং আউটপুট) (বর্তমানে নন-কেপটিং)

শুভ জন্মদিন, চ্যালেঞ্জ! এখানে আপনার বর্তমান: একটি উত্তর!

সম্পাদনা: পাইথন কোডে রূপান্তরিত আউটপুট, উন্নত সংকোচনের হার (সামান্য) EDIT2: এটি কাঁচা মুদ্রণ তৈরি যখন size 1. উন্নত স্কোর, তবে স্কোরটি আবার গণনা করা দরকার। সম্পাদনা: @ ডেনিস উল্লেখ করেছিলেন যে আমি এখনও বাগগুলি ঠিক করতে পেরেছি, সুতরাং আমি উত্তরটি নন-কার্পেটিং হিসাবে চিহ্নিত করেছি

কোড:

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) রয়েছে বলে মনে হচ্ছে , যা আমি প্রোগ্রামটি চালানোর জন্য স্থির করেছি। আপনার কোডটি চালনার সময় আমি যদি ভুল না করি তবে উত্পন্ন কিছু চিত্রের মাত্রা ভুল (যেমন, image2.txt33,164 বাইট রয়েছে, তবে image2-50.0.txt33,329 রয়েছে) এবং অন্যান্য উত্পন্ন প্রোগ্রামগুলি চালনার সময় একই ফাইলটি তৈরি করে না ( 0.5110 এরimage3-50.0.txt মানের রয়েছে ) , কিন্তু উত্পাদিত প্রোগ্রামটি চালানোর ফলে 0.4508 মানের মানের ফলাফল পাওয়া যায় )।

— ডেনিস

সংযোজন: আমি image3-50.0.pyআপনার ড্রপবক্স থেকে ডাউনলোড করেছি এবং এটি আমার উত্পন্ন ফাইলটির সাথে মেলে।

— ডেনিস