Rust コード例

// helloJP.rs
//rustc helloJP.rs

use std::io;

 fn main()
 {
    // 世界よ、こんにちは
    println!("こんにちは, 世界!");
    
    // 標準入力を待機
    println!("");
    let mut 入力 = String::new();
    println!("Enter で画面を閉じます...");
    io::stdin().read_line(&mut 入力).unwrap();
}

[package]
name = "Hello_World"
version = "0.1.0"
edition = "2024"

[dependencies]
crossterm = "0.29.0"

// Hello, world! と表示された後、プログラムが終了せずに待機します。
// キーを何か1つ押すと、即座にそのキーのコードが表示され、プログラムが終了します。
// 仕組み: crossterm::event::read() は、通常Enterが必要なターミナルの挙動を回避し、
// キーが押された瞬間にイベントを取得します。

//use crossterm::event::{self, Event, KeyCode};
use crossterm::event::{self, Event};
use std::io::{self, Write};

fn main() -> io::Result<()> {
    // Hello World を表示
    println!("Hello, world!");
    println!("何かキー操作で画面を閉じます...");
    io::stdout().flush()?;

    // キー入力を待機（Enter不要）
    loop {
        // イベントが発生したかチェック
        if event::poll(std::time::Duration::from_millis(100))? {
            // イベントを読み込む
            if let Event::Key(key_event) = event::read()? {
                println!("Pressed: {:?}", key_event.code);
                break; // 何かキーが押されたらループを抜ける
            }
        }
    }

    Ok(())
}

// TimeGeminiJP.rs
// rustc TimeGeminiJP.rs
// Gemini に教えてもらいました

use std::thread; // スレッド（sleepなど）を使うためのモジュール
use std::time;   // 時間（Duration, Instant）を使うためのモジュール
use std::io;     // 入出力関連のトレイト、標準入出力など

fn main() {
    // 今の時刻（計測開始地点）を取得
    let 開始時刻 = time::Instant::now();

    // 【動作確認用】3秒間スリープする（ご自身のコードに合わせて変更してください）
    let スリープ時間 = time::Duration::from_secs(3);
    thread::sleep(スリープ時間);

    // 最初の時刻からの経過時間を取得（Duration型）
    let 経過時間 = 開始時刻.elapsed();

    // 経過時間の「合計秒数」を取得
    let 合計秒数 = 経過時間.as_secs();

    // 合計秒数から「時間・分・秒」を算数で計算する
    let 時間 = 合計秒数 / 3600;          // 3600秒で割ると「時間」
    let 分 = (合計秒数 % 3600) / 60;     // 時間の余りを60で割ると「分」
    let 秒 = 合計秒数 % 60;              // さらにその余りが「秒」

    // 表示用の文字列を作る（可変なString型）
    let mut 出力 = String::new();

    // 「時間」が0より大きければ表示に追加
    if 時間 > 0 {
        出力.push_str(&format!("{}時間", 時間));
    }
    // 「分」が0より大きければ表示に追加
    if 分 > 0 {
        出力.push_str(&format!("{}分", 分));
    }
    // 「秒」が0より大きければ表示に追加
    if 秒 > 0 {
        出力.push_str(&format!("{}秒", 秒));
    }
    // もし全部0だった場合（1秒未満）は「0秒」と表示するなどの対策
    if 出力.is_empty() {
        出力.push_str("0秒");
    }
    // 最終的な結果を表示
    println!("経過時間: {}", 出力);

    // 標準入力を待機
    println!("");
    let mut 入力 = String::new();
    println!("Enter で画面を閉じます...");
    io::stdin().read_line(&mut 入力).unwrap();
}

// 素因数分解
// rustc factorization3JP.rs

use std::{time, io};
//use std::io;

fn 素因数分解(n: u128) {

    // 今の時刻を取得
    let 開始時刻 = time::Instant::now();
    println!("{}",n);
    
    fn 素因数分解サブ(n: u128, m: u128) -> (u128, u128) {
        let mut c = 0;
        let mut x = n;
        while x % m == 0 {
            c += 1;
            x /= m;
        }
        (c, x)
    }

    let (c, n) = 素因数分解サブ(n, 2);
    if c > 0 { print!("({},{})", 2, c); }
    let mut x = 3;
    let mut m = n;
    while x * x <= m {
        let (c, n) = 素因数分解サブ(m, x);
        if c > 0 { print!("({},{})", x, c); }
        m = n;
        x += 2;
    }
    if m > 1 { print!("({},{})", m, 1); }
    
    println!("");
    // 最初の時刻からの経過時間を表示
    println!("{:?}", 開始時刻.elapsed());
    println!("");
}

fn main() {

    素因数分解(24);
    素因数分解(12345678);
    素因数分解(123456789);
    素因数分解(1234567890);
    素因数分解(1111111111);
    素因数分解(8635844967113809);
    素因数分解(121439531096594251777);
    println!("次は10日間かかります！");
    println!("待てないならウインドウ右上の×で終了してください。");
    素因数分解(717985416201895737890248682491);  //10日6時間 886851/(60*60*24)=10.264479166667
    
    // 標準入力を待機
    println!("");
    let mut 入力 = String::new();
    println!("Enter で画面を閉じます...");
    io::stdin().read_line(&mut 入力).unwrap();
}

[package]
name = "PrimeFactorization"
version = "0.1.0"
edition = "2021"

[dependencies]
prime_factorization = "1.0.5"

// PrimeFactorization
// Gemini に教えてもらいました
// https://crates.io/crates/prime_factorization
// https://docs.rs/prime_factorization/latest/prime_factorization/
// 最大128ビット整数までの素因数分解ライブラリ。
//因数分解アルゴリズムは、最初の 1000 個の素数による試し割り、フェルマーの因数分解法、
//そして須山の媒介変数化を用いた射影座標を用いたレンストラの楕円曲線因数分解から構成されます。
//フェルマーの因数分解法の後、楕円曲線因数分解のステップに進む前に、
//その数が素数である可能性を、数の大きさに応じて
//ミラー・ラビン法または強いベイリー-PSW 素数判定法のいずれかを用いて判定します。
//後者の判定法は、ここで使用されている数値範囲 (128 ビットまで) では決定論的ではありませんが、
//既知の反例は存在しません。

