दरवाजे दरवाजे, दरवाजे की दुकान के नीचे चलो!

Question

चुनौती दुगनी है:

एक कार्यक्रम बनाएं जो एक दरवाजा बनाता है। ASCII, HTML या अन्यथा

द्वार को क्रियाशील बनाएं। खुलता और बंद होता है

इनपुट या इंटरैक्शन के माध्यम से या तो खुले-सक्षम!

• गैर-कार्यात्मक द्वार +5 अंक।
• बस एक खुला-सक्षम दरवाजा +10 अंक।
• इंटरएक्टिव दरवाजा +15 अंक।
• फैंसी दरवाजा +20 अंक। इसका मतलब होता है घूमना, बाइफोल्ड आदि
• एनिमेटेड +20 अंक।
• <100 अक्षर +50 अंक।
• विशेष रूप से ड्राइंग या एनीमेशन के लिए डिज़ाइन किए गए प्रोग्राम का उपयोग करने के लिए -100 अंक।

यदि आपके पास मानदंड सुझाव हैं तो उन्हें टिप्पणियों में छोड़ दें।

गैर-कार्यात्मक खुला दरवाजा उदाहरण:

<?php
$idiots_in_room=true;

if($idiots_in_room)
{

$count=20;
$count2=7;
for($i=0;$i<$count;$i++)
{

if($i==0)
{
echo str_repeat("-",10);
if($i==0){echo ".";}
echo "\n";
}
elseif($i==9)
{
echo str_repeat("-",10);
echo str_repeat(" ",7)."o"."|";
echo "\n";
}
elseif($i<=9)
{

echo str_repeat("-",1).str_repeat(" ",8).str_repeat("-",1);

echo ($i<5) ? str_repeat(" ",$i*2)."\\" : str_repeat(" ",8)."|";
echo "\n";
}
elseif($i<=14)
{
if($i>9){echo str_repeat(" ",$i)."\\";}
echo str_repeat(" ",$count2--)."|";
echo "\n";
}

}
}

उदाहरण आउटपुट:

----------.
-        -  \
-        -    \
-        -      \
-        -        \
-        -        |
-        -        |
-        -        |
-        -        |
----------       o|
          \       |
           \      |
            \     |
             \    |
              \   |

Comments

क्या आपके पास कोई उदाहरण है?

— beary605

@ beary605 गैर-कार्यात्मक उदाहरण प्रदान किया गया

— Event_Horizon

एक "दरवाजा" परिभाषित

— जोएल कॉर्नेट

दरवाजों के लिए ASCII कोड (या छवियों) के लिए बाहरी फ़ाइलों का उपयोग करने के बारे में क्या? उनकी गिनती कैसे होती है?

— जाजपी

Answer 1

जावास्क्रिप्ट, 4380 वर्ण, 65 (?) अंक

ASCII? चेक। एचटीएमएल? चेक। एक दरवाजा है? चेक। खुला दरवाजा? चेक। इंटरएक्टिव? चेक। फैंसी? ठीक से तैनात टिका के साथ डबल दरवाजे, मुझे आशा है कि मायने रखता है। एनिमेटेड? चेक। 100 पात्रों के तहत? हा। ड्राइंग के लिए इच्छित सुविधाओं का उपयोग नहीं कर रहे हैं? चेक।

लाइव डेमो। (नोट: फ़ायरफ़ॉक्स के साथ मेरे परीक्षण में, एक से अधिक बार दरवाज़े पर क्लिक करने से काम नहीं होता है - किसी कारणवश इवेंट हैंडलर फिर से आग नहीं लगाता है और मैं ऐसा करने के लिए परेशान हूं, जो मैंने गलत किया, उसका स्वागत करना। हालाँकि, आप इसे अच्छे जेएस प्रदर्शन के लिए क्रोम में चलाना चाहते हैं।]

