Встановити теоретичну арифметику

Приміщення

Вже було декілька викликів, які передбачають множення без оператора множення ( тут і тут ), і це виклик знаходиться в тому ж ключі (найбільш схожий на друге посилання).

Ця задача, на відміну від попередніх, буде використовувати набір теоретичних визначень натуральних чисел ( N ):

і

наприклад,

і так далі.

Змагання

Нашою метою є використання заданих операцій (див. Нижче), для додавання та множення натуральних чисел. З цією метою всі записи будуть на тій же «заданій мові», чий перекладач знаходиться нижче . Це забезпечить послідовність, а також легше оцінювання.

Цей інтерпретатор дозволяє маніпулювати натуральними числами як множинами. Вашим завданням буде написати два програмні органи (див. Нижче), одне з яких додає натуральні числа, а друге з яких помножує їх.

Попередні примітки до наборів

Набори дотримуються звичайної математичної структури. Ось кілька важливих моментів:

• Набори не замовлені.
• Жоден набір не містить себе
• Елементи є або в наборі, або ні, це булеве. Тому набір елементів не може мати кратності (тобто елемент не може бути у множині кілька разів.)

Перекладач та специфіка

"Програма" для цього виклику написана "мовою набору" і складається з двох частин: заголовка та тіла.

Заголовок

Заголовок дуже простий. Це повідомляє перекладачеві, яку програму ви вирішуєте. Заголовок - це початковий рядок програми. Він починається з +або *символу або з наступним двома цілими числами з пробілом. Наприклад:

+ 3 5

або

* 19 2

є дійсними заголовками. Перший вказує на те, що ви намагаєтесь вирішити 3+5, це означає, що ваша відповідь повинна бути 8. Друга схожа за винятком множення.

Тіло

Тіло - це ваші фактичні вказівки перекладачеві. Це те, що справді становить вашу програму "додавання" чи "множення". Ваша відповідь повинна складатися з двох програмних органів, по одному на кожне завдання. Потім ви зміните заголовки, щоб фактично виконати тестові справи.

Синтаксис та інструкції

Інструкції складаються з команди, за якою слідують нульові або більше параметрів. Для цілей наступних демонстрацій будь-який символ алфавіту - це ім'я змінної. Нагадаємо, що всі змінні є множинами. label- це назва мітки (мітки - це слова, за якими слідують крапки з комою (тобто main_loop:), int- ціле число. Нижче наведено дійсні інструкції:

1. jump labelбеззастережно стрибати на мітку. Мітка - це «слово», яке супроводжується крапкою з комою: наприклад main_loop:, це мітка.
2. je A label перейти до мітки, якщо A порожній
3. jne A label перейти до мітки, якщо A не порожній
4. jic A B label перейти до мітки, якщо A містить B
5. jidc A B label перейти до мітки, якщо A не містить B

6. assign A Bабо assign A int або
   де set(int)є набір представленняint

7. union A B C
8. intersect A B C
9. difference A B C
10. add A B
11. remove A B

12. print A друкує справжнє значення A, де {} - порожній набір
13. printi variable друкує ціле представлення A, якщо воно існує, інакше видає помилку.

14. ; Точка з комою вказує, що решта рядка - це коментар і інтерпретатор буде проігнорований

Додаткова інформація

При запуску програми є три попередньо змінених змінних. Вони є set1,set2 і ANSWER. set1приймає значення першого параметра заголовка. set2приймає значення другого. ANSWERце спочатку порожній набір. Після завершення програми інтерпретатор перевіряє, чи ANSWERє ціле подання відповіді на арифметичну задачу, визначену в заголовку. Якщо це так, це вказує на повідомлення stdout.

Інтерпретатор також відображає кількість використаних операцій. Кожна інструкція - одна операція. Ініціація мітки також коштує однієї операції (Мітки можна ініціювати лише один раз).

Ви можете мати максимум 20 змінних (включаючи 3 попередньо визначені змінні) та 20 міток.

Код перекладача

Все дуже повільно, коли в цьому перекладачі використовується велика кількість (> 30). Я викладу причини цього.

