एक एकल पिक्सेल एक परिपत्र पथ में घूम रहा है


45

यह एक चित्रमय आउटपुट चुनौती है जहाँ कार्य प्रति भाषा में सबसे छोटा कोड देना है ।

कार्य

आपके कोड को एक एकल बैंगनी पिक्सेल (हेक्स मान # 800080 या आरजीबी (128, 0, 128)) की साजिश रचनी चाहिए, एक सर्कल में गोल-गोल घूमते हुए। पूरी यात्रा को गोल बनाने के लिए ठीक 60 सेकंड का समय लेना चाहिए और अनिश्चित काल तक जारी रहना चाहिए। पिक्सेल के अलावा स्क्रीन या विंडो पर कुछ और नहीं दिखाया जाना चाहिए। सर्कल की चौड़ाई 0.75 (उपयुक्त रूप से गोलाई) स्क्रीन या खिड़की की चौड़ाई और पृष्ठभूमि सफेद होनी चाहिए। मूर्खतापूर्ण समाधानों को रोकने के लिए, स्क्रीन या विंडो कम से कम 100 पिक्सेल चौड़ी होनी चाहिए।

आपका कोड एक पूर्ण कार्यक्रम होना चाहिए ।

भाषा और पुस्तकालय

आप अपनी पसंद की किसी भी भाषा या लाइब्रेरी का उपयोग कर सकते हैं। हालाँकि, यदि संभव हो तो मैं आपके कोड का परीक्षण करने में सक्षम होना चाहूंगा ताकि यदि आप इसे उबंटू में चलाने के लिए स्पष्ट निर्देश प्रदान कर सकें तो यह बहुत सराहनीय होगा।

शीर्ष बीस भाषाओं को याद कर रहा है। मदद की आवश्यकता।

निम्नलिखित शीर्ष बीस प्रोग्रामिंग भाषाएं वर्तमान में सभी समाधानों को याद कर रही हैं।

  • सी , सी ++, सी # , पायथन , पीएचपी , विज़ुअल बेसिक .NET , पर्ल, डेल्फी / ऑब्जेक्ट पास्कल, असेंबली , ऑब्जेक्टिव-सी , स्विफ्ट, पास्कल, मैटलैब / ऑक्टेव , पीएल / एसक्यूएल, ओपनडेज एबीएल, आर

सूची

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से सूची बनाता है) क) प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes


1
सर्कल क्या त्रिज्या होना चाहिए?
टिमोथी ग्रोट

19
पिक्सेल बैंगनी क्यों होना चाहिए? मैं रंग क्षमताओं की जरूरत नहीं है, जिसका अर्थ है कि वे एक बहुत abitrary कारण के लिए चुनौती के लिए नहीं किया जा सकता TI-बेसिक जैसे कुछ भाषाओं ग्रहण करेंगे
Fatalize

1
@ इसका मतलब यह है कि बाइट्स को बचाने के लिए आप कुछ चालाक रचनात्मक तरीके से कार्यक्रम में रंग नहीं डाल सकते।
टिमोथी ग्रोट

3
@ टिमोथीग्रोट TI-BASIC में मुख्य रूप से केवल एक ही रंग है: काला। बाकी सब कुछ एक पिक्सेल है। सी (एसई) कैलकुलेटर हैं जिनके रंग हैं, लेकिन सभी में एक नहीं है।
कॉनर ओ'ब्रायन

10
मुझे यकीन है कि आपकी स्क्रीन पर एक बैंगनी सेलोफ़ेन डालने से बाइट्स में आपके कोड का आकार नहीं जुड़ता। मेरा मतलब है कि यह vectrex काम करता है;)
तीमुथियुस Groote

जवाबों:


23

प्रसंस्करण , 101 97 96 बाइट्स

4 बाइट्स फ्लैम्बिनो के लिए धन्यवाद।

क्रेटी लिथोस को 1 बाइट।

