अरीबास - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

अरीबास - बहुसटीक अंकगणित दुभाषिया

SYNOPSIS

अरिबास [विकल्पों] [ari-file> [आर्ग1>आर्ग2> ...]]

यह मैन पेज डेबियन के लिए लिखा गया था क्योंकि मूल सॉफ़्टवेयर में कोई मैन नहीं था
इस पृष्ठ पर ज़ूम कई वीडियो ट्यूटोरियल और अन्य साहायक साधन प्रदान करता है।

वर्णन

अरीबास बड़े पूर्णांक अंकगणित के लिए उपयुक्त एक इंटरैक्टिव दुभाषिया है
बहुपरिशुद्धता फ़्लोटिंग पॉइंट अंकगणित। इसका सिंटैक्स पास्कल या मोडुला-2 के समान है,
लेकिन इसमें सी, लिस्प, ओबेरॉन जैसी अन्य प्रोग्रामिंग भाषाओं की विशेषताएं भी शामिल हैं।

उपयोग

उपयोग करने का सबसे आसान तरीका अरिबास (बड़े पूर्णांक) अंकगणित के लिए एक कैलकुलेटर के रूप में है। बाद
अरिबास प्रारंभ हो गया है, यह एक संकेत प्रदर्शित करता है ==> और इनपुट स्वीकार करने के लिए तैयार है. बस दर्ज करें
जिस अभिव्यक्ति की आप गणना करना चाहते हैं, उसके बाद पूर्ण विराम लगाएं और फिर रिटर्न दबाएँ
उदाहरण

==> 123 + 456*789.

अरीबास जवाब

-: 359907

प्रतीक -: परिणाम का परिचय देता है.
जरूरी। अपने इनपुट के अंत को चिह्नित करने के लिए, आपको हमेशा पूर्ण विराम 'टाइप करना होगा।' और तब
रिटर्न दबाएँ.

आप गणना के परिणाम को एक वेरिएबल पर निर्दिष्ट कर सकते हैं, जैसे कि

==> F6 := 2**64 + 1.
-: 18446_74407_37095_51617

यह छठे फ़र्मेट नंबर की गणना करता है (** घातांक को दर्शाता है) और इसे निर्दिष्ट करता है
परिवर्तनशील F6 (ध्यान दें कि अरिबास केस संवेदनशील है, इसलिए यह वैसा नहीं है f6). बाद में
उदाहरण के लिए आप इस वेरिएबल का उपयोग अभिव्यक्ति में कर सकते हैं

==> 123**(F6 - 1) मॉड F6।
-: 688_66214_58712_63971

जो दर्शाता है (फर्मेट के प्रमेय द्वारा) कि F6 एक अभाज्य संख्या नहीं है।
तीन सबसे हालिया परिणाम छद्म चर में संग्रहीत हैं _, __, तथा ___. के लिए
उदाहरण के लिए आप अंतिम परिणाम को कमांड द्वारा वेरिएबल x में संग्रहीत कर सकते हैं

==> एक्स := _.
-: 688_66214_58712_63971

जैसा कि आप उपरोक्त उदाहरणों में देख सकते हैं, अरिबास अंडरस्कोर का उपयोग करता है _ आउटपुट की संरचना करने के लिए
बड़े पूर्णांकों का (>= 2**32). इसके अलावा पूर्णांकों के इनपुट के लिए आप अंडरस्कोर का उपयोग कर सकते हैं
एकमात्र शर्त यह है कि अंडरस्कोर के ठीक पहले और बाद में अंक हों,
उदाहरण:

==> z := 123_4567_890.
-: 1234567890

यहां आउटपुट में कोई अंडरस्कोर नहीं है, जो दर्शाता है कि z 2**32 से कम है।

अरीबास उदाहरण के लिए, गुणनखंडन के लिए कई अंतर्निहित कार्य हैं rho_factorize, जो
पोलार्ड के rho एल्गोरिदम का उपयोग करता है।

==> rho_factorize(F6).

कार्यरत ..
512 पुनरावृत्तियों के बाद कारक मिला

-: 274177

शेष सहकारक खोजने के लिए, आदेश दें