//Miller-Rabin素数判定とBaillie-PSW素数判定は確率的な判定ですが、
//このプログラムが使用する数値範囲では反例が存在しません。
//楕円曲線因数分解では、曲線上のランダムな初期点を使用するため、
//実行時間に多少のばらつきが生じる可能性があります。

use std::time;                  // 時間（Duration, Instant）を使うため
use std::io;                    // 入力のためのインポート
use prime_factorization::Factorization;
use std::collections::BTreeMap; // 追加：個数を数えるためのマップ
use std::io::{Write};           // 出力のためのインポート

fn main() {
    
    // 1. 素因数分解したい数（半素数）を定義
    //            = 103,979 * 36,028,797,018,963,913
    // 半素数（semiprime）とは、２つの素数の積で表される自然数
    let num: u128 = 3_746_238_285_234_848_709_827;
    
    // 2. 素因数分解を実行
    let factor_repr = Factorization::run(num);

    // 3. 取得した素因数のリストを表示
    // {:?} はデバッグ表示用のフォーマットです
    println!("元の数: {}", num);
    println!("素因数分解の結果: {:?}", factor_repr.factors);

    // 4. 正解と一致するかチェック
    assert_eq!(factor_repr.factors, vec![103_979, 36_028_797_018_963_913]);
    println!("検証に成功しました！");
    println!("");
    
    
    // 1. 素因数分解したい数を定義
    let num: u128 = 717_985_416_201_895_737_890_248_682_491;
    
    // 2. 素因数分解を実行
    let factor_repr = Factorization::run(num);

    // 3. 取得した素因数のリストを表示
    // {:?} はデバッグ表示用のフォーマットです
    println!("元の数: {}", num);
    println!("素因数分解の結果: {:?}", factor_repr.factors);
    println!("期待する結果　　：7 * 59 * 1738463477486430358087769207");
    println!("");

    // ---------------------------------------
    //ユーザーが入力した数字を素因数分解するインタラクティブなプログラム
    println!("--- 素因数分解ツール (u128 対応、数学形式表示) ---");
    println!("最大38桁の整数まで入力できます。大きな素数の積は時間がかかります。");
    println!("10が18回と1 ： 1010101010101010101010101010101010101 何日もかかります(^^ゞ");
    println!("終了するには 'q' を入力するか、Ctrl+C を押してください。");

    loop {
        // 1. プロンプト（入力待ちの合図）を表示
        print!("\n分解したい数字を入力してください: ");
        io::stdout().flush().unwrap(); // 表示を確定させる（Windowsで必要になることが多い

        // 2. ユーザーの入力を読み取る
        let mut input = String::new();
        io::stdin()
             .read_line(&mut input)
             .expect("入力の読み取りに失敗しました");

        // 今の時刻（計測開始地点）を取得
        let 開始時刻 = time::Instant::now();

        // 3. 終了判定
        let input = input.trim(); // 改行コードを取り除く
        if input == "q" {
            println!("終了します。");
            break;
        }

        // 4. 文字列を数値（u128）に変換
        match input.parse::<u128>() {
            Ok(num) => {
                // 素因数分解を実行
                let factor_repr = Factorization::run(num);
                
                // --- ここから数学形式への変換ロジック ---
                // 1. 各素因数の個数を集計 (例: [3, 3, 5] -> {3: 2, 5: 1})
                let mut counts = BTreeMap::new();
                for &f in &factor_repr.factors {
                    *counts.entry(f).or_insert(0) += 1;
                }
                // 2. 表示用の文字列に整形
                let result_parts: Vec<String> = counts
                    .iter()
                    .map(|(&base, &exp)| {
                        if exp > 1 {
                            format!("{}^{}", base, exp) // 指数形式
                        } else {
                            base.to_string()           // そのまま
                        }
                    })
                    .collect();
                // 3. " * " でつなげて表示
                println!("{} = {}", num, result_parts.join(" * "));
                // ---------------------------------------
                // 4. 検算  ---
                // factor_repr.factors は、例えば `12` を入力した場合、 [2, 2, 3] のような素因数のデータが入っています。
                // 「.iter().product()」 を使うと、リストの中身を全て掛け算してくれます。
                // `.iter()` でデータを順番に取り出し、`.product()` でそれらを全て掛け合わせます。
                // 手動で `for` ループを書いて掛け算する必要がなく、Rust らしいスマートな書き方です。
                let calculated_product: u128 = factor_repr.factors.iter().product();
                
                println!("---------------------------------------");
                println!("検算(Verification):");
                println!("  素因数リスト: {:?}", factor_repr.factors); // 素のリストを表示
                // `{:?}` を使うことで、ベクタ（リスト）の中身をデバッグ形式（`[2, 2, 3]` のような形）で
                // そのまま表示させています。実際にどの数字が掛け合わされたのかが視覚的にわかります。

                println!("  再計算結果  : {}", calculated_product);     // 掛け合わせた結果

                if num == calculated_product {
                    println!("  判定        : OK (元の数値と一致しました)");
                } else {
                    println!("  判定        : NG (不一致)");
                }
                println!("---------------------------------------");
            }
            Err(_) => println!("有効な正の整数を入力してください。"),
        }
        // 最初の時刻からの経過時間を取得（Duration型）
        let 経過時間 = 開始時刻.elapsed();

        // 経過時間の「合計秒数」を取得
        let 合計秒数 = 経過時間.as_secs();

        // 合計秒数から「時間・分・秒」を算数で計算する
        let 時間 = 合計秒数 / 3600;          // 3600秒で割ると「時間」
        let 分 = (合計秒数 % 3600) / 60;     // 時間の余りを60で割ると「分」
        let 秒 = 合計秒数 % 60;              // さらにその余りが「秒」

        // 表示用の文字列を作る（可変なString型）
        let mut 出力 = String::new();

        // 「時間」が0より大きければ表示に追加
        if 時間 > 0 {
            出力.push_str(&format!("{}時間", 時間));
        }
        // 「分」が0より大きければ表示に追加
        if 分 > 0 {
            出力.push_str(&format!("{}分", 分));
        }
        // 「秒」が0より大きければ表示に追加
        if 秒 > 0 {
            出力.push_str(&format!("{}秒", 秒));
        }
        // もし全部0だった場合（1秒未満）は「0秒」と表示するなどの対策
        if 出力.is_empty() {
            出力.push_str("0秒");
        }
        // 最終的な結果を表示
        println!("経過時間: {}", 出力);
    }
    
    // 標準入力を待機
    println!("");
    let mut 入力 = String::new();
    println!("Enter で画面を閉じます...");
    io::stdin().read_line(&mut 入力).unwrap();
}

