प्रस्तावना

जैसा कि मैंने आज से पहले एक तीरंदाजी 900 राउंड की शूटिंग कर रहा था (10 छोरों पर 6 छोरों पर, और 10 छोरों पर 3 छोरों पर, कुल 90 तीरों के लिए और 900 के अधिकतम स्कोर के लिए), मैंने इस चुनौती के बारे में सोचा।

तीरंदाजी में (यह मानते हुए कि आप एक FITA आपूर्ति किए गए टारगेट फेस [जिस कागज़ का टुकड़ा आप पर शूट करते हैं] पर शूट कर रहे हैं), प्रत्येक एरो के लिए आप अधिकतम 10. स्कोर का दावा कर सकते हैं। टारगेट फेस में घटते व्यास के 10 या 11 रिंग होते हैं, एक दूसरे के अंदर नेस्टेड। इनर रिंग के बाहर की ओर से, इन्हें 10 बिंदुओं से एक बिंदु तक गिना जाता है (और 11 रिंगों के मामले में, एक माध्यमिक अंतरतम रिंग है जो 'X' के रूप में गिना जाता है, जिसका स्कोर 10 है लेकिन टाई ब्रेकिंग मामलों के रूप में उपयोग किया जाता है उच्च मूल्य)। का निरीक्षण करें:

FITA लक्ष्य स्कोरिंग

बेशक, मैं FITA मीट्रिक स्कोरिंग की बात कर रहा हूं, जैसा कि ऊपर चित्रण में देखा गया है। यदि आप बारीकी से देखते हैं, तो आप अंतरतम रिंग का निरीक्षण कर सकते हैं, जो एक फीकी बिंदीदार रेखा है, जिसका स्कोर चिह्नित नहीं है। यह वह 'एक्स' है जिसका मैं उल्लेख कर रहा था, लेकिन आपको बोनस के लिए प्रतिस्पर्धा करने तक उस पर ध्यान नहीं देना होगा।

चुनौती

