famubu
/
playground
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

various old stuff

This commit is contained in:
Julin S 2023-04-26 22:32:37 +05:30
parent 8f44ce9775
commit c800042ddb
26 changed files with 877 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
haskell/README.org Normal file
View File

@ -0,0 +1,3 @@
#+TITLE: Haskell
- [[./state-monad.hs][state-monad.hs]]: Demo of state monad using postfix expression evaluator

70
haskell/state-monad.hs Normal file
View File

@ -0,0 +1,70 @@
-- | Demo of state monad
import Data.Char
import GHC.Float
import Control.Monad.State
-- | Process next input character
chrToOp
:: (Num a, Fractional a)
=> Char -- ^ Character denoting an operation
-> (a -> a -> a) -- ^ Function corresponding to the operation
chrToOp ch =
case ch of
'+' -> (+)
'-' -> (-)
'*' -> (*)
'/' -> (/)
-- | Process next input character
process_inp
:: Char -- ^ Next input character
-> [Float] -- ^ Current state of stack
-> [Float] -- ^ New state of stack
process_inp ch st
| isDigit ch = [int2Float $ digitToInt ch] ++ st
| elem ch "+-*/" = [(chrToOp ch) (st!!1) (st!!0)] ++ (tail (tail st))
| otherwise = st
postfixeval
:: String -- ^ Input string
-> State [Float] Float
postfixeval [] = do
st <- get
return $ head st
postfixeval (x:xs) = do
st <- get
let newst = process_inp x st
put newst
postfixeval xs
-- main = print $ fst $ runState (postfixeval "32+") []
main = do
putStrLn "Enter the postfix expression:"
inp <- getLine
print $ fst $ runState (postfixeval inp) []
{-
λ> fst $ runState (postfixeval "32+2*6-2/") []
2.0
λ> fst $ runState (postfixeval "32+") []
-}
{-
Enter the postfix expression:
32+
5.0
Enter the postfix expression:
32+2*6-2/
2.0
-}

7
misc/README.org Normal file
View File

@ -0,0 +1,7 @@
#+TITLE: Misc
ACL2 proof assistant:
- hello-acl2.lisp
Maude model cheker:
- my-nat.maude

6
misc/hello-acl2.lisp Normal file
View File

@ -0,0 +1,6 @@
(defun mem (e x)
(if (consp x)
(if (equal e (car list))
t
(mem e (cdr x))
nil)))

19
misc/my-nat.maude Normal file
View File

@ -0,0 +1,19 @@
--- From maude docs
--- This is a comment.
*** This is a comment too.
fmod SIMPLE-NAT is
sort Nat .
op zero : -> Nat .
op s_ : Nat -> Nat .
op _+_ : Nat Nat -> Nat .
--- variables
vars N M : Nat .
--- rewrite rules
eq zero + N = N .
eq s N + M = s (N + M) .
endfm

11
python/binary.py Normal file
View File

@ -0,0 +1,11 @@
def tobin(n : int) -> "List[int]":
rv = []
while n>0:
rv.append(n%2)
n//=2
return rv
for i in range(17):
rv = tobin(i)
rv.reverse()
print(rv)

38
python/cracklepop/cracklepop.py Normal file
View File

@ -0,0 +1,38 @@
"""
CracklePop!
A program that prints out the numbers 1 to 100 (inclusive).
If the number is divisible by 3, print Crackle instead of the number.
If it's divisible by 5, print Pop.
If it's divisible by both 3 and 5, print CracklePop.
"""
def get_msg(num: int) -> str:
"""
Find message to be printed for the number.
Return "Crackle", "Pop" and "CracklePop" if num is divisible by 3, 5
and 15 respectively, otherwise return empty string.
"""
msg = ""
if num % 3 == 0:
msg += "Crackle"
if num % 5 == 0:
msg += "Pop"
return msg
def cracklepop(limit: int) -> None:
"""
Print CracklePop for numbers from 1 to limit (inclusive)
"""
for num in range(1, limit+1):
msg = get_msg(num)
if msg:
print(msg)
else:
print(num)
if __name__ == "__main__":
cracklepop(100)

