সর্বাধিক দক্ষ ঘনক্ষেত্র

19

যেকোন কোড ম্যানুয়ালি লিখতে কিউবিকালি খুব ক্লান্তিকর Your

Cubically

এটি কিউবিকালি একটি দ্রুত রান ডাউন ডাউন; সংগ্রহস্থলের আরো একটি সম্পূর্ণ নির্দেশিকা এবং অধিকৃত হয়ে গেছে।

কিউবিকালি হ'ল একটি এসোলাং যা আমি কিছুক্ষণ আগে লিখেছিলাম, এটি ব্যবহারে বেদনাযুক্ত হওয়ার জন্য ডিজাইন করা হয়েছে। এতে মেমরির দুটি টুকরা, একটি 3x3x3 রুবিকের কিউব এবং "নোটপ্যাড" নামে একটি নিবন্ধ রয়েছে।

স্মৃতি

অভ্যন্তরীণ রুবিকের কিউবটি এভাবে শুরু করা হয়:

   000
   000          top face
   000
111222333444    left, front, right, and back faces, respectively
111222333444
111222333444
   555
   555          down face
   555

ডান মুখটি ঘড়ির কাঁটার দিকে 90 ° ঘুরিয়ে নেওয়ার পরে, মেমরি কিউবটি দেখতে এমন হবে:

   002
   002
   002
111225333044
111225333044
111225333044
   554
   554
   554

কমান্ড

একটি অ-পূর্ণসংখ্যার অক্ষর ডিফল্ট কমান্ড সেট করে। ডিফল্ট কমান্ডটি আবার সেট করার আগে প্রতিটি পূর্ণসংখ্যার জন্য, সেই পূর্ণসংখ্যার সাথে কমান্ডটি সঞ্চালিত হয়। উদাহরণস্বরূপ, 5 দিয়ে x524y312কমান্ড সঞ্চালন করা হবে x, তারপরে 2 দিয়ে, তারপর 4 দিয়ে, তারপরে y3 দিয়ে কমান্ড সঞ্চালন করবে , তারপরে 1 দিয়ে, তারপর 2 দিয়ে।

যে পূর্ণসংখ্যাগুলি কমান্ডগুলি ব্যবহার করে তারা মুখ সূচকগুলি উপস্থাপন করে। সুতরাং ইউপি (0-ইনডেক্সড) মুখে x0পারফর্ম করবে x। x1সম্পাদন করা হবেxবাম (1-ইনডেক্সড) মুখের উপর এবং আরও অনেক কিছু।

6যে কোনও কমান্ড দিয়ে পারফর্ম করলে নোটপ্যাড মানটিতে সেই কমান্ডটি সম্পাদিত হবে। 6 এর চেয়ে বেশি পূর্ণসংখ্যার সাথে কোনও কমান্ড সম্পাদন করলে ত্রুটি ঘটবে।

এখানে কয়েকটি উদাহরণ আদেশ রয়েছে:

  • R1 - ডানদিকে ঘড়ির কাঁটার দিকে 90 turn ঘুরান যাতে অভ্যন্তরীণ ঘনক্ষন উপরের দ্বিতীয় উদাহরণের মতো দেখাবে
  • R11 - ডানদিকে ঘড়ির কাঁটার দিক থেকে 90 ° বার অদলবদল করুন to R2
  • +0 - ইউপি মুখের সমস্ত মান নোটপ্যাডে যুক্ত করুন
  • +000 - ইউপি মুখের সমস্ত মান নোটপ্যাডে তিনবার যুক্ত করুন
  • @6 - অস্তিত্বহীন ষষ্ঠ-সূচকযুক্ত মুখ (স্মৃতি) একটি চরিত্র হিসাবে মুদ্রণ করুন
  • %4 - পূর্ণসংখ্যার হিসাবে BACK মুখে সমস্ত মানের সমষ্টি মুদ্রণ করুন

কমান্ড এবং সিনট্যাক্সের একটি সম্পূর্ণ তালিকা সংগ্রহস্থলটিতে উপলব্ধ ।

চ্যালেঞ্জ

