理論演算を設定する

前提

乗算演算子なし（こことここ）で乗算することを含むいくつかの課題がすでにあり、この課題も同じように（2番目のリンクに最も類似しています）です。

この課題は、以前の課題とは異なり、自然数（N）の集合論的定義を使用します。

そして

例えば、

等々。

チャレンジ

私たちの目標は、セット演算（下記参照）を使用して、自然数を加算および乗算することです。この目的のために、すべてのエントリは同じ「設定言語」であり、そのインタープリターは下にあります。これにより、一貫性とスコアリングが容易になります。

このインタプリタを使用すると、自然数をセットとして操作できます。あなたの仕事は2つのプログラム本体（以下を参照）を書くことです。1つは自然数を追加し、もう1つはそれらを乗算します。

セットに関する予備的な注記

セットは通常の数学的構造に従います。ここにいくつかの重要なポイントがあります：

• セットは注文されていません。
• セット自体は含まれていません
• 要素はセットに含まれるかどうか、これはブール値です。したがって、セット要素は多重度を持つことができません（つまり、要素はセットに複数回存在することはできません）。

通訳と詳細

この課題の「プログラム」は「設定言語」で記述され、ヘッダーと本文の2つの部分で構成されます。

ヘッダ

ヘッダーは非常に単純です。それはあなたが解決しているプログラムをインタプリタに伝えます。ヘッダーはプログラムの最初の行です。+or *文字のいずれかで始まり、スペースで区切られた2つの整数が続きます。例えば：

+ 3 5

または

* 19 2

有効なヘッダーです。最初は、あなたが解決しようとしていること3+5、つまりあなたの答えが正しいことを意味します8。2つ目は乗算を除いて同様です。

体

本文は、通訳に対する実際の指示がある場所です。これが、真に「加算」または「乗算」プログラムを構成するものです。答えは、各タスクに1つずつ、2つのプログラム本体で構成されます。次に、実際にテストケースを実行するようにヘッダーを変更します。

構文と手順

指示は、コマンドとそれに続く0個以上のパラメーターで構成されます。次のデモンストレーションでは、アルファベット文字は変数の名前です。すべての変数はセットであることを思い出してください。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. ; セミコロンは、行の残りがコメントであり、インタープリターによって無視されることを示します

詳細情報

プログラムの開始時には、3つの既存の変数があります。彼らはset1、set2そしてANSWER。set1最初のヘッダーパラメータの値を取ります。set2秒の値を取ります。ANSWER最初は空のセットです。プログラムが完了すると、インタープリターANSWERは、ヘッダーで定義されている算術問題に対する回答の整数表現がであるかどうかをチェックします。もしそうなら、それはstdoutへのメッセージでこれを示します。

インタープリターは、使用された操作の数も表示します。すべての命令は1つの操作です。ラベルの開始にも1つの操作のコストがかかります（ラベルは1回しか開始できません）。

最大20の変数（3つの事前定義された変数を含む）と20のラベルを持つことができます。

通訳者コード

このインタープリターで多数（> 30）を使用すると、処理が非常に遅くなります。その理由を概説します。

• セットの構造は、1つの自然数の増加で、セット構造のサイズを効果的に2倍にするものです。N番目の自然数があり、2 ^ n個（これで私はあなたが見ればという意味では、その中に空集合をNツリーとして、あるn個の空のセットが。注のみ空集合は葉することができます。）この手段を30に対処することは非常にあること20や10を扱うよりもコストがかかります（2 ^ 10と2 ^ 20と2 ^ 30を比較しています）。
• 等価チェックは再帰的です。セットは無秩序であるとされているので、これはこれに取り組む自然な方法のように思われました。
• 修正方法がわからなかった2つのメモリリークがあります。C / C ++が苦手です。少数のみを扱っており、割り当てられたメモリはプログラムの終了時に解放されるため、これはそれほど問題にはなりません。（誰かが何か言う前に、はい、私は知っていstd::vectorます。私はこれを学習課題として行っていました。それを修正する方法がわかっている場合は、私に知らせてください、そうでなければ編集を行います。そのまま。）

また、ファイルset.h内のインクルードパスに注意してくださいinterpreter.cpp。さらに苦労せずに、ソースコード（C ++）：

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;
}

当選条件

あなたは2人で2つのプログラムBODIESを作成します。1つはヘッダーの数値を乗算し、もう1つはヘッダーの数値を加算します。

これは最速のコードチャレンジです。最も速いのは、各プログラムの2つのテストケースを解決するために使用される操作の数によって決まります。テストケースは次のヘッダー行です。

さらに：

+ 15 12

そして

+ 12 15

そして乗算のために

* 4 5

そして

* 5 4

各ケースのスコアは、使用された操作の数です（インタープリターはプログラムの完了時にこの数を示します）。合計スコアは、各テストケースのスコアの合計です。

有効なエントリの例については、サンプルエントリを参照してください。

入賞作品は以下を満たします。

1. 2つのプログラム本体が含まれ、1つは乗算、もう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