उन्हें लेज़रों के साथ नष्ट करें

Question

परिचय

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

आप अपने लेजर से किन दुश्मनों को मार सकते हैं, और जो छिपा रहे हैं?

संकट

सबसे पहले, एक क्षेत्र nपर एक पूर्णांक द्वारा एक अखाड़ा का आकार दिया जाता है । निम्नलिखित nपंक्तियों में nएक स्थान द्वारा अलग की गई प्रति पंक्ति पूर्णांक होती है। प्रत्येक पूर्णांक उस स्थान पर भवन की ऊंचाई का प्रतिनिधित्व करता है। प्रत्येक इमारत एक आयताकार ठोस है, 1 यूनिट 1 यूनिट ऊंचाई इकाइयों द्वारा।

इसके बाद, अपने स्थान तीन चल बिन्दु संख्या के रूप में एक पंक्ति पर दिया जाता है x, y, z।

अंत में, mएक पंक्ति में पूर्णांक द्वारा दुश्मनों की संख्या दी जाती है । निम्न mपंक्तियों में एक स्थान द्वारा अलग की गई प्रति पंक्ति तीन फ़्लोटिंग पॉइंट नंबर होते हैं। ये प्रतिनिधित्व करते हैं x, yऔर zएक दुश्मन के निर्देशांक। समन्वय प्रणाली को निम्नानुसार परिभाषित किया गया है:

• x शहर के इनपुट में बाएं से दाएं मापा जाता है
• y ऊपर से नीचे तक मापा जाता है
• z जमीन से मापा जाता है

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

नमूना इनपुट

टिप्पणियाँ, '#' द्वारा निरूपित की जाती हैं, जो आपको यह देखने में मदद करने के लिए मौजूद हैं कि प्रत्येक पंक्ति क्या करती है। वे वास्तविक इनपुट में मौजूद नहीं होंगे।

5              # Size of the map
0 0 0 0 0      # Buildings
0 0 0 0 0      # Buildings
4 4 4 4 4      # Buildings
0 0 0 0 0      # Buildings
0 0 0 0 0      # Buildings
2.5 0.0 4.0    # Your location
3              # Number of enemies
2.5 5.0 0.1    # Enemy location
2.5 5.0 5.0    # Enemy location
0.0 2.7 4.5    # Enemy location

नमूना उत्पादन

ऊपर दिए गए नमूना इनपुट के लिए, हम निम्न आउटपुट करते हैं:

-1
1
1

मान्यताओं

• 0 << n100
• 0 << m100
• 0 <= x<=n
• 0 <= y<=n
• 0 <= z<n
• खिलाड़ी किसी भवन के कोने, किनारे या किनारे पर या अंदर नहीं होंगे
• किसी दुश्मन के लिए आपकी दृष्टि कभी भी किसी इमारत के कोने, किनारे या किनारे पर नहीं जाएगी
• एक खिलाड़ी एक बाधा नहीं है

Comments

खुशी है कि इसे सैंडबॉक्स से बाहर देखना :)

— टिमटेक

अगर मैं किसी दुश्मन को नष्ट नहीं कर सकता, तो क्या मैं उनसे जुड़ सकता हूं?

— जॉन ड्वोरक

@ user80551 क्षमा करें, मुझे आपके संपादन को शीर्षक में वापस करना पड़ा क्योंकि गलत वर्तनी जानबूझकर की गई थी। यह गूगल।

— बारिश

@Rusher ओह, क्षमा करें, IDK कि

— user80551

संबंधित: youtube.com/watch?v=NKTpWi5itOM

— qwr

Answer 1

पर्ल, 301 296 282

संपादित करें 2: वास्तव में, प्रतियोगिता या नहीं, यह थोड़ा और आगे बढ़ने का कोई कारण नहीं है। इसे ऑनलाइन टेस्ट करें ।

संपादित करें: कोष्ठकों के जोड़े चले गए, गैर-शून्य पूर्णांक की जांच करने के लिए सरल रीगेक्स।

पठनीयता के लिए नई सूचियों और मांगपत्र के साथ:

sub i{<>=~/\S+/g}
@b=map[i],@r=0..<>-1;
print.1<=>(map{
    @a[1,0,2,4,3]=@a;
    @b=map{$i=$_;[map$b[$_][$i],@r]}@r;
    grep$a[3]
        &&($k=(($x=$_)-$a[0])/$a[3])**2<=$k
        &&pop[sort map@{$b[$_]}[$x-!!$x,$x],
                   ($_=$a[1]+$k*$a[4]),$_-/^\d+$/]
           >=$a[2]+$k*$a[5]
    ,@R=@r
}@a=map$_-shift@v,i,@u=@v=@$_),$/for([i])x<>

5.14स्केलर (सरणी संदर्भ) तर्क के कारण इसकी आवश्यकता होती है pop।

Comments

क्या आप अपने समाधान को थोड़ा समझा सकते हैं? मैंने इसका परीक्षण नहीं किया है और मैंने पर्ल को झुकाव नहीं किया है, फिर भी, इसलिए कुछ टिप्पणियां अच्छी होंगी।

— वर्ल्डसेडर

@WorldSEnder, एल्गोरिथम की रूपरेखा निम्नानुसार है। स्ट्रेट लाइन PE3-डी स्पेस, "प्लेयर" (X1Y1Z1) और "दुश्मन" (X2Y2Z2) में दो बिंदुओं को जोड़ती है। (XY)समतल पर इसका प्रक्षेपण कुछ ग्रिड-लाइनों यानी पूर्णांकों x = constया y = constजैसे कि X1 < x < X2या Y1 < y < Y2(जैसे कि यहाँ है X1 < X2, लेकिन यह महत्वपूर्ण नहीं है) को प्रतिच्छेद करता है । x yइन चौराहों के निर्देशांक आसानी से मिल सकते हैं, और इसलिए लाइन zपर एक बिंदु का समन्वय PEभी।

— user2846289

(जारी) दूसरी ओर, किसी भी x yनिर्देशांक के लिए, हम hइमारत की ऊंचाई जानते हैं (बल्कि, अधिकतम 4 इमारतों की ऊंचाई जो साझा करते हैं x y)। h < zउपरोक्त उल्लेखित सभी "चौराहे बिंदुओं" के लिए (और केवल अगर) शत्रु को गोली मार दी जा सकती है। कार्यान्वयन कुछ बुनियादी अंकगणित है, साथ ही साथ गोल्फ के उद्देश्य के लिए पर्ल के साथ कई चालें भी हैं। एक महीने पहले मैंने इसे कैसे किया, इसका विवरण देने में अभी कुछ समय लगेगा :-)।

— user2846289

अर्घ, जैसा कि मैं देख रहा हूं कि अंतिम (5 वें) संशोधन में एक बग है: अभिव्यक्ति @aमें सरणी के तत्वों के सूचकांकों को इसके बजाय grepआदेश में प्रकट होना चाहिए - क्षमा करें। 0,3,0,4,1,5,23,0,3,1,4,2,5

— user2846289

ठीक है, कभी नहीं से बेहतर देर हो गई, और इस सब के साथ खत्म करने के लिए, यहां टिप्पणी संस्करण है।

— user2846289

Answer 2

पायथन 2.7 - 429 420 308 308 वर्ण

मैंने इस चुनौती को एक कोड गोल्फ समस्या की तुलना में एक गणित समस्या के रूप में अधिक सोचा था, इसलिए यदि मैं कुछ स्पष्ट अनुकूलन से चूक गया, तो मेरे लिए बहुत कठोर मत बनो। वैसे भी, यहाँ कोड है:

b=lambda:raw_input().split()
m=map
d=range(input())
h=[m(int,b())for _ in d]
x,y,z=m(float,b())
for e,f,g in[m(float,b())for _ in[1]*input()]:o=lambda x,y,u,v,i,j:i<=x+u/v*(j+1-y)<=i+1<[]>z+(g-z)/v*(j+1-y)<=max(h[i][j:j+2])if v else 0;print 1-2*any(o(x,y,e-x,f-y,j,i)+o(y,x,f-y,e-x,i,j)for j in d for i in d)

