Go to Qiita Advent Calendar 2024 Top
LoginSignup
2
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

@NAVYSHUNTA(Shunta Nakamura)

競プロ用のチートシート（Java）

Last updated at Posted at 2024-03-16

はじめに

競プロで使う Java のチートシートを載せています。

標準入力

記号は次の意味で使い分けています。
整数：$N, M, A_i, B_i, H, W$
文字列：$S, T, S_i$

コメントで記載されている部分に入るコードのチートシートになります。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // ここの部分を載せています
    }
}

標準入力が int 型の場合

$N$

int n = sc.nextInt();

$N$ $M$

int n = sc.nextInt();
int m = sc.nextInt();

$N$
$A_1$ $A_2$ $\dots$ $A_N$

int n = sc.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i++) {
    a[i] = sc.nextInt();
}

$N$
$A_1$
$A_2$
$\vdots$
$A_N$

int n = sc.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i++) {
    a[i] = sc.nextInt();
}

$N$
$A_1$ $B_1$
$A_2$ $B_2$
$\vdots$
$A_N$ $B_N$

int n = sc.nextInt();
int[] a = new int[n];
int[] b = new int[n];
for (int i = 0; i < n; i++) {
    a[i] = sc.nextInt();
    b[i] = sc.nextInt();
}

$H$ $W$
$A_{1,1}$ $A_{1,2}$ $\dots$ $A_{1,W}$
$A_{2,1}$ $A_{2,2}$ $\dots$ $A_{2,W}$
$\vdots$
$A_{H,1}$ $A_{H,2}$ $\dots$ $A_{H,W}$

int h = sc.nextInt();
int w = sc.nextInt();
int[][] a = new int[h][w];
for (int i = 0; i < h; i++) {
    for (int j = 0; j < w; j++) {
        a[i][j] = sc.nextInt();
    }
}

標準入力が long 型の場合

$N$

long n = sc.nextLong();

$N$ $M$

long n = sc.nextLong();
long m = sc.nextLong();

$N$
$A_1$ $A_2$ $\dots$ $A_N$

int n = sc.nextInt();
long[] a = new long[n];
for (int i = 0; i < n; i++) {
    a[i] = sc.nextLong();
}

$N$
$A_1$
$A_2$
$\vdots$
$A_N$

int n = sc.nextInt();
long[] a = new long[n];
for (int i = 0; i < n; i++) {
    a[i] = sc.nextLong();
}

$N$
$A_1$ $B_1$
$A_2$ $B_2$
$\vdots$
$A_N$ $B_N$

int n = sc.nextInt();
long[] a = new long[n];
long[] b = new long[n];
for (int i = 0; i < n; i++) {
    a[i] = sc.nextLong();
    b[i] = sc.nextLong();
}

$H$ $W$
$A_{1,1}$ $A_{1,2}$ $\dots$ $A_{1,W}$
$A_{2,1}$ $A_{2,2}$ $\dots$ $A_{2,W}$
$\vdots$
$A_{H,1}$ $A_{H,2}$ $\dots$ $A_{H,W}$

int h = sc.nextInt();
int w = sc.nextInt();
long[][] a = new long[h][w];
for (int i = 0; i < h; i++) {
    for (int j = 0; j < w; j++) {
        a[i][j] = sc.nextLong();
    }
}

標準入力が文字列の場合

$S$

String s = sc.next();

$S$ $T$

String s = sc.next();
String t = sc.next();

$N$
$S_1$
$S_2$
$\vdots$
$S_N$

int n = sc.nextInt();
String[] s = new String[n];
for (int i = 0; i < n; i++) {
    s[i] = sc.next();
}

型変換

記号は次の意味で使い分けています。
$\text{int}$ 型の整数：$N_{\text{int}}$
$\text{long}$ 型の整数：$N_{\text{long}}$
文字：$C$
文字列：$S$
$\text{int}$ 型の整数の配列：$L_{N_\text{int}}$
$\text{long}$ 型の整数の配列：$L_{N_\text{long}}$
文字の配列：$L_C$
文字列の配列：$L_S$

型変換は期待通りの結果にならない場合があります。
例えば、 $S$ $\rightarrow$ $C$ では、文字列 $S$ の長さが $1$ 以外の場合は期待通りの結果になりません。
他にも、 $N_{\text{long}}$ $\rightarrow$ $N_{\text{int}}$ では、 $N_{\text{long}}$ の値が $32\, \text{bit}$ 整数型に収まらない場合は型変換を行うとオーバーフローします。

$N_{\text{int}}$ $\rightarrow$ $N_{\text{long}}$ $(\ \text{int}\ \rightarrow \text{long}\ )$

long n_long = n_int;

