ヽ｜∵｜ゝ(Fantom) の 開発blog？

/// <summary>
/// 最小公倍数を求める(Least Common Multiple)
/// 2020/11/14 Fantom 
/// http://fantom1x.blog130.fc2.com/blog-entry-385.html
/// http://fantom1x.blog130.fc2.com/blog-entry-384.html
/// http://fantom1x.blog130.fc2.com/blog-entry-215.html#lcm
/// </summary>
/// <param name="a">数値1 (>0)</param>
/// <param name="b">数値2 (>0)</param>
/// <returns>最小公倍数</returns>
public static int Lcm(this int a, int b)
{
    return a * b / Gcd(a, b);  //※Gcd は前回の記事を参照
}

using System;

int h = 16;
int v = 9;
int m = Lcm(h, v);
Console.WriteLine("m = " + m);

/// <summary>
/// 最大公約数を求める(Greatest Common Divisor).
/// ユークリッドの互除法 (非再帰版).
/// 2020/11/12 Fantom (Java から移植)
/// http://fantom1x.blog130.fc2.com/blog-entry-384.html
/// http://fantom1x.blog130.fc2.com/blog-entry-215.html
/// </summary>
/// <param name="a">数値1 (>0)</param>
/// <param name="b">数値2 (>0)</param>
/// <returns>最大公約数 (なし=1 [互いに素])</returns>
public static int Gcd(this int a, int b)
{
    //a > b にする（スワップ）
    if (a < b)
    {
        int tmp = a;
        a = b;
        b = tmp;
    }

    //ユークリッドの互除法
    int r = -1;
    while (r != 0)
    {
        r = a % b;
        a = b;
        b = r;
    }

    return a;  //b には r = 0 の値が入るため、a を返す
}

using System;

int a = 1920;
int b = 1080;
int d = Gcd(a, b);
Console.WriteLine("d = " + d);  //最大公約数
Console.WriteLine(a + "x" + b + " => " + (a / d) + ":" + (b / d));  //約分に利用

/// <summary>
/// 最大公約数を求める(Greatest Common Divisor).
/// [ユークリッドの互除法] (再帰版).
/// 2020/11/12 Fantom (Java から移植)
/// http://fantom1x.blog130.fc2.com/blog-entry-384.html
/// http://fantom1x.blog130.fc2.com/blog-entry-215.html
/// </summary>
/// <param name="a">数値1 (>0) (a >= b)</param>
/// <param name="b">数値2 (>0)</param>
/// <returns>最大公約数 (なし=1 [互いに素])</returns>
public static int GcdRec(int a, int b) 
{
    return (b == 0) ? a : GcdRec(b, a % b);
}

using System;

int a = 1920;
int b = 1080;
int d =  (a >= b) ? GcdRec(a, b) : GcdRec(b, a);  //a >= b にする
Console.WriteLine("d = " + d);  //最大公約数
Console.WriteLine(a + "x" + b + " => " + (a / d) + ":" + (b / d));  //約分に利用

/// <summary>
/// a / b の約分をする
/// 2020/11/12 Fantom 
/// http://fantom1x.blog130.fc2.com/blog-entry-384.html
/// </summary>
/// <param name="a">分子 (>0)</param>
/// <param name="b">分母 (>0)</param>
/// <returns></returns>
public static (int, int) Reduce(this int a, int b)
{
    int d = Gcd(a, b);  //最大公約数
    return (a / d, b / d);
}

using System;

int width = 1920;
int height = 1080;
var aspect = Reduce(width, height);
Console.WriteLine($"{width}x{height} => {aspect.Item1}:{aspect.Item2}");

public static int[] Reduce(this int a, int b)
{
    int d = Gcd(a, b);  //最大公約数
    return new int[]{ a / d, b / d };
}

