42

एक टर्मिनल पर एक सतत साइनसोइडल तरंग स्क्रॉल को लंबवत रूप से प्रिंट करें। कार्यक्रम को समाप्त नहीं होना चाहिए और लगातार लहर को नीचे स्क्रॉल करना चाहिए (जब तक कि यह किसी तरह बाधित नहीं होता है) को छोड़कर। आप मान सकते हैं कि अतिप्रवाह एक समस्या नहीं है (यानी आप बढ़ते काउंटरों या अनंत पुनरावर्ती के साथ अनंत छोरों का उपयोग कर सकते हैं)।

लहर को निम्नलिखित गुणों को संतुष्ट करना चाहिए:

आयाम = 20 वर्ण (शिखर आयाम)
अवधि = 60 से 65 रेखाएँ (सम्मिलित)
आउटपुट में केवल रिक्त स्थान, न्यूलाइन और शामिल होना चाहिए |
आउटपुट की प्रत्येक पंक्ति के बाद, 50ms के लिए रुकें

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

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

सबसे छोटा कोड जीतता है।

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

code-golf ascii-art kolmogorov-complexity

— ace_HongKongIndependence
स्रोत

1

शिखर आयाम, शिखर-से-शिखर आयाम, या जड़-वर्ग आयाम?

— डेविड

पीक आयाम।

— ace_HongKongIndोसेंडेंस

1

क्या यह सिर्फ और सिर्फ रिक्त स्थान के साथ एक लहर खींचना ठीक है?

— जिलेटिन

1

सभी उत्तर अभी तक अमान्य हैं। वे केवल SIGKILL के लिए ही नहीं SIGKILL के लिए भी रुकते हैं।

— मैक्स राइड

1

@ मोम ने ठीक कहा, मैं इसे "हमेशा के लिए जाना चाहिए जब तक कि अन्यथा बाधित न हो"।

— ace_HongKongInd डिपेंडेंस

12

एपीएल (35)

(हां, यह 35 बाइट्स में फिट है, यहां 1-बाइट एपीएल एन्कोडिंग है )

{∇⍵+⌈⎕DL.05⊣⎕←'|'↑⍨-21+⌈20×1○⍵×.1}1

स्पष्टीकरण:

{... }1: फ़ंक्शन को शुरुआत में 1 के साथ कॉल करें
1○⍵×.1: करने के लिए सरकार के काम के लिए करीब पर्याप्त sin(⍵×π÷30)। ( 1○है sin)।
-21+⌈20: सीमा के लिए सामान्य 1..40और नकारात्मक
'|'↑⍨: Nस्ट्रिंग से अंतिम वर्ण लें '|'(जिसके परिणामस्वरूप |अंत में रिक्त स्थान की एक स्ट्रिंग होती है
⎕←: प्रदर्शित करें
⌈⎕DL.05: 50 एमएस प्रतीक्षा करें और वापस लौटें 1। ( ⎕DLउस समय की राशि लौटाता है जो वास्तव में इंतजार कर रहा था, जो पास होने वाला है 0.05, उस मूल्य को पूरा करता है 1)।
∇⍵+: फ़ंक्शन को फिर से चलाने के 1लिए उस नंबर ( ) को जोड़ें ⍵और चलाएं।

— मारीनस
स्रोत

2

डारन ... मुझे लगा कि त्रिकोणमितीय फ़ंक्शंस प्लस समय की देरी से आप लोग बाहर निकल

— जाएंगे

2

यहाँ एक 33 चार एक:{⎕←'|'↑⍨-⌈20×1+1○⍵⋄∇.1+⍵⊣⎕DL.05}0

— टोबिया

3

@ पात LOL। आपको एपीएल की जांच करनी चाहिए, यह एक नवीनता भाषा नहीं है। यह बहुत पुराना है और दशकों से बड़ी प्रणालियों में उपयोग में है। यह कुछ और की तुलना में काफी अनूठा है। IMHO के प्रतीक इसे और अधिक पठनीय बनाते हैं कि ASCII- केवल व्युत्पन्न (J)

— टोबिया

22

सी, 74 73 70 69 67 अक्षर

67 चरित्र समाधान कई अच्छे विचारों के साथ @ यूगोरेन और अन्य से:

i;main(j){main(poll(printf("%*c|\n",j=21+sin(i++*.1)*20,0),0,50));}

पुनरावृत्ति के बजाय लूप के साथ 69 वर्ण समाधान:

i;main(j){while(printf("%*c|\n",j=21+sin(i++*.1)*20,0))poll(0,0,50);}

लगभग प्रति क्षेत्र। :)

— treamur
स्रोत

1

यह @ इक्का के अपने C उत्तर से प्रेरित था।

— तैनूर

2

मुझे लगता है कि आप 5E4इसके बजाय उपयोग कर सकते हैं 50000।

— मुसीफिल

2

मुझे लगता है कि आप / 10 के बजाय * .1 का उपयोग कर सकते हैं।

— मूला

1

@ मुसिफिल, मैंने भी 5E4 का उपयोग करने के बारे में सोचा था, लेकिन यह पता चला कि यह काम नहीं करता है: संकलक usleep()प्रोटोटाइप दिखाए बिना , आपको स्पष्ट रूप से 5E4 डालना होगा।

— त्रिनूर

