अपने टर्मिनल में पाठ को एनिमेट करें

Question

अपने टर्मिनल में पाठ को एनिमेट करें

लक्ष्य

लक्ष्य अपने आउटपुट में स्ट्रिंग "हैलो वर्ल्ड" को "चेतन" करना है ताकि प्रत्येक चरित्र एक दूसरे के बाद पूंजीकृत हो जाए।

प्रत्येक पत्र को कैपिटल किए जाने के बाद आपका प्रोग्राम बाहर निकल सकता है।

उदाहरण के लिए;

# Iteration 1
Hello world

# Iteration 2
hEllo world

# Iteration 3
heLlo world

# Iteration 4
helLo world

# Iteration 5
hellO world

# Iteration 6 (note: it should capitilize the space char (ie: a break between iteration 5 and iteration 7)
hello world

# Iteration 7
hello World

# Iteration 8
hello wOrld

# Iteration 9
hello woRld

# Iteration 10
hello worLd

# Iteration 11
hello worlD

इसे केवल एक बार स्ट्रिंग को चेतन करना चाहिए और प्रत्येक राज्य के बीच 1 सेकंड की देरी होनी चाहिए।

इनपुट

किसी इनपुट की आवश्यकता नहीं है, लेकिन "हैलो वर्ल्ड" में वह स्ट्रिंग होनी चाहिए जो "एनिमेटेड" हो।

उत्पादन

स्ट्रिंग "हैलो वर्ल्ड" एनिमेटेड होना चाहिए। एक प्रकार की तरंग एनीमेशन बनाने के लिए आउटपुट 1 पंक्ति के रूप में होना चाहिए। खाली ट्रेलिंग नई लाइन की अनुमति है। उदाहरण gif;

^{मैंने इसे एक मेटास्प्लोइट यूट्यूब वीडियो पर देखा और सोचा कि यह प्रभाव बहुत अच्छा था, जो कि मैंने जहाँ से गिफ़ रिकॉर्ड किया है, इसलिए यह थोड़ा सुस्त है, लेकिन मुझे आशा है कि यह आउटपुट ठीक दिखाता है}

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

^{सैंडबॉक्स लिंक}

Comments

क्या यह एक त्रुटि के साथ बाहर निकल और बंद हो सकता है?

— स्टीवी ग्रिफ़िन

@StewieGriffin जब तक एनीमेशन देखने योग्य है, निश्चित है।

— ।

मुझे नहीं लगता कि 1 सेकंड की देरी चुनौती को जोड़ती है। हमारे पास एक गुच्छा है और हर बार ऐसा लगता है जैसे एक ही बॉयलरप्लेट को जोड़ा गया है।

— xnor

@xnor क्या आप का मतलब है देरी की अवधि 1 सेकंड स्पष्ट रूप से है, या क्या आप किसी भी देरी का मतलब है? लैटर का कोई मतलब नहीं होगा क्योंकि यह एक एनीमेशन है ..

— Metoniem

@Metoniem नहीं, केवल गोल में वर्णित। जब तक मैंने गलत नहीं समझा। प्रत्येक अक्षर को एक बार बाएं से दाएं से एक बार केवल "

— हेल

Answer 1

26 बाइट्स निकालें

ihello world<ESC>qq~gsul@qq0@q

स्पष्टीकरण (अभी तक कोई भी नहीं):

सबसे पहले, हमें 'हैलो वर्ल्ड' टेक्स्ट दर्ज करना होगा। यह बहुत सीधा है। यह सिर्फ है:

ihello world<ESC>

इस बिंदु पर, कर्सर 'दुनिया' में 'd' पर है। आगे:

qq              " Start recording into register 'q'
  ~             " Swap the case of the character underneath the cursor, and move the cursor to the right
   gs           " Sleep for one second
     u          " Undo the last change (of swapping case).
      l         " Move one character to the right (Get it? 'l' == 'Right' because vim is intuitive!)
                " This will cause the error to break on the last character of the input.
       @q       " Call register 'q'
         q      " Stop recording
          0     " Move to the first character
           @q   " Call the recursive macro

दो अन्य 26 बाइट संस्करण भी मुझे मिले हैं:

ihello world<ESC>qq~gsulq011@q
ihello world<ESC>011@='~gsul'<cr>

Comments

यार वो मस्त! : यहाँ उत्पादन है i.gyazo.com/52d0b9268446aed36ce7eb641c40ff6c.gif (आधा वैसे भी, Gyazo रिकॉर्डिंग बंद कर)

— ʰᵈˑ

मुझे नहीं लगता ~ कि लूप टूटता है । मेरा मानना ​​है कि यह lहै कि कड़ी मेहनत करता है

— Krixi Lithos

@KritiiLithos आह, इसके परीक्षण के बाद, ऐसा लगता है कि आप सही हैं। अच्छा बिंदु, मुझे लगता है कि बाहर संपादित करेंगे

— DJMcMayhem

पुष्टि कर सकते हैं - यह काम करता है।

— SIGSTACKFAULT

Answer 2

पायथन 2, 98 94 90 बाइट्स

for x in range(11):s='hello world';print'\r'+s[:x]+s[x:].capitalize(),;[1for y in' '*8**8]

-9 -4 बाइट्स @ElPedro -4 बाइट्स के लिए @JonathanAllan और @Rod को धन्यवाद

Comments

PPCG में आपका स्वागत है, अच्छा पहला पोस्ट c:

— Rod

अच्छा लेख! यह एक राजधानी 'एच' और एक ही समय में हालांकि पर "W" है लगता है repl.it/Fhii - यह लोअरकेस नहीं करने के लिए "एच" लगता है

