C#练习题答案: 我最小码解释器（又名Brainf ** K）【难度：3级】--景越C#经典编程题库,1000道C#基础练习题等你来挑战

最新推荐文章于 2021-02-08 21:55:14 发布
最新推荐文章于 2021-02-08 21:55:14 发布
阅读量122 收藏
点赞数
分类专栏： C#编程训练习题答案 文章标签： csharp面试题库和答案 csharp编程练习 算法 口译 逻辑
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45444821/article/details/102763564
版权

我最小码解释器(又名Brainf ** K)【难度:3级】:

答案1:

using System;
using System.Collections.Generic;
using System.Linq;

public static class Kata
{
  public static string BrainLuck(string code, string input)
  {
    return new Interpreter(code, input).Execute();
  }
}

public class Interpreter
{
  private Dictionary<char, Action> commands = new Dictionary<char, Action>();
  private List<dataByte> data = new List<dataByte>();
  private string validCode;
  private int pointer;
  private string output;
  private string input;
  private int codeLoc;
  
  public Interpreter(string code, string input)
  {
    output = String.Empty;
    commands.Add('<', Backward);
    commands.Add('>', Forward);
    commands.Add('+', Increment);
    commands.Add('-', Decrement);
    commands.Add('.', AddToOutput);
    commands.Add(',', TakeInput);
    commands.Add('[', Jump);
    commands.Add(']', Jump);
    this.input = input;
    validCode = new string(code.Where(commands.ContainsKey).ToArray());
    data.Add(new dataByte());
  }
  
  private void Forward() => MovePointerForward();
  private void Backward() => pointer = pointer == 0 ? 0 : pointer -1;
  private void Increment() => data.ElementAt(pointer).dataVal += 1;
  private void Decrement() => data.ElementAt(pointer).dataVal -= 1;
  private void TakeInput() => TakeIn();
  private void AddToOutput() => output += (char)data.ElementAt(pointer).dataVal;
  private void Jump() => JumpCheck(validCode[codeLoc]);
  
  private void JumpCheck(char command)
  {
    if (command == '[' &amp;&amp; data.ElementAt(pointer).dataVal == 0) jumpIndex(1, '[', ']');
    if (command == ']' &amp;&amp; data.ElementAt(pointer).dataVal != 0) jumpIndex(-1, ']', '[');
  }
  
  private void jumpIndex(int addValue, char match, char stop)
  {
    var count = 1;
    while (count > 0)
    {
      codeLoc += addValue;
      if (validCode[codeLoc] == match)
      {
        count += 1;
      }
      if (validCode[codeLoc] == stop)
      {
        count -= 1;
      }
    }    
  }
  
  private void MovePointerForward()
  {
    pointer++;
    if (pointer >= data.Count())
    {
      data.Add(new dataByte());
    }
  }
  
  private void TakeIn()
  {
    data.ElementAt(pointer).dataVal = input[0];
    input = input.Remove(0, 1);
  }
  
  public string Execute()
  {
    var codeBound = validCode.Length;
    while (codeLoc < codeBound)
    {
      var act = commands[validCode[codeLoc]];
      act();
      codeLoc++;
    }
    return output;
  }
}

public class dataByte
{
  private int val;
  public int dataVal
  {
    get {return val;}
    set
    {
      val = value;
      if (val > 255) val = 0;
      if (val < 0) val = 255;
    }
  }
}​

答案2:

using System;
using System.Collections.Generic;
using System.Linq;

