ক্ষুধার্ত চিত্র সাপ - হোল # 3

Question

হোল # 1

জো সাপ ক্ষুধার্ত।

সে ছবি খায়, একবারে এক পিক্সেল।

তিনি সত্যিই উজ্জ্বল পিক্সেল পছন্দ করেন।

চ্যালেঞ্জ

তিনি যে সর্বাধিক উজ্জ্বল পিক্সেলগুলি সন্ধান করতে পারেন প্রোগ্রামটি পান, কেবলমাত্র তিনি উপরে, নীচে, বাম বা ডানদিকে যেতে পারেন।

বিশেষ উল্লেখ

• জো অবশ্যই ছবির উপরের বাম পিক্সেল থেকে শুরু করতে হবে।
• জো প্রতিটি পদক্ষেপে 1 দ্বারা অনুভূমিক বা উল্লম্বভাবে অগ্রসর হতে পারে
• ছবিতে পিক্সেলের পরিমাণের 1/3 স্থান (পিক্সেল হিসাবে 1/3 যত বেশি মুভ) সরানোর জন্য জোয়ের যথেষ্ট সময় রয়েছে। যদি পিক্সেলের সংখ্যা 3 এর একাধিক না হয় তবে নিকটতম পূর্ণসংখ্যকে বৃত্তাকারে নামান।
• জো তার পথ অতিক্রম করতে পারে, যদিও এটি 0 উজ্জ্বলতা হিসাবে গণনা করা হয়
• উজ্জ্বলতা r, g এবং b এর যোগফলের উপর ভিত্তি করে তৈরি হয়, সুতরাং rgb (0,0,0) 0 এর উজ্জ্বলতা থাকে যখন rgb (255,255,255) সর্বাধিক উজ্জ্বলতা থাকে।

ইনপুট

আপনি পছন্দ মতো ইমেজ ইনপুট করতে পারেন।

আউটপুট

• একটি চিত্র আপনার ছবির শেষ ফলাফল দেখাচ্ছে (কালো পিক্সেল খাওয়া সহ)।
• খাওয়ার উজ্জ্বলতার পরিমাণ (দয়া করে আপনার উত্তরের পরিসরটি নির্দিষ্ট করুন)

স্কোরিং

আপনার প্রোগ্রামটি গ্রেড করা হবে:

• জো পিক্সেলের গড় উজ্জ্বলতা / ছবিতে পিক্সেলের গড় উজ্জ্বলতা *

* আপনি আপনার প্রোগ্রাম এ হার্ডকোড করতে পারেন

আপনার মোট স্কোর নিম্নলিখিত চিত্রগুলির জন্য স্কোরের গড় হবে:

পরীক্ষার চিত্রসমূহ:

http://upload.wikimedia.org/wikipedia/en/thumb/f/f4/The_Scream.jpg/800px-The_Scream.jpg

Comments

মজাদার Markdown সত্য - তুমি এগুলির মূল লিঙ্ক মধ্যে চিত্র চালু করতে পারে: [![image description](SE URL for downsized image)](URL for original image)।

— ক্যালভিনের শখ

লোকদের উত্তরগুলিতে একটি উদাহরণ "খাওয়া" চিত্র অন্তর্ভুক্ত করার জন্য জিজ্ঞাসা করা একটি ধারণা হতে পারে।

— নাথানিয়েল

1 টি চিত্রটি নষ্ট হয়েছে: আপলোড.উইকিমিডিয়া.আর

— উইকিপিডিয়া

Answer 1

সি ++, স্কোর: 1,42042 1,46766

এটি বিদ্যমান দুটি সমাধানের মূলত আরও কিছুটা পরিশীলিত সংস্করণ: চারটি সম্ভাব্য পদক্ষেপের মধ্যে, এটি উজ্জ্বলতা সর্বাধিকীকরণকারী একটি নির্বাচন করে। তবে লক্ষ্যমাত্রার পিক্সেলের উজ্জ্বলতার দিকে তাকানোর পরিবর্তে লক্ষ্য পিক্সেলের আশেপাশের পিক্সেল-উজ্জ্বলতার ভারযুক্ত সমষ্টিটি লক্ষ্য করে, যেখানে লক্ষ্যটির নিকটে থাকা পিক্সেলের ওজন বেশি থাকে।