==> x := F6 div _.
-: 6728_04213_10721

यह जांचने के लिए कि क्या यह कारक प्रधान है, राबिन का संभाव्य परीक्षण रब_प्राइमटेस्ट हो सकता है
लागू:

==> रब_प्राइमटेस्ट(x).
-: सत्य

समारोह rho_factorize छोटे गुणनखंड खोजने के लिए अच्छा है (जैसे 10 दशमलव तक)।
अंक); अधिक जटिल गुणनखंडन कार्यों के लिए अधिक शक्तिशाली एल्गोरिदम जैसे
द्विघात छलनी qs_factorize इस्तेमाल किया जाना चाहिए

==> qs_factorize(2**128+1).

(आपके कंप्यूटर की शक्ति के आधार पर, इसमें कुछ सेकंड से लेकर कुछ मिनट तक का समय लगेगा
7वीं फ़र्मेट संख्या का अभाज्य गुणनखंड प्राप्त करने के लिए।)

नियंत्रण संरचनाओं
RSI एसटी पाश और जब फंदे में आना अरिबास मॉड्यूला-2 की तरह एक वाक्यविन्यास है। उदाहरण के लिए,
निम्नलिखित कमांड अनुक्रम 100 के फैक्टोरियल की गणना करता है।

==> एक्स := 1;
i: = 2 से 100 करते हैं
एक्स := एक्स*आई;
अंत;
x.

जैसा कि आप इस उदाहरण में देख सकते हैं, इनपुट कई पंक्तियों तक विस्तारित हो सकता है।

ऊपर एसटी लूप निम्नलिखित के बराबर है जब पाश

==> एक्स := 1; मैं := 2;
जबकि मैं <= 100 करता हूँ
एक्स := एक्स*आई;
इंक(आई);
अंत;
x.

शाखा निर्माण
if ... फिर ... एल्सिफ़ ... अन्य ... समाप्त
इसका सिंटैक्स भी मॉड्यूला-2 जैसा ही है।

बहु परिशुद्धता चल बिन्दु अंकगणित
अरीबास विभिन्न प्रकार के फ़्लोटिंग पॉइंट नंबरों का समर्थन करता है जिन्हें आंतरिक रूप से दर्शाया जाता है
विभिन्न बिट-लंबाई के मंटिसा के साथ:

सिंगल_फ्लोट 32 बिट्स
डबल_फ्लोट 64 बिट्स
long_float 128 बिट्स

और कार्यान्वयन पर निर्भर सीमा तक कई उच्च परिशुद्धताएं, आमतौर पर 1024 या
5120 बिट्स, जिसे फ़ंक्शन द्वारा निर्धारित किया जा सकता है max_floatprec(). डिफ़ॉल्ट रूप से, कब
डेटा प्रकार की संख्याओं के साथ गणना करना वास्तविक, सिंगल_फ्लोट्स का उपयोग किया जाता है। यह एक से मेल खाता है
9 से 10 दशमलव स्थानों की सटीकता। 5120 बिट्स की सटीकता 1500 से अधिक के अनुरूप है
दशमलव स्थानों।

फ़ंक्शन का उपयोग करके परिशुद्धता को बदला जा सकता है set_floatprec. फ़ंक्शन एक लेता है
पूर्णांक तर्क, जो बिट्स में वांछित परिशुद्धता है। यह स्वचालित रूप से गोल हो जाता है
अगला उच्चतर उपलब्ध मूल्य। उदाहरण के लिए, बाद में

==> set_floatprec(100).
-: 128

फ़्लोटिंग पॉइंट परिशुद्धता 128 बिट है और आप गणना कर सकते हैं

==> आर्कटान(sqrt(3))।
-: 1.04719_75511_96597_74615_42144_61093_16762_8

==> _/pi.
-: 0.33333_33333_33333_33333_33333_33333_33333_33

उपयोगकर्ता परिभाषित कार्यों
उपयोगकर्ता अपने स्वयं के कार्यों को परिभाषित कर सकता है। एक विशिष्ट उदाहरण दिखता है