<title>Door</title>
<pre onmouseup="turn();" style="display: table; margin: auto; font-family: 'Monaco', monospace; font-size: 0.6em; line-height: 0.7em;">
</pre>
<p>Click doors to open or close.</p>
<script>

  // Appearance of hit surface - global used to avoid allocating a record to return
  var mat;

  // Scene construction tools
  function box(size,ms) {
    return function (x, y, z) {
      var vdist0 = Math.abs(x) - size[0];
      var vdist1 = Math.abs(y) - size[1];
      var vdist2 = Math.abs(z) - size[2];
      mat = vdist0 > vdist1 && vdist0 > vdist2 ? ms[0] :
            vdist1 > vdist0 && vdist1 > vdist2 ? ms[1] :
            ms[2];
      return Math.max(vdist0, vdist1, vdist2);
    };
  }
  function translate(vec, obj) {
    var dx = vec[0];
    var dy = vec[1];
    var dz = vec[2];
    return function (x, y, z) { return obj(x - dx, y - dy, z - dz); };
  }
  function mirror(obj) {
    return function (x, y, z) { return obj(-x, y, z); };
  }
  function spin(obj) {
    return function (x, y, z) {
      var a = Date.now() / 1000;
      var s = Math.sin(a);
      var c = Math.cos(a);
      return obj(
        x * c + z * s,
        y,
        x * -s + z * c
      );
    };
  }
  function doorturn(obj) {
    return function (x, y, z) {
      var a = pos;
      var s = Math.sin(a);
      var c = Math.cos(a);
      return obj(
        x * c + z * s,
        y,
        x * -s + z * c
      );
    };
  }
  function rotx(a, obj) {
    return function (x, y, z) {
      var s = Math.sin(a);
      var c = Math.cos(a);
      return obj(
        x,
        y * c + z * s,
        y * -s + z * c
      );
    };
  }
  function roty(a, obj) {
    return function (x, y, z) {
      var s = Math.sin(a);
      var c = Math.cos(a);
      return obj(
        x * c + z * s,
        y,
        x * -s + z * c
      );
    };
  }
  function union(as, bs) {
    return function (x, y, z) {
      var a = as(x, y, z); var am = mat;
      var b = bs(x, y, z);
      if (a < b) {
        mat = am;
        return a;
      } else {
        return b;
      }
    };
  }

  // Display parameters
  var vw = 80, vh = 80;
  var timestep = 1/30;

  // Scene
  var wallhwidth = 30;
  var wallhheight = 35;
  var wallmat = [";", "\u2014", ":"];
  var dhwidth = 10;
  var dhheight = 20;
  var hthick = 2;
  var door = translate([-dhwidth*2, 0, 0], doorturn(translate([hthick, 0, dhwidth], box([hthick, dhheight, dhwidth], [".", "\u2014", "|"]))));
  var doors = union(door, mirror(door));
  var wall = union(
    union(
      translate([dhwidth*2+wallhwidth, 0, -hthick], box([wallhwidth, wallhheight, hthick], wallmat)),
      translate([-dhwidth*2-wallhwidth, 0, -hthick], box([wallhwidth, wallhheight, hthick], wallmat))),
    translate([0, wallhheight-(wallhheight-dhheight)/2, -hthick], box([dhwidth*2, (wallhheight-dhheight)/2, hthick], wallmat)));
  var floor = translate([0, -dhheight - 1.1, 0], box([100, 1, 100], ["/","/","/"]));
  var sill = translate([0, -dhheight - 1, -hthick], box([dhwidth*2, 1, hthick], ["\\","%","\\"]));
  var sbox = translate([0, 0, -12], spin(box([8, 8, 8], ["x", "y", "z"])))
  var scene = union(sbox, union(union(wall, doors), union(floor, sill)));
  var view = translate([vw/2, vh/2, -100], rotx(0.2, roty(-0.6, scene)));

  // Animation state
  var pos = -Math.PI/2;
  var dpos = 0;
  var interval;

  // Main loop function
  function r() {
    // Update state
    pos += dpos * timestep;
    if (Math.abs(pos) >= Math.PI/2) {
      dpos = 0;
      pos = Math.PI/2 * pos / Math.abs(pos);
      if (pos < 0) { // no animation needed
        clearInterval(interval); interval = undefined;
      }
    }

    // Render scene
    var t = [];
    for (var y = vh - 1; y >= 0; y--) {
      for (var x = 0; x < vw; x++) {
        var z = 0, distance;
        while ((distance = view(x,y,z)) > 0.12) {
          z -= distance;
          if (!isFinite(z) || z < -1000) {
            mat = " ";
            break;
          }
        }
        t.push(mat);
      }
      t.push("\n");
    }
    document.getElementsByTagName("pre")[0].textContent = t.join("");
  }

  // Click handler
  function turn() {
    if (dpos !== 0) {
      dpos *= -1;
    } else {
      dpos = (pos < 0 ? 1 : -1) * 2.3;
    }
    if (!interval) {
      interval = setInterval(r, timestep*1000);
    }
  }

  // Render initial state
  r();