সম্পাদনা: পাড়ার গণনায় ননলাইনার উজ্জ্বলতা ব্যবহার করা স্কোরকে কিছুটা উন্নত করে।

সঙ্গে সংকলন g++ joe.cpp -ojoe -std=c++11 -O3 -lcairo। কায়রো প্রয়োজন।

সাথে চালাও joe <image-file> [<radius>]। <image-file>ইনপুট পিএনজি চিত্র। <radius>(ঐচ্ছিক যুক্তি) পিক্সেলে, সংকলিত ওভারের আশপাশ ব্যাসার্ধ আছে (ছোট দ্রুততর করতে, বৃহত্তর (প্রায়) ভাল। হয়) আউটপুট স্কোর এবং একটি চিত্র নামে out.<image-file>।

#include <cairo/cairo.h>
#include <iostream>
#include <iterator>
#include <algorithm>
#include <string>

using namespace std;

int main(int argc, const char* argv[]) {
    auto* img = cairo_image_surface_create_from_png(argv[1]);
    int width = cairo_image_surface_get_width(img),
        height = cairo_image_surface_get_height(img),
        stride = cairo_image_surface_get_stride(img);
    unsigned char* data = cairo_image_surface_get_data(img);

    double* brightness = new double[width * height];
    double total_brightness = 0;
    for (int y = 0; y < height; ++y) {
        for (int x = 0; x < width; ++x) {
            const unsigned char* p = data + stride * y + 4 * x;
            total_brightness += brightness[y * width + x] = p[0] + p[1] + p[2];
        }
    }

    const int r = argc > 2 ? stoi(argv[2]) : 64, R = 2 * r + 1;
    double* weight = new double[R * R];
    for (int y = -r; y <= r; ++y) {
        for (int x = -r; x <= r; ++x)
            weight[R * (y + r) + (x + r)] = 1.0 / (x*x + y*y + 1);
    }

    auto neighborhood = [&] (int x, int y) {
        double b = 0;
        int x1 = max(x - r, 0), x2 = min(x + r, width - 1);
        int y1 = max(y - r, 0), y2 = min(y + r, height - 1);
        for (int v = y1; v <= y2; ++v) {
            const double *B = brightness + width * v + x1;
            const double *W = weight + R * (v - (y - r)) + (x1 - (x - r));
            for (int u = x1; u <= x2; ++u, ++B, ++W)
                b += (*W) * (*B) * (*B);
        }
        return b;
    };

    int n = (2 * width * height + 3) / 6;
    int x = 0, y = 0;
    double path_brightness = 0;
    int O[][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    for (int i = 0; i < n; ++i) {
        if (i % 1000 == 0) cerr << (200 * i + n) / (2 * n) << "%\r";

        path_brightness += brightness[width * y + x]; brightness[width * y + x] = 0;
        unsigned char* p = data + stride * y + 4 * x;
        p[0] = p[1] = 16 * i % 255; p[2] = 0;

        auto O_end = partition(begin(O), end(O), [&] (const int* o) {
            return x + o[0] >= 0 && x + o[0] < width &&
                   y + o[1] >= 0 && y + o[1] < height;
        });
        const int* o_max; double o_max_neighborhood = -1;
        for (auto o = O; o != O_end; ++o) {
            double o_neighborhood = neighborhood(x + (*o)[0], y + (*o)[1]);
            if (o_neighborhood > o_max_neighborhood)
                o_max = *o, o_max_neighborhood = o_neighborhood;
        }
        x += o_max[0]; y += o_max[1];
    }

    cout << (path_brightness * width * height) / (n * total_brightness) << endl;

    cairo_surface_write_to_png(img, (string("out.") + argv[1]).c_str());

    delete []brightness;
    delete []weight;
    cairo_surface_destroy(img);
}

ফলাফল

Bridge    1.39945
Balls     1.77714
Scream    1.38349
Fractal   1.31727
Vortex    1.66493
Tornado   1.26366
-----------------
Average   1.46766

আরও আই-ক্যান্ডি

Comments

আমি কেবলমাত্র আমার নিজস্ব কিছু নমুনা চিত্রগুলিতে আপনার প্রোগ্রামটি চেষ্টা করেছি এবং কেবলমাত্র শুরুর পয়েন্টের আশেপাশে খুব কালো রঙ রয়েছে, এবং সেখানে পার্শ্ববর্তী ল্যাম্বদা এনএএন ফিরে আসার কারণে আপনার প্রোগ্রামটি ক্র্যাশ হয়েছে।

— প্লাজমাএইচএইচ

@ প্লাজমাএইচইচ মন আপত্তিজনক চিত্রটি ভাগ করছেন?

— Ell

আমি এটি ছুটির চিত্রগুলি খাচ্ছিলাম ... 400x400 খাঁটি কালো যদিও "ট্রিক" করে।

— প্লাজমাএইচএইচ

@ প্লাজমাএইচএইহহ ওয়েল, খাঁটি কালো চিত্রটির একটি অপরিজ্ঞাত স্কোর রয়েছে, এটি শূন্যের চেয়ে শূন্য, এটি একটি এনএএন হবে। এটি আশেপাশের গণনার উপর প্রভাব ফেলবে না, যদিও প্রোগ্রামটি ক্র্যাশ করবে (যদিও এটি ভাসমান-পয়েন্ট পরিবেশের উপর নির্ভর করে))

