कोड गोल्फ के 9 छेद - किकऑफ़

Question

पहले से ही 9 होल चैलेंज (और यहां एक और ) हो चुका है , लेकिन वह पिछले साल सू था। और इसके अलावा, मैं केवल 2 महीने के लिए रहा हूं (हालांकि यह हमेशा की तरह लगता है)। और यह काफी अलग है।

लीडर बोर्ड: (ध्यान दें कि छेद के लिए वजन अभी तक स्थापित नहीं हैं)

+---------------+------------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+
|Competitor     | Language   | Hole 1 | Hole 2 | Hole 3 | Hole 4 | Hole 5 | Hole 6 | Hole 7 | Hole 8 | Hole 9 | Total  |
+----------------------------------------------------------------------------------------------------------------------+
|Dennis         |CJam        |        | 31     |        |        |        |        |        |        |        | 31     |
+----------------------------------------------------------------------------------------------------------------------+
|Optimizer      |CJam        |        | 35     |        |        |        |        |        |        |        | 35     |
+----------------------------------------------------------------------------------------------------------------------+
|Martin Büttner |Mathematica |        | 222    |        |        |        |        |        |        |        | 222    |
+----------------------------------------------------------------------------------------------------------------------+
|Cameron        |Python      | 878    |        |        |        |        |        |        |        |        | 878    |
+----------------------------------------------------------------------------------------------------------------------+
|bubalou        |Processing 2| 717    |        |        |        |        |        |        |        |        | 717    |
+----------------------------------------------------------------------------------------------------------------------+
|Doorknob       |Python 2    |        |        |0.079711|        |        |        |        |        |        |0.079711|
+----------------------------------------------------------------------------------------------------------------------+
|Vulcan         |Java        |        |        |0.6949  |        |        |        |        |        |        |0.6949  |
+----------------------------------------------------------------------------------------------------------------------+
|Eli            |C++         |        |        |1.42042 |        |        |        |        |        |        |1.42042 |
+---------------+------------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+

अन्य छेद:

• छेद २
• छेद ३

यह हाल ही में यहां लगभग धीमा हो गया है, इसलिए मैं यहां अगले 9 होल गोल्फ कोर्स को किक करने के लिए हूं, जिसमें उन सभी को शामिल करना है जो मैंने अपने (सीमित) अनुभव में यहां देखे हैं। यह दर्ज करेगा:

• अससी कला
• ग्राफिकल आउटपुट
• कॉनवे का जीवन का खेल
• पहाड़ी के राजा
• कोलमोगोरोव जटिलता
• Quines
• इमेज प्रोसेसिंग
• गणित
• क्लासिक कोड गोल्फ।

मैं वास्तव में आगे देख रहा हूं कि आप क्या कर सकते हैं!

प्रतियोगिता नियम

• आप सभी छेदों के लिए 1 भाषा चुनेंगे (जिसमें आप भाग लेते हैं ... अधिक जानकारी के लिए बिंदु 4 देखें)।
• सभी छेदों के लिए - मानक कमियां (अभी भी) मज़ेदार नहीं हैं।
• अगली चुनौती तब दिखाई देगी जब मैं देखूंगा कि समय की उचित मात्रा को देखते हुए पर्याप्त प्रस्तुतियाँ हैं। उदाहरण के लिए, पहाड़ी के राजा को अधिक समय लगेगा।
• आपको सभी छेदों में भाग लेने की आवश्यकता नहीं है। यदि आपको कोई छेद विशेष रूप से चुनौतीपूर्ण लगता है, तो उसे करने के लिए समय नहीं है, आदि, आपको सबसे कम अंक के रूप में कई बार 2 अंक प्राप्त होंगे। कृपया १२ वर्णों के साथ १ गोल्फ उत्तर छोड़ कर २४ अंक लेकर इस नियम का लाभ न लें।

स्कोरिंग

• आपका स्कोर सभी छेदों से स्कोर की परिणति पर आधारित है
• न्यूनतम स्कोर जीत (असली गोल्फ के अनुसार)
• लीडरबोर्ड को इस पृष्ठ के शीर्ष पर रखा जाएगा

मैं यह सुनिश्चित करने के लिए अपनी पूरी कोशिश करूंगा कि कोई भी प्रश्न डुप्लिकेट नहीं है, सभी प्रश्नों में वस्तुनिष्ठ मानदंड हैं, अच्छी तरह से लिखे गए हैं, और यह कि वे सभी (अपेक्षाकृत) पूरे प्रतियोगिता के संदर्भ में बराबर वजन रखते हैं।

हालांकि, जब मैं असफल हो तो कृपया धैर्य रखें।

और, आगे की हलचल के बिना, पहली चुनौती!

प्लाज्मा ग्लोब

एक प्लाज्मा ग्लोब हर किसी का पसंदीदा खिलौना है:

अपनी नौकरी यह एक आकर्षित करने के लिए।

आपको एक आधार तैयार करना होगा:

विश्व:

एक टेस्ला बात (?)

और, निश्चित रूप से, शांत प्लाज्मा शूट:

हालाँकि, जब आप प्लाज्मा ग्लोब के पास अपना हाथ रखते हैं (या एक प्रवाहकीय वस्तु जैसा कि विकिपीडिया मुझे बताता है), तो यह प्लाज्मा को आकर्षित करता है ।

आपके ग्लोब को यह प्रतिबिंबित करना चाहिए।

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

ध्यान दें कि
1. मध्य में काला वृत्त प्लाज्मा के ऊपर रहता है।
2. इस उदाहरण में, कोण pi / 2 होगा।

आपके पास एक से अधिक प्रवाहकीय वस्तु हो सकती है, और उस घटना में, यह आवश्यक नहीं है कि शूट समान रूप से अलग हो। हालांकि, वे अपेक्षाकृत बाहर हैं। उदाहरण के लिए, यह 2 वस्तुओं के लिए ठीक है, 1 कोण pi / 4 शक्ति 5 पर और दूसरा कोण 5pi / 3 शक्ति 3 पर:

आपको शूट के प्रत्येक अंतिम बिंदु (प्लाज्मा के) को देखने में सक्षम होना चाहिए।

हालांकि, 16 से अधिक शक्ति वाली एक वस्तु (या वस्तुओं का योग) को देखते हुए, दुनिया "टूट जाएगी":

टिप्पणियाँ

• ग्लोब का व्यास आधार की लंबाई से 1.5 गुना बड़ा है, जो एक वर्ग है
• जब ग्लोब टूटता है, तो ग्लोब दाईं ओर होता है। यह जमीन के साथ-साथ आधार के दाईं ओर स्पर्शरेखा है। प्लाज्मा ग्लोब के टूटने पर कोई प्लाज्मा नहीं होना चाहिए (क्यों? निश्चित रूप से सुरक्षा विशेषताएं! इस पर कोई शब्द नहीं है कि यह पहली जगह में कैसे टूट गया।)
• शूट को छोड़कर हर चीज का रंग काला होना चाहिए, और 1 पिक्सेल मोटा होना चाहिए। प्लाज्मा का रंग 245 - 280, और संतृप्ति / मान 100 है। "HSV" के तहत इसका उपयोग करें यदि आपको कोई पता नहीं है कि मैं किस बारे में बात कर रहा हूं।

इनपुट

इनपुट STDIN / कमांड लाइन args / जो कुछ भी या फ़ंक्शन तर्कों के माध्यम से हो सकता है।

प्लाज्मा इनपुट के बेस की लंबाई 2 होनी चाहिए - (वेक्टर ग्राफिक्स का उपयोग करते हुए एक अक्ष शामिल करें), और ऑब्जेक्ट्स की एक सरणी:

[[angle,power],[angle,power],[angle,power]]

तो बिना ऑब्जेक्ट के (16 लाइनों के साथ पहली तस्वीर देखें) इनपुट होगा

100,[]

अगली (एक वस्तु, शक्ति 5) के लिए यह होगा:

100,[[1.570796,5]]

अंतिम उदाहरण के लिए:

100,[[0.785398,5],[5.23598,3]]

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

Comments

@ मार्टिनबटनर यदि बेस-लेंथ छोटी होने पर इमेज छोटी नहीं होती है, तो एक धुरी शामिल करें

— स्ट्रेच मैनीक्योर

अपने दूसरे उदाहरण में। क्या होगा अगर दूसरी वस्तु थी -3/8π? उस स्थिति में यह अन्य बीमों में से एक के साथ ओवरलैप होगा। क्या हमें ऐसे मामले में सभी बीमों को घुमाना होगा? यदि ऐसा है, तो मुझे लगता है कि आपको यह निर्दिष्ट करने की आवश्यकता है कि वस्तु-प्रेरित बीम से अलग-अलग बीमों की कितनी दूरी होनी चाहिए।

— मार्टिन एंडर

एर .... क्यों बोर्ड का "छेद 2" पहले से ही भरा हुआ है, भले ही कोई जवाब न हो?

— क्लेम १

इसे बेहतर रूप से देखने के लिए थोड़ी मदद: inear.se/plasmaball

— CSᵠ

@xem उम, वहाँ 2 छेद करने के लिए उत्तर हैं, तो उन्हें पोस्ट क्यों नहीं? यह जरूरी नहीं है कि क्रम में जाना है ...

— स्ट्रेच उन्मत्त

Answer 1

प्रसंस्करण 2 - 717 अक्षर

