গাণিতিক এক্সপ্রেশন শোডাউন!

15

আপনাকে 6 নম্বর দেওয়া হবে: 5 টি সংখ্যা [0-9] এবং একটি লক্ষ্য নম্বর। আপনার লক্ষ্যটি হ'ল অঙ্কের মাঝে অপারেটরগুলি ছেদ করা আপনার লক্ষ্য হিসাবে যতটা সম্ভব get আপনি প্রতিটি অঙ্ক ব্যবহার করতে হবে ঠিক একবার, এবং নিম্নলিখিত অপারেটর ব্যাবহার করতে পারেন অনেক হিসাবে বার হিসাবে আপনি চান: + - * / () ^ sqrt sin cos tan। উদাহরণস্বরূপ, যদি আমাকে দেওয়া হয় তবে 8 2 4 7 2 65আমি আউটপুট দিতে পারি 82-(2*7)-4। এটি 64 টিতে মূল্যায়ন করে, সুতরাং আমি 1 টি স্কোর থেকে যেহেতু আমি লক্ষ্য থেকে 1 দূরে ছিলাম। দ্রষ্টব্য: আপনি অঙ্কগুলির মধ্যে দশমিক পয়েন্ট রাখতে পারবেন না।

আমি গাণিতিক এক্সপ্রেশন মূল্যায়নের জন্য এই স্ট্যাকওভারফ্লো উত্তরটি থেকে কোডটি ব্যবহার করছি । এই প্রশ্নের নীচে এমন প্রোগ্রাম রয়েছে যা আপনি এটি পরীক্ষা করে দেখতে পারেন।

চেইন ফাংশন (আপডেট!)

@ এমদাহমৌনে এই চ্যালেঞ্জের এক নতুন স্তরের জটিলতা প্রকাশ করেছেন। এর মতো, আমি একটি নতুন বৈশিষ্ট্য যুক্ত করছি: আনারি ফাংশনগুলি শৃঙ্খলাবদ্ধ। এটি পাপ, কোস, ট্যান এবং স্কয়ার্টে কাজ করে। এখন লেখার পরিবর্তে sin(sin(sin(sin(10))))আপনি লিখতে পারেন sin_4(10)। এটি ব্যবহারকারীর মধ্যে চেষ্টা করে দেখুন!

ইনপুট

5 টি সংখ্যার 200 লাইন-বিভাজিত পরীক্ষার কেস এবং একটি লক্ষ্য নম্বর যা স্থান দ্বারা পৃথক। নমুনা পরীক্ষার কেসগুলি তৈরি করতে আপনি প্রশ্নের নীচের অংশে প্রোগ্রামটি ব্যবহার করতে পারেন তবে অফিসিয়াল স্কোরিংয়ের জন্য আমার নিজের পরীক্ষার কেসগুলি থাকবে। পরীক্ষার কেসগুলি লক্ষ্য সংখ্যার জন্য নিম্নলিখিত রেঞ্জগুলির সাথে 40 টি পরীক্ষার 5 বিভাগে বিভক্ত হয়:

  • বিভাগ 1: [0,1] (5 দশমিক পয়েন্ট)
  • বিভাগ 2: [0,10] (4 দশমিক পয়েন্টে)
  • বিভাগ 3: [0,1000] (3 দশমিক পয়েন্টে)
  • বিভাগ 4: [0,10 6 ] (1 দশমিক পয়েন্ট)
  • বিভাগ 5: [0,10 9 ] (0 দশমিক পয়েন্টে)

আউটপুট

200 লাইন পৃথক গাণিতিক এক্সপ্রেশন। উদাহরণস্বরূপ, যদি পরীক্ষার কেস হয় 5 6 7 8 9 25.807, একটি সম্ভাব্য আউটপুট হতে পারে78-59+6

স্কোরিং