— ইল

O_max পয়েন্টারটি একবার দেখুন if (o_neighborhood > o_max_neighborhood) o_max = *o, o_max_neighborhood = o_neighborhood;এই কোডটি সেট করে। তবে ন্যান জড়িত থাকার কারণে, তুলনাটি সর্বদা মিথ্যা, সুতরাং__ম্যাক্স কখনও সেট করা হয় না এবং অবিশ্রুত ব্যবহার করা হয় না।

— প্লাজমাএইচএইচ

Answer 2

পাইথন 3, স্কোর = 1.57

প্রথমে আমাদের সাপ একে অপরের থেকে সমান দূরত্বের সাথে উল্লম্ব রেখা তৈরি করে চিত্র ভ্রমণ করে।

উল্লম্ব লাইনে একে অপরের পাশে দুটি পয়েন্ট নিয়ে এবং একটি লুপ তৈরি করে যার প্রান্তগুলি সেগুলি করে আমরা এই সাপটিকে প্রসারিত করতে পারি।

|      |
|  =>  +----+
|      +----+
|      |

আমরা পয়েন্টগুলিকে জোড়গুলিতে সংগঠিত করি এবং প্রতিটি জোড়ের জন্য আমরা লুপের আকার এবং গড় উজ্জ্বলতার মানটি সংরক্ষণ করি যা দেয় সবচেয়ে ভাল গড় উজ্জ্বলতা।

প্রতিটি পদক্ষেপে আমরা এক্সটেনশনে সর্বাধিক গড় উজ্জ্বলতা অর্জন করতে তার লুপটি প্রসারিত করি এবং জোড়ার জন্য নতুন অনুকূল লুপের আকার এবং উজ্জ্বলতার মান গণনা করি highest

