স্কোয়ার, সার্কেল, ত্রিভুজ,… গিয়ার?

Question

অ্যালগোডো এবং পেইন্ট ব্যবহার করে আমি এই ছয়টি 300 × 300 চারটি সুবিধাজনক আকারের একরঙা চিত্র তৈরি করেছি:

এই শ্রেণীর চিত্রগুলির নিম্নলিখিত বৈশিষ্ট্য রয়েছে:

• এগুলি সর্বদা 300 × 300 পিক্সেল, একরঙা (কেবলমাত্র সাদা এবং সাদা) থাকে এবং ঠিক চারটি সাদা অঞ্চল থাকে যা একটি বর্গক্ষেত্র, একটি বৃত্ত, একটি ত্রিভুজ এবং একটি গিয়ারের সাথে মিলে যায়।
• আকারগুলি কখনই একে অপরকে ওভারল্যাপ করে না বা একে অপরকে স্পর্শ করে না, বা তারা চিত্রের সীমানাকে স্পর্শ করে না বা সীমার বাইরে যায় না।
• আকারগুলির সর্বদা একই আকার থাকে তবে এগুলি কোনও উপায়ে ঘোরানো এবং অবস্থিত হতে পারে।

(আকারগুলিরও সমান ক্ষেত্র রয়েছে, যদিও এইরূপে যখন জঞ্জাল করা হয় তখন তাদের পিক্সেল গণনাগুলি ঠিক সমতুল্য হওয়ার সম্ভাবনা কম))

চ্যালেঞ্জ

সংক্ষিপ্ততম প্রোগ্রাম বা ফাংশনটি লিখুন যা এই জাতীয় চিত্রের ফাইল নাম নেয় এবং সমস্ত সাদা পিক্সেল ঘুরিয়ে দেয় ...

• লাল (255, 0, 0)যদি তারা স্কোয়ারে থাকে।
• (0, 0, 255)তারা যদি বৃত্তে থাকে তবে নীল
• সবুজ (0, 255, 0)যদি তারা ত্রিভুজ হয়।
• হলুদ (255, 255, 0)যদি তারা গিয়ারে থাকে।

যেমন

বিস্তারিত

আপনার প্রোগ্রামটি কার্যকরভাবে সম্ভব সমস্ত ইনপুট চিত্রগুলির জন্য কাজ করা উচিত। (কেবলমাত্র বৈধ 300 × 300 একরঙা চিত্রগুলি ইনপুট হবে)) আমি যে ছয়টি চিত্র সরবরাহ করেছি তা কেবল উদাহরণ, আপনি তাদের প্রোগ্রামে তাদের আউটপুট হার্ডকোড নাও দিতে পারেন।

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

আপনি যতক্ষণ রঙ স্কিমের সাথে লেগে থাকেন ততক্ষণ আপনি ইনপুট এবং আউটপুট জন্য যেকোন সাধারণ লসলেস ইমেজ ফাইল ফর্ম্যাট ব্যবহার করতে পারেন।

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

স্কোরিং

সবচেয়ে কম বাইটস সহ জমাটি জয়লাভ করে। আমি অতিরিক্ত চিত্রগুলির সাথে তাদের বৈধতা নির্ধারণের জন্য জমা দেওয়ার পরীক্ষা করতে পারি।

Comments

অ্যান্টি-এলিয়জিং না করে আমরা কী ধরে নিতে পারি যে ইনপুটটি কালো এবং সাদা? যদি তা না হয় তবে আমরা কী অ্যান্টি-এলিয়জড ইনপুটগুলি থেকে অ্যান্টি-এলিয়জিং অপসারণ করতে পারি?

— জন ডিভোরাক

@ জনডভোরাক হ্যাঁ একরঙা দ্বারা আমি কেবল কালো এবং সাদা বোঝায় তাই অ্যান্টি-এলিয়জিং হতে পারে না।

— ক্যালভিনের

আমরা কি কেবলমাত্র একটি ফাইল এক্সটেনশনের চেয়ে আরও নির্দিষ্টভাবে একটি নির্দিষ্ট ইনপুট ফর্ম্যাটটির প্রয়োজন? যথা, আমি ভিতরে কোনও মন্তব্য ছাড়াই আমাকে একটি এসসিআইআই পিবিএম ইনপুট চাই ।

— জন ডিভোরাক

সুতরাং ... আমি এটি সমাধান করার চেষ্টা করছিলাম এবং আমি এই চিত্রটি দিয়ে শেষ করেছি । কীভাবে সত্যই তা নিশ্চিত নয় তবে ওহে, অভিনব দেখাচ্ছে। : পি

— ডুরকনব

আমি আমার সমাধানটি পোস্ট করতে চাই না কারণ এটি এল এর মতো একই ধারণা তবে আরও খারাপ। তবে আমি কেবল এটিই বলতে চাই যে এটি করা একটি উপভোগযোগ্য সামান্য চ্যালেঞ্জ ছিল :)

— ক্রিস বার্ট-ব্রাউন

Answer 1

জে - 246,224 185 বাইট