— ʰᵈˑ

मुद्रण समस्या के बारे में, आप -uतर्क और उपयोगprint"\t"+s[:x]+s[x:].title(),; को पारित कर सकते हैं (ध्यान रखें अल्पविराम) । और यह आपकी बाइट काउंट को नहीं बदलेगा (क्योंकि तर्क +2 बाइट्स को जोड़ देगा)

— Rod

@Rod ध्वज एक बाइट के रूप में गिना जाएगा क्योंकि पायथन के लिए एक स्वीकार्य मंगलाचरण है python -c 'code here'। ध्वज के साथ, आह्वान होगा python -uc 'code here', जो एक बाइट अलग है।

— मेगो

आपका संस्करण बहुत सुंदर है, लेकिन 95 बाइट्स और स्क्रीन को साफ करता है (मैंने विंडोज 7-64 पर 2.7.8 के साथ परीक्षण किया)। ट्राय इट ऑनलाइन एनिमेशन नहीं देता है, बस लाइन बाय लाइन रिजल्ट।

— जोनाथन एलन

Answer 3

कमोडोर 64, 168 162 137 133 बेसिक (और टोकनयुक्त) बाइट्स का उपयोग किया जाता है

 0s=1024:?"{control+n}{clear home}hello world":fOi=.to1:fOj=.to11:x=pE(s+j):pokes+j,x+64
 1x=pE(1023+j):pO1023+j,abs(x-64):pO1029,32:pO1035,32:fOz=.to99:i=.:nEz,j,i

आपको वास्तविक C64 या एमुलेटर में प्रवेश करने के लिए BASIC कीवर्ड संक्षिप्ताक्षर का उपयोग करना होगा (या प्रोग्राम को कमोडोर 128 में दर्ज करें और इसे C64 मोड में वापस लोड करें, हालांकि यह 128 पर भी काम करना चाहिए)। {control+n}केवल उद्घाटन बोली के बाद काम / प्रदर्शन होगा। यह शॉर्टहैंड है chr$(14)और इसलिए कुछ बाइट्स बचाता है और कैरेक्टर सेट को बिजनेस मोड या अपर / लोअर केस कैरेक्टर्स पर स्विच करता है ।

मैंने आपके लिए कुछ संक्षिप्ताक्षरों में जोड़ा है ताकि आप। {clear home}चरित्र का उपयोग करके किया जाता है Shiftऔर CLR/HOMEउद्घाटन उद्धरण चिह्न के बाद कुंजी।

उदाहरण के लिए बिना सोचे-समझे लिस्टिंग को इस प्रकार दर्ज किया जा सकता है:

 0 let s=1024
 1 print chr$(14); chr$(147); "hello world"
 2 for i=0 to 1
 3  for j=0 to 11
 4   let x=peek(s + j)
 5   poke s + j, x + 64
 6   let x=peek(1023 + j)
 7   poke 1023 + j, abs(x - 64)
 8   poke 1029, 32
 9   poke 1035, 32
10   for z=0 to 99
11    let i=0
12   next z
13  next j
14 next i

यह PETSCII चारसेट को बिज़नेस मोड (अपर / लोअर केस) में बदलकर काम करता है, और स्क्रीन के टॉप लाइन पर हैलो वर्ल्ड स्ट्रिंग लिख रहा है, जो कि मेमोरी लोकेशन $ 0400 पर स्थित है, फिर यह अगले के लिए प्रत्येक लोकेशन पर वैल्यू लेगा वहां से 11 बाइट्स और 64 (ऊपरी मामले के बराबर) द्वारा प्रत्येक मूल्य में वृद्धि। यदि j काउंटर the 0 है, तो यह पिछले मेमोरी स्थान को फिर से ६४ से कम करने के लिए लाइन २ पर एक रूटीन कहता है।

पंक्ति 3 एक विराम है, यह $ 0405 और $ 040b को स्थान देने के लिए एक स्थान भी लिखता है, जो एक बग फिक्स है (जिसे शायद कुछ बाइट्स को बचाने के लिए हटाया जा सकता है)।

Comments

मुझे यह जोड़ना चाहिए कि fori=0to1step0... nextiमूल रूप से एक अनंत (गोटो-लेस) लूप का निर्माण कर रहा है, जैसे while(true){...}कि अधिक आधुनिक भाषाओं में।

— शॉन बेयबर्स

आप अनंत लूप के बजाय सिर्फ गोटो का उपयोग क्यों नहीं करते? यहां तक ​​कि 2 न्यूलाइन्स के साथ जो जोड़ना होगा, यह अभी भी बाइट्स को बचाएगा। इसके अलावा रैम बाइट्स आपके कोड में बाइट्स की संख्या के समान नहीं है।

— मिल्कीवेय 90

क्योंकि GO TOप्रतिबंधित है, ठीक है ;-) एक आसानी CLRसे टूटे हुए FRE(0)समारोह के साथ बाइट फ्री बाइट्स बाहर काम करने से पहले आसानी से लिस्टिंग से बाहर काम कर सकते हैं

— शॉन Bebbers

इस बारे में क्षमा करें

— MilkyWay90

Answer 4

सी #, 230 215 193 161 135 134 130 बाइट्स

यह C # है तो यह सही है! :-( लेकिन कुछ मदद और खोज के बाद, मैं (और अन्य, वास्तव में) पहले से ही 100 बाइट्स निकालने में कामयाब रहे।

golfed