আপনি ASCII পাঠ্যটিকে ইনপুট হিসাবে গ্রহণ করবেন এবং আউটপুট হিসাবে একটি কিউবিক প্রোগ্রাম মুদ্রণ করবেন।

উদাহরণ ( এখানে এবং এখান থেকে চুরি ):

Input -> Output
Hello, World! -> +53@6+1F2L2+0@6L2F2U3R3F1L1+2@66L3F3R1U1B3+0@6:4U1R1+00@6-000@6*0-4+000@6-00@6+2-000000@6-5+4000@6-00@6/0+00@6:0+0/0+00@6
1$2$3$4$5$6$7$8$9$10$ -> B1+2/2%6@4+00/0%6@4+00/1%6@4+21/1%6@4+30/0%6@4+22/1%6@4+22/1%6@4+40/1%6@4+52/1%6@4+42/1%6@4

বিধি

  • আপনার প্রোগ্রামে 100 টি পরীক্ষার ক্ষেত্রে অনুবাদ সম্বলিত একটি অভিধান থাকতে পারে না।
  • আপনার প্রোগ্রামটি অবশ্যই 180 সেকেন্ডেরও কম সময়ের মধ্যে শেষ করতে হবে (সপ্তাহে যে কোনও ব্রুট-ফোর্স প্রোগ্রাম নেই)।
  • আপনার প্রোগ্রামকে বৈধ কিউবিক কোড অবশ্যই আউটপুট দিতে হবে যা 180 সেকেন্ডেরও কম সময়ে শেষ হয়।
  • আপনার প্রোগ্রামটি স্ট্যান্ডার্ড ইনপুটটির মাধ্যমে ইনপুট নেবে, যদি না আপনি পরীক্ষক ড্রাইভারের সাথে গোলযোগ করতে চান।
  • আপনার প্রোগ্রামটি অবশ্যই কিউবিক কোড থেকে আউটপুট দিতে হবে যা রান করার সময় আপনার প্রোগ্রামের ইনপুট ব্যতীত অন্য কিছুই উত্পাদন করে না। ಠ_ಠ

স্কোরিং

আপনি সিউডোরোডম দৈর্ঘ্যের 100 টি সিউডোর্যান্ডম স্ট্রিং দিয়ে আপনার প্রোগ্রামটি পরীক্ষা করবেন। (একটি বাশ স্ক্রিপ্ট সরবরাহ করা হয়েছে যা এটি আপনার জন্য এটি করবে)) আপনি কীভাবে স্কোর করবেন তা এখানে:

  • আউটপুট প্রোগ্রামের দৈর্ঘ্য হতে দিন ণ ।
  • ইনপুট স্ট্রিংয়ের দৈর্ঘ্য l হতে দিন ।
  • একটি পরিবর্তনশীল যাক দ ফলও হতে ণ / L ।
  • সমস্ত আর এর গড় সন্ধান করুন : (আর 1 + আর 2 + আর ... + আর 100 ) / 100 ।

এই স্ক্রিপ্ট দিয়ে পরীক্ষা। নির্দেশ অনুসারে আপনাকে এটিকে সংশোধন করতে হবে। নোট করুন যে প্রোগ্রামটি আউটপুটটি বৈধ কিউবিক কোড কিনা তা যাচাই করে না। আপনি যদি স্ক্রিপ্টটি কাজ না করতে পারেন তবে আমি সহায়তা করতে পারি। কিউবিকভাবে চ্যাট রুমে আমাকে পিং করুন ।