প্রতিটি প্রতিযোগিতামূলক প্রোগ্রামের চেয়ে লক্ষ্য সংখ্যার কাছাকাছি হওয়া প্রতিটি রাউন্ডের লক্ষ্য। আমি ব্যবহার করতে যাচ্ছি মারিও কার্ট 8 স্কোরিং , যা: । যদি একাধিক উত্তর একই সঠিক স্কোর পায় তবে পয়েন্টগুলি সমানভাবে বিভক্ত হয়, নিকটতম প্রান্তকে গোল করে। উদাহরণস্বরূপ, যদি 5 তম-অষ্টম স্থানে প্রোগ্রামগুলি বাঁধা থাকে তবে তারা প্রত্যেকে (8 + 7 + 6 + 5) / 4 = 6.5 => 7 পয়েন্ট পেতে পারে। 200 রাউন্ড শেষে, প্রোগ্রামটি সবচেয়ে বেশি পয়েন্ট পেয়েছিল। দুটি প্রোগ্রামের শেষে যদি একই সংখ্যক পয়েন্ট থাকে তবে টাই-ব্রেকারটি এমন প্রোগ্রাম যা দ্রুত চলমান শেষ করে।1st: 15 2nd: 12 3rd: 10 4th: 9 5th: 8 6th: 7 7th: 6 8th: 5 9th: 4 10th: 3 11th: 2 12th: 1 13th+: 0

বিধি

  1. আপনি কেবলমাত্র ম্যাকের সি, সি ++, জাভা, পিএইচপি, পার্ল, পাইথন (2 বা 3), রুবি এবং সুইফটের মতো প্রাক-ইনস্টল হওয়া কোনও একটি ভাষা ব্যবহার করতে পারেন। আপনার যদি কোনও ভাষা থাকে তবে আপনি একটি সংকলক / দোভাষীর সাথে ব্যবহার করতে চান যা তুলনামূলকভাবে ছোট ডাউনলোড আমি এটি যুক্ত করতে পারি। আপনি কোনও অনলাইন দোভাষী দিয়ে একটি ভাষাও ব্যবহার করতে পারেন, তবে এটি তত দ্রুত চলবে না।
  2. যদি আপনি ট্রিগ ফাংশন ডিগ্রি বা রেডিয়ানে গণনা করতে চান তবে আপনার উত্তরে উল্লেখ করুন ।
  3. আপনার প্রোগ্রামটি অবশ্যই আমার ম্যাকের 60 সেকেন্ডের মধ্যে 200 টি পরীক্ষার ক্ষেত্রে (কোনও ফাইল বা STDOUT- এ) এর সমাধানগুলি আউটপুট করতে পারে ।
  4. এলোমেলোতা বীজ করা আবশ্যক।
  5. সমস্ত পরীক্ষার ক্ষেত্রে আপনার মোট আউটপুট 1 এমবি এর বেশি হতে পারে না ।
  6. আপনি যদি নিজের সমাধানটির উন্নতি করে থাকেন এবং পুনরায় স্কোর করতে চান তবে সাহস করে আপনার উত্তরের শীর্ষে পুনরায় স্কোর যুক্ত করুন ।

প্রোগ্রাম

(আপনি যদি রেডিয়ান চান তবে "ডিগ্রি" যুক্তিটি "রেড" তে পরিবর্তন করুন)

  1. মূল্যায়নকারী পরীক্ষা
  2. পরীক্ষার ক্ষেত্রে আপনার প্রোগ্রামের আউটপুট স্কোর করুন
  3. পরীক্ষার কেস তৈরি করুন:

document.getElementById("but").onclick = gen;
var checks = document.getElementById("checks");
for(var i = 1;i<=6;i++) {
var val = i<6 ? i : "All";
var l = document.createElement("label");
l.for = "check" + val;
l.innerText = " "+val+" ";
checks.appendChild(l);
  var check = document.createElement("input");
  check.type = "checkBox";
  check.id = "check"+val;
  if(val == "All") {
  check.onchange = function() {
  if(this.checked == true)  {
  for(var i = 0;i<5;i++) {
    this.parentNode.elements[i].checked = true;
  }
  }
};  
  }
  else {
  check.onchange = function() {
    document.getElementById("checkAll").checked = false;
  }
  }
  checks.appendChild(check);
  
}



function gen() {
var tests = [];
var boxes = checks.elements;
if(boxes[0].checked)genTests(tests,1,5,40);
if(boxes[1].checked)genTests(tests,10,4,40);
if(boxes[2].checked)genTests(tests,1000,3,40);
if(boxes[3].checked)genTests(tests,1e6,1,40);
if(boxes[4].checked)genTests(tests,1e9,0,40);
document.getElementById("box").value =  tests.join("\n");
}

function genTests(testArray,tMax,tDec,n) {
for(var i = 0;i<n;i++) {
  testArray.push(genNums(tMax,tDec).join(" "));
}
}