// Gemini pro に教えてもらいました
// 整数型の最小値、最大値を表示します
// MinMax2JP.rs
// rustc MinMax2JP.rs

use std::io;
use std::fmt::Display;

/// 整数を3桁ごとのカンマ区切り文字列に変換するジェネリック関数
fn カンマ区切り文字列に<T>(n: T) -> String
where
    T: Display + PartialOrd + From<u8> + Copy
{
    let s = n.to_string();
    let mut 結果 = String::new();

    // 負の数かどうかを判定（0より小さいか）
    let 負の数か = n < T::from(0);
    // 数字部分のみを取り出す（マイナス記号を除去）
    let 数字部分 = if 負の数か { &s[1..] } else { &s };

    for (i, c) in 数字部分.chars().rev().enumerate() {
        if i > 0 && i % 3 == 0 {
            結果.push(',');
        }
        結果.push(c);
    }
    if 負の数か {
        結果.push('-');
    }
    結果.chars().rev().collect()
}

fn main() {
    // i128 も u128 も同じ関数でOK！
    println!("i128 min: {}", カンマ区切り文字列に(i128::MIN));
    println!("i128 max:  {}", カンマ区切り文字列に(i128::MAX));
    println!("u128 max:  {}", カンマ区切り文字列に(u128::MAX));
    // ついでに他の型でも動きます
    println!("i32  min: {}", カンマ区切り文字列に(-1234567i32));

    // 標準入力を待機
    println!("");
    let mut 入力 = String::new();
    println!("Enter で画面を閉じます...");
    io::stdin().read_line(&mut 入力).unwrap();
}

// Gemini pro に教えてもらいました
//rustc SaveUTF16.rs

use std::fs::File;
use std::io::{BufWriter, Write};
use std::io;

fn main() -> std::io::Result<()> {            // <- Resultを返すと宣言しています
    let content = "こんにちは、世界！\n標準ライブラリだけで UTF-16 で保存！";
    let file_path = "output_std_utf16.txt";

    let file = File::create(file_path)?;
    let mut writer = BufWriter::new(file);

    // 1. BOM を書き込む (Little Endian の場合は FF FE)
    writer.write_all(&[0xFF, 0xFE])?;

    // 2. 文字列を UTF-16 のイテレータに変換し、u16 を u8 (LE) に分解して書き込む
    for u16_char in content.encode_utf16() {
        // u16 を リトルエンディアンのバイト列 [u8; 2] に変換
        let bytes = u16_char.to_le_bytes();
        writer.write_all(&bytes)?;
    }

    writer.flush()?;
    println!("保存完了: {}", file_path);

    // 標準入力を待機
    println!("");
    let mut 入力 = String::new();
    println!("Enter で画面を閉じます...");
    io::stdin().read_line(&mut 入力).unwrap();

    Ok(())         //正常終了（`Ok`）を返せるようにする
}

// Gemini pro に教えてもらいました
// SaveUTF16ExternCrate

use std::fs::File;
use std::io::Write;
use encoding_rs::UTF_16LE;
use std::io;

fn main() -> std::io::Result<()> {
    let content = "こんにちは、世界！\n`encoding_rs` を使って UTF-16 で保存！";
    let file_path = "output_utf16le.txt";

    // 1. UTF-16LE にエンコード
    // .encode() は (Cow<[u8]>, encoding, bool) を返します
    let (encoded_bytes, _, _) = UTF_16LE.encode(content);

    // 2. ファイルを作成
    let mut file = File::create(file_path)?;

    // 3. BOM (Byte Order Mark) を書き込む (0xFF, 0xFE)
    // encoding_rs はデフォルトでは BOM を付けないため、手動で追加します
    file.write_all(&[0xFF, 0xFE])?;

    // 4. エンコードされた本文を書き込む
    file.write_all(&encoded_bytes)?;

    println!("保存完了: {}", file_path);

    // 標準入力を待機
    println!("");
    let mut 入力 = String::new();
    println!("Enter で画面を閉じます...");
    io::stdin().read_line(&mut 入力).unwrap();

    Ok(())
}

// Gemini pro に教えてもらいました
// SaveUTF16ExternCrate

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

fn main() -> std::io::Result<()> {
    let content = "あ"; // 日本語 1文字
    let file_path = "debug_test.txt";

    // 1. エンコード
    let (encoded_bytes, _, _) = UTF_16LE.encode(content);
    
    // 2. 書き込み
    let mut file = File::create(file_path)?;
    file.write_all(&[0xFF, 0xFE])?; // BOM
    file.write_all(&encoded_bytes)?;
    drop(file); // ファイルを確実に閉じる

    // 3. 【検証】保存されたファイルを「バイト列」として読み直す
    let mut reader = File::open(file_path)?;
    let mut buffer = Vec::new();
    reader.read_to_end(&mut buffer)?;

    println!("保存されたバイト列: {:X?}", buffer);
    
    // 判定
    if buffer.starts_with(&[0xFF, 0xFE]) {
        println!("結果: これは【UTF-16 LE (BOMあり)】です！");
    } else if buffer.contains(&0x00) {
        println!("結果: 0x00 が含まれているので UTF-16 の可能性が高いです。");
    } else {
        println!("結果: BOMがなく、0x00もなければ UTF-8 と判定されている可能性があります。");
    }
    
    // 標準入力を待機
    println!("");
    let mut 入力 = String::new();
    println!("Enter で画面を閉じます...");
    io::stdin().read_line(&mut 入力).unwrap();
    
    Ok(())
}