code-challenge  cubically 
— এমডি এক্সএফ
সূত্র
1
— এমডি এক্সএফ
" @6- কোন চরিত্র হিসাবে অস্তিত্বহীন 6th ষ্ঠ সূচকযুক্ত মুখ (নোটপ্যাড) এর যোগফলটি" আরও সঠিক হতে হবে? যোগফলও কি %4? করছেন +কমান্ড সমষ্টি মুখ তারপর ... সমস্ত মান বা যে যোগ করতে চান?
— জোনাথন অ্যালান
@ জোনাথান অ্যালান @6/ %6কেবলমাত্র নোটপ্যাডের মানটি একটি চরিত্র / পূর্ণসংখ্যা হিসাবে মুদ্রণ করে। @x/ %x(যেখানে x কোনও বিদ্যমান চেহারা) x-সামান্য মুখের উপর সমস্ত মান যুক্ত করে যোগফলকে একটি অক্ষর / পূর্ণসংখ্যা হিসাবে মুদ্রণ করে। +নিবন্ধে নির্দিষ্ট মুখের সমস্ত মান যুক্ত করে।
— এমডি এক্সএফ
আহ, কোনও কারণে আমি নোটপ্যাডটি 9 টি মান হিসাবে ভেবেছিলাম।
— জোনাথন অ্যালান

উত্তর:

4

সি ++ 11, স্কোর : 6.37

#include <iostream>
#include <vector>
#include <array>
#include <limits>
#include <algorithm>

const int inf = std::numeric_limits<int>::max(),
maxDiff = 128, nFace = 6;
std::array<int, maxDiff+1> plusvalue, totalvalue, plustrace, totaltrace;
std::array<int, nFace> input;

void prtrace(int value) {
    while (value) {
        std::cout << plustrace[value];
        value -= input[plustrace[value]];
    }
}

void prexpr(int i) {
    char xorwt = 0;
    if (i < 0) {
        xorwt = '+' ^ '-';
        i = -i;
    }
    if (totalvalue[i] != 0 && totalvalue[i] != inf) {
        std::cout << (char)('+' xor xorwt);
        prtrace(totaltrace[i]);
        if (totaltrace[i] != i) {
            std::cout << (char)('-' xor xorwt);
            prtrace(totaltrace[i] - i);
        }
    }
}

int main() {
    std::cout << "RU";
    input = {6, 15, 27, 26, 19, 42};
    std::cin >> std::noskipws;

    std::fill(plusvalue.begin(), plusvalue.end(), inf);
    plusvalue[0] = 1; // '+'
    for (int i = 0; i < nFace; ++i) { // knapsack, each value repeated inf times
        int val = input[i];
        if (val == 0) continue;
        for (int p = 0; p <= maxDiff - val; ++p) {
            if (plusvalue[p] != inf && plusvalue[p + val] > plusvalue[p] + 1) {
                plusvalue[p + val] = plusvalue[p] + 1;
                plustrace[p + val] = i;
            }
        }
    }
    for (int p = 0; p <= maxDiff; ++p) totalvalue[p] = plusvalue[p], totaltrace[p] = p;
    totalvalue[0] = 0;
    for (int sub = 1; sub <= maxDiff; ++sub) {
        if (plusvalue[sub] == inf) continue;
        for (int p = 0; p <= maxDiff - sub; ++p) {
            if (plusvalue[p+sub] != inf && totalvalue[p] > plusvalue[p+sub] + plusvalue[sub]) { // include '+'s
                totalvalue[p] = plusvalue[p+sub] + plusvalue[sub];
                totaltrace[p] = p+sub;
            }
        }
    }

//    // Note: plustrace[x] = i<=nFace : plustrace[x-input[i]] + 1 = plustrace[x]
//    long long sum = 0;
//    for (int i = 0; i <= maxDiff; ++i) {
//        sum += totalvalue[i];
//        std::cout << i << '\t' << totalvalue[i] << '\t';
//        prexpr(i);
//        std::cout << '\n';
//    }
//
//    std::cout << "_______________________________\n\nAverage = " << sum / (maxDiff + 1.) << '\n';

// RU 3.98131

    char ch;
    int cur = 0;
    while (std::cin >> ch) {
        int diff = ch - cur;
        prexpr(diff);
        std::cout << "@6";
        cur += diff; // cur = ch
    }
}

/*
RU 3.98131
*/

এটি অনলাইন চেষ্টা করুন! (এএসসিআইআই থেকে কিউবিক কোড উত্পন্ন করুন) এবং (কিউবিক কোড চালান)

