22

आपका पक्षी कुछ व्यायाम के लिए खुजली कर रहा है और हर समय स्थिर स्थितियों में फंसने से बीमार है। एक कार्यक्रम लिखें जो नृत्य चाल के आधार पर प्रत्येक 100ms * n या 200ms * n को अपडेट करते हुए एक बेतरतीब ढंग से नाचने वाली अस्सी पक्षी को दिखाएगा। पक्षी हमेशा नृत्य चाल से शुरू होता है <(")>।

कार्यक्रम को एक इनपुट को स्वीकार करना चाहिए जो नींद अंतराल को ( n >= 0 && n <= 50) से गुणा करने के लिए एक नंबर है ।

100ms चाल

^(")v
v(")^
^(")^
v(")v

200ms चाल

(>")>
<(")>
<("<)

अतिरिक्त विवरण

रैंडमनेस में एकरूपता नहीं है, लेकिन प्रत्येक डांस मूव को रोके जाने का एक उचित मौका होना चाहिए (कम से कम 1 60 में उचित लगता है, यह ठीक है अगर एक ही चाल एक पंक्ति में दो बार होती है)
एक समय में केवल एक ही पक्षी प्रदर्शित होना चाहिए, न कि एक से अधिक पक्षी
अनुगामी व्हाट्सएप की अनुमति है (लेकिन अन्य अनुगामी पात्र नहीं हैं)
सोने से पहले एक पक्षी को प्रदर्शित किया जाना चाहिए

उदाहरण पायथन 3 में

import random, time, sys

birds = """(>")>
<(")>
<("<)
^(")v
v(")^
^(")^
v(")v"""
birds = birds.split()

interval = int(input("Sleep for 100ms*"))
selection = -1

while True:
    if selection == -1:
        selection = 1
    else:
        selection = random.randint(0, len(birds)-1)
    sys.stdout.write('\r'+birds[selection])
    if selection > 2:
        time.sleep(0.1*interval)
    else:
        time.sleep(0.2*interval)

जीतना

यह कोड-गोल्फ इतना कम से कम बाइट्स जीतता है!

— redstarcoder
स्रोत

क्या पक्षी की आँखें एक दोहरे उद्धरण या दो एकल उद्धरण हैं?

— पावेल

@ पावेल, डबल कोट

— redstarcoder

6

खैर, आज मैंने सीखा कि आपको अजगर में मल्टी लाइन स्ट्रिंग्स में उद्धरण चिह्नों से बचना नहीं है।

— पावेल

यदि मेरी भाषा आउटपुट को संशोधित नहीं कर सकती है, तो क्या मैं हर 100/200 एमएस में एक नया पक्षी पैदा कर सकता हूं?

— देवचर

1

Ideone का उपयोग करते हुए , Lua \rएस्केप ए की तरह कार्य करता है \n। न ही मैं os.execute("cls")वहां उपयोग कर सकता हूं । @redstarcoder

— devRicher

3

MATL , 53 बाइट्स

xXx`'./U;HbG#3@@!{uu'F'v^<>(")'Za7e 7YrY)D5M3>QG*&XxT

चाल समान रूप से यादृच्छिक हैं।

नीचे एक नमूना चलाया गया है n = 2। या इसे MATL ऑनलाइन पर आज़माएं! (दुभाषिया प्रयोगात्मक है। यदि यह शुरू में नहीं चलता है तो "रन" को फिर से दबाने या पृष्ठ को ताज़ा करने का प्रयास करें)।

व्याख्या

x                   % Take input n and delete it
Xx                  % Clear screen
`                   % Do...while
  './U;HbG#3@@!{uu' %   Push this (compressed) string
  F                 %   Specify source alphabet for decompression
  'v^<>(")'         %   Push target alphabet
  Za                %   Base conversion (decompress)
  7e                %   Reshape as a 7-row char matrix. Each row is a move
  7Yr               %   Push random integer from 1 to 7
  Y)                %   Select that row from the char matrix
  D                 %   Display it
  5M                %   Push the integer again
  3>                %   Does it exceed 3? Gives false (0) or true (1)
  Q                 %   Add 1
  G*                %   Multiply by n
  &Xx               %   Pause that many tenths of a second and clear screen
  T                 %   Push true
                    % End (implicit). Since top of the stack is true, this causes
                    % and infinite loop

— लुइस मेंडो
स्रोत

6

मतलाब, 125 117 बाइट्स

दुर्भाग्य से यह TIO में प्रदर्शित नहीं किया जा सकता है क्योंकि आउटपुट का कोई "स्ट्रीमिंग" नहीं है। 1इसके बदले इनपुट के लिए gif है :

t=input('')*.1;a='^(")vv(")^^(")^v(")v(>")><(")><("<)';while 1;n=randi(7);clc;disp(a(n*5-4:n*5));pause(t+t*(n>4));end

धन्यवाद @LuisMendo -8 बाइट्स के लिए!

— flawr
स्रोत

5

* * <> , 103 101 बाइट्स

<vD[3'(")'
1x<.5
S\:43_C43CdooI:o@:o@:o@Do
R!"^"x"v">
>:2* _"><"92.
x '>)">('u.02S*2:oooooodO<'<("<)'

यहाँ कोशिश करो! ( nप्रारंभिक स्टैक पर लिखें या आपको एक त्रुटि मिलेगी)

मैं अपनी चुनौती पर एक छुरा लेने का फैसला किया क्योंकि कोई उप 100 बाइट्स जवाब नहीं थे। nस्टैक पर जगह और दूर तुम जाओ! यह (")कुछ बाइट्स को बचाने के लिए वर्णों का पुन: उपयोग करता है ।

व्याख्या

initialisation

<vD[3'(")'

यहां हम (")बाद के उपयोग के लिए स्टोर करते हैं।

<           move the IP left
   [3'(")'  push '(")' to a new stack
  D         move back down to a clean stack
 v          move the IP down into "dance chooser"

नृत्य करने वाला

1x<.5
 \

यह अक्सर यह चुनने के लिए निष्पादित किया जाता है कि हम किस प्रकार का नृत्य उत्पन्न करने जा रहे हैं।

 x         generate a 100ms dance or a 200ms dance
1  .5      jump to "200ms dance"
 \         mirror IP into "100ms dance"

एक भी नहीं है vइसके बाद के संस्करण xऔर एक <भी इसके बारे में सही करने के लिए। xयदि यह IP को गलत दिशा में ले जाने का प्रयास करता है तो ये फिर से निष्पादित हो जाते हैं।

100ms नृत्य उत्पन्न करें

S\:1*43_C43CdooI:o@:o@:o@Do

यहां हम 100ms डांस मूव्स में से एक को जेनरेट और आउटपुट करते हैं।

 \                         mirror the IP right
  :                        copy n
   43 C43C                 call "generate '^' or 'v'" twice
     _                     ignored mirror
          do               output a carriage return
            o              output the first hand of the bird
             I:o@:o@:o@D   select, copy, and output '(")'
                        o  output the second hand of the bird
S                          sleep for previous n*100ms
 \                         mirror IP back to "dance chooser"

43C - "^" या "v" उत्पन्न करें

R!"^"x"v">

यह एक सरल कार्य है जो "^" या "v" उत्पन्न करता है, फिर लौटता है। यह डांस चॉसर के समान काम करता है, जहां यह xसुनिश्चित करने के लिए चारों ओर निर्देश है कि आईपी केवल बाएं या दाएं चलता है।

     x      generate "^" or "v"
R!"^"    >  push "^" to stack and return
R     "v"   push "v" to stack and return

200 मी डांस जनरेट करें

यह एक और है जो इसके साथ शुरू होता है x। इसे दो खंडों में विभाजित किया जाएगा: <(")>और दूसरा (>")> and <("<), क्योंकि वे दो अलग-अलग खंड हैं और xकेवल एक चीज है जो वे साझा करते हैं।

`<(")>`

>:2* _"><"b2.

यह मूल रूप से generate 100ms danceदिनचर्या की शुरुआत करता है, लेकिन ><एक यादृच्छिक ^vकॉम्बो के बजाय पक्षी के हाथों को आबाद करता है । यह nइस समय के साथ-साथ दो गुणा हो जाता है। यह generate 100ms danceपूरे पक्षी के उत्पादन के लिए दिनचर्या का उपयोग करने के लिए और इसके बजाय 200ms की प्रतीक्षा करने के लिए सभी सेटअप करता है ।

>              move IP right
 :2*           copy n and do n*2
     _         ignored mirror
      "><"     push "><" to stack
          b2.  jump to "output carriage return" in "generate 100ms dance"

`(>")>` तथा `<("<)`

x '>)">('u.02S*2:oooooodO<'<("<)'

यह थोड़ा स्पष्टीकरण (>")>और <("<)पीढ़ी के बारे में है , हालांकि इसके xबाहर आईपी भेज सकते हैं (नीचे समझाया गया है)।

x                                  move to "choose dance", generate (>")>, <("<), or <(")> (previous routine)  
  '>)">('                          push '(>")>' to the stack
                          '<("<)'  push '<("<)' to the stack
         u              O<         ensure inner code block is always executed with IP moving left
                      od           output carriage return
                 ooooo             output bird
             S*2:                  sleep for n*200ms
          .02                      jump to "dance chooser"

— redstarcoder
स्रोत

3

जावास्क्रिप्ट (ईएस 6) + एचटीएमएल 5: 118 116 + 8 = 124 बाइट्स

जावास्क्रिप्ट: 119 बाइट्स

f=n=>{a.innerHTML='(>")>0<(")>0<("<)0^(")v0v(")^0^(")^0v(")v'.split(0)[r=+new Date%7],setTimeout(f,(1+(r<3))*100*n,n)}

मैं एक यादृच्छिक-ईश संख्या उत्पन्न करने के लिए युग के बाद से मिलीसेकंड का उपयोग कर रहा हूं। सैद्धांतिक रूप से, यह हमेशा एक ही (सेट) नंबर की संख्या उत्पन्न करेगा, लेकिन मेरे पीसी पर एक परीक्षण ने मुझे एक बहुत यादृच्छिक परिणाम दिया (अधिकांश संख्याएं कम या ज्यादा समान रूप से दिखाई दीं)। इस तथ्य का उपयोग करते हुए कि एक आईडी वाले HTML तत्व जावास्क्रिप्ट में वैश्विक विंडो ऑब्जेक्ट में जुड़ जाते हैं, इसलिए document.getElementById()इसकी आवश्यकता नहीं है।

HTML: 8 बाइट्स

<b id=a>

मैं यहां उद्धरणों को छोड़ रहा हूं और bटैग को बंद नहीं कर रहा हूं । यह मान्य HTML नहीं है, लेकिन सभी ब्राउज़र स्वतः टैग को वैसे भी बंद कर देते हैं। मैंने इसे बोल्ड किया क्योंकि bएक-पात्र HTML तत्व है और क्योंकि मेरे पक्षी का नृत्य देखने लायक है।

— ल्यूक
स्रोत

1

जब f स्वयं कॉल करता है, तो वह n फिर से पास नहीं होता है। मेरे लिए कम से कम यह केवल पहली बार n का सम्मान करने के लिए लगता है, जिसके बाद यह शून्य (या अपरिभाषित) है। इसके अलावा कभी-कभी आउटपुट अपरिभाषित होता है। क्या इसे r% 7 होना चाहिए?

— क्रिस एम

तुम सही हो, मैं n पास करना भूल गया। यह वास्तव में% 7 होना चाहिए। मैंने पक्षी की मात्रा को कम कर दिया। सुधार के लिए धन्यवाद, अब यह तय हो गया है।

— ल्यूक

क्षमा करें, मैं आपकी बाइट मायने रखता हूं! कूल गोल्फिंग, मुझे रैंडम फंक्शन और जीरो स्प्लिटिंग पसंद है

— क्रिस एम

धन्यवाद। मुझे अपना उत्तर संपादित करते समय एक 4B सुधार मिला, जिसका मतलब था कि मैंने 2B को बचाया है, इसलिए यह सब ठीक है। ईएस 5 और उससे पहले के बाइट्स को बचाने के लिए शून्य बंटवारे का उपयोग किया जाता है, लेकिन आप ईएस 6 के बाद से टेम्पलेट स्ट्रिंग्स के साथ कोष्ठकों को छोड़ सकते हैं, इसलिए यह अब उपयोगी नहीं है। यह एक अलग दृष्टिकोण से शेष है (जहां मैंने सेट इन्टरवल के लिए पहले तर्क के रूप में एक टेम्पलेट स्ट्रिंग का उपयोग किया था)।

— ल्यूक

2

पॉवरशेल , 124 117 बाइट्स

(धन्यवाद टिम्मीड )

for(){(-split'^(")v v(")^ ^(")^ v(")v (>")> <(")> <("<)')[($i=0..6|random)];sleep -m((100,200)[$i-gt3]*$args[0]);cls}

इसे ऑनलाइन आज़माएं! (ऐसा नहीं है कि यह TIO में काम करेगा ...)

— briantist
स्रोत

आप $b117 तक नीचे जाने के लिए छद्म-त्रिशंकु को समाप्त और उपयोग कर सकते हैं - for(){(-split'^(")v v(")^ ^(")^ v(")v (>")> <(")> <("<)')[($i=0..6|random)];sleep -m((100,200)[$i-gt3]*$args[0]);cls}मुझे लगता है कि यह संभव है; मैं अभी भी इसे देख रहा हूं।

— AdmBorkBork

आप बस मुझे @TimmyD (धन्यवाद) के लिए बधाई देते रहें! मुझे लगता है कि ये परिवर्तन आपके स्वयं के उत्तर को स्पष्ट करने के लिए पर्याप्त हैं; यह मेरे कोड में अद्वितीय कुछ भी नहीं छोड़ता है :)

— रिश्वतवादी

नहीं, वे आपके कोड पर केवल मामूली ट्वीक्स हैं। समग्र तर्क बिल्कुल वही है। कोशिश करो।

— AdmBorkBork

2

नूडल , नॉनकमेटिंग 67 बाइट्स

ʠƘṣḳƑðẉḤż’ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð
ḊḢðḞ’ṀḌcṀḌcİ8c¬ððɲḷṛḋʠṡʠạÇƥƥạƥḋʠ⁺µḍ

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

कोशिश करो:)

यह काम किस प्रकार करता है

                                                                     # Note: The input is immediately pushed onto the stack.
ʠ                                                                    # Moves the pointer for the top of the stack down one.
 ƘṣḳƑðẉḤż’ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð                                      # Creates a string based off of the key "ƘṣḳƑðẉḤż" and the compressed text "ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð" to create "^(")vðv(")^ð^(")^ðv(")vð(>")>ð<(")>ð<("<)" which then gets split by the null character "ð" to create an array of strings which gets pushed to the stack.
                               \n                                    # A new line to separate the literals.
                                 ḊḢðḞ’ṀḌcṀḌcİ8c¬ðð                   # Creates a string based off of the key "ḊḢðḞ" and the compressed text "ṀḌcṀḌcİ8c¬ðð" to create "100ð100ð100ð100ð200ð200ð200" which then gets split the same way as before.
                                                  ɲ                  # Turns each element in the array into a number creating the array of delays.
                                                   ḷ                 # Loops the rest of the code unconditionally.
                                                    ṛ                # Generates a random number from 0 to the length-1 of the array on top of the stack.
                                                     ḋ               # Duplicates the random number.
                                                      ʠ              # Moves the stack pointer down to save one of the random numbers for later.
                                                       ṡ             # Swap the array with the random number such that the array is on top again.
                                                        ʠ            # Moves the stack pointer down such that the random number is on top.
                                                         ạ           # Uses the random number to access the bird array which is now after the random number and pushes the element onto the stack.
                                                          Ç          # Clears the screen and pops the bird and pushes it to the screen.
                                                           ƥƥ        # Moves the stack pointer up two times such that the random number is the top.
                                                             ạ       # Use the random number to access the array with delays and pushes that item onto the stack.
                                                              ƥ      # Moves the stack pointer up in order to have the input on top.
                                                               ḋ     # Duplicates the users input.
                                                                ʠ    # Moves the stack pointer back down in order to have the user input on top followed by the random item from the delay array.
                                                                 ⁺µ  # This command pops two numbers off and multiplies them and pushes the result back on.
                                                                   ḍ # Pops off of the stack and uses that as a delay in milliseconds.

64 बाइट्स

यहां एक संस्करण है जो एक कोड स्निपेट के रूप में काम करता है।

ʠƘṣḳƑðẉḤż’ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð EAð¶’Ṁ|ṢĿ<h4¶¬ȥḷṛḋʠṡʠạÇƥƥạƥḋʠ⁺µḍ

<div id="noodel" code="ʠƘṣḳƑðẉḤż’ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð EAð¶’Ṁ|ṢĿ<h4¶¬ȥḷṛḋʠṡʠạÇƥƥạƥḋʠ⁺µḍ" input="2" cols="5" rows="3"></div>

<script src="https://tkellehe.github.io/noodel/release/noodel-1.1.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>

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

— tkellehe
स्रोत

1

पायथन, 157 बाइट्स

import time,random;n,m=5,int(input())
while 1:print('(>")><(")><("<)^(")vv(")^^(")^v(")v'[n:n+5]);time.sleep((.1+(n<15)/10)*m);n=(n+random.randint(1,6)*5)%35

मैंने इसे चिकन अस्सी कला के बिना भी करने की कोशिश की, लेकिन यह लंबे समय तक था।

import time,random;n,m=5,int(input())
while 1:
  print(['^v'[n%2]+'(")'+'v^'[0<n<3],''.join(map(chr,[40+20*(n>4),62-22*(n>4),34,41+19*(n>5),62-21*(n>5)]))][n>3])
  time.sleep((.1+(n>3)/10)*m);n=(n+random.randint(1,6))%7

— Cormac
स्रोत

1

रूबी, 97 + 1 = 98 बाइट्स

-nझंडे से +1 बाइट ।

a=1;loop{puts %w{^(")v <(")> v(")^ (>")> ^(")^ <("<) v(")v}[a];sleep$_.to_i*0.1*(1+a%2);a=rand 7}

— मूल्य स्याही
स्रोत

1

क्लोजर, 185 178 बाइट्स

+18 बाइट्स क्योंकि यह साथ शुरू नहीं हुआ था <(")>।

-7 बाइट्स inlining द्वारा birds, और छुटकारा पाने के let।

#(loop[m nil r(or m 1)](print"\r"((clojure.string/split"(>\")> <(\")> <(\"<) ^(\")v v(\")^ ^(\")^ v(\")v"#" ")r))(flush)(Thread/sleep(*(if(> r 2)100 200)%))(recur 1(rand-int 7)))

बस रिक्त स्थान पर पक्षियों को विभाजित करता है, 0-6 से एक यादृच्छिक सूचकांक चुनता है, चुने हुए पक्षी को प्रदर्शित करता है, फिर यदि चुना हुआ सूचकांक 2 से अधिक है, तो यह 100ms, 200 मी का इंतजार करता है।

क्लोजर वास्तव splitमें कोर में एक स्ट्रिंग विधि की आवश्यकता है ।

Ungolfed:

(defn dancing-bird [n]
  (loop [m nil]
    (let [birds (clojure.string/split "(>\")> <(\")> <(\"<) ^(\")v v(\")^ ^(\")^ v(\")v" #" ")
          rand-i (or m 1)]
      (print "\r" (birds rand-i))
      (flush)
      (Thread/sleep (* (if (> r 2) 100 200) n))
      (recur (rand-int 7)))))

— Carcigenicate
स्रोत

बर्ड डांसर (>)>

अतिरिक्त विवरण

उदाहरण पायथन 3 में

जीतना

MATL , 53 बाइट्स

व्याख्या

मतलाब, 125 117 बाइट्स

* * <> , 103 101 बाइट्स

व्याख्या

initialisation

नृत्य करने वाला

100ms नृत्य उत्पन्न करें

43C - "^" या "v" उत्पन्न करें

200 मी डांस जनरेट करें

<(")>

(>")> तथा <("<)

जावास्क्रिप्ट (ईएस 6) + एचटीएमएल 5: 118 116 + 8 = 124 बाइट्स

जावास्क्रिप्ट: 119 बाइट्स

HTML: 8 बाइट्स

पॉवरशेल , 124 117 बाइट्स

नूडल , नॉनकमेटिंग 67 बाइट्स

यह काम किस प्रकार करता है

पायथन, 157 बाइट्स

रूबी, 97 + 1 = 98 बाइट्स

क्लोजर, 185 178 बाइट्स

`<(")>`

`(>")>` तथा `<("<)`