// Gemini pro に教えてもらいました

use std::fs;
use std::io;

fn main() -> std::io::Result<()> {
    // 1. バイト列として読み込む
    let bytes = fs::read("output_std_utf16.txt")?;

    // 2. 先頭2バイト(BOM)をスキップし、2バイトごとに結合して u16 の配列にする
    // (BOMがないファイルの場合は bytes[2..] ではなく bytes.as_slice() を使います)
    let u16_vec: Vec<u16> = bytes[2..]
        .chunks_exact(2)
        .map(|chunk| u16::from_le_bytes([chunk[0], chunk[1]]))
        .collect();

    // 3. String (UTF-8) に変換
    let content = String::from_utf16(&u16_vec).unwrap();

    println!("{}", content);

    // 標準入力を待機
    println!("");
    let mut 入力 = String::new();
    println!("Enter で画面を閉じます...");
    io::stdin().read_line(&mut 入力).unwrap();

    Ok(())
}

[package]
name = "ShiftJIS_2_UTF8JP"
version = "0.1.0"
edition = "2024"

[dependencies]
encoding_rs = "0.8.35"
rfd = "0.17.2"

//ChatGPTによる

use encoding_rs::SHIFT_JIS;
use std::fs;
use std::io::Write;
use std::path::Path;
use std::io;

fn main() {
    // ファイル選択ダイアログを表示
    let ファイル名 = rfd::FileDialog::new()
        .add_filter("Text", &["txt"])
        .pick_file();

    if let Some(path) = ファイル名 {
        println!("選択されたファイル: {:?}", path);

        // バイナリで読み込む
        let bytes = fs::read(&path).expect("ファイル読み込み失敗");

        // Shift JIS を UTF-8 にデコード
        let (cow, _, had_errors) = SHIFT_JIS.decode(&bytes);
        if had_errors {
            println!("警告: デコードエラーがありました");
        }

        let utf8_text = cow.to_string();

        // 新しいファイル名を作成
        let original_stem = path.file_stem().unwrap().to_string_lossy();
        let 新ファイル名 = format!("{}UTF8BOM.txt", original_stem);
        let parent = path.parent().unwrap_or(Path::new("."));
        let 新パス = parent.join(新ファイル名);

        // UTF-8 で保存
        let mut file = fs::File::create(&新パス).expect("ファイル作成失敗");
        // UTF-8 BOM を先に書き込む
        file.write_all(&[0xEF, 0xBB, 0xBF]).expect("BOM書き込み失敗");
        // 本文を書き込む
        file.write_all(utf8_text.as_bytes()).expect("ファイル書き込み失敗");

        println!("UTF-8 に変換して保存しました: {:?}", 新パス);
    } else {
        println!("ファイルが選択されませんでした");
    }

    // 標準入力を待機
    println!("");
    let mut 入力 = String::new();
    println!("Enter で画面を閉じます...");
    io::stdin().read_line(&mut 入力).unwrap();
}

[package]
name = "LineSort"
version = "0.1.0"
edition = "2024"

[dependencies]
encoding_rs = "0.8.35"
rfd = "0.17.2"

// ChatGPT による
// 時間表示は Gemini による

// use encoding_rs::{SHIFT_JIS, UTF_8, UTF_16LE, UTF_16BE, Encoding};
use encoding_rs::{SHIFT_JIS, UTF_8, UTF_16LE, UTF_16BE};
use std::fs;
use std::io::Write;
use std::path::Path;
use std::{time, io};  //時間（Duration, Instant）と標準入出力

#[derive(Clone, Copy)]
#[derive(Debug)]
enum TextEncoding {
    Utf8,
    Utf8Bom,
    Utf16Le,
    Utf16Be,
    ShiftJis,
}

/// 文字コード判定＋UTF-8 に変換
fn decode_text(bytes: &[u8]) -> (String, TextEncoding) {
    // UTF-8 BOM
    if bytes.starts_with(&[0xEF, 0xBB, 0xBF]) {
        let (cow, _, _) = UTF_8.decode(&bytes[3..]);      //0xEF 0xBB 0xBF の3バイト
        return (cow.to_string(), TextEncoding::Utf8Bom);
    }
    // UTF-16 LE BOM
    if bytes.starts_with(&[0xFF, 0xFE]) {
        let (cow, _, _) = UTF_16LE.decode(&bytes[2..]);
        return (cow.to_string(), TextEncoding::Utf16Le);  //Windows UNICODE
    }
    // UTF-16 BE BOM
    if bytes.starts_with(&[0xFE, 0xFF]) {
        let (cow, _, _) = UTF_16BE.decode(&bytes[2..]);
        return (cow.to_string(), TextEncoding::Utf16Be);
    }
    // ★ BOM 無し UTF-8 を試す
    let (cow, _, had_errors) = UTF_8.decode(bytes);
    if !had_errors {
        return (cow.to_string(), TextEncoding::Utf8);     //BOM無し：UTF8を試して
                                                          //エラーでなければ UTF8
    }
    // 最後に Shift JIS
    let (cow, _, _) = SHIFT_JIS.decode(bytes);
    (cow.to_string(), TextEncoding::ShiftJis)
}

/// UTF-8 String を元の文字コードへ変換
fn encode_text(text: &str, enc: TextEncoding) -> Vec<u8> {
    match enc {
        TextEncoding::Utf8 => text.as_bytes().to_vec(),
        TextEncoding::Utf8Bom => {
            let mut v = vec![0xEF, 0xBB, 0xBF];
            v.extend_from_slice(text.as_bytes());
            v
        }
        TextEncoding::Utf16Le => {
            let (cow, _, _) = UTF_16LE.encode(text);
            let mut v = vec![];
            v.extend_from_slice(&cow);
            v
        }
        TextEncoding::Utf16Be => {
            let (cow, _, _) = UTF_16BE.encode(text);
            let mut v = vec![];
            v.extend_from_slice(&cow);
            v
        }
        TextEncoding::ShiftJis => {
            let (cow, _, _) = SHIFT_JIS.encode(text);
            cow.to_vec()
        }
    }
}