public static class Kata
    {
        public static string BrainLuck(string code, string input)
        {
            code = string.Concat(code.Where(ch => new char[] { '>', '<', '+', '-', ',', '.', '[', ']' }.Contains(ch)));
            List<byte> memory = new List<byte>();
            string output = "";

            int codePtr = 0;
            int inputPtr = 0;
            int memoryPtr = 0; memory.Add(0);

            while (codePtr < code.Length)
            {
                switch (code[codePtr])
                {
                    case '>':
                        if (++memoryPtr >= memory.Count)
                            memory.Add(0);
                        break;
                    case '<':
                        if (memoryPtr == 0)
                            memory.Insert(0, 0);
                        else
                            --memoryPtr;
                        break;
                    case '+':
                        memory[memoryPtr] = memory[memoryPtr] < 255 ? ++memory[memoryPtr] : (byte)0;
                        break;
                    case '-':
                        memory[memoryPtr] = memory[memoryPtr] > 0 ? --memory[memoryPtr] : (byte)255;
                        break;
                    case ',':
                        memory[memoryPtr] = (byte)input[inputPtr];
                        ++inputPtr;
                        break;
                    case '.':
                        output += (char)memory[memoryPtr];
                        break;

                    case '[':
                        if (memory[memoryPtr] == 0) // zero means to jump from loop
                        {
                            int cnt = 1;
                            while (cnt != 0)
                            {
                                ++codePtr;
                                if (code[codePtr] == '[') ++cnt;
                                else if (code[codePtr] == ']') --cnt;
                            }
                        }
                        break;

                    case ']':
                        if (memory[memoryPtr] != 0)
                        {
                            int cnt = 1;
                            while (cnt != 0)
                            {
                                --codePtr;
                                if (code[codePtr] == ']') ++cnt;
                                else if (code[codePtr] == '[') --cnt;
                            }
                        }
                        break;
                }
                ++codePtr;
            }
            return output;
        }
    }​

答案3:

using System;
using System.Collections.Generic;
using System.IO;

public static class Kata
{
    public static string BrainLuck(string code, string input)
    {
        if (code == null)
        {
            throw new ArgumentNullException(nameof(code));
        }
        if (input == null)
        {
            throw new ArgumentNullException(nameof(input));
        }

        using (var inputStream = new MemoryStream(GetBytes(input)))
        using (var outputStream = new MemoryStream())
        {
            var data = new List<byte>() { 0 };
            var pointer = 0;

            for (int pc = 0; pc < code.Length; ++pc)
            {
                switch (code[pc])
                {
                    case '>':
                        if (++pointer == data.Count)
                        {
                            data.Add(0);
                        }
                        break;
                    case '<':
                        if (pointer == 0)
                        {
                            throw new InvalidOperationException("Can't decrement data pointer at start of data.");
                        }
                        --pointer;
                        break;
                    case '+':
                        ++data[pointer];
                        break;
                    case '-':
                        --data[pointer];
                        break;
                    case '.':
                        outputStream.WriteByte(data[pointer]);
                        break;
                    case ',':
                        data[pointer] = (byte)inputStream.ReadByte();
                        break;
                    case '[':
                        if (data[pointer] == 0 &amp;&amp; (pc = FindClosing(code, pc)) == -1)
                        {
                            throw new ArgumentException("Unmatched '['.", nameof(code));
                        }
                        break;
                    case ']':
                        if (data[pointer] != 0 &amp;&amp; (pc = FindOpening(code, pc)) == -1)
                        {
                            throw new ArgumentException("Unmatched ']'.", nameof(code));
                        }
                        break;
                    default:
                        throw new ArgumentException("Unknown instruction.", nameof(code));
                }
            }

            return GetString(outputStream.ToArray());
        }
    }

    private static byte[] GetBytes(string s)
    {
        return Array.ConvertAll(s.ToCharArray(), c => (byte)c);
    }

    private static string GetString(byte[] bytes)
    {
        return new string(Array.ConvertAll(bytes, b => (char)b));
    }

    private static int FindClosing(string s, int startIndex)
    {
        int level = 1;

        for (int index = startIndex + 1; index < s.Length; ++index)
        {
            switch (s[index])
            {
                case '[':
                    ++level;
                    break;
                case ']':
                    if (--level == 0)
                    {
                        return index;
                    }
                    break;
            }
        }

        return -1;
    }

    private static int FindOpening(string s, int startIndex)
    {
        int level = 1;

        for (int index = startIndex - 1; index >= 0; --index)
        {
            switch (s[index])
            {
                case ']':
                    ++level;
                    break;
                case '[':
                    if (--level == 0)
                    {
                        return index;
                    }
                    break;
            }
        }

        return -1;
    }
}
​