एक फ़ंक्शन (या पूर्ण प्रोग्राम बनाएं, यदि भाषा फ़ंक्शन का समर्थन नहीं करती है), जो इनपुट के रूप में एक पूरी तरह से वर्ग छवि प्राप्त करता है (या छवि फ़ाइल नाम, यदि आवश्यक हो), कुछ संख्या में हरे (HEX # 00FF00, RGB (0) 255, 0)) कुछ आकार के डॉट्स, और स्कोर लौटाता है। छवि में हरे बिंदुओं के अलावा डेटा हो सकता है , लेकिन हरा हमेशा एक ही छाया होगा।

आप कल्पना कर सकते हैं कि चौकोर छवि लक्ष्य के चेहरे को दर्शाती है, जिसमें सबसे बाहरी रिंग 4 बिंदुओं (टॉप सेंटर, बॉटम सेंटर, राइट सेंटर, लेफ्ट सेंटर) को छूती है। निरूपित लक्ष्य चेहरा हमेशा उसी अनुपात का होगा, जिसके सभी छल्लों में इनपुट लक्ष्य छवि की चौड़ाई 1/20 की चौड़ाई होगी। एक उदाहरण के रूप में, इनपुट आयामों की एक छवि को 400px द्वारा 400px दिया गया है, तो आप मान सकते हैं कि प्रत्येक अंगूठी में 20px की आंतरिक चौड़ाई है, जैसा कि नीचे सचित्र है:

भद्दा उदाहरण चित्रण

स्पष्टीकरण

यदि दो अलग-अलग रिंगों को छूते हैं, तो दो रिंगों में से उच्च को गिना जाता है
जब तक बोनस के लिए प्रयास न किया जाए, आपको स्वचालित रूप से मिसेस या 'x' केस के लिए खाता नहीं बनाना होगा
आप मान सकते हैं कि कोई भी हरा वृत्त अतिव्यापी नहीं है
आप यह भी मान सकते हैं कि हरे रंग की उस छाया का कोई अन्य पिक्सेल छवि में नहीं है
छवि या तो PNG, JPEG या PPM प्रारूप (आपकी पसंद) में होगी
बाहरी छवि प्रसंस्करण पुस्तकालयों की अनुमति है, अगर इस प्रश्न के पोस्टिंग से पहले लेखक
आप मान सकते हैं कि एक लक्ष्य पर सभी हरे वृत्त एक ही व्यास के होंगे
यदि ओवरलैपिंग सर्कल बोनस के लिए शूटिंग (हाह), आप मान सकते हैं कि छवि में कम से कम एक सर्कल में एक और ओवरलैपिंग नहीं है
मानक खामियों को अस्वीकार कर दिया जाता है

परीक्षण के मामलों

निम्नलिखित दो मामलों में प्रत्येक अंक 52 होना चाहिए (या बोनस के मामले में, 52 1 'x' और 1 मिस के साथ):

और यह अंतिम परीक्षण मामला 25 स्कोर करना चाहिए :

बक्शीश

-25 बाइट्स यदि आप मिस (किसी भी रिंग के बाहर) की संख्या को भी वापस कर देते हैं
-30 बाइट्स यदि आप Xs की राशि लौटाते हैं (मान लें कि अंतरतम x छवि की चौड़ाई का 3/100 वां हिस्सा है, और 10 तो छवि की चौड़ाई का 2/100 वां हिस्सा है। 1-9 अनुपात अपरिवर्तित रहता है।
-35% बाइट गिनती अगर आप अतिव्यापी हलकों के लिए खाते हैं

यह कोड गोल्फ है, इसलिए कम से कम बाइट्स जीतता है। मज़े करो!

code-golf image-processing

— globby
स्रोत

"30 तीर एक छोर पर, कुल 30 तीर के लिए एक छोर है"? 90 तीर नहीं होना चाहिए?

— डेविड डिक

@DavidCarraher मुझे एहसास हुआ कि जैसे मैंने पोस्ट किया है। सही किया गया

— ग्लोबबी

हम किस छवि प्रारूप का उपयोग कर सकते हैं? पीएनजी? पीपीएम? हमारे अपने कस्टम प्रारूप? (मैं पहले दो नहीं बल्कि तीसरे ग्रहण करेंगे, लेकिन सिर्फ स्पष्टीकरण के लिए।)

— दरवाज़े

मान लीजिए कि सिर्फ JPEG या PNG सादगी @Doorknob के लिए冰करते हैं

— globby

1

मुझे लगता है कि सबसे कठिन बोनस सबसे कम इनाम वाला है।

— जस्टिन

4

प्रसंस्करण 2, 448-25 = 423 बाइट्स

int x,y,w,b,v,c,m;color g;PImage i;void setup(){i=loadImage("f.png");w=i.width;size(w,w);g=#00ff00;image(i,0,0);b=v=x=y=c=m=0;loadPixels();while(y*w+x<w*w){if(pixels[y*w+x]==g){f(y,x);if(v>=0)c+=v;else m++;}v=-1;x++;if(x==w){x=0;y++;}}println(c+" "+m);}void f(int k,int l){pixels[k*w+l]=color(0);if(pixels[(k+1)*w+l]==g)f(k+1,l);if(pixels[k*w+l+1]==g)f(k,l+1);if(pixels[k*w+l-1]==g)f(k,l-1);k-=w/2;l-=w/2;b=10-(int)(sqrt(k*k+l*l)/(w/20));if(b>v)v=b;}

पिक्सेल के माध्यम से एक छवि फ़ाइल f लूप में पढ़ता है जब तक कि वह हरा नहीं पाता है तब बाढ़ उस बिंदु को निर्धारित करने वाले सर्कल को भरता है जो केंद्र के सबसे करीब है। फिर उस स्कोर को कुल में जोड़ता है। यदि स्कोर नकारात्मक है, तो इसे एक मिस काउंटर में जोड़ा जाता है।

कार्यक्रम 2 नंबरों को आउटपुट करेगा, पहला स्कोर है और दूसरा नंबरों की संख्या है।

  int x,y,w,b,v,c,m;
  color g;
  PImage i;
void setup()
{
  i=loadImage("f.png");
  w=i.width;
  size(w,w);
  g=#00ff00;
  image(i,0,0);
  b=v=x=y=c=m=0;  
  loadPixels();
  while(y*w+x<w*w)
  {
    if(pixels[y*w+x]==g)
    {
      f(y,x);
      if(v>=0)c+=v;
      else m++;
    }
    v=-1;
    x++;
    if(x==w){x=0;y++;}
  }
  print(c+" "+m);
}

void f(int k,int l)
{
  pixels[k*w+l]=color(0);
 if(pixels[(k+1)*w+l]==g)f(k+1,l);
 if(pixels[k*w+l+1]==g)f(k,l+1);
 if(pixels[k*w+l-1]==g)f(k,l-1); 
 k-=w/2;
 l-=w/2;
 b=10-(int)(sqrt(k*k+l*l)/(w/20));
 if(b>v)v=b;
}

आप यहाँ प्रसंस्करण प्राप्त कर सकते हैं

— bubalou
स्रोत

4

पर्ल 5 + जीडी: 225 - 25 = 200

संपादित करें: अनुक्रमित PNGs में गलत पिक्सेल पढ़ने का कारण मिला और वर्कअराउंड लागू किया। जीडी लाइब्रेरी के साथ किसी कारण से हरे रंग के पिक्सेल मान (4,254,4) के रूप में पढ़े जाते हैं। मुझे यकीन नहीं है कि यह प्रश्न में शामिल पीएनजी फाइलों के लिए विशिष्ट है। नीचे दिए गए कोड में लाइन ब्रेक को हटाया जा सकता है।

use GD;$k=newFromPng GD::Image'-',1;
sub v{/ /;10-int((($'-@x/2)**2+($`-@x/2)**2)**.5/@x*20)}
map{v>0?($r+=v):$%++,fill$k @c,0if 65280==getPixel$k @c=split
}sort{v($_=$b)- v$_=$a}map{//;map"$_ $'",@x}@x=0..width$k-1;
print"$r $%"

इनपुट पर एक PNG छवि लेता है और 2 मान प्रिंट करता है: अंकों और यादों की संख्या। उदाहरण के लिए:

perl arch.pl <arch52.png
52 1

अंतिम मिनट परिवर्तन:

सच रंग मोड है कि मैं वैसे भी द्वारा प्रयोग किया जाता रंग अनुक्रमित की जरूरत में getPixelऔर fillबस पूर्णांक आरजीबी मूल्यों इनकोड, तो उपयोग करने की आवश्यकता rgbहै और colorAllocateकरने के लिए और उन अनुक्रमित से कन्वर्ट करने के लिए।

स्पष्टीकरण:

सभी पिक्सेल निर्देशांक की सूची बनाएँ (अंतरिक्ष पूर्णांक के जोड़े को अलग करके)।
संभावित स्कोर के आधार पर छाँटें ( sub vजिसके माध्यम से पैरामीटर लेता है$_ मानक पैरामीटर के बजाय क्योंकि यह छोटा है)।
उच्चतम स्कोरिंग से शुरू होने वाले प्रत्येक पिक्सेल के लिए यदि यह परिणाम के लिए हरा है और बाढ़ इसके स्थान को काला कर देती है।

— nutki
स्रोत

यह चित्र नहीं है; @ bubalou का जवाब सही ढंग से # 00FF00 के रूप में रंग पढ़ा

— globby

@ ग्लोबबी मुझे पता है कि रंग छवि में सही हैं (मैंने छवि संपादन सॉफ्टवेयर के साथ जाँच की), लेकिन शायद रंग स्थान को ट्रिम करने के लिए भी वही मेटा जानकारी है।

— नटकी

संभवतः। हालांकि यह अजीब है

— ग्लोबबी

3

हस्केल - 579-25 = 554 603-25-30 576-25-30 = 521 बाइट्स

रणनीति:

सभी पिक्सेल के लिए (d, x, y) त्रिभुजों की सूची बनाएँ (d केंद्र से दूरी पर है)
दूरी के अनुसार सूची को क्रमबद्ध करें
सबसे बड़ी दूरी के साथ शुरुआत: यदि पिक्सेल एक छोटे से पड़ोस में केवल हरे रंग का पिक्सेल है, तो इसे L की सूची में रखें, अन्यथा इसे काला कर दें
दूरी सूची एल से स्कोर की गणना करें

आउटपुट एक ट्रिपल (स्कोर, मिस, एक्स) है, जैसे (52,1,1) के लिए परीक्षण छवि के लिए।

यदि केंद्र के निकटतम सर्कल का पिक्सेल किसी अन्य सर्कल के 3 पिक्सेल के भीतर है, तो प्रोग्राम विफल हो सकता है।

import Data.List
import Codec.Picture
import Codec.Picture.RGBA8
import Codec.Picture.Canvas
z=fromIntegral
f(e,x,y)(v,h)|and$j x y:[not$j a b|a<-[x-3..x+3],b<-[y-3..y+3],not(a==x&&b==y)]=(v,e:h)|1<2=(setColor x y(PixelRGBA8 0 0 0 0)v,h)
 where j n m|PixelRGBA8 0 255 0 _<-getColor n m v=0<1|0<1=0>1
d k r(h,i,j)|r>10*k=(h,i+1,j)|r<k*3/5=(h+10,i,j+1)|1<2=(10-(floor$r/k)+h,i,j)
main=do
 i<-readImageRGBA8 "p.png"
 let(Right c)=imageToCanvas i;s=canvasWidth c;q=[3..s-4];(_,g)=foldr f(c,[])$sort[(sqrt$(z x-z s/2)^2+(z y-z s/2)^2,x,y)|x<-q,y<-q]
 print$foldr(d$z s/20)(0,0,0)g

— nimi
स्रोत

एक टिप: .also all idके समान है and, आप jपैटर्न गार्ड के साथ लागू कर सकते हैंj n m|PixelRGBA8 0 255 0 _<-getColor n m v=0<1|0<1=0>1

— गर्व हैकेलर

@proudhaskeller: हाँ, धन्यवाद!

— nimi

2

गणितज्ञ - 37१ 386 - 25 = 361

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

i=IntegerPart;c=i/@((NestList[#+.01&,.1,10]~Prepend~1)*100);g[m_]:=Last@@c~Position~#-1&/@(i@Round@Last@#&/@(#*100&/@Riffle[RGBColor/@NestList[#+.01&,{.1,.1,.1},10],Table[Disk[{0,0},n],{n,1,.1,-.1}]]~Graphics~{ImageSize->ImageDimensions[m],PlotRangePadding->None}~ImageMultiply~ChanVeseBinarize[m,"TargetColor"->Green]~ComponentMeasurements~"Max"/.Rule[a_,b_]:>b))//{Total@#,#~Count~0}&

पीआईएल के साथ अजगर - एक तुच्छ और गैर-इष्टतम समाधान, 961 बाइट्स

यह बस समस्या को हल करने पर एक मूर्खतापूर्ण दृष्टिकोण का प्रदर्शन करने की कोशिश है। पहले दो परीक्षण मामलों को चलाने में ~ 2 मिनट लगते हैं, और ~ 20 मिनट मेरे सिस्टम पर तीसरे को चलाने के लिए क्योंकि जल्दी से बना हुआ है, बहुत ही संसाधन गहन, और प्रतिकारक रूप से एल्गोरिथ्म जटिल सर्कल डिटेक्टर। इसके बावजूद, यह आवश्यकताओं को पूरा करता है, हालांकि यह निश्चित रूप से उम्मीद के मुताबिक नहीं है। जितनी अधिक हरे रंग की छवि होती है, उसे चलाने में उतना ही अधिक समय लगता है।

from PIL import Image,ImageDraw
a=lambda x,y,w,h:filter(lambda x:0<=x[0]<w and 0<=x[1]<h,[(x-1,y-1),(x,y-1),(x+1,y-    1),(x-1,y),(x,y),(x+1,y),(x-1,y+1),(x,y+1),(x+1,y+1)])
def b(c):
 d=0,255,0;e,f=c.size;g=c.load();h,i=[],[];j=Image.new("RGB",(e,f));k=ImageDraw.Draw(j)
 for l in range(e):
  for m in range(e):
   n=g[l,m][:-1]
   if n==d and(l,m)not in i:
    o=[(l,m)];p=[];q=1
    while q:
     q=0;r=o[:]
     for s in o:
      t=filter(lambda x:g[x[0],x[1]][:-1]==d and(x[0],x[1]) not in r,a(s[0],s[1],e,f))
      if t:
       r+=t
       if len(t)<8:
        p+=[s]
       q=1
     o=r
    h+=[p]
    for u in o:
     i+=[u]
   i+=[(l,m)]
 p=map(lambda x:"#"+str(x)*6,'123456789ab');v=0;k.rectangle((0,0,e,f),fill=p[0])
 for n in p[1:]:
  w=e/20*v;x=e-w;k.ellipse((w,w,x,x),fill=n);v+=1
 y=j.load();z=0
 for l in h:
  v=[]
  for m in l:
   s=y[m[0],m[1]]
   if s not in v:
    v+=[s]
  v=max(v);z+=p.index("#"+''.join(map(lambda x:hex(x)[2:],v)))
 return z

एक पीआईएल छवि वस्तु लेता है, और स्कोर लौटाता है।

कदम यह लेता है:

हरे घेरे अलग करें (अक्षम रूप से)
- कुछ पिक्सेल के सभी पड़ोसी खोजें n , यदि कोई भी हरे रंग का पिक्सेल है, तो उन्हें सर्कल में जोड़ें
- 8 पड़ोसियों वाले पिक्सेल को फ़िल्टर करके किसी न किसी रूपरेखा का निर्धारण करें
एक लक्ष्य प्रतिनिधित्व ड्रा करें
- एक रिक्त कैनवास बनाएँ
- एक अद्वितीय रंगीन पृष्ठभूमि बनाएं (याद करने में आसान)
- अद्वितीय रंगों के साथ नेस्टेड इलिप्स ड्रा करें
निर्धारित करें कि प्रत्येक सर्कल में कौन सा स्कोरिंग ज़ोन है, लक्ष्य के रंग (एस) का निर्धारण करके जो सर्कल के नीचे होगा
स्कोरिंग ज़ोन (यदि एकाधिक) के उच्च चुनें और कुल में स्कोर जोड़ें
कुल लौटाओ