()=>{for(int i=1;;){var b="\rhello world".ToCharArray();b[i++]-=' ';System.Console.Write(b);System.Threading.Thread.Sleep(1000);}}

Ungolfed

class P
{
    static void Main()
    {
        for (int i = 1;;)
        {
            var b = "\rhello world".ToCharArray();
            b[i++] -= ' ';
            System.Console.Write(b);
            System.Threading.Thread.Sleep(1000);
        }
    }
}

स्क्रीनशॉट

हालांकि यह बहुत अच्छा लगता है जब लूपिंग और तेज होता है।

अपडेट

• गाड़ी की वापसी का उपयोग करके 15 बाइट खो दिया, Clear()जिसके बजाय मुझे System.Consoleकहीं इनलाइन के साथ एक प्रयोग को बदलने की अनुमति दी ।

• लंबोदर के साथ बदला हुआ कार्यक्रम @ byRicher को 23 बाइट्स का धन्यवाद

• यह इस बिंदु पर @devRicher के साथ सहयोग का एक प्रकार बन गया , उनके कुछ सुझावों के कारण मैं एक और 32 बाइट्स खोने में कामयाब रहा!
• @Kratz द्वारा 2 वास्तव में स्मार्ट और दिलचस्प सुझावों के लिए धन्यवाद , मैं एक और 26 बाइट्स बचाने के new string(b)साथ bऔर b[i]=char.ToUpper(b[i])साथ में कामयाब रहा b[i]-=' '!
• @ ब्वॉयफ्रेंड काi++ शुक्रिया अदा करके 1 बाइट कम
• 4 बाइट्स कम चलती गाड़ी से वापस स्ट्रिंग की शुरुआत में और i<11मेरे forलूप से निकालते हैं

Comments

कुछ बाइट्स स्निप class P{static void Main(){ ... }}करने के ()=>{ ... }लिए बदलें । PPCG उत्तर के रूप में कार्यों को स्वीकार करता है, इसलिए एक लैम्ब्डा ठीक काम करता है।

— devRicher

@devRicher आह मैं देख रहा हूं, मैंने पहले कभी लैंब का इस्तेमाल नहीं किया, लेकिन यह एक अच्छा सुधार है। धन्यवाद!

— मेटोनीम

यदि आप नहीं जानते कि उनका उपयोग कैसे करें (या नहीं करना चाहते हैं), तो यह एक साधारण के लिए अभी भी ठीक है void g(){ ... }।

— devRicher