答案4:

using System.Collections.Generic;

public static class Kata {
  public static string BrainLuck(string code, string input) {
    var cells = new Dictionary<int, byte>() { {0,0} };
    var ptr = 0;
    var inputPtr = 0;
    var output = "";
    for (var i = 0; i < code.Length; i++) {
      switch (code[i]) {
        case '>': ptr++; break;
        case '<': ptr--; break;
        case '+': cells[ptr]++; break;
        case '-': cells[ptr]--; break;
        case '.': output += (char)cells[ptr]; break;
        case ',': cells[ptr] = (byte)input[inputPtr]; inputPtr++; break;
        case '[': if (cells[ptr] == 0) i = FindMatch(code, i); break;
        case ']': if (cells[ptr] != 0) i = FindMatch(code, i); break;
        default: break;
      }
      if (!cells.ContainsKey(ptr)) cells[ptr] = 0;
    }
    return output;
  }
  
  private static int FindMatch(string code, int index) {
    var start = code[index];
    var end = (start == '[') ? ']' : '[';
    var direction = (start == '[') ? 1 : -1;
    var depth = 0;
    for (var i = index + direction; i >= 0 &amp;&amp; i < code.Length; i += direction) {
      if (code[i] == start) {
        depth++;
      } else if (code[i] == end) {
        if (depth == 0) return i;
        depth--;
      }
    }
    return -1;
  }
}​

答案5:

using System.Collections.Generic;
public static class Kata
{
  public static string BrainLuck(string code, string input, string outp = "")
  {
    var data = new byte[32];
    for(int i = 0, inP = 0, p = 0; i < code.Length; i++)
    {
      if (code[i] == '>')  p++;
      if (code[i] == '<')  p--;
      if (code[i] == '+')  data[p]++;
      if (code[i] == '-')  data[p]--;
      if (code[i] == '.')  outp += (char)data[p];
      if (code[i] == ',')  data[p] = (byte)input[inP++];
      if (code[i] == '[' &amp; data[p] == 0) i = BMatch(code, i, -1, 1,']');
      if (code[i] == ']' &amp; data[p] != 0) i = BMatch(code, i, 1, -1, '[');
    }
    return outp;
  }
  
  private static int BMatch(string s, int i, int b, int dir, char pair)
  {
    if (s[i] == pair &amp;&amp; b == 0) return i; 
    if (s[i] == '[') b++;
    if (s[i] == ']') b--;
    return BMatch(s, i+dir, b, dir, pair);
  }
}​

答案6:

using System.Collections.Generic;
using System.Linq;

public static class Kata
{
  public static string BrainLuck(string code, string input)
  {
    var outp = new List<byte>();
    var data = new byte[9000];
    
    for(int i = 0, inP = 0, p = 0; i < code.Length; i++)
    {
      if (code[i] == '>')  p++;
      if (code[i] == '<')  p--;
      if (code[i] == '+')  data[p]++;
      if (code[i] == '-')  data[p]--;
      if (code[i] == '.')  outp.Add(data[p]);
      if (code[i] == ',')  data[p] = (byte)input[inP++];
      if (code[i] == '[' &amp; data[p] == 0) i = BMatch(code, i, -1, ']');
      if (code[i] == ']' &amp; data[p] != 0) i = BMatch(code, i,  1, '[');
    }
    return string.Concat(outp.Select(x => (char)x));
  }
  
  private static int BMatch(string s, int i, int d, char pair)
  {
    for (int b = d; (s[i] != pair || b != 0); i -= d)
    {
      if (s[i] == '[') b++;
      if (s[i] == ']') b--;
    }
    return i;
  }
}​

答案7:

using System;
using System.Collections.Generic;
using System.Linq;

public static class Kata {