==> फ़ंक्शन fac(n: पूर्णांक): पूर्णांक;
था
x,i: पूर्णांक;
शुरू करना
एक्स := 1;
i के लिए := 2 से n तक
एक्स := एक्स*आई;
अंत;
वापसी एक्स;
समाप्त।

यदि आपने इसे सही ढंग से दर्ज किया है, अरिबास फ़ंक्शन नाम को प्रतिध्वनित करता है

-: फैक

और अब से आप उपयोग कर सकते हैं एफ ए सी एक अंतर्निहित फ़ंक्शन के समान, उदाहरण के लिए

==> एफ ए सी(32).
-: 2_63130_83693_36935_30167_21801_21600_00000

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

==> फ़ंक्शन sqrt_list(n: पूर्णांक): वास्तविक की सरणी;
था
vec: वास्तविक की सरणी[n];
i: पूर्णांक;
शुरू करना
i के लिए := 1 से n तक
vec[i-1] := sqrt(i);
अंत;
वापसी सप्ताह;
समाप्त।

यह फ़ंक्शन 1 से n तक पूर्णांकों के वर्गमूलों की एक सरणी लौटाता है
उदाहरण

==> sqrt_list(10).
-: (1.00000000, 1.41421356, 1.73205081, 2.00000000,
2.23606798, 2.44948974, 2.64575131, 2.82842712, 3.00000000,
3.16227766)

एक बड़े प्रोग्रामिंग प्रोजेक्ट में जहां आपको कई फ़ंक्शन की आवश्यकता होती है, आप उन्हें दर्ज नहीं करेंगे
सीधे पर अरिबास शीघ्र लेकिन बाहरी पाठ के साथ फ़ंक्शन परिभाषाएँ तैयार करें
संपादक बनाएं और उन्हें एक्सटेंशन वाली फ़ाइल में सहेजें .अरी , उदाहरण के लिए abcd.ari . यह फ़ाइल
फिर लोड किया जा सकता है अरिबास कमांड का उपयोग करना

==> लोड ("एबीसीडी")।

यदि फ़ाइल में कोई सिंटैक्स त्रुटि है, तो आपको फ़ॉर्म का एक त्रुटि संदेश मिलता है

लोड की गई फ़ाइल की पंक्ति <= 23 में त्रुटि
यदि: अंत अपेक्षित

जो आपको बताता है (इस उदाहरण में) कि इसमें कोई त्रुटि है if पंक्ति 23 या में निर्माण करें
फ़ाइल में पहले. (ध्यान दें कि त्रुटि संदेश कभी-कभी बहुत सटीक नहीं होते हैं।) आप
फिर त्रुटि को ठीक कर सकते हैं और फ़ाइल को फिर से लोड कर सकते हैं।

ऑनलाइन मदद
आदेश

==> प्रतीक(अरिबास)।

सभी कीवर्ड और अंतर्निहित कार्यों के नामों की एक सूची लौटाता है अरिबास. इस सूची में है
लगभग 200 प्रविष्टियाँ, और निम्नानुसार प्रारंभ और समाप्त होती हैं:

(ARGV, _, __, ___, abs, alloc, और, arccos, arcsin, arctan, arctan2, aribas, array, atof,
एटोई, आरंभ, बाइनरी, बिट_एंड, बिट_क्लियर, बिट_लेंथ, ......, टॉलोवर, टॉपर,
प्रतिलेख, सत्य, ट्रंक, प्रकार, उपयोगकर्ता, var, संस्करण, जबकि, लिखना, राइट_ब्लॉक, राइट_बाइट,
लिखना)

इस सूची के अधिकांश प्रतीकों के लिए, आप फ़ंक्शन का उपयोग करके एक संक्षिप्त ऑनलाइन सहायता प्राप्त कर सकते हैं
मदद करना(). उदाहरण के लिए, कमांड

==> सहायता(एआरजीवी)।

बिल्टइन वेरिएबल पर एक जानकारी देता है एआरजीवी, जहाँ तक

==> मदद(जबकि)।

के वाक्यविन्यास का वर्णन करता है जब कुंडली। यदि आपको इससे अधिक जानकारी चाहिए
ऑनलाइन सहायता में, दस्तावेज़ देखें जो इसमें पाया जा सकता है /usr/share/doc/aribas.