/// 高速クイックソート（in-place）
// fn quick_sort(lines: &mut [String]) {
//     if lines.len() <= 1 {
//         return;
//     }
//
//     let pivot = lines.len() / 2;
//     let pivot_value = lines[pivot].clone();
//
//     let mut left = 0;
//     let mut right = lines.len() - 1;
//
//     while left <= right {
//         while lines[left] < pivot_value {
//             left += 1;
//         }
//         while lines[right] > pivot_value {
//             if right == 0 { break; }
//             right -= 1;
//         }
//         if left <= right {
//             lines.swap(left, right);
//             left += 1;
//             if right == 0 { break; }
//             right -= 1;
//         }
//     }
//
//     let (l, r) = lines.split_at_mut(left);
//     quick_sort(l);
//     quick_sort(r);
// }

fn main() {
    // �@ ファイル選択
    let path = match rfd::FileDialog::new().pick_file() {
        Some(p) => p,
        None => return,
    };

    // 今の時刻（計測開始地点）を取得
    let now = time::Instant::now();

    // �A 読み込み
    let bytes = fs::read(&path).expect("読み込み失敗");
    let (text, encoding) = decode_text(&bytes);

    // CRLF / LF 両対応
    let mut lines: Vec<String> = text
        .lines()
        .map(|s| s.to_string())
        .collect();

    println!("行数: {}", lines.len());

    // // �B クイックソート
    //quick_sort(&mut lines);

    // �B ソート（安全・高速・スタックオーバーフローしない）
    lines.sort_unstable();

    // 改行コードを設定
    let use_crlf = matches!(
        encoding,
        TextEncoding::ShiftJis | TextEncoding::Utf16Le | TextEncoding::Utf16Be
    );
    let sorted_text = if use_crlf {
        lines.join("\r\n")
    } else {
        lines.join("\n")
    };

    // 出力ファイル名
    let stem = path.file_stem().unwrap().to_string_lossy();
    let parent = path.parent().unwrap_or(Path::new("."));
    let out_path = parent.join(format!("{}SortedChatGPT.txt", stem));

    // 元の文字コードで保存
    let encoded = encode_text(&sorted_text, encoding);
    let mut file = fs::File::create(&out_path).expect("作成失敗");
    file.write_all(&encoded).expect("書き込み失敗");

    println!("ソート完了: {:?}", out_path);

    // 最初の時刻からの経過時間を表示
    // 最初の時刻からの経過時間を取得（Duration型）
    let elapsed = now.elapsed();

    // 経過時間の「合計秒数」を取得
    let total_secs = elapsed.as_secs();

    // 合計秒数から「時間・分・秒」を算数で計算する
    let hours = total_secs / 3600;              // 3600秒で割ると「時間」
    let minutes = (total_secs % 3600) / 60;     // 時間の余りを60で割ると「分」
    let seconds = total_secs % 60;              // さらにその余りが「秒」

    // 表示用の文字列を作る（可変なString型）
    let mut output = String::new();

    // 「時間」が0より大きければ表示に追加
    if hours > 0 {
        output.push_str(&format!("{}時間", hours));
    }
    // 「分」が0より大きければ表示に追加
    if minutes > 0 {
        output.push_str(&format!("{}分", minutes));
    }
    // 「秒」が0より大きければ表示に追加
    if seconds > 0 {
        output.push_str(&format!("{}秒", seconds));
    }
    // もし全部0だった場合（1秒未満）は「0秒」と表示するなどの対策
    if output.is_empty() {
        output.push_str("0秒");
    }
    // 最終的な結果を表示
    println!("経過時間: {}", output);
    
    println!("判定された文字コード: {:?}", encoding);

    // 標準入力を待機
    println!("");
    let mut input = String::new();
    println!("Enter で画面を閉じます...");
    io::stdin().read_line(&mut input).unwrap();
}

[package]
name = "LineSortGemini"
version = "0.1.0"
edition = "2021"

[dependencies]
rfd = "0.17.2"                  # ファイルダイアログ
encoding_rs = "0.8"             # 文字コード変換
charset-normalizer-rs = "1.1.0" # 文字コード自動判定 文字間が _ でなくて - であることに注意
chardetng = "0.1"               # 高精度な文字コード判定