আমরা মান অনুসারে বাছাই করা একটি হিপ স্ট্রাকচারে (মান, আকার, পয়েন্ট_ পেয়ার) ট্রিপলটি সংরক্ষণ করি যাতে আমরা সবচেয়ে বড় উপাদানটি (O (1)) মুছে ফেলতে পারি এবং দক্ষতার সাথে নতুন সংশোধিত একটি (ও (লগ এন) এ যুক্ত করতে পারি।

যখন আমরা পিক্সেল গণনা সীমাতে পৌঁছে যাই তখন আমরা থামি এবং সেই সাপটি চূড়ান্ত সাপ হবে।

উল্লম্ব রেখাগুলির মধ্যে দূরত্বের ফলাফলগুলিতে খুব কম প্রভাব পড়েছে তাই একটি ধ্রুব 40 পিক্সেল বেছে নেওয়া হয়েছিল।

ফলাফল

swirl    1.33084397946
chaos    1.76585674741
fractal  1.49085737611
bridge   1.42603926741
balls    1.92235115238
scream   1.48603818637
----------------------
average  1.57033111819

দ্রষ্টব্য: মূল "দ্য স্ক্রিম" ছবিটি উপলভ্য ছিল না তাই আমি অনুরূপ রেজোলিউশনের সাথে অন্য একটি "দ্য স্ক্রিম" ছবি ব্যবহার করেছি।

জিআইএফ "ঘূর্ণি" চিত্রটিতে সাপকে প্রসারিত করার প্রক্রিয়া দেখায়:

কোডটি স্টিডিনের থেকে একটি (বা আরও বেশি স্থান বিচ্ছিন্ন) ফাইলের নাম (গুলি) নেয় এবং ফলস্বরূপ সাপ চিত্রগুলি ফাইলের পিএনজি লিখায় এবং স্কোরগুলি স্টাডাউটে মুদ্রণ করে।

from PIL import Image
import numpy as np
import heapq as hq

def upd_sp(p,st):
    vs,c=0,0
    mv,mp=-1,0
    for i in range(st,gap):
        if p[1]+i<h:
            vs+=v[p[0],p[1]+i]+v[p[0]+1,p[1]+i]
            c+=2
            if vs/c>mv:
                mv=vs/c
                mp=i
    return (-mv,mp)

mrl=[]
bf=input().split()

for bfe in bf:
    mr,mg=0,0    
    for gap in range(40,90,1500):

        im=Image.open(bfe)
        im_d=np.asarray(im).astype(int)

        v=im_d[:,:,0]+im_d[:,:,1]+im_d[:,:,2]

        w,h=v.shape

        fp=[]
        sp=[]
        x,y=0,0
        d=1

        go=True
        while go:
            if 0<=x+2*d<w:
                fp+=[(x,y)]
                fp+=[(x+d,y)]
                sp+=[(x-(d<0),y)]
                x+=2*d
                continue
            if y+gap<h:
                for k in range(gap):
                    fp+=[(x,y+k)]
                y+=gap
                d=-d
                continue
            go=False

        sh=[]
        px=im.load()

        pl=[]

        for p in fp:
            pl+=[v[p[0],p[1]]]
            px[p[1],p[0]]=(0,127,0)   

        for p in sp:
            mv,mp=upd_sp(p,1)
            if mv<=0:
                hq.heappush(sh,(mv,1,mp+1,p))

        empty=False
        pleft=h*w//3
        pleft-=len(fp)
        while pleft>gap*2 and not empty:

            if len(sh)>0:
                es,eb,ee,p=hq.heappop(sh)
            else:
                empty=True
            pleft-=(ee-eb)*2

            mv,mp=upd_sp(p,ee)
            if mv<=0:
                hq.heappush(sh,(mv,ee,mp+1,p))    

            for o in range(eb,ee):
                pl+=[v[p[0],p[1]+o]]
                pl+=[v[p[0]+1,p[1]+o]]
                px[p[1]+o,p[0]]=(0,127,0)   
                px[p[1]+o,p[0]+1]=(0,127,0)

        pl+=[0]*pleft

        sb=sum(pl)/len(pl)
        ob=np.sum(v)/(h*w)

        im.save(bfe[:-4]+'snaked.png')

        if sb/ob>mr:
            mr=sb/ob
            mg=gap

    print(bfe,mr)
    mrl+=[mr]

print(sum(mrl)/len(mrl))

Answer 3

পাইথন 2 (স্কোর: 0.0797116)

বলটি রোলিংয়ের জন্য খুব সাধারণ এবং নির্বোধ লোভী অ্যালগরিদম।

#!/usr/bin/python

from PIL import Image

OFFSETS = [(-1, 0), (0, -1), (1, 0), (0, 1)]
def test_img(filename):
    img = Image.open(filename)

    joe, eaten = (0, 0), []
    img_w, img_h = img.size
    all_pixels = [
        sum(img.getpixel((x, y)))
        for x in xrange(img_w)
        for y in xrange(img_h)
    ]
    total_brightness = float(sum(all_pixels)) / len(all_pixels)

    for _ in xrange(0, (img_w*img_h)/3):
        max_offset, max_brightness = (0, 0), 0
        for o in OFFSETS:
            try:
                brightness = sum(img.getpixel((joe[0] + o[0], joe[1] + o[1])))
            except IndexError:
                brightness = -1
            if brightness >= max_brightness:
                max_offset = o
                max_brightness = brightness

        joe = (joe[0] + max_offset[0], joe[1] + max_offset[1])
        eaten.append(max_brightness)
        img.putpixel(joe, (0, 0, 0))

    eaten_brightness = float(sum(eaten)) / len(eaten)
    print('%d of %d (score %f)' % (eaten_brightness, total_brightness, eaten_brightness / total_brightness))
    img.show()

test_img('img0.jpg')
test_img('img1.png')
test_img('img2.jpg')
test_img('img3.jpg')
test_img('img4.jpg')

আউটপুট:

llama@llama:~/Code/python/ppcg40069hungrysnake$ ./hungrysnake.py 
15 of 260 (score 0.060699)
9 of 132 (score 0.074200)
16 of 300 (score 0.055557)
4 of 369 (score 0.010836)
79 of 400 (score 0.197266)

Comments

আমি মনে করি আপনার স্কোরিং বন্ধ আছে। পুরো চিত্রের গড় উজ্জ্বলতার চেয়ে এটি খাওয়ার জোয়ের গড়পড়তা ... একটি এলোমেলো জো মোটামুটি ১ স্কোর পেয়েছে

— স্ট্রেচ ম্যানিয়াক

@ স্ট্রেচমানিয়াক হুম, আমি কোনও ভুল দেখছি না। sum of brightnesses of eaten pixels / amount of eaten pixelsসঠিক সূত্র, সঠিক? হতে পারে এটি কেবল একটি সত্যই ভয়ঙ্কর অ্যালগরিদম;)