/// <summary>
/// ３つ以上の最大公約数を求める[gcd(a, b, c,...)].
/// ユークリッドの互除法の繰り返しで求める.
/// 2020/11/12 Fantom (Java から移植)
/// http://fantom1x.blog130.fc2.com/blog-entry-384.html
/// http://fantom1x.blog130.fc2.com/blog-entry-220.html
/// </summary>
/// <param name="param">数値1, 2, 3,... (a, b, c,...) (>0) [引数は3個以上]</param>
/// <returns>最大公約数(なし=1[互いに素])</returns>
public static int Gcd(params int[] param) {
    int len = param.Length;
    int g = Gcd(param[0], param[1]);
    for (int i = 1; i < len - 1; i++)
    {
        g = Gcd(g, param[i + 1]);
    }
    return g;
}

using System;

int a = 12;
int b = 36;
int c = 60;
int d = 96;

int g1 = Gcd(a, b);
int g2 = Gcd(g1, c);
int g3 = Gcd(g2, d);
Console.WriteLine("g3 = " + g3);

int g = Gcd(a, b, c, d);
Console.WriteLine("g  = " + g);
Console.WriteLine(g == g3);

using UnityEngine;
using Random = UnityEngine.Random;

public static class Extensions  //拡張メソッド用 static クラス（名前は任意）
{
    //配列の要素をシャッフルする (Fisher-Yates shuffle)
    public static void Shuffle<T>(this T[] arr)
    {
        for (int i = arr.Length - 1; i > 0; i--)
        {
            int j = Random.Range(0, i + 1);  //[0]～[i]
            T tmp = arr[i];     //swap
            arr[i] = arr[j];
            arr[j] = tmp;
        }
    }
}


//メインでは・・・
using System.Linq;

int[] arr = { 0, 1, 2, 3, 4, 5 };
for (int i = 0; i < 5; i++)
{
    arr.Shuffle();
    Debug.Log(arr.Select(e => e.ToString()).Aggregate((s, a) => s + ", " + a));
}

using UnityEngine;
using Random = UnityEngine.Random;

public static class Extensions  //拡張メソッド用 static クラス（名前は任意）
{
    //配列の要素をシャッフルする (Fisher-Yates shuffle)
    public static void Shuffle<T>(this T[] arr)
    {
        for (int i = arr.Length - 1; i > 0; i--)
        {
            int j = Random.Range(0, i + 1);  //[0]～[i]
            arr.Swap(i, j);
        }
    }