</script>

बंद होने पर, दरवाजे इस तरह दिखते हैं:

Comments

होगा, वहाँ कुछ सुंदर काम thats।

— Event_Horizon

यह बहुत अच्छा है।

— मेज़ैंडर

Answer 2

HTML और CSS3, 55 अंक

फैंसी, इंटरैक्टिव, एनिमेटेड दरवाजा 55 अंक है, मुझे लगता है।

हां, यह किसी भी अन्य दरवाजे की तरह खुलता है, लेकिन अगर स्लाइडिंग दरवाजा फैंसी के रूप में गिना जाता है, तो यह एक घूर्णन क्यों नहीं करता है? यदि एक घूर्णन एक फैंसी नहीं है, ठीक है, एक स्लाइडिंग दरवाजा कोई समस्या नहीं है:)

एक डेमो http://result.dabblet.com/gist/3132160/ac475112dbba493d2dd7d98493d4f4ceaa209a7c पर उपलब्ध है । खोलने और बंद करने के लिए डॉर्कनब पर क्लिक करें। कोई जावास्क्रिप्ट शामिल नहीं; यह CSS3 का जादू मात्र है।

#wall {
    background-color: #eee;
    bottom: 0;
    left: 0;
    position: absolute;
    right: 0;
    top: 0;
    transform: rotateX(-10deg);
    transform-origin: 0 100%;
    transform-style: preserve-3d;
}

#door-container {
    background-color: black;
    height: 100%;
    margin: 0 auto;
    width: 300px;
}

#door {
    background-color: brown;
    height: 100%;
    margin: auto;
    position: relative;
    transform-origin: 0 0;
    transition: transform 0.5s ease;
    width: 300px;
}

#door .knob {
    background-color: gold;
    border-radius: 10px;
    height: 20px;
    margin-top: -10px;
    position: absolute;
    right: 10px;
    top: 50%;
    width: 20px;
}

#open:target + #wall #door {
    transform: rotateY(-145deg);
}

#open:target + #wall #open-link {
    display: none;
}

#close-link {
    display: none;
}

#open:target + #wall #close-link {
    display: inline;
}

<span id="open"></span>
<div id="wall">
    <div id="door-container">
        <div id="door">
            <a href="#open" id="open-link" class="knob"></a>
            <a href="#closed" id="close-link" class="knob"></a>
        </div>
    </div>
</div>

Comments

स्लाइडिंग से मेरा मतलब मूल रूप से एक आंगन के लिए "स्लाइडिंग ग्लास दरवाजा" था, लेकिन मैं देख सकता था कि इसे फैंसी कैसे माना जाएगा (विशेषकर कोडिंग शब्दों में, एक घूर्णन की तुलना में बहुत आसान)। इसके अलावा, घूमते हुए दरवाजे से मेरा मतलब रिवॉल्विंग से था। सही कर देंगे।

— Event_Horizon

Answer 3

गणितज्ञ 271 वर्ण

