गोल्फस्क्रिप्ट, 59 51 50 चार्ट
प्रत्येक चरित्र को खोना अत्यंत कठिन है:
0[2.{).,2>{\.@%!},{.2$-.4$>{].p~\[}{;\;}if..}or}do
आउटपुट :
[2 3 1]
[3 5 2]
[7 11 4]
[23 29 6]
[89 97 8]
[113 127 14]
...
स्पष्टीकरण :
स्टैक सेट किया गया है, इसलिए प्रत्येक पुनरावृत्ति स्टैक के साथ शुरू होती है, शीर्ष दाईं ओर स्थित है। [वर्तमान सरणी मार्कर को इंगित करता है, जिसका अर्थ है जब दुभाषिया एक का सामना करना पड़ता ], शीर्ष करने के लिए निशान से ढेर पर सब कुछ एक सरणी में डाल दिया है।
g [ last | cur
gअब तक का अधिकतम अंतर है। ऊपर से नीचे:
command | explanation
-----------------+----------------------------------------
0[2. | initialize vars g=0, last=2, cur=2
{...}do | loop forever...
लूप के अंदर:
) | cur += 1
.,2>{\.@%!}, | put all divisors of cur into a list
{...}or | if the list is empty, cur is prime, so
| the block is executed. otherwise,
| 'do' consumes the stack, sees it is truthy,
| and loops again
यह एक सूची में सभी विभाजक कैसे डालता है? चलो यह कदम से कदम है
Command | explanation | stack
-----------------+----------------------------------------------+----------------
| initial stack | n
., | make list of 0..n-1 | n [0,1,...,n-1]
2> | take elements at index 2 and greater | n [2,3,...,n-1]
{...}, | take list off stack, then iterate through |
| the list. on each iteration, put the current |
| element on the stack, execute the block, and |
| pop the top of the stack. if the top is |
| true then keep the element, else drop it. |
| when done, push list of all true elements |
| So, for each element... | n x
\. | Swap & dup | x n n
@ | Bring x around | n n x
% | Modulo | n (n%x)
! | Boolean not. 0->1, else->0. Thus this is 1 |
| if x divides n. | n (x divides n)
| So only the divisors of n are kept | n [divisors of n]
यदि भाजक खाली हैं तो यह क्या करता है?
Command | explanation | stack
-----------------+----------------------------------------------+----------------
| initial stack | g [ last | cur
. | dup | g [ l | c | c
2$ | copy 3rd down | g [ l | c | c | l
- | sub. This is the current gap, cur-last | g [ l | c | c-l
. | dup | g [ l | c | c-l | c-l
4$ | copy 4th down | g [ l | c | c-l | c-l | g
> | is cur gap > max gap so far? | g [ l | c | c-l | c-l>g
{#1}{#2}if.. | #1 if c-l > g, #2 otherwise, and do ".." in | ... | g [ c | c | c
| either situation |
दो रास्ते: हाँ और नहीं। यदि हाँ (ध्यान दें कि ifस्टैक पर शीर्ष मूल्य का उपभोग करता है):
Command | explanation | stack
-----------------+----------------------------------------------+----------------
| initial stack. note that now the old `g` is | XX [ l | c | g
| garbage and `c-l` is the new `g`. |
] | close the array | XX [l, c, g]
.p | duplicate it and print it, consuming the dup | XX [l, c, g]
~ | pump array back onto the stack. Note now the | XX | l | c | j
| array marker [ is gone. |
\ | swap. | XX | l | g | c
[ | mark the array | XX | l | g | c [
. | this is the part after the if. dups the top, | XX | l | g [ c | c
| but it does this in two steps, first popping |
| c then putting two copies on top, so the |
| array marker moves |
. | dup again | XX | l | g [ c | c | c
यदि नही:
Command | explanation | stack
-----------------+----------------------------------------------+----------------
| initial stack. In this case g is still the | g [ l | c | c-l
| max gap so far |
;\; | dump top of stack, swap, and dump again | g [ c
.. | the part after the if. dup twice | g [ c | c | c
या तो मामले में ध्यान दें, हमारा स्टैक अब फॉर्म में है ... | g [ c | c | c।
अब doस्टैक से शीर्ष मान को चबूतरे - हमेशा c- और लूप्स यदि यह सकारात्मक है। चूंकि cहमेशा बढ़ते हुए, यह हमेशा सच होता है, इसलिए हम हमेशा के लिए लूप करते हैं।
एक बार पॉप करने के बाद, स्टैक का शीर्ष है g [ c | c, जिसका अर्थ है कि अंतिम रूप से अपडेट किया गया है c, सरणी का निशान उसी स्थान पर है, और gअभी भी वह जगह है जहां हम इसकी उम्मीद करते हैं।
ये GolfScript के जटिल ऑपरेशन हैं। मुझे आशा है कि आपको साथ में मज़ा आया!