use chardetng::EncodingDetector;
//use encoding_rs::{Encoding, UTF_8};
use encoding_rs::{Encoding};
use rfd::FileDialog;
use std::fs::{self, File};
use std::io::Read;
use std::path::{Path, PathBuf};
use std::{time, io};  //時間（Duration, Instant）と標準入出力

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. ファイルを開くダイアログ
    let file_path = FileDialog::new()
        .add_filter("Text Files", &["txt", "csv", "log"])
        .pick_file()
        .ok_or("ファイルが選択されませんでした。")?;

    // 今の時刻（計測開始地点）を取得
    let now = time::Instant::now();

    println!("読み込み中: {:?}", file_path.file_name().unwrap());

    // 2. ファイルをバイナリとして読み込む
    let mut file = File::open(&file_path)?;
    let mut buffer = Vec::new();
    file.read_to_end(&mut buffer)?;

    // 3. 文字コード判定とデコード (BOM対応)
    let (encoding, decoded_string) = detect_and_decode(&buffer);
    println!("判定された文字コード: {}", encoding.name());

    // 4. 行に分割 (CRLF / LF 混在に対応)
    // .lines() は改行文字(\rや\n)を自動的に取り除いてくれます
    let mut lines: Vec<&str> = decoded_string.lines().collect();
    let original_count = lines.len();
    println!("行数: {} 行", original_count);

    // 5. 行ソート (Rust標準の sort_unstable を使用)
    // Unicodeコードポイント順: 記号 < 数字 < 英字 < ひらがな < カタカナ < 漢字
    println!("ソート中...");
    lines.sort_unstable();

    // 6. 出力データの作成
    // Windowsの標準に合わせて CRLF (\r\n) で結合します
    let output_text = lines.join("\r\n");

    // 7. 元の文字コードにエンコードして保存
    // ファイル名を生成
    let output_path = create_output_path(&file_path);

    // エンコード
    //  (BOM付きだった場合は、encoding_rs は通常BOMなしで出力するため、必要なら付与可能だが、今回は標準的な挙動とする)
    let (encoded_bytes, _, _) = encoding.encode(&output_text);

    // 書き込み
    fs::write(&output_path, &encoded_bytes)?;

    println!("完了しました！");
    println!("出力ファイル: {:?}", output_path.file_name().unwrap());

    // 最初の時刻からの経過時間を表示
    // 最初の時刻からの経過時間を取得（Duration型）
    let elapsed = now.elapsed();

    // 経過時間の「合計秒数」を取得
    let total_secs = elapsed.as_secs();

    // 合計秒数から「時間・分・秒」を算数で計算する
    let hours = total_secs / 3600;              // 3600秒で割ると「時間」
    let minutes = (total_secs % 3600) / 60;     // 時間の余りを60で割ると「分」
    let seconds = total_secs % 60;              // さらにその余りが「秒」

    // 表示用の文字列を作る（可変なString型）
    let mut output = String::new();

    // 「時間」が0より大きければ表示に追加
    if hours > 0 {
        output.push_str(&format!("{}時間", hours));
    }
    // 「分」が0より大きければ表示に追加
    if minutes > 0 {
        output.push_str(&format!("{}分", minutes));
    }
    // 「秒」が0より大きければ表示に追加
    if seconds > 0 {
        output.push_str(&format!("{}秒", seconds));
    }
    // もし全部0だった場合（1秒未満）は「0秒」と表示するなどの対策
    if output.is_empty() {
        output.push_str("0秒");
    }
    // 最終的な結果を表示
    println!("経過時間: {}", output);
    
    // 標準入力を待機
    println!("");
    let mut input = String::new();
    println!("Enter で画面を閉じます...");
    io::stdin().read_line(&mut input).unwrap();

    Ok(())
}

/// 文字コードを判定してデコードする関数
/// BOMがあればそれを優先し、なければ chardetng で推測する
fn detect_and_decode(buffer: &[u8]) -> (&'static Encoding, String) {
    // 1. まずBOM（バイト順マーク）を確認する
    // encoding_rs の for_bom は BOM があればそのエンコーディングを返す
    if let Some((enc, bom_len)) = Encoding::for_bom(buffer) {
        // BOMがあった場合、その部分を除去してデコード
        let (decoded, _, _) = enc.decode(&buffer[bom_len..]);
        return (enc, decoded.into_owned());
    }

    // 2. BOMがない場合、chardetng で中身を解析して推測する
    let mut detector = EncodingDetector::new();
    detector.feed(buffer, true);
    let encoding = detector.guess(None, true); // TLD指定なし、日本語等の可能性を含める

    // 3. 決定したエンコーディングでデコード
    // decode_with_bom_removal は念のため入れているが、上記で除去済みなら問題ない
    let (decoded, _, _) = encoding.decode(buffer);
    (encoding, decoded.into_owned())
}

/// 出力ファイル名の生成 (SortedGemini を付与)
fn create_output_path(path: &Path) -> PathBuf {
    let stem = path.file_stem().unwrap_or_default().to_str().unwrap_or_default();
    let extension = path.extension().unwrap_or_default().to_str().unwrap_or_default();

    let new_filename = if extension.is_empty() {
        format!("{}SortedGemini", stem)
    } else {
        format!("{}SortedGemini.{}", stem, extension)
    };

    path.with_file_name(new_filename)
}

[package]
name = "LineSortClaude"
version = "0.1.0"
edition = "2024"

[dependencies]
native-dialog = "0.7"     # 渡辺注：このダイアログのバージョンを上げると FileDialog::new() を使えなくてエラーになります
                          # native_dialog::FileDialog ではなく rfd::FileDialog を使う方が正解
encoding_rs = "0.8.35"

use std::fs::{File, OpenOptions};
//use std::io::{BufReader, BufWriter, Read, Write};
use std::io::{BufWriter, Read, Write};
use std::path::{Path, PathBuf};
//use encoding_rs::{SHIFT_JIS, UTF_8, UTF_16LE, UTF_16BE};
use encoding_rs::{SHIFT_JIS, UTF_16LE, UTF_16BE};
use std::{time, io};  //時間（Duration, Instant）と標準入出力

fn main() {
    if let Err(e) = run() {
        eprintln!("エラーが発生しました: {}", e);
        std::process::exit(1);
    }
}

fn run() -> Result<(), Box<dyn std::error::Error>> {
    // ファイル選択ダイアログを表示
    let file_path = select_file()?;

    // 今の時刻（計測開始地点）を取得
    let now = time::Instant::now();

    println!("選択されたファイル: {}", file_path.display());

    // ファイルを読み込み、エンコーディングを自動検出
    let (lines, encoding, has_bom) = read_file_with_encoding(&file_path)?;
    println!("検出されたエンコーディング: {:?}", encoding);
    println!("読み込んだ行数: {}", lines.len());

    // クイックソートで行をソート
    let mut sorted_lines = lines;
    quick_sort(&mut sorted_lines);
    println!("ソート完了");

    // 出力ファイル名を生成
    let output_path = generate_output_path(&file_path)?;
    println!("出力先: {}", output_path.display());

    // ソート結果をファイルに書き込み
    write_file_with_encoding(&output_path, &sorted_lines, encoding, has_bom)?;
    println!("ファイルの書き込みが完了しました");

    // 最初の時刻からの経過時間を表示
    // 最初の時刻からの経過時間を取得（Duration型）
    let elapsed = now.elapsed();

    // 経過時間の「合計秒数」を取得
    let total_secs = elapsed.as_secs();

    // 合計秒数から「時間・分・秒」を算数で計算する
    let hours = total_secs / 3600;              // 3600秒で割ると「時間」
    let minutes = (total_secs % 3600) / 60;     // 時間の余りを60で割ると「分」
    let seconds = total_secs % 60;              // さらにその余りが「秒」

    // 表示用の文字列を作る（可変なString型）
    let mut output = String::new();

    // 「時間」が0より大きければ表示に追加
    if hours > 0 {
        output.push_str(&format!("{}時間", hours));
    }
    // 「分」が0より大きければ表示に追加
    if minutes > 0 {
        output.push_str(&format!("{}分", minutes));
    }
    // 「秒」が0より大きければ表示に追加
    if seconds > 0 {
        output.push_str(&format!("{}秒", seconds));
    }
    // もし全部0だった場合（1秒未満）は「0秒」と表示するなどの対策
    if output.is_empty() {
        output.push_str("0秒");
    }
    // 最終的な結果を表示
    println!("経過時間: {}", output);
    
    // 標準入力を待機
    println!("");
    let mut input = String::new();
    println!("Enter で画面を閉じます...");
    io::stdin().read_line(&mut input).unwrap();

    Ok(())
}