कैसे सेवा मेरे निकास
एक को ख़त्म करने के लिए अरिबास सत्र, प्रकार निकास पर अरिबास शीघ्र

==> बाहर निकलें

और फिर रिटर्न (ENTER) कुंजी दबाएँ।

अगर आप जाना नहीं चाहते अरिबास, लेकिन एक अनंत लूप या ए से बाहर निकलना चाहते हैं
गणना जो बहुत लंबे समय तक चलती है, नियंत्रण-सी टाइप करें (यदि आप चला रहे हैं अरिबास अंदर से
Emacs, आपको CONTROL-C को दो बार दबाना होगा)। यह (ज्यादातर मामलों में) करंट को रोक देगा
गणना करें और वापस लौटें अरिबास शीघ्र।

जब आप Emacs इंटरफ़ेस का नहीं बल्कि कमांड लाइन संस्करण का उपयोग कर रहे हों अरिबास, आप
कभी-कभी निम्न स्थिति में आ जाते हैं: किसी पिछली पंक्ति में टाइपिंग त्रुटि होती है,
लेकिन आप इसे ठीक करने के लिए उस पंक्ति पर वापस नहीं लौट सकते। इस स्थिति में आपको बस a टाइप करना होगा
पूर्ण विराम '.', उसके बाद रिटर्न। आपको एक त्रुटि संदेश मिलेगा जिसे आप सुरक्षित रूप से प्राप्त कर सकते हैं
अनदेखा करें, और एक नया संकेत ==> प्रकट होता है, जो आपको पुनः प्रयास करने की अनुमति देता है।

कमान लाइन बहस

अरिबास [विकल्पों] [ari-file> [आर्ग1>आर्ग2> ...]]

विकल्पों
निम्न विकल्प उपलब्ध हैं:

-q (शांत मोड) स्क्रीन पर सभी संदेशों को दबा देता है (संस्करण संख्या, कॉपीराइट नोटिस,
आदि) कब अरिबास शुरू हो गया

-v (वर्बोज़ मोड, डिफ़ॉल्ट) जब स्क्रीन पर संदेशों को दबाया नहीं जाता है अरिबास is
शुरू कर दिया है।

-c
अरिबास स्क्रीन पर लिखते समय यह अपनी लाइन ब्रेकिंग करता है। आम तौर पर ऐसा माना जाता है
वह स्क्रीन (या वह विंडो जिसमें अरिबास रन) में 80 कॉलम हैं। -सी के साथ
विकल्प के रूप में आप एक अन्य संख्या निर्धारित कर सकते हैं, जो 40 और 160 (दशमलव में) के बीच होनी चाहिए
प्रतिनिधित्व)। उदाहरण के लिए, यदि आप दौड़ते हैं अरिबास 72 के साथ एक Xterm विंडो में
कॉलम, विकल्प -c72 (या -c 72, -c और संख्या के बीच का स्थान है) का उपयोग करें
वैकल्पिक)।

-m
यहाँ 500 और 32000 के बीच (दशमलव प्रतिनिधित्व में) एक संख्या है
संख्या इंगित करती है कि कितने किलोबाइट RAM है अरिबास के लिए उपयोग करना चाहिए अरिबास ढेर।
डिफ़ॉल्ट मान कब उपयोग किए गए विकल्पों पर निर्भर करता है अरिबास संकलित किया गया. आमतौर पर,
UNIX या LINUX के तहत यह -m6 के अनुरूप 6000 मेगाबाइट है

-h <पथ of मदद फ़ाइल>
की ऑनलाइन मदद अरिबास एक फ़ाइल aribas.hlp पर निर्भर करता है जिसे इसमें स्थित किया जाना चाहिए
पर्यावरण चर PATH की सीमा. यदि ऐसा नहीं है तो आप निर्दिष्ट कर सकते हैं
-h विकल्प के साथ सहायता फ़ाइल का सटीक पथ। उदाहरण के लिए यदि फ़ाइल
aribas.hlp निर्देशिका में है / Usr / स्थानीय / lib, विकल्प -h का उपयोग करें / Usr / स्थानीय / lib
(-h के बाद का स्थान आवश्यक नहीं है)। यदि सहायता मिले तो -h विकल्प का भी उपयोग किया जा सकता है
फ़ाइल का नाम अलग है. यदि सहायता फ़ाइल को help-aribas नाम दिया गया है और वह इसमें निहित है
निर्देशिका /home/joe/ari, उपयोग करें -h/home/joe/ari/help-aribas.