    public static string BrainLuck(string code, string input) {
        Dictionary<int, int> brackets = new Dictionary<int, int>();
        Stack<int> starts = new Stack<int>();
        byte[] mem = new byte[256];
        string output = "";
        int ptr = 0, read = 0;

        for (int i = 0; i < code.Length; i++) {
            if (code[i] == '[') starts.Push(i);
            if (code[i] == ']') brackets.Add(starts.Pop(), i);
        }
        foreach (var item in brackets.ToArray()) brackets.Add(item.Value, item.Key);

        for (int ip = 0; ip < code.Length; ip++) {
            if (code[ip] == '[' &amp;&amp; mem[ptr] == 0 || code[ip] == ']' &amp;&amp; mem[ptr] != 0) ip = brackets[ip];
            if (code[ip] == '>' || code[ip] == '<') ptr += code[ip] == '>' ? 1 : -1;
            if (code[ip] == '+' || code[ip] == '-') mem[ptr] = (byte)(mem[ptr] + (code[ip] == '+' ? 1 : -1));
            if (code[ip] == ',') mem[ptr] = (byte)input[read++];
            if (code[ip] == '.') output += (char)mem[ptr];
        }

        return output;
    }

}​

答案8:

using System;
using System.Collections.Generic;
using System.Linq;

public class BrainFuckInterpreter
{
    string instructions;
    string inputStream;
    int pntr;
    List<int> mem = new List<int>() {0};
    string outputString = "";
    int instPointer;

    private Dictionary<char, Action> ops;

    public BrainFuckInterpreter(string program, string input)
    {
        instructions = program;
        inputStream = input;
        ops = new Dictionary<char, Action>()
        {
            { '>',this.incPntr},
            { '<',this.decPntr},
            { '+',this.incByte},
            { '-',this.decByte},
            { '.',this.output},
            { ',',this.input},
            { '[',this.jmpIfZero},
            { ']',this.jmpIfNonZero},
        };
    }

    public string Run()
    {
        char op;
        while (instPointer < instructions.Length)
        {
            op = instructions[instPointer];
            if (ops.ContainsKey(op))
                ops[op]();
            else
                instPointer++;
        }
        return outputString;
    }

    private void incPntr()
    {
        pntr++;
        if (pntr >= mem.Count)
        {
            mem.Add(0);
        }
        instPointer++;
    }

    private void decPntr()
    {
        pntr--;
        if (pntr < 0)
        {
            pntr = 0;
            mem.Insert(0,0);
        }
        instPointer++;
    }

    private void incByte()
    {
        mem[pntr] = (mem[pntr] + 1)%256;
        instPointer++;
    }

    private void decByte()
    {
        mem[pntr]--;
        if (mem[pntr] == -1)
        {
            mem[pntr] = 255;
        }
        instPointer++;
    }

    private void output()
    {
        outputString += (char)mem[pntr];
        instPointer++;
    }

    private void input()
    {
        mem[pntr] = inputStream[0];
        inputStream = inputStream.Substring(1);
        instPointer++;
    }

    private void jmpIfZero()
    {
        if (mem[pntr] != 0)
        {
            instPointer++;
            return;
        }

        var matches = 1;
        do
        {
            instPointer++;
            if (instructions[instPointer] == '[')
                matches++;
            if (instructions[instPointer] == ']')
                matches--;
        } while (matches != 0);

        instPointer++;
    }

    private void jmpIfNonZero()
    {
        if (mem[pntr] == 0)
        {
            instPointer++;
            return;
        }

        var matches = 1;
        do
        {
            instPointer--;
            if (instructions[instPointer] == '[')
                matches--;
            if (instructions[instPointer] == ']')
                matches++;
        } while (matches != 0);

        instPointer++;
    }
}

public static class Kata
  {
      public static string BrainLuck(string code, string input)
      {
         return new BrainFuckInterpreter(code,input).Run();
      }
  }​

答案9:

using System;
using System.Collections.Generic;

