ค่อนข้างน่าเบื่อเกินกว่าที่จะเขียนโค้ดด้วยตนเองความท้าทายของคุณคือการแปลข้อความ ASCII เป็นซอร์สโค้ดแบบสองมิติ

Cubically

นี่เป็นเพียงการวิ่งลงอย่างรวดเร็วของ Cubically; พื้นที่เก็บข้อมูลมีคู่มือที่สมบูรณ์แบบและรายละเอียดเพิ่มเติม

ในทางตรงกันข้ามเป็น esolang ที่ฉันเขียนเมื่อไม่นานมานี้ออกแบบมาเพื่อใช้ในการเจ็บปวด มันมีหน่วยความจำสองส่วนลูกบาศก์รูบิค 3x3x3 และการลงทะเบียนที่เรียกว่า "notepad"

หน่วยความจำ

Cube ของ Rubik ภายในเริ่มต้นได้เช่นนี้:

   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

คำสั่ง

อักขระที่ไม่ใช่จำนวนเต็มตั้งค่าคำสั่งเริ่มต้น สำหรับแต่ละจำนวนเต็มก่อนที่คำสั่งเริ่มต้นจะถูกตั้งค่าอีกครั้งคำสั่งจะดำเนินการกับจำนวนเต็มนั้น ตัวอย่างเช่นx524y312จะดำเนินการคำสั่งxด้วย 5 จากนั้นด้วย 2 จากนั้นด้วย 4 จากนั้นดำเนินการคำสั่งyด้วย 3 จากนั้นด้วย 1 จากนั้นด้วย 2

จำนวนเต็มที่คำสั่งใช้แสดงดัชนีหน้า ดังนั้นx0จะแสดงxบนใบหน้า UP (0-indexed) x1จะแสดงxบนใบหน้าซ้าย (ดัชนี 1 รายการ) และอื่น ๆ

การดำเนินการคำสั่งใด ๆ ด้วย6จะดำเนินการคำสั่งนั้นกับค่า notepad การดำเนินการคำสั่งใด ๆ ที่มีจำนวนเต็มมากกว่า 6 จะทำให้เกิดข้อผิดพลาด

นี่คือตัวอย่างคำสั่ง:

• R1 - หมุนหน้าขวาตามเข็มนาฬิกา 90 °เพื่อให้ลูกบาศก์ภายในดูเหมือนกับตัวอย่างที่สองด้านบน
• R11 - หันหน้าไปทางขวาตามเข็มนาฬิกา 90 °สองครั้งเหมือนกัน R2
• +0 - เพิ่มค่าทั้งหมดของ UP face ให้กับ notepad
• +000 - เพิ่มค่าทั้งหมดของ UP face ให้กับ notepad สามครั้ง
• @6 - พิมพ์ใบหน้า (หน่วยความจำ) ที่ไม่มีดัชนีตัวที่ 6 เป็นตัวอักษร
• %4 - พิมพ์ผลรวมของค่าทั้งหมดบนใบหน้าด้านหลังเป็นจำนวนเต็ม

รายการที่สมบูรณ์ของคำสั่งและไวยากรณ์ที่มีอยู่ในพื้นที่เก็บข้อมูล

ท้าทาย

คุณจะใช้ข้อความ ASCII เป็นอินพุตและพิมพ์โปรแกรม Cubically เป็นเอาต์พุต

ตัวอย่าง (ขโมยมาจากที่นี่และที่นี่ ):

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 testcase
• โปรแกรมของคุณจะต้องเสร็จสิ้นในเวลาน้อยกว่า 180 วินาที (ไม่มีโปรแกรมบังคับโดยใช้เวลาสัปดาห์)
• โปรแกรมของคุณต้องส่งออกรหัส Cubically ที่ถูกต้องซึ่งเสร็จสิ้นในเวลาน้อยกว่า 180 วินาที
• โปรแกรมของคุณจะรับอินพุตผ่านอินพุตมาตรฐานเว้นแต่คุณต้องการยุ่งกับไดรเวอร์ทดสอบ
• โปรแกรมของคุณจะต้องแสดงผลรหัสแบบสองมิติที่ไม่ก่อให้เกิดสิ่งใดนอกจากอินพุตของโปรแกรมเมื่อทำงาน ಠ_ಠ