float d;void draw(){background(-1);stroke(#800080);d+=PI/1800;point(50+cos(d)*38,50+sin(d)*38);}

यह आवश्यक एनीमेशन के साथ एक डिफ़ॉल्ट 100 बाय 100 पिक्सेल विंडो बनाता है।

आउटपुट विंडो

अस्वीकरण: वह छवि GIF नहीं है। एक मिनट के लिए इसे घूरो मत।


2
क्या यह 60 सेकंड के नियम को लागू करता है?

2
@ लिम्बिक हाँ। डिफ़ॉल्ट फ़्रैमरेट 60 एफपीएस है , और मैं π/1800एक समय में कोण रेडियन बढ़ा रहा हूं । ( π/3600मेरे मस्तिष्क के
मस्से के

5
@ Pietu1998 यह दिमागी लड़ाई इस तथ्य के कारण थी कि पीआई गलत है
क्रंचर

2
@ क्रंचर गोटा लव वी हार्ट!
टिम

17
अरे, आपका जीआईएफ काम नहीं कर रहा है, मैंने एक मिनट के लिए इसे देखा लेकिन कुछ नहीं हुआ
बीटा डिके

16

QB64, 79 बाइट्स

QB64 एक QBasic एमुलेटर है जो कुछ अच्छी सुविधाओं को जोड़ता है। यह प्रोग्राम एक ( CLS,15) का उपयोग करता है जो वैनिला क्यूबेसिक द्वारा समर्थित नहीं है।

SCREEN 7
DO
T=TIMER/9.55
PSET(COS(T)*75+99,SIN(T)*75+99),5
PLAY"c8"
CLS,15
LOOP

यह बहुत जोर से है। यह PLAYस्क्रीन को साफ़ करने से पहले थोड़ी देर के लिए निष्पादन को रोकने के लिए कमांड का उपयोग करता है ; अन्यथा पिक्सेल झिलमिलाहट और अदृश्य हो जाएगा।

QB64 डाउनलोड करें , इस फ़ाइल को लोड करें, क्लिक करें Runऔर फिर Start

यहाँ यह कार्रवाई में है:

कार्यक्रम

मैं (कुछ चाल ले लिया SCREEN 7बजाय SCREEN 13, और PSETके बजाय POKE,) से @ DLosc का जवाब तो क्रेडिट कारण है। जैसा कि उनके जवाब में, मेरा मैजेंटा वास्तव में है #8B008B, जिसे ओपी द्वारा स्वीकार्य माना गया था।

(स्थिरांक 9.55का एक अनुमान है 30/π = 9.54929658551। क्या यह काफी करीब है?)


हा! PLAYदेरी के लिए उपयोग करने के बारे में कभी नहीं सोचा । शपथ ली थी कि एक कोड बाकी के लिए था, लेकिन मैं इसे अब मदद फ़ाइल में नहीं देख रहा हूं। मैंने TIMERपैरामीटर के रूप में (एक फ़ंक्शन) का उपयोग करने पर विचार किया , लेकिन कभी यह देखने की कोशिश नहीं की कि क्या वह छोटा था। कुडोस!
DLosc

4
धन्यवाद! मैं बेशर्मी PSETसे आपसे दूर हो गया, इसलिए कुदोस वापस :) ऐसा लग रहा है कि एक विश्राम बाकी है, n0जो इससे लंबा है c। इसके अलावा, मैं इसे नियम-झुकने के एक बिट के रूप में पसंद करता हूं: ओपी ने कहा कि खिड़की में कुछ और नहीं दिखाया जा सकता है, लेकिन कभी नहीं कहा कि मेरा कार्यक्रम जोर से बीप बीप बीप पर नहीं जा सकता ।
लिन

1
मेरे पास बीप्स के खिलाफ कुछ भी नहीं है, लेकिन जब मैं लिनक्स में कोशिश करता हूं तो मैं वास्तव में एक सर्कल के चारों ओर घूमते हुए पिक्सेल नहीं देख सकता।

1
यहां यह मेरी मशीन पर कार्रवाई में है, जो पर्याप्त सबूत होना चाहिए।
लिन

12
मैंने थोड़ी देर के लिए छवि को देखा, क्योंकि आपने कहा था "यहां यह कार्रवाई में है "।
mbomb007

14

जावा, 449 443 439 बाइट्स

क्योंकि मेरे पास हमेशा बेवकूफ विचार थे। जावा में गोल्फिंग की तरह;)।

import java.awt.*;import javax.swing.*;class F extends JFrame{F()throws Exception{setContentPane(new P());setSize(400,400);setVisible(0<1);for(;;Thread.sleep(100))repaint();}class P extends JPanel{double c;public void paintComponent(Graphics g){g.setColor(new Color(8388736));c=(c-0.1)%60;double t=0.104*c;g.fillRect((int)(180+Math.sin(t)*120),(int)(180+Math.cos(t)*120),1,1);}}public static void main(String[]x)throws Exception{new F();}}

संपादित करें: 7 बाइट्स गोल्फिंग के लिए @Ypypypn के लिए धन्यवाद!

Edit2: @ बर्ट डी के लिए 3 बाइट्स बचाने के लिए धन्यवाद!


7
जावा अब तक का सबसे लंबा

1
- आपको सदस्य चर को शून्य करने की आवश्यकता नहीं है, इसलिए आप "c = 0" को "c" में परिवर्तित करके दो बाइट्स (~ 0.45%) बचा सकते हैं।
फ्रांज डी।

1
और आप हेक्स में रंग को इनिशियलाइज़ करके एक और बाइट बचा सकते हैं, अर्थात नया कलर (0x800080)।
फ्रांज डी।

1
@FranzD। इससे भी बेहतर - बस दशमलव संख्या का उपयोग करें 8388736
य्प्निपन

1
छुटकारा पाएं JFrame, उपयोग करें Frame, आपको javax आयात को हटाने की अनुमति देता है।
मैजिक ऑक्टोपस Urn

14

गणितज्ञ, 102 101 94 बाइट्स

Animate[Graphics[{White,Disk[],{Purple,Point[{0,1}]}}~Rotate~-t],{t,0,2π},DefaultDuration->60]

एक सफेद सर्कल बनाता है जो छिपा हुआ है और एक बिंदु रखता है जो 0 से 2 that तक इसके किनारे का अनुसरण करता है। Mathematica का DefaultDurationविकल्प आइए मैं इसे हर 60 सेकंड में एक लूप पूरा करने के लिए सेट करता हूं।

यहां आउटपुट का स्पेड अप संस्करण है:

संपादित करें: 2 वर्णों को बचाने के Circleलिए बदलें Disk, tइसे दक्षिणावर्त स्थानांतरित करने के लिए एक नकारात्मक संकेत जोड़ा गया ।

संपादित करें: ~ऑपरेटर (मौरिस के लिए धन्यवाद) का उपयोग करके 7 बाइट्स सहेजे गए ।


14
आगे प्रमाण है कि मैथेमेटिका सिर्फ एक प्रोग्रामिंग भाषा है जहाँ आप कुछ अस्पष्ट अंग्रेजी शब्द लिखते हैं जो इस तरह का अर्थ चाहते हैं कि आप चाहते हैं, तो विराम चिह्न जोड़ें। (मैंने सुना है कि आप a~f~bइसके बजाय उपयोग कर सकते हैं f[a,b], जो आपके Rotateछोटे नहीं करेगा ?)
लिन

1
आप इसके लिए उपसर्ग संकेतन का भी उपयोग कर सकते हैं Point@{0,1}और मुझे नहीं लगता कि आपको सूची की आवश्यकता है Purple,Point...
मार्टिन एंडर

1
@Mauris। अप्रशिक्षित आंख के लिए, गणितज्ञ वास्तव में अस्पष्ट अंग्रेजी शब्दों और विराम चिह्नों की तरह लग सकता है। वास्तव में, वे विशिष्ट, अच्छी तरह से परिभाषित कार्यों, सेटिंग्स और ऑपरेटरों के नाम हैं। संभावना है कि एक गैर-प्रोग्रामर वर्कआउट कोड को स्पिन कर सकता है।
डेविड

3
@ डेविड: हाहा, बेशक मैं जानता हूँ - मैं सिर्फ मजाक कर रहा था :)
लिन

@ मौरिस, तुमने मुझे बेवकूफ बनाया!
डेविड 10

14

HTML, 235 290 295 354 347 बाइट्स

<a><style>*{position:absolute;margin:0;box-sizing:border-box}body{height:100vh;width:100vh}a{left:12.5%;top:50%;width:75%;height:1px;border-left:1px solid purple;animation:r 60s infinite linear}@keyframes r{100%{transform:rotate(360deg

एक .htmlफ़ाइल के रूप में सहेजें और ब्राउज़र में खोलें, जिसमें क्रोम या फ़ायरफ़ॉक्स जैसे विक्रेता उपसर्गों की आवश्यकता नहीं है। या इस फील को आजमाएं ।


यह एक नया संस्करण है जो मेरे पहले प्रयास की तुलना में छोटा है, जिसे मैंने एक बैठक से 5 मिनट पहले लिखा था। कैनवास का नया आकार व्यूपोर्ट ऊंचाई पर आधारित एक वर्ग है। यह बहुत अच्छा काम करता है और एक निश्चित परिभाषित ऊंचाई तक सीमित नहीं है। मैं चुनौती में सेटिंग्स के बारे में बहुत सटीक हूं (इसके मूल, बैंगनी और 1px का 75% आकार)। इसलिए मुझे निम्नलिखित नियमों को त्यागने या सरल करने की आवश्यकता है:

* { margin: 0; box-sizing:border-box; }
a { left: 12.5%; }

Ungolfed

यह साफ मार्कअप के साथ ungolfed संस्करण है:

<!DOCTYPE html>
<html>

<head>
    <style>
        * {
            position: absolute;
        }

        body {
            margin: 0;
            height: 100vh;
            width: 100vh;
        }

        a {
            left: 12.5%;
            top: 50%;
            width: 75%;
            height: 1px;
            border-left: 1px solid purple;
            box-sizing: border-box;
            animation: r 60s infinite linear;
        }

        @keyframes r {
            100%{
                transform: rotate(360deg)
            }
        }
    </style>    
</head>
<body>
    <a></a>
</body>

संपादित करता

  • 7 बाइट्स जोड़े । मैंने सोचा कि कोई भी नोटिस नहीं करेगा, कि एनीमेशन पर एक डिफ़ॉल्ट सहजता है। ;) मैंने इसे linearअभी सेट कर दिया है।
  • सहेजे गए 59 बाइट्स बीच में बंद करें कि ब्राउज़र अपने आप को संभाल लेंगे सब कुछ फेंक कर।
  • ट्रेलिंग को हटाकर 3 बाइट्स को बचाया)}}टूथब्रश के लिए धन्यवाद ।
  • सहेजा 2 बाइट्स का उपयोग करके 12%बजाय 12pxजो एक ही मूल्य माता पिता तत्व के आकार के लिए इसी है।
  • सहेजे गए 55 बाइट्स बड़े पैमाने पर पुनर्रचना की वजह से, को भी ध्यान में टिप्पणी की एक बहुत कुछ ले लिया। सभी योगदानों के लिए बहुत बहुत धन्यवाद।