function genNums(tMax,tDec) {
var nums = genDigits();
nums.push(genTarget(tMax,tDec));
return nums;
}

function genTarget(tMax,tDec) {
  return genRand(tMax,tDec);
}

function genRand(limit,decimals) {
  var r = Math.random()*limit;
  return r.toFixed(decimals);
}

function genDigits() {
  var digits = [];
   for(var i = 0;i<5;i++) {
    digits.push(Math.floor(Math.random()*10));
   }
   return digits;
}
textarea {
  font-size: 14pt;
  font-family: "Courier New", "Lucida Console", monospace;
}

div {
text-align: center;
}
<div>
<label for="checks">Sections: </label><form id="checks"></form>
<input type="button" id="but" value="Generate Test Cases" /><br/><textarea id="box" cols=20 rows=15></textarea>
</div>
স্নিপেট প্রসারিত করুন

লিডারবোর্ড

  1. ব্যবহারকারী 202729 ( সি ++ ): 2856, 152 জিতেছে
  2. mdahmoune ( পাইথন 2 ) [v2]: 2544, 48 জিতেছে

বিভাগ স্কোর (জয়ের # টি):

  1. [0-1] ব্যবহারকারী 202729 : 40, এমডাহুমনে: 0
  2. [0-10] ব্যবহারকারী 202729 : 40, এমডাহুমনে: 0
  3. [0-1000] ব্যবহারকারী 202729 : 39, এমডাহুমনে: 1
  4. [0-10 6 ] ব্যবহারকারী 202729 : 33, এমডাহুমনে: 7
  5. [0-10 9 ] ব্যবহারকারী 202729: 0, এমডাহুমনে : 40

সম্পর্কিত: ব্যবহারকারী-নির্দিষ্ট নম্বর ব্যবহার করে একটি বৈধ সমীকরণ তৈরি করুন

code-challenge  test-battery  expression-building 
— geokavel
সূত্র
ত্রিকোণমিত্রিক ফাংশনগুলিতে ডিগ্রি ব্যবহারের কোনও নির্দিষ্ট কারণ আছে কি? রেডিয়ান বা ডিগ্রি নির্দিষ্ট করে উত্তরের জন্য কোনও বিকল্প যুক্ত করা যেতে পারে?
— notjagan
অঙ্কগুলির সেটটিতে অগত্যা একটি শূন্য অংক থাকে?
— mdahmoune
@mdahmoune পরীক্ষার কেসগুলি এলোমেলোভাবে তৈরি করা হয়, সুতরাং অঙ্কগুলি সমস্ত 0 হতে পারে You আপনাকে এই পরিস্থিতিতে আপনার সেরাটি করতে হবে। ডিগ্রি মোডে আমি 3283.14 এর সাথে সমস্ত উপায়ে পেতে সক্ষম হয়েছি cos(0)/sin(0^0)/sin(0^0)।
— জিওকেভেল
আপনার সম্পূর্ণ উত্তরের জন্য থ্যাঙ্কস :)
— mdahmoune
এটি কি 5 টি বিভিন্ন বিভাগের জন্য একই স্কোরিং পদ্ধতি? ABS (target_value-generated_expression_value)? আমি
— mdahmoune

উত্তর:

3

সি ++

// This program use radian mode

//#define DEBUG

#ifdef DEBUG
#define _GLIBCXX_DEBUG
#include <cassert>
#else
#define assert(x) void(0)
#endif

namespace std {
    /// Used for un-debug.
    struct not_cerr_t {
    } not_cerr;
}

template <typename T>
std::not_cerr_t& operator<<(std::not_cerr_t& not_cerr, T) {return not_cerr;}

#include <iostream>
#include <iomanip>
#include <cmath>
#include <limits>
#include <array>
#include <bitset>
#include <string>
#include <sstream>

#ifndef DEBUG
#define cerr not_cerr
#endif // DEBUG


// String conversion functions, because of some issues with MinGW
template <typename T>
T from_string(std::string st) {
    std::stringstream sst (st);
    T result;
    sst >> result;
    return result;
}

template <typename T>
std::string to_string(T x) {
    std::stringstream sst;
    sst << x;
    return sst.str();
}

template <typename T> int sgn(T val) {
    return (T(0) < val) - (val < T(0));
}


const int N_ITER = 1000, N_DIGIT = 5, NSOL = 4;
std::array<int, N_DIGIT> digits;
double target;

