随机应变 ABCD: Always Be Coding and … : хороший
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
$ 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
### 依存パッケージのインストール
$ 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
### 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
#[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;
}
}
}
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;
}
}
}
}
### 文字列の変換
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(())
}
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
import os
from cryptography.fernet import Fernet
from reedsolo import RSCodec
CHUNK_SIZE = 32
DATA_SEGMENTS = 4
TOTAL_SEGMENTS = 8
rsc = RSCodec(TOTAL_SEGMENTS - DATA_SEGMENTS)
key = Fernet.generate_key()
cipher = Fernet(key)
original_data = b"StorjTestData1234567890!ThisIsAChunkTestFile!!"
print(f"元データ: {original_data}")
encrypted_data = cipher.encrypt(original_data)
print(f"暗号化データ: {encrypted_data}")
chunks = [encrypted_data[i:i+CHUNK_SIZE] for i in range(0, len(encrypted_data), CHUNK_SIZE)]
def encode_chunk(chunk):
encoded = rsc.encode(chunk)
seg_size = len(encoded) // TOTAL_SEGMENTS
return [encoded[i:i+seg_size] for i in range(0, len(encoded), seg_size)]
distributed_chunks = []
for chunk in chunks:
segments = encode_chunk(chunk)
distributed_chunks.append(segments)
for i, chunk_segs in enumerate(distributed_chunks):
print(f"\n チャンク{i+1}:")
for j, seg in enumerate(chunk_segs):
print(f" ノード{j}: {seg}")
def recover_chunk(pieces):
combined = b''.join(pieces)
return rsc.decode(combined)
recovered_encrypted = b''
for chunk_segs in distributed_chunks:
selected_pieces = chunk_segs[:DATA_SEGMENTS]
recovered = recover_chunk(selected_pieces)
recovered_encrypted += recovered
decrypted_data = cipher.decrypt(recoved_encrypted)
print(f"\n復元された平文: {decrypted_data}")
$ python3 storj.py
元データ: b’StorjTestData1234567890!ThisIsAChunkTestFile!!’
暗号化データ: b’gAAAAABoLw7a8YpRJbYfA1bt6JOd9Rn28BVtmziV9-qXo9pWs41Or5LN8J0J3UKgAB7uTmpXjkHgTiEv_Dn4ajnfJATxU4lkoOS8xI67SmVeORdvPm6O6OEqGYBXfhQAGaBEtun2jHOw’
チャンク1:
ノード0: bytearray(b’gAAA’)
ノード1: bytearray(b’AABo’)
ノード2: bytearray(b’Lw7a’)
ノード3: bytearray(b’8YpR’)
ノード4: bytearray(b’JbYf’)
ノード5: bytearray(b’A1bt’)
ノード6: bytearray(b’6JOd’)
ノード7: bytearray(b’9Rn2′)
ノード8: bytearray(b”3\’\xf8\xd8″)
チャンク2:
ノード0: bytearray(b’8BVt’)
ノード1: bytearray(b’mziV’)
ノード2: bytearray(b’9-qX’)
ノード3: bytearray(b’o9pW’)
ノード4: bytearray(b’s41O’)
ノード5: bytearray(b’r5LN’)
ノード6: bytearray(b’8J0J’)
ノード7: bytearray(b’3UKg’)
ノード8: bytearray(b’\x1b\xe3=\xc7′)
チャンク3:
ノード0: bytearray(b’AB7u’)
ノード1: bytearray(b’TmpX’)
ノード2: bytearray(b’jkHg’)
ノード3: bytearray(b’TiEv’)
ノード4: bytearray(b’_Dn4′)
ノード5: bytearray(b’ajnf’)
ノード6: bytearray(b’JATx’)
ノード7: bytearray(b’U4lk’)
ノード8: bytearray(b’t\x915\xa3′)
チャンク4:
ノード0: bytearray(b’oOS8′)
ノード1: bytearray(b’xI67′)
ノード2: bytearray(b’SmVe’)
ノード3: bytearray(b’ORdv’)
ノード4: bytearray(b’Pm6O’)
ノード5: bytearray(b’6OEq’)
ノード6: bytearray(b’GYBX’)
ノード7: bytearray(b’fhQA’)
ノード8: bytearray(b’e\x02al’)
チャンク5:
ノード0: bytearray(b’Ga’)
ノード1: bytearray(b’BE’)
ノード2: bytearray(b’tu’)
ノード3: bytearray(b’n2′)
ノード4: bytearray(b’jH’)
ノード5: bytearray(b’Ow’)
ノード6: bytearray(b’\x00\xea’)
ノード7: bytearray(b’\x8b\x07′)