เกณฑ์การให้คะแนน

คุณจะทดสอบโปรแกรมของคุณด้วย 100 pseudorandom สตริงของความยาว pseudorandom (มีการระบุสคริปต์ทุบตีที่จะทำสิ่งนี้ให้คุณ) นี่คือวิธีที่คุณจะได้คะแนน:

• ให้ความยาวของโปรแกรมที่ส่งออกเป็นo
• ให้ความยาวของสายป้อน พ.ศ. ลิตร
• ให้ตัวแปรRเป็นผลมาจากการo /ลิตร
• หาค่าเฉลี่ยของทุกR : (R ₁ + R ₂ + R _... + R ₁₀₀ ) / 100

ทดสอบด้วยสคริปต์นี้ คุณจะต้องแก้ไขมันตามคำแนะนำ โปรดทราบว่าโปรแกรมไม่ได้ตรวจสอบว่าการส่งออกเป็นรหัส Cubically ที่ถูกต้อง หากคุณไม่สามารถทำให้สคริปต์ทำงานได้ฉันสามารถช่วยได้ Ping ฉันในห้องแชท Cubically

C ++ 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
*/

ลองออนไลน์! (สร้างรหัสตามลำดับจาก ASCII)และ(เรียกใช้รหัสตามลำดับ)

คำอธิบาย:

• ครั้งแรกโปรแกรมพิมพ์ "RU" ซึ่งทำให้ผลรวมใบหน้าจากการ{0,9,18,27,36,45} {6, 15, 27, 26, 19, 42}สิ่งที่ทำให้ชุดผลรวมนั้นมีประโยชน์คือ gcd คือ 1 ดังนั้นโดยตัวตนของBézoutจึงมีวิธีสร้างหมายเลขใด ๆdจากผลรวม (หรือความแตกต่าง) ของตัวเลขเหล่านั้น
• ดังนั้นถ้าถ่านต่อไปคือchและมูลค่า Notepad ปัจจุบันมีnแล้วให้d = ch - nเราสามารถรันคำสั่ง Cubically ในรูปแบบ+{digits from 0 to 5}-{digits from 0 to 5}ดังกล่าวว่าค่า Notepad chจะกลายเป็น จากนั้นก็ดำเนินการ%6เพื่อพิมพ์ค่าแผ่นจดบันทึก
• เพื่อหาวิธีที่มีประสิทธิภาพมากที่สุดในการแสดงdเป็นผลรวม / ความแตกต่างของตัวเลขในชุดที่ใบหน้ารวมผมใช้อัลกอริทึมเป้สำหรับตัวเลขทั้งหมดจาก 0 ถึง 128 เช่นสำหรับd=1โปรแกรมที่ได้รับ27 - 26 = 1จึงพิมพ์ซึ่งเป็น+2-3 27 - 26 = 1ซึ่งสามารถเห็นได้เมื่อรันโปรแกรมด้วยอินพุตabcเอาต์พุตของโปรแกรม

  RU + 4333 @ 6 + 2-3 @ 6 + 2-3 @ 6

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)

ลองออนไลน์!

โอเคฉันไม่คิดว่าฉันจะเพิ่มประสิทธิภาพได้อีก

รุ่นนี้วนซ้ำผ่านตัวละครแต่ละตัวเพิ่ม c% 9 (โดยที่ c คือค่าทศนิยมของตัวละคร) โดยการทำ:5+2/1แล้วเพิ่มส่วนที่หารด้วย 9 โดยการเพิ่มมูลค่าของใบหน้านั้น ตัวอย่างเช่น: เมื่อ:2/1+551@ต้องการพิมพ์ "e" โดยที่:2/1เพิ่ม 2 +551เพิ่ม 99 (9 * (5 + 5 + 1) หรือ 9 * 11) และ@พิมพ์ผลลัพธ์ io.read()การป้อนข้อมูลจะถูกอ่านด้วย