1
मैं सिर्फ पोस्ट पर टिप्पणी करना चाहता था, मैं एक शुद्ध html / css समाधान देखना चाहता हूं (एक सबमिट करने के लिए ty)
dwana

1
फिडेल का उपयोग करके गतिमान पिक्सेल की गति बहुत असमान होती है। जब पिक्सेल बाईं तरफ होता है तो यह लगभग रुक जाता है। कोई विचार क्यों?

1
@insertusernamehere :) मुझे लगता है कि अनगुल्ड संस्करण को भी अब अपडेट करने की आवश्यकता है।

5
आपको वैधता के बावजूद सबसे छोटे कामकाजी कोड के लिए जाना चाहिए। ग्लोबल नेमस्पेस को प्रदूषित करने जैसी चीजें गोल्फ कोर्स करते समय बराबर होती हैं।
जॉन ड्वोरक

2
आप )}}अंत से ड्रॉप कर सकते हैं (सीएसएस पार्सर स्वचालित रूप से ब्लॉकों को समाप्त कर देगा)
टूथब्रश

14

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

TI-84 + CSE / CE कैलकुलेटर के लिए, जो कुछ सीमित BASIC रंगीन ग्राफिक्स का समर्थन करते हैं।

AxesOff
ZSquare
While rand
Pt-Off(imag(Ans),real(Ans
7.5e^(-i6startTmr°
Pt-On(imag(Ans),real(Ans),13
End

यहाँ रंग मैजेंटा है, या रंग 13 (एक MAGENTAटोकन का उपयोग भी कर सकते हैं )।

जब पिक्सेल प्रदर्शित होता है और जब इसे फिर से बंद कर दिया जाता है, तो मैं थोड़ी सी देरी (~ 15 एमएस) प्रदान करने के लिए अनंत लूप स्थिति के randबजाय उपयोग करता हूं 1

इस कार्यक्रम को चलाने से पहले अपने कैलकुलेटर को रेडियन मोड पर सेट करें; मैं इसे आकार में नहीं गिनता क्योंकि यह डिफ़ॉल्ट स्थिति है। Ansकार्यक्रम से पहले 0 दर्ज करके भी 0 पर सेट करें; यह भी डिफ़ॉल्ट है।

इस कार्यक्रम के परीक्षण के लिए @quartata के लिए धन्यवाद (मेरा रंग कैलकुलेटर नहीं है)।


भोला विचार: क्या आप थोड़ी देर के लूप का उपयोग करने के बजाय कार्यक्रम को स्वयं कॉल कर सकते हैं, और क्या यह कम होगा?
लिन

@ मौरिस लूप 3 टोकन है, जबकि एक प्रोग्राम का नाम आमतौर पर लंबा है
TheDoctor

1
@ मौरिस द लूप वास्तव में 4 बाइट्स हैं, और 3 में पुनरावृत्ति करना संभव है, लेकिन 300 से कम कॉल के बाद स्टैक बहुत तेज़ी से बाहर निकलता है।
lirtosiast

@Lembik क्योंकि आप [ codegolf.stackexchange.com/a/62203/39328] के साथ ठीक हैं , मैं इसे स्मूथ होने के लिए नहीं बदलूंगा
15

13

जावा, 339 308 289 287 बाइट्स

import java.awt.*;class F extends Frame{{setSize(200,200);show();}int c;public void paint(Graphics g){g.setColor(new Color(8388736));g.fillRect((int)(99+Math.sin(--c*.01)*75),(int)(99+Math.cos(c*.01)*75),1,1);for(int i=0;++i<62864;)paint();}public static void main(String[] x){new F();}}

@Peter लेनकेफी के लिए धन्यवाद, जिसका महान समाधान मुझे मिल गया, और जिसकी लूप के लिए मैंने बेशर्मी से नकल की!

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

संपादित करें: टिप्पणियों में उनके सुझावों के लिए @Peter Lenkefi और @tobii को धन्यवाद। बीटिंग एचटीएमएल अच्छा होगा - क्या कोई जानता है कि नींद का उपयोग किए बिना जावा में मज़बूती से कैसे रोकें () और अपवादों को पकड़ने के लिए?

संपादित करें 2: जावा BEATS HTML (वर्तमान में 290 बाइट्स पर!): डी टाइमिंग अब मशीन-निर्भर है, लेकिन मेरी मशीन पर एक पूर्ण चक्र के लिए ~ 60 सेकंड, जो @Lembik के अनुसार ठीक है। उनके सुझाव के लिए @PeterLenkefi पर फिर से धन्यवाद - मेरा उत्तर उनके आधे से अधिक है :)

EDIT 3: @ अजय ने "रिपेंट" से "री" हटाने का सुझाव दिया। दो बाइट कम। हम वहाँ पहुँच रहे हैं :)


1
हमें इसे HTML के तहत प्राप्त करना होगा (इसलिए <290 अभी)
पीटर लेन्केफी

1
@PeterLenkefi: दुर्भाग्य से, मैं कलाकारों के ब्रेस को नहीं बचा सकता; पाप / कॉस परिणाम कास्टिंग सीधे गणना को तोड़ता है। पेंट के अंदर आपका दमन () अविश्वसनीय रूप से गंदा है :)
फ्रांज डी।

1
@ ट्रॉयसेफ़ मैं गोल्फ के लिए था;) मैं किसी भी चीज़ के लिए जावा का उपयोग नहीं करता।
बजे पीटर लेनकेफी