ব্যাখ্যা:

  • প্রথম প্রোগ্রাম কপি করে প্রিন্ট "রাবি", যা থেকে মুখ সমষ্টি করতে {0,9,18,27,36,45}করতে {6, 15, 27, 26, 19, 42}। এই মুখের সমষ্টিটিকে কী দরকারী করে তা হ'ল জিসিডি হ'ল, তাই বাজাউটের পরিচয় dঅনুসারে এই সংখ্যাগুলির যোগফল (বা পার্থক্য) থেকে যে কোনও সংখ্যা তৈরির উপায় রয়েছে ।
  • অতএব, যদি পরবর্তী চরটি হয় chএবং বর্তমান নোটপ্যাড মান হয় n, তবে আসুন d = ch - n, আমরা কিউবিকী কমান্ডগুলি ফর্মটিতে কার্যকর করতে পারি +{digits from 0 to 5}-{digits from 0 to 5}যে নোটপ্যাড মানটি হয়ে যায় ch। তারপরে %6নোটপ্যাডের মানটি প্রিন্ট করতে কেবল চালিত করুন ।
  • প্রকাশ করার সবচেয়ে কার্যকর উপায় খুঁজতে dমুখ সমষ্টি সেটে সংখ্যার একটি সমষ্টি / পার্থক্য, আমি 0 থেকে 128. যেমন, জন্য সব সংখ্যার জন্য Knapsack অ্যালগরিদম ব্যবহার d=1, প্রোগ্রাম পায় 27 - 26 = 1, তাই এটি ছাপে +2-3, যা 27 - 26 = 1। ইনপুট abc, প্রোগ্রাম আউটপুট সহ প্রোগ্রামটি চালানোর সময় যা দেখা যায়

    আরউ + 4333 @ 6 + 2-3 @ 6 + 2-3 @ 6

— user202729
সূত্র
ওহ, দুর্দান্ত কাজ! ন্যাপস্যাক অ্যালগরিদম হ'ল আমরা অনুমান করি।
— তেহপার্স
নোট করুন যে ভাষা আপডেটের কারণে আপনি @স্পষ্টভাবে কল করার মাধ্যমে আরও ভাল স্কোর পেতে @6পারেন - @সমস্ত ক্ষেত্রেই সংক্ষিপ্ত করা যেতে পারে ।
— এমডি এক্সএফ
17

অ্যাপ্লিকেশন Lua, স্কোর : 85.91 13.50 13.20 12.70 9.41 9.32 9.83 9.66 9.12 9.06 8.03 (গড়)

-- Get input
local inp = io.read("*a")

local out = ""
local faces = { [5] = 45, [4] = 36, [3] = 27, [2] = 18, [1] = 9 }
local lastChar = nil

-- Mode the program is in
-- 2 = not set (needs :), 1 = just set (needs +), 0 = normal
local mode = 1;
for i = 1, inp:len() do
  -- Character value at current position
  local c = string.byte(inp, i)

  if c == lastChar then
    -- Repeat character
    out = out .. "6"
  elseif c % 9 == 0 and c <= 45 then
    if #out == 0 then
      out = out .. "@"
    end
    out = out .. (c / 9)
  else
    local c2 = c

    -- Handle if difference from lastChar is divisible by 9
    if lastChar and (c - lastChar) % 9 == 0 then
      local difference = c - lastChar
      if difference > 0 then
        out = out .. "+"
      else
        out = out .. "-"
        difference = difference * -1
      end

      for index = 5, 1, -1 do
        local face = faces[index]
        while difference >= face do
          difference = difference - face
          out = out .. index
        end
      end
      c = 0
    end

    -- Handle anything not divisible by 9
    local extra = c % 9
    if extra > 0 then
      -- Try to optimize by dividing by 9, if possible
      if lastChar and math.floor(lastChar / 9) == extra then
        out = out .. "/1"
        mode = 1
        extra = 0
      else
        while extra > 0 do
          local n = extra > 5 and 5 or extra

          if mode == 2 then
            out = out .. ":"
            mode = 1
          elseif mode == 1 then
            out = out .. "+"
            mode = 0
          end
          out = out .. n
          extra = extra - n
        end
        out = out .. "/1"
        mode = 1
      end

      c = c - (c % 9)
    end

    -- Handle anything divisible by 9
    for index = 5, 1, -1 do
      local face = faces[index]
      while c >= face do
        if mode == 2 then
          out = out .. ":"
          mode = 1
        elseif mode == 1 then
          out = out .. "+"
          mode = 0
        end
        c = c - face
        out = out .. index
      end
    end

    out = out .. "@6"
    lastChar = c2
  end

  mode = 2