आप सरणी सूचकांकों के साथ तार का उपयोग कर सकते हैं ( char g = string j[x]लगभग 50 बाइट्स बचाने के लिए:()=>{var s="Hello world";for(int i=1;i<11;i++){string h = s;h[i]=char.ToUpper(s[i]);System.Console.Write(h+"\r");System.Threading.Thread.Sleep(1000);}}

— devRicher

आप एक और बाइट को क्लॉज के लिए इंक्रीजेशन को हटाकर ऐक्सेस एक्सेस की तरह लगा सकते हैं b[i++]-=' '। यह काम आएगा, क्योंकि तब आप लूप के लिए शर्त को हटा सकते हैं और सिर्फ लिख सकते हैं for(int i=0;;)। ओपी ने टिप्पणियों में बताया, कि कार्यक्रम एक त्रुटि के साथ बाहर निकल सकता है, इसलिए आप एक IndexOutOfRangeException

— Snowfire

Answer 5

पॉवरशेल, 126 119 107 104 बाइट्स

'Hello world';$s='hello world';1..10|%{sleep 1;cls;-join($s[0..($_-1)]+[char]($s[$_]-32)+$s[++$_..11])}

संशोधन (संभावित रूप से कई होंगे):

$s.Lengthकॉन्स्ट 1011 में बदलें

पुनर्गठित स्ट्रिंग बिल्डर, हटाया 1 बयान में शामिल होने और इस्तेमाल किया ++$sबजाय ($s+1)कुछ करने के लिए धन्यवाद बाइट्स को बचाने के लिए, @AdmBorkBork

AdmBorkBork केवल दो बार स्ट्रिंग का उपयोग करके इंगित करता है कि वास्तव में एन्कैप्सुलेटिंग की तुलना में कम है और फिर .ToLower()इसे 'ing - जो वर्बोज़ पॉवर्सशेल के बारे में बहुत कुछ कहता है, -3!

---

मूल रूप से स्ट्रिंग की लंबाई के माध्यम से लूप, तीन भागों की एक सरणी बनाते हैं, पूर्व-कैपिटल, कैपिटल और पोस्ट-कैपिटल, मध्य अक्षर से 32 दूर ले जाते हैं, फिर ऊपरी मामले को प्राप्त करने के लिए एक चार में परिवर्तित करें, सौभाग्य से यह doesn एक दृश्य चरित्र में टी टर्न स्पेस या तो, मुझे आशा है कि यह स्वीकार्य है?

Comments

आप बस स्ट्रिंग मुद्रण के बजाय में सहेजकर सामने बंद तीन और बाइट्स बचा सकता है $sऔर .ToLower()यह ing। -'Hello world';$s='hello world';

— AdmBorkBork

102 बाइट्स इनलाइन-इन $ s

— Veskah

Answer 6

CP-1610 असेंबली, 50 DECLEs = 63 बाइट्स

इस कोड को एक Intellivision पर चलाने का इरादा है ।

एक CP-1610 ओपकोड को 10-बिट मान के साथ एन्कोड किया गया है, जिसे 'DECLE' के रूप में जाना जाता है। यह कार्यक्रम 50 DECLE का है, $ 4800 से शुरू होकर $ 4831 पर समाप्त होगा।

                                  ROMW  10          ; use 10-bit ROM
                                  ORG   $4800       ; start program at address $4800

                          main    PROC
4800 0002                         EIS               ; enable interrupts (to enable display)

4801 0001                         SDBD              ; load pointer to string in R4
4802 02BC 0026 0048               MVII  #@@str, R4

4805 02A2                         MVI@  R4,     R2  ; R2 = length of string
4806 0091                         MOVR  R2,     R1  ; R1 = uppercase counter

4807 02BD 0214            @@loop  MVII  #$214,  R5  ; R5 = video memory pointer
4809 0093                         MOVR  R2,     R3  ; R3 = character counter

480A 02A0                 @@next  MVI@  R4,     R0  ; R0 = next character
480B 0338 0020                    SUBI  #32,    R0  ; minus 32 -> character #
480D 004C                         SLL   R0,     2   ; multiply by 8 to get the
480E 0048                         SLL   R0          ; correct GROM card
480F 03F8 0007                    XORI  #7,     R0  ; add 7 (for white)

4811 014B                         CMPR  R1,     R3  ; uppercase? ...
4812 020C 0002                    BNEQ  @@draw

4814 0338 0100                    SUBI  #256,   R0  ; ... yes: sub 32*8

4816 0268                 @@draw  MVO@  R0,     R5  ; draw character
4817 0013                         DECR  R3          ; decrement character counter
4818 022C 000F                    BNEQ  @@next      ; process next character or stop

481A 0001                         SDBD              ; R0 = spin counter to wait ~1 second
481B 02B8 0038 00D3               MVII  #$D338, R0  ;    = 54072 = 13518 * 60 / 15
                                                    ; (assuming 13518 cycles per frame)

481E 0010                 @@spin  DECR  R0          ; 6 cycles
481F 022C 0002                    BNEQ  @@spin      ; 9 cycles
                                                    ; -> 15 cycles per iteration

4821 0114                         SUBR  R2,     R4  ; reset pointer to beginning of string
4822 0011                         DECR  R1          ; decrement uppercase counter
4823 022C 001D                    BNEQ  @@loop      ; process next iteration or stop

4825 0017                         DECR  PC          ; infinite loop

4826 000B 0068 0065 006C  @@str   STRING 11, "hello world"
482A 006C 006F 0020 0077
482E 006F 0072 006C 0064
                                  ENDP

उत्पादन

Answer 7

MATL , 30 बाइट्स

11:"10&Xx'hello world't@)Xk@(D

MATL ऑनलाइन पर यह कोशिश करो !

11:              % Push [1 2 ... 11]
  "              % For each k in [1 2 ... 11]
  10&Xx          %   Pause for 10 tenths of a second and clear screen
  'hello world'  %   Push this string
  t              %   Duplicate
  @)             %   Get the k-th character from the duplicated string
  Xk             %   Convert to uppercase
  @(             %   Write into the k-th position of the string
  D              %   Display
                 % Implicit end

Answer 8

PHP, 76 74 71 बाइट्स

देरी से पूर्ण दूसरे होने और इसके कोई अंश न होने के लिए धन्यवाद @hd!
2 बाइट्स के लिए @ user63956 और 3 बाइट्स के लिए @aross का धन्यवाद।

for(;$c=($s="hello world")[$i];sleep(print"$s\r"))$s[$i++]=ucfirst($c);

के साथ भागो -nr।

Comments

आप के साथ 2 बाइट्स बचा सकते हैं sleep(print"$s\r")।

— user63956

के साथ 3 बाइट्स सहेजें ucfirst

— aross

Answer 9

C, 97 ने 106 बाइट वापस ले ली

बच गए पात्रों को 1 बाइट के रूप में गिना जाता है

char*a="HELLO\0WORLD\xED";b,c;m(){for(b=0;b<156;putchar(a[c]+32*(b/12^c||c==5)))(c=b++%12)||fflush(sleep(1));}

नोट: मैंने अनलिंक किए गए TIO पर समय की देरी के बारे में टिप्पणी की है क्योंकि यह आउटपुट प्रदर्शित करने से पहले पूरा होने का इंतजार करता है, यह भी गाड़ी के रिटर्न को पहचानता नहीं है और नई लाइनें डालता है। इसके अलावा, यदि आप विंडोज पर हैं, तो नींद सेकंड के बजाय मिलीसेकंड में होती है, इसलिए sleep(1)बनना चाहिए sleep(1000)।

नोट 2: मैंने इस प्रविष्टि को उस समय के लिए वापस ले लिया है जब तक कि आउटपुट बग्स को इस्त्री नहीं किया गया है।

Comments

किसी कारण के लिए, यह मेरी मशीन पर कुछ भी आउटपुट नहीं करता है

— क्रिति लिथोस

यदि आप खिड़कियों पर हैं, तो आपको देरी को बदलना होगा, यह एक गाड़ी वापसी पर भी समाप्त हो जाएगी ताकि आप 130 से 129 बदलना चाहें, इसलिए इसे अंतिम पुनरावृत्ति के दौरान इसे प्रिंट करने से बचा जाता है।

— अहमोन

मेरे लिए यह कार्यक्रम बिल्कुल भी समाप्त नहीं होता है, और यह कुछ भी आउटपुट नहीं करता है। मुझे ^Cइसे रोकने के लिए इसे मैन्युअल रूप से करना पड़ा । (मैं मैक पर भी हूँ)

— क्रिस्ति लिथोस

मेरा मानना ​​है कि यह एक प्रिंट बफर समस्या है, मैं अभी के लिए अपनी प्रविष्टि वापस लूंगा।

— अहमोन

Answer 10

जावास्क्रिप्ट (ईएस 6), 141 139 131 बाइट्स

Apsillers को 8B धन्यवाद दिया

_=>a=setInterval("b=[...`hello world`],c.clear(b[d]=b[d].toUpperCase(++d>10&&clearInterval(a))),c.log(b.join``)",1e3,c=console,d=0)

व्याख्या

यह बिना किसी तर्क के एक फ़ंक्शन बनाता है, जो स्ट्रिंग hello worldको वर्णों की एक सरणी में विभाजित करता है और d+1^वें वर्ण को कैपिटल करता है । dएक ऐसा काउंटर है जो 0हर बार शुरू होता है और बढ़ाया जाता है।

प्रयोग

f=_=>a=setInterval("b=[...`hello world`],c.clear(b[d]=b[d].toUpperCase(++d>10&&clearInterval(a))),c.log(b.join``)",1e3,c=console,d=0)
f()

Comments

चतुर, मैं इसे अपडेट करूंगा।

— ल्यूक

इसके अलावा, मुझे इसे फंक्शन करने का कोई कारण नहीं दिखता है, क्योंकि इसमें कोई इनपुट नहीं है - बस कोड चलाएं, है ना?

— अप्सिलर्स

प्रश्न कहता है कि यह एक कार्यक्रम माना जाता है, लेकिन उस स्थिति में आप एक फ़ंक्शन भी प्रस्तुत कर सकते हैं। आमतौर पर कोड स्निपेट की अनुमति नहीं है।

— ल्यूक

यह अच्छा है, जीजी!

— ।

क्या आप इस मामले में एक अस्वीकृत "कोड स्निपेट" बनाम एक अनुमत "प्रोग्राम" की अपनी समझ के बीच अंतर कर सकते हैं? यदि आप केवल उस अग्रणी को निकालते हैं जिसका _=>आपके पास पूरा कार्यक्रम है (उदाहरण के लिए, यदि आप इसे किसी फ़ाइल में अटकाते हैं, तो Node.js इसे पूर्ण करने के लिए सफलतापूर्वक चलेगा)। "कोड स्निपेट्स" के खिलाफ निषेध की मेरी समझ उस कोड लिखने के खिलाफ है जो स्पष्ट रूप से एक चर के रूप में कुछ इनपुट को स्वीकार करता है, जैसे "अगर हम मानते हैं कि हमारे iपास पहले से ही इनपुट है, तो हम कर सकते हैं ..." जो यहां नहीं हो रहा है, क्योंकि स्पष्ट रूप से है। कोई निवेश नहीं।

— अप्सिलर्स

Answer 11

नूडल , 22 बाइट्स

”<8@\|DḶ|\6þıHḶƥɲSḍsɲS

कोशिश करो:)