ठीक से स्थापित डेबियन पैकेज के साथ अरिबास यह आवश्यक नहीं होना चाहिए
इस विकल्प का प्रयोग करें।

-p
इस विकल्प के साथ आप फ़ाइलों को लोड करने के लिए एक खोज पथ निर्दिष्ट कर सकते हैं अरिबास स्रोत
कोड. या तो एक निर्देशिका का (पूर्ण) पथनाम हो सकता है या
कोलन द्वारा अलग किए गए कई पथनाम। मान लीजिए कि आपने कॉल किया है अरिबास साथ में
विकल्प

-p/usr/local/lib/aribas:~/एरी/उदाहरण

और आपकी होम निर्देशिका /home/alice/ है। फिर आदेश

==> लोड ("कारक")।

फ़ाइल Factor.ari को पहले वर्तमान निर्देशिका में खोजेगा, फिर इसमें
निर्देशिका /usr/local/lib/aribas और अंत में /home/alice/ari/examples में।

-b लोड करते समय बैच मोड अरिबास कमांड लाइन से सोर्स कोड फ़ाइल देखें
नीचे.

उदाहरण के लिए, एक अक्षर वाले विकल्प जिनमें किसी तर्क की आवश्यकता नहीं होती, उन्हें मर्ज किया जा सकता है

अरिबास -क्यू -बी

के बराबर है

अरिबास -क्यूबी

आगे आदेश line तर्क

विकल्पों के बाद अगले कमांड लाइन तर्क की व्याख्या a के नाम के रूप में की जाती है
के साथ फाइल अरिबास सोर्स कोड। यदि फ़ाइल नाम में एक्सटेंशन .ari है, तो यह
विस्तार छोड़ा जा सकता है. फ़ाइल को कमांड की तरह लोड किया गया है भार(" ")
की शुरुआत के बाद दिया गया था अरिबास पर अरिबास तत्पर। यदि फ़ाइल नहीं है
वर्तमान निर्देशिका में पाए जाने पर इसे निर्दिष्ट निर्देशिकाओं में खोजा जाता है
-पी विकल्प. यदि विकल्प -बी दिया गया था, तो फ़ाइल लोड और निष्पादित होती है।
बाद में अरिबास इसका संकेत दिखाए बिना बाहर निकल जाता है। यदि फ़ाइल लोड नहीं की जा सकती
पूरी तरह से एक त्रुटि के कारण, अरिबास त्रुटि संदेश के तुरंत बाद बाहर निकल जाता है।

...
जब आगे कमांड लाइन तर्क अनुसरण करते हैं , उन्हें एकत्र किया जाता है (जैसे
स्ट्रिंग्स) साथ में वेक्टर में एआरजीवी जिसे यहां से एक्सेस किया जा सकता है
अंदर अरिबास. उदाहरण: यदि आप कॉल करते हैं अरिबास कमांड लाइन के साथ

एरिबास स्टार्टअप 4536 ईसेनस्टीन

और वर्तमान निर्देशिका में स्टार्टअप.ari फ़ाइल शामिल है अरिबास इसे लोड करता है और
सदिश एआरजीवी का रूप है

==> एआरजीवी.
-: ("स्टार्टअप", "4536", "ईसेनस्टीन")

यदि आपको कुछ तर्कों को संख्याओं के रूप में चाहिए न कि स्ट्रिंग के रूप में, तो आप उन्हें इसके द्वारा रूपांतरित कर सकते हैं
एटोई (या एटोफ़); हमारे उदाहरण में

==> x := atoi(ARGV[1]).
-: 4536

