आपको एक पॉलीग्लॉट बनाना चाहिए जो एक भाषा में इनपुट के वर्ग और दूसरे में इनपुट के वर्गमूल को आउटपुट करता है। बाइट्स जीत में सबसे छोटा जवाब!
आपके पास कम से कम 3 दशमलव स्थानों की सटीकता होनी चाहिए, और इनपुट हमेशा एक सकारात्मक फ्लोट होगा।
आपको एक पॉलीग्लॉट बनाना चाहिए जो एक भाषा में इनपुट के वर्ग और दूसरे में इनपुट के वर्गमूल को आउटपुट करता है। बाइट्स जीत में सबसे छोटा जवाब!
आपके पास कम से कम 3 दशमलव स्थानों की सटीकता होनी चाहिए, और इनपुट हमेशा एक सकारात्मक फ्लोट होगा।
जवाबों:
U
जोल्फ में स्क्वायर रूट, MATL में वर्ग।
इसे ऑनलाइन आज़माएं! (Matl)
जुल्फ कोड की कोशिश करो। केवल फ़ायरफ़ॉक्स पर काम करता है।
ये दोनों 1 बाइट हैं, क्योंकि MATL और जोल्फ दोनों ASCII / विस्तारित ASCII कोडपे का उपयोग करते हैं, इसलिए सभी कमांड 1 बाइट हैं।
#include<math.h>
float f(float n){auto p=.5;return pow(n,2-p*3);}
मूल उत्तर:
#include<math.h>
float f(float n){return pow(n,sizeof('-')-1?2:.5);}
दोनों संस्करणों के लिए, C का उत्पादन n^2
और C ++ का उत्पादन होता है sqrt(n)
।
auto
"स्टैक पर आवंटित" का अर्थ है। यह कीवर्ड काफी बेकार है क्योंकि यह वैसे भी डिफ़ॉल्ट है, इसलिए C ++ ने इसका अर्थ कुछ और बताया। सी में, हालांकि, यह p
(यह एक भंडारण वर्ग है, एक प्रकार नहीं है) के प्रकार के बारे में कोई राय व्यक्त नहीं करता है , इसलिए यह int
डिफ़ॉल्ट रूप से गिना जाता है (यह डिफ़ॉल्ट-टू- int
व्यवहार आजकल हतोत्साहित किया जाता है, और संभावना केवल इसलिए मौजूद है क्योंकि सी के कुछ पूर्ववर्तियों में डेटा प्रकार बिल्कुल नहीं थे, लेकिन कंपाइलर अभी भी इसे समझते हैं)। और हां, (int)0.5
0. है
n^2
।
lambda n:n**(1/2or 2)
पायथन 2.x का उत्पादन n^2
, पायथन 3.x का उत्पादन करता है sqrt(n)
।
2 बाइट्स @ धन्यवाद के लिए बच गए!
or
?
/
पूर्णांक विभाजन ( 1/2==0
) करता है। Py3 में, यह फ्लोटिंग पॉइंट डिवीजन करता है ( 1/2==0.5)
! 0
फाल्सी है।
*.
2sable वर्ग की गणना करता है। इसे ऑनलाइन आज़माएं!
जेली वर्गमूल की गणना करती है। इसे ऑनलाइन आज़माएं!
* Read the input twice and compute the product of both copies.
This pushes the square of the input.
. Unrecognized token (ignored).
. Numeric literal; yield 0.5.
* Raise the input to the power 0.5.
This yields the square root.
#/*
lambda n:n**.5;'''*/
float a(i){return i*i;}//'''
अजगर: यह ऑनलाइन कोशिश करो!
पॉलीग्लॉट टिप्पणियों का उपयोग करके काम करता है। बाकी बहुत व्याख्यात्मक है।
पहली बार सी का उपयोग कर!
return 0;
अंत से चूक सकते हैं- C99 main()
विशेष रूप से 0 का निहित रिटर्न देता है । स्रोत
stdio.h
उस मामले में शामिल करने की आवश्यकता है ?
ओम में वर्ग को आउटपुट करता है, जेली में वर्गमूल।
ओम और जेली अलग-अलग सिंगल-बाइट कोडपेस का उपयोग करते हैं, इसलिए प्रोग्राम प्रत्येक एन्कोडिंग में अलग-अलग दिखाई देगा।
कार्यक्रम का xxd हेक्सडंप:
00000000: fd7f 0a ...
जेली के कोडपेज का उपयोग करना, यह इस तरह दिखाई देता है:
’
½
जेली अपने मुख्य लिंक होने के लिए सबसे नीचे की रेखा को लेती है, और अन्य लिंक को अनदेखा करती है जब तक कि विशेष रूप से नहीं बुलाया जाता है। तो यहाँ यह सिर्फ वर्गमूल ( ½
) करता है और इसे संक्षेप में आउटपुट करता है।
ओम के कोडपेज (CP437) का उपयोग करते हुए, यह इस तरह दिखाई देता है:
²⌂◙
²
वर्ग समारोह है, और ⌂
और ◙
दोनों अपरिभाषित है, तो कार्यक्रम सिर्फ वर्गों परोक्ष इनपुट पढ़ सकते हैं और परोक्ष यह आउटपुट।
½
बाइट पाने के लिए जेली कोड पेज का उपयोग करते हैं , तो ²
मैप क्या करता है? क्या यह सिर्फ कबाड़ है जिसे अभी भी अनदेखा किया गया है? और इसके विपरीत ओम के लिए? तब यह 2 बाइट्स लगता है।
²
ओम में कोड बिंदु 5 पर है। जेली में कोड बिंदु 5 है %
और कुछ भी नहीं करता है, इसलिए यह कोई फर्क नहीं पड़ता कि पहली पंक्ति क्या है। मान लीजिए कि ½
जेली 27 पर है, और ओह्म में कोड बिंदु 27 है J
और कुछ भी नहीं करता है, इसलिए यह मायने नहीं रखता कि दूसरी पंक्ति क्या है। इस प्रकार, यदि आपके पास फ़ाइल है 00000101<newline>00011011
, तो यह 3 बाइट्स है। मुझे लगता है कि एकमात्र समस्या यह है कि अगर नईलाइन कोड पृष्ठों में एक अलग स्थान पर है।
float f(float n){return n//*
/sqrt(n)//*/1*n
;}
-lm
ध्वज की आवश्यकता है (+3)
C89 पैदा करता है n^2
, C99 पैदा करता है sqrt(n)
। C89 में परीक्षण करने के लिए, इसे ऑनलाइन आज़माएं!
sqrt
संस्करण को करने के लिए C89 को कम कोड लेना चाहिए, लेकिन यह s के sqrt
साथ फ़ंक्शन को स्पष्ट रूप से घोषित करने पर जोर देता है int
, इसलिए यह सबसे अच्छा है जिसे मैं प्रबंधित कर सकता हूं।
@(x)x^(2-3*any(version>60)/2)
यह ऑक्टेव में वर्ग और MATLAB में वर्गमूल का उत्पादन करता है।
स्पष्टीकरण:
वाक्य रचना MATLAB और ऑक्टेव (कोड के इस छोटे से टुकड़े के लिए) में समान है।
यह एक अनाम फ़ंक्शन बनाता है:
@(x) % Take x as input
x^( ) % Raise x to the power of ...
version % Returns the version number
% 4.2.0 in Octave,
% '9.2.0.538062 (R2017a)' in MATLAB
version>60 % 'R' is larger than 60. All others are smaller
3*any(version>60)/2 % Checks if there is an 'R' and multiplies it by 1.5 if it is.
2-3*any(version>60) % 2-1.5*(is there an 'R')
sqr(x)
बेसिक में स्क्वायर रूट और डेल्फी में स्क्वायर।
आप अभिव्यक्ति का निरीक्षण करने के लिए डिबगर का उपयोग कर सकते हैं, जिससे किसी भी आउटपुट आवश्यकताओं को पूरा किया जा सकता है!
x
? आप मान नहीं सकते कि यह किसी मूल्य पर सहेजा गया है। लेकिन आप वास्तव में (x)
एक समारोह में लौटने के रूप में इसे हटाने और लेबल करने में सक्षम हो सकते हैं ।
निम्नलिखित बाइट्स कार्यक्रम बनाते हैं:
FD B9 74
05AB1E वर्गमूल, फायरबॉल वर्गों की गणना करता है।
स्पष्टीकरण (05AB1E - ý¹t
):
ý Pushes an empty string to the stack (not entirely sure why)
¹ Push first input
t Square root
स्पष्टीकरण (आग का गोला - ²╣t
):
² Square input
╣ Unassigned
t Unassigned
कभी-कभी, यह एक अधूरी भाषा होने में मदद करता है;)
यह वास्तव में मेरी अपेक्षा से अधिक चुनौतीपूर्ण था! मुझे काफी आश्चर्य है कि मेरा कोड कितना लंबा है।
eval(['alert((_=prompt())*_)','echo$argv[1]**.5'][+![]]);
यह कैसे काम करता है?
यह सरणी से चलाने के लिए कोड का चयन करके काम करता है।
PHP और JavaScript का पता लगाया जाता है +![]
।
PHP में, []
(खाली सरणी) एक मिथ्या मूल्य है, जबकि जावास्क्रिप्ट में यह एक सत्य मूल्य है (ऑब्जेक्ट्स (को छोड़कर null
) हमेशा सत्य होते हैं, यहां तक new Boolean(false)
कि सत्य भी है!)।
लेकिन, मुझे इसे एक संख्यात्मक मान प्राप्त करने की आवश्यकता है, इसलिए, मैं सिर्फ एक not
( !
) का उपयोग करता हूं और इसे पूर्णांक ( +
) के साथ परिवर्तित करता हूं ।
अब, 1
जावास्क्रिप्ट मूल्य देता है , जबकि जावास्क्रिप्ट पैदावार 0
।
एक कोड के अंदर कोड को रखने, उन अनुक्रमित पर, हमें वांछित भाषा के लिए सही कोड का चयन करने की अनुमति देगा।
इसका उपयोग [JS,PHP][+![]]
सही भाषा का कोड प्राप्त करने के लिए किया जा सकता है ।
पिछले पॉलीग्लॉट पर, मैंने उपयोग किया है '\0'=="\0"
, जो true
जावास्क्रिप्ट में है (चूंकि \0
NULL-बाइट के रूप में पार्स किया गया है) और false
PHP में ( '\0'
NULL-बाइट के रूप में पार्स नहीं किया जाएगा, NULL-बाइट के \0
साथ शाब्दिक स्ट्रिंग की तुलना में )।
मुझे खुशी है कि मैं इस चेक को कम करने में कामयाब रहा +!'0'
।
मैं @rckd के बारे में और अधिक खुश हूं , जिसने इसे वर्तमान संस्करण में घटा दिया!
वहाँ से, यह बस eval
आवश्यक कोड है।
पीएचपी
PHP 2 तर्क से मूल्य प्राप्त करने और मानक आउटपुट में प्रदर्शित करता है echo$argv[1]**.5
(के बराबर echo sqrt($argv[1]);
, वर्ग-रूट संख्या) निष्पादित करेगा ।
जावास्क्रिप्ट
जावास्क्रिप्ट निष्पादित करता है alert((_=prompt())*_)
, जो एक में वर्ग संख्या प्रदर्शित करता है alert
।
1 बाइट बचाने के लिए @rckd और 3 बाइट बचाने के लिए @ user59178 धन्यवाद !
echo$argv[1]**.5
इसके बजाय 3 बाइट्स बचा सकते हैंecho sqrt($argv[1])
nqƓ½
nq # Ignored by Jelly, push n**2 in 05AB1E then quit.
Ɠ½ # Ignored by 05AB1E due to quit, push sqroot of input in Jelly.
किसी और ने एक अच्छी बात की, मुझे लगता है कि यूटीएफ -8 के पात्रों को कोड पृष्ठों में एक ही ऑपरेशन साझा नहीं किया गया है कि वे प्रत्येक को एनकोड करने के लिए तकनीकी रूप से 2-बाइट्स हैं। हालाँकि, जब इसे हेक्स डंप के संदर्भ में देखते हैं:
6e 71 93 0a
05AB1E के CP1252 में इस परिणाम को एन्कोडिंग:
nq“\n
इसका मतलब यह है कि यह अभी भी वर्ग का उत्पादन करेगा और बाकी को अनदेखा करेगा। जब ये बाइट्स जेली के कोडपेज का उपयोग करके एन्कोडेड होते हैं:
nqƓ½
निष्पादित होने पर मूल इच्छित कोड, इनपुट लेने और sqrt लेने के वांछित परिणाम में परिणाम होता है।
Ɠ
और ½
दो बाइट्स को एन्कोड करने की आवश्यकता होती है। हालांकि, बाइट अनुक्रम 6e 71 93 0a
( सीपी -125 के nqƓ½
लिए जेली के nq“\n
लिए) दोनों भाषाओं में काम करना चाहिए।
½
दोनों कोड-पेज पर होने के कारण इसे एक एकल के रूप में गिनने की अनुमति नहीं है क्योंकि वे अलग-अलग ऑपरेशन हैं जो मुझे लगता है? मैं अभी भी पूरे पृष्ठ-पृष्ठ की चीज़ पर फ़र्ज़ी हूं।
6e 71 93 0a
इसलिए 4 बाइट्स का दावा करने के बारे में कोई "सैद्धांतिक रूप से" नहीं है। बस 4 बाइट्स का दावा करें। यह सिर्फ इतना होता है कि 05AB1E के मानक एन्कोडिंग में, यह एक चीज़ पढ़ता है, जो आप चाहते हैं, जबकि जेली के मानक एन्कोडिंग में, यह एक और पढ़ता है जो आपको चाहिए। एक तरफ के रूप में, सिर्फ 2 एनकोडिंग एक ही चरित्र को सांकेतिक शब्दों में बदलना कर सकते हैं इसका मतलब यह नहीं है कि उन दोनों में चरित्र समान होगा। बस पहले से साझा किए गए एक लुकिंग टेबल के साथ संख्यात्मक साइबरफोर जैसे एन्कोडिंग के बारे में सोचें और उम्मीद है कि यह आपको एक अच्छा शुरुआती मानसिक-मॉडल देगा।
ld_*GX^!
CJam में वर्ग की गणना करता है ( इसे ऑनलाइन आज़माएं! ) और MATL में वर्गमूल ( इसे ऑनलाइन आज़माएं! )।
ld e# Read input line and interpret as a double
_ e# Duplicate
* e# Multiply. Pops the input number twice, pushes its square
G e# Push 16
X e# Push 1
^ e# Bitwise XOR. Pops 16 and 1, and pushes 17
! e# Negate. Pops 17, pushes 0
e# Implicitly display. This prints the squared input with decimals,
e# immediately followed by the 0 coming from the negate operation
e# Even if the square of the input number is an integer, say 5,
e# it is displayed as 5.0, so including an extra 0 always gives a
e# correct result
l % Push 1. This is a number or equivalently a 1×1 array
d % Consecutive differences. Pops 1, pushes [] (empty array)
_ % Negate (element-wise). This leaves [] as is
* % Implicitly input a number and push it. Multiply (element-wise):
% pops [] and the input number, pushes []
G % Push input number again
X^ % Square root. Pops number, pushes its square root
! % Transpose. For a number (1×1 array) this does nothing
% Implicitly display. The stack contains [] and the result; but
% [] is not displayed at all
( """ )
fsqrt
\ """);lambda n:n*n
इसे ऑनलाइन आज़माएँ: पायथन 2 (वर्ग) | फोर्थ (sqrt)
यह पायथन में एक अनाम फ़ंक्शन और fsqrt
फोर्थ में एक अंतर्निहित फ़ंक्शन का मूल्यांकन करता है। पैंथन में लैम्बडा के सामने f
रखकर 2 बाइट्स के लिए एक नामित फ़ंक्शन हो सकता है f=
।
फोर्थ कार्यक्रम एक अस्थायी बिंदु शाब्दिक लेता है , जिसे फोर्थ में वैज्ञानिक संकेतन में लिखा जाना चाहिए। पाई को 3 दशमलव स्थानों पर काट दिया 3.141
जाएगा ( ) इस तरह लिखा जाएगा:
3141e-3
f=a=>eval(`try{eval("a**2")}catch(e){Math.sqrt(a)}`)
ES7 में इनपुट के वर्ग और ES6 में वर्गमूल को लौटाता है। जब तक आपके पास एक पुराना ब्राउज़र नहीं है जो ईएस 6 का समर्थन करता है लेकिन ईएस 7 का समर्थन नहीं करता है, तब तक परीक्षण करना कठिन है।
f=a=>eval(`try{eval("a**2")}catch(e){Math.sqrt(a)}`)
console.log(f(4));
ECHO"$argv[1]"**2;#];rdmq
PHP में वर्ग और CJam में वर्गमूल की गणना करता है। -r
PHP में उपयोग करके चलाया जाना है ।
पहली कमांड लाइन तर्क ( $argv[1]
) को शक्ति 2 तक बढ़ाता है और इसे आउटपुट करता है। यहां $argv[1]
वास्तव में एक स्ट्रिंग में इनलाइन चर के रूप में डाला गया है, जो एक्सप्रेशन करने से पहले एक नंबर पर डाली जाती है। ऐसा इसलिए है क्योंकि v
CJam में एक वैध निर्देश नहीं है और इसे पार्स करते समय त्रुटि का कारण होगा, लेकिन इसे स्ट्रिंग में डालने से कोई समस्या नहीं होगी।
#
टिप्पणी शुरू करता है, इसलिए बाद में सब कुछ नजरअंदाज कर दिया जाता है।
कोड का पहला भाग, ECHO"$argv[1]"**2;#
मूल्यों का एक गुच्छा धक्का देता है और संचालन का एक गुच्छा करता है, जो सभी अच्छी तरह से बेकार हैं। एकमात्र महत्वपूर्ण बात यह है कि वे किसी भी त्रुटि का कारण नहीं बनते हैं, क्योंकि इसके बाद सही है ];
, जो एक सरणी में पूरे स्टैक को लपेटता है और फिर इसे त्याग देता है।
उसके बाद, यह इनपुट ( rd
) से एक डबल पढ़ता है , और अपने वर्गमूल ( mq
) को प्राप्त करता है, और अंतर्निहित रूप से इसे आउटपुट करता है।
;float f(float x){return sqrt(x);}char*
F="_this^2";
OFP स्क्रिप्ट में, एक लाइन की शुरुआत में एक अर्धविराम उस पंक्ति को एक टिप्पणी करता है, जबकि C अतिरिक्त अर्धविराम के बारे में परवाह नहीं करता है।
सी:
OFP स्क्रिप्टिंग भाषा:
init.sqs
मिशन फ़ोल्डर में के रूप में सहेजें , फिर इसके साथ कॉल करें hint format["%1", 2 call F]
।
2 डी भाषाएं!
/&:*.@
>in:o#p;
/&:*.@
/ divide top two (no-op)
& read decimal input
: duplicate
* square
. output
@ terminate
/ mirror up, then right
>in:o#p;
i read line of input
n cast to number
:o# square root
p print
; terminate
यार, मैं वास्तव में जेली लिंक संरचना के साथ मज़े कर रहा हूं।
:*n;
½
-v
[शीर्ष मत वाले उत्तर] ( codegolf.meta.stackexchange.com/a/11431/44874 ) के अनुसार, मेरी राय में इसका उपयोग होता है । ><>
दुभाषिया कि जरूरत है -v
और इस सरल संभव मंगलाचरण की वजह है।
0//1or exec("function=lambda a:(lambda b:a);x=0")
y=2//2/2
f=(function(x)(x**y))//1 or(lambda x:x**y)
जेएस में स्क्वायर रूट, पायथन में स्क्वायर।
फ़ायरफ़ॉक्स पर काम करता है (FF 52 पर परीक्षण किया गया है) और (function(x) x)(42) === 42
वैध सिंटैक्स होने की आवश्यकता है । **
ऑपरेटर के लिए भी ES7 की आवश्यकता होती है ।
x=>x**y
बजाय उपयोग करना संभव है ? या अजगर उस पर झपटा होगा?
function
यह कोई कीवर्ड नहीं है, इसलिए यह एक मान्य पहचानकर्ता है। इसलिए मैंने अभी इसे ( exec
बयान के अंदर ) एक नूप फ़ंक्शन सौंपा ।
अपडेट: मुझे हार माननी चाहिए। डिजिटल ट्रॉमा का बैश / श जवाब इस से कहीं अधिक सुरुचिपूर्ण है।
bc -l<<<"sqrt($1^(($(kill -l|wc -l)*3-3)/7+1))"
बैश पैदा करता है n^2
, श पैदा करता है sqrt(n)
।
bc
की जरूरत है ताकि sqrt
गणना की जा सके। व्यवहार में अंतर बैश और श के बीच है।
ठीक है, तकनीकी रूप से "श" जो मैं उपयोग कर रहा हूं वह अभी भी बैश है, लेकिन "पॉसिक्स" मोड में बैश करें (जो तब होता है जब आप सिस्टम के /bin/sh
बजाय इनवॉइस करते /bin/bash
हैं जहां /bin/sh
बैश के लिए एक उपनाम है)। यदि आपके सिस्टम पर ऐसा है, तो आप इसके साथ परीक्षण कर सकते हैं:
/bin/bash prog.sh 4
/bin/sh prog.sh 4
यह यहां बताए गए मतभेदों पर आधारित है: https://www.gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html
kill -l
(संभावित संकेतों को सूचीबद्ध करता है; कुछ भी नहीं बदलता है) bash
और में sh
। यह कई अंतरों में से एक है जो आप यहां पा सकते हैं: gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html
input a
?a^2'^.25
में QBasic , यह एक संख्या लेता है, और प्रिंट उस नंबर चुकता। बाकी कोड को अनदेखा कर दिया गया है क्योंकि QBasic इसे एक टिप्पणी ( '
) के रूप में देखता है ।
QBIC उसी इनपुट स्टेटमेंट का उपयोग करता है। इसके बाद यह उसी संख्या को मुद्रित करने के लिए चला गया, फिर एक चौथाई की शक्ति के लिए उठाया, प्रभावी रूप से इसे दो बार जड़ दिया। ऐसा इसलिए है क्योंकि '
एक कोड शाब्दिक के रूप में देखा जाता है: शुद्ध QBasic कोड जिसे QBIC द्वारा पार्स नहीं किया गया है।
संपादित करें: यह उल्टे कार्यों के लिए एक बाइट है।
RTa
²
जेली कोड (इसके 'मुख्य लिंक') के नीचे से निष्पादन शुरू करता है और देखता है कि क्या उसे कुछ अधिक की आवश्यकता है: यह कमांड को स्क्वायर में देखता है और इनपुट और आउटपुट का ध्यान रखता है।
पिप शीर्ष रेखा को कार्यान्वित करता है, स्क्वायर्ड करता है (cmd लाइन से स्पष्ट रूप से पढ़ा जाता है) var का और अनुमानित प्रिंट। नीचे की रेखा को अनदेखा किया जाता है।
PRTaVS
:।
वुल्फ्राम भाषा में एक नंबर का वर्ग प्राप्त करें और PHP में वर्गमूल प्राप्त करें;
n^2
echo sqrt(_GET["n"]);
पहली पंक्ति वोल्फ्राम भाषा है। सबसे पहले, आप वोल्फ्राम अल्फा में सर्चबार में n को बदलने वाले हैं, इसलिए कोड भी इनपुट है। फिर यह एंटर दबाने पर जवाब जेनरेट करेगा
n^2
दूसरी लाइन PHP है, इसे n का वर्गमूल मिलता है जिसे एड्रेस बार में इनपुट करना होता है (जैसे। ppcg.php.net?n=213, जहां 213 n का मान है)
echo sqrt($_GET["n"]);
p=^4 :
bc<<<"sqrt($1)$p"
मैक पर, sh
है bash
Posix मोड में चल रहा है, और के अनुसार इस मामले में https://www.gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html :
POSIX विशेष बिलिन से पहले असाइनमेंट स्टेटमेंट बिलिन पूरा होने के बाद शेल वातावरण में बने रहते हैं
इस प्रकार sh
, चर के चलने के बाद p
मान होता है, लेकिन इसके लिए , चर का केवल मूल्य होता है जबकि इसे चलाया जाता है, और बाद में खाली होता है।^4
:
bash
p
:
अभी भी वास्तव bash
में कवर के तहत, कुछ बैशमिज़ जैसे कि <<<
हेर्स्ट्रेस अभी भी बैश और श दोनों मामलों के लिए काम करते हैं।
उबंटू 16.01 पर, sh
एक सिम्लिंक dash
है, जो <<<
बगुले नहीं करता है । इसलिए हमारे पास इसके बजाय:
p=^4 :
echo "sqrt($1)$p"|bc
यह कार्यक्रम कार्डिनल में इनपुट को वर्ग करता है और ऑक्टेव में वर्गमूल प्राप्त करता है
%:=t.
disp(sqrt(input("")))
इसे ऑनलाइन आज़माएं! (कार्डिनल)
अतः ओक्टेव में% सिंगल लाइन टिप्पणी है इसलिए यह केवल इनपुट प्राप्त करता है और वर्गमूल को प्रिंट करता है
disp(sqrt(input("")))
ताकि कार्डिनल प्रोग्राम 0 एरर और डायट, प्रोग्राम से डिवाइड का सामना न करे
%:=t.
एक स्थान के साथ स्थानांतरित कर दिया गया है, जिसे दोनों कार्यक्रमों द्वारा अनदेखा किया गया है
कार्यक्रम% पर शुरू होता है
यह इनपुट प्राप्त करता है और मूल्य को सक्रिय के रूप में संग्रहीत करता है:
यह निष्क्रिय को सक्रिय के बराबर होने के लिए सेट करता है =
यह निष्क्रिय टी द्वारा सक्रिय को गुणा करता है
अंत में यह सक्रिय मूल्य को आउटपुट करता है।
<body onload=alert(<?=$x*$x.')>'.sqrt($x)?>
इनपुट इस प्रकार है:
<?php $x = 10; ?>
किंडा आत्म-व्याख्या करता है, लेकिन क्या यह नियमों के अनुकूल है? मेरा पहला कोड गोल्फ थो :-)
alert(<?=$x*$x.')>'.sqrt($x)?
)
गैर-प्रतिस्पर्धात्मक क्योंकि:
+
और ⓟ
, CGL तकनीकी रूप से एक वैध भाषा है। x=>x**2
//-₂
सरल: एक अनाम तीर फ़ंक्शन जो अपने पहले तर्क को चुकता करता है। अनाम भाषा कोड पर टिप्पणी की गई है।
नॉन-ब्रेकिंग स्पेस पहली पंक्ति से पहले एक टिप्पणी की तरह कार्य करता है। /
कोई-ऑप्स कर रहे हैं। -
दूसरी पंक्ति में वर्तमान ढेर संख्या है, जो डिफ़ॉल्ट रूप से 0. है तो -1, जहां इनपुट संग्रहीत किया जाता है करने के लिए यह सेट यही कारण है कि घटती का मतलब है। ₂
इसके वर्गमूल, जो अब वह जगह है जहाँ इनपुट रख दिया गया है के साथ मौजूदा ढेर में पहला आइटम बदल देता है। डिफ़ॉल्ट रूप से, वर्तमान स्टैक आउटपुट होता है, इनपुट के वर्गमूल को आउटपुट करता है।