public static class Kata
    {
        class Data
    {
        List<short> d = new List<short>();
        public Data()
        {

        }
        public short get(int index)
        {
            if (index < d.Count) return d[index];
            else
            {
                d.AddRange(new short[index - d.Count + 1]);
                return 0;
            }
        }
        public void set(short val, int index)
        {
            if (index < d.Count) d[index] = val;
            else
            {
                d.AddRange(new short[index - d.Count + 1]);
                d[index] = val;
            }
        }
        public int len() { return d.Count; }
    }
    static int findMatchFwd(string code, int start)
    {
        int open = 1;
        for (int i = start + 1; i < code.Length; ++i)
        {
            if (code[i] == '[') open++;
            else if (code[i] == ']') open--;
            if (open == 0) return i;
        }
        return start + 1;
    }
    static int findMatchBwd(string code, int start)
    {
        int open = -1;
        for (int i = start - 1; i >= 0; --i)
        {
            if (code[i] == '[') open++;
            else if (code[i] == ']') open--;
            if (open == 0) return i;
        }
        return start + 1;
    }
    public static string BrainLuck(string code, string input)
    {
        int dataPtr = 0, instrPtr = 0, inputPtr = 0;
        Data d = new Data();
        string res = "";
        while (instrPtr < code.Length)
        {
            if (code[instrPtr] == ',')
            {
                if (inputPtr >= input.Length) break;
                d.set((short)input[inputPtr++], dataPtr);
                instrPtr++;
            }
            else if (code[instrPtr] == '.')
            {
                res += ((char)d.get(dataPtr)).ToString();
                instrPtr++;
            }
            else if (code[instrPtr] == '+')
            {
                short old = d.get(dataPtr);
                if (old == 255) old = 0;
                else old += 1;
                d.set(old, dataPtr);
                instrPtr++;
            }
            else if (code[instrPtr] == '-')
            {
                short old = d.get(dataPtr);
                if (old == 0) old = 255;
                else old -= 1;
                d.set(old, dataPtr);
                instrPtr++;
            }
            else if (code[instrPtr] == '>')
            {
                ++dataPtr;
                instrPtr++;
            }
            else if (code[instrPtr] == '<')
            {
                --dataPtr;
                instrPtr++;
            }
            else if (code[instrPtr] == '[')
            {
                short b = d.get(dataPtr);
                if (b != 0)
                    instrPtr++;
                else
                {
                    instrPtr = findMatchFwd(code, instrPtr) + 1;
                }
            }
            else if (code[instrPtr] == ']')
            {
                short b = d.get(dataPtr);
                if (b == 0)
                    instrPtr++;
                else
                {
                    instrPtr = findMatchBwd(code, instrPtr) + 1;
                }
            }
        }
        return res;
    }
    }​

答案10:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

public static class Kata
{
  public static string BrainLuck(string code, string input)
  {
    var output = new StringBuilder();
    
    var data = new List<byte>() { 0 };
    var dataPointer = 0;
    var inputPointer = 0;
    for(int i = 0;i < code.Length; ++i)
    {
      if(code[i] == '>')
      {
        ++dataPointer;
        if (dataPointer >= data.Count)
          data.Add(0);
      }
      else if(code[i] == '<')
      {
        --dataPointer;
      }
      else if(code[i] == '+')
      {
        ++data[dataPointer];
      }
      else if(code[i] == '-')
      {
        --data[dataPointer];
      }
      else if(code[i] == '.')
      {
        output.Append(Convert.ToChar(data[dataPointer]));
      }
      else if(code[i] == ',')
      {
        data[dataPointer] = Convert.ToByte(input[inputPointer++]);
      }
      else if(code[i] == '[')
      {
        if(data[dataPointer] == 0)
          i = FindMatchingClosingBracket(code, i);
      }
      else if(code[i] == ']')
      {
        if(data[dataPointer] != 0)
          i = FindMatchingOpeningBracket(code, i) - 1;
      }
    }
    return output.ToString();
  }
  
  private static int FindMatchingClosingBracket(string code, int start)
  {
    var openingBracketsCount = 0;
    for(int i = start + 1; i < code.Length; ++i)
    {
      if(code[i] == '[')
        ++openingBracketsCount;
      else if(code[i] == ']')
      {
        if(openingBracketsCount == 0)
          return i;
        else
          --openingBracketsCount;
      }
    }
    throw new Exception();
  }
  