typedef std::bitset<N_ITER> stfunc; // sin-tan expression
// where sin = 0, tan = 1

double eval(const stfunc& fn, int length, double value) {
    while (length --> 0) {
        value = fn[length] ? std::tan(value) : std::sin(value);
    }
    return value;
}

struct stexpr { // just a stfunc with some information
    double x = 0, val = 0; // fn<length>(x) == val
    int length = 0;
    stfunc fn {};
//    bool operator[] (const int x) {return fn[x];}
    double eval() {return val = ::eval(fn, length, x);}
};

struct expr { // general form of stexpr
    // note that expr must be *always* atomic.
    double val = 0;
    std::string expr {};

    void clear() {
        val = 0;
        expr.clear();
    }

    // cos(cos(x)) is in approx 0.5 - 1,
    // so we can expect that sin(x) and tan(x) behaves reasonably nice
    private: void wrapcos2() {
        expr = "(cos_2 " + expr + ")"; // we assume that all expr is atomic
        val = std::cos(std::cos(val));
    }

    public: void wrap1() {
        if (val == 0) {
            expr = "(cos " + expr + ")"; // we assume that all expr is atomic
            val = std::cos(val);
        }
        if (val == 1) return;
        wrapcos2(); // range 0.54 - 1
        int cnt_sqrt = 0;
        for (int i = 0; i < 100; ++i) {
            ++cnt_sqrt;
            val = std::sqrt(val);
            if (val == 1) break;
        }
        expr = "(sqrt_" + to_string(cnt_sqrt) + " " + expr + ")"; // expr must be atomic
    }
};

stexpr nearest(double initial, double target) {
    stexpr result; // built on the fn of that
    result.x = initial;
    double value [N_ITER + 1];
    value[0] = initial;
    for (result.length = 1; result.length <= N_ITER; ++result.length) {
        double x = value[result.length-1];
        if (x < target) {
            result.fn[result.length-1] = 1;
        } else if (x > target) {
            result.fn[result.length-1] = 0;
        } else { // unlikely
            --result.length;
//            result.val = x;
            result.eval();
            assert(result.val == x);
            return result;
        }
        value[result.length] = result.eval(); // this line takes most of the time
        if (value[result.length] == value[result.length-1])
            break;
    }

//    for (int i = 0; i < N_ITER; ++i) {
//        std::cerr << i << '\t' << value[i] << '\t' << (value[i] - target) << '\n';
//    }

    double mindiff = std::numeric_limits<double>::max();
    int resultlength = -1;
    result.length = std::min(N_ITER, result.length);
    for (int l = 0; l <= result.length; ++l) {
        if (std::abs(value[l] - target) < mindiff) {
            mindiff = std::abs(value[l] - target);
            resultlength = l;
        }
    }

    result.length = resultlength;
    double val = value[resultlength];
    assert(std::abs(val - target) == mindiff);
    if (val != target) { // second-order optimization
        for (int i = 1; i < result.length; ++i) {
            // consider pair (i-1, i)
            if (result.fn[i-1] == result.fn[i]) continue; // look for (sin tan) or (tan sin)
            if (val < target && result.fn[i-1] == 0) { // we need to increase val : sin tan -> tan sin
                result.fn[i-1] = 1;
                result.fn[i] = 0;
                double newvalue = result.eval();
//                if (!(newvalue >= val)) std::cerr << "Floating point sin-tan error 1\n";
                if (std::abs(newvalue - target) < std::abs(val - target)) {
//                    std::cerr << "diff improved from " << std::abs(val - target) << " to " << std::abs(newvalue - target) << '\n';
                    val = newvalue;
                } else {
                    result.fn[i-1] = 0;
                    result.fn[i] = 1; // restore
                    #ifdef DEBUG
                    result.eval();
                    assert(val == result.val);
                    #endif // DEBUG
                }
            } else if (val > target && result.fn[i-1] == 1) {
                result.fn[i-1] = 0;
                result.fn[i] = 1;
                double newvalue = result.eval();
//                if (!(newvalue <= val)) std::cerr << "Floating point sin-tan error 2\n";
                if (std::abs(newvalue - target) < std::abs(val - target)) {
//                    std::cerr << "diff improved from " << std::abs(val - target) << " to " << std::abs(newvalue - target) << '\n';
                    val = newvalue;
                } else {
                    result.fn[i-1] = 1;
                    result.fn[i] = 0; // restore
                    #ifdef DEBUG
                    result.eval();
                    assert(val == result.val);
                    #endif // DEBUG
                }
            }
        }
    }
    double newdiff = std::abs(val - target);
    if (newdiff < mindiff) {
        mindiff = std::abs(val - target);
        std::cerr << "ok\n";
    } else if (newdiff > mindiff) {
        std::cerr << "Program error : error value = " << (newdiff - mindiff) << " (should be <= 0 if correct) \n";
        std::cerr << "mindiff = " << mindiff << ", newdiff = " << newdiff << '\n';
    }
    result.eval(); // set result.result
    assert(val == result.val);

    return result;
}