— ডোরকনব

@ ডুরকনব এটিThe average brightness of pixels Joe eats / The average brightness of the pixels in the picture*

— hmatt1

কমলা এবং কালো স্যুইরিলি (নীল নয়) একের জন্য, আমি গড় উজ্জ্বলতা পেয়েছি 68.0846 ... যা আপনার কারও সাথে মেলে না বলে মনে হয়। সম্ভবত যোগফল (গেটপিক্সেল (...)) আপনি যা চান তা ফেরত দেয় না? (আমি কিন্ডার পাইথন নবাগত)। বিটিডাব্লু, এখানে pictures টি ছবি রয়েছে তবে আপনার কাছে কেবল পাঁচটি আউটপুট রয়েছে। আপনি কি কোনওভাবে ছবি লেবেল করতে পারেন?

— টানা উন্মাদ

@ স্ট্রেচমানিয়াক আপনি কীভাবে আপনার উজ্জ্বলতা গণনা করছেন? খনিতে কেবল আর, জি এবং বি মানগুলির যোগফল। দুঃখিত, আমি দ্বিতীয়ার থেকে শেষের দিকে আসে এমন ঝকঝকে একটিটি মিস করেছি (আপনি নিজের মন্তব্যে যা উল্লেখ করেছেন, আমি মনে করি)। আমি সকালে এটি যোগ করব (আমাকে এখন ঘুমাতে হবে)।

— ডোরকনবব

Answer 4

জাভা (স্কোর: 0.6949)

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

এটা, হয় সম্পাদন করা তিনটি আর্গুমেন্ট সোর্সে (ক্লাস ধ্রুবক যেমন বিদ্যমান) চালাতে, অথবা আকারে কমান্ড লাইন এর মাধ্যমে তাদের পাস java HungryImageSnake <source> <iterations> <printScores>যেখানে <source>ইমেজ খেতে উৎস ফাইল, <iterations>বার চিত্র খেতে সংখ্যা (নিচ্ছে গড় স্কোর এবং সমস্ত পুনরাবৃত্তির চেয়ে সেরা স্কোর সংরক্ষণ করে) এবং <printScores>প্রতিটি পুনরাবৃত্তির স্কোর প্রিন্ট করা সত্য বা মিথ্যা নয়।