load'viewmat'
(viewmat~0,(255*4 3$_2|.#:3720)/:/:@(<([:}.(>./%+/%#)@:(+/&:*:@(-"1)+/%#)@(4$.$.@:=)&>)<"0@~.@,))@(~.@,i.])@(>./**@{.)@((0,(,-)#:>:i.3)&|.)^:_@(*i.@:$)@(0<readimg_jqtide_)

এটি একটি মজার এক!

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

ভিউম্যাপ অ্যাডোন ব্যবহার করে ফলাফলটি প্রদর্শন করে। ফাইল রিডিং এবং আউটপুট ব্যতীত কোনও সরঞ্জামবক্স ব্যবহার করা হয়নি।

দৃust়তা কোনও প্রয়োজনীয়তা বলে মনে হয় না, এটি 18 বাইট বন্ধ করে দেয়। 2 আরও বেশি অপ্রয়োজনীয় স্পেস, প্রতিস্থাপিত &.>দ্বারা &>মধ্যে ratioএবং &.:দ্বারা &:অন্য 2 বাইট জন্য dcent হবে।

( ) এর compপরিবর্তে শিফটিং ব্যবহারের স্বল্পতা এবং পারফরম্যান্স উভয়ই বিশাল লাভ । এইভাবে চিত্রটি একটি 3x3 উইন্ডো দিয়ে স্ক্যান করার পরিবর্তে চিত্রটি অনুলিপি করা হয়েছে এবং 8 টি দিক থেকে সরানো হয়েছে।cut;.

idফাংশন জন্য হাস্যকর জটিল কি এটা করতে প্রয়োজন ছিল। এখন এটি আইডিকে পিক্সেলগুলিকে অবজেক্টগুলিতে অনন্য সংখ্যার অ্যারের সাহায্যে চিত্রটি গুণিত করে বিজিটিকে শূন্যে সেট করে।

কোডটি আরও কিছুটা ব্যাখ্যা করা হয়েছে:

load'viewmat'                                 NB. display only
imnames =: < ;. _2 (0 : 0)
C6IKR.png
DLM3y.png
F1ZDM.png
Oa2O1.png
YZfc6.png
chJFi.png
)

images =: (0<readimg_jqtide_) each imnames    NB. read all images in boxed array

id =: *i.@:$                                  NB. NB. assign one number to each non-background (non-zero) pixel
comp =: (>./ * *@{.)@shift^:_@id              NB. 8 connected neighbor using shift
  shift =: (>,{,~<0 _1 1)&|.                  NB. generate the original, and 8 shifted versions (automatically padding and cropping).
result =: comp each images                    NB. Execute comp verb for each image
col =: (~.@, i. ])                            NB. Color: give each component and BG a separate color.

NB. BG in 0, 0 Get all max distance to center % mean distance to center ratios
ratio  =: (< ([:}.rat@:dcent@getInd &>)  <"0@~.@,)
  getInd =: 4 $. $.@:=                        NB. get indices for component y in array x
  dcent  =: +/&.:*:@(-"1) +/%#                NB. distence from center each point
  rat    =: >./ % +/%#                        NB. ratio from distances

cm=: (255*4 3$_2|.#:3720)                     NB. colormap (except black).
(viewmat~ 0,cm /: /:@ratio )@col each result  NB. for each image, show the result, permuting the colormap according to ratio's

NB. almostgolf this
P1 =: (>./**@{.)@((0,(,-)#:>:i.3)&|.)^:_@(*i.@:$)@(0<readimg_jqtide_) NB. reading till components
P2 =: (<([:}.(>./%+/%#)@:(+/&:*:@(-"1)+/%#)@(4$.$.@:=)&>)<"0@~.@,) NB. recognition: get fraction mean vs max distance to center per component, toss BG.     
P3 =: (viewmat~0,(255*4 3$_2|.#:3720)/:/:@P2)@(~.@,i.])@P1    NB. piece together : permute colormap, display components

NB. seriousgolf
load'viewmat'
f =:(viewmat~0,(255*4 3$_2|.#:3720)/:/:@(<([:}.(>./%+/%#)@:(+/&:*:@(-"1)+/%#)@(4$.$.@:=)&>)<"0@~.@,))@(~.@,i.])@((>./**@{.)@shift^:_)@(*i.@:$)@(0<readimg_jqtide_)
NB. example usage:
f&> imnames NB. do for all images

বিশদটি ব্যাখ্যা করার জন্য এইটি কিছুটা দীর্ঘ, তবে আগ্রহ থাকলে তা করবে।

Comments

উপরের ডান পিক্সেলটি বিজি হওয়ার গ্যারান্টিযুক্ত। ওপি অনুসারে "আকারগুলি কখনই একে অপরকে ওভারল্যাপ করে না বা একে অপরকে স্পর্শ করে না, বা তারা চিত্রের সীমানাকে স্পর্শ করে না বা সীমার বাইরে যায় না।"

— ডাঃ বেলিসেরিয়াস

ধন্যবাদ, এটি সহায়ক। (আসলে আমি বাম উপরের পিক্সেলটি বোঝাতে চাইছি the এটি ব্যাকগ্রাউন্ড সনাক্তকরণ (22 বাইট) বন্ধ করে দেয়।

— jpjacobs

নাটকীয়ভাবে দৈর্ঘ্য হ্রাস, এবং বর্ধিত কর্মক্ষমতা :)

— jpjacobs

Answer 2

গণিত, 459 392 বাইট tes

f=(d=ImageData@Import@#/.{a_,_,_}:>a;(For[a={};b={#&@@d~Position~1},b!={},c=#&@@b;b=Rest@b;d[[##&@@c]]=0;a~AppendTo~c;If[Extract[d,c+#]==1,b=b⋃{c+#}]&/@{e={1,0},-e,e={0,1},-e}];m=1.Mean@a;m=#-m&/@a;n=Count[Partition[Norm/@SortBy[m,ArcTan@@#&],300,1,1],l_/;l[[150]]==Max@l];(d[[##&@@#]]=Round[n^.68])&/@a)&/@Range@4;Image[d/.n_Integer:>{{0,0,0},,{0,1,0},{1,0,0},,,,{1,1,0},{0,0,1}}[[n+1]]])&

Ungolfed:

f = (
 d = ImageData@Import@# /. {a_, _, _} :> a;
 (
    For[a = {}; b = {# & @@ d~Position~1},
     b != {},
     c = # & @@ b;
     b = Rest@b;
     d[[## & @@ c]] = 0;
     a~AppendTo~c;
     If[Extract[d, c + #] == 1, 
        b = b ⋃ {c + #}] & /@ {e = {1, 0}, -e, e = {0, 1}, -e}
     ];
    m = 1. Mean@a; m = # - m & /@ a;
    n = 
     Count[Partition[Norm /@ SortBy[m, ArcTan @@ # &], 300, 1, 1], 
      l_ /; l[[150]] == Max@l];
    (d[[## & @@ #]] = Round[n^.68]) & /@ a
    ) & /@ Range@4;
 Image[d /. 
   n_Integer :> {{0, 0, 0}, , {0, 1, 0}, {1, 0, 0}, , , , {1, 1, 
       0}, {0, 0, 1}}[[n + 1]]]
) &

আমি রূপান্তর m=1.Mean@a;m=#-m&/@a;করে আরও 6 টি বাইট সংরক্ষণ করতে পারি m=#-Mean@a&/@a;, তবে এটি কার্যকরভাবে কার্যকর করার সময়টিকে ধরিয়ে দেয় যা পরীক্ষার জন্য বিরক্তিকর। (উল্লেখ্য যে, এই দুই optimisations হল: এর গণনার খুঁজে pulling Mean@aগোষ্ঠীর বাইরে এবং । ফ্লোটিং পয়েন্ট সংখ্যার পরিবর্তে সঠিক সিম্বলিক ধরনের ব্যবহার মজার ব্যাপার হচ্ছে, সঠিক ধরনের ব্যবহার অনেক বেশি যে পুনরাবৃত্তির গড় কম্পিউটিং চেয়ে গুরুত্বপূর্ণ।)

সুতরাং এটি তিন নম্বর পদ্ধতির:

• বন্যা-পূরণ দ্বারা অঞ্চলগুলি সনাক্ত করুন।
• সমস্ত পিক্সেল স্থানাঙ্কের গড় গড়ে প্রতিটি অঞ্চলের আনুমানিক কেন্দ্রটি সন্ধান করুন।

• এখন আকারের সমস্ত পিক্সেলের জন্য বনাম কোণ থেকে সেই কেন্দ্রের দূরত্ব প্লট করুন:

  

  ধ্রুবক ব্যাসার্ধ সম্পর্কে অলসতর ওঠানামার কারণে ত্রিভুজটির 3 টি স্পষ্ট ম্যাক্সিমার, বর্গ 4, গিয়ার 16 এবং বৃত্তটিতে টন রয়েছে।

• আমরা ম্যাক্সিমার সংখ্যাটি 300 পিক্সেল (কোণ অনুসারে অর্ডার) এর টুকরোগুলি দেখে খুঁজে পাই এবং যেখানে পিক্সেল পজিশনে 150সর্বাধিক সেখানে স্লাইসগুলি গণনা করি ।
• তারপরে আমরা কেবল পিক্সের সংখ্যার উপর নির্ভর করে সমস্ত পিক্সেল রঙ করি (চক্রের আকারের কারণে চেনাশোনাটি 16 এরও বেশি কিছু হয় এবং প্রায় 20 টি পীক ফলন দেয়)।

কেবলমাত্র রেকর্ডের জন্য, আমি যদি ইলের ধারণাটি ব্যবহার করি এবং অঞ্চলগুলিকে কেবল কোনও পিক্সেল এবং কেন্দ্রের মধ্যে বৃহত্তম দূরত্ব অনুসারে বাছাই করি, আমি এটি 342 বাইটে করতে পারি:

f=(d=ImageData@Import@#/.{a_,_,_}:>a;MapIndexed[(d[[##&@@#]]=#&@@#2)&,SortBy[(For[a={};b={#&@@d~Position~1},b!={},c=#&@@b;b=Rest@b;d[[##&@@c]]=0;a~AppendTo~c;If[Extract[d,c+#]==1,b=b⋃{c+#}]&/@{e={1,0},-e,e={0,1},-e}];a)&/@Range@4,(m=Mean@#;Max[1.Norm[#-m]&/@#])&],{2}];Image[d/.n_Integer:>{{0,0,0},{0,0,1},{1,1,0},{1,0,0},{0,1,0}}[[n+1]]])&

তবে যতক্ষণ না প্রত্যেকে অন্যের গল্ফ না করে তাদের নিজস্ব মূল অ্যালগরিদম ব্যবহার করছে ততক্ষণ আমি এটির সাথে প্রতিযোগিতা করার ইচ্ছা করি না।

Comments

সবচেয়ে আকর্ষণীয় সমাধান!

— সিশারপি

Answer 3

জাভা, 1204 1132 1087 1076

আমি নিজে এটি প্রমাণ করতে পারি যে আমি এটি করতে পারি।

আমি ফাংশন ঘোষণার ঠিক সামনেই আমদানিগুলি অন্তর্ভুক্ত করেছি; এটি কাজ করার জন্য এগুলি শ্রেণীর বাইরে থাকতে হবে:

import java.awt.*;import java.awt.image.*;import java.io.*;import java.util.*;import javax.imageio.*;

BufferedImage i;Set<Point>Q;void p(String a)throws Exception{i=new BufferedImage(302,302,1);i.getGraphics().drawImage(ImageIO.read(new File(a)),1,1,null);Set<Set<Point>>S=new HashSet<>();for(int y=0;y<300;y++){for(int x=0;x<300;x++){if(!G(x,y)){Point p=new Point(x,y);Q=new HashSet<>();if(!S.stream().anyMatch(s->s.contains(p)))S.add(f(x,y));}}}Object[]o=S.stream().sorted((p,P)->c(p)-c(P)).toArray();s(o[0],255);s(o[1],255<<16);s(o[2],0xFF00);s(o[3],0xFFFF00);ImageIO.write(i.getSubimage(1,1,300,300),"png",new File(a));}boolean G(int x,int y){return i.getRGB(x,y)!=-1;}Set<Point>f(int x,int y){Point p=new Point(x,y);if(!Q.contains(p)&&!G(x,y)){Q.add(p);f(x-1,y);f(x+1,y);f(x,y-1);f(x,y+1);}return Q;}int c(Set<Point>s){return(int)s.stream().filter(p->G(p.x-2,p.y-1)||G(p.x-2,p.y+1)||G(p.x+1,p.y-2)||G(p.x-1,p.y-2)||G(p.x+2,p.y-1)||G(p.x+2,p.y+1)||G(p.x+1,p.y+2)||G(p.x-1,p.y+2)).count();}void s(Object o,int c){((Set<Point>)o).stream().forEach(p->{i.setRGB(p.x,p.y,c);});}

অবরুদ্ধ (এবং চলমান; যেমন বয়লারপ্লেট যুক্ত):

import java.awt.Point;
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.HashSet;
import java.util.Set;
import javax.imageio.ImageIO;

public class SquareCircleTriangleGear {
    public static void main(String[]args){
        try {
            new SquareCircleTriangleGear().p("filepath");
        } catch (Exception ex) {
        }
    }
    BufferedImage i;
    Set<Point>Q;
    void p(String a)throws Exception{
        i = new BufferedImage(302,302,BufferedImage.TYPE_INT_RGB);
        i.getGraphics().drawImage(ImageIO.read(new File(a)),1,1,null);
        Set<Set<Point>>set=new HashSet<>();
        for(int y=0;y<300;y++){
            for(int x = 0;x<300;x++){
                if(i.getRGB(x,y)==-1){
                    Point p = new Point(x,y);
                    Q=new HashSet<>();
                    if(!set.stream().anyMatch((s)->s.contains(p))){
                        set.add(fill(x,y));
                    }
                }
            }
        }
        Object[]o=set.stream().sorted((p,P)->c(p)-c(P)).toArray();
        s(o[0],0x0000FF);
        s(o[1],0xFF0000);
        s(o[2],0x00FF00);
        s(o[3],0xFFFF00);
        ImageIO.write(i.getSubImage(1,1,300,300), "png", new File(a));
    }
    Set<Point>fill(int x, int y){
        Point p=new Point(x,y);
        if(!Q.contains(p)&&!i.getRGB(x,y)!=-1) {
        Q.add(p);
            fill(x-1,y);
            fill(x+1,y);
            fill(x,y-1);
            fill(x,y+1);
        }
        return Q;
    }
    int c(Set<Point>s){return (int)s.stream().filter(p->isBoundary(p.x,p.y)).count();}
    boolean isBoundary(int x, int y){
        return i.getRGB(x-2,y-1)!=-1||i.getRGB(x-2,y+1)!=-1||i.getRGB(x+1,y-2)!=-1||
               i.getRGB(x-1,y-2)!=-1||i.getRGB(x+2,y-1)!=-1||i.getRGB(x+2,y+1)!=-1||
               i.getRGB(x+1,y+2)!=-1||i.getRGB(x-1,y+2)!=-1;
    }
    void s(Object o,int c){
        ((Set<Point>)o).stream().forEach(p->{i.setRGB(p.x,p.y,c);});
    }
}

এটি প্রতি পিক্সেলের চিত্রের পুনরাবৃত্তি করে এবং প্রতিবার "গর্তে" পৌঁছানোর পরে বন্যা ভরাট করে কাজ করে। আমরা একটি হিসাবে একে বন্যা ভরাট ফলাফলের যোগ Set<Point>একটি থেকে Set। তারপরে আমরা কোন আকারটি নির্ধারণ করি। আকারের সীমানা পিক্সেলের সংখ্যা দেখে এটি করা হয়। আমি একটি কালো টাইল থেকে নাইটের সরানো হিসাবে সীমানা সংজ্ঞায়িত করেছি, যেহেতু এটি ঘূর্ণন এবং এর মধ্যে আরও ধ্রুবক থাকবে। যখন আমরা এটি করি, এটি স্পষ্ট হয়ে যায় যে আকারগুলি সেই মান অনুসারে বাছাই করা যায়: বৃত্ত, স্কোয়ার, ত্রিভুজ, গিয়ার। সুতরাং আমি সেই আকারের সমস্ত পিক্সেলকে সঠিক রঙে সাজিয়ে রেখেছি

মনে রাখবেন যে আমি যে চিত্রটি লিখছি তা সরাসরি ফাইল থেকে নেওয়া হয়নি, কারণ যদি আমি এটি করতে যাই তবে জাভা চিত্রটিকে কালো এবং সাদা হিসাবে মনে করবে এবং রঙগুলি পূরণ করা কাজ করবে না। সুতরাং আমাকে নিজের ইমেজটি তৈরি করতে হবে TYPE_INT_RGB(যা 1)। এছাড়াও মনে রাখবেন যে ইমেজ আমি কাজ করছি 302দ্বারা 302; এটি এমন যাতে নাইটের দূরত্বের অ্যালগরিদমটি ইমেজটিতে সীমার বাইরে পড়ার চেষ্টা করার বিষয়ে চিন্তা করার দরকার নেই। আমি কল করে এই তাত্পর্যটি আকারে স্থির করছি i.getSubImage(1,1,300,300)। _{দ্রষ্টব্য: আমি ছবিগুলি আপলোড করার সময় এটি ঠিক করতে ভুলে গিয়েছি, এই ক্ষেত্রে চিত্রগুলি 2 পিক্সেল খুব প্রশস্ত হয় তবে এই সত্যটি ব্যতীত সেগুলি সঠিক হওয়া উচিত}

ফাংশনটি সেই ফাইলটি ওভাররাইট করবে যার পথটি প্রবেশ করেছে Out

Comments

ক্লাসের নামটি ছোট করার পাশাপাশি মূল পদ্ধতিতে আঙ্গুলগুলি "এ" বা অনুরূপ করে কিছু অক্ষর সংরক্ষণ করতে পারে।

— রায়ান

@ রায়ান যারা গণনা করা হয় নি। আমি কেবল আমদানি + কার্যগুলি গণনা করি, প্রশ্ন দ্বারা অনুমোদিত allowed

— জাস্টিন

আমি মনে করি আমি এটি 1000 বাইটের নিচে পেতে সক্ষম হতে পারি। চেষ্টা করার সময় পেলে অবশ্যই এটি পরে কাজ করা উচিত।

— জাস্টিন

Answer 4

পাইথন, 571 567 528 বাইট

একইভাবে কুইকুনাক্সের সমাধানের জন্য, এটি 1 থেকে 4 পর্যন্ত সূচি দিয়ে প্রতিটি আকারকে বন্যায় ভরাট করে শুরু হয় এটি এর পরে তাদের সীমানা বৃত্তের ব্যাসার্ধ দ্বারা আকারগুলির পরিচয় নির্ধারণ করে। একটি রঙ-প্যালেট সেই অনুযায়ী নির্মিত হয় এবং চিত্রটি সূচিযুক্ত রঙের চিত্র হিসাবে সংরক্ষণ করা হয়।

সম্পাদনা: আকারগুলি চিত্রের সীমানাকে স্পর্শ না করার গ্যারান্টিযুক্ত সত্যটি মিস করেছে। তত কম!

from PIL.Image import*;from numpy import*
I=open(sys.argv[1]).convert("P")
D=list(I.getdata())
W=300;R=range(W*W);N=range(5)
O=[[0,i,array([0,0])]for i in N];n=0
for i in R:
 if D[i]>4:
    n+=1;S=[i]
    while S:
     j=S.pop()
     if D[j]>4:D[j]=n;O[n][0]+=1;O[n][2]+=j%W,j/W;S+=[j+1,j-1,j+W,j-W]
for o in O[1:]:o[2]/=o[0];o[0]=0
for i in R:
 if D[i]:o=O[D[i]];v=(i%W,i/W)-o[2];o[0]=max(o[0],dot(v,v))
O.sort()
C=[0]*5+[255]*3+[0,255,0,0]*2;P=C[:]
for i in N:j=3*O[i][1];P[j:j+3]=C[3*i:3*i+3]
I.putdata(D);I.putpalette(P);I.save("o.png")

কমান্ড লাইনে একটি ইনপুট ফাইলের নাম নেয় এবং এতে আউটপুট লিখে o.png।

Comments

আর্, আমি যা করার চেষ্টা করছি তার চেয়ে এতো সহজ। +1

— মার্টিন ইন্ডার

Answer 5

গণিত 225

---

আপডেট :

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

---

f@i_ := (m = MorphologicalComponents[ImageData@i];
Image@Partition[Flatten[(m)] /. 
   Append[ ReplacePart[SortBy[ComponentMeasurements[m, "Circularity"], Last], 
   {{1, 2} -> Yellow, {2, 2} -> Green, {3, 2} -> Red, {4, 2} -> Blue}], 0 -> Black], 
Dimensions[m][[2]]])

ImageData চিত্রটি 0 এবং 1 এর ম্যাট্রিক্স হিসাবে দেখায়।

Flatten সেই ম্যাট্রিক্সকে একটি তালিকায় রূপান্তর করে।

Morphological Componentsপিক্সেলের 4 টি ক্লাস্টার সন্ধান করে এবং ক্লাস্টার অনুসারে প্রতিটি পিক্সেলকে 1, 2, 3, 4 একটি পৃথক পূর্ণসংখ্যার নির্ধারণ করে। 0 টি (কালো) পটভূমির জন্য সংরক্ষিত।

ComponentMeasurements গুচ্ছগুলির বৃত্তটি পরীক্ষা করে।

সর্বাধিক থেকে সর্বনিম্ন বিজ্ঞপ্তি সর্বদা থাকবে: বৃত্ত, বর্গক্ষেত্র, ত্রিভুজ এবং গিয়ার।

ReplacePart বৃত্তাকারতা বাছাই করে প্রতিটি উপাদানকে যথাযথ আরজিবি রঙের সাথে প্রতিস্থাপন করে।

Partition...Dimensions[m][[2]] পিক্সেল রঙগুলির তালিকা গ্রহণ করে এবং ইনপুট চিত্রের মতো ম্যাট্রিক্সের একই মাত্রা প্রদান করে।

Image পিক্সেল রঙের ম্যাট্রিক্সকে একটি রঙিন চিত্রে রূপান্তর করে।

{f[img1],f[img2],f[img3],f[img4]}

Comments

147 অক্ষর:f@i_:=Image[#/.Append[Thread[Ordering[Last/@ComponentMeasurements[#,"Circularity"]]->{Yellow,Green,Red,Blue}],0->Black]]&@MorphologicalComponents@i

— আলেফাল্ফা

গৌণ পয়েন্ট: আপনার রঙগুলির সঠিক আরজিবি মান নেই। প্রধান বিষয়: আমি নিশ্চিত নই যে আমি এটি কম্পিউটার ভিশন লাইব্রেরি বা ফাংশন ব্যবহার না করে গণনা করব।

— ক্যালভিনের

"বিজ্ঞপ্তি" তর্কযোগ্যভাবে দৃশ্যমান; আমি আর কি করতে পারি তা দেখতে পাব। রঙগুলি তবে মারা গেছে: {RGBColor[1, 0, 0], RGBColor[0, 1, 0], RGBColor[0, 0, 1], RGBColor[1, 1, 0]}যেখানে 1 টি 255 এর সাথে মিলে যায় No কোনও লাইব্রেরি ব্যবহৃত হয়নি।

— ডেভিডসি

@ ক্যালভিনের শখগুলি MorphologicalComponentsআপনার নিয়মকে সন্তুষ্ট করে বা লঙ্ঘন করেছে কিনা তা ইস্যুতে নেমে আসে বলে মনে হচ্ছে । একবার প্রতিটি পিক্সেল কোন ক্লাস্টারের অন্তর্ভুক্ত তা জানার পরে, কোন চিত্রটি কোনটি তা নির্ধারণ করার জন্য পিক্সেলের কাঁচা গণনা সহ অনেকগুলি উপায় রয়েছে।

— ডেভিডসি

আমি এটি বলতে যাচ্ছি যে এটি নিয়ম লঙ্ঘন করে না, কারণ এটি খুব তর্কসাপেক্ষভাবে একটি কম্পিউটার ভিশন ফাংশন, এবং এটি ম্যাথামেটিকাকে একটি অন্যায্য সুবিধা দেয়। আমি সম্মত হই যে রঙগুলি সঠিক হওয়া উচিত তবে সেগুলি আপনার চিত্রটিতে স্পষ্টভাবে দেখা যায় ( (255,0,22)আমি পেইন্ট এ চেক করলে লাল হয় )। আমার গাণিতিক নেই তাই আমি নিশ্চিত হয়ে দৌড়াতে পারি না।

— ক্যালভিনের

Answer 6

গণিত, 354 345 314 291 288

এখনও গল্ফিং, আরও কয়েকটি অক্ষর দ্বারা সংক্ষিপ্ত করা যেতে পারে, কিন্তু অভিনয় অসহনীয় হয়ে ওঠে। আকারগুলি সনাক্ত করতে ভেরিয়েন্স ব্যবহার করে:

f=(w=Position[z=ImageData@Import@#,1];r=Nearest;v@x_:=Variance@N[Norm[Mean@x-#]&/@x];Image[Plus@@(ReplacePart[0z/. 0->{0,0,0},#->r[{108,124,196,115}->List@@@{Blue,Red,Green,Yellow},v@#][[1]]]&/@Rest@NestList[(m=r[w=w~Complement~#];FixedPoint[Union@@(m[#,{8,2}]&/@#)&,{#&@@w}])&,{},4])])&

ব্যবধান সহ:

f = (w = Position[z = ImageData@Import@#, 1];
     r = Nearest; 
     v@x_ := Variance@N[Norm[Mean@x - #] & /@ x];
     Image[Plus @@ (ReplacePart[ 0 z /. 0 -> {0, 0, 0}, # -> r[{108, 124, 196, 115} -> 
                                              List @@@ {Blue, Red, Green, Yellow}, v@#][[1]]] & /@
     Rest@NestList[(m = r[w = w~ Complement~#];
                   FixedPoint[Union @@ (m[#, {8, 2}] & /@ #) &, {# & @@ w}]) &
                   , {}, 4])]) &

পরীক্ষামূলক:

s = {"http://i.stack.imgur.com/Oa2O1.png", "http://i.stack.imgur.com/C6IKR.png", 
     "http://i.stack.imgur.com/YZfc6.png", "http://i.stack.imgur.com/F1ZDM.png", 
     "http://i.stack.imgur.com/chJFi.png", "http://i.stack.imgur.com/DLM3y.png"};
Partition[f /@ s, 3] // Grid

এখানে এটি সম্পূর্ণরূপে নিয়ন্ত্রিত is পরে ব্যাখ্যা যুক্ত করবে:

findOneZone[{universe_List, lastZone_List}] :=
 Module[{newUniverse, proximityFindFunc, seedElement},
  newUniverse = Complement[universe, lastZone];
  proximityFindFunc = Nearest@newUniverse;
  seedElement = {First@newUniverse};
  {newUniverse, FixedPoint[Union @@ (proximityFindFunc[#, {8, 2}] & /@ #) &, seedElement]}]

colorAssign[zone_List] :=
 Module[{
   vlist = {108, 124, 196, 115},
   cols = List @@@ {Blue, Red, Green, Yellow},
   centerVariance},
  centerVariance[x_List] := Variance@N[Norm[Mean@x - #] & /@ x];
  First@Nearest[vlist -> cols, centerVariance@zone]]

colorRules[zones_List] := (# -> colorAssign[#] & /@ zones)

main[urlName_String] := 
 Module[{pixels, FgPixelPositions, rawZones, zones},
  pixels = ImageData@Import@urlName;
  FgPixelPositions = Position[pixels, 1];
  (*fill and separate the regions*)
  rawZones = NestList[findOneZone[#] &, {FgPixelPositions, {}}, 4];
  zones = Rest[rawZones][[All, 2]];
  (*Identify,colorize and render*)
  Image@ReplacePart[ConstantArray[{0, 0, 0}, Dimensions@pixels], 
    colorRules[zones]]]

s = {"http://i.stack.imgur.com/Oa2O1.png"};
main /@ s

Answer 7

পাইথন, 579 577 554 514 502 501 বাইট

প্রতিটি আকারের জন্য, এটি বন্যা পূর্ণ করে, তারপরে সেন্ট্রয়েড এবং সবচেয়ে দূরের পয়েন্টের মধ্যে দূরত্ব গণনা করুন।

তারপরে আকৃতির আসল পৃষ্ঠটি একটি ত্রিভুজ, বর্গক্ষেত্র, ডিস্ক বা চাকার পৃষ্ঠের সাথে তুলনা করা হয় যা একই আকারের হবে।

গণিত আমদানি ; থেকে PIL । চিত্র আমদানি *; এ , আর , _ , আই = অ্যাবস , ব্যাপ্তি ( 300 ), 255 , খোলা ( সিস । আরজিভি [ 1 ])। রূপান্তর ( 'পি' ); প্রশ্ন = আমি । লোড () জন্য ঞ মধ্যে আর : জন্য আমি এ আর : যদি প্রশ্ন [ 

 
  আমি , ঞ ] == : _ : 
   এক্স , ওয়াই , গুলি , z- র , পি = 0 , 0 , 0 , [], [( আমি , ঞ )] যখন পি : 
    একটি , খ = ঢ = P । পপ () যদি না ( প্রশ্ন [ এন !] = : _ বা এন মধ্যে z- র ): 
     এক্স + + = একটি ; Y + =
   
     খ ; z + = [ n ]; পি + = [( ক , খ - ১ ), ( এ + ১ , খ ), ( ক , খ + ১ ), ( ক - ১ , খ )]; গুলি + + = 1 
   R = সর্বোচ্চ ([ গণিত । hypot ( এক্স / গুলি - এক্স , ওয়াই / গুলি - Y ) জন্য এক্স , Y ইন z ]); সি = { 1 : একটি ( গুলি - ( 1.4 * R ) ** 2 ), 2 : একটি ( গুলি - R * R / 3 ), 3 : একটি ( গুলি - গণিত । Pi * R * R ), 4 : একজন ( গুলি - 2.5 * R * R )} জন্য পি মধ্যে z- র
   : 
    প্রশ্ন [ পি ] = মিনিট ( সে , কী = সি । পাওয়া ) 
আই । পুটপ্লেট ([ 0 , 0 , 0 , _ ] * 3 + [ _ , _ , 0 ]) 
আমি । প্রদর্শন ()

Answer 8

সি # 1086 বাইট

তবুও অন্য একটি বন্যার-সমাধান, কেবলমাত্র রেকর্ডের জন্য যেহেতু এখানে কোনও সি # সংস্করণ নেই। কুইঞ্চুনসের মতো আমি নিজেকে প্রমাণ করতে চেয়েছিলাম যে আমি এটি করতে পারি এবং জাভাতে তার পদ্ধতির মধ্যে খুব একটা পার্থক্য নেই।

• এই সমাধানটি কোনও পুনরাবৃত্তি (তবে একটি স্ট্যাক) ব্যবহার করে না কারণ আমি স্ট্যাকওভারফ্লোগুলিতে চালিয়ে যাচ্ছি।
• বর্ডারপিক্সেল সনাক্তকরণটি 4 পরবর্তী পিক্সেল দেখে সরল করা হয়েছে, সেগুলির কোনওটি যদি কালো হয় তবে বর্তমান একটি বর্ডার পিক্সেল।

এটি প্রতিটি চিত্র ফর্ম্যাট গ্রহণ করে।

• প্যারামিটার 1 = ইনপুটপথ
• প্যারামিটার 2 = আউটপুটপথ

সমস্ত স্ট্যাটিক স্টাফগুলি সরিয়ে এবং প্রোগ্রামের একটি উদাহরণ তৈরি করে সম্ভবত এটি কয়েকটি চ্যাটারচ্যারে নামিয়ে দেওয়া যেতে পারে।

পঠনযোগ্য সংস্করণ:

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;

class Program
{
    static Bitmap img;
    static int w, h;
    static ISet<Point> pointsDone = new HashSet<Point>();
    static void Main(string[] a)
    {
        img = new Bitmap(a[0]);
        w = img.Width;
        h = img.Height;
        Bitmap clone = new Bitmap(w,h, PixelFormat.Format32bppArgb);
        Graphics.FromImage(clone).DrawImage(img, 0, 0, w, h);
        img = clone;




        Color[] colors = new[] { Color.Blue, Color.Red, Color.Green, Color.Yellow };

        var shapes = new List<ISet<Tuple<bool, Point>>>();
        for(int x=0;x<w;x++)
            for (int y = 0; y < h; y++)
            {
                Point p = new Point(x, y);
                if (pointsDone.Add(p) && _isWhitePixel(p))
                    shapes.Add(_detectShape(p));
            }
        int index = 0;
        foreach (var shp in shapes.OrderBy(shp => shp.Count(item => item.Item1)))
        {
            foreach (var pixel in shp)
                img.SetPixel(pixel.Item2.X, pixel.Item2.Y, colors[index]);
            index++;
        }

        img.Save(a[1]);
    }

    private static ISet<Tuple<bool, Point>> _detectShape(Point p)
    {
        var todo = new Stack<Point>(new[] { p });
        var shape = new HashSet<Tuple<bool, Point>>();
        do
        {
            p = todo.Pop();
            var isBorderPixel = false;
            foreach (var n in new[] { new Point(p.X + 1, p.Y), new Point(p.X - 1, p.Y), new Point(p.X, p.Y + 1), new Point(p.X, p.Y - 1) })
                if (_isWhitePixel(n))
                {
                    if (pointsDone.Add(n))
                        todo.Push(n);
                }
                else isBorderPixel = true; // We know we are at the border of the shape
            shape.Add(Tuple.Create(isBorderPixel, p));

        } while (todo.Count > 0);
        return shape;
    }

    static bool _isWhitePixel(Point p)
    {
        return img.GetPixel(p.X, p.Y).ToArgb() == Color.White.ToArgb();
    }
}

Golfed:

using System;using System.Collections.Generic;using System.Drawing;using System.Drawing.Imaging;using System.Linq;class P{static Bitmap a;static int w,h;static ISet<Point> d=new HashSet<Point>();static void Main(string[] q){a=new Bitmap(q[0]);w=a.Width;h=a.Height;var c=new Bitmap(w,h,PixelFormat.Format32bppArgb);Graphics.FromImage(c).DrawImage(a,0,0,w,h);a=c;var e=new[]{Color.Blue,Color.Red,Color.Green,Color.Yellow};var f=new List<ISet<dynamic>>();for(int x=0;x<w;x++)for(int y=0;y<h;y++){Point p=new Point(x,y);if (d.Add(p)&&v(p))f.Add(u(p));}int i=0;foreach(var s in f.OrderBy(s=>s.Count(item=>item.b))){foreach(var x in s)a.SetPixel(x.p.X,x.p.Y,e[i]);i++;}a.Save(q[1]);}private static ISet<dynamic> u(Point p){var t=new Stack<Point>(new[]{p});var s=new HashSet<dynamic>();do{p=t.Pop();var b=false;foreach(var n in new[]{new Point(p.X+1,p.Y),new Point(p.X-1,p.Y),new Point(p.X,p.Y+1),new Point(p.X,p.Y-1)})if(v(n)){if (d.Add(n))t.Push(n);}else b=true;s.Add(new{b,p});}while (t.Count>0);return s;}static bool v(Point p){return a.GetPixel(p.X,p.Y).ToArgb()==Color.White.ToArgb();}}