यह किनारे और कोने के मामलों (अनजाने में सजा) के लिए काम करना चाहिए और बहुत ठोस है। प्रदान किए गए उदाहरण के लिए ऊपुत:

-1
1
1

और यहाँ एक "लघु" स्पष्टीकरण है:

fast_read = lambda : raw_input().split() # define a helper
# m = map another helper
grid_range = range(input())
houses = [map(int, fast_read()) for _ in grid_range]
# 'map(int,...)' is a shorter version of '[int(a) for a in ...]'
pos_x,pos_y,pos_z = map(float, fast_read()) # read the player position
# the following loops through all enemy coordinates
for ene_x, ene_y, ene_z in [map(float,fast_read()) for _ in[1]*input()]:
    vec_z = ene_z - pos_z
    # is_hit macro uses vector math to detemine whether we hit a specific wall
    # wallhit -> 1
    # no wallhit -> 0
    is_hit = lambda pos_x, pos_y, vec_x, vec_y, co_x, co_y:\
        (co_x <= pos_x + vec_x/vec_y * (co_y + 1 - pos_y) <= co_x + 1 # check if hit_x is good
        < [] > # an effective and
        pos_z + (ene_z - pos_z)/vec_y * (co_y + 1 - pos_y) <= max(houses[co_x][co_y:co_y + 2]) # check if hit_z is good
        if vec_y else 0) # if vec_y is 0 we can't hit the wall parallel to y
    print (.5 - # can hit -> 0.5 - 0 = 0.5, hit -> 0.5 - 1 = -0.5
            any( # if we hit any wall
                # we swap x and y-coordinate because we read them "incorrect"
                is_hit(pos_x, pos_y, ene_x-pos_x, ene_y-pos_y, cur_y, cur_x) # check for hit in x-direction
                + # effective 'or'
                is_hit(pos_y, pos_x, ene_y-pos_y, ene_x-pos_x, cur_x, cur_y) # check for hit in y-direction
                    for cur_y in grid_range # loop y
                for cur_x in grid_range)) # loop x

मुझे लगता है कि यह खामियों से भरा है। Btw मैं घोंसले के शिकार पर बचाया (पहला स्तर एक अंतरिक्ष, दूसरा एक टैब, फिर एक टैब और एक स्थान है ...)। मुझे उम्मीद है कि इस जवाब के बाद यह करने के तरीके की ओर इशारा कर सकता है।

Comments

मुझे बस एहसास हुआ कि नमूना इनपुट अमान्य था क्योंकि दुश्मनों में से एक सीधे जमीन पर स्थित था, जो तकनीकी रूप से एक शून्य ऊंचाई की इमारत का शीर्ष है, जो मैंने वादा किया था कि ऐसा नहीं होगा। आपका सबमिशन सही किए गए टेस्ट केस को पास करता है, लेकिन यह इसे विफल कर देता है - ideone.com/8qn3sv । क्या आप मेरे परीक्षण के मामले की जांच कर सकते हैं? मुझे कुछ याद आ रहा है या शायद मेरी समन्वय प्रणाली अस्पष्ट है।

— बारिश

नहीं, यह सिर्फ इतना है कि वेक्टर कोनों के माध्यम से सही जा रहा है ... अब मुझे पता है कि आपने 6 और 7 :) का वादा क्यों किया था

— WorldSEnder

btw, मैं एक नकारात्मक फ्लोट का उत्पादन करता हूं, लेकिन इसे 2 अतिरिक्त वर्णों के print 1-2*...बजाय तय किया जा सकता है ( print.5-...इसलिए) यह इतना बड़ा अंतर नहीं है जो मुझे लगता है

— WorldSEnder

आपने मेरे साथ आए कुछ टेस्ट पास किए। अच्छी नौकरी! आपको अभी भी आगे जाना चाहिए और इसे युक्ति के अनुरूप रखने के लिए पूर्णांक प्रिंट करना चाहिए।

— रात 14:07 बजे बारिश