35
python/cracklepop/test_crackle_pop.py Normal file
View File

@ -0,0 +1,35 @@
import pytest
import cracklepop
@pytest.mark.parametrize("num, expected", [
(51, "Crackle"), # divisible by 3
(65, "Pop"), # divisible by 5
(75, "CracklePop"), # divisible by both 3 and 5
(82, "") # not divisible by 3, 5 and 15
])
def test_get_msg(num, expected):
assert cracklepop.get_msg(num) == expected
def test_cracklepop(capsys):
limit = 15
expected = """1
2
Crackle
4
Pop
Crackle
7
8
Crackle
Pop
11
Crackle
13
14
CracklePop
"""
cracklepop.cracklepop(limit)
assert capsys.readouterr().out == expected

45
python/interests.py Normal file
View File

@ -0,0 +1,45 @@
"""
Functions to find simple and compound interests.
"""
def comp_interest(principal: float,
rate: float,
comp_freq: int,
duration: float) -> float:
"""
principal: principal amount
rate: Rate interest as float (100% is 100)
duration: Duration in years
comp_freq: Number of compounding periods in a year
interest = principal*((1 + rate/100)**n) - principal
"""
rate /= 100 * comp_freq
rv = (1 + rate) ** (comp_freq * duration)
rv = principal * rv
rv -= principal
return rv
def simp_interest(principal: float,
rate: float,
duration: float) -> float:
"""
principal: principal amount
rate: Rate interest as float (100% is 100)
duration: Duration in years
comp_freq: Number of compounding periods in a year
interest = principal * duration * rate
"""
return principal * duration * rate/100
#import pytest
#
#@pytest.mark.parametrize("principal,rate,comp_freq,duration,expected", [
# (12000, 10, 2, 1.5, 1891.5),
# (1000, 20, 1, 2, 440.0),
#])
#def test_comp_interest(principal, rate, comp_freq, duration, expected):
# rv = comp_interest(principal, rate, comp_freq, duration)
# assert round(rv, 5) == expected

48
python/lucas.py Normal file
View File

@ -0,0 +1,48 @@
def aCb(a: int, b: int) -> int:
abin = [int(x) for x in bin(a)[2:]]
bbin = [int(x) for x in bin(b)[2:]]
alen = len(abin)
blen = len(bbin)
maxlen = max(alen, blen)
abin = [0] * (maxlen - alen) + abi, safe=""n
bbin = [0] * (maxlen - blen) + bbin
acc = 1
for x,y in zip(abin, bbin):
if x==0 and y==1:
return 0
return 1
def oneline(level: int) -> "List[Int]":
"""
level starts from 0.
"""
return [aCb(level,j) for j in range(level+1)]
def pascal(n: int):
for i in range(n):
print(" "*(n-i), end="")
l = oneline(i)
for x in l:
print(f" {x}", end="")
print()
pascal(50)
"""
1
1 1
1 0 1
1 1 1 1
1 0 0 0 1
1 1 0 0 1 1
1 0 1 0 1 0 1
1 1 1 1 1 1 1 1
1 0 0 0 0 0 0 0 1
1 1 0 0 0 0 0 0 1 1
1 0 1 0 0 0 0 0 1 0 1
1 1 1 1 0 0 0 0 1 1 1 1
1 0 0 0 1 0 0 0 1 0 0 0 1
1 1 0 0 1 1 0 0 1 1 0 0 1 1
1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
"""

18
python/pyconau2020/README.md Normal file
View File