---

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

”<8@\|DḶ|\6þ           # Displays the string "hello¤world".
”<8@\|DḶ|\6            # Decompresses to the array ["h", "e", "l", "l", "o", "¤", "w", "o", "r", "l", "d"] and pushes it on top of the stack.
           þ           # Pushes a copy of the array to the screen which since is an array is done by reference.

            ı          # Makes the array on the top of the stack the new stack.

             HḶƥɲSḍsɲS # Loops eleven times creating the animation.
             H         # Pushes the string "H" on to the top of the stack.
              Ḷ        # Consumes the "H" that gets evaluated as a base 98 number which comes out to eleven.
               ƥ       # Move the stack pointer up one.
                ɲS     # Switch the case of the top of the stack which will show up on the screen because the array is done by reference.
                  ḍs   # Delay for one second.
                    ɲS # Switch the case back.
                       # Implicit end of the loop.

---

स्निपेट 25 बाइट संस्करण का उपयोग करता है जो लगातार लूप करता है।

<div id="noodel" cols="10" rows="2" code="”<8@\|DḶ|\6þıḷʠ*HḶƥɲSḍsɲS" input=""/>
<script src="https://tkellehe.github.io/noodel/release/noodel-2.5.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>

Answer 12

बैश + कोरुटिल्स, 99 98 बाइट्स

x=hello\ world
for((;n<11;)){
echo -en "\r${x:0:n}"`tr a-z A-Z<<<"${x:n:1}"`"${x:n+++1}"
sleep 1
}

Answer 13

पर्ल 6 , 65 61 बाइट्स

for 3..12 ->\i{sleep say "\echello world".&{S:nth(i)/./{$/.uc}/}}

(sleep say S:nth(3+$++)/./{$/.uc}/with "\echello world")xx 11

GIF:

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

ANSI एस्केप अनुक्रम \ecस्क्रीन को साफ करता है।
प्रत्येक पुनरावृत्ति, iहार्ड कोडित स्ट्रिंग के 'वें चरित्र को इसके ऊपरी-केस संस्करण द्वारा प्रतिस्थापित किया जाता है। हमेशा समारोह रिटर्न , जो नींद समारोह के रूप में व्याख्या यह पारित हो जाता है दूसरा।
sayTrue1

Answer 14

रूबी, 82 81 बाइट्स

12.times{|a|$><<?^H*11;'Hello world'.chars{|y|$><<((0!=a-=1)?y:y.upcase)};sleep 1}

^ एच असिसी 8 (बैकस्पेस) है, और केवल 1 बाइट है।

Answer 15

सी, 87 बाइट्स