जैसा कि प्रसंस्करण कलाकारों के लिए बनाई गई भाषा है, और मैं एक बहुत ही नौसिखिया प्रोग्रामर हूं, मैं इनमें से कई चुनौतियों पर बहुत अच्छा करने की उम्मीद नहीं करता हूं। कहा जा रहा है, मुझे वास्तव में पसंद है कि प्रसंस्करण में चीजों को आकर्षित करना कितना सरल है, और मुझे इसके साथ कुछ और खेलने का मतलब है, इसलिए ये चुनौतियां दिलचस्प होनी चाहिए।

int j,m,b,k,d,l;float w,c,h,x,y,z;float v[],p[],g[];void setup(){j=m=d=0;c=z=0;String i[]= loadStrings("f.txt");i[0]=i[0].replace("[","").replace("]","");String o[]=split(i[0],',');v=new float[o.length];p=new float[o.length-1];for(String s:o){if(!s.equals("")){v[j]=Float.parseFloat(s);}j++;}w=v[0];size((int)w*3,(int)w*3);h=w*.75;l=v.length;noLoop();}void draw(){translate(w/2,height);scale(1,-1);rect(0,0,w,w);if(l>2){while(m<j-1){m+=2;c+=v[m];}}if(c>16){ellipse(w+h,h,2*h,2*h);rect(w/2,w,1,h);}else{ellipse(w/2,w+h,2*h,2*h);rect(w/2,w,1,h);b=16;m=1;stroke(#1500ff);if(l>2){while(m<j){p[m-1]=cos(v[m])*h;p[m]=sin(v[m])*h;strokeWeight(v[m+1]);line(w/2,w+h,p[m-1]+w/2,p[m]+w+h);b-=v[m+1];m+=2;}}strokeWeight(1);c=(PI*2)/b;k=b;g=new float[b+b];while(b>0){g[d]=cos(z+c*b)*h;g[d+1]=sin(z+c*b)*h;m=0;if(l>2){while(m<j-1){if(abs(g[d]-p[m])<.1 && abs(g[d+1]-p[m+1])<.1){b=k+1;z=z+.1;d=-2;break;}m+=2;}}b--;d+=2;}d--;while(d>0){line(w/2,w+h,g[d]+w/2,g[d-1]+w+h);d-=2;}}stroke(#000000);fill(#000000);ellipse(w/2,w+h,w/9,w/9);}

मुझे यकीन है कि यह काफी कम हो सकता है और मैं ऐसा करने की कोशिश कर सकता हूं, जब मेरे पास अधिक समय होगा, लेकिन अब मैं इससे खुश हूं।

स्केच के डेटा फ़ोल्डर में स्थित फ़ाइल (f.txt) में पढ़ता है ताकि उसका इनपुट मिल सके। जब तक वे ओवरलैप नहीं करते मैंने मुफ्त बीम को स्थानांतरित करने के कैमरन विचार का उपयोग किया।

int j,m,b,k,d,l;
float w,c,h,x,y,z;
float v[],p[],g[];
void setup(){
j=m=d=0;
c=z=0;
String i[]= loadStrings("f.txt");
i[0]=i[0].replace("[","").replace("]","");
String o[]=split(i[0],',');
v=new float[o.length];
p=new float[o.length-1];
for(String s:o){if(!s.equals("")){v[j]=Float.parseFloat(s);}j++;}
w=v[0];
size((int)w*3,(int)w*3);
h=w*.75;
l=v.length;
noLoop();
}

void draw()
{
  translate(w/2,height);
  scale(1,-1);
  rect(0,0,w,w);
  if(l>2) 
  {
    while(m<j-1)
    {
      m+=2;
      c+=v[m];
    }
  }
  if(c>16)
  {
    ellipse(w+h,h,2*h,2*h);
    rect(w/2,w,1,h);
  }
  else
  {
    ellipse(w/2,w+h,2*h,2*h);
    rect(w/2,w,1,h);
    b=16;m=1;
    stroke(#1500ff);
    if(l>2)
    { 
      while(m<j)
      {
        p[m-1] = cos(v[m]) * h;
        p[m] = sin(v[m]) * h;
        strokeWeight(v[m+1]);
        line(w/2,w+h,p[m-1]+w/2,p[m]+w+h);
        b-=v[m+1];
        m+=2;
      }
    }
    strokeWeight(1);
    c=(PI*2)/b;
    k=b;
    g=new float[b+b];
    while(b>0)
    {
      g[d] = cos(z+c*b) * h;
      g[d+1] = sin(z+c*b) * h;
      m=0;
      if(l>2)
      {
        while(m<j-1)
        {
          if(abs(g[d]-p[m])<.1 && abs(g[d+1]-p[m+1])<.1)
          {
            b=k+1;
            z=z+.1;
            d=-2;
            break;
          }
          m+=2;
        }
      }
      b--;
      d+=2;
    }
    d--;
    while(d>0)
    {
      line(w/2,w+h,g[d]+w/2,g[d-1]+w+h);
      d-=2;
    }
  }
    stroke(#000000);
    fill(#000000);
    ellipse(w/2,w+h,w/9,w/9);
}

उदाहरण:

100, [[0.785398,3], [5.23598,5]]

100, []

100, [[1.72398,12], [5.23598,5]]

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

Answer 2

अजगर, 878 चरस

किसी भी तरह से यह अच्छी तरह से गोल्फ नहीं है, लेकिन मैं इस छेद के लिए एक जवाब देखना चाहता था।

import matplotlib.pyplot as P
from math import *
L=len
M=min
Y=P.plot
K=P.Circle
Z=P.gcf().gca().add_artist
f=sin
g=cos
k={'color':(0,0,0)}
j={'color':(.16,0,1)}
def Q(S,C):
    P.axis([-S,S*2.5,0,S*3.5],**k)
    Y([0,S,S,0,0],[0,0,S,S,0],**k)
    Y([S/2,S/2],[S,7*S/4],**k)
    Z(K([S/2,7*S/4],S/20,**k))

    k['fill']=False

    A,B=zip(*C)

    N=16-sum(B)
    if N<0:
        Z(K([7*S/4,3*S/4],3*S/4,**k))

    else:
        Z(K([S/2,7*S/4],3*S/4,**k))
        if L(C)==0:
            D(16,0,S)
        elif L(C)==1:
            D(N,A[0],S)
            Y([S/2,S/2+3*S*g(A[0])/4],[7*S/4,7*S/4+3*S*f(A[0])/4],linewidth=B[0],**j)
        else:
            for c in C:
                Y([S/2,S/2+3*S*g(c[0])/4],[7*S/4,7*S/4+3*S*f(c[0])/4],linewidth=c[1],**j)
            D(N,J(N,A),S)
    P.show()


def J(N,A):
    T=d=0
    t=2*pi/N
    while d<0.1:
        T+=0.1
        d=M(M(a-T-floor((a-T)/t)*t for a in A),\
            M(T+ceil((a-T)/t)*t-a for a in A))
    return T


def D(N,I,S):
    a=I
    for i in range(N):
        Y([S/2,S/2+3*S*g(a)/4],[7*S/4,7*S/4+3*S*f(a)/4],**j)
        a+=2*pi/N

और कुछ नमूना आउटपुट

Q(100,[[pi/4,6],[-4.2*pi/8,1]])

Q(100,[[0.785398,10],[5.23598,7]])

Q(100,[[pi/4,3],[pi/2,3],[3*pi/2,2],[5*pi/4,2]])

Comments

यह कैसे सुनिश्चित करता है कि ऑब्जेक्ट-प्रेरित और फ्री बीम कभी ओवरलैप न हों?

— मार्टिन एंडर

मैं एक छोटी राशि से समान रूप से दूरी वाले बीम को घुमाता हूं जब तक कि मुझे एक अभिविन्यास नहीं मिलता है जो यह सुनिश्चित करता है कि बीम कम से कम 0.1 रेडियन अलग

— कैमरून

आह, ठीक है, मैं कुछ इस तरह की उम्मीद थी। स्पष्टीकरण देने के लिए धन्यवाद!

— मार्टिन एंडर

एनपी, मैं किसी भी वस्तु-प्रेरित बीम और किसी भी मुक्त किरण के बीच न्यूनतम दूरी को अधिकतम करने के तरीके को हल करने की कोशिश कर रहा हूं, लेकिन यह एक मुश्किल सवाल लगता है

— कैमरून

A,B=zip(*C)कुछ बाइट्स बचाना चाहिए

— gnibbler

Answer 3

पायथन 2.7, 378 375

from turtle import *;import sys
(s,P),A,B=eval(sys.argv[1]),90,180
n,S=sum([b for(a,b) in P]),.75*s;l=16-n
for i in 'abcd':fd(s);lt(A)
pu()
if l<0:goto(s+S,0)
else:goto(s/2,s)
pd();circle(S);pu();goto(s/2,s);lt(A);pd();fd(S)
def C():fd(S);fd(-S)
if n<16:
 color('blue')
 for i in range(l):rt(360/l);C()
 for a,p in P:pensize(p);rt(a*57.3);C()
color('black')
shape('circle')

यह अपने मापदंडों को कमांडलाइन तर्क से पढ़ता है।

नमूना चित्र:

(पैरामीटर = 100,[[0.785398,5],[5.23598,3]])

(पैरामीटर = 100,[])

(पैरामीटर = 100,[[1.72398,12],[5.23598,5]])

Comments

मैं यह परीक्षण करने में सक्षम नहीं था, लेकिन यह थोड़ा यहाँ गोल्फ

— 0WJYxW9FMN