RandyMcMillan

use sha2::{Digest, Sha256};

/// Calculates the Hamming distance between two SHA-256 hashes.
///
/// This function takes two byte slices representing SHA-256 hashes and returns 
/// the number of bits that differ between them.
fn hamming_distance_sha256(hash1: &[u8], hash2: &[u8]) -> u32 {
    assert_eq!(hash1.len(), 32, "Invalid hash1 length");
    assert_eq!(hash2.len(), 32, "Invalid hash2 length");

RandyMcMillan

use sha2::{Digest, Sha256};

/// Calculates the Hamming distance between two SHA-256 hashes.
///
/// This function takes two byte slices representing SHA-256 hashes and returns 
/// the number of bits that differ between them.
fn hamming_distance_sha256(hash1: &[u8], hash2: &[u8]) -> u32 {
    assert_eq!(hash1.len(), 32, "Invalid hash1 length");
    assert_eq!(hash2.len(), 32, "Invalid hash2 length");

RandyMcMillan

use sha2::{Digest, Sha256};

/// Calculates the Hamming distance between two SHA-256 hashes.
///
/// This function takes two byte slices representing SHA-256 hashes and returns 
/// the number of bits that differ between them.
fn hamming_distance_sha256(hash1: &[u8], hash2: &[u8]) -> u32 {
    assert_eq!(hash1.len(), 32, "Invalid hash1 length");
    assert_eq!(hash2.len(), 32, "Invalid hash2 length");

RandyMcMillan

use actix_web::{get, web, App, HttpResponse, HttpServer, Responder};
use bitcoincore_rpc::{Auth, Client, RpcApi};
use serde_json::Value;

struct AppState {
    btc_client: Client,
}

#[get("/blocktemplate")]
async fn get_block_template(data: web::Data<AppState>) -> impl Responder {

RandyMcMillan

use sha2::{Digest, Sha256};

/// Calculates the Hamming distance between two SHA-256 hashes.
///
/// This function takes two byte slices representing SHA-256 hashes and returns 
/// the number of bits that differ between them.
fn hamming_distance_sha256(hash1: &[u8], hash2: &[u8]) -> u32 {
    assert_eq!(hash1.len(), 32, "Invalid hash1 length");
    assert_eq!(hash2.len(), 32, "Invalid hash2 length");

RandyMcMillan

use sha2::{Digest, Sha256};

/// Calculates the Hamming distance between two SHA-256 hashes.
///
/// This function takes two byte slices representing SHA-256 hashes and returns 
/// the number of bits that differ between them.
fn hamming_distance_sha256(hash1: &[u8], hash2: &[u8]) -> u32 {
    assert_eq!(hash1.len(), 32, "Invalid hash1 length");
    assert_eq!(hash2.len(), 32, "Invalid hash2 length");

RandyMcMillan

use std::any::Any;
use std::fmt::Debug;

fn print_type_name<T: Any + Debug>(value: &T) {
    println!("Type of {:?} is: {}", value, std::any::type_name::<T>());
}

fn main() {
    let i: i32 = 42;
    print_type_name(&i);

RandyMcMillan

use std::fs;
use std::path::Path;

fn main() {
    let input = "/usr/share/doc";

    fn action(path: &str) { println!("\t{}" , path); }

    fn walk(path: &str) {
        println!("Listing {} ..." , path);

RandyMcMillan

use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};

#[derive(Debug, Clone)]
struct HashMap<K, V>
where
    K: Eq + Hash + Clone,
    V: Clone,
{
    // Buckets for storing key-value pairs

RandyMcMillan

fn gamma(n: f64) -> f64 {
    // For simplicity, we'll use a basic approximation method.
    // For higher accuracy, consider using a more sophisticated algorithm or a crate 
    // like `special_function` (if it provides Gamma).

    // We can use integration techniques like the trapezoidal rule or Simpson's rule for approximation.
    // Here's a basic trapezoidal rule example:

    let mut result = 0.0;
    let a = 0.0;