end
print(out)

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

ঠিক আছে, আমি এটিকে আর অনুকূলিত করতে পারি বলে আমি মনে করি না।

এই সংস্করণটি প্রতিটি চরিত্রের মাধ্যমে পুনরাবৃত্তি করে, সি% 9 যোগ করে (যেখানে সি বর্ণটির দশমিক মান হয়) :5+2/1, তারপরে সেই মুখের মান যুক্ত করে 9 দ্বারা বিভাজ্য অংশগুলি যুক্ত করে। উদাহরণস্বরূপ: :2/1+551@"ই" মুদ্রণ করতে, যেখানে :2/12 যুক্ত হয়, +55199 (9 * (5 + 5 + 1), বা 9 * 11) যোগ করে এবং @আউটপুট মুদ্রণ করে। ইনপুট সঙ্গে পড়া হয় io.read()।

অপ্টিমাইজেশানগুলির মধ্যে মুদ্রণের পরে সরাসরি যোগ করা / বিয়োগ করা অন্তর্ভুক্ত হয় যদি অক্ষরের মধ্যে পার্থক্য 9 এর একাধিক হয়, সম্ভব হয় তবে বর্তমান মানকে স্ক্র্যাচ থেকে সি% 9 সেট করার পরিবর্তে বিভাজন করা এবং বর্তমান মানটি পুনরায় গণনা না করে পুনরায় মুদ্রণের মাধ্যমে অক্ষর পুনরাবৃত্তি করা। অতিরিক্তভাবে, আমি ইতিমধ্যে লক্ষ্য মান সহ যে কোনও মুখ তাত্ক্ষণিকভাবে মুদ্রণের জন্য কামিলের পদ্ধতিটি কার্যকর করেছি এবং এমডি এক্সএফের :শুরুতে ব্যবহার না করার পরামর্শটি পরিবর্তে কেবল একটি দিয়ে শুরু করুন +।

