paiza.ioでelixir その197

# 概要
paiza.ioでelixirやってみた。
練習問題やってみた。

# 練習問題
俺cpuをアセンブルを実行する、インタープリタでfizzbuzzを実行せよ。

# サンプルコード

```
defmodule Va do
	use Agent
	def start_link() do
		Agent.start_link(fn ->
			0
		end, name: __MODULE__)
	end
	def get() do
		Agent.get(__MODULE__, fn v ->
			v
		end)
	end
	def set(x) do
		Agent.update(__MODULE__, fn v ->
			x
		end)
	end
end
defmodule Src do
	use Agent
	def start_link() do
		Agent.start_link(fn -> 
            ""
		end, name: __MODULE__)
	end
	def set(x) do
		Agent.update(__MODULE__, fn v ->
	        x
		end)
	end
	def get() do
		Agent.get(__MODULE__, fn v ->
			v
		end)
	end
	def getn(n) do
		Agent.get(__MODULE__, fn v ->
	    	Enum.at(String.split(v, "\n", trim: true), n - 1)
	    end)
    end
    def getl("end") do
        0
    end
	def getl(a) do
		Agent.get(__MODULE__, fn v ->
            Enum.reduce(String.split(v, "\n", trim: true), 1, fn l, n ->
	    	    if String.starts_with?(l, a) do
	    	        Va.set(n)
	    	    end
	    	    n = n + 1
	        end)
	        Va.get
	    end)
    end
end
defmodule Sim do
    def val(s) do
        if String.starts_with?(s, "'") do
            String.at(s, 1)
            |> String.to_charlist
            |> List.first
        else
            String.to_integer(s)
        end
    end
	def start_link do
		Agent.start_link(fn ->
			[a: 0, b: 0, c: 0, pc: 1, stack: [], g: ""]
		end, name: __MODULE__)
	end
	def push(s) do
		Agent.update(__MODULE__, fn v ->
    	    n = val(s)
		    stack = v[:stack]
			stack = Enum.concat(stack, [n])
			v = List.keyreplace(v, :stack, 0, {:stack, stack})
			pc = v[:pc] + 1
			List.keyreplace(v, :pc, 0, {:pc, pc})
		end)
	end
    def set(d) do
		Agent.update(__MODULE__, fn v ->
		    stack = v[:stack]
		    po = Enum.count(stack) - 1
			top = Enum.at(stack, po)
		    stack = Enum.drop(stack, -1) 
			v = List.keyreplace(v, :stack, 0, {:stack, stack})
			v = List.keyreplace(v, :a, 0, {:a, top})
			pc = v[:pc] + 1
			List.keyreplace(v, :pc, 0, {:pc, pc})
		end)
    end
    def get(d) do
		Agent.update(__MODULE__, fn v ->
		    a = v[:a]
		    stack = v[:stack]
		    stack = Enum.concat(stack, [a])
			v = List.keyreplace(v, :stack, 0, {:stack, stack})
			pc = v[:pc] + 1
			List.keyreplace(v, :pc, 0, {:pc, pc})
		end)
    end
    def gt() do
		Agent.update(__MODULE__, fn v ->
		    stack = v[:stack]
			po = Enum.count(stack) - 1
			top = Enum.at(stack, po)
			tmp = Enum.with_index(stack)
			po = po - 1
			stack = Enum.map(tmp, fn {val, ind} ->
				cond do
				ind == po ->
					val > top
				true ->
					val
				end
			end)
			stack = Enum.drop(stack, -1)
			v = List.keyreplace(v, :stack, 0, {:stack, stack})
			pc = v[:pc] + 1
			List.keyreplace(v, :pc, 0, {:pc, pc})
		end)
    end
    def eq() do
		Agent.update(__MODULE__, fn v ->
		    stack = v[:stack]
			po = Enum.count(stack) - 1
			top = Enum.at(stack, po)
			tmp = Enum.with_index(stack)
			po = po - 1
			stack = Enum.map(tmp, fn {val, ind} ->
				cond do
				ind == po ->
					val == top
				true ->
					val
				end
			end)
			stack = Enum.drop(stack, -1)
			v = List.keyreplace(v, :stack, 0, {:stack, stack})
			pc = v[:pc] + 1
			List.keyreplace(v, :pc, 0, {:pc, pc})
		end)
    end
    def if_(t) do
		Agent.update(__MODULE__, fn v ->
		    stack = v[:stack]
		    po = Enum.count(stack) - 1
			top = Enum.at(stack, po)
		    stack = Enum.drop(stack, -1) 
			v = List.keyreplace(v, :stack, 0, {:stack, stack})
			if top do
			    pc = Src.getl(t)
	    		List.keyreplace(v, :pc, 0, {:pc, pc})
			else
			    pc = v[:pc] + 1
	    		List.keyreplace(v, :pc, 0, {:pc, pc})
			end
		end)
    end
    def jmp(t) do
		Agent.update(__MODULE__, fn v ->
		    pc = Src.getl(t)
    		List.keyreplace(v, :pc, 0, {:pc, pc})
		end)
	end
    def out3() do
		Agent.update(__MODULE__, fn v ->
		    stack = v[:stack]
		    g = v[:g]
		    po = Enum.count(stack) - 1
			top = Enum.at(stack, po)
		    o = Integer.floor_div(top, 100)
		    g = g <> to_string(o)
            v = List.keyreplace(v, :g, 0, {:g, g})
		    pc = v[:pc] + 1
		    List.keyreplace(v, :pc, 0, {:pc, pc})
		end)
    end
	def out2() do
		Agent.update(__MODULE__, fn v ->
		    stack = v[:stack]
		    g = v[:g]
		    po = Enum.count(stack) - 1
			top = Enum.at(stack, po)
			o = rem(top, 100)
		    o = Integer.floor_div(o, 10)
		    g = g <> to_string(o)
            v = List.keyreplace(v, :g, 0, {:g, g})
		    pc = v[:pc] + 1
		    List.keyreplace(v, :pc, 0, {:pc, pc})
		end)
    end
    def out1() do
		Agent.update(__MODULE__, fn v ->
		    stack = v[:stack]
		    g = v[:g]
		    po = Enum.count(stack) - 1
			top = Enum.at(stack, po)
		    o = rem(top, 10)
		    g = g <> to_string(o)
            v = List.keyreplace(v, :g, 0, {:g, g})
		    pc = v[:pc] + 1
		    List.keyreplace(v, :pc, 0, {:pc, pc})
		end)
    end
    def drop() do
		Agent.update(__MODULE__, fn v ->
		    stack = v[:stack]
		    stack = Enum.drop(stack, -1) 
			v = List.keyreplace(v, :stack, 0, {:stack, stack})
		    pc = v[:pc] + 1
		    List.keyreplace(v, :pc, 0, {:pc, pc})
		end)
    end
    def out() do
		Agent.update(__MODULE__, fn v ->
		    stack = v[:stack]
		    g = v[:g]
		    po = Enum.count(stack) - 1
			top = Enum.at(stack, po)
		    g = g <> <<top ::utf8>>
            v = List.keyreplace(v, :g, 0, {:g, g})
		    stack = Enum.drop(stack, -1) 
			v = List.keyreplace(v, :stack, 0, {:stack, stack})
		    pc = v[:pc] + 1
		    List.keyreplace(v, :pc, 0, {:pc, pc})
		end)
    end
    def add() do
		Agent.update(__MODULE__, fn v ->
		    stack = v[:stack]
			po = Enum.count(stack) - 1
			top = Enum.at(stack, po)
			tmp = Enum.with_index(stack)
			po = po - 1
			stack = Enum.map(tmp, fn {val, ind} ->
				cond do
				ind == po ->
					val + top
				true ->
					val
				end
			end)
			stack = Enum.drop(stack, -1)
			v = List.keyreplace(v, :stack, 0, {:stack, stack})
			pc = v[:pc] + 1
			List.keyreplace(v, :pc, 0, {:pc, pc})
		end)
    end
    def rem() do
		Agent.update(__MODULE__, fn v ->
		    stack = v[:stack]
			po = Enum.count(stack) - 1
			top = Enum.at(stack, po)
			tmp = Enum.with_index(stack)
			po = po - 1
			stack = Enum.map(tmp, fn {val, ind} ->
				cond do
				ind == po ->
					rem(val, top)
				true ->
					val
				end
			end)
			stack = Enum.drop(stack, -1)
			v = List.keyreplace(v, :stack, 0, {:stack, stack})
			pc = v[:pc] + 1
			List.keyreplace(v, :pc, 0, {:pc, pc})
		end)
    end
	def print() do
		Agent.get(__MODULE__, fn v ->
            g = v[:g]
            IO.puts g
        end)
    end
	def pc() do
		Agent.get(__MODULE__, fn v ->
            v[:pc]
        end)
    end
    def test() do
		Agent.get(__MODULE__, fn v ->
            v
        end)
    end
end

defmodule Main do
    def run(0) do
        Sim.print()
    end
    def run(pc) do
        m = Src.getn(pc)
        #IO.puts(m)
        s = String.split(m, "  ")
        cond do
	    Enum.at(s, 1) == "set" ->
    	    Sim.set(Enum.at(s, 2))
	    Enum.at(s, 1) == "get" ->
	   	    Sim.get(Enum.at(s, 2))
	    Enum.at(s, 1) == ">" ->
		    Sim.gt()
	    Enum.at(s, 1) == "=" ->
		    Sim.eq()
	    Enum.at(s, 1) == "if" ->
		    Sim.if_(Enum.at(s, 2))
	    Enum.at(s, 1) == "out3" ->
		    Sim.out3()
	    Enum.at(s, 1) == "out2" ->
		    Sim.out2()
	    Enum.at(s, 1) == "out1" ->
		    Sim.out1()
	    Enum.at(s, 1) == "drop" ->
		    Sim.drop()
	    Enum.at(s, 1) == "out" ->
		    Sim.out()
	    Enum.at(s, 1) == "+" ->
		    Sim.add()
	    Enum.at(s, 1) == "%" ->
		    Sim.rem()
   	    Enum.at(s, 1) == "jmp" ->
		    Sim.jmp(Enum.at(s, 2))
	    true ->
		    Sim.push(Enum.at(s, 1))
	    end
	    #IO.inspect Sim.test
        run(Sim.pc)
	end
	def start(str) do
	    Src.set(str)
	    run(1)
	end
end
Va.start_link
Sim.start_link
Src.start_link

str = """
  0
  set  a
loop  get  a
  1
  +
  set  a
  get  a
  15
  %
  0
  =
  if  skip2  
  get  a
  5
  %
  0
  =
  if  skip1
  get  a
  3
  %
  0
  =
  if  skip0
  get  a
  out3
  out2
  out1
  drop
  jmp  skip3
skip0  'F'
  out
  'i'
  out
  'z'
  out
  'z'
  out
  jmp  skip3
skip1  'B'
  out
  'u'
  out
  'z'
  out
  'z'
  out
  jmp  skip3
skip2  'F'
  out
  'i'
  out
  'z'
  out
  'z'
  out
  jmp  skip1
skip3  ' '
  out
  100
  get  a
  >
  if  loop
  jmp  end
"""
Main.start(str)


```

# 実行結果

```
001 002 Fizz 004 Buzz Fizz 007 008 Fizz Buzz 011 Fizz 013 014 FizzBuzz 016 017 Fizz 019 Buzz Fizz 022 023 Fizz Buzz 026 Fizz 028 029 FizzBuzz 031 032 Fizz 034 Buzz Fizz 037 038 Fizz Buzz 041 Fizz 043 044 FizzBuzz 046 047 Fizz 049 Buzz Fizz 052 053 Fizz Buzz 056 Fizz 058 059 FizzBuzz 061 062 Fizz 064 Buzz Fizz 067 068 Fizz Buzz 071 Fizz 073 074 FizzBuzz 076 077 Fizz 079 Buzz Fizz 082 083 Fizz Buzz 086 Fizz 088 089 FizzBuzz 091 092 Fizz 094 Buzz Fizz 097 098 Fizz Buzz 
```

# 成果物

https://paiza.io/projects/XKqGfOaeqERx2awJx_eUTQ?language=elixir


以上。