फ्यू , 423 बाइट्स
Fueue एक कतार आधारित esolang जिसमें चल रहे प्रोग्राम है है कतार।
)$$4255%%1(~):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]](H-):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
इसे ऑनलाइन आज़माएं!
यह काम किस प्रकार करता है
यह स्पष्टीकरण हाथ से निकलने का रास्ता हो भी सकता है और नहीं भी । दूसरी ओर मैं नहीं जानता कि यह कैसे व्याख्या करने के लिए बहुत एक तरह से मुझे आशा है कि लोगों का पालन कर सकते में कम।
मुदा छल चादर
इस कार्यक्रम में उपयोग नहीं की जाने वाली कुछ विशेषताओं सहित विवरणों के लिए esolang wiki लेख देखें ।
प्रारंभिक कार्यक्रम कतार की प्रारंभिक स्थिति है, जिसमें निम्नलिखित तत्व शामिल हो सकते हैं:
- पूर्णांक शाब्दिक (स्रोत में केवल गैर-नकारात्मक, लेकिन नकारात्मक की गणना की जा सकती है), उन्हें निष्पादित करके एक चरित्र प्रिंट करता है।
- स्क्वायर-ब्रैकेट सीमांकित नेस्टेड ब्लॉक, निष्क्रिय (संरक्षित बरकरार जब तक कि कुछ फ़ंक्शन उन पर कार्य नहीं करता है)।
- कार्य, उनके तर्क कतार में तुरंत उनका अनुसरण करने वाले तत्व हैं:
+*/-%: पूर्णांक अंकगणित ( -एकात्मक, %तार्किक निषेध) है। यदि संख्या तर्क नहीं दिए गए हैं तो निष्क्रिय करें।()<: कोष्ठक में तत्व डालें, ब्लॉक से कोष्ठक निकालें, ब्लॉक में अंतिम तत्व जोड़ें। बाद के दो अक्रिय हैं जब तक कि एक ब्लॉक द्वारा पीछा नहीं किया जाता है।~:: स्वैप, डुप्लिकेट।$: कॉपी (संख्या + तत्व लेता है)। गैर-संख्या से पहले जड़ता।H: पड़ाव कार्यक्रम।
ध्यान दें कि []घोंसला बनाते समय , ()नहीं - उत्तरार्द्ध बस अलग-अलग कार्य हैं।
निष्पादन ट्रेस सिंटैक्स
अंक के बीच छोड़कर, व्हाट्सएप वैकल्पिक है। निम्नलिखित निष्पादन निशान में इसका उपयोग कार्यक्रम संरचना, विशेष रूप से सुझाव देने के लिए किया जाएगा:
- जब कोई फ़ंक्शन निष्पादित होता है, तो यह और इसके तर्क आसपास के तत्वों से रिक्त स्थान के साथ सेट किए जाएंगे। यदि कुछ तर्क जटिल हैं, तो उनके बीच एक स्थान भी हो सकता है।
- कई निष्पादन निशान बाईं ओर एक "देरी बूँद" में विभाजित हैं, एक हिस्से से दाईं ओर अलग हो जाते हैं जो पर्याप्त डेटा हेरफेर करता है। अगला भाग देखें
{}गणितीय अभिव्यक्तियों के पूर्णांक परिणाम को दर्शाने के लिए घुंघराले कोष्ठक (फ़्यू में प्रयुक्त नहीं) का उपयोग निशान में किया जाता है। इसमें नकारात्मक संख्याएं शामिल हैं, क्योंकि Fueue में केवल गैर-नकारात्मक शाब्दिक हैं - नकारात्मक -कार्य है।
विभिन्न पैमाइश योग्य नाम और ...मान और संक्षिप्त को दर्शाने के लिए उपयोग किए जाते हैं।
देरी की रणनीति
सहज रूप से, कतार के चारों ओर निष्पादन चक्र, आंशिक रूप से यह संशोधित करता है कि यह किस माध्यम से गुजरता है। किसी फ़ंक्शन के परिणामों को अगले चक्र तक फिर से कार्य नहीं किया जा सकता है। जब तक वे बातचीत नहीं करते हैं, तब तक कार्यक्रम के विभिन्न भाग समानांतर रूप से विकसित होते हैं।
परिणामस्वरूप, कोड का एक बहुत सिंक्रनाइज़ेशन के लिए समर्पित है, विशेष रूप से सही समय तक कार्यक्रम के कुछ हिस्सों के निष्पादन में देरी करने के लिए। इसे गोल्फ करने के लिए बहुत सारे विकल्प हैं, जो उन हिस्सों को अपठनीय बूँद में बदल देता है जिन्हें केवल चक्र द्वारा उनके निष्पादन चक्र को ट्रेस करके समझा जा सकता है।
ये रणनीति हमेशा नीचे में व्यक्तिगत रूप से उल्लिखित नहीं होगी:
)[A]Aएक चक्र के लिए देरी । (संभवतः सबसे आसान और सबसे पठनीय विधि।)~efतत्वों को स्वैप करता है eऔर fजो उनके निष्पादन में देरी करता है। (संभवतः कम से कम पठनीय, लेकिन अक्सर मामूली देरी के लिए सबसे छोटा।)$1eएक भी तत्व देरी करता है e।-और %विलंब संख्या के लिए उपयोगी हैं (बाद के लिए 0और 1)- एक पंक्ति में कई समान तत्वों में देरी करते समय,
:या $उन्हें एक ही से बनाने के लिए उपयोग किया जा सकता है।
(nnकोष्ठक में लपेटता है, जिसे बाद में सुविधानुसार हटाया जा सकता है। यह संख्यात्मक गणनाओं के लिए विशेष रूप से महत्वपूर्ण है, क्योंकि संख्याओं को बहुत अधिक अस्थिर किया जाता है, यहां तक कि पहली बार उन्हें एक ब्लॉक में लगाए बिना भी कॉपी किया जा सकता है।
समग्र संरचना
बाकी विवरण को सात भागों में विभाजित किया गया है, प्रत्येक चल रहे कार्यक्रम के एक भाग के लिए है। बड़े चक्र जिसके बाद उनमें से ज्यादातर खुद को दोहराते हैं, उन्हें पूरी कतार से गुजरने वाले एकल के "चक्र" से अलग करने के लिए "पुनरावृत्तियों" कहा जाएगा।
यहां बताया गया है कि प्रारंभिक कार्यक्रम उनके बीच कैसे बांटा गया है:
A: )$$4255%%1(~
B: ):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
C:
D: (H-
E:
F:
G: ):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
कार्यक्रम के अंत में बड़ा अंक बाकी को रिवर्स में एनकोड करता है, प्रति वर्ण दो अंक, प्रत्येक एएससीआईआई मूल्य से 30 घटाया जाता है (इसलिए जैसे 10एनकोडिंग एक( ।)
उच्च स्तर पर आप इस कार्यक्रम में डेटा (बाइनम के साथ शुरू) के बारे में सोच सकते हैं जैसा कि दाएं से बाएं ओर बह रहा है, लेकिन बाएं से दाएं बहने पर नियंत्रण है। हालाँकि, निचले स्तर पर फ़्यूए कोड और डेटा के बीच के अंतर को हर समय बनाए रखता है।
- खंड G सबसे पहले महत्वपूर्ण अंकों को विभाजित करते हुए ASCII अंकों (जैसे
0पूर्णांक के रूप में अंक 48) में bignum को डिकोड करता है । यह हर 15 चक्र में एक अंक उत्पन्न करता है।
- अनुभाग एफ में उत्पादित अंक ASCII मान शामिल हैं (प्रत्येक खंड के अंदर) जब तक खंड ई उन्हें उपभोग नहीं कर सकता है।
- खंड ई एक बार में उत्पादित अंकों को संभालता है, उन्हें प्रपत्र के ब्लॉकों में बाँधता है
[x[y]] बाँधती है, प्रत्येक जोड़ी के एन्कोडेड चरित्र को भी प्रिंट करती है।
- सेक्शन डी में एक गहरी नेस्टेड ब्लॉक होता है जो धीरे-धीरे
[x[y]]ब्लॉकों से इस तरह से निर्मित होता है कि एक बार जब इसमें सभी अंक होते हैं, तो यह उन सभी को प्रिंट करने के लिए चलाया जा सकता है, फिर पूरे कार्यक्रम को रोक दें।
- सेक्शन सी, सेक्शन डी के निर्माण को संभालता है, और सेक्शन ई को फिर से बनाता है।
- सेक्शन B सेक्शन C के साथ-साथ हर 30 साइकल को भी रीक्रिएट करता है।
- धारा A अन्य खंडों के अंतिम पुनरावृत्ति होने तक चक्रों की गणना करता है। फिर यह सेक्शन बी को निरस्त करता है और सेक्शन डी को चलाता है।
खंड एक
धारा ए कार्यक्रम के अंत का समय निर्धारण करता है। एकल स्वैप फ़ंक्शन को कम करने के लिए 4258 चक्र लगते हैं ~, जो तब खंड बी के लिए एक समायोजन करता है जो इसके मुख्य लूप को रोकता है और इसके बजाय अनुभाग डी को चलाना शुरू करता है।
)$ $4255% %1 (~
)$%%%...%% %0 [~]
)$%%%...% %1 [~]
⋮
)$ %0 [~]
) $1[~]
)[~]
~
- एक
$फ़ंक्शन ब्रैकेट्स में लपेटते %समय निम्नलिखित की 4255 प्रतियां बनाता है ।(~
- प्रत्येक चक्र को अंतिम
%संख्या के बीच 0और निम्न संख्या को चालू करने के लिए उपयोग किया जाता है 1।
- जब सभी
%एस का उपयोग किया जाता है, तो (प्रभावी रूप से एक एनओपी) $1की 1 प्रति बनाता है [~], और अगले चक्र पर )कोष्ठक हटाता है।
अनुभाग बी
सेक्शन बी अपने आप को पुनर्जीवित करने के साथ-साथ सेक्शन सी के प्रत्येक 30 चक्रों के एक नए पुनरावृत्ति को भी संभालता है।
) : [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]] [BkB]
)$ $24% %0 :< [~:)~)] ~ [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<] [BkB]
)$ %...%%% %1 < < [~:)~)] [BkB] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...%% %0 < [~:)~)[BkB]] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...% %1 [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
⋮
) $1 [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]] (1)
~:) ~)[BkB] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
) : [BkB] ) [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<] (2)
) [BkB] [BkB] $11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<
- एक
:बड़ा ब्लॉक निम्नलिखित (एक प्रति के रूप में संक्षिप्त डुप्लिकेट [BkB]), तो )पहले प्रतिलिपि से कोष्ठक निकाल देता है।
$$24%%0 अनुभाग A में एक के समान एक उलटी गिनती सेट करता है।- हालांकि यह नीचे गिना जाता है,
:<बदल जाता है <<, और ~दो खंडों को स्वैप करता है , एक नए अनुभाग C के लिए कोड को अंतिम रूप देता है।
- दो
<फ़ंक्शन दो अंतिम ब्लॉकों को पहले एक में पैक करते हैं - यह सामान्य पुनरावृत्तियों में निरर्थक है, लेकिन ~खंड ए से अंत में अपना काम करने की अनुमति देगा ।
- (1) जब उलटी गिनती समाप्त हो जाती है,
)तो बाहरी कोष्ठक हटा दिए जाते हैं। अगला अनुभाग C कोड की शुरुआत ~:)में बदल जाता है ):और ~)स्वैप हो जाता है )।
- (2) सेक्शन बी अब अपने प्रारंभिक चक्र पर वापस आ गया है, जबकि एक
)बस सी के नए खंड को चलाने के लिए कोष्ठक को हटाने के बारे में है।
अंतिम पुनरावृत्ति में, ~खंड A से बिंदु (1) ऊपर दिखाई देता है:
~ ) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]] (1)
[~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]] )
~स्वैप )ब्लॉक भर में और धारा सी में, से खंड बी को रोकने को पुन: चलाने जा रहा है।
अनुभाग सी
धारा सी नए अंकों के चरित्र जोड़े को खंड डी के ब्लॉक में विलय करता है, और अनुभाग ई के नए पुनरावृत्तियों को भी बनाता है।
नीचे के साथ एक विशिष्ट यात्रा से पता चलता xहै और yअंक 'ASCII कोड का प्रतिनिधित्व। बहुत पहले पुनरावृत्ति में, आने वाले "डी" और "ई" तत्व प्रारंभिक हैं [H]और -इसके बजाय, जैसा कि कोई भी पिछला अनुभाग ई किसी भी अंक चरित्र जोड़े का उत्पादन करने के लिए नहीं चला है।
C D E
$11~ ) ~<[[+$4--498+*-:~-10)):])<~] [)))~] < [)))~[...]] [x[y]]
~~~ ~~~ ~~~ ~~) [[+$4--498+*-:~-10)):])<~] < [)))~] [)))~[...][x[y]]]
~~~ ~~~ ) ~ [[+$4--498+*-:~-10)):])<~] [)))~[)))~[...][x[y]]]]
~~~ ~ ) [)))~[....]] [[+$4--498+*-:~-10)):])<~]
~~[)))~[....]] )[[+$4--498+*-:~-10)):])<~]
[)))~[....]] ~[+$4--498+*-:~-10)):])<~
- यह सिंक्रनाइज़ेशन की एक अलग विधि का उपयोग करता है जिसे मैंने इस उत्तर के लिए खोजा था। जब आपके पास
~एक पंक्ति में कई स्वैप कार्य होते हैं , तो पंक्ति प्रत्येक चक्र में लगभग 2/3 तक सिकुड़ जाएगी (क्योंकि एक ~दो के बाद स्वैप होता है), लेकिन कभी-कभी शेष ~एस के साथ जो कि इस प्रकार सावधानी से कहर बरपाता है।
$11~ऐसी पंक्ति पैदा करता है। अगले खंड में अगले ~स्वैप होता है <। <अंत में दूसरा एक नया डिजिट पेयर ब्लॉक (अंक एक्स और वाई को एएससीआईआई कोड के रूप में) खंड डी ब्लॉक में जोड़ता है।- अगले चक्र में,
~पंक्ति में एक ~~शेष है, जो ~निम्नलिखित पर एक स्वैप करता है )। अन्य <खंड डी को एक [)))~]ब्लॉक में जोड़ता है ।
- इसके बाद
~स्वैप किया गया नया खंड ई कोड के साथ निम्नलिखित खंड को स्वैप करता है। फिर एक नया बचे हुए भाग में ~एक स्वैप होता है ), और अंत में पंक्ति के अंतिम भाग ~~में से ~एक को खंड E पर स्वैप करता है जैसे कि )उसके ब्रैकेट को हटा दिया है।
अंतिम पुनरावृत्ति में, अनुभाग ए ~ने )खंड बी और खंड सी में स्वैप किया है । हालांकि, अनुभाग सी इतना अल्पकालिक है कि यह पहले से ही गायब हो गया है, और )अनुभाग डी की शुरुआत में समाप्त होता है।
अनुभाग डी
अनुभाग डी अंतिम बड़े अंक को प्रिंट करने और कार्यक्रम को रोकने का काम करता है। अधिकांश कार्यक्रम चलाने के दौरान, यह एक निष्क्रिय ब्लॉक है जो B-G निर्माण पर सहयोग करता है।
(H -
[H]-
⋮
[)))~[H-]] After one iteration of section C
⋮
[)))~[)))~[H-][49[49]]]] Second iteration, after E has also run
⋮
) [)))~[...]] [49[48]] Final printing starts as ) is swapped in
))) ~[...][49[48]]
)) )[49[48]] [...]
)) 49 [48][...] Print first 1
) )[48] [...]
) 48 [...] Print 0
)[...] Recurse to inner block
...
⋮
)[H-] Innermost block reached
H - Program halts
- कार्यक्रम के पहले चक्र में, कोष्ठक में
(रुकने के कार्य को लपेटता है H। ए- अनुसरण करता है, इसे डिजिट जोड़ी के बजाय पहले पुनरावृत्ति के लिए डमी तत्व के रूप में उपयोग किया जाएगा।
- निगमित की गई पहली वास्तविक अंक जोड़ी
[49[49]], 11अंक में अंतिम के समान है ।
- बहुत अंतिम अंकों की जोड़ी
[49[48]]( 10अंक के आरंभ में) वास्तव में ब्लॉक में शामिल नहीं है, लेकिन इससे कोई अंतर नहीं पड़ता है )[A[B]]और )[A][B]दोनों बराबर हो जाते हैं A[B]।
अंतिम पुनरावृत्ति के बाद, )खंड B से दाईं ओर स्वैप किया जाता है और अनुभाग D ब्लॉक को डीबॉक किया जाता है। )))~प्रत्येक उप-खंड की शुरुआत में यह सुनिश्चित करें कि सभी भागों सही क्रम में क्रियान्वित कर रहे हैं बनाता है। अंत में अंतरतम ब्लॉक में एक Hरुकने वाला कार्यक्रम होता है।
अनुभाग ई
सेक्शन E, सेक्शन G द्वारा निर्मित ASCII अंकों के युग्मों को संभालता है, और दोनों संबंधित एन्कोडेड वर्ण को प्रिंट करता है और संयुक्त जोड़ी के साथ ब्लॉक को C और D को छोड़ता है।
फिर नीचे के साथ एक विशिष्ट यात्रा से पता चलता xहै और yअंक 'ASCII कोड का प्रतिनिधित्व।
E F
~ [+$4--498+*-:~-10)):] ) < ~ [y] [x]
) [+$4--498+*-:~-10)):] < [x] [y]
+ $4- - 498 +*- :~ -10 ) ) : [x[y]]
+--- -{-498} +*- ~~{-10} ) ) [x[y]] [x[y]]
+-- - 498 +* -{-10} ~ ) x [y] [x[y]]
+- -{-498} + * 10 x )[y] [x[y]]
+ - 498 + {10*x} y [x[y]]
+ {-498} {10*x+y} [x[y]]
{10*x+y-498} [x[y]]
[x[y]]
- आने वाले अंक ब्लॉकों को स्वैप किया जाता है, फिर y ब्लॉक को x ब्लॉक में जोड़ा जाता है, और पूरे जोड़ी ब्लॉक को कॉपी किया जाता है। एक प्रतिलिपि तब तक छोड़ दी जाएगी जब तक कि अनुभाग C और D के लिए अंत नहीं होगा।
- अन्य प्रतिलिपि को फिर से डीबॉक किया जाता है, फिर गणना करने के लिए अंकगणितीय कार्यों का एक क्रम लागू होता है
10*x+y-498, एन्कोडिंग वर्ण का ASCII मान। 498 = 10*48+48-30, 48एस के ASCII एन्कोडिंग पूर्ववत xऔर yजबकि 30पाली से एन्कोडिंग 00–99के लिए30–129 है, जो सभी प्रिंट योग्य ASCII भी शामिल है।
- परिणामी संख्या को निष्पादित करने के लिए छोड़ दिया जाता है, जो इसके चरित्र को प्रिंट करता है।
अनुभाग एफ
धारा F में ASCII अंकों के कोड वाले निष्क्रिय ब्लॉक होते हैं। कार्यक्रम के अधिकांश भाग के लिए यहां दो सबसे अधिक संख्या में होंगे, चूंकि खंड ई उन्हें उसी गति से खपत करता है जो जी उनके साथ पैदा करता है। हालांकि, अंतिम मुद्रण चरण में कुछ अनावश्यक 0अंक यहां एकत्र होंगे।
[y] [x] ...
अनुभाग जी
धारा जी कार्यक्रम के अंत में बड़ी संख्या को विभाजित करने का काम करता है, पहले कम से कम महत्वपूर्ण अंक, और अपने ASCII कोड के साथ ब्लॉक भेजने के लिए अन्य वर्गों के लिए छोड़ दिया।
चूँकि इसकी कोई रुकने की जाँच नहीं है, यह वास्तव में 0अंकों का उत्पादन जारी रखेगा , जब तक कि संख्या 0 से कम नहीं हो जाती है, जब तक कि अनुभाग डी Hफ़ंक्शन के साथ पूरे कार्यक्रम को रोक नहीं देता है।
[BkG] बड़े शुरुआती कोड ब्लॉक की एक प्रति संक्षिप्त करता है, जिसका उपयोग नए पुनरावृत्तियों को शुरू करने के लिए स्व-प्रतिकृति के लिए किया जाता है।
पहले चक्रों में प्रारंभिक:
) :~ : [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:] ( 106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
) ~ ~ [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:] [BkG] [10...11]
) [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:] ~ [BkG] [10...11]
) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):] ~ : [10...11] [BkG]
विशिष्ट पुनरावृत्ति, Nविभाजित करने के लिए संख्या को दर्शाता है:
) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):] ~ : [N] [BkG]
) :~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+ :5 ) : [N] : [BkG]
) ~ ~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/] +5 5 ) [N] [N] [BkG] [BkG]
) [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/] ~ 10 N [N] [BkG] [BkG]
) ~:~ ~ ( [:~)*[):~[$1(+48]):~+]-:~~)10)~~] / N 10 [N] [BkG] [BkG]
) ~ : [:~)*[):~[$1(+48]):~+]-:~~)10)~~] ( {N/10} [N] [BkG] [BkG]
) [:~)*[):~[$1(+48]):~+]-:~~)10)~~] : [{N/10}] [N] [BkG] [BkG]
:~ )*[):~[$1(+48]):~+]- :~ ~)10 ) ~ ~ [{N/10}] [{N/10}] [N] [BkG] [BkG]
~~) *[):~[$1(+48]):~+]- ~~10 ) ) [{N/10}] ~ [{N/10}] [N] [BkG] [BkG]
) ~ * [):~[$1(+48]):~+] -10 ~ ) {N/10} [N] [{N/10}] [BkG] [BkG]
) [):~[$1(+48]):~+] * {-10} {N/10} ) [N] [{N/10}] [BkG] [BkG]
) :~ [$1(+48]) :~ + {-10*(N/10)} N [{N/10}] [BkG] [BkG]
) ~ ~ [$1(+48] ) ~ ~ {N%10} [{N/10}] [BkG] [BkG]
) [$1(+48] ~ ) {N%10} ~ [{N/10}] [BkG] [BkG]
$1( + 48 {N%10} ) [BkG] [{N/10}] [BkG]
( {48+N%10} BkG [{N/10}] [BkG] New iteration starts
[{48+N%10}] ....
- यहाँ देरी बूँद विशेष रूप से बालों वाली है। हालांकि, दो चक्रों में देरी के
+:5बजाय केवल नई देरी की चाल का उपयोग करना है। कार्यक्रम में एस के केवल एक सहयोगी ने इसके लिए मदद की थी।--101010
[N]और [BkG]ब्लॉक दोहराया गया है, की तो एक प्रतिलिपि Nसे विभाजित है 10।[{N/10}]को डुप्लिकेट किया जाता है, फिर अधिक अंकगणितीय फ़ंक्शन का उपयोग ASCII कोड के अंतिम अंक की गणना करने के लिए किया Nजाता है 48+((-10)*(N/10)+N)। इस ASCII कोड वाला खंड F के लिए छोड़ दिया गया है।- नई पुनरावृत्ति की शुरुआत करने के
[{N/10}]लिए [BkG]ब्लॉकों के बीच स्वैप की दूसरी प्रति प्राप्त होती है ।
बोनस क्वीन (540 बाइट्स)
)$$3371%%1[~!~~!)!]):[)$$20%%0[):]~)~~[)$$12%%0[<$$7%~~0):~[+----48+*-~~10))]<]<~!:~)~~[40~[:~))~:~[)~(~~/[+--48):]~10]+30])):]]][)[H]](11(06(06(21(21(25(19(07(07(19(61(96(03(96(96(03(11(03(63(11(28(61(11(06(06(20(18(07(07(18(61(11(28(63(96(11(96(96(61(11(06(06(19(20(07(07(18(61(30(06(06(25(07(96(96(18(11(28(96(61(13(15(15(15(15(22(26(13(12(15(96(96(19(18(11(11(63(30(63(30(96(03(28(96(11(96(96(61(22(18(96(61(28(96(11(11(96(28(96(61(11(96(10(96(96(17(61(13(15(15(22(26(11(28(63(96(19(18(63(13(21(18(63(11(11(28(63(63(63(61(11(61(42(63(63
इसे ऑनलाइन आज़माएं!
चूँकि मुझे यकीन नहीं था कि कौन सा तरीका सबसे छोटा होगा, इसलिए मैंने पहली बार वर्णों को कूटने की कोशिश की क्योंकि दो-अंको की संख्या (s से अलग हो गई । कोर कोड थोड़ा छोटा है, लेकिन 50% बड़ा डेटा प्रतिनिधित्व इसके लिए बनाता है। नहीं के रूप में एक दूसरे के रूप में गोल्फ, मैं बंद कर दिया जब मुझे एहसास हुआ कि यह इसे हरा नहीं होगा। इसका एक फ़ायदा है: इसे bignum समर्थन के साथ कार्यान्वयन की आवश्यकता नहीं है।
इसकी समग्र संरचना मुख्य एक के समान है। सेक्शन G सीधे F में डेटा प्रतिनिधित्व भरने के बाद से धारा G गायब है। हालाँकि, खंड E को दो-अंकीय संख्याओं के अंकों को फिर से बनाने के लिए एक समान दिव्य गणना करनी चाहिए।