    //要素のスワップ
    public static void Swap<T>(this T[] arr, int i, int j)
    {
        T tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

//メインは同じ（※略）

・・・（略）・・・
public class Extensions  //※通常メソッドの場合、static でなくても可
{
    //配列の要素をシャッフルする (Fisher-Yates shuffle)
    public static void Shuffle<T>(T[] arr)
    {
        for (int i = arr.Length - 1; i > 0; i--)
        {
            int j = Random.Range(0, i + 1);  //[0]～[i]
            Swap(arr, i, j);
        }
    }

    //要素のスワップ
    public static void Swap<T>(T[] arr, int i, int j)
    {
        T tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

//メインでは・・・
・・・（略）・・・
Extensions.Shuffle(arr);    //※クラス名は任意の定義による
・・・（略）・・・

using UnityEngine;
using Random = System.Random;    //ここでエイリアスにしておくと表記が楽

public static class Extensions  //拡張メソッド用 static クラス（名前は任意）
{
    static Random rand = new Random();  //※毎回 new するならいっそ static で利用する

    //配列の要素をシャッフルする (Fisher-Yates shuffle)
    public static void Shuffle<T>(this T[] arr)
    {
        for (int i = arr.Length - 1; i > 0; i--)
        {
            int j = rand.Next(i + 1);  //[0]～[i]
            arr.Swap(i, j);
        }
    }

    //スワップは拡張メソッドと同じ（※略）
}

//メインは同じ（※略）

using System.Collections.Generic;
using UnityEngine;
using Random = UnityEngine.Random;

public static class Extensions  //拡張メソッド用 static クラス（名前は任意）
{
    //リストの要素をシャッフルする (Fisher-Yates shuffle)
    public static void Shuffle<T>(this List<T> list)
    {
        for (int i = list.Count - 1; i > 0; i--)
        {
            int j = Random.Range(0, i + 1);  //[0]～[i]
            T tmp = list[i];
            list[i] = list[j];
            list[j] = tmp;
        }
    }
}


//メインでは・・・
using System.Linq;

List<int> list = new List<int>() { 0, 1, 2, 3, 4, 5 };
for (int i = 0; i < 5; i++)
{
    list.Shuffle();
    Debug.Log(list.Select(e => e.ToString()).Aggregate((s, a) => s + ", " + a));
}

using System.Collections.Generic;
using UnityEngine;
using Random = UnityEngine.Random;

public static class Extensions  //拡張メソッド用 static クラス（名前は任意）
{
    //リストの要素をシャッフルする (Fisher-Yates shuffle)
    public static void Shuffle<T>(this List<T> list)
    {
        for (int i = list.Count - 1; i > 0; i--)
        {
            int j = Random.Range(0, i + 1);  //[0]～[i]
            list.Swap(i, j);
        }
    }

    //要素のスワップ
    public static void Swap<T>(this List<T> list, int i, int j)
    {
        T tmp = list[i];
        list[i] = list[j];
        list[j] = tmp;
    }
}

//メインは同じ（※略）

・・・（略）・・・
public class Extensions
{
    //リストの要素をシャッフルする (Fisher-Yates shuffle)
    public static void Shuffle<T>(List<T> list)
    {
        for (int i = list.Count - 1; i > 0; i--)
        {
            int j = Random.Range(0, i + 1);  //[0]～[i]
            Swap(list, i, j);
        }
    }

    //要素のスワップ
    public static void Swap<T>(List<T> list, int i, int j)
    {
        T tmp = list[i];
        list[i] = list[j];
        list[j] = tmp;
    }
}

//メインでは・・・
・・・（略）・・・
Extensions.Shuffle(list);   //※クラス名は任意の定義による
・・・（略）・・・

using UnityEngine;
using Random = System.Random;    //ここでエイリアスにしておくと表記が楽

public static class Extensions  //拡張メソッド用 static クラス（名前は任意）
{
    static Random rand = new Random();  //※毎回 new するならいっそ static で利用する

    //リストの要素をシャッフルする (Fisher-Yates shuffle)
    public static void Shuffle<T>(this List<T> list)
    {
        for (int i = arr.Length - 1; i > 0; i--)
        {
            int j = rand.Next(i + 1); //[0]～[i]
            arr.Swap(i, j);
        }
    }

    //スワップは拡張メソッドと同じ（※略）
}

//メインは同じ（※略）

/**<h1>整数の桁数を求める</h1>
 * <p>0 となるまで、10 で割り続ける方法。</p>
 * @param value ： 調べる値
 * @return<b>int</b> ： 桁数 (負の値は '-' を除いた桁数)
 */
public static final int length(long value) {
    int cnt = 0;
    do {
        cnt++;
        value /= 10;
    } while (value != 0);
    return cnt;
}


//メインでは...
int n = 1234;       //4
//int n = -4321;    //4
//int n = 0;        //1
System.out.println(length(n));

/**<h1>整数の桁数を求める</h1>
 * <p>0 となるまで、10 で割り続ける方法。</p>
 * @param value ： 調べる値
 * @return<b>int</b> ： 桁数 (負の値は '-' を除いた桁数)
 */
public static final int length(long value) {
    int cnt = 1;    //0 にも対応
    while ((value /= 10) != 0) {
        cnt++;
    }
    return cnt;
}


//メインでは...
int n = 1234;       //4
//int n = -4321;    //4
//int n = 0;        //1
System.out.println(length(n));

//int n = 1234;     //4
int n = -4321;      //4
//int n = 0;        //1

System.out.println(String.valueOf(Math.abs(n)).length());

/**<h1>x<sup>n</sup> の桁数を求める</h1>
 * <p>log10() により求める。底が負のときは NaN となるので注意。</p>
 * @param x ： 底 (> 0)
 * @param k ： べき指数 (>= 0)
 * @return<b>double</b> ： 桁数
 */
public static final double powLength(final double x, final double k) {
    return Math.floor(Math.log10(x) * k) + 1;
}


//メインでは...
int x = 2, k = 30;    //10.0
//int x = 123456789, k = 99999;    //809144.0
System.out.println(powLength(x, k));

/**<h1>x<sup>y<sup>z</sup></sup> (べき乗のべき乗)の桁数を求める</h1>
 * <p>log10() により求める。底が負のときは NaN となるので注意。</p>
 * @param x ： 底 (> 0)
 * @param y ： べき指数1 (>= 0)
 * @param z ： べき指数2 (>= 0)
 * @return<b>double</b> ： 桁数 (オーバーフロー: Infinity に注意)
 */
public static final double powpowLength(final double x, final double y, final double z) {
    final double p = Math.log10(y) * z;    //y^z
    final double q = Math.log10(x);        //x^p
    return Math.floor(q * Math.pow(10, p)) + 1;
}


//メインでは...
int x = 2, y = 3, z = 5;    //74.0
//int x = 5, y = 6, z = 7;    //195667.0
System.out.println(powpowLength(x, y, z));

/**<h1>x<sup>y<sup>z</sup></sup> (べき乗のべき乗) の log10() を返す</h1>
 * <p>この値で比較すれば、大小関係がわかる。底が負のときは NaN となるので注意。</p>
 * @param x ： 底 (> 0)
 * @param y ： べき指数1 (>= 0)
 * @param z ： べき指数2 (>= 0)
 * @return<b>double</b> ： 底を10<sup>10</sup>に合わせた log10() を返す
 */
public static final double powpowLog10(final double x, final double y, final double z) {
    final double p = Math.log10(y) * z;            //y^z
    final double q = Math.log10(Math.log10(x));    //10^q = log10 x
    return p + q;
}

/**<h1>x<sup>y<sup>z</sup></sup> (べき乗のべき乗) 同士の大小の比較</h1>
 * <p>比較の関係値を返す(-1, 0, 1 のみ)。差分ではない。</p>
 * @param x1 ： 底 a (> 0)
 * @param y1 ： べき指数1 a (>= 0)
 * @param z1 ： べき指数2 a (>= 0)
 * @param x2 ： 底 b (> 0)
 * @param y2 ： べき指数1 b (>= 0)
 * @param z2 ： べき指数2 b (>= 0)
 * @return<b>int</b> ： -1 : a < b / 1 : a > b / 0 : a == b
 */
public static final int powpowCompare(final double x1, final double y1, final double z1, 
    final double x2, final double y2, final double z2) {

    final double a = powpowLog10(x1, y1, z1);
    final double b = powpowLog10(x2, y2, z2);
    if (a < b) {
        return -1;
    } else if (a > b) {
        return 1;
    } else {
        return 0;
    }
}


//メインでは...
int x1 = 123456, y1 = 9876543, z1 = 24356891;	//Infinity
int x2 = 333333, y2 = 5555555, z2 = 22222222;	//Infinity
System.out.println(powpowLength(x1, y1, z1));
System.out.println(powpowLog10(x1, y1, z1));
System.out.println(powpowLength(x2, y2, z2));
System.out.println(powpowLog10(x2, y2, z2));
System.out.println(powpowCompare(x1, y1, z1, x2, y2, z2));

int x = 2, y = 3, z = 5;
int a = (int)Math.pow(y, z);
BigDecimal b = new BigDecimal(x).pow(a);
System.out.println(b.toString());
System.out.println(b.precision());
System.out.println(powpowLength(x, y, z));

int n;
n = 46;
String bin = Integer.toString(n, 2);    //10進数→2進数
//String bin = Integer.toBinaryString(n); //10進数→2進数(※同じ)
System.out.println(n + " -> " + bin + " (2)");

n = 51;
String tri = Integer.toString(n, 3);    //10進数→3進数
System.out.println(n + " -> " + tri + " (3)");

n = 16;
String oct = Integer.toString(n, 8);    //10進数→8進数
//String oct = Integer.toOctalString(n);  //10進数→8進数(※同じ)
System.out.println(n + " -> " + oct + " (8)");

n = 30;
String hex = Integer.toString(n, 16);   //10進数→16進数
//String hex = Integer.toHexString(n);    //10進数→16進数(※同じ)
System.out.println(n + " -> " + hex + " (16)");

int v;
String bin = "101110";
v = Integer.parseInt(bin, 2);    //2進数→10進数
System.out.println(bin + " (2) -> " + v);

String tri = "1220";
v = Integer.parseInt(tri, 3);    //3進数→10進数
System.out.println(tri + " (3) -> " + v);

String oct = "20";
v = Integer.parseInt(oct, 8);    //8進数→10進数
System.out.println(oct + " (8) -> " + v);

String hex = "1e";
v = Integer.parseInt(hex, 16);   //16進数→10進数
System.out.println(hex + " (16) -> " + v);

String s = "11111111111111111111111111111111";  //2進数は31ビット目(最下位を0とするとき)が1のとき負の値となる
//int v = Integer.parseInt(s, 2);  //エラー(NumberFormatException)
int v = Integer.parseUnsignedInt(s, 2);  //-1

int b = 0b101110;    //2進数表現
System.out.println("b = " + b);    //10進数

int o = 020;     //8進数表現
System.out.println("o = " + o);    //10進数

int h = 0x1e;    //16進数表現
System.out.println("h = " + h);    //10進数

import java.util.ArrayList;
import java.util.List;

/**<h1>基数変換したリストを作る（各桁を分解）</h1>
 * <p>各桁の値は、下位から上位に向かって入る。</p>
 * @param value ： 元の数値 (10進数)
 * @param radix ： 変換する基数 (>= 2)
 * @return<b>List<Integer></b> ： 基数で割った余りのリスト
 */
public static final List<Integer> baseRemainder(int value, final int radix) {
    final List<Integer> list = new ArrayList<Integer>();
    int m;
    do {
        m = value % radix;
        value /= radix;
        list.add(m);
    } while (value > 0);

    return list;
}


//メインでは...
int n = 51;
List<Integer> list = baseRemainder(n, 3);
for (int k : list) {
    System.out.print(k + " ");
}

int n = 1234;
List<Integer> list = baseRemainder(n, 10);
for (int k : list) {
    System.out.print(k + " ");
}

import java.util.ArrayList;
import java.util.List;

/**<h1>各桁のリスト(n進数)を10進数に変換する</h1>
 * <p>要素(各桁の値)は、下位から上位に向かって入っているものを使う。</p>
 * @param list ： 各桁のリスト
 * @param radix ： リストの基数
 * @return<b>int</b> ： 10進数
 */
public static final int digitsToInt(final List<Integer> list, final int radix) {
    int sum = 0;
    int x = 1;
    final int len = list.size();
    for (int i = 0; i < len; i++) {
        sum += list.get(i) * x;
        x *= radix;
    }
    return sum;
}


//メインでは...
int b = 0b101110;    //2進数表現
List<Integer> list = baseRemainder(b, 2);

System.out.print("list = ");
for (int k : list) {
    System.out.print(k + " ");
}
System.out.println();

int v = digitsToInt(list, 2);
System.out.println("v = " + v);

for (int v : list) {
    sum += v * x;
    x *= radix;
}