छोटे घरेलू जानवरों पर प्रयोग के साथ , नोबेल पुरस्कार विजेता एरविन श्रोडिंगर ने निकटतम लेजर खोजने और इसके बजाय चीजों पर शूट करने का फैसला किया है। क्योंकि ... विज्ञान!

विवरण

आप दो अंक है कि लेजर के माध्यम से गुजरता है और एक लेजर बीम का आकार दिया जाएगा, और आप यह निर्धारित करना चाहिए जहां लेजर बीम चाहिए चले गए हैं, हो सकता है चले गए हैं, और नहीं कर सकता चले गए हैं।

लेजर बीम क्षैतिज, ऊर्ध्वाधर या विकर्ण हो सकता है। आकार 1 लेजर बीम के लिए, वे क्रमशः इस तरह दिखते हैं:

       #  #
       #   #
#####  #    #
       #     #
       #      #

विकर्ण लेजर बीम को भी फ़्लिप किया जा सकता है। आकार 2 लेजर बीम इस तरह दिखते हैं:

       ###  ##
#####  ###  ###
#####  ###   ###
#####  ###    ###
       ###     ##

सामान्य तौर पर, आकार की लेजर बीम (एन) प्राप्त करने के लिए, बस आकार के लेजर बीम (एन -1) को लें और दोनों पक्षों पर आकार के लेजर बीम (1) जोड़ें। अंतिम उदाहरण के रूप में, यहां आकार 3 के सभी संभावित लेजर बीम हैं, जिन्हें "बोर्ड" पर दिखाया गया है:

###.....#####.....##
####....#####....###
#####...#####...####
.#####..#####..#####
..#####.#####.#####.
...###############..
....#############...
.....###########....
####################
####################
####################
####################
####################
.....###########....
....#############...
...###############..
..#####.#####.#####.
.#####..#####..#####
#####...#####...####
####....#####....###

इस "बोर्ड" में हमेशा 20x20 (वर्णों में) के आयाम होंगे।

इनपुट

आपके प्रोग्राम को इनपुट के रूप में पाँच पूर्णांक दिए जाएंगे। वे क्रम में हैं, एक्स ₁ , वाई ₁ , एक्स ₂ , वाई ₂ , और लेजर बीम का आकार। उन्हें ठीक उसी क्रम में लिया जाना चाहिए। यदि आप चाहें, तो आप ऑर्डर (x, y) जोड़े को एक सरणी, टपल, सूची, या अन्य अंतर्निहित डेटा प्रकार के रूप में ले सकते हैं जो दो मूल्यों को संग्रहीत करता है।

इनपुट के रूप में दिए गए दोनों दो बिंदु बोर्ड के भीतर होंगे, और उन्हें अलग होने की गारंटी दी जाएगी (यानी दोनों बिंदु कभी भी समान नहीं होंगे)। लेजर बीम का आकार बाध्य है 1 ≤ size < 20। हमेशा कम से कम एक संभव लेजर बीम होगा जो दोनों बिंदुओं से गुजरता है।

उत्पादन

आपके प्रोग्राम को निम्न वर्णों का 20x20 ग्रिड आउटपुट करना चाहिए:

# अगर हर संभव लेजर बीम जो दो बिंदुओं से गुजरती है, इस बिंदु से भी गुजरती है।
. अगर कोई लेज़र बीम नहीं है जो दो बिंदुओं और इस बिंदु से गुजरता है।
? यदि कुछ है, लेकिन सभी नहीं, संभव लेजर बीम इस बिंदु से गुजरते हैं।
Xयदि यह दो मूल इनपुट बिंदुओं में से एक है (यह ओवरराइड करता है #)।

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

7, 7, 11, 3, 1

..............#.....
.............#......
............#.......
...........X........
..........#.........
.........#..........
........#...........
.......X............
......#.............
.....#..............
....#...............
...#................
..#.................
.#..................
#...................
....................
....................
....................
....................
....................

18, 18, 1, 1, 2

#??.................
?X??................
??#??...............
.??#??..............
..??#??.............
...??#??............
....??#??...........
.....??#??..........
......??#??.........
.......??#??........
........??#??.......
.........??#??......
..........??#??.....
...........??#??....
............??#??...
.............??#??..
..............??#??.
...............??#??
................??X?
.................??#

10, 10, 11, 10, 3

?????..????????..???
??????.????????.????
????????????????????
????????????????????
.???????????????????
..??????????????????
????????????????????
????????????????????
????????????????????
????????????????????
??????????XX????????
????????????????????
????????????????????
????????????????????
????????????????????
..??????????????????
.???????????????????
????????????????????
????????????????????
??????.????????.????

3, 3, 8, 10, 4

??????????..........
??????????..........
??????????..........
???X??????..........
???##?????..........
???###????..........
????###????.........
.????###????........
..????###????.......
..?????##?????......
..??????X??????.....
..??????????????....
..???????????????...
..????????????????..
..?????????????????.
..??????????????????
..??????????????????
..????????.?????????
..????????..????????
..????????...???????

परीक्षण के मामले ऊर्ध्वाधर अंतरिक्ष के संरक्षण के लिए स्टैक स्निपेट के अंदर स्थित रूबी लिपि के साथ उत्पन्न हुए थे।

कोड स्निपेट दिखाएं

/*

#!/usr/bin/ruby

$w = $h = 20

class Point
    attr_reader :x, :y
    def initialize x, y
        @x = x
        @y = y
    end
    def inspect
        "(#{@x}, #{@y})"
    end
    def == p
        @x == p.x && @y == p.y
    end
    alias eql? ==
    def hash
        @x * $h + @y
    end
    def valid?
        @x >= 0 && @y >= 0 && @x < $w && @y < $h
    end
end

module Angle
    HORIZONTAL = Point.new(1, 0)
    VERTICAL = Point.new(0, 1)
    DIAG1 = Point.new(1, 1)
    DIAG2 = Point.new(1, -1)
end

def line_points point, angle, size
    points = [point]

    while points[-1].valid?
        points.push Point.new(points[-1].x + angle.x, points[-1].y + angle.y)
    end
    points.pop
    while points[0].valid?
        points.unshift Point.new(points[0].x - angle.x, points[0].y - angle.y)
    end
    points.shift

    if size == 1
        points
    elsif size > 1
        a2 = case angle
            when Angle::HORIZONTAL then Angle::VERTICAL
            when Angle::VERTICAL then Angle::HORIZONTAL
            else Angle::VERTICAL  # HORIZONTAL also works
        end
        (size-1).times do |n|
            np1 = Point.new(point.x + a2.x*(n+1), point.y + a2.y*(n+1))
            np2 = Point.new(point.x - a2.x*(n+1), point.y - a2.y*(n+1))
            points.concat line_points np1, angle, 1 if np1.valid?
            points.concat line_points np2, angle, 1 if np2.valid?
        end
        points
    else
        throw 'something is very wrong'
    end
end

def generate_grid x1, y1, x2, y2, size
    p1 = Point.new(x1, y1)
    p2 = Point.new(x2, y2)
    lasers = []
    points = [Point.new((p1.x + p2.x) / 2, (p1.y + p2.y) / 2)]  # midpoint
    while points.length > 0
        point = points.pop
        new_lasers = Angle.constants
            .map{|angle| line_points point, Angle.const_get(angle), size }
            .select {|laser| laser.include?(p1) && laser.include?(p2) } -
            lasers
        if new_lasers.length > 0
            lasers.concat new_lasers
            points.push Point.new(point.x+1, point.y) if point.x+1 < $w
            points.push Point.new(point.x, point.y+1) if point.y+1 < $h
            points.push Point.new(point.x-1, point.y) if point.x-1 > 0
            points.push Point.new(point.x, point.y-1) if point.y-1 > 0
        end
    end
    grid = Array.new($h) { ?. * $w }
    lasers.each do |laser|
        laser.each do |point|
            grid[point.y][point.x] = ??
        end
    end
    lasers.reduce(:&).each do |point|
        grid[point.y][point.x] = ?#
    end
    grid[p1.y][p1.x] = 'X'
    grid[p2.y][p2.x] = 'X'
    grid
end

testcases = [
    [7, 7, 11, 3, 1],
    [18, 18, 1, 1, 2],
    [10, 10, 11, 10, 3],
    [3, 3, 8, 10, 4]
]

testcases.each do |test|
    puts test * ', '
    puts
    puts generate_grid(*test).map{|line| '    ' + line }
    puts
end

*/

स्निपेट का विस्तार करें

नियम

आपका कार्यक्रम 30 सेकंड (उचित मशीन पर) के तहत परीक्षण के प्रत्येक मामले को हल करने में सक्षम होना चाहिए। यह एक पवित्रता जांच से अधिक है, क्योंकि मेरे परीक्षण रूबी कार्यक्रम ने परीक्षण के सभी मामलों को तत्काल पास से हल किया।
यह कोड-गोल्फ है , इसलिए सबसे छोटा समाधान जीतता है।

code-golf

— Doorknob
स्रोत

यहां इस्तेमाल होने वाली शब्दावली ने मुझे शुरू में ही उलझा दिया। मेरा मानना है कि लेजर आमतौर पर एक उपकरण को संदर्भित करता है जो लेजर बीम का उत्पादन करता है । क्या आप यहाँ का प्रतिनिधित्व कर रहे हैं वास्तव में मुस्कराते हुए, सही हैं? यह वास्तविक लेजर का प्रतिनिधित्व नहीं माना जाता है, जो कि मुस्कराते हुए उपकरण होगा?

— रेटो कोराडी

अंतिम परीक्षा का मामला गलत लगता है। आकार 4 लेज़र 9 पिक्सेल चौड़ा होना चाहिए। ऊर्ध्वाधर ट्रैक कम से कम चौड़ा होना चाहिए, लेकिन वास्तव में संकीर्ण है।

— लेवल रिवर सेंट

@steveverrill साइज़ 4 7 पिक्सल चौड़ा है। पिक्सेल में चौड़ाई है 2 * size - 1। आकार 1 1 पिक्सेल है, आकार 2 3 पिक्सेल है, आकार 3 5 पिक्सेल है (ऊपर उदाहरण देखें), आकार 4 7 पिक्सेल है।

— रेटो कोराडी

मैं नहीं देखता कि श्रोडिंगर इस चुनौती से कैसे संबंधित है।

— user12205

@JonasDralle फिर से, समय सीमा ज्यादातर सिर्फ एक पवित्रता जांच है, और लगभग हर प्रस्तुत करने की अपेक्षा उससे कम समय में पूरा होने की उम्मीद है।

— दरवाज़े

सी, 291 280 277 265 बाइट्स

x,y,A,C,B,D,a,c,b,d,w,s,t;T(i){return abs(i)<2*w-1;}U(j,k){s+=T(j-k)*T(j)*T(k);t*=T(j-k)*j*k<1;}main(){for(scanf("%i%i%i%i%i",&a,&b,&c,&d,&w);y<20;y+=!x)s=0,t=1,U(A=a-x,C=c-x),U(B=b-y,D=d-y),U(A-B,C-D),U(A+B,C+D),putchar((x=++x%21)?".?#x"[!!s+t+(!A*!B+!C*!D)]:10);}

उपयोग करके संकलित / चलाया जा सकता है:

gcc laser.c -o laser && इको "10 10 11 10 3" | ./laser

नीचे, व्हॉट्सएप और व्याख्यात्मक टिप्पणियों के साथ समान कोड:

// Integers...
x,y,A,C,B,D,a,c,b,d,w,s,t;

// Is true if i is in range (of something)
T(i){return abs(i)<2*w-1;}

// Tests if lasers (horizontal, vertical, diagonal, etc) can/must exist at this point
// T(j-k) == 0 iff the laser of this direction can exist
// s += 1 iff this laser direction can pass through this point
// t *= 1 iff this laser direction must pass through this point
U(j,k){
    s+=T(j-k)*T(j)*T(k);
    t*=T(j-k)*j*k<1;
}

main(){ 
    // Read input; p0=(a,b), p1=(c,d)
    for(scanf("%i%i%i%i%i",&a,&b,&c,&d,&w); y<20; y+=!x)

        // A, B, C and D represent delta-x and delta-y for each points
        // e.g.: if we're processing (2,3), and p0=(4,5), A=4-2, B=5-3
        // s != 0 iff (x,y) can have some laser through it
        // t == 1 iff all lasers pass through (x,y)
        // (!A*!B+!C*!D) == 1 iff (x,y) is either p0 or p1  
        s=0,t=1,U(A=a-x,C=c-x),U(B=b-y,D=d-y),U(A-B,C-D),U(A+B,C+D),
        putchar((x=++x%21)?".?#x"[!!s+t+(!A*!B+!C*!D)]:10);
}

— आंद्रे हार्डर
स्रोत

U(int j,int k)-> U(j,k); '\n'-> 10।

— user12205

k<=0->k<1

— user12205

अच्छे अंक। अगर मैं कर सकता मैं upvote!

— एंड्रे हार्डर

सी, 302 बाइट्स

b[400],x,y,s,t,w,d,e,g,k;f(u,v){d=u*x+v*y;e=u*s+v*t;if(e<d)k=e,e=d,d=k;for(k=0;k<400&d+w>e;++k)g=k%20*u+k/20*v,b[k]|=g>e-w&g<d+w|(g<d|g>e)*2;}main(){scanf("%d%d%d%d%d",&x,&y,&s,&t,&w);w=2*w-1;f(1,0);f(0,1);f(1,1);f(1,-1);b[y*20+x]=4;b[t*20+s]=4;for(k=0;k<400;)putchar(".#.?X"[b[k]]),++k%20?0:puts("");}

इनपुट को स्टैडिन से लिया गया है, परिभाषित क्रम में 5 नंबर पढ़ रहा है।

अंतिम आकार में कमी के कदम से पहले:

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

int b[400], x, y, s, t, w, d, e, g, k;

void f(int u, int v) {
  d = u * x + v * y;
  e = u * s + v * t;
  if (e < d) k = e, e = d, d = k;
  if (d + w > e) {
    for (k = 0; k < 400; ++k) {
      g = u * (k % 20) + v * (k / 20);
      if (g > e - w && g < d + w) b[k] |= 1;
      if (g < d || g > e) b[k] |= 2;
    }
  }
}

int main() {
  scanf("%d%d%d%d%d", &x, &y, &s, &t, &w);
  w = 2 * w - 1;
  f(1, 0); f(0, 1); f(1, 1); f(1, -1);
  b[y * 20 + x] = 4;
  b[t * 20 + s] = 4;
  for (k = 0; k < 400; ) {
     putchar(".#.?X"[b[k]]);
     ++k % 20 ? 0 : puts("");
  }
}

प्रमुख चरणों की कुछ व्याख्या:

Array bराज्य / परिणाम रखता है। बिट 0 को उन सभी पिक्सल्स के लिए सेट किया जाएगा जिन्हें एक बीम द्वारा पहुँचा जा सकता है। बिट 1 उन सभी पिक्सेल के लिए सेट किया जाएगा जो सभी बीम से कवर नहीं हैं ।
फ़ंक्शन fको सभी 4 दिशाओं (ऊर्ध्वाधर, क्षैतिज, दोनों विकर्ण) के लिए कहा जाता है। इसके तर्क दिशा के सामान्य वेक्टर को निर्दिष्ट करते हैं।
समारोह में f:
- दिशा के सापेक्ष दोनों इनपुट बिंदुओं की दूरी की गणना ( dऔर e) सामान्य वेक्टर के साथ बिंदु के डॉट उत्पाद के रूप में की जाती है।
- यदि आवश्यक हो तो दूरी की अदला-बदली की जाती है ताकि dहमेशा उससे कम या बराबर हो e।
- यदि बीम की चौड़ाई के बीच का अंतर dऔर eबड़ा है, तो इस दिशा में कोई भी बीम संभव नहीं है।
- अन्यथा, सभी पिक्सेल पर लूप। बिट 0 सेट करें यदि पिक्सेल किसी भी बीम द्वारा पहुंच योग्य है, और बिट 1 यदि यह सभी बीम से कवर नहीं है।
मान के साथ दो इनपुट बिंदुओं को चिह्नित करें 4. चूंकि हमने राज्य को ट्रैक करने के लिए बिट्स 0 और 1 का उपयोग किया था, जिसके परिणामस्वरूप मान 0 से 3 है, यह सबसे छोटा अप्रयुक्त मूल्य है।
पिक्सल पर लूप करें b, और मानों को उनके प्रिंट करने के दौरान रेंज 0 से 4 में उनके संबंधित वर्ण में परिवर्तित करें।

— रेटो कोराडी
स्रोत

आप उस forलूप में इन्क्रीमेंटर में कोड की आखिरी लाइन डालकर थोड़ा बचा सकते हैं

— ऐसा नहीं कि चार्ल्स

श्रोडिंगर की लेजर

विवरण

इनपुट

उत्पादन

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

नियम

सी, 291 280 277 265 बाइट्स

सी, 302 बाइट्स