expr nearest(const expr& in, double target) {
    stexpr tmp = nearest(in.val, target);
    expr result;
    for (int i = 0; i < tmp.length; ++i)
        result.expr.append(tmp.fn[i] ? "tan " : "sin ");

    result.expr = "(" + result.expr + in.expr + ")";
    result.val = tmp.val;
    return result;
}

int main() {
    double totalscore = 0;

    assert (std::numeric_limits<double>::is_iec559);
    std::cerr << std::setprecision(23);

//    double initial = 0.61575952241185627;
//    target = 0.6157595200093855;
//    stexpr a = nearest(initial, target);
//    std::cerr << a.val << ' ' << a.length << '\n';
//    return 0;

    while (std::cin >> digits[0]) {
        for (unsigned i = 1; i < digits.size(); ++i) std::cin >> digits[i];
        std::cin >> target;

/*        std::string e;
//        int sum = 0;
//        for (int i : digits) {
//            sum += i;
//            e.append(to_string(i)).push_back('+');
//        }
//        e.pop_back(); // remove the last '+'
//        e = "cos cos (" + e + ")";
//        double val = std::cos(std::cos((double)sum));
//
//        stexpr result = nearest(val, target); // cos(cos(x)) is in approx 0.5 - 1,
//        // so we can expect that sin(x) and tan(x) behaves reasonably nice
//        std::string fns;
//        for (int i = 0; i < result.length; ++i) fns.append(result.fn[i] ? "tan" : "sin").push_back(' ');
//
//        std::cout << (fns + e) << '\n';
//        continue;*/

        std::array<expr, NSOL> sols;
        expr a, b, c, d; // temporary for solutions

        /* ----------------------------------------
           solution 1 : nearest cos cos sum(digits) */

        a.clear();
        for (int i : digits) {
            a.val += i; // no floating-point error here
            a.expr.append(to_string(i)).push_back('+');
        }
        a.expr.pop_back(); // remove the last '+'
        a.expr = "(" + a.expr + ")";
        a.wrap1();

        sols[0] = nearest(a, target);


        /* -----------------------------------------
              solution 2 : a * tan(b) + c (also important) */

        // find b first, then a, then finally c
        a.clear(); b.clear(); c.clear(); // e = a, b = e1, c = e2

        a.expr = to_string(digits[0]);
        a.val = digits[0];
        a.wrap1();

        b.expr = "(" + to_string(digits[1]) + "+" + to_string(digits[2]) + ")";
        b.val = digits[1] + digits[2];
        b.wrap1();

        c.expr = to_string(digits[3]);
        c.val = digits[3];
        c.wrap1();

        d.expr = to_string(digits[4]);
        d.val = digits[4];
        d.wrap1();

        b = nearest(b, std::atan(target));

        double targetA = target / std::tan(b.val);
        int cnt = 0;
        while (targetA < 1 && targetA > 0.9) {
            ++cnt;
            targetA = targetA * targetA;
        }
        a = nearest(a, targetA);
        while (cnt --> 0) {
            a.val = std::sqrt(a.val);
            a.expr = "sqrt " + a.expr;
        }
        a.expr = "(" + a.expr + ")"; // handle number of the form 0.9999999999

        /// partition of any number to easy-to-calculate sum of 2 numbers
        {{{{{{{{{{{{{{{{{{{{{{{{{{{{}}}}}}}}}}}}}}}}}}}}}}}}}}}}

        double targetC, targetD; // near 1, not in [0.9, 1), >= 0.1
        // that is, [0.1, 0.9), [1, inf)

        double target1 = target - (a.val * std::tan(b.val));

        double ac = std::abs(target1), sc = sgn(target1);
        if (ac < .1) targetC = 1 + ac, targetD = -1;
        else if (ac < 1) targetC = 1 + ac/2, targetD = ac/2 - 1;
        else if (ac < 1.8 || ac > 2) targetC = targetD = ac/2;
        else targetC = .8, targetD = ac - .8;

        targetC *= sc; targetD *= sc;

        c = nearest(c, std::abs(targetC)); if (targetC < 0) c.val = -c.val, c.expr = "(-" + c.expr + ")";
        d = nearest(d, std::abs(targetD)); if (targetD < 0) d.val = -d.val, d.expr = "(-" + d.expr + ")";

        sols[1].expr = a.expr + "*tan " + b.expr + "+" + c.expr + "+" + d.expr;
        sols[1].val = a.val * std::tan(b.val) + c.val + d.val;

        std::cerr
        << "\n---Method 2---"
        << "\na = " << a.val
        << "\ntarget a = " << targetA
        << "\nb = " << b.val
        << "\ntan b = " << std::tan(b.val)
        << "\nc = " << c.val
        << "\ntarget c = " << targetC
        << "\nd = " << d.val
        << "\ntarget d = " << targetD
        << "\n";

        /* -----------------------------------------
              solution 3 : (b + c) */

        target1 = target / 2;
        b.clear(); c.clear();

        for (int i = 0; i < N_DIGIT; ++i) {
            expr &ex = (i < 2 ? b : c);
            ex.val += digits[i];
            ex.expr.append(to_string(digits[i])).push_back('+');
        }
        b.expr.pop_back();
        b.expr = "(" + b.expr + ")";
        b.wrap1();

        c.expr.pop_back();
        c.expr = "(" + c.expr + ")";
        c.wrap1();

        b = nearest(b, target1);
        c = nearest(c, target - target1); // approx. target / 2

        sols[2].expr = "(" + b.expr + "+" + c.expr + ")";
        sols[2].val = b.val + c.val;

        /* -----------------------------------------
              solution 4 : a (*|/) (b - c)  (important) */

        a.clear(); b.clear(); c.clear(); // a = a, b = e1, c = e2

        a.expr = to_string(digits[0]);
        a.val = digits[0];
        a.wrap1();

        b.expr = "(" + to_string(digits[1]) + "+" + to_string(digits[2]) + ")";
        b.val = digits[1] + digits[2];
        b.wrap1();

        c.expr = "(" + to_string(digits[3]) + "+" + to_string(digits[4]) + ")";
        c.val = digits[3] + digits[4];
        c.wrap1();


        // (b-c) should be minimized
        bool multiply = target < a.val;
        double factor = multiply ? target / a.val : a.val / target;

        target1 = 1 + 2 * factor; // 1 + 2 * factor and 1 + factor

        std::cerr << "* Method 4 :\n";
        std::cerr << "b initial = " << b.val << ", target = " << target1 << ", ";
        b = nearest(b, target1);
        std::cerr << " get " << b.val << '\n';

        std::cerr << "c initial = " << c.val << ", target = " << b.val - factor << ", ";
        c = nearest(c, b.val - factor); // factor ~= e1.val - e2.val
        std::cerr << " get " << c.val << '\n';

        sols[3].expr = "(" + a.expr + (multiply ? "*(" : "/(") +
        ( b.expr + "-" + c.expr )
        + "))";
        factor = b.val - c.val;
        sols[3].val = multiply ? a.val * factor : a.val / factor;

        std::cerr << "a.val = " << a.val << '\n';

        /* ----------------------------------
                    Final result */

        int minindex = 0;
        assert(NSOL != 0);
        for (int i = 0; i < NSOL; ++i) {
            if (std::abs(target - sols[i].val) < std::abs(target - sols[minindex].val)) minindex = i;
            std::cerr << "Sol " << i << ", diff = " << std::abs(target - sols[i].val) << "\n";
        }
        std::cerr << "Choose " << minindex << "; target = " << target << '\n';
        totalscore += std::abs(target - sols[minindex].val);

        std::cout << sols[minindex].expr << '\n';
    }

    // #undef cerr // in case no-debug
    std::cerr << "total score = " << totalscore << '\n';
}