2

आप असाइनमेंट को प्रिंट में j में ले जाकर दो और अक्षर काट सकते हैं, जैसे printf("%*s\n",j=21+sin(i++*.1)*20,"|"):। परिणामी प्रकार अभी भी int है इसलिए यह एक मान्य फ़ील्ड चौड़ाई तर्क है।

— आर्ट

12

गणितज्ञ 121 104 80 67 64

n=1;While[0<1,Spacer[70 Sin[n Pi/32]+70]~Print~"|";Pause@.05; n++]

ज्या

— DavidC
स्रोत

प्रश्न कहता है कि इसे प्लॉट करने के लिए गणितज्ञ का उपयोग नहीं करना चाहिए। यह किसी भी तरह से अलग है?

— मलाकी

13

@ मालाची यस। यह किसी भी अन्य उत्तर की तरह, इसे गणना करने के लिए गणित का उपयोग करता है। गणितज्ञ का उपयोग करने की साजिश को गणितज्ञ साजिश x=20*sin(pi*y/30)+20या कुछ इसी तरह बता रहा होगा ।

— जस्टिन

ठीक है मैं आपको जो कुछ भी कह रहा हूं, उसे स्पष्ट करने के लिए धन्यवाद

— मालाची

1

और यहाँ एक 58 चार संस्करण हैDo[Spacer[70*Sin[n*Pi/32]+70]~Print~"|";Pause@.05,{n,18!}]

— Ajasja

1

Im एक गणितज्ञ उपयोगकर्ता नहीं है, लेकिन मुझे लगता है कि आप 1 char को कम 1 == 1करने के 0 < 1लिए बदल सकते हैं ।

— सीसीपी

11

पर्ल, 48 (68)

GNU नींद संस्करण: 48

print$"x(25+20*sin).'|
';$_+=.1;`sleep .05`;do$0

क्रॉस प्लेटफॉर्म: 68

use Time::HiRes"sleep";print$"x(25+20*sin).'|
';$_+=.1;sleep.05;do$0

समय का उपयोग हटा दिया गया: शेल नींद समारोह का उपयोग करके HiRes मॉड्यूल। रूबी उदाहरण के अनुसार छोटा वेतन वृद्धि। प्रिमो के काम से संकेत देखकर $ "और $ 0 का उपयोग करके कम किया गया। प्राइमो के लिए धन्यवाद।

— KevinColyer
स्रोत

मैंने इसे एक फ़ाइल के रूप में सहेजा test.plऔर भाग गया perl ./test.pl, हालांकि प्रतीक्षा समय विनिर्देश से मेल नहीं खाता। साथ ही, तरंग का आयाम बहुत छोटा है। (यह आयाम शिखर और संतुलन की स्थिति के बीच की लंबाई को संदर्भित करता है।)

— ace_HongKongIndependence

मुझे लगता है कि अगर मैंने वेतन वृद्धि को .105 से बदल दिया तो .1 मैं 56 चरों में माणिक को हराऊंगा!

— केविनकोलियर

@प्रिमो - मेरी शेल स्लीप 1 सेकंड से कई गुना कम करती है ...

— केविनकोलियर

man sleep→ unsigned int sleep(unsigned int seconds);। यह त्रुटि नहीं करेगा, लेकिन वास्तविक नींद अंतराल शून्य है। आपको छोटा बनाने के लिए कुछ सुझाव: परिवर्तन $dकरें $_, और फिर उपयोग करें (25+20*sin), और \nएक शाब्दिक नई रेखा के लिए बदलें ।

— प्रिमो

2

@primo man 1 sleepएक जीएनयू / लिनक्स बैश खोल पर कि हमें बताता हैUnlike most implementations that require NUMBER be an integer, here NUMBER may be an arbitrary floating point number.

— ace_HongKongIndependence

11

पर्ल - 64 (या 60) बाइट्स

निम्नलिखित Windows- विशिष्ट शेल कमांड का उपयोग करता है:

`sleep/m50`,print$"x(20.5-$_*(32-abs)/12.8),'|
'for-32..31;do$0

निम्नलिखित एक GNU / लिनक्स-विशिष्ट शेल कमांड का उपयोग करता है:

`sleep .05`,print$"x(20.5-$_*(32-abs)/12.8),'|
'for-32..31;do$0

दोनों 64 बाइट्स पर।

अवधि 64 है।
अधिकतम आयाम बिल्कुल 20 है।
वक्र पूरी तरह से सममित है।
प्रत्येक अवधि समान है।

ध्यान दें कि यह बिल्कुल एक साइनसॉइडल तरंग नहीं है, बल्कि एक द्विघात प्रक्षेप है। एक वास्तविक पाप के खिलाफ साजिश रची:

आवश्यक ग्रैन्युलैरिटी पर, ये नेत्रहीन हैं।

यदि सौंदर्यशास्त्र इतना महत्वपूर्ण नहीं है, तो मैं एक 60 बाइट विकल्प प्रदान करता हूं , जिसकी अवधि 62 की है, अधिकतम आयाम ~ 20.02, और मामूली विषमताएं:

`sleep/m50`,print$"x(20-$_*(31-abs)/12),'|
'for-31..30;do$0

— Primo
स्रोत