m(){char*f,a[]="\rhello world";for(f=a;*++f;*f&=95,printf(a),*f|=32,fflush(sleep(1)));}

संकलन और लिनक्स पर चलता है।

Answer 16

मैथेमेटिका, 130 128 123 110 108 बाइट्स

Dynamic@o
s="hello world";i=1;t=StringTake;Do[o=t[s,{1,i-1}]<>Capitalize@t[s,{i}]<>t[s,{++i,11}];Pause@1,11]

स्पष्टीकरण: i=111 से, "हेल्लो वर्ल्ड" के 1 से (i-1) वें चरित्र के लिए "hello world"[i]प्रिंट करें , कैपिटल करें , फिर iउसी समय इंक्रीमेंट करते हुए , बाकी स्ट्रिंग को प्रिंट करें ।

Answer 17

जावा 215 212 204 203 बाइट्स

interface A{static void main(String z[])throws Exception{for(int i=0;i<10;i++){char[]b="helloworld".toCharArray();b[i]=Character.toUpperCase(b[i]);System.out.println(new String(b));Thread.sleep(1000);}}}

Ungolfed:

 interface A {
 static void main(String z[]) throws Exception {
    for (int i = 0; i < 10; i++) {
        char[] b = "helloworld".toCharArray();
        b[i] = Character.toUpperCase(b[i]);
        System.out.println(new String(b));
        Thread.sleep(1000);
    }
  }
}

Comments

यह interface A(एक स्थान के साथ) नहीं होना चाहिए ? इसके अलावा आप के बीच की जगह को हटा सकते हैं ,और Character.toUpperCase।

— NoOneIsHere 21

साइट पर आपका स्वागत है!

— DJMcMayhem

3 अंक के लिए @NoOneIsHere करने के लिए यश

— विकासशील 21

धन्यवाद @DJMcMayhem, हमेशा चुनौतियों के माध्यम से पढ़ना पसंद किया और अंत में एक का जवाब देने के लिए मिला!

— डेवलपिंग

Answer 18

आर , 106 103 बाइट्स

x=el(strsplit("hello world",""))
for(i in 1:11){y=x;y[i]=toupper(y[i]);cat('\f',y,sep='');Sys.sleep(1)}

बस एक साधारण लूप, कंसोल को साफ़ करने के साथ cat('\f')कुछ हद तक सिस्टम-निर्भर लगता है लेकिन मुझे बेहतर तरीके के बारे में पता नहीं है।

Comments

मैं इस का उपयोग कर outgolfing की कोशिश की utf8ToInt। यह काम नहीं किया, एक विशेष मामले के रूप में अंतरिक्ष को संभालने की आवश्यकता है। इस प्रक्रिया में मुझे पता चला कि cat("\014")बेहतर काम करने के लिए लग रहा cat("\f")था, जहां काम नहीं किया। लेकिन TIO पर नहीं

— JayCe

Answer 19

सी, 122 बाइट्स

i;f(){char s[]="Hello world\r";for(i=0;i<11;i++){s[i]=toupper(s[i]);s[i-1]=tolower(s[i-1]);printf(s);fflush(0);sleep(1);}}

C #: D से छोटा

Comments

अंतिम फ्रेम के दिखाई देने के लिए, आपको अपने फॉर-लूप के i<11बजाय करना होगाi<10

— क्रिति लिथोस

Answer 20

पर्ल, 75 बाइट्स

sleep print"\33c".("hello world"=~s/(.{$_})(.)(.*)/$1\U$2\E$3\n/r)for 0..10

ESCcकंसोल को खाली करने और कर्सर को हर पुनरावृत्ति पर बाईं ओर ऊपर ले जाने के लिए ANSI कोड का उपयोग करता है , लेकिन \nलाइन बफर में खो जाने वाले पूरे एनीमेशन से बचने के लिए प्रतिस्थापित स्ट्रिंग के अंत में अभी भी आवश्यकता होती है ।

print1 के मान को वापस करने के लिए एक सफल कॉल , जिसे सीधे पास किया जा सकता है sleep।

Comments

आप उस पर कुछ बाइट्स का उपयोग $`और $'सहेज सकते हैं (.{$_})(.)(.*)(यह टर्मिनल में काम नहीं करेगा, लेकिन यह कोई समस्या नहीं है)। हालाँकि इसके लिए अपने कोड के बाकी हिस्सों को थोड़ा संशोधित करना होगा "hello world"=~s/./sleep print"\33c$`\U$&\E$'\n"/ger:। (मैंने लगभग यह सटीक कोड लिखा था, फिर जब कोई देख रहा था कि किसी ने अभी तक एक पर्ल उत्तर पोस्ट किया है, तो मैंने तुम्हारा पाया)। और बायटेकाउंट के बारे में थोड़ा विस्तार से: आप एक बाइट को बचाने के लिए एक लैटरल न्यूलाइन का उपयोग कर सकते हैं, और शायद किसी प्रकार के लिटरल \33c(हालांकि उस आखिरी के बारे में भी निश्चित नहीं हैं)।

— दादा

Answer 21

स्माइलबासिक, 90 71 बाइट्स

FOR I=0TO 10CLS?"hello world
LOCATE I,0?CHR$(CHKCHR(I,0)-32)WAIT 60NEXT

Answer 22

जेली , 24 21 बाइट्स

”Æ⁹Œu⁸¦ȮœS
“½,⁻⁸3»Jç€

यह एक niladic लिंक / फ़ंक्शन है जो STDOUT पर प्रिंट करता है। यह पूर्ण कार्यक्रम के रूप में काम नहीं करता है।