স্ট্যান্ডার্ড আউটপুট থেকে স্ট্যান্ডার্ড আউটপুট থেকে ইনপুট।

— user202729
সূত্র
হ্যাঁ, আমি মনে করি <1MB। নোট করুন যে প্রোগ্রামটি যদি কোনও কিছু লঙ্ঘন করে তবে আপনি হ্রাস করতে পারবেন N_ITER(বর্তমানে 1000)
— ব্যবহারকারী 202729
@ জোকাভেল এখন 1 / sin_100000000 (2)অনুমতি দেওয়া হলে এটি প্রশ্নবিদ্ধ , বা sin_1.374059274 (1)।
— ব্যবহারকারী 202729
1 / sin_100000000 (2)আপনার নিজের কাছে 1 এবং 2 অঙ্ক থাকলে তা অনুমোদিত। কিভাবে sin_1.374059274কাজ করবে আমার কোনও ধারণা নেই । পাপকে বারবার অ-পূর্ণসংখ্যার পুনরাবৃত্তি করার অর্থ কী?
— জিওকাভেল
@ জোকাভেল তবে পূর্বের সূত্রটি মূল্যায়নে চিরকালের জন্য নেয়, সুতরাং স্কোর গণনা করা কঠিন নয়। পরে en.wikedia.org/wiki/… | সংজ্ঞায়িত করা যেতে পারে অফিসিয়াল পরীক্ষার ক্ষেত্রে প্রোগ্রামটি কেমন?
— ব্যবহারকারী 202729
আংশিক পুনরাবৃত্তির দ্বারা আপনি কী বোঝাতে চেয়েছেন তা আমি দেখতে পেয়েছি তবে আমি মনে করি এটি বাস্তবায়ন আমার পক্ষে খুব কঠিন। আপনার প্রোগ্রামটি ভাল সময়ে চলে - প্রায় 25 সেকেন্ড।
— জিওকাভেল
2