यह साइनसोइडल तरंग नहीं है; यह केवल परवलय है (यदि मैं आपका कोड सही पढ़ता हूं)। (यदि आप कुछ साइनसोइडल तरंग के साथ इसका प्रतिनिधित्व कर सकते हैं, तो मैं फ़ंक्शन देखना पसंद करूंगा)।

— जस्टिन

साइन एक फॉर्मूला है, अगर आप फॉर्मूला को दोहराते हैं तो यह अभी भी साइनसोइडल वेव है। और यह शायद कुछ फैशन में साइन का एक प्रकार है।

— मलाकी

8

रूबी 56

i=0
loop{puts" "*(20*Math.sin(i+=0.1)+20)+?|;sleep 0.05}

— daniero
स्रोत

क्या P के साथ पुट की अनुमति है?

— स्लीडपेन

1

@Slicedpan मुझे लगता है कि मैं नहीं करूँगा, क्योंकि यह कुछ आकर्षित करने के लिए एक चुनौती है। pप्रत्येक पंक्ति के चारों ओर दोहरे उद्धरण जोड़ेंगे और "ड्राइंग" को बदल देंगे।

— डेनियरो

7

Befunge 98 - 103 100

:1g:02p' \k:02gk,'|,a,$ff*:*8*kz1+:'<\`*
468:<=?ABDEFGGGHGGGFEDBA?=<:86420.,+)'&$#"!!! !!!"#$&')+,.02

एक प्रोग्राम के लिए चीयर्स जो त्रिकोणमितीय क्षमताओं के बिना एक भाषा में ऐसा करता है; वास्तव में पहला कार्यक्रम। दूसरी पंक्ति केवल डेटा है; पाप के एससीआई मूल्य के अनुरूप चरित्र, एक अंतरिक्ष चरित्र में जोड़ा गया।

संपादित करें: मैंने अंतरिक्ष को न घटाकर 3 वर्णों को बचाया; साइनसॉइड का अनुवाद 32 इकाइयों को दाईं ओर (जो मान्य है) किया जाता है।

Befunge में स्लीप कमांड या कुछ समान नहीं है। एक फिंगरप्रिंट ढूंढना अच्छा होगा, लेकिन मैं एक नहीं ढूंढ सका, इसलिए ff*:*8*धक्का देता है 8*225**2( 405000) और kzएक नोप चलाता है जो कई बार (अच्छी तरह से, कई बार + 1)। Pyfunge के साथ विंडोज़ कमांड लाइन पर , यह लगभग 50 मिलीसेकंड निकला, इसलिए मैं कहता हूं कि मैं अच्छा हूं। नोट: अगर किसी को इसके लिए एक अच्छा फिंगरप्रिंट पता है, तो कृपया मुझे बताएं।

कोड का अंतिम भाग बस जांचता है कि क्या काउंटर (डेटा लाइन के लिए) डेटा अतीत है, यदि यह है, तो काउंटर 0 पर रीसेट हो जाता है।

मैं प्रयोग किया जाता है इस डेटा उत्पन्न करने के लिए।

टेलर श्रृंखला

हालाँकि यह संस्करण 105 वर्णों का है, लेकिन मुझे इसे शामिल करना था:

:::f`!4*jf2*-:::*:*9*\:*aa*:*:01p*-01g9*/a2*+\$\f`!4*j01-*b2*+:01p' \k:01gk,$'|,a,ff*:*8*kz1+:f3*`!3*j$e-

मैं अपने कार्यक्रम को छोटा करने की कोशिश कर रहा था, और कॉशन (साइन की गणना कठिन है) के लिए टेलर श्रृंखला को देखने का फैसला किया । मैं यहाँ अनुरोध की गई अवधि से मिलान xकरने के pi * x / 30लिए बदल गया , फिर 20आयाम से मेल खाने के लिए गुणा किया गया। मैंने कुछ सरलीकरण किए (रद्द करने के लिए समायोजित कारक, बिना फ़ंक्शन के मूल्य को बहुत अधिक बदलकर)। फिर मैंने इसे लागू किया। अफसोस की बात है, यह एक छोटा कार्यान्वयन नहीं है।

:f`!4*jf2*-

जाँचता है कि टेलर श्रृंखला के मान गलत हो रहे हैं (लगभग x = 15)। अगर वे हैं, तो मैं के x - 30बजाय के लिए टेलर श्रृंखला की गणना x।

:::*:*9*\:*aa*:*:01p*-01g9*/a2*+

x = 0जब xस्टैक पर मूल्य है , तो टेलर श्रृंखला का मेरा कार्यान्वयन है ।

\$\f`!4*j01-*

टेलर श्रृंखला के मूल्य की उपेक्षा करता है यदि टेलर श्रृंखला को समायोजन की आवश्यकता होती है।

b2*+

कोसाइन तरंग को सकारात्मक बनाएं; अन्यथा, मुद्रण काम नहीं करेगा।

:01p' \k:01gk,$'|,a,

लहर को छापता है

ff*:*8*kz1+

makeshift 50 मिलीसेकंड के लिए प्रतीक्षा करें, फिर वेतन वृद्धि x

:f3*`!3*j$e-

यदि x45 से अधिक है, तो इसे -14 (फिर, टेलर श्रृंखला त्रुटि समायोजन) में बदलें।

— जस्टिन
स्रोत