$N_{\text{long}}$ $\rightarrow$ $N_{\text{int}}$ $(\ \text{long}\ \rightarrow \text{int}\ )$

int n_int = (int) n_long;

$N_{\text{int}}$ $\rightarrow$ $C$ $(\ \text{int}\ \rightarrow \text{char}\ )$

char c = (char) n_int;

$N_{\text{long}}$ $\rightarrow$ $C$ $(\ \text{long}\ \rightarrow \text{char}\ )$

char c = (char) n_long;

$N_{\text{int}}$ $\rightarrow$ $S$ $(\ \text{int}\ \rightarrow \text{String}\ )$

String s = String.valueOf(n_int);

$N_{\text{long}}$ $\rightarrow$ $S$ $(\ \text{long}\ \rightarrow \text{String}\ )$

String s = String.valueOf(n_long);

$N_{\text{int}}$ $\rightarrow$ $L_{N_\text{int}}$ $(\ \text{int}\ \rightarrow \text{int [ ]}\ )$

char[] l_c = String.valueOf(n_int).toCharArray();
int[] l_n_int = new int[l_c.length];
for (int i = 0; i < l_c.length; i++) {
    l_n_int[i] = l_c[i] - '0';
}

$N_{\text{long}}$ $\rightarrow$ $L_{N_\text{long}}$ $(\ \text{long}\ \rightarrow \text{long [ ]}\ )$

char[] l_c = String.valueOf(n_long).toCharArray();
long[] l_n_long = new long[l_c.length];
for (int i = 0; i < l_c.length; i++) {
    l_n_long[i] = l_c[i] - '0';
}

$N_{\text{int}}$ $\rightarrow$ $L_C$ $(\ \text{int}\ \rightarrow \text{char [ ]}\ )$

char[] l_c = String.valueOf(n_int).toCharArray();

$N_{\text{long}}$ $\rightarrow$ $L_C$ $(\ \text{long}\ \rightarrow \text{char [ ]}\ )$

char[] l_c = String.valueOf(n_long).toCharArray();

$N_{\text{int}}$ $\rightarrow$ $L_S$ $(\ \text{int}\ \rightarrow \text{String [ ]}\ )$

String[] l_s = String.valueOf(n_int).split("");

$N_{\text{long}}$ $\rightarrow$ $L_S$ $(\ \text{long}\ \rightarrow \text{String [ ]}\ )$

String[] l_s = String.valueOf(n_long).split("");

$C$ $\rightarrow$ $N_{\text{int}}$ $(\ \text{char}\ \rightarrow \text{int}\ )$

int n_int = c;

$C$ $\rightarrow$ $N_{\text{long}}$ $(\ \text{char}\ \rightarrow \text{long}\ )$

long n_long = c;

$C$ $\rightarrow$ $S$ $(\ \text{char}\ \rightarrow \text{String}\ )$

String s = String.valueOf(c);

$S$ $\rightarrow$ $N_{\text{int}}$ $(\ \text{String}\ \rightarrow \text{int}\ )$

int n_int = Integer.parseInt(s);

$S$ $\rightarrow$ $N_{\text{long}}$ $(\ \text{String}\ \rightarrow \text{long}\ )$

long n_long = Long.parseLong(s);

$S$ $\rightarrow$ $C$ $(\ \text{String}\ \rightarrow \text{char}\ )$

char c = s.charAt(0);

$S$ $\rightarrow$ $L_{N_\text{int}}$ $(\ \text{String}\ \rightarrow \text{int [ ]}\ )$

int[] l_n_int = new int[s.length()];
for (int i = 0; i < s.length(); i++) {
    l_n_int[i] = s.charAt(i) - '0';
}

$S$ $\rightarrow$ $L_{N_\text{long}}$ $(\ \text{String}\ \rightarrow \text{long [ ]}\ )$

long[] l_n_long = new long[s.length()];
for (int i = 0; i < s.length(); i++) {
    l_n_long[i] = s.charAt(i) - '0';
}

$S$ $\rightarrow$ $L_C$ $(\ \text{String}\ \rightarrow \text{char [ ]}\ )$

char[] c = s.toCharArray();

$S$ $\rightarrow$ $L_S$ $(\ \text{String}\ \rightarrow \text{String [ ]}\ )$

String[] l_s = s.split("");

$L_{N_\text{int}}$ $\rightarrow$ $N_\text{int}$ $(\ \text{int [ ]}\ \rightarrow \text{int}\ )$

String s = "";
for (int i = 0; i < l_n_int.length; i++) {
    s += l_n_int[i];
}
int n_int = Integer.parseInt(s);

$L_{N_\text{long}}$ $\rightarrow$ $N_\text{long}$ $(\ \text{long [ ]}\ \rightarrow \text{long}\ )$