পাইথন 2 , রেডিয়ানস, সরকারী পরীক্ষায় 0.0032 স্কোর করে

এটি দ্বিতীয় খসড়া সমাধানটি 0.0032 পয়েন্টের গড় স্কোর দেয়। যেহেতু এটি প্রচুর সংমিশ্রণ sinব্যবহার করে আমি আউটপুট সূত্রের জন্য নিম্নলিখিত কমপ্যাক্ট স্বরলিপি ব্যবহার করেছি:

  • sin_1 x=sin(x)
  • sin_2 x=sin(sin(x))
  • ...
  • sin_7 x=sin(sin(sin(sin(sin(sin(sin(x)))))))
  • ... 
import math
import bisect
s1=[[float(t) for t in e.split()] for e in s0.split('\n')]
maxi=int(1e7)
A=[]
B=[]
C=[]
D=[]
a=1
for i in range(maxi):
	A.append(a)
	C.append(1/a)
	b=math.sin(a)
	c=a-b
	B.append(1/c)
	D.append(c)
	a=b
B.sort() 
C.sort() 
A.sort() 
D.sort() 
d15={0:'sqrt_100 tan_4 cos_2 sin 0',1:'sqrt_100 tan_4 cos_2 sin 1',2:'sqrt_100 tan_2 cos_2 sin 2',3:'sqrt_100 tan_4 cos_2 sin 3',4:'sqrt_100 tan_4 cos_2 sin 4',5:'sqrt_100 tan_4 cos_2 sin 5',6:'sqrt_100 tan_4 cos_2 sin 6',7:'sqrt_100 tan_2 cos_2 sin 7',8:'sqrt_100 tan_2 cos_2 sin 8',9:'sqrt_100 tan_4 cos_2 sin 9'}
def d16(d):return '('+d15[d]+')'

def S0(l):
	cpt=0
	d=l[:-1]
	r=l[-1]
	a1,a2,a3,a4,a5=[int(t) for t in d]
	i1=bisect.bisect(B, r)-1
	w1=abs(r-B[i1])
	i2=bisect.bisect(C, w1)-1
	w2=abs(w1-C[i2]) 
	s='('+d16(a1)+'/(sin_'+str(i1)+' '+d16(a2)+'-'+'sin_'+str(i1+1)+' '+d16(a3)+')'+'+'+d16(a4)+'/sin_'+str(i2)+' '+d16(a5)+')'
	return (w2,s)