1
का उपयोग करते हुए int c,iऔर छोड़ते हुए intमें for(int i=..कुछ और बचाने चाहिए।
मार्को 13

1
आपको F के लिए वर्ग घोषणा की भी आवश्यकता नहीं है, आप बस फ़्रेम वर्ग इनलाइन का विस्तार कर सकते हैं new Frame(){...}:।
मैजिक ऑक्टोपस Urn

9

हास्केल, 143 136 बाइट्स

यह ग्लोस पैकेज का उपयोग करता है :

import Graphics.Gloss
main=animate(InWindow""(100,100)(0,0))white$ \t->color(makeColor 0.5 0 0.5 1).rotate(t*6).translate 38 0$circle 1

प्रिटियर संस्करण है

import Graphics.Gloss

purple :: Color
purple = makeColor 0.5 0.0 0.5 1.0

main :: IO ()
main = animate (InWindow "" (100,100) (0,0)) white $ \t ->
    color purple . rotate (t * 6) . translate 38 0 $ circle 1

आप कुछ व्हाट्सएप को हटा सकते हैं।
12

@ हाल ही में, धन्यवाद। मैंने भी दो अनावश्यक हटा दिए .0
फ्रायरिच राबे

8

HTML (CSS?), 167 बाइट्स

सम्मिलन के उत्तर से प्रेरित

<style>body{position:fixed;left:50%;top:12%;width:1px;height:75vmin;border-top:1px solid #800080;animation:r 60s infinite linear}@keyframes r{to{transform:rotate(1turn

Ungolfed:

body {
    position: fixed;
    left: 50%;
    top: 12%;
    width: 1px;
    height: 75vmin;
    border-top: 1px solid #800080;
    animation: r 60s infinite linear;
}
@keyframes r {
    to {
        transform: rotate(1turn);
    }
}


सिर्फ एक FYI करें, HTML + CSSआमतौर पर इसे प्रोग्रामिंग भाषा नहीं माना जाता है, हालांकि यह OP पर निर्भर है।
GamrCorps

1
यह फ़ायरफ़ॉक्स 41.0.2 पर कुछ भी नहीं करता है।
n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

1
बस फ़ायरफ़ॉक्स 41.0.2 पर परीक्षण किया गया, विन 10. मेरे लिए ठीक काम करता है।
लछलन आर्थर

1
Ubuntu में 41.0.2 में मेरे लिए काम करता है।

1
+1 केवल bodyखुद को चेतन करने के लिए अच्छी सोच । :)
18::

7

QBasic, 106

SCREEN 7
COLOR 5,15
DO
t=TIMER
CLS
PSET(99+99*COS(i),99+99*SIN(i))
i=i+ATN(1)/75
1IF TIMER<t+.1THEN 1
LOOP

QB64 पर परीक्षण किया गया है , जिसमें कहा गया है कि इसका लिनक्स संस्करण है (हालांकि मैंने इसे केवल विंडोज पर आजमाया है)।

  • SCREEN 7 ग्राफिक्स मोड सेट करता है।
  • COLOR 5,15 गहरे मैजेंटा को अग्रभूमि रंग के रूप में और चमकदार सफेद को पृष्ठभूमि रंग के रूप में सेट करता है।
  • DO ... LOOPएक अनंत लूप है। आमतौर पर आप इसे इस रूप में देखेंगे DO WHILE ... LOOP(या आप LOOP WHILEइसके बजाय रख सकते हैं , या UNTILएक नकारात्मक स्थिति के लिए उपयोग कर सकते हैं), लेकिन आप उस स्थिति को भी छोड़ सकते हैं, जिस स्थिति में यह हमेशा के लिए बंद हो जाता है।
  • TIMER आधी रात के बाद से फ़्लोटिंग-पॉइंट मान के रूप में संख्या है।
  • CLS = स्क्रीन दिखाई।
  • PSET डिफ़ॉल्ट रूप से एक रंग, अग्रभूमि रंग के लिए एक बिंदु सेट करता है।
  • iशून्य पर शुरू होता है और लूप के माध्यम से प्रत्येक बार पीआई / 300 से गिना जाता है, इस प्रकार 600 पुनरावृत्ति के बाद एक पूर्ण चक्र पूरा होता है। हम पीआई की गणना 4 * आर्कटन (1) के रूप में करते हैं।
  • अंतिम पंक्ति 0.1 सेकंड बीतने तक प्रतीक्षा करती है। मैंने अपने QBasic किताबों से जो मुहावरा सीखा, वह था t# = TIMER: WHILE TIMER < t# + 0.1: WEND। लेकिन हमें #0.1-सेकंड के अंतर के लिए दोहरे-सटीक संख्याओं (साथ चिह्नित ) की आवश्यकता नहीं है , और यह पता चलता है कि IF cond THEN [GOTO] lineवाक्यविन्यास 1 वर्ण WHILE ... WENDलूप से कम है ।

लूप 60 सेकंड में 600 बार दोहराता है, इस प्रकार एक पूर्ण चक्र पूरा करता है।

चेतावनियां

  • रंग 5, डार्क मैजेंटा, #8B008Bअनुरोध के बजाय है#800080 (ओपी के साथ साफ) है।
  • स्क्रीन मोड 7 320x200 है, और इसलिए सर्कल में व्यास 198 है, जो चौड़ाई का> = 0.75 नहीं है, लेकिन ऊंचाई का = = 0.75 (ओपी के साथ भी साफ किया गया) है।
  • यदि आप इसे डॉस QBasic पर चलाते हैं, तो यह फुलस्क्रीन है, इसलिए "पिक्सेल" वास्तव में मॉनिटर पर एक भी पिक्सेल नहीं है (जब तक कि आपके पास 320x200 मॉनिटर नहीं होता है)। लेकिन यह काफी करीब होना चाहिए। QB64 एक विंडो में चलता है जो सटीक आयामों का उपयोग करता है, और इस प्रकार पिक्सेल एक शाब्दिक पिक्सेल है।
  • QB64 में कम से कम, संपूर्ण क्रांति करने में 65 सेकंड से अधिक समय लगता है। मैं सच में पता नहीं क्यों; यह या तो राउंडिंग त्रुटियों या लूप पर ओवरहेड होना चाहिए, हालांकि मैंने सफलता के बिना दोनों को कम करने की कोशिश की है। सिद्धांत रूप में, कोड को सही ढंग से काम करना चाहिए-जैसा है। व्यवहार में, कोई भी राशि को जोड़ सकता हैi वृद्धि होती है जब तक कि एक क्रांति 60 सेकंड के करीब न हो। (69 या 68 के हर का प्रयास करें।)
  • यहां कोई सुंदर चित्र नहीं। :( लिसेक की गुणवत्ता एक पिक्सेल को सही ढंग से पकड़ने के लिए पर्याप्त नहीं थी।

यह कोड लिनक्स में मेरे लिए पूरी तरह से काम करता है। धन्यवाद।

यह वास्तव में QBasic 4.5 में चलता है, लेकिन पृष्ठभूमि वास्तव में सफेद नहीं है :)। यह संकलन और चलने का एक GIF है: codegolf.square7.ch/altqb.gif
mınxomaı

@ mınxomaτ अजीब, रंग 15 या तो सफेद या हल्के भूरे रंग के साथ देना चाहिए जो मैंने सोचा था कि मुझे सब कुछ के अनुसार ... यह प्रकाश सियान (रंग 11) जैसा दिखता है। SCREEN 8इसके बदले क्या करता 7है?
DLosc

वही हरी-भरी पृष्ठभूमि। लेकिन आप सही हैं, कल्पना के अनुसार यह सफेद होना चाहिए। मैंने कलर 7 (ग्रे) भी आज़माया और यह ग्रे के रूप में सामने आया। तो आपका समाधान बिल्कुल ठीक है, लेकिन मेरे डॉस में कुछ गड़बड़ है।
21

7

mIRC स्क्रिप्ट, 184 बाइट्स

alias g {
window -p @m -1 -1 100 128
f
}
alias f {
inc %s 1
set %o $calc(%s *38/360)
clear @m
drawdot -r @m $rgb(128,0,128) 1 $calc($cos(%o)*38+50) $calc($sin(%o)*38+52)
.timer 1 1 f
}

यह शराब में mIRC के लिए अनुकूलित है। MIRC शुरू करें, Alt + Rफिर इसे दबाएं , संपादक को बंद करें और इसे चलाएं/g

पूर्वावलोकन

जीआईएफ पर समय समाप्त हो सकता है।


यह मुझ पर एक नया है! यह बहुत अच्छा होगा अगर आप इसे चलाने का एनिमेटेड जिफ़ बना सकें।

यह पहली भाषाओं में से एक थी जिसका मैंने उपयोग किया / मुझे कोडिंग में दिलचस्पी थी!
वारिस

6

आर, 170 बाइट्स

library(animation);for(i in 1:60){par(mar=rep(0,4));plot.new();t=2*pi*(1-i)/60;points(3*cos(t)/8+.5,3*sin(t)/8+.5,pch=19,col="#800080");ani.record()};repeat{ani.replay()}

यह पैकेज पर निर्भर करता है animation। और यहाँ यह काम करने के लिए जिफ है:

एक खिड़की में

अवैध समाधान एक gif (139 बाइट्स) को सहेजना:

animation::saveGIF({for(i in 1:60){par(mar=rep(0,4));plot.new();t=2*pi*(1-i)/60;points(3*cos(t)/8+.5,3*sin(t)/8+.5,pch=19,col="#800080")}})

यह एक ImageMagick स्थापित करने की आवश्यकता है। परिणाम एक जिफ़ में सहेजा जाता है।

! [गोल और गोल


हालांकि यह बहुत अच्छा है .. चुनौती को स्क्रीन / विंडो पर लिखने के लिए कोड की आवश्यकता है।

ओह मुझे समझ नहीं आया।
प्लेनैपस

2
यहाँ यह है, एक खिड़की में।
प्लेनैपस

6

जूते के साथ रूबी, 159 बाइट्स

Shoes.app{animate{background stroke white
fill purple
r=0.75*c=self.width/2
t=Time.now
m=Math
rect c+r*m.sin(a=(t.sec+t.usec*1e-6)*m::PI/30),c-r*m.cos(a),2,2}}

पिक्सेल वास्तव में एनालॉग घड़ी के सेकंड हैंड की नोक है। तो यह एक बिल्कुल सटीक है।

जूते के साथ रूबी, 134 बाइट्स

m=Math
Shoes.app{animate{|f|r=0.75*c=self.width/2
background stroke white
fill purple
rect c+r*m.sin(a=f*m::PI/360),c-r*m.cos(a),2,2}}

यह एक फ्रेम-प्रति-सेकंड आधारित विकल्प है, जो अन्य उत्तरों से प्रेरित है। यद्यपि दस्तावेज़ कहता है कि डिफ़ॉल्ट एफपीएस 10 है, व्यावहारिक परीक्षण से पता चलता है कि यह वास्तव में 12 है।

दोनों समाधान "सर्कल की चौड़ाई 0.75 (उपयुक्त रूप से) स्क्रीन या खिड़की की चौड़ाई होनी चाहिए" का शाब्दिक अर्थ है: खिड़की की चौड़ाई के आधार पर गणना करें, इसलिए पिक्सेल कभी-कभी एक गैर-वर्ग विंडो के नीचे छोड़ सकती है। यकीन नहीं होता कि इस तरह के मामले को कैसे संभाला जा सकता है। (चौड़ाई और ऊंचाई का कम से कम उपयोग करें। अंडाकार पथ पर चलें?) खिड़की डिफ़ॉल्ट रूप से 600 x 500 आकार से शुरू होती है और आकार बदलने योग्य होती है।


रूबी समाधान देखकर बहुत खुश हुई! अब हमें अजगर, पर्ल, ....

5

डी, 286 280 बाइट्स

(392 यदि सामान्य रूप से लिखा जाए)

import simpledisplay,std.math;void main(){auto w=new SimpleWindow(100,100);auto c=50;auto r=c*2/3;int t;auto y=600/PI;w.eventLoop(50,{auto p=w.draw();p.clear;p.outlineColor=Color(128,0,128);p.drawPixel(Point(c+cast(int)(r*cos(t/y)),c+cast(int)(r*sin(t/y))));if(++t==1200)t=0;});}

या जिस तरह से मैंने मूल रूप से इसे गोल्फिंग के बिना लिखा था:

import simpledisplay, std.math;

void main() {
        auto window = new SimpleWindow(100, 100);
        auto c = window.width/2;
        auto r = c*2/3;
        int t;
        float cycle = 20*60/(PI*2);
        window.eventLoop(50, {
                auto p = window.draw();
                p.clear;
                p.outlineColor = Color(128, 0, 128);
                p.drawPixel(Point(c + cast(int) (r*cos(t/cycle)), c + cast(int) (r*sin(t/cycle))));
                if(++t == 20*60)
                        t = 0;
        });
}

यहाँ पर स्थित simpleedisplay.d और color.d पर निर्भर करता है: https://github.com/adamdruppe/arsd

बस उन दो व्यक्तिगत फ़ाइलों को डाउनलोड करें और उन्हें उपरोक्त कोड के रूप में अपनी उसी निर्देशिका में डालें, फिर: dmd yourfile.d simpledisplay.d color.dसंकलन करने के लिए और फिर इसे चलाएं।

मेरी छोटी सी लाइब्रेरी को इस तरह से सरल बनाने के लिए त्वरित एनिमेशन बनाने के लिए लिखा गया था, इसलिए यह अपनी खूबियों को बखूबी निभाता है! काश, मैं लंबे पहचानकर्ता नामों को पसंद करता और एक ऐसा Pointकंस्ट्रक्टर नहीं देता, floatजो 18 बाइट्स की कास्टिंग करता और .... मेरी विधि के नामों की स्पेलिंग को कुछ दर्जन जोड़ देता।


1
EventWop btw के लिए पहला तर्क एक मिलीसेकंड टाइमर है। यदि यह गैर-शून्य है, तो यह स्वचालित रूप से आपके लिए एक टाइमर बनाता है और उस अंतराल पर प्रदान किए गए शून्य आर्ग के साथ फ़ंक्शन को कॉल करता है। (EventLoop उपयोगकर्ता इनपुट को संभालने के लिए MouseEvent या KeyEvent आर्ग के साथ फ़ंक्शन भी ले सकता है)। तो 50 मिलीसेकंड अंतराल = 20 फ्रेम प्रति सेकंड, इसलिए 60 सेकंड में 20 * 60 = चक्र।
एडम डी। रूपे

मुझे लगता है कि जिस तरह से आप इस सवाल का जवाब ऊपर 392 के बजाय 280 लीडरबोर्ड कोड की पसंद में लिखा है

5

सी #, 379 365 बाइट्स

using System.Windows.Forms;using static System.Math;class P:Form{static void Main(){var f=new P();var p=new PictureBox();f.SetBounds(0,0,1000,1000);f.Controls.Add(p);f.Show();for(var i=0d;;i+=PI/3000){p.SetBounds((int)(Cos(i)*375+500),(int)(Sin(i)*375+500),1,1);p.CreateGraphics().Clear(System.Drawing.Color.FromArgb(-8388480));System.Threading.Thread.Sleep(10);}}}

निर्भर करता है System.Windows.Formsऔर System.Drawingचलाने के लिए। आउटपुट एक 1000x1000 विंडो में है।


कुछ बाइट्स var
बचाकर

सिस्टम गणित पर स्थिर आयात का उपयोग करके एक और बाइट को बचाएं
Pinkfloydx33

आप सिस्टम नेमस्पेस में अपना कोड घोषित कर सकते हैं और सिस्टम के अन्य सभी संदर्भों को हटा सकते हैं और मुझे लगता है कि 10 बाइट्स बचा सकते हैं
चरण

5

एसवीजी, 177 बाइट्स

<svg><g transform=translate(75,75)><circle id=x r=.5 cx=56 fill=#800080><animateTransform xlink:href=#x attributeName=transform type=rotate to=360 dur=60s repeatCount=indefinite

नरक से नाश्ते के लिए अवैध मार्कअप, लेकिन यह (क्रोम में कम से कम) चलता है। एचटीएमएल 5 कैनवास की तरह, एसवीजी के लिए डिफ़ॉल्ट आकार 300x150 प्रतीत होता है, इसलिए यह मान रहा है।

संपादित करें: वूप्स, मैंने गलती से 60 की बजाय 6 की अवधि में छोड़ दिया। निश्चित रूप से, लेकिन यह भी पाया गया कि 0.5बस के रूप में काम करता है .5, इसलिए बाइट गिनती में कोई बदलाव नहीं हुआ।


5

X86 मशीन-कोड - 150 146 149 133 127 बाइट्स

गोल्फ संस्करण:

        00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
        --------------------------------------------------------------------
0000    B0 13 CD 10 BA C9 03 88 F1 BE 76 01 F3 6E B0 0F - °.Í.ºÉ.ˆñ¾v.ón°.
0010    49 68 00 A0 07 F3 AA 64 66 A1 6C 04 66 A3 80 01 - Ih. .óªdf¡l.f£€.
0020    64 66 A1 6C 04 66 2B 06 80 01 66 50 89 E5 D9 EB - df¡l.f+.€.fP‰åÙë
0030    D8 C0 DA 4E 00 DE 34 D9 FB BB 7D 01 DE 0F DE 47 - ØÀÚN.Þ4Ùû»}.Þ.ÞG
0040    FE DF 5E 02 DE 0F DE 47 FE DF 5E 00 5F 69 FF 40 - þß^.Þ.ÞGþß^._iÿ@
0050    01 58 01 C7 BB 88 01 8B 0F 39 CF 74 C3 30 C0 AA - .X.Ç»ˆ.‹.9ÏtÃ0Àª
0060    4F 89 3F 89 CF B0 0F AA 31 C0 FE C4 CD 16 74 B0 - O‰?‰Ï°.ª1ÀþÄÍ.t°
0070    B8 03 00 CD 10 C3 20 00 20 44 04 64 00 4B 00    - ¸..Í.Ã . D.d.K.

'Ungolfed', स्रोत संस्करण:

; golfCrcl.asm
;
; - 16 bit implementation of an animated pixel that circumscribes a circle.
; - 127 bytes .COM file
;
;   - enhzflep -
;   31 Oct 2015 - initial
;               - set closest colour to desired #800080
;    2/3 Nov 2015 - removed unnecessary instuctions, used BX register to index mem by fpu
;               - removed .data section alignment, better register use in curPixel/lastPixel compares and calcs, reusing value of si after palette setting
[section .text]
[bits 16]
[org 0x100]
EntryPoint:
;   mov     fs, bx          ; bx is 0 on entry. Set fs seg register to this

    ; set graphics mode 320x200
    mov     al, 0x13
    int     0x10

    ; set colour #0 to be as close to the desired one as possible
    ; the vga palette registers are 6 bits by default (some models allow switching to 8 bits)
    ; therefore, we cant represent all of the 16.7m colours that we can in 24bit modes
    ; we're limited to 'just' 64*64*64 = 262,144 (256k) colours. Unfortunately, #800080 is not
    ; a colour we can represent exactly in mode13 or any other mode with 6 bit regs.
    mov     dx, 0x3c9
    mov     cl, dh
    mov     si, desiredCol
    rep     outsb                           ; cx now=0 and si now points to totalTicksNeeded

    ; clear the screen to white
    mov     al, 0x0f                        ; index of a colour thats already FF,FF,FF
;   xor     cx, cx                          ; cx = 0 - its zeroed by the rep outsb instruction above.
    dec     cx                              ; cx = FFFF
    push    word 0xA000                     ; segment of video memory
    pop     es                              ; pop it into es
    rep     stosb                           ; es:[di] = 0F, inc di, dec cx. If cx != 0 then repeat.

    ; setup the timing stuff
    mov     eax, [fs:0x046C]                ; 32 bit value updated at 18.2Hz by bios
    mov     [initialTicks], eax

.drawLoop:
    mov     eax, [fs:0x046C]                ; 32 bit value updated at 18.2Hz by bios
    sub     eax, [initialTicks]             ; eax = curTime-startTime (in increments of 1/18.2 of a second --- 182 = 10 seconds)

    push    eax                             ; number of elapsed clock ticks - ready to be loaded by fpu. Also stack space for calc result
    mov     bp, sp                          ; get pointer to last element pushed onto the stack
    fldpi                                   ; st0 = pi
    fadd    st0                             ; st0 = 2pi
    fimul   long [bp]                       ; (currentTick/requiredTicks) * 2pi
;   fidiv   word [totalTicksNeeded]
    fidiv   word [si]                       ; si still points to totalTicksNeeded after setting the palette earlier
    fsincos                                 ; st0 = cos(old_st0), st1 = sin(old_st0)

    mov     bx, radius
    fimul   word [bx]                       ;   fimul word [radius] -  cos(angle)*radius
    fiadd   word [bx-2]                     ;   fiadd word [origin] -  origin + cos(angle)*radius
    fistp   word [bp+2]                     ; ---- X-coord -------

    fimul   word [bx]                       ;   fimul   word [radius]
    fiadd   word [bx-2]                     ;   fiadd   word [origin]
    fistp   word [bp+0]                     ;  ---- Y-coord -------

    ;---------------
    pop     di                              ; calculated Y-coord
    imul    di, 320                         ; multiply it by the screen width
    pop     ax                              ; calculated X-coord
    add     di, ax                          ; di = x + (pixels_per_row * y_coord)

    mov     bx, lastIndex
    mov     cx, [bx]                        ; get the mem index for the last pixel
    cmp     di, cx                          ; check if we're indexing the same pixel as last time through the loop
    je      .drawLoop                       ; if so, return to start of loop - no need to delete and redraw the pixel in the same spot.

    xor     al, al                          ; col index 0
    stosb                                   ; draw our purple pixel
    dec     di                              ; stosb advanced di to the next pixel, undo this (stosb followed by dec di is still shorter than mov es:[di], al)
    mov     [bx], di                        ; save the pixel's mem address
    mov     di, cx                          ; restore index of pixel drawn last time through the loop
    mov     al, 0x0f                        ; pal index of white
    stosb                                   ; erase the last pixel

    ; check for a keystroke
    xor     ax, ax
    inc     ah
    int     0x16
    jz      .drawLoop                           ; loop if no keys pressed

.drawingDone:
    ; set text mode 80x25
    mov     ax, 0x3
    int     0x10

    ; program exit
    ret                                     ; Dos pushes a 0000 onto the stack and copies CD 20 to offset 0 of our code-seg
                                            ; before it invokes our program. ret jumps back to that CD 20 (int 0x20) instruction

; Since this is a .COM file, all program, data and stack exist in the same segment. 
; Using .text and .data sections only improves program readability - doing so only has minor effects on the binary produced.
;
; In this case, the assembler word aligns anything in the data section. This may have the effect of adding a padding byte,
; which we really dont need/want here. Data is machine-word aligned to improve the speed of access for the hardware. Machine-word
; is used to refer to the size of an int. In the case of 16 bit code, this will generally be 16 bits, 32 bit code has 32 bit words
; and so on. This code is 16 bit, so things should be aligned to word boundaries for maximum execution speed
;
;[section .data]
desiredCol          db  0x80/4, 0x00, 0x80/4        ; palette registers are only 6 bit.
totalTicksNeeded    dw  1092
origin              dw  100
radius              dw  75

; ticks/second = 18.2
; totalTime = 60 seconds
; totalTicks = 1092 (18.2 * 60)
; degreesPerTick = 360 / 1092 = 0.3296703
; timerTicksAddr = 0040:006C (0000:046C) dword
[section .bss]
initialTicks    resd    1
lastTickValue   resd    1
lastIndex       resw    1

डाउनलोड करने योग्य, बेस 64 एन्कोडेड संस्करण

data:application/octet-stream;base64,sBPNELrJA4jxvnYB826wD0loAKAH86pkZqFsBGajgAFkZqFsBGYrBoABZlCJ5dnr2MDaTgDeNNn7u30B3g/eR/7fXgLeD95H/t9eAF9p/0ABWAHHu4gBiw85z3TDMMCqT4k/ic+wD6oxwP7EzRZ0sLgDAM0QwyAAIEQEZABLAA==

इस पते को अपने ब्राउज़र में कॉपी और पेस्ट करें। परिणामी फ़ाइल का नाम बदलें golfcrcl.comऔर एक डॉस वातावरण, यानी डॉसबॉक्स में चलाएं।


यह भी खूब रही! परीक्षण किया और पूरी तरह से काम करता है।

1
ओह तस्वीर! बस एहसास हुआ कि आपने उपयोग करने के लिए एक रंग निर्दिष्ट किया है और मैंने इसे पूरी तरह से अनदेखा कर दिया है। : उफ़: मैं थोड़ी देर बाद ठीक करूँगा। कलर इंडेक्स 0x09 के बजाय 0x5C होना चाहिए (डोसबॉक्स को सही तरीके से सेट करने पर, अन्यथा, मैं सिर्फ 1 कलर रिमैप
करूंगा

4

गणितज्ञ 208 185 139 बाइट्स

छवि के रूप में उपयोग की गई एक सरणी के चारों ओर बैंगनी पिक्सेल ले जाता है।

विधि 1 139 बाइट्स

n=900;Dynamic@Refresh[t=DateValue@"Second";ReplacePixelValue[Image@Array[1&,{n,n}],
400{Cos[z=Pi/30t],Sin@z}+450->Purple],UpdateInterval->1]

विधि 2 154 बाइट्स

60 सेकंड में एक परिपत्र पथ के साथ एक पिक्सेल प्लॉट करता है।

Dynamic@Refresh[t=DateValue@"Second";Graphics[{AbsolutePointSize@.01,Purple, 
Point[{Cos[z=Pi/30t],Sin@z}]},PlotRange->1,ImageSize->Full],UpdateInterval->1]

विधि 3 193 बाइट्स

यह एक घड़ी खींचता है, जिसमें सफेद रंग के टिक और लेबल होते हैं, जिसके लिए दूसरा हाथ पिक्सेल होता है।

Dynamic@Refresh[ClockGauge[AbsoluteTime[],TicksStyle->White, 
GaugeMarkers->{None,None,Graphics[{White,Disk[],Purple, 
AbsolutePointSize[.01],Point@{3,0}}]},PlotTheme->"Minimal"],UpdateInterval->1]

मैं देखता हूं, बुनियादी एलटीआर भ्रम ... लेकिन वैसे भी, आप 30और के बीच की जगह को हटा सकते हैं t
लेजिओनमल 978

4

ओब्ज-सी ++ / कोको, 777 678 668 657 643 628 बाइट्स

#include <Cocoa/Cocoa.h>
float r;@implementation V:NSView-(void)drawRect:(NSRect)d{CGContext*c=(CGContext*)NSGraphicsContext.currentContext.graphicsPort;CGContextSetRGBFillColor(c,.5,0,.5,1);CGContextFillRect(c,(CGRect){cos(r)*38+50,sin(r-=pi/300)*38+50,1,1});[NSTimer scheduledTimerWithTimeInterval:.1 target:self selector:@selector(x)userInfo:0 repeats:0];}-(void)x{self.needsDisplay=1;}@end
int main(){NSRect b={0,0,100,100};NSWindow*w=[[NSWindow alloc]initWithContentRect:b styleMask:1 backing:2 defer:0];[w orderFront:0];w.backgroundColor=[NSColor whiteColor];w.contentView=[[V alloc]initWithFrame:b];[NSApp run];return 0;}

तो यह शायद कुछ भी करने का सबसे बुरा तरीका है, लेकिन मुझे लगा कि मैं कोशिश करूँगा।

एक मैक (वैसे भी) पर संकलित किया जा सकता है g++ -framework Cocoa file.mmऔर टर्मिनल से चला जाता है ( ctrl-Cछोड़ने के लिए, क्योंकि यह एक ऐप नहीं है)।

स्क्रीनशॉट

संपादित करें: सहेजे गए 99 बाइट्स: main()OS X 10.10 पर चलने के लिए निश्चित (पहले संस्करण केवल 10.8 पर चलता था), सादे ट्रिगर गणना के पक्ष में अनुवाद / घुमाया गया, विंडो प्लेसमेंट और अन्य छोटे सामान के साथ परेशान होना बंद हो गया।

संपादित करें: एक और 10 बाइट्स सहेजे गए: केवल orderFrontविंडो प्रदर्शित करने के लिए बदल दिया गया । वास्तव में यह सामने की खिड़की नहीं बनाता है, हालांकि, लेकिन न orderFrontAndMakeKeyतो ऐसा किया , ...

संपादित करें: एक और 11 बाइट्स सहेजे गए: छोड़ दिया गया NSMakeRectऔर एक अंक मिला जिसे बस जाना था।

संपादित करें: एक और 14 बाइट्स सहेजे गए: NSTimerकुछ भी करने के लिए उदाहरण को निर्दिष्ट करने की आवश्यकता नहीं है , और जाहिरा तौर rपर शून्य को प्रारंभ करने को छोड़ सकते हैं ।

संपादित करें: एक और 15 बाइट्स सहेजे गए: मैं रोक नहीं सकता। मदद भेजें।


धन्यवाद। ओब्ज-सी ++ वर्तमान में सबसे लंबे समय तक कम से कम कोड प्रतियोगिता में स्पष्ट विजेता है!

14
+1 भी सबसे एनिमेटेड गैर-एनिमेटेड छवि प्रतियोगिता जीतने के लिए ।
लिन

4

जावास्क्रिप्ट / प्रसंस्करणjs, 175 173 156 153 152 बाइट्स

var s=256,e,h,m;void setup(){size(s,s);h=s/2;}void draw(){background(-1);m=-millis()*(PI/36000);stroke(h,0,h);e=s/2*0.75;point(h+sin(m)*e,h+cos(m)*e);}

चलाने के लिए: या तो http://www.openprocessing.org/sketch/226733 पर जाएं प्रसंस्करण का उपयोग करके इसे देखने के लिए प्रसंस्करण, या प्रसंस्करण से प्रसंस्करण 2.0 डाउनलोड करें। प्रसंस्करण आईडीई में कोड पेस्ट करें, जावास्क्रिप्ट मोड का चयन करें और देखें यह जाना।


योग्य, आपने मुझसे 20 सेकंड पहले प्रोसेसिंग पोस्ट की थी।
पुरकाकूदरी

क्या हेडर इस उत्तर में गलत है? यह लीडरबोर्ड में दिखाई नहीं देता है।

1
याद किया कि, अब मैं उस पर हूँ।
टिमोथी ग्रोट

1
यह अब 60 सेकंड की आवश्यकता को पूरा करना चाहिए
तीमुथियुस Groote

1
background(-1)एक बाइट से छोटा हैbackground(255)
कृति लिथोस

3

एल्म , 274 बाइट्स

import Color exposing (..)
import Graphics.Collage exposing (..)
import Time exposing (..)
main=Signal.map((\t->collage 200 200 [move(75*cos(-2*pi*t/60),75*sin(-2*pi*t/60))(filled(rgb 128 0 128)(circle 2)),outlined(solid black)(square 200)])<<inSeconds)(every(0.01*second))

इसे अपने ब्राउज़र में आज़माएँ या संपादित करें:

ध्यान दें कि यदि हम आयात से छुटकारा पा लेते हैं और कैनवास के चारों ओर रूपरेखा तैयार कर रहे हैं, तो हम 149 बाइट्स तक नीचे हैं, लेकिन यह शायद धोखा है!


वूप्स, फिक्स्ड! मैं परीक्षण के दौरान अधीर मिल गया
jmite

1
यह बहुत अच्छा है और एक कार्यात्मक भाषा में कुछ प्राप्त करना बहुत अच्छा है। हमें अभी हास्केल और स्काला की आवश्यकता है!

2
@ लिम्बिक I ने
फ्रेरिच राबे

3

सी #, 301 बाइट्स

using System.Windows.Forms;using System.Drawing;class P:Form{static void Main(){Application.Run(new P());}P(){Paint+=(o,e)=>{var g=e.Graphics;g.Clear(Color.White);g.TranslateTransform(150,150);g.RotateTransform(System.DateTime.Now.Second*6);g.FillRectangle(Brushes.Purple,105,0,1,1);Invalidate();};}}

डिफ़ॉल्ट आकार के मैट्रिक्स पर निर्भर करता है; आकार और स्थिति कई कारकों के आधार पर थोड़ी दूर हो सकती है। मई बुरी तरह से टिमटिमा सकता है या नहीं; इसे हल करने के लिए, निम्नलिखित जोड़ें:

SetStyle(ControlStyles.OptimizedDoubleBuffer|ControlStyles.AllPaintingInWmPaint,true);

3

लुआ + लोवे, 189 वर्ण

t=0
m=math
l=love
g=l.graphics
function l.update(d)t=t+d end
function l.draw()a=t*m.pi/30
g.setBackgroundColor(255,255,255)g.setColor(127,0,127)g.point(400+225*m.cos(a),300+225*m.sin(a))end

love.update()पिछले फ्रेम के बाद से गुजरे हुए समय को पैरामीटर के रूप में प्राप्त करता है। डिफ़ॉल्ट निर्देशांक 800 x 600 विंडो में डिफ़ॉल्ट रूप से ड्रॉ होता है, क्योंकि विंडो वैसे भी resizable नहीं है।


पहला लुआ जवाब! धन्यवाद।

3

पायथन 2 + पायगेम, 221 198 193

exec'from %s import*;'*3%('math','pygame','time')
_,p,D=[255],128,display
S=D.set_mode(_*2)
while 1:S.fill(_*3);S.set_at(map(lambda f:int(p+f(pi*(time()%60)/30)*96),(cos,sin)),(p,0,p));D.flip()

1
भयानक रूप से भयानक!

अब हमें बस एक अजगर + कछुए के समाधान की आवश्यकता है।

3

सी (एसडीएल 1.2 का उपयोग करके), 237 233

#include <SDL.h>
#define P(f)(int)(128+96.0*f(3.14*((int)(.001*SDL_GetTicks())%60)/30))
main(){SDL_Surface*s=SDL_SetVideoMode(255,255,32,0);while(1){int*p=s->pixels;memset(p,255,260100);p[P(cos)+s->w*P(sin)]=0x800080FF;SDL_Flip(s);}}

संकलन और उपयोग कर चलाएं gcc -I/usr/include/SDL snippet.c -lSDL -lm && ./a.out


बहुत बढ़िया! मुझे लगा कि कोई ऐसा नहीं करेगा।

2

एक्शनस्क्रिप्ट 2.0, 151 बाइट्स

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

createEmptyMovieClip("p",0)
p._x=p._y=r=200
p.beginFill(0x800080)
p.moveTo(r,0)
p.lineTo(r-1,0)
p.lineTo(r,1)
onEnterFrame=function(){p._rotation+=.25}

मूल विचार: एक नई फिल्म क्लिप ऑब्जेक्ट बनाएं, इसे (200, 200) पर रखें, और फिर इसमें 200 पिक्सल राइट में डॉट 2 ड्रा करें । अब मूवी क्लिप 200 पिक्सेल चौड़ी और 1 पिक्सेल ऊँची है। धुरी बिंदु मूल निर्देशांक है जहां हमने शुरू किया था, इसलिए जब हम _rotationसंपत्ति को संशोधित करते हैं, बिंदु (200, 200) के चारों ओर एक सर्कल में डॉट चलता है। आसानी से, _rotationडिग्री में है; 0.25 डिग्री / फ्रेम * 24 फ्रेम / सेकंड * 60 सेकंड / मिनट = 360 डिग्री / मिनट।

यदि आपके पास फ्लैश है, तो स्क्रैच से चलाने के लिए, एक नया फ्लैश डॉक्यूमेंट 1 बनाएं , एक्शन पैनल खोलें और उपरोक्त कोड पेस्ट करें। डिफ़ॉल्ट सफेद पृष्ठभूमि, 550x400 कैनवस, और 24 एफपीएस को संभालने के लिए आगे कोई अनुकूलन की आवश्यकता नहीं है। Ctrl-Enter दबाएं और इसे चलते देखें।

यदि आपके पास स्वयं फ़्लैश नहीं है, तो आप अभी भी नि: शुल्क फ्लैश प्लेयर के साथ परिणाम देख सकते हैं, जिसे अधिकांश आधुनिक ब्राउज़रों के साथ आना चाहिए। यहां SWF फाइल डाउनलोड करें । यदि आप इसे नहीं खेल सकते हैं, तो इस HTML पेज को डाउनलोड करने और इसे खोलने की कोशिश करें, उसी निर्देशिका में SWF फ़ाइल के साथ।

1 का परीक्षण एडोब फ्लैश CS4 पेशेवर पर किया गया था, "फ्लैश फाइल (एक्शनस्क्रिप्ट 2.0)" का चयन करते समय पूछा गया कि किस प्रकार की नई फाइल बनाई जाए।

2 वास्तव में एक छोटा त्रिकोण है, जैसा कि आप देखेंगे कि क्या आप इसे पर्याप्त रूप से ज़ूम इन करते हैं। यह एक गोल्फ का रास्ता था जिसे मैं डॉट बना सकता था।


2

जावास्क्रिप्ट w / jQuery, 205 बाइट्स

y=75;with($('<canvas/>').appendTo(document.body)[0].getContext('2d')){fillStyle='#800080';translate(y,y);(f=function(){clearRect(-y,-y,y*2,y*2);fillRect(0,56,1,1);rotate(Math.PI/300);setTimeout(f,100)})()}

jsfiddle , नीचे स्निपेट

यह शायद पुस्तक द्वारा काफी नहीं है। एक कैनवास का डिफ़ॉल्ट आकार (क्रोम में कम से कम) 300x150 है, इसलिए मैंने सर्कल को 75x75 पर केंद्रित किया है। मैं इसे 150x75 पर केन्द्रित कर सकता हूं, और इसकी त्रिज्या 113px (~ 75% चौड़ाई) बना सकता हूं, लेकिन यह कुछ समय में कैनवास के बाहर होगा, इसलिए मैंने इसके बजाय ~ 75% ऊंचाई को चुना।

लेकिन यह विशेष रूप से कम नहीं है, इसलिए meh '



2

जावास्क्रिप्ट ईएस 6, 202 बाइट्स

a=0;with((D=document).body.appendChild(D.createElement`canvas`).getContext`2d`)with(Math)setInterval((f=t=>t(a+=PI/6e3)*60+75)=>fillRect(f(cos,clearRect(0,0,150,150),fillStyle=`#800080`),f(sin),1,1),10)

फ़ायरफ़ॉक्स 41 में परीक्षण किया गया।

अन्य (लगभग) शुद्ध जावास्क्रिप्ट उत्तर की तरह, सर्कल 75x75 पर केंद्रित है क्योंकि एचटीएमएल ऐनक द्वारा परिभाषित कैनवास तत्वों का डिफ़ॉल्ट आकार 300x150 है।


2

मतलाब, 141 136

मैं सिर्फ आपके लिए, लिम्बिक को पूरी सूची देने के लिए इसे जमा करता हूं।

v=-100:100;
[y,x,m]=ndgrid(v,v,0);
n=75;
while 1;
    pause(1);
    c=m;
    c(x+i*y==round(n))=1;
    imshow(c);
    colormap([1,1,1;.5,0,.5]);
    n=n*exp(pi*i/30);
end

पुराना संस्करण:

v=-100:100;
[x,y,m]=ndgrid(v,v,0);
while 1;
c=m;
c(x+i*y==round(75*(-1)^(s/30)))=1;
imshow(c);
colormap([1,1,1;.5,0,.5]);
s=mod(s-1,60);
pause(1);
end
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.