  private static int FindMatchingOpeningBracket(string code, int start)
  {
    var closingBracketsCount = 0;
    for(int i = start - 1; i > -1; --i)
    {
      if(code[i] == ']')
        ++closingBracketsCount;
      else if(code[i] == '[')
      {
        if(closingBracketsCount == 0)
          return i;
        else
          --closingBracketsCount;
      }
    }
    throw new Exception();
  }
}​



goodview andyldm
关注
专栏目录
csharp高级练习题:我最小码解释器（又名Brainf ** K）【难度：3级】--景越C#经典编程题库,不同难度C#练习题，适合自学C#的新手进阶训练
景越c#经典编程题库(csharp programming training)
10-28 245
csharp高级练习题:我最小码解释器(又名Brainf ** K)【难度:3级】: 从现实世界的启发Brainf \ * \ * K,我们要创建的语言将支持以下指令(机器内存或者’的解释数据"应做字节的一个潜在的无限数组矩阵,初始化为0): *>递增数据指针(以点到下一个小区向右侧). *<递减数据指针(以点到下一个小区到左). *’+'增量(由一个增加,截断溢出:255 + 1 =...
bfInterpreter:用CC ++编写的Brainf * ck编程语言的解释器
03-13
Brainf * ck编程语言的解释器。 包括一些我编写的示例程序。 如果您想了解有关Brainf * ck的更多信息，请找到Wikipedia文章。 用法 （如果您使用的是Windows，则为MacOS和Linux：对不起） make ./main file [-d] ...
python最小解释器
01-23
python最小解释器，可以把py文件附加exe末尾，从而把py文件变成exe，可脱离python环境运行。 py文件附加到exe方法，执行下列dos命令： copy /b pyloader.exe+test.py test.exe
cpp-ParTcl一个最小的Tcl解释器
08-16
ParTcl - 一个最小的Tcl解释器
humo:最小的编程语言解释器
04-01
幽默语 Humo是一种编程语言，具有极小的解释器实现，并且对于命令式编程语言而言，其操作集最少。 这是一种实验性语言，它使用很少的概念来执行图灵完整的计算。 现场演示： 完整的解释器实现代码（以下代码执行任何Humo程序）： /* * Humo Language * Copyright (C) 2002-2010, Fernando Damian Petrola * * Distributable under GPL license. * See terms of license at gnu.org. */ package ar.net.fpetrola.humo ; import java.util.HashMap ; import java.util.Map ; public class HumoInterpreter { protected Map<
python最小解释器制作
haart的专栏
01-23 1596
平时经常用用到python脚本来实现一些小功能，可以通过pyinstaller之类的工具把py文件编译成exe程序，可是编译出来的程序动辄3mb以上，太大了很不爽。、、 我就想能不能把py编译成更小一点的exe。首先想到的是把py代码转换为c++代码，网上搜了很久也木有这样的工具。又一想，有没有python精简版之类的python库，又搜索很久没找到。 后来想到，自己编译python核心库，通...
一个小巧的lua解释器实现
09-01
一个小巧的lua解释器实现 全部代码 有注释
BrainF**k Devlopment Toolkit
最新发布
07-22
BrainF**k Devlopment Toolkit(BFDTK)，可用于开发BrainF**k程序。
BrainScript:用TypeScript编写的BrainF ***解释器
05-02
用TypeScript编写的 （BF）解释器和REPL。 安装 使用以下命令从安装 $ npm i brainscript 或在在线尝试 var lib = require ( "brainscript" ) lib . bf ( "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>...
Brainterpreter:简单的 Java BrainF*** 解释器
07-22
脑翻译 简单的 Java BrainF*** 解释器 ###项目状态：运行中。 需要一些清理、重构和记录 ###Purpose：Java 解决方案，满足您所有 BrainF*** 口译需求！ ＃＃＃特征： 基本 Java CLI 跨平台
hlang（一个小语言解释器）
02-22
一个自制小语言的解释器，纯c++11完成，内置测试文件，
C#版解释器
02-29
用C#写的解释器，大家可以看看，其中有些bug，希望大家帮着解决
for-fun-brainfuck：C＃的Brainfuck（esolang）实现
02-12
Brainfuck（esolang） Urban Muller在1993年创立了Brainfuck，其目的是设计一种语言，该语言可以用最小的编译器来实现，[2]受FALSE编程语言的1024字节编译器的启发。[3] 已经使一些精明的编译器小于200字节。 经典发行版是Muller的版本2，其中包含Amiga的编译器，解释器，示例程序和自述文件。 该语言由以下列出的八个命令组成。 Brainfuck程序是这些命令的序列，可能还散布着其他字符（被忽略）。 除非另有说明，否则命令将顺序执行。 指令指针从第一个命令开始，并且它所指向的每个命令都将被执行，然后通常前进到下一个命令。 当指令指针经过最后一条命令时，程序终止。 笨蛋语言使用一个简单的机器模型，该模型包括程序和指令指针，以及至少30,000个字节单元的数组，这些单元初始化为零。 可移动的数据指针（初始化为指向数组的最左字节）； 两个
BrainFuck语言解释器及一些demo
12-26
一个很小巧的BrainFuck语言解释器，内置很多小demo
Python学习笔记 - 做一个缩小版CPython解释器
weixin_50930712的博客
02-08 248
Python学习笔记 - 做一个缩小版CPython解释器 也不是我自己想做，主要是同学要我帮忙，他想学习Python，但是磁盘剩余空间太小，不够安装Python，就要我帮忙写一个小一点的。 要我写，就肯定要省略这样那样的，不过没关系（反正初学者应该够用了）。 直接上代码。 个人觉得用C语言的话可能编译出来的程序会比较小（反正我的Python环境已经超过1.2GB了，不知道是不是因为模块比较多的原因） 仅供Windows系统使用。 名称：pyey（Python Everywhere） #include "P
简单解释器
zev的博客
09-10 607
文章目录题目语法和语义循环绘图比例设置角度旋转坐标平移注释代码主函数功能函数头文件测试用例说明 题目 为函数绘图语言编写一个解释器，解释器接受用绘图语言编写的源程序，经语法和语义分析之后，将源程序所规定的图形显示在显示屏（或窗口）中。 语法和语义 循环绘图（FOR-DRAW） 比例设置（SCALE） 角度旋转（ROT） 坐标平移（ORIGIN） 注释 （-- 或 //） 循环绘图 ...
要理解解释器，做一个小解释器----小话c语言(20)
编程语言技巧经验分享
06-12 8449
作者：陈曦 日期：2012-6-12   11:31:12 环境：[Mac 10.7.1  Lion  Intel-based  x64  gcc4.2.1  xcode4.2]   转载请注明出处 Q： 解释器来源于什么？ A： 如果说是广义的解释器，那么可以把它理解成翻译器，只要能将一种被看成原始的东西翻译成需要的东西，处理的东西就可以被称为解释器。从编程语言角度，解释器更多
Brainfuck解释器（C#）
weixin_30270561的博客
11-16 447
根据维基百科上的内容随手写的一个BF解释器，输入有两个参数——程序代码、输入流，返回内容为输出流。输入、输出均为字符串。 字符 含义 C语言替换 > 指针加一 ++ptr; < 指针减一 --ptr; + 指针指向的字节的值加一 ++*ptr; ...
C#代码解释器
性别男、爱好女
04-24 2649
1、C#代码解释器简介 能够动态执行 C#代码是一件很酷的功能，比如，我们可以在控制台中输入一行 C#代码，然后程序自动编译并执行这一行代码，将结果显示给我们。这差不多就是一个最简单的 C#代码解释器了。 动态执行 C#代码又是一件很有用的功能，比如，我们可以将某些代码写在某个文件之中，由程序集在执行时进行加载，改变这些代码不用中止程序，当程序再次加载这些代码时，就自动执行的是新代码了
C语言学习资源大集合：考试、模拟与经典实例
10. 其他编程语言和工具：例如关于Brainf*ck语言的解释器（http://post.baidu.com/f?kz=15998145）和C51系列仿真实验器（http://post.baidu.com/f?kz=14332652），拓展了学习者的视野，了解不同领域的编程实践。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值