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

using UnityEngine;

var resolutions = Screen.resolutions;
foreach (var res in resolutions)
{
    Debug.Log($"{res} {Reduce(res.width, res.height)}, w/h = {(float)res.width/res.height}");  //※Reduce は以前の記事を参照
}

/// <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);

/**<h1>３つ以上の最大公約数を求める[gcd(a, b, c,...)]</h1>
 * <p>ユークリッドの互除法の繰り返しで求める。</p>
 * @param param ： 数値1, 2, 3,... (a, b, c,...) (>0) [引数は3個以上]
 * @return<b>int</b> ： 最大公約数(なし=1[互いに素])
 */
public static final int gcd(final int... param) {
    final int len = param.length;
    int g = gcd(param[0], param[1]);    //gcd(a, b) は以前作ったもの
    for (int i = 1; i < len - 1; i++) {
        g = gcd(g, param[i + 1]);       //gcd(a, b) は以前作ったもの
    }
    return g;
}


//メインでは...
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);
System.out.println("g3 = " + g3);

int g = gcd(a, b, c, d);
System.out.println("g  = " + g);
System.out.println(g == g3);

/**<h1>３つ以上のパラメタに対応させた拡張ユークリッド互除法[ax + by + cz +... = gcd(a, b, c,...)]</h1>
 * <p>拡張ユークリッドの互除法の繰り返しで求める。</p>
 * @param param ： 数値 1, 2, 3,... (a, b, c,...) (>0) [引数は3個以上]
 * @return<b>int[]</b> ： {[0]:gcd, [1]:x, [2]:y, [3]z,...} 最大公約数(なし=1 [互いに素])と解 x, y, z...
 */
public static final int[] extgcd(final int... param) {
    final int len = param.length;
    final int[][] g = new int[len - 1][];
    g[0] = extgcd(param[0], param[1]);      //extgcd(a, b) は以前作ったもの
    for (int i = 1; i < len - 1; i++) {
        g[i] = extgcd(g[i - 1][0], param[i + 1]);    //extgcd(a, b) は以前作ったもの
    }

    //解の係数を展開する
    final int[] res = new int[len + 1];
    res[len] = g[len - 2][2];
    res[0] = g[len - 2][0];    //gcd

    int k = g[len - 2][1];
    for (int i = len - 3; i >= 0; i--) {
        res[i + 2] = g[i][2] * k;
        k *= g[i][1];
    }
    res[1] = k;
    return res;
}


//メインでは...
int a = 12;
int b = 16;
int c = 18;
int d = 21;

int[] g1 = extgcd(a, b);
System.out.println("g1 = " + g1[0] + ", x = " + g1[1] + ", y = " + g1[2]);
int[] g2 = extgcd(g1[0], c);
System.out.println("g2 = " + g2[0] + ", x = " + g2[1] + ", y = " + g2[2]);
int[] g3 = extgcd(g2[0], d);
System.out.println("g3 = " + g3[0] + ", x = " + g3[1] + ", y = " + g3[2]);

int[] g = extgcd(a, b, c, d);
System.out.println("g  = " + g[0] + ", w = " + g[1] + ", x = " + g[2] + ", y = " + g[3] + ", z = " + g[4]);

/**<h1>拡張ユークリッド互除法</h1>
 * <p>ax + by = gcd(a, b) となる a, b の最大公約数と解 x, y を求める。</p>
 * @param a ： 数値１(>0)
 * @param b ： 数値２(>0)
 * @return<b>int[]</b> ： {[0]:gcd, [1]:x, [2]:y}：最大公約数(なし=1 [互いに素])と解 x, y
 */
public static final int[] extgcd(int a, int b) {
    int x0 = 1, x1 = 0;
    int y0 = 0, y1 = 1;

    while (b != 0) {
        int q = a / b;
        int r = a % b;
        int x2 = x0 - q * x1;
        int y2 = y0 - q * y1;

        a = b; b = r;
        x0 = x1; x1 = x2;
        y0 = y1; y1 = y2;
    }

    return new int[]{a, x0, y0};
}


//メインでは...
int a = 12;
int b = 21;
int[] res = extgcd(a, b);
int g = res[0];
int x = res[1];
int y = res[2];
System.out.println("g = " + g + ", x = " + x + ", y = " + y);
System.out.println(a + " * " + x + " + " + b + " * " + y + " = " + g);
int sum = a * x + b * y;
System.out.println(sum == g);

/**<h1>拡張ユークリッド互除法</h1>
 * <p>ax + by = gcd(a, b) となる a, b の最大公約数と解 x, y を求める。</p>
 * @param a ： 数値１(>0)
 * @param b ： 数値２(>0)
 * @param x ： 解 x (参照渡し用 new int[1] で作る)
 * @param y ： 解 y (参照渡し用 new int[1] で作る)
 * @return<b>int</b> ： 最大公約数(なし=1 [互いに素])
 */
public static final int extgcd(final int a, final int b, final int[] x, final int[] y) {
    int g = a;
    if (b != 0) {
        g = extgcd(b, a % b, y, x);
        y[0] -= (a / b) * x[0];
    } else {
        x[0] = 1;
        y[0] = 0;
    }
    return g;
}


//メインでは...
int a = 12;
int b = 21;
int[] x = new int[1];    //参照渡しにするため、要素１個で作る
int[] y = new int[1];    //参照渡しにするため、要素１個で作る
int g = extgcd(a, b, x, y);
System.out.println("g = " + g + ", x = " + x[0] + ", y = " + y[0]);
System.out.println(a + " * " + x[0] + " + " + b + " * " + y[0] + " = " + g);
int sum = a * x[0] + b * y[0];
System.out.println(sum == g);

int a = 4;    //入力
int b = 11;   //入力

int[] res = extgcd(a, b);
int g = res[0];
int x = res[1];
int y = res[2];

if (g != 1) {
    System.out.println(-1);
} else {
    String ans = "" + ((x >= 0) ? x : 0);
    ans += " " + ((y >= 0) ? y : 0);
    ans += " " + ((x < 0) ? -x : 0);
    ans += " " + ((y < 0) ? -y : 0);
    System.out.println(ans);    //答え
}