全探索

fn dfs(i: i32, sum: i32) -> bool {
   let k = 10;
   let n = 10;

   if (i == n) {
      return sum == k;
   }

   if (dfs(i + 1, sum)) {
      return true;
   }

   if (dfs(i + 1, sum + i)) {
      return true;
   }
   return false;
}


fn main() {
   if (dfs (0, 0)) {
      println!("yes");
   } else {
      println!("no");
   }
}

Ants POJ 1852

fn main() {
   let n = 10;
   let L = 100;
   let mut minT: i32 = 0;

   for i in 0..n {
      minT = std::cmp::max(minT, i.min(L - i));
   }

   let mut maxT: i32 = 0;
   for i in 0..n {
      maxT = std::cmp::max(minT, std::cmp::max(i, L - i));
   }

   println!("max:{}, min: {}", minT, maxT);

}

max:9, min: 91

三角形の周長

fn main() {

   let mut ans: i32 = 0;
   let n: i32 = 10;

   for i in 0..n {
      let j = i + 1;
      for j in j..n {
         let k = j + 1;
         for k in k..n {
            let len = i + j + k;
            let ma = std::cmp::max(i, std::cmp::max(j, k));
            let rest = len - ma;

            if (ma < rest) {
               ans = std::cmp::max(ans, len);
            }
         }
      }
   }
   println!("{}", ans);
}

Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.14s
Running `target/debug/basic`
24

【Blockchain】Avalancheのノードの稼働

$ wget -nd -m https://raw.githubusercontent.com/ava-labs/avalanche-docs/master/scripts/avalanchego-installer.sh;\
chmod 755 avalanchego-installer.sh;\
./avalanchego-installer.sh

$ ./avalanchego –network-id=local –staking-enabled=false –snow-sample-size=1 –snow-quorum-size=1 –http-host=0.0.0.0

【Blockchain】Cardanoのノードの稼働

### 依存パッケージのインストール
$ sudo apt update
$ sudo apt install -y libssl-dev build-essential m4 jq curl

MithrilクライアントはRustで開発されている

### Rustツールチェーンのインストール
$ curl –proto ‘=https’ –tlsv1.2 -sSf https://sh.rustup.rs | sh
$ source $HOME/.cargo/env
$ rustup install stable
$ rustup default stable
$ rustup update
$ rustup component add clippy rustfmt
$ rustup target add x86_64-unknown-linux-musl

Mithrilクライアントは、Cardanoノードのデータベースを迅速に同期するためのツール

$ git clone https://github.com/input-output-hk/mithril.git
$ cd mithril
$ ls
CHANGELOG.md NOTICE internal mithril-install.sh
CODE-OF-CONDUCT.md README.md mithril-aggregator mithril-relay
CONTRIBUTING.md SECURITY.md mithril-client mithril-signer
Cargo.lock demo mithril-client-cli mithril-stm
Cargo.toml docs mithril-client-wasm mithril-test-lab
DEV-ADR.md examples mithril-common networks.json
LICENSE flake.lock mithril-explorer openapi.yaml
Makefile flake.nix mithril-infra
$ git fetch –all –prune
$ git checkout tags/2403.1

$ cd mithril-client-cli
$ make build

$ ./mithril-client -V
$ sudo mv mithril-client /usr/local/bin/mithril-client

$ mithril-client cardano-db snapshot list
$ mithril-client cardano-db snapshot download –snapshot-id

【Blockchain】ethereumのlight nodeをサーバで動かしたい

### ubuntuにaptよりインストール
$ sudo add-apt-repository -y ppa:ethereum/ethereum
$ sudo apt update
$ sudo apt install -y geth

### light modeについて
$ geth –syncmode “light”
INFO [06-02|12:21:33.754] Starting Geth on Ethereum mainnet…
INFO [06-02|12:21:33.756] Bumping default cache on mainnet provided=1024 updated=4096
INFO [06-02|12:21:33.762] Maximum peer count ETH=50 total=50
INFO [06-02|12:21:33.767] Smartcard socket not found, disabling err=”stat /run/pcscd/pcscd.comm: no such file or directory”
WARN [06-02|12:21:33.773] Sanitizing cache to Go’s GC limits provided=4096 updated=654
Fatal: –syncmode: unknown sync mode “light”, want “full” or “snap”
lightクライアント機能は削除されている模様

### snap (軽量なフルノード)
数時間で同期可能
400GB以上が必要
$ geth –syncmode=snap

【Rust】プロセススケジュラー

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ProcessState {
    Ready,
    Running,
    Waiting,
    Terminated,
}

#[derive(Debug)]
struct Process {
    pid: usize,
    state: ProcessState,
}