TIO पर कोड का परीक्षण नहीं किया जा सकता है; यह नियंत्रण वर्णों का उपयोग करता है और TIO का कोई टर्मिनल एमुलेटर (अभी तक) नहीं है।

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

“½,⁻⁸3»Jç€  Niladic link. No arguments.

“½,⁻⁸3»     Index into Jelly's dictionary to yield "hello world".
       J    Indices; yield [1, ..., 11].
        ç€  Apply the helper link to each index, with right arg. "hello world".


”Æ⁹Œu⁸¦ȮœS  Dyadic helper link. Left argument: i. Right argument: "hello world"

Ӯ          Set the return value to '\r'.
  ⁹         Set the return value to "hello world". Implicitly prints '\r'.
   Œu⁸¦     Uppercase the i-th letter.
       Ȯ    Print.
        œS  Sleep "hello world" seconds. (Strings are cast to Boolean.)

Comments

(Strings are cast to Boolean.)वह कुटिल है!

— आउटगॉल्फ को एरिक करें

Answer 23

सी, 122 बाइट्स

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

main(){
    char*p=".Hello world\rH";
    write(1,p+1,13);
    do{
        sleep(1);
        *p=8;
        p[1]|=32;
        p[2]^=(p[2]>32)*32;
        write(1,p++,3);
    }while(p[4]);
}

(न्यूलाइन और इंडेंटेशन्स कॉस्मेटिक और बाइट काउंट का हिस्सा नहीं)

अब, कुछ पाठक ध्यान दें कि इसके लिए आधुनिक मशीनों (मैजिक इनकंटेशन -static -Wl,-N) पर चलने के लिए कुछ मसाज की आवश्यकता होती है , लेकिन इस तरह से C का वास्तविक कार्यान्वयन व्यवहार करने के लिए होता है, इसलिए मुझे लगता है कि यह मान्य है। यह ASCII के चरित्र सेट को भी मानता है, और यह एक अनुगामी न्यूलाइन नहीं छापता है।

बोनस: एक EBCDIC संस्करण के लिए, आप के 8साथ 22और के 64साथ प्रतिस्थापित कर सकते हैं 32, और के लिए तर्क स्विच कर सकते हैं p[1]और p[2]। गैर-EBCDIC प्रणाली पर परीक्षण करने के लिए, आप के साथ संकलन कर सकते हैं -funsigned-char -fexec-charset=cp037।

आउटपुट 43 बाइट्स है: Hello world«H‹hE‹eL‹lL‹lO‹o ‹ W‹wO‹oR‹rL‹lD

Answer 24

स्काला, 92 बाइट्स

val h="hello world"
0 to 10 map{i=>print("\b"*99+h.updated(i,h(i)toUpper))
Thread sleep 999}

Ungolfed

val h="hello world"    //declare a variable h with the string "hello world"
0 to 10                //create a range from 0 to 10
map { i=>              //loop with index i
  print(                 //print
    "\b" * 99              //99 backspace chars
    + h.updated(           //and h with
      i,                     //the i-th char
      h(i).toUpper           //replaced with the i-th char in uppercase
    )     
  )
  Thread sleep 999       //sleep 999 ms
}

Comments

+1 के लिएh(i)toUpper

— हमेशा

Answer 25

बैच, 184 बाइट्स

@echo off
for %%h in (Hello hEllo heLlo helLo hellO hello)do call:c %%h world
for %%w in (World wOrld woRld worLd worlD)do call:c hello %%w
exit/b
:c
timeout/t>nul 1
cls
echo %*

उत्सुकता के लिए कमांड लाइन timeout/t>nul 1भ्रष्ट हो जाती है अगर कोई अनुगामी न्यूलाइन नहीं है, तो मैं इसे फ़ाइल के अंत में नहीं रख सकता।

Answer 26

रूबी, 108 बाइट्स

पहली बार, प्रथम वर्ष के छात्र। यह कोई ईगल नहीं है, लेकिन मुझे कम से कम थोड़ा गर्व है।