कर दूँगा। वेक्टर की लंबाई एआरजीवी द्वारा निर्धारित किया जा सकता है लंबाई(एआरजीवी).

चल रहा है अरिबास भीतर Emacs

तुम दौड़ सकते हो अरिबास Emacs के भीतर से कमांड देकर (Emacs के मिनीबफर में)

एमएक्स रन-एरीबास

(यदि आपके पास मेटा कुंजी नहीं है, तो एमएक्स के बजाय ईएससी एक्स का उपयोग करें) फिर अरिबास में लोड किया जाएगा
*aribas* नाम वाली एक Emacs विंडो और आप इसमें अपना इनपुट संपादित कर सकते हैं अरिबास सामान्य के साथ
Emacs कमांड.

यदि आपका इनपुट पूर्णविराम के साथ समाप्त होता है '। और आप रिटर्न दबाते हैं, इसे भेज दिया जाता है अरिबास. अगर
हालाँकि आपका पूरा इनपुट पूर्ण विराम के साथ समाप्त नहीं होता है, (उदाहरण के लिए a के जवाब में)।
readln), इनपुट भेजा जाता है अरिबास सीजे (कंट्रोल-जे) या सीसी रिटर्न द्वारा।

यदि आप पिछले इनपुट को दोहराना चाहते हैं, तो एमपी (या ईएससी पी) इनपुट के माध्यम से पीछे की ओर चक्र करता है
इतिहास, और एमएन (या ईएससी एन) चक्र आगे बढ़ता है।

एक कंट्रोल-सी भेजा जाता है अरिबास Cc Cc द्वारा (Cc को दो बार दबाएँ)।

इसकी शुरुआत भी संभव है अरिबास कमांड लाइन तर्कों के साथ Emacs से। इसके लिए
आदेश का उद्देश्य

सीयू एमएक्स रन-एरीबास

देना होगा. फिर एक संकेत

रन-एरीबास: अरीबास

उदाहरण के लिए, Emacs के मिनीबफ़र में दिखाई देता है और आप कमांड लाइन को पूरा कर सकते हैं

रन-एरीबास: अरीबास स्टार्टअप 4536 ईसेन्सटीन

(ऊपर देखो)।

विन्यास फ़ाइल

चलाने के लिए विकल्प अरिबास नाम के साथ कॉन्फ़िगरेशन फ़ाइल का उपयोग करके भी निर्दिष्ट किया जा सकता है
.arirc. अरीबास निम्न क्रम में कॉन्फ़िगरेशन फ़ाइल खोजता है:

1) वर्तमान निर्देशिका
2) उपयोगकर्ता की होम निर्देशिका

एक तीसरी संभावना है: आप एक पर्यावरण चर को परिभाषित कर सकते हैं एआरआईआरसी युक्त
कॉन्फ़िगरेशन फ़ाइल का नाम (जो .arirc से भिन्न हो सकता है), पूर्ण सहित
पथ।

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

-इस में

फिर इस पंक्ति के बाद की हर चीज़ को इस प्रकार माना जाता है अरिबास स्रोत कोड और कब निष्पादित किया गया अरिबास
शुरू हो गया।

के लिए एक कॉन्फ़िगरेशन फ़ाइल का अस्तित्व अरिबास देने की संभावना को बाहर नहीं करता
कमांड लाइन तर्क. यदि कोई विकल्प (जैसे -m विकल्प) दोनों में निर्दिष्ट है
कॉन्फ़िगरेशन फ़ाइल और कमांड लाइन लेकिन विभिन्न मानों के साथ, फिर विनिर्देश
कमांड लाइन पर मान्य है. अनुरूप रूप से, कमांड लाइन पर एक -v विकल्प -q को ओवरराइड करता है
कॉन्फ़िगरेशन फ़ाइल में विकल्प. यदि कॉन्फ़िगरेशन फ़ाइल में -init कोड है और a
कमांड लाइन पर तर्क, फिर -init कोड पहले निष्पादित किया जाता है और
बाद में लोड किया गया है और इसका कोड निष्पादित किया गया है।

onworks.net सेवाओं का उपयोग करके ऑनलाइन aribas का उपयोग करें