किसी बेहतर समाधान के साथ आने तक अपना जवाब स्वीकार करें। मुझे नहीं लगता कि वे करेंगे। बहुत मुश्किल से ही किसी ने पुरानी हल की गई चुनौतियों को फिर से देखा है। आपको अधिक गोल्फ करना चाहिए! ऐसा लगता है कि आप अपना सामान जानते हैं। :)

— बारिश

Answer 3

सी - 2468

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{
    float x;
    float y;
    float z;
} vec3;

float
dot(vec3 a, vec3 b)
{
    return a.x * b.x + a.y * b.y + a.z * b.z;
}

vec3
scale(float s, vec3 a)
{
    vec3 r;
    r.x = s * a.x;
    r.y = s * a.y;
    r.z = s * a.z;
    return r;
}

vec3
add(vec3 a, vec3 b)
{
    vec3 r;
    r.x = a.x + b.x;
    r.y = a.y + b.y;
    r.z = a.z + b.z;
    return r;
}

int
intersect(vec3 a, vec3 b, vec3 *normals, vec3 *points, int nnormals)
{
    vec3 ab = add(b, scale(-1, a));
    float tfirst = 0;
    float tlast = 1;
    int i;
    for(i = 0; i < nnormals; i++)
    {
        float d = dot(normals[i], points[i]);
        float denom = dot(normals[i], ab);
        float dist = d - dot(normals[i], a);
        float t = dist / denom;
        if(denom > 0 && t > tfirst)
        {
            tfirst = t;
        }
        else if(denom < 0 && t < tlast)
        {
            tlast = t;
        }
    }
    return tfirst < tlast ? 1 : 0;
}

const vec3 N = {0,-1,0};
const vec3 S = {0,1,0};
const vec3 W = {-1,0,0};
const vec3 E = {1,0,0};
const vec3 D = {0,0,-1};

int
main(void)
{
    vec3 normals[5];
    vec3 player;
    vec3 *targets;
    int i;
    int j;
    vec3 *buildings;
    vec3 *b;
    int nbuildings = 0;
    int n;
    int m;
    char line[300];
    normals[0] = N;
    normals[1] = S;
    normals[2] = W;
    normals[3] = E;
    normals[4] = D;
    fgets(line, 300, stdin);
    n = atoi(line);
    /*5 sides for each building*/
    buildings = calloc(n * n * 5, sizeof(*buildings));
    b = buildings;
    for(i = 0; i < n; i++)
    {
        char *z;
        fgets(line, 300, stdin);
        for(j = 0; j < n && (z = strtok(j ? NULL : line, " \n")) != NULL; j++)
        {
            vec3 bottom;
            vec3 top;
            if(z[0] == '0') continue;
            nbuildings++;
            bottom.x = j;
            bottom.y = i;
            bottom.z = 0;
            top.x = j + 1;
            top.y = i + 1;
            top.z = atoi(z);
            b[0] = top;
            b[1] = bottom;
            b[2] = top;
            b[3] = bottom;
            b[4] = top;
            b += 5;
        }
    }
    fgets(line, 300, stdin);
    player.x = atof(strtok(line, " "));
    player.y = atof(strtok(NULL, " "));
    player.z = atof(strtok(NULL, " \n"));
    fgets(line, 300, stdin);
    m = atoi(line);
    targets = calloc(m, sizeof(*targets));
    for(i = 0; i < m; i++)
    {
        int hit = 1;
        fgets(line, 300, stdin);
        targets[i].x = atof(strtok(line, " "));
        targets[i].y = atof(strtok(NULL, " "));
        targets[i].z = atof(strtok(NULL, " \n"));
        for(j = 0; j < nbuildings; j++)
        {
            b = &buildings[j * 5];
            if(intersect(player, targets[i], normals, b, 5) == 1)
            {
                hit = 0;
                break;
            }
        }
        printf("%d\n", hit ? 1 : -1);
    }
    free(buildings);
    free(targets);
    return 0;
}

Comments

कुछ परीक्षण मामलों की कोशिश की और आप उन सभी को पारित कर दिया। यहाँ वह विचारधारा है जिसे कोई और सत्यापित करने के लिए उपयोग कर सकता है - ideone.com/MTXpzF

— Rainbolt