12.times{|i|sleep(0.1); puts "\e[H\e[2J", "hello world".sub(/(?<=.{#{Regexp.quote(i.to_s)}})./, &:upcase);}

Answer 27

पास्कल, 187 152 बाइट्स

सबसे कुशल या सबसे कम नहीं, लेकिन काफी अच्छी तरह से काम करता है!

uses crt,sysutils;label R;const X:Word=1;P='hello world';begin
R:clrscr;write(P);gotoxy(X,1);write(upcase(P[X]));sleep(999);X:=X*Ord(X<11)+1;goto R
end.

परीक्षण किया गया और फ्री पास्कल कम्पाइलर 2.6+ पर काम करता है।

35 बाइट बचाने के लिए @manatwork का धन्यवाद !

---

मैंने फ़ाइल संकलित करने और इसे विंडोज पर चलाने के लिए http://www.onlinecompiler.net/pascal का उपयोग किया है ।
अब तक इसके साथ कोई समस्या नहीं देखी गई है।

Comments

UpCaseपुराने टर्बो समय से एक फ़ंक्शन मौजूद है। (वहाँ यह केवल संभाला Char, लेकिन फ्री पास्कल में भी तार संभालता है।)

— मैनेटवर्क

मामूली दो टूक: एक्स Word(या Byte) को घोषित करने के लिए पर्याप्त है ; पी बनाओ constतो यह इनिशियलाइज़ेशन वैल्यू से टाइप होता है; अलग-अलग varकीवर्ड से छुटकारा पाने के लिए एक्स को इनिशियलाइज़ कंटिन्यू बनाते हैं (यह सभी पास्कल वेरिएंट में काम नहीं कर सकता है, लेकिन निश्चित रूप से फ्री पास्कल में करता है); ClrScrऊपरी बाएँ कोने में कूदने के लिए उपयोग करें; इसे ifएकल अभिव्यक्ति के साथ बदलें X:=X*Ord(X<11)+1:। pastebin.com/FfaixkES

— मैनटवर्क

मैं वास्तव में नहीं जानता था कि const X:Word=1;P='hello world';और यह const X:Word=1;P='hello world';संभव था। मैंने टर्बो पास्कल 7 पर पास्कल सीखा, जो कि उसके अनुरूप नहीं हो सकता है। और पूरी तरह से भूल गया upcase। आपका बहुत बहुत धन्यवाद!

— इस्माइल मिगुएल

Answer 28

C 120 110 104 96 बाइट्स

f(){char *j,s[]="\rhello world";for(j=s;*++j;*j-=32,printf(s),*j+=32,fflush(0),sleep(‌​1));}

अनप्लग्ड संस्करण

void f()
{
  char *j;
  char s[]="hello world";
  j=s; 

   for (;*j;j++)
   {
      *j-=32;  
       printf(s); // print the string and right after change the same char to lower case
       *j+=32;
      fflush(0);
      sleep(1);
   }

}

@Pakk कुछ बाइट्स, महान विचार को बचाने के लिए धन्यवाद। :)

@Pakk @KarlNapf अपने इनपुट्स के लिए धन्यवाद दोस्तों।

अभी भी छोटा किया जा सकता है !? :)

Comments

का उपयोग करें -=और +=। इसके अलावा, एक पॉइंटर चर भी बचा सकता है []लेकिन मुझे यकीन नहीं है।

— कार्ल नेप

char * j; f () {char s [] = "hello world"; के लिए (j = s; * j; j ++) {* j- = 32; printf ("\ r% s", s); * j + = 32; फ़्लफ़श (0); स्लीप (1);}} (103 वर्ण)

पिछली टिप्पणी के पीछे आइडिया: इसे प्रिंटफ के बाद फिर से कम करें, फिर आपको यह जांचने की जरूरत नहीं है कि क्या j-1 मौजूद है। और कुछ वर्णों को बचाने के लिए पॉइंटर्स का उपयोग करें।

char *j,s[]="hello world";कुछ और चार्ट बचाने के लिए।

f(){char*j,s[]="\rhello world";for(j=s;*++j;*j-=32,printf(s),*j+=32,fflush(0),sleep(1));}89 बाइट्स।

— कार्ल नेफ

Answer 29

पायथन 2, 220 189 179 बाइट्स

तार का उपयोग किए बिना समाधान और capitalize(), बाइट की गिनती इस प्रकार है:

import time,sys
from numpy import *
F=fromstring("\rhello world",int8)
for i in range(1,12):
    time.sleep(1)
    F[i]-=32
    savetxt(sys.stdout,F,fmt="%c",newline="")
    F[i]+=32

और मामला रीसेट किए बिना थोड़ा लंबा संस्करण (191 वर्ण):

import time,sys
from numpy import *
a=arange(11)
F=tile(fromstring("\rhello world",int8),(11,1))
F[a,a+1]-=32
for i in a:
    time.sleep(1)
    savetxt(sys.stdout,F[i],fmt="%c",newline="")

Comments

साइट पर आपका स्वागत है! ऐसा लगता है कि आपने अतिरिक्त व्हाट्सएप किया है। विशेष रूप से अपने समान संकेतों के आसपास

— गेहूं जादूगर

Answer 30

सी ++, 88 125 बाइट्स

#include<iostream>#include<unistd.h>
int main(){for(int c;++c<12;){char a[]="\rhello world";a[c]-=32;std::cout<<a;sleep(1);}}

Ungolfed संस्करण:

#include <iostream>
#include <unistd.h>

int main()
{
   for (int c;++c<12;)
   {
      char a[] = "\rhello world";
      a[c]-=32;
      std::cout << a;
      sleep(1);
   }
}

देव-सी ++ के साथ विंडोज 10 मशीन पर टीडीएम-जीसीसी के साथ संकलित।

संपादित करें: मैं अपने पहले संस्करण में शामिल करना भूल गया।

Comments

अरे, तुम मेरे सी # उत्तर के साथ मेरी मदद करने वाले लड़के हो! आपके C ++ दृष्टिकोण ने मुझे एहसास दिलाया कि मैं वास्तव में गाड़ी की वापसी को स्ट्रिंग की शुरुआत में ले जाकर अपने पाश से उस स्थिति को दूर कर सकताfor हूं .. मैं आपकी भी मदद करूंगा: डूइंग for(int c=1;;c++)आपको 1 बाइट बचाएगा।

— मेटोनीम

जैसा कि आपने मेरे C # उत्तर में सुझाया था, मेरी पिछली टिप्पणी के साथ आप तब कर सकते थे for(int c=1;;)और फिर a[c++]-=32;एक और बाइट को बचाने के लिए।

— मेटोनीम

लेकिन शुरुआत में गाड़ी वापसी के साथ, यह अभी भी एक चरित्र (the मेरे मामले में) को हैलो वर्ल्ड के बाद आउटपुट में प्रिंट करता है, हालांकि मुझे वास्तव में यकीन नहीं है कि क्यों ...

— स्नोफायर

यह ... बल्कि अजीब है। ऐसा नहीं होना चाहिए ?!

— 12