การปรับให้เหมาะสมรวมถึงการเพิ่ม / ลบโดยตรงหลังจากการพิมพ์หากความแตกต่างระหว่างตัวละครเป็นจำนวนมากของ 9, หารค่าปัจจุบันถ้าเป็นไปได้มากกว่าการตั้งค่า c% 9 จากรอยขีดข่วนและการทำซ้ำตัวอักษรโดยการพิมพ์ค่าปัจจุบันอีกครั้ง นอกจากนี้ผมได้ใช้วิธีการ Kamil ของทันทีพิมพ์หน้าใด ๆ ที่มีอยู่แล้วมีค่าเป้าหมายและข้อเสนอแนะ MD XF ที่จะไม่ใช้:ที่จุดเริ่มต้น +แต่แทนที่จะเป็นเพียงแค่เริ่มต้นด้วย

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 และพฤติกรรม End-Of-Input ที่สอดคล้องกัน

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

การเพิ่ม / ลบของใบหน้าซ้ายคือการวนซ้ำจนจบเมื่ออ่าน EOF

C # (.NET Core)คะแนน: 129.98 11.73 10.82 9.62 10.33 10.32 10.20

-1.2 จุดจากคำแนะนำของ MD XF ที่จะใช้@6666...แทน@6@6@6@6...อักขระซ้ำและลำดับการเริ่มต้นที่เหนือกว่า

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นั้นคือการแก้ไข MD XF ที่แก้ไขได้ซึ่งสร้างคิวบ์นี้:

   242
   202
   242
000131555313
010121535343
000131555313
   424
   454
   424

ความสำคัญของคิวบ์นี้คือด้านใดด้านหนึ่งมีผลรวมเป็น 1 ช่วยให้การจัดระเบียบของ Notepad ในขนาดเล็กกว่าทวีคูณของเก้าและโดยเฉพาะอย่างยิ่งมันลดความซับซ้อนของการเคลื่อนไหวญาติแทนที่จะต้องเริ่มจากศูนย์อักขระแต่ละตัว; ในอัลกอริทึมนี้ทั้งการบวกและการลบจะใช้เส้นทางที่สั้นที่สุดระหว่างตัวละคร

การกำหนดค่าเริ่มต้นของ MD XF ทำให้ด้านที่ 2 มีผลรวมเท่ากับ 14 ซึ่งจะช่วยประหยัดเอาต์พุตจำนวนมากสำหรับระยะทาง ASCII ระหว่าง 14 ถึง 20

ตอนนี้สามารถจัดการอินพุตที่มีการขึ้นบรรทัดใหม่ภายใน Console.Read () รับอักขระแต่ละตัวจนกระทั่งสิ้นสุดไฟล์ ดูลิงค์ TIO ที่ควรมีอินพุต

Hello, 
World!

โกนเศษส่วนสักสองสามจุดด้วยการแสดงอักขระในทันทีหากค่า ASCII นั้นเกิดขึ้นที่ด้านข้างแล้ว

ทดสอบ Script ที่ได้รับความอนุเคราะห์จาก MDXF

ส่งก่อนหน้าที่นี่และคำอธิบาย:

นี่เป็นเรื่องที่น่าเบื่อ แต่เท่าที่ฉันสามารถบอกได้ เป็นที่ยอมรับว่าฉันพยายามHello, World!แต่ก็วิ่งออกในล่าม TIO Cubically และมันออก "Hello, World!" ดังนั้นฉันคิดว่ามันใช้งานได้

แทนที่จะจัดการกับคิวบ์จริง ๆ แล้ว notepad จะเพิ่มขึ้นเพียงผลรวมของ 1 หน้า (9) ซ้ำ ๆ จนกระทั่งมันมีค่าที่เหมาะสมสำหรับตัวละครแต่ละตัวแล้วพิมพ์มัน