fn select_file() -> Result<PathBuf, Box<dyn std::error::Error>> {
    let file = native_dialog::FileDialog::new()
        .add_filter("テキストファイル", &["txt", "csv", "log"])
        .add_filter("すべてのファイル", &["*"])
        .show_open_single_file()?;

    file.ok_or_else(|| "ファイルが選択されませんでした".into())
}

#[derive(Debug, Clone, Copy)]
enum DetectedEncoding {
    Utf8,
    Utf16Le,
    Utf16Be,
    ShiftJis,
}

fn read_file_with_encoding(path: &Path) -> Result<(Vec<String>, DetectedEncoding, bool), Box<dyn std::error::Error>> {
    let mut file = File::open(path)?;
    let mut bytes = Vec::new();
    file.read_to_end(&mut bytes)?;

    // BOMとエンコーディングの検出
    let (encoding, has_bom, start_pos) = detect_encoding(&bytes);

    // バイト列をデコード
    let text = decode_bytes(&bytes[start_pos..], encoding)?;

    // 行に分割（CRLFとLFの両方に対応）
    let lines: Vec<String> = text
        .lines()
        .map(|s| s.to_string())
        .collect();

    Ok((lines, encoding, has_bom))
}

fn detect_encoding(bytes: &[u8]) -> (DetectedEncoding, bool, usize) {
    // BOMチェック
    if bytes.starts_with(&[0xEF, 0xBB, 0xBF]) {
        return (DetectedEncoding::Utf8, true, 3);
    }
    if bytes.starts_with(&[0xFF, 0xFE]) {
        return (DetectedEncoding::Utf16Le, true, 2);
    }
    if bytes.starts_with(&[0xFE, 0xFF]) {
        return (DetectedEncoding::Utf16Be, true, 2);
    }

    // BOMなしの場合、内容から推測
    // UTF-16の検出（null バイトの存在をチェック）
    let null_count = bytes.iter().take(1000.min(bytes.len())).filter(|&&b| b == 0).count();
    if null_count > 10 {
        // 偶数位置にnullが多い場合はUTF-16LE
        let even_nulls = bytes.iter().enumerate().take(1000.min(bytes.len()))
            .filter(|&(ref i, &b)| i % 2 == 1 && b == 0).count();
        //  .filter(|(i, &b)| i % 2 == 1 && b == 0).count();
        if even_nulls > null_count / 2 {
            return (DetectedEncoding::Utf16Le, false, 0);
        }
        // 奇数位置にnullが多い場合はUTF-16BE
        let odd_nulls = bytes.iter().enumerate().take(1000.min(bytes.len()))
            .filter(|&(ref i, &b)| i % 2 == 0 && b == 0).count();
        //  .filter(|(i, &b)| i % 2 == 0 && b == 0).count();
        if odd_nulls > null_count / 2 {
            return (DetectedEncoding::Utf16Be, false, 0);
        }
    }

    // UTF-8の検出
    if std::str::from_utf8(bytes).is_ok() {
        return (DetectedEncoding::Utf8, false, 0);
    }

    // デフォルトはShift_JIS
    (DetectedEncoding::ShiftJis, false, 0)
}

fn decode_bytes(bytes: &[u8], encoding: DetectedEncoding) -> Result<String, Box<dyn std::error::Error>> {
    match encoding {
        DetectedEncoding::Utf8 => {
            Ok(String::from_utf8_lossy(bytes).to_string())
        }
        DetectedEncoding::Utf16Le => {
            let (decoded, _, had_errors) = UTF_16LE.decode(bytes);
            if had_errors {
                eprintln!("警告: デコード中にエラーがありました");
            }
            Ok(decoded.to_string())
        }
        DetectedEncoding::Utf16Be => {
            let (decoded, _, had_errors) = UTF_16BE.decode(bytes);
            if had_errors {
                eprintln!("警告: デコード中にエラーがありました");
            }
            Ok(decoded.to_string())
        }
        DetectedEncoding::ShiftJis => {
            let (decoded, _, had_errors) = SHIFT_JIS.decode(bytes);
            if had_errors {
                eprintln!("警告: デコード中にエラーがありました");
            }
            Ok(decoded.to_string())
        }
    }
}

fn quick_sort(arr: &mut [String]) {
    if arr.len() <= 1 {
        return;
    }

    //let len = arr.len();
    let pivot_index = partition(arr);

    let (left, right) = arr.split_at_mut(pivot_index);
    quick_sort(left);
    if right.len() > 1 {
        quick_sort(&mut right[1..]);
    }
}

fn partition(arr: &mut [String]) -> usize {
    let len = arr.len();
    let pivot_index = len / 2;
    arr.swap(pivot_index, len - 1);

    let mut i = 0;
    for j in 0..len - 1 {
        if arr[j] <= arr[len - 1] {
            arr.swap(i, j);
            i += 1;
        }
    }
    arr.swap(i, len - 1);
    i
}