यह ठीक उसी तरह का उत्तर है जिसका मुझे इंतजार है, आशा है कि आप इसे नीचे ले जा सकते हैं :)

— ace_HongKongInd डिपेंडेंस

1

वहाँ! मैंने सफलतापूर्वक कोड की लंबाई -5 चार्ट घटा दी है! और अभी भी सुधार की गुंजाइश है!

— जस्टिन

@Quincunx मेरा पर्ल सॉल्यूशन भी ट्रिग फंक्शन्स में निर्मित किसी भी वस्तु का उपयोग नहीं करता है;)

— प्रिमो

6

अजगर, 108,93,90,89, 88

import math,time
a=0
while 1:print" "*int(20+20*math.sin(a))+"|";time.sleep(.05);a+=.1

अब अनंत स्क्रॉल के साथ :)

संपादित करें: ठीक है, 90. पर्याप्त?

संपादित करें: संपादित करें: नहीं, 89।

संपादित करें: संपादित करें: संपादित करें: 88 बूथबी के लिए धन्यवाद ।

— गैब्रिएल डी'अटन
स्रोत

क्षमा करें, यदि मैंने प्रश्न को स्पष्ट नहीं किया है - आपके कार्यक्रम को समाप्त नहीं होना चाहिए और लगातार लहर को नीचे स्क्रॉल करना चाहिए (सिग्नेट को छोड़कर)

— ace_HongKongInd डिपेंडेंस

1

a=0.-> a=0आपको 88

— बूथबीज

5

PHP, 59 अक्षर

<?for(;;usleep(5e4))echo str_pad('',22+20*sin($a+=.1)).~ƒõ;

— एलेक्स बैरेट
स्रोत

1

के echo ...;स्थान पर उपयोग करके आप अपने आप को कुछ बाइट्स बचा सकते हैं fwrite(STDOUT,...);।

— प्रिमो

वैसे भी कमांड लाइन से कॉल करने पर समझ में आता है। 10 पात्रों को बचाया - धन्यवाद प्राइमो।

— एलेक्स बैरेट

1

५ <?for(;;)echo~str_pad(ƒõ,22+20*sin($a+=.1),ß,usleep(5e4));

— प्रिमो

बहुत अच्छा। मैं उन परिवर्तनों के साथ अपने उत्तर को संपादित नहीं करूंगा, आपको अपने अनुसार पोस्ट करना चाहिए।

— एलेक्स बैरेट

1

@ एसी एन्कोडिंग के साथ इसे सहेजने की आवश्यकता है। आइडोन स्वचालित रूप से सब कुछ utf-8 में बदल देता है, जो टूट जाता है। ~ƒõके लिए बस आशुलिपि है "|\n"।

— प्रिमो

4

C64 बुनियादी, 64 PETSCII चार्ट

यहाँ छवि विवरण दर्ज करें

PAL C64 पर, For i=0 to 2:next iलगभग चक्र। 0,05 सेकंड, इसलिए देरी समय का सम्मान किया जाता है।

— गैब्रिएल डी'अटन
स्रोत

3

जावास्क्रिप्ट 88 76 78 अक्षर

setInterval('console.log(Array(Math.sin(i++/10)*20+21|0).join(" ")+"|")',i=50)

केंडल फ्रे के कोड के आधार पर।

— joeytje50
स्रोत

आप कभी भी आरंभ नहीं करते हैं i, इसलिए यह एक लहर के बजाय एक सीधी रेखा को प्रिंट करता है।

— गिली

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

— joeytje50

3

सी - 86 + 3 वर्ण

धन्यवाद शायना और एडिट के लिए जोश

i;main(j){for(;j++<21+sin(i*.1)*20;)putchar(32);puts("|");usleep(50000);i++;main(1);}

मैं; मुख्य (जे) {के लिए (जे = 0; J ++ <20 + sin (मैं / 10) * 20;।) putchar (32), कहते हैं ( "|"); usleep (50000); मैं ++, मुख्य () ;}

~~फ्लोट i; मेन (j) {के लिए (j = 0; j ++ <20 + sin (i) * 20;) putchar (32); put ("|"); usleep (50000); i + =; 1; main; 1; );}~~

-lmध्वज के साथ संकलित , मुझे लगता है कि मुझे 3 वर्ण जोड़ने की आवश्यकता है

— ace_HongKongIndependence
स्रोत

1

क्या यह काम करेगा यदि आपने मुझे एक इंट बना दिया है और इसे केवल पाप से कॉल के भीतर 10.0 (या 9.9 से एक चार्ट को बचाने के लिए?) में विभाजित किया है? i;main(j){for(j=0;j++<20+sin(i/10.0)*20;)putchar(32);puts("|");usleep(50000);i++;main();}

— शियोना

आप लूप को बदलने के लिए आकार को 76 अक्षरों या तो printf("%*s\n",(int)(21+sin(i++/10.)*20),"|")

— प्रिंटफ

1

हम्म ... अगर मैं अपने जवाब में इस विचार का उपयोग करता हूं, तो मैं वास्तव में दोषी महसूस करूंगा, खासकर जब यह मेरा अपना सवाल है ... क्या आप खुद एक जवाब पोस्ट करने पर विचार करेंगे?

— ace_HongKongIndependence 21