String s = "";
for (int i = 0; i < l_n_long.length; i++) {
    s += l_n_long[i];
}
long n_long = Long.parseLong(s);

$L_{N_\text{int}}$ $\rightarrow$ $S$ $(\ \text{int [ ]}\ \rightarrow \text{String}\ )$

String s = "";
for (int i = 0; i < l_n_int.length; i++) {
    s += l_n_int[i];
}

$L_{N_\text{long}}$ $\rightarrow$ $S$ $(\ \text{long [ ]}\ \rightarrow \text{String}\ )$

String s = "";
for (int i = 0; i < l_n_long.length; i++) {
    s += l_n_long[i];
}

$L_{N_\text{int}}$ $\rightarrow$ $L_C$ $(\ \text{int [ ]}\ \rightarrow \text{char [ ]}\ )$

char[] l_c = new char[l_n_int.length];
for (int i = 0; i < l_n_int.length; i++) {
    l_c[i] = (char) (l_n_int[i]);
}

$L_{N_\text{long}}$ $\rightarrow$ $L_C$ $(\ \text{long [ ]}\ \rightarrow \text{char [ ]}\ )$

char[] l_c = new char[l_n_long.length];
for (int i = 0; i < l_n_long.length; i++) {
    l_c[i] = (char) (l_n_long[i]);
}

$L_{N_\text{int}}$ $\rightarrow$ $L_S$ $(\ \text{int [ ]}\ \rightarrow \text{String [ ]}\ )$

String[] l_s = new String[l_n_int.length];
for (int i = 0; i < l_n_int.length; i++) {
    l_s[i] = String.valueOf(l_n_int[i]);
}

$L_{N_\text{long}}$ $\rightarrow$ $L_S$ $(\ \text{long [ ]}\ \rightarrow \text{String [ ]}\ )$

String[] l_s = new String[l_n_long.length];
for (int i = 0; i < l_n_long.length; i++) {
    l_s[i] = String.valueOf(l_n_long[i]);
}

$L_C$ $\rightarrow$ $S$ $(\ \text{char [ ]}\ \rightarrow \text{String}\ )$

String s = new String(l_c);

$L_C$ $\rightarrow$ $L_{N_\text{int}}$ $(\ \text{char [ ]}\ \rightarrow \text{int [ ]}\ )$

int[] l_n_int = new int[l_c.length];
for (int i = 0; i < l_c.length; i++) {
    l_n_int[i] = l_c[i] - '0';
}

$L_C$ $\rightarrow$ $L_{N_\text{long}}$ $(\ \text{char [ ]}\ \rightarrow \text{long [ ]}\ )$

long[] l_n_long = new long[l_c.length];
for (int i = 0; i < l_c.length; i++) {
    l_n_long[i] = l_c[i] - '0';
}

$L_C$ $\rightarrow$ $L_S$ $(\ \text{char [ ]}\ \rightarrow \text{String [ ]}\ )$

String[] l_s = new String[l_c.length];
for (int i = 0; i < l_c.length; i++) {
    l_s[i] = String.valueOf(l_c[i]);
}

$L_S$ $\rightarrow$ $N_\text{int}$ $(\ \text{String [ ]}\ \rightarrow \text{int}\ )$

int n_int = Integer.parseInt(String.join("", l_s));

$L_S$ $\rightarrow$ $N_\text{long}$ $(\ \text{String [ ]}\ \rightarrow \text{long}\ )$

long n_long = Long.parseLong(String.join("", l_s));

$L_S$ $\rightarrow$ $S$ $(\ \text{String [ ]}\ \rightarrow \text{String}\ )$

String s = String.join("", l_s);

$L_S$ $\rightarrow$ $L_{N_\text{int}}$ $(\ \text{String [ ]}\ \rightarrow \text{int [ ]}\ )$

int[] l_n_int = new int[l_s.length];
for (int i = 0; i < l_s.length; i++) {
    l_n_int[i] = Integer.parseInt(l_s[i]);
}

$L_S$ $\rightarrow$ $L_{N_\text{long}}$ $(\ \text{String [ ]}\ \rightarrow \text{long [ ]}\ )$

long[] l_n_long = new long[l_s.length];
for (int i = 0; i < l_s.length; i++) {
    l_n_long[i] = Long.parseLong(l_s[i]);
}

$L_S$ $\rightarrow$ $L_C$ $(\ \text{String [ ]}\ \rightarrow \text{char [ ]}\ )$

char[] l_c = new char[l_s.length];
for (int i = 0; i < l_s.length; i++) {
    l_c[i] = l_s[i].charAt(0);
}
2
0
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
Sign upLogin
2
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?