fn generate_output_path(input_path: &Path) -> Result<PathBuf, Box<dyn std::error::Error>> {
    let parent = input_path.parent().ok_or("親ディレクトリが見つかりません")?;
    let stem = input_path.file_stem().ok_or("ファイル名が取得できません")?;
    let extension = input_path.extension().unwrap_or_default();

    let new_filename = format!(
        "{}SortedClaude.{}",
        stem.to_string_lossy(),
        extension.to_string_lossy()
    );

    Ok(parent.join(new_filename))
}

fn write_file_with_encoding(
    path: &Path,
    lines: &[String],
    encoding: DetectedEncoding,
    has_bom: bool,
) -> Result<(), Box<dyn std::error::Error>> {
    let file = OpenOptions::new()
        .write(true)
        .create(true)
        .truncate(true)
        .open(path)?;

    let mut writer = BufWriter::new(file);

    // BOMを書き込み
    if has_bom {
        match encoding {
            DetectedEncoding::Utf8 => writer.write_all(&[0xEF, 0xBB, 0xBF])?,
            DetectedEncoding::Utf16Le => writer.write_all(&[0xFF, 0xFE])?,
            DetectedEncoding::Utf16Be => writer.write_all(&[0xFE, 0xFF])?,
            _ => {}
        }
    }

    // 各行をエンコードして書き込み
    for (i, line) in lines.iter().enumerate() {
        let encoded = encode_string(line, encoding)?;
        writer.write_all(&encoded)?;

        // 最後の行以外は改行を追加（元のファイルと同じ形式）
        if i < lines.len() - 1 {
            let newline = encode_string("\r\n", encoding)?;
            writer.write_all(&newline)?;
        }
    }

    writer.flush()?;
    Ok(())
}

fn encode_string(s: &str, encoding: DetectedEncoding) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    match encoding {
        DetectedEncoding::Utf8 => Ok(s.as_bytes().to_vec()),
        DetectedEncoding::Utf16Le => {
            let (encoded, _, had_errors) = UTF_16LE.encode(s);
            if had_errors {
                eprintln!("警告: エンコード中にエラーがありました");
            }
            Ok(encoded.to_vec())
        }
        DetectedEncoding::Utf16Be => {
            let (encoded, _, had_errors) = UTF_16BE.encode(s);
            if had_errors {
                eprintln!("警告: エンコード中にエラーがありました");
            }
            Ok(encoded.to_vec())
        }
        DetectedEncoding::ShiftJis => {
            let (encoded, _, had_errors) = SHIFT_JIS.encode(s);
            if had_errors {
                eprintln!("警告: エンコード中にエラーがありました");
            }
            Ok(encoded.to_vec())
        }
    }
}

[package]
name = "CountOfEachCharacterJP"
version = "0.1.0"
edition = "2024"

[dependencies]
encoding_rs = "0.8.35"
rfd = "0.17.2"

//ChatGPTによる

use encoding_rs::{SHIFT_JIS, UTF_16BE, UTF_16LE, UTF_8};
use std::collections::HashMap;
use std::fs;
use std::io::Write;
use std::path::Path;
use std::io;


/// バイト列から文字コードを判定して UTF-8 String に変換
fn utf8に変換(bytes: &[u8]) -> String {
    // UTF-8 BOM
    if bytes.starts_with(&[0xEF, 0xBB, 0xBF]) {
        let (cow, _, _) = UTF_8.decode(&bytes[3..]);
        return cow.to_string();
    }
    // UTF-16 LE BOM
    if bytes.starts_with(&[0xFF, 0xFE]) {
        let (cow, _, _) = UTF_16LE.decode(&bytes[2..]);
        return cow.to_string();
    }
    // UTF-16 BE BOM
    if bytes.starts_with(&[0xFE, 0xFF]) {
        let (cow, _, _) = UTF_16BE.decode(&bytes[2..]);
        return cow.to_string();
    }
    // ★ BOM 無し UTF-8 を試す
    let (cow, _, had_errors) = UTF_8.decode(bytes);
    if !had_errors {
        // UTF-8 として問題なければ採用
        return cow.to_string();
    }
    // 最後に Shift JIS
    let (cow, _, _) = SHIFT_JIS.decode(bytes);
    cow.to_string()
}


fn main() {
    // �@ ファイル選択ダイアログ
    let ファイル_パス = rfd::FileDialog::new()
        .add_filter("Text", &["txt"])
        .pick_file();

    let path = match ファイル_パス {
        Some(p) => p,
        None => {
            println!("ファイルが選択されませんでした");
            return;
        }
    };

    // �A ファイル読み込み
    let bytes = fs::read(&path).expect("ファイル読み込み失敗");

    // 文字コードを考慮して UTF-8 に変換
    let text = utf8に変換(&bytes);

    // �B 文字ごとの出現回数をカウント（空白・改行除外）
    let mut カウント: HashMap<char, usize> = HashMap::new();
    for ch in text.chars() {
        if ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t' {
            continue;
        }
        *カウント.entry(ch).or_insert(0) += 1;
    }

    // 出力ファイル名作成
    let stem = path.file_stem().unwrap().to_string_lossy();
    let parent = path.parent().unwrap_or(Path::new("."));
    let out_path = parent.join(format!("{}Count.txt", stem));

    // �C 並び替え
    // 1. 出現回数の降順
    // 2. 出現回数が同じ場合は文字コード順（昇順）
    let mut items: Vec<(char, usize)> = カウント.into_iter().collect();
    items.sort_by(|a, b| {
        b.1.cmp(&a.1)   // 出現回数：多い順
            .then_with(|| a.0.cmp(&b.0)) // 文字コード順
    });

    // �C UTF-8 で書き出し
    let mut out = fs::File::create(&out_path).expect("出力ファイル作成失敗");

    for (ch, count) in items {
        writeln!(out, "{}\t{}", ch, count).unwrap();
    }

    println!("文字頻度を出力しました:");
    println!("{:?}", out_path);

    // 標準入力を待機
    println!("");
    let mut 入力 = String::new();
    println!("Enter で画面を閉じます...");
    io::stdin().read_line(&mut 入力).unwrap();
}