import javax.imageio.ImageIO;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Random;

public class HungryImageSnake {

    private static final String SOURCE = "tornado.jpg";
    private static final int ITERATIONS = 50;
    private static final boolean PRINT_SCORES = true;

    public static void main(String[] args) {
        try {
            String source = args.length > 0 ? args[0] : SOURCE;
            int iterations = args.length > 1 ? Integer.parseInt(args[1]) : ITERATIONS;
            boolean printScores = args.length > 2 ? Boolean.parseBoolean(args[2]) : PRINT_SCORES;

            System.out.printf("Reading '%s'...%n", source);
            System.out.printf("Performing %d meals...%n", iterations);
            BufferedImage image = ImageIO.read(new File(source));
            double totalScore = 0;
            double bestScore = 0;
            BufferedImage bestImage = null;
            for (int i = 0; i < iterations; i++) {
                HungryImageSnake snake = new HungryImageSnake(image);
                while (snake.isHungry()) {
                    snake.eat();
                }
                double score = snake.getScore();
                if (printScores) {
                    System.out.printf("    %d: score of %.4f%n", i + 1, score);
                }
                totalScore += score;
                if (bestImage == null || score > bestScore) {
                    bestScore = score;
                    bestImage = snake.getImage();
                }
            }
            System.out.printf("Average score: %.4f%n", totalScore / iterations);
            String formattedScore = String.format("%.4f", bestScore);
            String output = source.replaceFirst("^(.*?)(\\.[^.]+)?$", "$1-b" + formattedScore + "$2");
            ImageIO.write(bestImage, source.substring(source.lastIndexOf('.') + 1), new File(output));
            System.out.printf("Wrote best image (score: %s) to '%s'.%n", bestScore, output);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private int x;
    private int y;
    private int movesLeft;
    private int maximumMoves;
    private double eatenAverageBrightness;
    private double originalAverageBrightness;
    private BufferedImage image;

    public HungryImageSnake(BufferedImage image) {
        this.image = copyImage(image);
        int size = image.getWidth() * image.getHeight();
        this.maximumMoves = size / 3;
        this.movesLeft = this.maximumMoves;
        int totalBrightness = 0;
        for (int x = 0; x < image.getWidth(); x++) {
            for (int y = 0; y < image.getHeight(); y++) {
                totalBrightness += getBrightnessAt(x, y);
            }
        }
        this.originalAverageBrightness = totalBrightness / (double) size;
    }

    public BufferedImage getImage() {
        return image;
    }

    public double getEatenAverageBrightness() {
        return eatenAverageBrightness;
    }

    public double getOriginalAverageBrightness() {
        return originalAverageBrightness;
    }

    public double getScore() {
        return eatenAverageBrightness / originalAverageBrightness;
    }

    public boolean isHungry() {
        return movesLeft > 0;
    }

    public void eat() {
        if (!isHungry()) {
            return;
        }
        int[][] options = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
        shuffleArray(options); // prevent snake from getting stuck in corners
        int[] bestOption = null;
        int bestBrightness = 0;
        for (int[] option : options) {
            int optionX = this.x + option[0];
            int optionY = this.y + option[1];
            if (exists(optionX, optionY)) {
                int brightness = getBrightnessAt(optionX, optionY);
                if (bestOption == null || brightness > bestBrightness) {
                    bestOption = new int[]{ optionX, optionY };
                    bestBrightness = brightness;
                }
            }
        }

        image.setRGB(bestOption[0], bestOption[1], 0);
        this.movesLeft--;
        this.x = bestOption[0];
        this.y = bestOption[1];
        this.eatenAverageBrightness += bestBrightness / (double) maximumMoves;
    }

    private boolean exists(int x, int y) {
        return x >= 0 && x < image.getWidth() && y >= 0 && y < image.getHeight();
    }

    private int getBrightnessAt(int x, int y) {
        int rgb = image.getRGB(x, y);
        int r = (rgb >> 16) & 0xFF;
        int g = (rgb >> 8) & 0xFF;
        int b = rgb & 0xFF;
        return r + g + b;
    }

    private static <T> void shuffleArray(T[] array) {
        Random random = new Random();
        for (int i = array.length - 1; i > 0; i--) {
            int index = random.nextInt(i + 1);
            T temp = array[index];
            array[index] = array[i];
            array[i] = temp;
        }
    }

    private static BufferedImage copyImage(BufferedImage source){
        BufferedImage b = new BufferedImage(source.getWidth(), source.getHeight(), source.getType());
        Graphics g = b.getGraphics();
        g.drawImage(source, 0, 0, null);
        g.dispose();
        return b;
    }
}

পঞ্চাশেরও বেশি পুনরুক্তির চিত্র দ্বারা গড় স্কোর:

Bridge - 0.7739
Spheres - 0.5580
Scream - 0.8197
Fractal - 0.3850
Vortex - 0.9158
Tornado - 0.7172

একই পঞ্চাশটি পুনরাবৃত্তির উপর চিত্র দ্বারা সর্বোত্তম স্কোর:

Bridge - 0.8996
Spheres - 0.8741
Scream - 0.9183
Fractal - 0.5720
Vortex - 1.1520
Tornado - 0.9281

সর্বোচ্চ স্কোরিং 'ইমেজ:

চিত্রগুলি থেকে বোঝা যায়, পিক্সেলের তৃতীয়াংশের তুলনায় আসলে কম খাওয়া হয়, যেহেতু সাপ মাঝে মধ্যে পিক্সেলের মধ্যে ইতিমধ্যে খেয়ে ফেলেছে, যেখানে এটির নড়াচড়া এলোমেলো না হওয়া পর্যন্ত এটি মৃত অঞ্চলে আটকে থাকে ছবির একটি ভোজ্য অংশ।

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

অবশ্যই, আরও ভাল পন্থা প্রতিটি পিক্সেলের জন্য কিছু প্রকারের উজ্জ্বলতা heuristic তৈরি করা এবং width * height / 3সর্বাধিক গড় উজ্জ্বলতার সাথে পিক্সেলের পথ সন্ধান করা হবে, তবে আমি সন্দেহ করি যে এই পদ্ধতিটি রান সময়গুলিতে, বিশেষত বৃহত্তর চিত্রগুলিতে সংখ্যা হিসাবে অনুকূল হবে সম্ভাব্য ক্রমক্রম খুব বড় হবে। আমি এই পদ্ধতির কোনও ফর্মের পরে শট নিতে পারি এবং যদি তা হয় তবে এটির একটি পৃথক উত্তরে পোস্ট করতে পারি।

Comments

আমার উত্তরটি কত বড় তা নিয়ে যদি কেউ বিরক্ত হন (এতে থাকা চিত্রগুলির কারণে) তবে আমাকে জানান এবং আমি ছবিগুলি লিঙ্কগুলির বা অন্য কোনও কম স্প্যাসি বিকল্পের পক্ষে সরিয়ে ফেলব remove অথবা, কেউ যদি কোনও "খাওয়া" চিত্রের সম্পূর্ণ রেজোলিউশনটির মূল পছন্দ করতে চান, আমাকেও একটি মন্তব্যে জানিয়ে দিন।

— এফটিহম্পসন

Answer 5

পাইথন 2, স্কোর: 1.205

কিছুক্ষণ আগে আমি একটি দ্রুত পাইথন সমাধানটি একসাথে রেখেছি তবে এটি পোস্ট করতে ভুলে গিয়েছি। এটা এখানে. এটি চিত্রের মধ্যে সবচেয়ে ধনী ব্লকগুলি সন্ধান করে এবং তারপরে যে সমস্ত সেরা ব্লক আসে সেগুলি খেয়ে প্রতিটি ব্লকে ভ্রমণ করে।

ফলাফল

bridge.jpg: 591.97866/515.41501 =                               1.14855 
BallsRender.png: 493.24711/387.80635 =                          1.27189 
Mandel_zoom_04_seehorse_tail.jpg: 792.23990/624.60579 =         1.26838 
Red_Vortex_Apophysis_Fractal_Flame.jpg: 368.26121/323.08463 =   1.13983 
The_Scream.jpg: 687.18565/555.05221 =                           1.23806
swirl.jpg: 762.89469/655.73767 =                                1.16341

AVERAGE                                                         1.205

উদাহরণ চিত্র

পাইথন 2.7 কোড

from pygame.locals import *
import pygame, sys, random

fn = sys.argv[1]

screen = pygame.display.set_mode((1900,1000))
pic = pygame.image.load(fn)
pic.convert()
W,H = pic.get_size()
enough = W*H/3
screen.blit(pic, (0,0))

ORTH = [(-1,0), (1,0), (0,-1), (0,1)]
def orth(p):
    return [(p[0]+dx, p[1]+dy) for dx,dy in ORTH]

def look(p):
    x,y = p
    if 0 <= x < W and 0 <= y < H:
        return sum(pic.get_at(p))
    else:
        return -1

# index picture
locs = [(x,y) for x in range(W) for y in range(H)]
grid = dict( (p,sum(pic.get_at(p))) for p in locs )
rank = sorted( grid.values() )
median = rank[ len(rank)/2 ]
dark = dict( (k,v) for k,v in grid if v < median )
good = dict( (k,v) for k,v in grid if v > median )
pictotal = sum(rank)
picavg = 1.0 * pictotal/(W*H)
print('Indexed')

# compute zone values:
block = 16
xblocks, yblocks = (W-1)/block, (H-1)/block
zones = dict( ((zx,zy),0) for zx in range(xblocks) for zy in range(yblocks) )
for x,y in locs:
    div = (x/block, y/block)
    if div in zones:
        colsum = sum( pic.get_at((x,y)) )
        zones[div] += colsum

# choose best zones:
zonelist = sorted( (v,k) for k,v in zones.items() )
cut = int(xblocks * yblocks * 0.33)
bestzones = dict( (k,v) for v,k in zonelist[-cut:] )

# make segment paths:
segdrop = [(0,1)] * (block-1)
segpass = [(1,0)] * block
segloop = [(0,-1)] * (block-1) + [(1,0)] + [(0,1)] * (block-1)
segeat = ( segloop+[(1,0)] ) * (block/2)
segshort = [(1,0)] * 2 + ( segloop+[(1,0)] ) * (block/2 - 1)

def segtopath(path, seg, xdir):
    for dx,dy in seg:
        x,y = path[-1]
        newloc = (x+dx*xdir, y+dy)
        path.append(newloc)

# design good path:
xdir = 1
path = [(0,0)]
segtopath(path, segdrop, xdir)
shortzone = True
while True:
    x,y = path[-1]
    zone = (x/block, y/block)
    if zone in bestzones:
        if shortzone:
            seg = segshort
        else:
            seg = segeat
    else:
        seg = segpass
    segtopath(path, seg, xdir)
    shortzone = False
    # check end of x block run:
    x,y = path[-1]
    zone = (x/block, y/block)
    if not ( 0 <= x < xblocks*block ):
        del path[-1]
        segtopath(path, segdrop, xdir)
        shortzone = True
        xdir = xdir * -1
    if len(path) > enough:
        break
print('Path Found')

# show path on picture:
loc = path.pop(0)
eaten = 1
joetotal = grid[loc]
i = 0
while eaten <= enough:
    loc = path[i]
    i += 1
    pic.set_at(loc, (0,0,0))
    joetotal += grid[loc]
    eaten += 1
    if i % 1000 == 0:
        screen.blit(pic, (0,0))
        pygame.display.flip()
        for event in pygame.event.get():
            if event.type == QUIT: sys.exit(0)

# save picture and wait:
screen.blit(pic, (0,0))
pygame.display.flip()
pygame.image.save(pic, 'output/'+fn)
joeavg = 1.0 * joetotal/eaten
print '%s: %7.5f/%7.5f = %7.5f' % (fn, joeavg, picavg, joeavg/picavg)
while True:
    for event in pygame.event.get():
        if event.type == QUIT: sys.exit(0)