ठीक। कर दूँगा। धन्यवाद। :)

— त्रिनूर १६'१४ को

1

आप दो और अक्षरों बंद दाढ़ी कर सकते हैं अगर आप को दूर j=0: i;main(j){for(;j++<21+sin(i/10.)*20;)putchar(32);puts("|");usleep(50000);i++;main(1);}। यह इस धारणा पर निर्भर करता है कि कार्यक्रम को 0 तर्कों के साथ कहा जाता है।

— जोश

3

टीआई-बेसिक, 33 बाइट्स

While 1:Output(8,int(7sin(X)+8),"!":Disp "":π/30+X→X:End

निम्नलिखित चेतावनी मौजूद हैं :

16x8 की स्क्रीन सीमा के कारण, इस साइन लहर में केवल 7 का आयाम है (60 की अवधि अभी भी बनी हुई है)
चर का उपयोग करने का एक आसान तरीका न होने के कारण |, !इसका उपयोग किया जाता है
एक सटीक सिस्टम टाइमर की कमी के कारण देरी लागू नहीं होती है। हालाँकि, रन गति लगभग सही दिखाई देती है।

— माइक क्लार्क
स्रोत

1

हे, चूंकि TI-BASIC की गिनती एक- / दो बाइट टोकन में होती है, यह वास्तव में 33 बाइट्स ("56 वर्ण" नहीं) है, इसलिए इसे वास्तव में चुनौती जीतनी चाहिए थी!

— MI राइट

आयाम की बात को छोड़कर ...

— lirtosiast

ठीक है, हाँ, लेकिन बाइट्स द्वारा जाना ठीक है।

— एमआई राइट

2

जावास्क्रिप्ट - 88

setInterval(function(){console.log(Array(Math.sin(i++/10)*20+21|0).join(" ")+"|")},i=50)

मुझे यकीन है कि कोई ऐसा व्यक्ति हो सकता है जो वास्तव में चतुर है।

— केंडल फ्रे
स्रोत

2

जे - 103,58,5754

IRC के भयानक लोगों के लिए धन्यवाद

(0.1&+[6!:3@]&0.05[2:1!:2~' |'#~1,~[:<.20*1+1&o.)^:_]0

दाएं से बाएं शब्दों में यह पढ़ता है: 0 अनंत समय से शुरू करना: पाप, 1 जोड़ना, 20 से गुणा करना, फर्श, परिशिष्ट 1 (इसलिए यह 2 तत्वों की सरणी बन जाता है), दो बाइट्स कॉपी करें '| तदनुसार, इसे प्रिंट करें, 0.05s प्रतीक्षा करें और 0.1 जोड़ें

अनंत लूप के बजाय हम पुनरावृत्ति का उपयोग कर सकते हैं, यह 2 वर्णों को बचाएगा, लेकिन कुछ पुनरावृत्तियों के बाद भी स्टैक त्रुटि उत्पन्न करेगा

($:+&0.1[6!:3@]&0.05[2:1!:2~' |'#~1,~[:<.20*1+1&o.)0

जहां $:एक पुनरावर्ती कॉल है।

— बेंत की मार
स्रोत

क्या आप थोड़ा स्पष्टीकरण जोड़ना चाहेंगे, ताकि जे सिंटैक्स (मेरे जैसे) से अपरिचित लोग भी आपके उत्तर को समझ सकें?

— ace_HongKongInd डिपेंडेंस

ट्रेन की संरचना के बारे में उपद्रव करके इसे 50 वर्णों तक छोटा करना संभव है (+2*(%20)6!:3@[2:1!:2~' |'#~1,~[:<.20*1+1&o.)^:_]0:। पुनरावृत्ति संस्करण केवल इस बार 1 चार्ज बचाता है, $:@(+2*(%20)6!:3@[2:1!:2~' |'#~1,~[:<.20*1+1&o.)0हालांकि यह बाहर तलने से पहले लंबे समय तक चलता है।

— एल्गोरिथमशार्क

2

हास्केल - 75

main=putStr$concat["|\n"++take(floor$20+20*sin x)(repeat ' ')|x<-[0,0.1..]]

दुर्भाग्य से, मैं अपने चार गिनती को दोगुना किए बिना 50 एमएस को रोकने के लिए कार्यक्रम नहीं प्राप्त कर सका, इसलिए यह सिर्फ कंसोल को बाढ़ देता है, लेकिन यह साइन लहर का उत्पादन करता है।

यहाँ रुकने के साथ पूर्ण कोड (नई रूपरेखा के साथ 138 अंक):

import GHC.Conc
import Control.Monad
main=mapM_(\a->putStr a>>threadDelay 50000)(["|\n"++take(floor$20+20*sin x)(repeat ' ')|x<-[0,0.1..]])

— ज़ाक़
स्रोत

2

रोकना आवश्यकताओं में से एक था। क्या आप विराम के साथ कोड भी पोस्ट कर सकते हैं?

— जस्टिन

ठीक है, मैंने इसे पोस्ट किया। मैं चाहता हूं कि हास्केल आपको आयात के बिना कोड को रोक दें।

— जक

आयाम से मेरा मतलब है शिखर आयाम, यानी आपके वर्तमान कार्यक्रम का दो बार आयाम। आप 20+20*sin xअर्हता प्राप्त करने के बजाय इसे बदलने की इच्छा कर सकते हैं।

— ace_HongKongIndependence

हा ज़रूर। मुझे लगता है कि मैंने सवाल के उस हिस्से की गलत व्याख्या की है।

— ज़ाक

2

पर्ल 6: 46 चार्ट

sleep .05*say ' 'x(25+20*.sin),'|'for 0,.1...*

0,0.1 ... *उस पर लूप का उपयोग करके एक असीम आलसी रेंज बनाएं । sayरिटर्न Bool::Trueजो गुणा के रूप में 1 के रूप में होता है, इस तरह से मैं इसे एक बयान में रख सकता हूं।

— Ayiko
स्रोत

मैं देख सकता हूं कि क्यों sleepऔर .05अलग होना पड़ता है। लेकिन मुझे आश्चर्य है अगर बीच की जगह sayऔर ' 'अनिवार्य है?

— मत्तीस

हाँ: यह एक पंक्ति में "2 शर्तें देता है" एक के लिए त्रुटि का say' 'उपयोग कर सकते हैं, say(' ')लेकिन यह इस मामले में 1 चार अतिरिक्त है ...

— 18

1

@ मैथियास: पर्ल 6 में, लिस्टॉप्स में या तो बहस नहीं करनी होती है, उनके बाद एक जगह होती है या कोष्ठक का उपयोग करना होता है। यह पर्ल 5 के विपरीत, कोड गोल्फ के लिए डिज़ाइन की गई भाषा नहीं है (लेकिन इसमें कई अच्छी बिलियन विशेषताएं हैं, इसलिए यह प्रयोग करने योग्य है)।

— कोनराड बोरोस्की

@xfix स्पष्टीकरण के लिए धन्यवाद। मुझे भाषा पसंद है, लेकिन मैंने इसे अभी तक पूरी तरह से नहीं देखा है, क्योंकि मैं अभी भी एक कार्य परियोजना में इसका उपयोग नहीं कर सकता हूं। हालांकि, मैं हमेशा कुछ पर्ल 6 स्क्रिप्ट लिखने की योजना बनाता हूं। @ Ayiko, मैं आपके पर्ल 6 पोस्ट की सराहना करता हूं :-)

— Matthias

2

_fugly जावास्क्रिप्ट - 77

i=setInterval("console.log(Array(Math.sin(i+=.1)*20+20|0).join(' ')+'|')",50)

और अगर हम फ़ायरफ़ॉक्स में करते हैं - 73

i=setInterval("console.log(' '.repeat(Math.sin(i+=.1)*20+20|0)+'|');",50)

और अगर हम बुरा कर रहे हैं - 67

i=setInterval("throw(' '.repeat(Math.sin(i+=.1)*20+20|0)+'|');",50)

— eithed
स्रोत

1

स्काला, 92,89, 87

def f(i:Int){println(" "*(20+20*math.sin(i*.1)).toInt+"|");Thread sleep 50;f(i+1)};f(1)

— ValarDohaeris
स्रोत

(20+20*math.sin(i*.1))इसे 1 char से कम करता है, यह मानते हुए कि यह सिंटैक्स है (मुझे Scala के साथ कोई अनुभव नहीं है)

— ace_HongKongInd डिपेंडेंस

धन्यवाद, लेकिन मुझे अभी पता चला है कि खुद :)

— वालरडोहेरिस

1

अजगर 3, 103

बेवकूफ frikk'n आयात ...

import time,math
t=0
while 1:t+=(.05+t<time.clock())and(print(' '*int(20+20*math.cos(t*1.9))+'|')or.05)

"नींद" के बजाय, यह कार्यान्वयन सीपीयू में पीसता है, क्योंकि अजगर दीवार घड़ी की तुलना में फ्लोटिंग-पॉइंट सीपीयू घड़ी प्राप्त करना आसान बनाता है। यह दृष्टिकोण फ्रॉल्स को हरा नहीं पाएगा , लेकिन यह मजेदार है इसलिए मैं इसे छोड़ रहा हूं।

— boothby
स्रोत

1

सी#

[१५२] वर्ण

namespace System{class P{static void Main(){for(var i=0d;;){Console.Write("{0,"+(int)(40+20*Math.Sin(i+=.1))+"}\n",'|');Threading.Thread.Sleep(50);}}}}

मुझे रनिंग का मौजूदा C # उत्तर नहीं मिला और मैं डाउनवोट नहीं हो सका क्योंकि मेरे पास पर्याप्त प्रतिष्ठा नहीं है

यह एक जोड़े को याद कर रहा था {और )फॉर लूप घोषणा के बाद गायब था ।

मैं समझती हूं कि जब इसे चलाया जाता है तो लहर के लुक में विचरण होता है क्योंकि जिस तरह से हम इस लहर को प्रदर्शित करने की कोशिश कर रहे हैं।

अगर हम नेमस्पेस और विधि घोषणा की गिनती नहीं कर रहे हैं, तो यह काम करने वाले संस्करण के लिए [104] अक्षर होंगे

for(var i=0d;;){Console.Write("{0,"+(int)(40+20*Math.Sin(i+=.1))+"}\n",'|');Threading.Thread.Sleep(50);}

— मालाची
स्रोत

अन्य C # उत्तर gmcs पर काम करता है। यह पहली बार में संकलन करने में विफल रहता है, लेकिन मुझे लगता है कि ऐसा इसलिए है क्योंकि स्रोत कोड में कुछ गैर-मुद्रण योग्य चरित्र है। एक खाली फाइल पर फिर से टाइप करने के बाद, संकलन सफल होता है।

— ace_HongKongIndependence

संकलक picky हो सकता है, है ना?

— मलाची

1

वीबी [236] [178]

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

Module Module1
Sub Main()
Dim i
While True
Console.WriteLine("{0:" & (40 + 20 * Math.Sin(i = i + 0.1)) & "}", "|")
Threading.Thread.Sleep(50)
End While
End Sub
End Module

— मालाची
स्रोत

1

सी#

मैजिक लाइन [91] वर्ण

for(var i=0d;;Console.Write("{0,"+(int)(40+20*Math.Sin(i+=.1))+"}\n",'|'))Thread.Sleep(50);

नीचे काम कर रहे कार्यक्रम। [१४।] वर्ण

namespace System{class P{static void Main(){for(var i=0d;;Console.Write("{0,"+(int)(40+20*Math.Sin(i+=.1))+"}\n",'|'))Threading.Thread.Sleep(50);}}}

— जॉन क्लियरज
स्रोत

क्षमा करें, यदि मैंने प्रश्न को स्पष्ट नहीं किया है - तो आपके कार्यक्रम को समाप्त नहीं होना चाहिए और निरंतर रूप से लहर को नीचे स्क्रॉल करना चाहिए (सिग्नेट को छोड़कर)। इसके अलावा, कृपया एक वर्ण गणना जोड़ें।

— ace_HongKongIndependence 20

क्षमा करें उस बिट के बारे में भूल गए। अब तय हो गया।

— जॉन क्लियरज

मुझे लगता है कि आप "Thread.Sleep" को खो सकते हैं और var के साथ "float" बदल सकते हैं :) 117 chars। - क्षमा करें, प्रतीक्षा समय नहीं देखा था।

using System;class P{static void Main(){for(var i=0d;;Console.Write("{0,"+(int)(40+20*Math.Sin(i+=.1))+"}\n",'|'))Thread.Sleep(50);}}

— मेदनी बायकाल

1

मैं इसे VS2010 में संकलित नहीं कर सकता Threading.Thread.Sleep(50)हूँ क्या मैं कुछ गलत कर रहा हूँ?

— मलाकी

1

मैं इसे चलाने में सक्षम था, लेकिन मुझे कुछ ब्रैकेट्स और सेमी-कॉलन्स को जोड़ना पड़ा और यह हर पीरियड एक जैसा नहीं लगता

— मालाची

1

बाश + बीसी (गणित करने के लिए), (०

$ for((;;i++)){ printf "%$(bc -l<<<"a=20*s($i/10);scale=0;a/1+20")s|
";sleep .05;}
                |
                 |
                   |
                     |
                       |
                         |
                           |
                            |
                              |
                               |
                                |
                                 |
                                  |
                                   |
                                   |
                                   |
                                   |
                                   |
                                   |

— डिजिटल आघात
स्रोत

1

टीआई-बेसिक, 30 बाइट्स

कुछ सटीकता की कीमत पर, अन्य उत्तर पर छोटे आकार में सुधार। ध्यान दें कि TI-Basic तकनीकी रूप से | चरित्र, लेकिन आपको इसे कंप्यूटर पर स्थानांतरित करना होगा या इसे एक्सेस करने के लिए असेंबली प्रोग्राम का उपयोग करना होगा।

While 1
Output(8,int(8+7sin(Ans)),":
Disp "
.03π+Ans
End

— एमआई राइट
स्रोत

वाह, यह चुनौती कितनी पुरानी थी, यह नहीं देखा! यह और अधिक गोल्फ (जो निश्चित रूप से संभव है) करने की कोशिश करने जा रहा था, लेकिन यह वास्तव में इसके लायक नहीं है ...

— एमआई राइट

वैसे, .03πहो सकता है .1, जो अभी भी आवश्यक अंतराल के भीतर है।

— lirtosiast

अच्छा कैच, धन्यवाद! क्या आप किसी भी तरह से देख सकते हैं कि मैं आउटपुट कमांड को गोल्फ कर सकता हूं? इसके अलावा, चूंकि मेरे पास एक सीएसई है, इसलिए मुझे कुछ बाइट्स की कीमत पर यह सही आयाम (26-चार स्क्रीन) में मिल सकता है।

— MI राइट

नहीं, आउटपुट कमांड ठीक दिखता है - बहुत बुरा है Disp को एक उद्धरण की आवश्यकता है। आयाम को 20 वर्ण होना चाहिए, वास्तव में, स्क्रीन की चौड़ाई 39 की आवश्यकता होती है। इसलिए यह केवल ग्राफ स्क्रीन पर काम करेगा, और ऐसा करने का कोई छोटा तरीका नहीं है।

— lirtosiast

1

जूलिया - 68

संपादित करें: एमएल और इक्का के लिए धन्यवाद।

i=0;while 0<1;println(" "^int(20sin(.1i)+20)*"|");i+=1;sleep(.05)end

खैर, यह बनाम एपीएल का मुकाबला नहीं कर सकता है, लेकिन यहां मेरा प्रयास है।

आउटपुट:

— सीसीपी
स्रोत

1

मैं जूलिया को नहीं जानता, लेकिन क्या इसके .05बजाय इसका उपयोग करना संभव 0.05है sleep?

— ace_HongKongInd डिपेंडेंस

वास्तव में हाँ! धन्यवाद

— सीसीपी

यह कटौती करने 68 वर्ण : i=0;while 0<1;println(" "^int(20sin(.1i)+20)*"|");i+=1;sleep(.05)end--- sin(i/10)*20के बराबर है20sin(.1i)

— एमएल

मैं जूलिया को नहीं जानता, लेकिन क्या आप इसके बजाय सभी प्राकृतिक नंबरों पर लूप के लिए उपयोग कर सकते हैं?

— lirtosiast

1

MATLAB, 81 बाइट्स

t=0;while(fprintf('%s\n',i))i=[];t=t+1;i(fix(21+20*sind(t*6)))='|';pause(.05);end

मैंने इस तथ्य का दुरुपयोग किया है कि iहमेशा MATLAB में आरंभीकृत किया जाता है, जिसका अर्थ है कि मैं पहले बयान के बिना बयान fprintfमें डाल सकता हूं । इसका मतलब यह है कि कार्यक्रम पहले एक खाली लाइन आउटपुट करता है, लेकिन मुझे लगता है कि यह कल्पना में निषिद्ध नहीं है।whilei

इसके अलावा, यह इस तथ्य का दुरुपयोग करता है कि मतलब सबसे अधिक ASCII नियंत्रण वर्णों की अनदेखी करेगा, NULL (पहली खाली लाइन के लिए भी) के बजाय एक स्थान प्रिंट कर रहा है।

— Sanchises
स्रोत

"मैंने इस तथ्य का दुरुपयोग किया कि मुझे हमेशा MATLAB में आरंभीकृत किया जाता है, जिसका अर्थ है कि मैं पहले बयान के बिना मैं पहले बयान में फ़र्ज़ीफ़ को लगा सकता था।" वास्तव में चतुर! +1!

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

0

एफ # - 90 79 77 76

यहाँ एक समाधान है पुनरावृत्ति का उपयोग करते हुए

let rec f x=printfn"%*c"(int(20.*sin x)+21)'|';Thread.Sleep 50;f(x+0.1)
f 0.

शायद इसे और बेहतर बनाया जा सके।

— pswg
स्रोत

F # के बारे में कुछ भी जाने बिना, मैं मान रहा हूं कि Thread.Sleep एमएस में एक मूल्य की उम्मीद करता है, इसलिए आप 0 में से किसी एक से छुटकारा पा सकते हैं और Thread.Sleep 50 कर सकते हैं। :)

— ValarDohaeris

@ValarDohaeris तुम सही हो। मैंने आवश्यकताओं को गलत बताया।

— pswg

0

ऑटोहॉटकी 176

SetKeyDelay,-1
run Notepad.exe
WinWaitActive, ahk_class Notepad
p:=0
loop
{
sleep 50
p+=Mod(Floor(A_index/40),2)?-1:1,t:=""
loop % p
t .= " "
sendinput % t "|`n"
}
esc::Exitapp

स्क्रिप्ट चलाएँ। यह नोटपैड खोलता है और पात्रों को प्रिंट करता है। बाहर निकलने के लिए कभी भी Esc दबाएँ।

— एवी
स्रोत

0

क्लोजर, 121

लघु संस्करण:

(loop[a 0](println(clojure.string/join(repeat(int(+ 20 (* 20 (Math/sin a)))) " ")) \|)(Thread/sleep 50)(recur(+ a 0.1)))

सुंदर संस्करण:

(loop [a 0]
  (println (clojure.string/join (repeat (int (+ 20 (* 20 (Math/sin a)))) " ")) \|)    
  (Thread/sleep 50)
  (recur(+ a 0.1)))

अवधि 64 है।

इसे टाइप करें lein replया फाइल में सेव करें sin.cljऔर चलाएं lein exec sin.clj(लेइन-एग्जाम्पल की आवश्यकता होती है)।

— ctrlrsf
स्रोत

साइनसोइडल वेव (लंबवत) प्रिंट करें

एपीएल (35)

सी, 74 73 70 69 67 अक्षर

गणितज्ञ 121 104 80 67 64

पर्ल, 48 (68)

पर्ल - 64 (या 60) बाइट्स

रूबी 56

Befunge 98 - 103 100

टेलर श्रृंखला

अजगर, 108,93,90,89, 88

PHP, 59 अक्षर

C64 बुनियादी, 64 PETSCII चार्ट

जावास्क्रिप्ट 88 76 78 अक्षर

सी - 86 + 3 वर्ण

जावास्क्रिप्ट - 88

जे - 103,58,5754

हास्केल - 75

पर्ल 6: 46 चार्ट

स्काला, 92,89, 87

अजगर 3, 103

सी#

वीबी [236] [178]

सी#

बाश + बीसी (गणित करने के लिए), (०

टीआई-बेसिक, 30 बाइट्स

जूलिया - 68

MATLAB, 81 बाइट्स

एफ # - 90 79 77 76

ऑटोहॉटकी 176