struct Scheduler {
    processes: Vec<Process>,
    current_index: usize,
}

impl Scheduler {
    fn new(processes: Vec<Process>) -> Self {
        Scheduler {
            processes,
            current_index: 0,
        }
    }

    fn schedule(&mut self) -> Option<&Process> {
        if self.processes.is_empty() {
            return None;
        }

        let len = self.processes.len();
        for _ in 0..len {
            self.current_index = (self.current_index + 1) % len;
            let proc = &mut self.processes[self.current_index];
            if proc.state == ProcessState::Ready {
                proc.state = ProcessState::Running;
                return Some(proc);
            }
        }
        None
    }

    fn update_state(&mut self, pid: usize, new_state: ProcessState) {
        if let Some(proc) = self.processes.iter_mut().find(|p| p.pid == pid) {
            proc.state = new_state;
        }
    }
}


fn main(){
    
    let mut scheduler = Scheduler::new(vec![
        Process { pid: 1, state: ProcessState::Ready},
        Process { pid: 2, state: ProcessState::Ready},
        Process { pid: 3, state: ProcessState::Waiting},
    ]);

    for _ in 0..5 {
        if let Some(proc) = scheduler.schedule() {
            println!("Running process: {:?}", proc.pid);
            scheduler.update_state(proc.pid, ProcessState::Ready);
        } else {
            println!("No Runnable processes.");
            break;
        }
    }
}

【Rust】メモリ管理

const FRAME_SIZE: usize = 4096;
const TOTAL_MEMORY: usize = 1024 * 1024 * 128;
const TOTAL_FRAMES: usize = TOTAL_MEMORY / FRAME_SIZE;

static mut FRAME_BITMAP: [bool; TOTAL_FRAMES] = [false; TOTAL_FRAMES];

pub struct FrameAllocator;

impl FrameAllocator {
    pub fn alloc() -> Option<usize> {
        unsafe {
            for (i, used) in FRAME_BITMAP.iter_mut() enumerate() {
                if !*used {
                    *used = true;
                    return Some(i * FRAME_SIZE);
                }
            }
            None
        }
    }

    pub fn dealloc(addr: usize) {
        let index = addr / FRAME_SIZE;
        if index < TOTAL_FRAMES {
            unsafe {
                FRAME_BITMAP[index] = false;
            }
        }
    }
}

【Rust】バイナリデータへの処理

### 文字列の変換

fn main() {
    let text = "Hello, Rust!";
    let binary = text.as_bytes();

    println!("binary: {:?}", binary);
}

binary: [72, 101, 108, 108, 111, 44, 32, 82, 117, 115, 116, 33]

### テキストファイルの変換
input.txt

Hello Rust!
This is sample

use std::fs::File;
use std::io::{self, Read, Write};

fn main() -> io::Result<()>{
    let mut input_file = File::open("./data/input.txt")?;

    let mut buffer = Vec::new();
    input_file.read_to_end(&mut buffer)?;

    println!("binary: {:?}", &buffer);

    Ok(())
}

### データのchunk

fn main(){
    
    let data = vec![0u8; 10000];

    let chunk_size = 1024;

    for(i, chunk) in data.chunks(chunk_size).enumerate() {
        println!("チャンク {}: サイズ = {}", i, chunk.len());
    }
}

チャンク 0: サイズ = 1024
チャンク 1: サイズ = 1024
チャンク 2: サイズ = 1024
チャンク 3: サイズ = 1024
チャンク 4: サイズ = 1024
チャンク 5: サイズ = 1024
チャンク 6: サイズ = 1024
チャンク 7: サイズ = 1024
チャンク 8: サイズ = 1024
チャンク 9: サイズ = 784

### 画像データのchunk

use std::fs::File;
use std::io::{self, Read, Write};

fn main()-> io::Result<()>{
    
    let mut input_file = File::open("./data/test.jpg")?;

    let mut buffer = Vec::new();
    input_file.read_to_end(&mut buffer)?;

    let chunk_size = 1024;

    for(i, chunk) in buffer.chunks(chunk_size).enumerate() {
        println!("チャンク {}: 値 = {:?}", i, chunk);
    }

    Ok(())
}

Rustでmalloc, free

use std::alloc::{alloc, dealloc, Layout};
use std::ptr;

fn main() {
    unsafe {
        let layout = Layout::new::<i32>();
        let ptr = alloc(layout) as *mut i32;

        if ptr.is_null() {
            panic!("メモリ確保に失敗しました");
        }

        *ptr = 42;
        println!("ptrが指す値: {}", *ptr);

        dealloc(ptr as *mut u8, layout);
    }
}

Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.83s
Running `target/debug/memory`
ptrが指す値: 42