— TehPers
সূত্র
1
আপনি সর্বদা আপনার নিজের প্রশ্ন এবং উত্তর সম্পর্কে মন্তব্য করতে পারেন, তবে আপনি এখনও সাধারণ মন্তব্য অধিকার সম্পর্কে যথেষ্ট নন to কম উত্তর এটির মতো উত্তরগুলি দিয়ে দীর্ঘ হওয়া উচিত নয় (বা সম্ভবত আরও কয়েকজন লোক একবার এটি দেখে
— this
2
@ এমডিএক্সএফ আমি তেমন একটা সুন্দর নই: পি
— কামিল দ্রাকারী
1
আপনি পরিবর্তন local inp = io.read()করতে পারেন local inp = io.read("*all")। এটি সমস্যার সমাধান করে।
— MDXF
1
আরেকটি সম্ভাব্য অপ্টিমাইজেশন - যেহেতু নোটপ্যাডটি 0 থেকে শুরু হয়, আপনাকে আউটপুট দেওয়ার দরকার নেই, উদাহরণস্বরূপ :5+124, পরিবর্তে আপনি কেবল লিখতে +5124পারেন, আপনি যদি এটি সঠিকভাবে টুইট করেন তবে স্কোরটি কিছুটা নিচে নামবে।
— এমডি এক্সএফ
1
আপনি সাম্প্রতিক কিছু কিউবিক আপডেটগুলি যেমন অন্তর্নিহিত মুখের মোড়কে সমর্থন করার জন্য নিজের উত্তর পরিবর্তন করেন তবে আপনি সম্ভবত আরও ভাল স্কোর পাবেন।
— এমডি এক্সএফ
16

Cubically , স্কোর : 86,98

U3D1R3L1F3B1U1D3~:7+1(-1@3(-1%1)6:1+3111@6%1-31111+004@6:1+11111%6:1+45@6:1-1%6~:7+1)6

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

দেখা যাচ্ছে, আপনার যা দরকার তা হ'ল শর্তযুক্ত লুপগুলি, 1 এর সমান মুখ এবং সামঞ্জস্যিক সমাপ্ত-ইনপুট আচরণ।

U3D1R3L1F3B1U1D3     set LEFT face sum to 1
~:7                  read input, set notepad to input
+1                   add 1 to notepad

(                    open loop that can always be jumped to
 -1                   subtract 1 from notepad
 @3                   print RIGHT face (ASCII 43 '+')

            ##   the following mechanism gets the output program's   ##
            ##   notepad to the current inputted ASCII value:        ##

 (                    open loop that can always be jumped to
  -1                   subtract 1 from notepad
  %1                   print '1'
 )6                   jump back to loop while notepad is nonzero

            ##   the following mechanism prints "/1@6:1"             ##

 :1+3111@6            set notepad to 47,    print (ASCII 47 '/')
 %1                   print LEFT face       print (integer '1')
 -31111+004@6         set notepad to 64,    print (ASCII 64 '@')
 :1+11111%6           set notepad to 6,     print (integer 6)
 :1+45@6              set notepad to 58,    print (ASCII 58 ':')
 :1-1%6               set notepad to 0,     print (integer 1)

 ~                    read input
 :7+1                 set notepad to input plus 1, so EOF changes to zero
)6                    loop if notepad is truthy

বাম মুখের যোগ / বিয়োগটি ইওএফ পড়ার সময় লুপটি শেষ করা।

— কামিল দ্রাকারী
সূত্র
2
আপনি পেয়েছেন নিশ্চয়ই মজা করা। এই অবিশ্বাস্য.
— এমডি এক্সএফ
ওহে ওহে, এটির আমার আসল সি # উত্তরের চেয়েও ভাল স্কোর আছে!
— কামিল দ্রাকারী
নোট করুন যে ভাষা আপডেটের কারণে আপনি @স্পষ্টভাবে কল করার মাধ্যমে আরও ভাল স্কোর পেতে @6পারেন - @সমস্ত ক্ষেত্রেই সংক্ষিপ্ত করা যেতে পারে ।
— এমডি এক্সএফ
9

সি # (.NET কোর) , স্কোর: 129.98 11.73 10.82 9.62 10.33 10.32 10.20

-১.২ পয়েন্টটি পুনরুক্তি করা চরিত্রের @6666...পরিবর্তে @6@6@6@6...এবং উচ্চতর সূচনা ক্রমের পরিবর্তে ব্যবহারের জন্য এমডি এক্সএফের পরামর্শ থেকে point

static void Main()
{
	List<byte> input = new List<byte>();
            int inChar = Console.Read();
            while (inChar != -1)
            {
                input.Add((byte)inChar);
                inChar = Console.Read();
            }


            Console.Write("U3D1R3L1F3B1U1D3");
            byte[] sides = new byte[] { 20, 1, 14, 43, 24, 33 };

            byte currentChar = 0;

   	    if(currentChar == input[0] || sides.Contains(input[0])) Console.Write("@");

            foreach (byte character in input)
            {
		if (currentChar == character)
		{
			Console.Write("6");
			continue;
		}
		
		if (sides.Contains(character))
		{
			Console.Write(Array.IndexOf(sides, character));
			continue;
		}
                if (currentChar < character)
                {
                    Console.Write("+");
                    while (currentChar < character)
                    {
                        byte nextAdd = sides.Where(s => s + currentChar <= character).Max();
                        currentChar = (byte)(currentChar + nextAdd);
                        Console.Write(Array.IndexOf(sides, nextAdd));
                    }
                }

                if (currentChar > character)
                {
                    Console.Write("-");
                    while (currentChar > character)
                    {
                        byte nextSub = sides.Where(v => currentChar - v >= character).Max();
                        currentChar = (byte)(currentChar - nextSub);
                        Console.Write(Array.IndexOf(sides, nextSub));
                    }
                }

                Console.Write("@6");
            }
}

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

আমার নতুন সংস্করণটি আসলে কিউবের কিছু হেরফের করে! হ্যাঁ!

প্রথমত Console.Writeএখানে এমডি এক্সএফ থেকে একটি স্থির হেরফের হয় যা এই ঘনকটি তৈরি করে:

   242
   202
   242
000131555313
010121535343
000131555313
   424
   454
   424

এই ঘনক্ষেত্রের তাত্পর্যটি হ'ল এর একটি পক্ষের সমষ্টি 1, যা নোটপ্যাডের ম্যানিপুলেশনগুলিকে নয়টির গুণকের চেয়ে ছোট স্কেলে মঞ্জুরি দেয় এবং বিশেষত এটি প্রতিটি চরিত্রকে শূন্য থেকে শুরু করার পরিবর্তে আপেক্ষিক চলনকে সহজতর করে; এই অ্যালগরিদমে যোগ এবং বিয়োগ উভয়ই অক্ষরের মধ্যে সংক্ষিপ্ততম পথ অবলম্বন করতে ব্যবহৃত হয়।

এমডি এক্সএফ এর প্রাথমিক সংস্করণের সংস্করণটি পার্শ্ব 2 এর 14 টি যোগফল তৈরি করে, যা 14 থেকে 20 এর মধ্যে ASCII দূরত্বের জন্য অনেকগুলি বাইট আউটপুট সংরক্ষণ করে।

এখন অভ্যন্তরীণ নতুনলাইনগুলির সাথে ইনপুটগুলি পরিচালনা করতে পারে, কনসোল R রিড () ফাইলের শেষ অবধি পৃথক অক্ষর পায়; টিআইও লিঙ্কটি দেখুন যাতে ইনপুট থাকা উচিত

Hello, 
World!

অক্ষরের আউটপুট করে তত্ক্ষণাত্ একটি বিন্দুতে কয়েকটি ভগ্নাংশ শেভ করে যদি এর ASCII মানটি ইতিমধ্যে কোনও দিকে উপস্থিত থাকে।

MDXF এর সৌজন্যে টেস্ট স্ক্রিপ্ট

পূর্ববর্তী জমা এখানে এবং ব্যাখ্যা:

এটি দারুণ বিরক্তিকর, তবে যতদূর আমি বলতে পারি এটি কাজ করে। স্বীকার করা মাত্র আমি চেষ্টা করেছি Hello, World!তবে আমি টিআইও কিউবিক্যাল ইন্টারপ্রেটারে আউটপুটটি চালিয়েছি এবং এটি "হ্যালো, ওয়ার্ল্ড!" সুতরাং আমি ধরে নিলাম এটি কাজ করে।

বাস্তবে কিউবকে একেবারে হেরফের করার পরিবর্তে নোটপ্যাডটি প্রতিটি চরিত্রের সঠিক মান না হওয়া পর্যন্ত বার বার 1 টি মুখ (9) এর যোগফল দ্বারা বাড়ানো হয়, তারপরে এটি মুদ্রণ করে।

— কামিল দ্রাকারী
সূত্র
মন্তব্যগুলি বর্ধিত আলোচনার জন্য নয়; এই কথোপকথন চ্যাটে সরানো হয়েছে ।
— মার্টিন ইন্ডার
@ মার্টিনএেন্ডার আপনি কি তাদের পরিবর্তে বিদ্যমান চ্যাটরুমে সরাতে পারবেন?
— এমডি এক্সএফ
@ এমডিএক্সএফ আমি পারতাম তবে আমি বলতে পারছি না যে তারা চ্যাটরুমে জায়গা এবং প্রসঙ্গে সম্পূর্ণরূপে বাইরে থাকবে।
— মার্টিন এন্ডার
@ মার্টিন ইন্ডার মন্তব্যগুলি চ্যাটরুমের চেয়ে পুরনো, সুতরাং এগুলি ঠিক অনুলিপিটিতে ফিরে আসবে, সঠিক?
— এমডি এক্সএফ
তারা হবে। ধন্যবাদ, আমি বার্তা স্থানান্তর করব।
— মার্টিন এন্ডার
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.