• Структура множин така, що збільшуючи на одне натуральне число, ви ефективно подвоюєте розмір заданої структури. У n- му натуральному числі є 2 ^ n порожніх наборів всередині нього (під цим я маю на увазі, що якщо ви виглядаєте n як дерево, є n порожніх множин. Зауважте, що лише порожні множини можуть бути листями). Це означає, що мати справу з 30 значно дорожче, ніж спілкування з 20 або 10 (ви дивитесь на 2 ^ 10 проти 2 ^ 20 проти 2 ^ 30).
• Перевірки рівності є рекурсивними. Оскільки набори нібито не упорядковані, це здавалося природним способом вирішити це.
• Є два витоки пам'яті, які я не міг зрозуміти, як виправити. Мені погано в C / C ++, вибачте. Оскільки ми маємо справу лише з невеликою кількістю, а виділена пам'ять звільняється в кінці програми, це насправді не повинно бути великою проблемою. (Перш ніж хтось щось скаже, так, я знаю про це std::vector, я робив це як навчальну вправу. Якщо ви знаєте, як це виправити, будь ласка, дайте мені знати, і я внесу зміни, інакше, оскільки це працює, я залишу його як є.)

Також зауважте, що set.hу interpreter.cppфайл включено шлях включення . Без додаткових помилок, вихідний код (C ++):

набір.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

Оцінка за кожен випадок - це кількість використаних операцій (інтерпретатор вкаже це число після завершення програми). Загальний бал - це сума балів за кожний тестовий випадок.

Дивіться мій приклад запису для прикладу дійсної записи.

Виграшне подання задовольняє наступному:

1. містить два програмних тіла: одне, яке множиться, і яке додає
2. має найнижчий загальний бал (сума балів у тестових випадках)
3. Враховуючи достатній час та пам'ять, працює для будь-якого цілого числа, яке може обробляти інтерпретатор (~ 2 ^ 31)
4. Не відображає помилок під час запуску
5. Не використовує команди налагодження
6. Не використовує недоліків у перекладачі. Це означає, що ваша фактична програма має бути дійсною як псевдокод, так і інтерпретаційною програмою на "заданій мові".
7. Не використовує стандартні лазівки (це означає, що немає тестових випадків твердого кодування.)

Будь ласка, дивіться мій приклад для здійснення посилання та прикладу використання мови.

Приклад відповіді, 1323 операції

Зауважте, що це приклад, а не реальний запис.

Орган доповнення

Зауважте, що цей орган не працюватиме без заголовка.

Коментарі не потрібні в реальній відповіді, але вони є для того, щоб допомогти вчити азам мови.

assign ANSWER set2                  ; ANSWER = set2
main:                               ; create label 'main'
    add ANSWER ANSWER               ; Answer union {Answer}, i.e. ANSWER++
    assign looper1 0
    assign looper2 0
    jump dec
    continue:
        intersect set1 set1 looper2 ; set1 = set1 intersect looper2, i.e. set1 = min(set1,looper2)
        jne set1 main
        jump end
dec:
    add looper1 looper1             ; looper1++
    jidc set1 looper1 continue      ; jump if looper >= set1    
    add looper2 looper2             ; looper2++
    jump dec
end:

Для тестового випадку

+ 15 12

використовує 440 operationsі для тестового випадку

+ 12 15

використовує 299 operations.

Тіло множення

assign mult_loop 0
main:
    jic set1 mult_loop addition    
    jump end

addition:
    assign temp2 set2
    main_add:
        add ANSWER ANSWER
        assign looper1 0
        assign looper2 0
        jump dec
        cont_add:
            intersect temp2 temp2 looper2
            jne temp2 main_add
            jump end_add
    dec:
        add looper1 looper1
        jidc temp2 looper1 cont_add
        add looper2 looper2
        jump dec
    end_add:
        add mult_loop mult_loop
        jump main

end:

Для тестового випадку

* 4 5

використовує 305 operationsі для тестового випадку

* 5 4

використовує 279 operations.

Тому моя загальна оцінка є440+299+305+279 = 1323