তাত্ত্বিক পাটিগণিত সেট করুন
প্রতিজ্ঞা
ইতিমধ্যে বেশ কয়েকটি চ্যালেঞ্জ রয়েছে যেগুলি গুণক অপারেটর ( এখানে এবং এখানে ) ছাড়া গুণকে জড়িত করে এবং এই চ্যালেঞ্জটি একই শিরাতে রয়েছে (বেশিরভাগ দ্বিতীয় লিঙ্কের মতো)।
এই চ্যালেঞ্জটি পূর্বের তুলনায়, প্রাকৃতিক সংখ্যাগুলির একটি সেট তাত্ত্বিক সংজ্ঞা ( N ) ব্যবহার করবে:
এবং
উদাহরণ স্বরূপ,
ইত্যাদি।
চ্যালেঞ্জ
আমাদের লক্ষ্যটি হ'ল সেট ক্রিয়াকলাপগুলি (নীচে দেখুন), প্রাকৃতিক সংখ্যা যুক্ত এবং গুণিত করা। এই উদ্দেশ্যে, সমস্ত এন্ট্রি একই 'সেট ভাষাতে' হবে যার দোভাষী নীচে । এটি ধারাবাহিকতার পাশাপাশি সহজ স্কোরিং সরবরাহ করবে।
এই দোভাষী আপনাকে প্রাকৃতিক সংখ্যাগুলি সেট হিসাবে পরিচালনা করতে দেয়। আপনার টাস্কটি দুটি প্রোগ্রাম বডি লিখতে হবে (নীচে দেখুন) যার মধ্যে একটি প্রাকৃতিক সংখ্যা যুক্ত করে, অন্যটি তাদেরকে গুণ করে।
সেটগুলিতে প্রাথমিক নোটস
সেটগুলি সাধারণ গাণিতিক কাঠামো অনুসরণ করে। এখানে কয়েকটি গুরুত্বপূর্ণ বিষয় রয়েছে:
- সেট অর্ডার করা হয় না।
- কোনও সেট নিজেই থাকে না
- উপাদানগুলি সেটে হয় বা না হয়, এটি বুলিয়ান। অতএব সেট উপাদানগুলির বহু গুণ থাকতে পারে না (অর্থাত্ কোনও উপাদান একাধিক বার সেট হতে পারে না))
দোভাষী এবং নির্দিষ্টকরণ
এই চ্যালেঞ্জের জন্য একটি 'প্রোগ্রাম' সেট ভাষাতে লেখা হয় এবং দুটি অংশ থাকে: একটি শিরোনাম এবং একটি বডি।
শিরোলেখ
শিরোনামটি খুব সাধারণ। এটি দোভাষীকে বলে যে আপনি কোন প্রোগ্রামটি সমাধান করছেন। শিরোনামটি প্রোগ্রামটির প্রারম্ভিক লাইন। এটি হয় দিয়ে শুরু হয় +বা *চরিত্র, দুটি পূর্ণসংখ্যার দ্বারা অনুসরণ, স্থান সীমায়িত। উদাহরণ স্বরূপ:
+ 3 5
অথবা
* 19 2
বৈধ শিরোনাম। প্রথমটি ইঙ্গিত দেয় যে আপনি সমাধানের চেষ্টা করছেন 3+5, তার অর্থ আপনার উত্তর হওয়া উচিত 8। দ্বিতীয়টি একই সাথে গুণ ব্যতীত।
শরীর
দোভাষী যেখানে আপনার আসল নির্দেশাবলী সেখানে। সত্যই এটি আপনার "সংযোজন" বা "গুণ" প্রোগ্রাম গঠন করে। আপনার উত্তরে দুটি কর্মসূচী থাকবে, প্রতিটি কাজের জন্য একটি করে। তারপরে আপনি পরীক্ষার কেসগুলি সম্পাদন করতে শিরোনাম পরিবর্তন করবেন।
সিনট্যাক্স এবং নির্দেশাবলী
নির্দেশাবলী শূন্য বা আরও বেশি পরামিতি অনুসরণ করে একটি কমান্ড গঠিত। নিম্নলিখিত বিক্ষোভের উদ্দেশ্যে, কোনও বর্ণমালার অক্ষর একটি চলকের নাম। মনে রাখবেন যে সমস্ত ভেরিয়েবল সেট are labelএকটি লেবেলের নাম (লেবেলগুলি সেমিকোলনগুলির পরে শব্দগুলি হয় (যেমন main_loop:), intএকটি পূর্ণসংখ্যা হয় following নীচের বৈধ নির্দেশাবলী:
jump labelশর্তহীনভাবে লেবেলে ঝাঁপুন। একটি লেবেল হল একটি 'শব্দ' যার পরে একটি সেমিকোলন: উদাহরণস্বরূপmain_loop:একটি লেবেল।je A labelA খালি থাকলে লেবেলে লাফ দিনjne A labelA খালি না থাকলে লেবেলে ঝাঁপুনjic A B labelলেবেলে লাফ দিন যদি A থাকে Bjidc A B labelলেবেলে লাফ দিন যদি A বি থাকে না
assign A Bবাassign A int
বা
যেখানে set(int)সেট উপস্থাপনাint
union A B C
intersect A B C
difference A B C
add A B
remove A B
print AA এর সত্যিকারের মান মুদ্রণ করে, যেখানে {the খালি সেটprinti variableA এর পূর্ণসংখ্যার প্রতিনিধিত্ব মুদ্রণ করে এটি উপস্থিত থাকলে অন্যথায় ত্রুটি আউটপুট করে।
;সেমিকোলন ইঙ্গিত দেয় যে বাকী রেখাটি একটি মন্তব্য এবং দোভাষী দ্বারা উপেক্ষা করা হবে
আরও তথ্য
প্রোগ্রাম শুরুতে, তিনটি বিদ্যমান বিদ্যমান ভেরিয়েবল রয়েছে। তারা হয় set1,set2 এবং ANSWER। set1প্রথম শিরোলেখের প্যারামিটারের মান নেয়। set2দ্বিতীয় মান লাগে। ANSWERপ্রাথমিকভাবে খালি সেট। প্রোগ্রাম সমাপ্তির পরে, ANSWERদোভাষীটি শিরোনামে সংজ্ঞায়িত গাণিতিক সমস্যার উত্তরটির পূর্ণসংখ্যার প্রতিনিধিত্ব করে কিনা তা পরীক্ষা করে। যদি এটি হয় তবে এটি স্টডআউটের বার্তার সাথে এটি নির্দেশ করে।
দোভাষা ব্যবহৃত ব্যবস্থার সংখ্যাও প্রদর্শন করে। প্রতিটি নির্দেশ এক অপারেশন। একটি লেবেল শুরুর জন্য একটি অপারেশনও ব্যয় হয় (লেবেলগুলি একবার একবার শুরু করা যেতে পারে)।
আপনার সর্বোচ্চ 20 টি ভেরিয়েবল (3 পূর্বনির্ধারিত ভেরিয়েবলগুলি সহ) এবং 20 টি লেবেল থাকতে পারে।
দোভাষী কোড
এই ইন্টারপ্রেটারে গুরুত্বপূর্ণ নোটগুলিএই দোভাষীটিতে বড় সংখ্যা (> 30) ব্যবহার করার সময় জিনিসগুলি খুব ধীর হয় slow আমি এর কারণগুলি রূপরেখা করব।
- সেটগুলির কাঠামোগুলি এমন যে একটি প্রাকৃতিক সংখ্যার দ্বারা বৃদ্ধি করা, আপনি কার্যকরভাবে সেট কাঠামোর আকার দ্বিগুণ করেন। এন ম প্রাকৃতিক নম্বর আছে 2 ^ n হল এটি মধ্যে খালি সেট (এই আমি বলতে চাচ্ছি যে আপনি যদি চেহারা দ্বারা এন একটি গাছ হিসেবে আছে এন খালি সেট। উল্লেখ্য শুধুমাত্র ফাঁকা সেট পাতার হতে পারে।) এর অর্থ এই যে 30 সঙ্গে তার আচরণ উল্লেখযোগ্যভাবে হয় 20 বা 10 এর সাথে ডিল করার চেয়ে বেশি ব্যয়বহুল (আপনি 2 ^ 10 বনাম 2 ^ 20 বনাম 2 ^ 30 দেখছেন))
- সমতার চেকগুলি পুনরাবৃত্ত হয়। যেহেতু সেটগুলি অভিযোগহীনভাবে অর্ডারড করা হয়েছে, এটি এটি মোকাবেলার প্রাকৃতিক উপায় বলে মনে হয়েছিল।
- দুটি মেমরি ফাঁস রয়েছে যা আমি কীভাবে ঠিক করতে পারি তা বুঝতে পারি না। আমি সি / সি ++ এ খারাপ, দুঃখিত। যেহেতু আমরা কেবলমাত্র অল্প সংখ্যক নিয়ে কাজ করছি, এবং বরাদ্দ মেমরিটি প্রোগ্রামের শেষে মুক্ত করা হয়, তাই এটি সত্যিই খুব বেশি সমস্যা হওয়া উচিত নয়। (কেউ কিছু বলার আগেই হ্যাঁ আমি জানতাম
std::vector; আমি এটি শিখার অনুশীলন হিসাবে করছিলাম। আপনি যদি এটি ঠিক করতে জানেন তবে দয়া করে আমাকে জানান এবং আমি সম্পাদনাগুলি করব, অন্যথায়, যেহেতু এটি কাজ করে, তাই আমি এটি ছেড়ে দেব) যেমন।)
এছাড়াও, পাথ অন্তর্ভুক্ত লক্ষ্য set.hমধ্যে interpreter.cppফাইল। পরবর্তী বিজ্ঞাপন ছাড়াই, উত্স কোড (সি ++):
set.h
using namespace std;
//MEMORY LEAK IN THE ADD_SELF METHOD
class set {
private:
long m_size;
set* m_elements;
bool m_initialized;
long m_value;
public:
set() {
m_size =0;
m_initialized = false;
m_value=0;
}
~set() {
if(m_initialized) {
//delete[] m_elements;
}
}
void init() {
if(!m_initialized) {
m_elements = new set[0];
m_initialized = true;
}
}
void uninit() {
if(m_initialized) {
//delete[] m_elements;
}
}
long size() {
return m_size;
}
set* elements() {
return m_elements;
}
bool is_empty() {
if(m_size ==0) {return true;}
else {return false;}
}
bool is_eq(set otherset) {
if( (*this).size() != otherset.size() ) {
return false;
}
else if ( (*this).size()==0 && otherset.size()==0 ) {
return true;
}
else {
for(int i=0;i<m_size;i++) {
bool matched = false;
for(int j=0;j<otherset.size();j++) {
matched = (*(m_elements+i)).is_eq( *(otherset.elements()+j) );
if( matched) {
break;
}
}
if(!matched) {
return false;
}
}
return true;
}
}
bool contains(set set1) {
for(int i=0;i<m_size;i++) {
if( (*(m_elements+i)).is_eq(set1) ) {
return true;
}
}
return false;
}
void add(set element) {
(*this).init();
bool alreadythere = false;
for(int i=0;i<m_size;i++) {
if( (*(m_elements+i)).is_eq(element) ) {
alreadythere=true;
}
}
if(!alreadythere) {
set *temp = new set[m_size+1];
for(int i=0; i<m_size; i++) {
*(temp+i)= *(m_elements+i);
}
*(temp+m_size)=element;
m_size++;
delete[] m_elements;
m_elements = new set[m_size];
for(int i=0;i<m_size;i++) {
*(m_elements+i) = *(temp+i);
}
delete[] temp;
}
}
void add_self() {
set temp_set;
for(int i=0;i<m_size;i++) {
temp_set.add( *(m_elements+i) );
}
(*this).add(temp_set);
temp_set.uninit();
}
void remove(set set1) {
(*this).init();
for(int i=0;i<m_size;i++) {
if( (*(m_elements+i)).is_eq(set1) ) {
set* temp = new set[m_size-1];
for(int j=0;j<m_size;j++) {
if(j<i) {
*(temp+j)=*(m_elements+j);
}
else if(j>i) {
*(temp+j-1)=*(m_elements+j);
}
}
delete[] m_elements;
m_size--;
m_elements = new set[m_size];
for(int j=0;j<m_size;j++) {
*(m_elements+j)= *(temp+j);
}
delete[] temp;
break;
}
}
}
void join(set set1) {
for(int i=0;i<set1.size();i++) {
(*this).add( *(set1.elements()+i) );
}
}
void diff(set set1) {
for(int i=0;i<set1.size();i++) {
(*this).remove( *(set1.elements()+i) );
}
}
void intersect(set set1) {
for(int i=0;i<m_size;i++) {
bool keep = false;
for(int j=0;j<set1.size();j++) {
if( (*(m_elements+i)).is_eq( *(set1.elements()+j) ) ) {
keep = true;
break;
}
}
if(!keep) {
(*this).remove( *(m_elements+i) );
}
}
}
void natural(long number) {
//////////////////////////
//MEMORY LEAK?
//delete[] m_elements;
/////////////////////////
m_size = 0;
m_elements = new set[m_size];
for(long i=1;i<=number;i++) {
(*this).add_self();
}
m_value = number;
}
void disp() {
if( m_size==0) {cout<<"{}";}
else {
cout<<"{";
for(int i=0; i<m_size; i++) {
(*(m_elements+i)).disp();
if(i<m_size-1) {cout<<", ";}
//else{cout<<" ";}
}
cout<<"}";
}
}
long value() {
return m_value;
}
};
const set EMPTY_SET;interpreter.cpp
#include<fstream>
#include<iostream>
#include<string>
#include<assert.h>
#include<cmath>
#include "headers/set.h"
using namespace std;
string labels[20];
int jump_points[20];
int label_index=0;
const int max_var = 20;
set* set_ptrs[max_var];
string set_names[max_var];
long OPERATIONS = 0;
void assign_var(string name, set other_set) {
static int index = 0;
bool exists = false;
int i = 0;
while(i<index) {
if(name==set_names[i]) {
exists = true;
break;
}
i++;
}
if(exists && index<max_var) {
*(set_ptrs[i]) = other_set;
}
else if(!exists && index<max_var) {
set_ptrs[index] = new set;
*(set_ptrs[index]) = other_set;
set_names[index] = name;
index++;
}
}
int getJumpPoint(string str) {
for(int i=0;i<label_index;i++) {
//cout<<labels[i]<<"\n";
if(labels[i]==str) {
//cout<<jump_points[i];
return jump_points[i];
}
}
cerr<<"Invalid Label Name: '"<<str<<"'\n";
//assert(0);
return -1;
}
long strToLong(string str) {
long j=str.size()-1;
long value = 0;
for(long i=0;i<str.size();i++) {
long x = str[i]-48;
assert(x>=0 && x<=9); // Crash if there was a non digit character
value+=x*floor( pow(10,j) );
j--;
}
return value;
}
long getValue(string str) {
for(int i=0;i<max_var;i++) {
if(set_names[i]==str) {
set set1;
set1.natural( (*(set_ptrs[i])).size() );
if( set1.is_eq( *(set_ptrs[i]) ) ) {
return (*(set_ptrs[i])).size();
}
else {
cerr<<"That is not a valid integer construction";
return 0;
}
}
}
return strToLong(str);
}
int main(int argc, char** argv){
if(argc<2){std::cerr<<"No input file given"; return 1;}
ifstream inf(argv[1]);
if(!inf){std::cerr<<"File open failed";return 1;}
assign_var("ANSWER", EMPTY_SET);
int answer;
string str;
inf>>str;
if(str=="*") {
inf>>str;
long a = strToLong(str);
inf>>str;
long b = strToLong(str);
answer = a*b;
set set1; set set2;
set1.natural(a); set2.natural(b);
assign_var("set1", set1);
assign_var("set2",set2);
//cout<<answer;
}
else if(str=="+") {
inf>>str;
long a = strToLong(str);
inf>>str;
long b = strToLong(str);
answer = a+b;
set set1; set set2;
set1.natural(a); set2.natural(b);
assign_var("set1", set1);
assign_var("set2",set2);
//cout<<answer;
}
else{
cerr<<"file must start with '+' or '*'";
return 1;
}
// parse for labels
while(inf) {
if(inf) {
inf>>str;
if(str[str.size()-1]==':') {
str.erase(str.size()-1);
labels[label_index] = str;
jump_points[label_index] = inf.tellg();
//cout<<str<<": "<<jump_points[label_index]<<"\n";
label_index++;
OPERATIONS++;
}
}
}
inf.clear();
inf.seekg(0,ios::beg);
// parse for everything else
while(inf) {
if(inf) {
inf>>str;
if(str==";") {
getline(inf, str,'\n');
}
// jump label
if(str=="jump") {
inf>>str;
inf.seekg( getJumpPoint(str),ios::beg);
OPERATIONS++;
}
// je set label
if(str=="je") {
inf>>str;
for(int i=0;i<max_var;i++) {
if( set_names[i]==str) {
if( (*(set_ptrs[i])).is_eq(EMPTY_SET) ) {
inf>>str;
inf.seekg( getJumpPoint(str),ios::beg);
OPERATIONS++;
}
break;
}
}
}
// jne set label
if(str=="jne") {
inf>>str;
for(int i=0;i<max_var;i++) {
if( set_names[i]==str) {
if(! (*(set_ptrs[i])).is_eq(EMPTY_SET) ) {
inf>>str;
inf.seekg( getJumpPoint(str),ios::beg);
OPERATIONS++;
}
break;
}
}
}
// jic set1 set2 label
// jump if set1 contains set2
if(str=="jic") {
inf>>str;
string str2;
inf>>str2;
set set1;
set set2;
for(int i=0;i<max_var;i++) {
if( set_names[i]==str ) {
set1 = *(set_ptrs[i]);
}
if(set_names[i]==str2) {
set2 = *(set_ptrs[i]);
}
}
if( set1.contains(set2) ) {
inf>>str;
inf.seekg( getJumpPoint(str),ios::beg);
OPERATIONS++;
}
else {inf>>str;}
}
// jidc set1 set2 label
// jump if set1 doesn't contain set2
if(str=="jidc") {
inf>>str;
string str2;
inf>>str2;
set set1;
set set2;
for(int i=0;i<max_var;i++) {
if( set_names[i]==str ) {
set1 = *(set_ptrs[i]);
}
if(set_names[i]==str2) {
set2 = *(set_ptrs[i]);
}
}
if( !set1.contains(set2) ) {
inf>>str;
inf.seekg( getJumpPoint(str),ios::beg);
OPERATIONS++;
}
else {inf>>str;}
}
// assign variable set/int
if(str=="assign") {
inf>>str;
string str2;
inf>>str2;
set set1;
set1.natural( getValue(str2) );
assign_var(str,set1);
OPERATIONS++;
}
// union set1 set2 set3
// set1 = set2 u set3
if(str=="union") {
inf>>str;
int i=0;
while(i<max_var) {
if( set_names[i] == str ) {
break;
}
i++;
}
set set1;
set set2;
string str1;
inf>>str1;
string str2;
inf>>str2;
for(int j=0;j<max_var;j++) {
if( str1 == set_names[j] ) {
set1= *(set_ptrs[j]);
}
if( str2 == set_names[j] ) {
set2= *(set_ptrs[j]);
}
}
set1.join(set2);
if(i==max_var) {
assign_var(str,set1);
}
else {
set_names[i]= str;
set_ptrs[i] = new set;
*(set_ptrs[i]) = set1;
}
OPERATIONS++;
}
// intersect set1 set2 set3
// set1 = set2^set3
if(str == "intersect") {
inf>>str;
int i=0;
while(i<max_var) {
if( set_names[i] == str ) {
break;
}
i++;
}
set set1;
set set2;
string str1;
inf>>str1;
string str2;
inf>>str2;
for(int j=0;j<max_var;j++) {
if( str1 == set_names[j] ) {
set1= *(set_ptrs[j]);
}
if( str2 == set_names[j] ) {
set2= *(set_ptrs[j]);
}
}
set1.intersect(set2);
if(i==max_var) {
assign_var(str,set1);
}
else {
set_names[i]= str;
set_ptrs[i] = new set;
*(set_ptrs[i]) = set1;
}
OPERATIONS++;
}
// difference set1 set2 set3
// set1 = set2\set3
if(str == "difference") {
inf>>str;
int i=0;
while(i<max_var) {
if( set_names[i] == str ) {
break;
}
i++;
}
set set1;
set set2;
string str1;
inf>>str1;
string str2;
inf>>str2;
for(int j=0;j<max_var;j++) {
if( str1 == set_names[j] ) {
set1= *(set_ptrs[j]);
}
if( str2 == set_names[j] ) {
set2= *(set_ptrs[j]);
}
}
set1.diff(set2);
if(i==max_var) {
assign_var(str,set1);
}
else {
set_names[i]= str;
set_ptrs[i] = new set;
*(set_ptrs[i]) = set1;
}
OPERATIONS++;
}
// add set1 set2
// put set2 in set 1
if(str=="add") {
inf>>str;
int i = 0; int j =0;
while(i<max_var) {
if(set_names[i]==str) {
break;
}
i++;
}
inf>>str;
while(j<max_var) {
if(set_names[j]==str) {
break;
}
j++;
}
set set2 = *(set_ptrs[j]);
if( ! (*(set_ptrs[i])).is_eq(set2) ){
(*(set_ptrs[i])).add(set2);
}
else {
(*(set_ptrs[i])).add_self();
}
OPERATIONS++;
}
// remove set1 set2
// remove set2 from set1
if(str=="remove") {
inf>>str;
int i = 0; int j =0;
while(i<max_var) {
if(set_names[i]==str) {
break;
}
i++;
}
inf>>str;
while(j<max_var) {
if(set_names[j]==str) {
break;
}
j++;
}
set set2 = *(set_ptrs[j]);
(*(set_ptrs[i])).remove(set2);
OPERATIONS++;
}
// print set
// prints true representation of set
if(str=="print") {
inf>>str;
for(int i=0;i<max_var;i++) {
if(set_names[i]==str) {
(*(set_ptrs[i])).disp();
}
}
cout<<"\n";
}
// printi set
// prints integer representation of set, if exists.
if(str=="printi") {
inf>>str;
cout<<getValue(str);
cout<<"\n";
}
}
}
cout<<"You used "<<OPERATIONS<<" operations\n";
set testset;
testset.natural(answer);
switch( testset.is_eq( *(set_ptrs[0]) ) ) {
case 1:
cout<<"Your answer is correct, the set 'ANSWER' is equivalent "<<answer<<".\n";
break;
case 0:
cout<<"Your answer is incorrect\n";
}
// cout<<"\n";
return 0;
}জয়ের শর্ত
আপনি দুজন দু'টি প্রোগ্রাম বোডি লিখুন , যার একটিতে শিরোলেখগুলিতে সংখ্যাগুলি গুন করে, অন্যটি শিরোনামে সংখ্যা যুক্ত করে।
এটি একটি দ্রুততম কোড চ্যালেঞ্জ। যা দ্রুত হয় তা প্রতিটি প্রোগ্রামের জন্য দুটি পরীক্ষার কেস সমাধান করতে ব্যবহৃত অপারেশনগুলির সংখ্যা দ্বারা নির্ধারিত হবে। পরীক্ষার কেসগুলি নিম্নলিখিত শিরোনামের লাইনগুলি:
সংযোজনের জন্য:
+ 15 12
এবং
+ 12 15
এবং গুণনের জন্য
* 4 5
এবং
* 5 4
প্রতিটি ক্ষেত্রে একটি স্কোর ব্যবহৃত অপারেশন সংখ্যা (প্রোগ্রামটি সম্পূর্ণ হওয়ার পরে দোভাষী এই সংখ্যাটি নির্দেশ করবে)। মোট স্কোর হ'ল প্রতিটি পরীক্ষার ক্ষেত্রে স্কোরগুলির যোগফল।
বৈধ প্রবেশের উদাহরণের জন্য আমার উদাহরণ এন্ট্রি দেখুন।
একটি বিজয়ী জমা নিম্নলিখিত বিষয়গুলি সন্তুষ্ট করে:
- দুটি প্রোগ্রাম বডি রয়েছে, একটি যা গুণ এবং একটি যা যুক্ত করে
- সর্বনিম্ন মোট স্কোর আছে (পরীক্ষার ক্ষেত্রে স্কোরের যোগফল)
- পর্যাপ্ত সময় এবং মেমরি দেওয়া, যে কোনও পূর্ণসংখ্যার জন্য কাজ করে যা দোভাষী দ্বারা পরিচালিত হতে পারে (~ 2 ^ 31)
- চালানোর সময় কোনও ত্রুটি প্রদর্শন করে না
- ডিবাগিং কমান্ড ব্যবহার করে না
- দোভাষীর ত্রুটিগুলি ব্যবহার করে না। এর অর্থ হ'ল আপনার আসল প্রোগ্রামটি সিউডো কোড হিসাবে বৈধ হওয়া উচিত এবং পাশাপাশি 'সেট ভাষা'-তে একটি ব্যাখ্যাযোগ্য প্রোগ্রাম।
- স্ট্যান্ডার্ড লুফোলগুলি ব্যবহার করে না (এর অর্থ কোনও হার্ডকোডিং পরীক্ষার মামলা নেই))
রেফারেন্স বাস্তবায়ন এবং ভাষার ব্যবহারের উদাহরণের জন্য দয়া করে আমার উদাহরণটি দেখুন।
$$...$$মেটাতে কাজ করে, তবে মেইনে নয়। আমি চিত্রগুলি তৈরি করতে কোডকোগ ব্যবহার করেছি ।