Manipulate[a = {0, 0, 0}; b = {0, 0, h}; p = Polygon; c = Cuboid; t = Rotate;Graphics3D[{c@{{-w - 1, 0, 0}, {-w, 1, h}}, c@{{w + 1, 0, 0}, {w, 1, h}},t[p@{a, b, {-w, 0, h}, {-w, 0, 0}}, r, {0, 0, 1}, {- 2 w/3, -w/3, 0}], t[p@{a, b, {w, 0, h}, {w, 0, 0}}, -r, {0, 0, 1}, { 2 w/3, -w/3, 0}]}],{{r, 0}, 0, 3/2}, {{w, 2}, 1, 3}, {{h, 4}, 3, 5}]

डबल दरवाजे

• शून्य से 90 डिग्री तक रोटेशन द्वारा खुला (स्लाइडर का उपयोग करके r)
• स्लाइडर्स ( hऔर w) द्वारा निर्धारित उनकी ऊंचाई और चौड़ाई हो सकती है ।
• एक 3D प्रकाश वातावरण में हैं
• अंतःक्रियात्मक रूप से विभिन्न कोणों से देखे जाने के लिए घुमाया जा सकता है।

---

कोड Sándor Kabal के एक कार्यक्रम पर आधारित है ।

Answer 4

पायथन - 65 अंक, 86 वर्ण

इंटरएक्टिव और 100 से कम वर्ण।

इनपुट की प्रतीक्षा करता है और आपको दरवाजा दिखाता है । वैध इनपुट "ओपन" और "क्लोज" और "बाय" है।

g,s=1,'open close'
while g:
 i=raw_input()
 print '_'+'/_ '[s.find(i)/5]+'_'
 g=i in s

Comments

आप शायद इसे टाइपिंग कमांड्स के बिना खुले / करीब टॉगल करने के लिए सेट कर सकते हैं और अभी भी आवश्यकताओं को पूरा कर सकते हैं - यह आपको कुछ वर्णों को बचाएगा।

— जोएल कॉर्नेट

शायद, लेकिन फिर से, यह कोड-गोल्फ नहीं है, इसलिए यह वास्तव में कोई फर्क नहीं पड़ता;)

— डैनिएरो

सुंदर उबाऊ दिखने वाला दरवाजा, लेकिन एक शानदार दिखने वाला

— मूसट्रैप

Answer 5

गणितज्ञ 127 वर्ण

यह मेरे द्वारा पहले प्रस्तुत एक से अधिक सुव्यवस्थित कार्यान्वयन है। इसका एक ही दरवाजा है। सिंगल डोर

• शून्य से 90 डिग्री तक घुमाव द्वारा खुलता है (स्लाइडर का उपयोग करके o)
• एक 3D प्रकाश वातावरण में है
• अंतःक्रियात्मक रूप से विभिन्न कोणों से देखे जाने के लिए घुमाया जा सकता है।

हालांकि, यह एक निश्चित दरवाजा ऊंचाई और चौड़ाई का उपयोग करता है।

Manipulate[a = {0, 0, 0}; Graphics3D[{Tube[{a, {1, 0, 0}, {1, 0, 2}, {0, 0, 2}, a}, .03],Rotate[Cuboid@{a, {1, -.1, 2}}, o, {0, 0, 1}, a]}], {o, 0, -Pi/2}]

Comments

आपको एक नया सबमिट करने के बजाय संभवतः अपना पिछला सबमिशन संपादित करना चाहिए।

— जो व्यक्ति

@ fireDude67 यदि यह एक कोड गोल्फ चुनौती होती, तो मैं अपनी पिछली प्रविष्टि को छोटे कोड के साथ बदल देता। हालांकि, एसओ ने छोटे कार्यक्रमों और अधिक जटिल कार्यक्रमों (अधिक सुविधाओं वाले दरवाजे) में रुचि दिखाई।

— डेविड जूल

ओह क्षमा करें, मैं तब उलझन में था

— जो व्यक्ति

@ fireDude67 कोई समस्या नहीं है।

— डेविड