@ -0,0 +1,18 @@
# Rube Codeberg entry
Made as an entry for the 'Rube Codeberg' competition conducted as part of the
11th PyCon Australia ([PyConline AU 2020](https://2020.pycon.org.au/program/sun/#rube-codeberg-competition).
The name of the contest is named after [Rube Goldberg machines](https://en.wikipedia.org/wiki/Rube_Goldberg_machine), which are in turn named after the American cartoonist [Rube Goldberg](https://en.wikipedia.org/wiki/Rube_Goldberg).
## Objective
The aim of the contest was to make a 'hello world' program in Python in as complicated
a way as possible.
## Cool entries
There were lot of cool entries for the competition (but I forgot which among them were the winning entries).
I couldn't dig all of them up but did manage to find this one:
- [By James Constable](https://github.com/jamesconstable/rube-codeberg)

104
python/pyconau2020/helloworld.py Normal file
View File

@ -0,0 +1,104 @@
"""
Prints "Hello world" using html pulled from a copy of the Pyconline program
page for Sunday. Uses beautiful soup.
BeautifulSoup is imported dynamically.
Requires internet to work.
Does the following:
- Get html of web page containing guidelines for Rube Codeberg with urllib.
- Open the source code of this program, to get the name of a module to
be imported (beautiful soup)
- Import BeautifulSoup dynamically using importlib
(thanks to Shivashis' talk)
- Parse the message to be printed using beautiful soup.
- Construct AST for a print function call with ast module.
(thanks to Katie's talk)
- Convert ast to code object which is then executed.
"""
from typing import List, Tuple
import ast
import importlib
import urllib.request
# from bs4 import BeautifulSoup # imported dynamically
URL = "https://2020.pycon.org.au/program/sun/"
def get_html(url: str) -> str:
"""Extract html from a url"""
with urllib.request.urlopen(url) as response:
bytestr = response.read()
return bytestr.decode('utf-8')
return None
def get_bs_name_from_src() -> List[str]:
"""
Extract the words 'beautiful' and 'soup' from this file and
return them as a list.
"""
with open(__file__) as fsrc:
lines = fsrc.readlines()
third_line_items = lines[2].split()[-2:] # ['beautiful', 'soup']
third_line_items[-1] = third_line_items[-1].replace('.', '')
return third_line_items
def get_bs_class():
"""Import bs4 dynamically and return BeautifulSoup class"""
name_list = get_bs_name_from_src()
mod_name = ''.join(word[0] for word in name_list) + "4"
class_name = ''.join(word.capitalize() for word in name_list)
bs4 = importlib.import_module(mod_name)
return getattr(bs4, class_name)
def get_fn_and_msg(html_str: str) -> Tuple[str, str]:
"""
Generate function name and extract message from the html string.
Use the first list item in the unordered list of rules in the page.
ie,
```
Print "Hello world!" on the screen (somehow - we don't care how
- doesn't have to be the console) as a result of being executed
```
"""
BeautifulSoup = get_bs_class()
soup = BeautifulSoup(html_str, "html.parser")
msg = soup.main.find_all("ul", limit=2)[-1].li.strong.string
fn_name, msg = msg.split(' ', maxsplit=1)
fn_name = fn_name.lower() # Print -> print
msg = msg.replace('"', ' ').strip() # "Hello world!" -> Hello world!
return fn_name, msg
def get_code(fn_name_str: str, msg: str):
"""
Generate AST for
>>> fn_name_str(msg) # print("Hello world!")
and return it as code object
"""
fn_name = ast.Name(id=fn_name_str, ctx=ast.Load())
fn_args = ast.Str(s=msg)
fn_call = ast.Call(func=fn_name, args=[fn_args], keywords=[])
expr = ast.Expr(value=fn_call)
module = ast.Module(body=[expr], type_ignores=[])
ast.fix_missing_locations(module)
return compile(module, '<ast>', 'exec')
if __name__ == "__main__":
html_text = get_html(f"http://web.archive.org/web/20200905141404/{URL}")
func_name, message = get_fn_and_msg(html_text)
code = get_code(func_name, message)
exec(code)

7
python/pyconau2020/others_incomplete.md Normal file
View File

@ -0,0 +1,7 @@
- [https://github.com/ewenmcneill/rube-codeberg-fsm](https://github.com/ewenmcneill/rube-codeberg-fsm)
- https://gist.github.com/r1chardj0n3s/f7cae394a1e6c759c9898fee8d7dc0b2
- https://github.com/wolfric83/pyconlineAU2020-RubeCodeberg
- https://gist.github.com/dwurf/95cdfdf5cd4d1890c8526cea2423cfeb

1
python/tictactoe/README.md Normal file
View File

@ -0,0 +1 @@
A simple tic tac toe game.

75
python/tictactoe/test_ttt.py Normal file
View File

@ -0,0 +1,75 @@
import textwrap
import pytest
import ttt
@pytest.fixture
def game():
return ttt.TicTacToe(players=[("User", 'O'), ("PC", 'X')])
@pytest.mark.parametrize('grid,expected', [
(['O', None, 'X',
'X', 'O', None,
None, None, 'O'], 1),
(['O', None, 'X',
'X', 'O', None,
None, None, 'X'], 0),
(['O', 'X', 'X',
'X', 'O', 'O',
'O', 'X', 'X'], -1),
])
def test_is_over(game, grid, expected):
game.grid = grid
game._empty = sum([1 for x in grid if x is None])
assert game._is_over() == expected
class TestNextTurn:
@pytest.mark.parametrize('grid, cell_idx, expected', [
(['O', 'X', 'X',
'X', None, 'O',
'O', 'X', 'X'], 4, -1),
([None, 'X', 'X',
'X', None, 'O',
'O', 'X', 'X'], 0, 0),
(['O', 'X', 'X',
'X', None, 'O',
'O', 'X', 'O'], 4, 1),
])
def test_valid(self, game, grid, cell_idx, expected):
game.grid = grid
game._empty = sum([1 for x in grid if x is None])
assert game.next_turn(cell_idx) == expected
@pytest.mark.parametrize('grid, cell_idx', [
(['O', 'X', 'X',
'X', None, 'O',
'O', 'X', 'X'], 1),
(['O', 'X', 'X',
'X', None, 'O',
'O', 'X', 'X'], 11),
])
def test_invalid(self, game, grid, cell_idx):
game.grid = grid
game._empty = sum([1 for x in grid if x is None])
with pytest.raises(ValueError):
game.next_turn(cell_idx)
def test_display(capsys):
grid = [None, 'X', 'X',
'X', None, 'O',
'O', 'X', 'X']
grid_str = """
| X | X
-----------
X | | O
-----------
O | X | X"""
grid_str = textwrap.dedent(grid_str).strip('\n')
ttt.display(grid)
captured = capsys.readouterr()
assert captured.out.strip('\n') == grid_str.strip('\n')

144
python/tictactoe/ttt.py Normal file
View File

@ -0,0 +1,144 @@
"""
Simple TicTacToe game
Needs Python>=3.6
"""
from typing import List, Tuple
class TicTacToe:
"""
Represents a game of tic-tac-toe.
"""
# Possbile winning configurations
_WINNING_POS = [
[0, 1, 2], # top horizontal
[3, 4, 5], # middle horizontal
[6, 7, 8], # bottom horizontal
[0, 3, 6], # left vertical
[1, 4, 7], # middle vertical
[2, 5, 8], # right vertical
[0, 4, 8], # main diagonal
[2, 4, 6] # anti-diagonal
]
def __init__(self, players: List[Tuple[str, str]]):
"""
TicTacToe grid is represented with the grid attribute as a list of
9 elements.
Empty cell have None value.
players: a list of exactly two elements where each element is a tuple
of two strings: player name and player symbol
The first player in this list will get the first turn.
Player symbols must be strings of length 1.
turn: index in the players list corresponding to the details of the
player who should play next.
Raises ValueError on invalid player info.
"""
if len(players) != 2:
raise ValueError(f"Exactly 2 players needed. Got {len(players)}")
# Check if player details are valid
for player_info in players:
count = len(player_info)
if count != 2:
raise ValueError(f"player tuple has 2 values. Got {count}")
symbol = player_info[1]
if len(symbol) != 1:
raise ValueError(f"{symbol}: player symbol is a single char")
# Assign attributes
self.players = players
self.grid = [None for _ in range(9)]
self.turn = 0
self._empty = 9 # Number of empty cells
def _is_over(self) -> int:
"""
Helper function for next_turn() that determines a game over condition.
Returns 0 if game is not over, 1 if game is over with a winner
and -1 if there is a tie.
"""
symbol = self.players[self.turn][1]
for win_pos in self._WINNING_POS:
if all([self.grid[pos] == symbol for pos in win_pos]):
return 1 # a player won
if self._empty == 0:
return -1 # a tie
return 0
def next_turn(self, cell_idx: str) -> int:
"""
Represents one turn in the game.
Accepts the index of chosen cell as a string.
Indexing starts from 0.
Returns 0 if game is not over, 1 if game is over with a winner
and -1 if there is a tie.
Raises ValueError if cell index is invalid.
"""
cell = int(cell_idx)
if cell < 0 or cell > 8:
raise ValueError(f"{cell}: Invalid cell index")
if self.grid[cell] is not None:
raise ValueError("Cell already taken!")
# Assign current player's symbol to cell
self.grid[cell] = self.players[self.turn][1]
self._empty -= 1
status = self._is_over()
if status == 0:
self.turn = 1 if self.turn == 0 else 0
elif status < 0:
self.turn = None
return status
def display(grid: List[int]) -> None:
"""Displays the grid"""
for row_num in range(3):
row = grid[row_num * 3: (row_num * 3) + 3]
row = [elem if elem is not None else ' ' for elem in row]
row_str = " " + ' | '.join(row)
print(row_str)
if row_num < 2:
print('-' * (len(row_str)+1))
def play(game: TicTacToe) -> None:
"""Event loop of the game"""
display(game.grid)
cell = input(f"{game.players[game.turn][0]}'s turn. Choose a cell: ")
while True:
try:
status = game.next_turn(cell)
except ValueError as verr:
print(verr)
else:
if status != 0:
break
display(game.grid)
cell = input(f"{game.players[game.turn][0]}'s turn. Choose a cell: ")
if game.turn is None:
print("Game tied...")
else:
print(f"{game.players[game.turn][0]} won!")
if __name__ == "__main__":
ttt = TicTacToe(players=[("User", 'O'), ("PC", 'X')])
play(ttt)

7
risc-v/README.md Normal file
View File

@ -0,0 +1,7 @@
#+TITLE: RISC-V
#+LINK: l1 https://github.com/TheThirdOne/rars
Run with [[l1][RARS]].
- [[./loop.asm][loop.asm]]: A loop
- [[./factorial.asm][factorial.asm]]: Factorial of a number

29
risc-v/factorial.asm Normal file
View File

@ -0,0 +1,29 @@
# long long int fact (long long int n) {
# if (n < 1) {
# return f;
# } else {
# return n * fact(n - 1);
# }
# }
.global main
.data
.text
fact:
bgt x10, x0, recurse # non-base case: n > 0
addi x10, x0, 1 # return 1
recurse:
addi x2, x2, -16 # expand stack (x2 is SP)
sw x10, 8(x2) # save n to stack
sw x1, 0(x2) # save return address to stack
addi x5, x10, -1 # calculate (n - 1)
add x10, x5, x0 # set up (n-1) as argument to next function call
jal x1, fact # recursive function call
lw x1, 0(x2) # retrieve original return address
lw x5, 8(x2) # retrieve original n
mul x10, x5, x10 # set up return value as (n * fact(n-1))
# mul available only in RV64M mulitply extension
over:
jalr x0, 0(x1) # return from fact() to caller function

25
risc-v/loop.asm Normal file
View File

@ -0,0 +1,25 @@
# for(i=0; i<100; ++i) {
# a[i] = b[i] + c;
# }
.global main
.data
.text
main:
addi x6, x0, 100
addi x5, x0, 10
sw x5, 0(x6)
addi x5, x5, 1
sw x5, 8(x6)
begin:
addi x5, x0, 80
add x6, x0, x0
loop: add x8, x28, x6
add x7, x29, x6
lw x7, 0(x7)
add x7, x7, x30
sw x7, 0(x8)
addi x6, x6, 8
bne x6, x5, loop

3
rust/README.org Normal file
View File

@ -0,0 +1,3 @@
#+TITLE: Rust
- [[./traits.rs][traits.rs]]: Traits in rust

1
rust/aoc2019/README.md Normal file
View File

@ -0,0 +1 @@
Just an attempt at AOC2019 with rust.

42
rust/aoc2019/d01p1.rs Normal file
View File

@ -0,0 +1,42 @@
/* https://adventofcode.com/2019/day/1 (part 1)*/
fn main() {
// 100 elements
let arr: [i32; 100] = [
95249, 126697, 77237, 80994, 91186, 53823, 115101, 130919, 88127,
141736, 53882, 67432, 94292, 73223, 139947, 66450, 55710, 128647,
73874, 57163, 139502, 140285, 119987, 125308, 77561, 74573, 85364,
92991, 102935, 71259, 99622, 118876, 124482, 148442, 77664, 90453,
111933, 110449, 74172, 148641, 58574, 135365, 84703, 81077, 65290,
136749, 127256, 94872, 143534, 81702, 59493, 72365, 69497, 149082,
79552, 78509, 73759, 147439, 97535, 118952, 114301, 104401, 95080,
100907, 132914, 136096, 52451, 70544, 120717, 107010, 76840, 51324,
135258, 73985, 118067, 86602, 95127, 51182, 84838, 60430, 86347,
140487, 147777, 85143, 114215, 100410, 126504, 69630, 123656, 108886,
144192, 123620, 147217, 146090, 101966, 80577, 62193, 143331, 79947,
93518
];
let mut fuel: i32 = 0;
for i in 0..100 {
fuel += arr[i] / 3 - 2;
}
println!("{}", fuel);
}
/*
# Equivalent Python program
arr = [95249, 126697, ...
..., 143331, 79947,
93518]
fuel = 0
for mass in arr:
fuel += mass // 3 - 2
print(fuel)
*/

36
rust/aoc2019/d01p2.rs Normal file
View File

@ -0,0 +1,36 @@
/* https://adventofcode.com/2019/day/1 (part 2)*/
fn recurse(mass: i32) -> i32 {
let fuel: i32 = mass / 3 - 2;
if fuel < 0 {
return 0
}
fuel + recurse(fuel)
}
fn main() {
// 100 elements
let arr: [i32; 100] = [
95249, 126697, 77237, 80994, 91186, 53823, 115101, 130919, 88127,
141736, 53882, 67432, 94292, 73223, 139947, 66450, 55710, 128647,
73874, 57163, 139502, 140285, 119987, 125308, 77561, 74573, 85364,
92991, 102935, 71259, 99622, 118876, 124482, 148442, 77664, 90453,
111933, 110449, 74172, 148641, 58574, 135365, 84703, 81077, 65290,
136749, 127256, 94872, 143534, 81702, 59493, 72365, 69497, 149082,
79552, 78509, 73759, 147439, 97535, 118952, 114301, 104401, 95080,
100907, 132914, 136096, 52451, 70544, 120717, 107010, 76840, 51324,
135258, 73985, 118067, 86602, 95127, 51182, 84838, 60430, 86347,
140487, 147777, 85143, 114215, 100410, 126504, 69630, 123656, 108886,
144192, 123620, 147217, 146090, 101966, 80577, 62193, 143331, 79947,
93518
];
let mut fuel: i32 = 0;
for i in 0..100 {
fuel += recurse(arr[i]);
}
println!("{}", fuel);
}

46
rust/aoc2019/d02p1.rs Normal file
View File

@ -0,0 +1,46 @@
/* https://adventofcode.com/2019/day/2 (part 1) */
fn main() {
let mut list = vec![
1, 12, 2, 3, 1, 1, 2, 3, 1, 3, 4, 3, 1, 5, 0, 3, 2, 1, 9, 19, 1, 10, 19,
23, 2, 9, 23, 27, 1, 6, 27, 31, 2, 31, 9, 35, 1, 5, 35, 39, 1, 10, 39,
43, 1, 10, 43, 47, 2, 13, 47, 51, 1, 10, 51, 55, 2, 55, 10, 59, 1, 9,
59, 63, 2, 6, 63, 67, 1, 5, 67, 71, 1, 71, 5, 75, 1, 5, 75, 79, 2, 79,
13, 83, 1, 83, 5, 87, 2, 6, 87, 91, 1, 5, 91, 95, 1, 95, 9, 99, 1, 99,
6, 103, 1, 103, 13, 107, 1, 107, 5, 111, 2, 111, 13, 115, 1, 115, 6,
119, 1, 6, 119, 123, 2, 123, 13, 127, 1, 10, 127, 131, 1, 131, 2, 135,
1, 135, 5, 0, 99, 2, 14, 0, 0
];
for i in (0..list.len()).step_by(4) {
if list[i] == 1 {
// addition
let r = list[i+3];
list[r] = list[list[i+1]] + list[list[i+2]];
} else if list[i] == 2 {
// multiplication
let r = list[i+3];
list[r] = list[list[i+1]] * list[list[i+2]];
} else if list[i] == 99 {
break;
}
}
println!("{}", list[0]);
}
/*
# Equivalent Python program
arr = [1, 12, 2, 3, ...
...
1, 135, 5, 0, 99, 2, 14, 0, 0]
for i in range(0, len(arr), 4):
if arr[i] == 1:
arr[arr[i+3]] = arr[arr[i+1]] + arr[arr[i+2]]
elif arr[i] == 2:
arr[arr[i+3]] = arr[arr[i+1]] * arr[arr[i+2]]
elif arr[i] == 99:
break
print(arr[0])
*/

30
rust/aoc2019/d02p2.rs Normal file
View File

@ -0,0 +1,30 @@
/* https://adventofcode.com/2019/day/2 (part 2)*/
fn main() {
let mut list = vec![
1, 71, 95, 3, 1, 1, 2, 3, 1, 3, 4, 3, 1, 5, 0, 3, 2, 1, 9, 19, 1, 10, 19,
23, 2, 9, 23, 27, 1, 6, 27, 31, 2, 31, 9, 35, 1, 5, 35, 39, 1, 10, 39,
43, 1, 10, 43, 47, 2, 13, 47, 51, 1, 10, 51, 55, 2, 55, 10, 59, 1, 9,
59, 63, 2, 6, 63, 67, 1, 5, 67, 71, 1, 71, 5, 75, 1, 5, 75, 79, 2, 79,
13, 83, 1, 83, 5, 87, 2, 6, 87, 91, 1, 5, 91, 95, 1, 95, 9, 99, 1, 99,
6, 103, 1, 103, 13, 107, 1, 107, 5, 111, 2, 111, 13, 115, 1, 115, 6,
119, 1, 6, 119, 123, 2, 123, 13, 127, 1, 10, 127, 131, 1, 131, 2, 135,
1, 135, 5, 0, 99, 2, 14, 0, 0
];
//let bckup = list.clone();
for i in (0..list.len()).step_by(4) {
if list[i] == 1 {
// addition
let r = list[i+3];
list[r] = list[list[i+1]] + list[list[i+2]];
} else if list[i] == 2 {
// multiplication
let r = list[i+3];
list[r] = list[list[i+1]] * list[list[i+2]];
} else if list[i] == 99 {
break;
}
}
println!("{}", 100 * list[1] + list[2]);
}

27
rust/traits.rs Normal file
View File

@ -0,0 +1,27 @@
trait HelloTrait {
fn hello(&self, s:String) -> String;
}
struct HelloStruct {
name: String
}
// Implementation of the trait for the struct
impl HelloTrait for HelloStruct {
fn hello(&self, s:String) -> String {
let x = format!("Hello {}, {}!", s, self.name);
x
}
}
fn main() {
let example = HelloStruct { name: String::from("John") };
println!("{}", example.hello(String::from("there")));
}
/*
Output:
:!./traits
Hello there, John!
*/