def S1(l):
	cpt=0
	d=l[:-1]
	r=l[-1]
	a1,a2,a3,a4,a5=[int(t) for t in d]
	i1=bisect.bisect(C, r)-1
	w1=abs(r-C[i1])
	i2=bisect.bisect(A, w1)-1
	w2=abs(w1-A[i2]) 
	s='('+d16(a1)+'/sin_'+str(i1)+' '+d16(a2)+'+sin_'+str(maxi-i2-1)+' ('+d16(a3)+'*'+d16(a4)+'*'+d16(a5)+')'
	return (w2,s)

def S2(l):
	cpt=0
	d=l[:-1]
	r=l[-1]
	a1,a2,a3,a4,a5=[int(t) for t in d]
	i1=bisect.bisect(A, r)-1
	w1=abs(r-A[i1])
	i2=bisect.bisect(D, w1)-1
	w2=abs(w1-D[i2]) 
	s='('+'(sin_'+str(maxi-i2-1)+' '+d16(a1)+'-'+'sin_'+str(maxi-i2)+' '+d16(a2)+')'+'+sin_'+str(maxi-i1-1)+' ('+d16(a3)+'*'+d16(a4)+'*'+d16(a5)+'))'
	return (w2,s)

def S3(l):
	cpt=0
	d=l[:-1]
	r=l[-1]
	a1,a2,a3,a4,a5=[int(t) for t in d]
	i1=bisect.bisect(A, r)-1
	w2=abs(r-A[i1])
	s='('+'sin_'+str(maxi-i1-1)+' ('+d16(a1)+'*'+d16(a2)+'*'+d16(a3)+'*'+d16(a4)+'*'+d16(a5)+'))'
	return (w2,s)

def S4(l):
	cpt=0
	d=l[:-1]
	r=l[-1]
	a1,a2,a3,a4,a5=[int(t) for t in d]
	i1=bisect.bisect(B, r)-1
	w2=abs(r-B[i1])
	s='('+d16(a1)+'/(sin_'+str(i1)+' '+d16(a2)+'-'+'sin_'+str(i1+1)+' '+d16(a3)+'*'+d16(a4)+'*'+d16(a5)+')'+')'
	return (w2,s)

def S5(l):
	cpt=0
	d=l[:-1]
	r=l[-1]
	a1,a2,a3,a4,a5=[int(t) for t in d]
	i1=bisect.bisect(C, r)-1
	w2=abs(r-C[i1])
	s='('+d16(a1)+'/sin_'+str(i1)+' '+d16(a2)+'*'+d16(a3)+'*'+d16(a4)+'*'+d16(a5)+')'
	return (w2,s)

def S6(l):
	cpt=0
	d=l[:-1]
	r=l[-1]
	a1,a2,a3,a4,a5=[int(t) for t in d]
	i1=bisect.bisect(D, r)-1
	w2=abs(r-D[i1])
	s='(sin_'+str(maxi-i1-1)+' '+d16(a1)+'-'+'sin_'+str(maxi-i1)+' '+d16(a2)+'*'+d16(a3)+'*'+d16(a4)+'*'+d16(a5)+')'
	return (w2,s)

def all4(s1):
	s=0
	for l in s1:
		f=min(S0(l),S1(l),S2(l),S3(l),S4(l),S5(l),S6(l))
		print f[1]
		s+=f[0]
	s/=len(s1)
	print 'average unofficial score:',s
all4(s1)

এটি অনলাইন চেষ্টা করুন!

— mdahmoune
সূত্র
1
আপনার প্রোগ্রামটি সরকারী পরীক্ষাগুলিতে 49.70 ডলার লাভ করে। কিছু কারণে নিম্নোক্ত সংখ্যায় অধ্যায় 3-এ একটি পরীক্ষা মামলা সত্যিই খারাপ করে: 6 7 8 0 1।
— জিওকেভেল
আপনার প্রোগ্রামটি +(tan_4 cos_2 sin 6)/(sin_0((-(tan_4 cos_2 sin 7)-(tan_4 cos_2 sin 8)+(tan_4 cos_2 sin 0)+(tan_4 cos_2 sin 1))))এই পরীক্ষার ক্ষেত্রে আউটপুট দেয় , যার সমান পরিমাণ 0.145।
— জিওকাভেল
দুঃখিত, আমি আপনার অফিসিয়াল পরীক্ষার স্কোরটি প্রথমবার ভুল লিখেছি। আপনি সরকারী পরীক্ষাগুলিতে গড়ের চেয়ে কিছুটা খারাপ করেন।
— জিওকাভেল
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.