結果
| 問題 |
No.182 新規性の虜
|
| コンテスト | |
| ユーザー |
 Subaru Nitta
|
| 提出日時 | 2025-11-06 01:59:54 |
| 言語 | Java (openjdk 23) |
| 結果 |
AC
|
| 実行時間 | 129 ms / 5,000 ms |
| コード長 | 39,973 bytes |
| コンパイル時間 | 4,091 ms |
| コンパイル使用メモリ | 113,812 KB |
| 実行使用メモリ | 52,332 KB |
| 最終ジャッジ日時 | 2025-11-06 02:00:03 |
| 合計ジャッジ時間 | 7,987 ms |
|
ジャッジサーバーID （参考情報） |
judge4 / judge1 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 3 |
| other | AC * 27 |
ソースコード
import java.io.*;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.util.*;
import java.math.*;
import java.util.stream.*;
import java.util.function.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public final class Main {
private static void solve(final FastScanner sc, final FastPrinter out) {
int n = sc.nextInt();
HashMap<Integer, Integer> hm = new HashMap<>(n);
int count = n;
while (n-- > 0) {
int a = sc.nextInt();
Integer t = hm.get(a);
if (t != null) {
if (t == 1) {
count -= 2;
} else {
count--;
}
}
hm.put(a, hm.getOrDefault(a, 0) + 1);
}
out.println(count);
}
public static void main(String[] args) {
try (final FastScanner sc = new FastScanner();
final FastPrinter out = new FastPrinter()) {
solve(sc, out);
} catch (Exception e) {
e.printStackTrace();
}
}
@SuppressWarnings("unused")
private static final class FastScanner implements AutoCloseable {
private static final int DEFAULT_BUFFER_SIZE = 65536;
private final InputStream in;
private final byte[] buffer;
private int pos = 0, bufferLength = 0;
public FastScanner() {
this(System.in, DEFAULT_BUFFER_SIZE);
}
public FastScanner(final InputStream in) {
this(in, DEFAULT_BUFFER_SIZE);
}
public FastScanner(final int bufferSize) {
this(System.in, bufferSize);
}
public FastScanner(final InputStream in, final int bufferSize) {
this.in = in;
this.buffer = new byte[bufferSize];
}
private int skipSpaces() {
int b = read();
while (b <= 32) b = read();
return b;
}
@Override
public void close() throws IOException {
if (in != System.in) in.close();
}
private int read() {
if (pos >= bufferLength) {
try {
bufferLength = in.read(buffer, pos = 0, buffer.length);
} catch (IOException e) {
throw new RuntimeException(e);
}
if (bufferLength <= 0) throw new RuntimeException(new EOFException());
}
return buffer[pos++] & 0xFF;
}
public int peek() {
try {
int b = skipSpaces();
pos--;
return b;
} catch (RuntimeException e) {
return 0;
}
}
public boolean hasNext() {
return peek() != 0;
}
public int nextInt() {
int b = skipSpaces();
boolean negative = false;
if (b == '-') {
negative = true;
b = read();
}
int result = 0;
while ('0' <= b && b <= '9') {
result = (result << 3) + (result << 1) + (b & 15);
b = read();
}
return negative ? -result : result;
}
public long nextLong() {
int b = skipSpaces();
boolean negative = false;
if (b == '-') {
negative = true;
b = read();
}
long result = 0;
while ('0' <= b && b <= '9') {
result = (result << 3) + (result << 1) + (b & 15);
b = read();
}
return negative ? -result : result;
}
public double nextDouble() {
int b = skipSpaces();
boolean negative = false;
if (b == '-') {
negative = true;
b = read();
}
long intPart = 0;
while ('0' <= b && b <= '9') {
intPart = (intPart << 3) + (intPart << 1) + (b & 15);
b = read();
}
double result = intPart;
if (b == '.') {
b = read();
double scale = 0.1;
while ('0' <= b && b <= '9') {
result += (b & 15) * scale;
scale *= 0.1;
b = read();
}
}
return negative ? -result : result;
}
public char nextChar() {
int b = skipSpaces();
return (char) b;
}
public String next() {
return nextStringBuilder().toString();
}
public StringBuilder nextStringBuilder() {
final StringBuilder sb = new StringBuilder();
int b = skipSpaces();
while (b > 32) {
sb.append((char) b);
b = read();
}
return sb;
}
public String nextLine() {
final StringBuilder sb = new StringBuilder();
int b = read();
while (b != 0 && b != '\n' && b != '\r') {
sb.append((char) b);
b = read();
}
if (b == '\r') {
int c = read();
if (c != '\n') pos--;
}
return sb.toString();
}
public BigInteger nextBigInteger() {
return new BigInteger(next());
}
public BigDecimal nextBigDecimal() {
return new BigDecimal(next());
}
public int[] nextInt(final int n) {
final int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = nextInt();
return a;
}
public long[] nextLong(final int n) {
final long[] a = new long[n];
for (int i = 0; i < n; i++) a[i] = nextLong();
return a;
}
public double[] nextDouble(final int n) {
final double[] a = new double[n];
for (int i = 0; i < n; i++) a[i] = nextDouble();
return a;
}
public char[] nextChars() {
return next().toCharArray();
}
public char[] nextChars(final int n) {
final char[] c = new char[n];
for (int i = 0; i < n; i++) c[i] = nextChar();
return c;
}
public String[] nextStrings(final int n) {
final String[] s = new String[n];
for (int i = 0; i < n; i++) s[i] = next();
return s;
}
public int[][] nextIntMat(final int h, final int w) {
final int[][] a = new int[h][w];
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
a[i][j] = nextInt();
return a;
}
public long[][] nextLongMat(final int h, final int w) {
final long[][] a = new long[h][w];
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
a[i][j] = nextLong();
return a;
}
public double[][] nextDoubleMat(final int h, final int w) {
final double[][] a = new double[h][w];
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
a[i][j] = nextDouble();
return a;
}
public char[][] nextCharMat(final int n) {
final char[][] c = new char[n][];
for (int i = 0; i < n; i++) c[i] = nextChars();
return c;
}
public char[][] nextCharMat(final int h, final int w) {
final char[][] c = new char[h][w];
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
c[i][j] = nextChar();
return c;
}
public String[][] nextStringMat(final int h, final int w) {
final String[][] s = new String[h][w];
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
s[i][j] = next();
return s;
}
public int[][][] nextInt3D(final int x, final int y, final int z) {
final int[][][] a = new int[x][y][z];
for (int i = 0; i < x; i++)
for (int j = 0; j < y; j++)
for (int k = 0; k < z; k++)
a[i][j][k] = nextInt();
return a;
}
public long[][][] nextLong3D(final int x, final int y, final int z) {
final long[][][] a = new long[x][y][z];
for (int i = 0; i < x; i++)
for (int j = 0; j < y; j++)
for (int k = 0; k < z; k++)
a[i][j][k] = nextLong();
return a;
}
public int[] nextSortedInt(final int n) {
final int[] a = nextInt(n);
sort(a);
return a;
}
public long[] nextSortedLong(final int n) {
final long[] a = nextLong(n);
sort(a);
return a;
}
public double[] nextSortedDouble(final int n) {
final double[] a = nextDouble(n);
sort(a);
return a;
}
public char[] nextSortedChars() {
final char[] c = nextChars();
sort(c);
return c;
}
public char[] nextSortedChars(final int n) {
final char[] c = nextChars(n);
sort(c);
return c;
}
public String[] nextSortedStrings(final int n) {
final String[] s = nextStrings(n);
sort(s);
return s;
}
public int[] nextIntPrefixSum(final int n) {
final int[] ps = new int[n];
ps[0] = nextInt();
for (int i = 1; i < n; i++) ps[i] = nextInt() + ps[i - 1];
return ps;
}
public long[] nextLongPrefixSum(final int n) {
final long[] ps = new long[n];
ps[0] = nextLong();
for (int i = 1; i < n; i++) ps[i] = nextLong() + ps[i - 1];
return ps;
}
public int[][] nextIntPrefixSum(final int h, final int w) {
final int[][] ps = new int[h + 1][w + 1];
for (int i = 1; i <= h; i++)
for (int j = 1; j <= w; j++)
ps[i][j] = nextInt() + ps[i - 1][j] + ps[i][j - 1] - ps[i - 1][j - 1];
return ps;
}
public long[][] nextLongPrefixSum(final int h, final int w) {
final long[][] ps = new long[h + 1][w + 1];
for (int i = 1; i <= h; i++)
for (int j = 1; j <= w; j++)
ps[i][j] = nextLong() + ps[i - 1][j] + ps[i][j - 1] - ps[i - 1][j - 1];
return ps;
}
public int[][][] nextIntPrefixSum(final int x, final int y, final int z) {
final int[][][] ps = new int[x + 1][y + 1][z + 1];
for (int a = 1; a <= x; a++)
for (int b = 1; b <= y; b++)
for (int c = 1; c <= z; c++)
ps[a][b][c] = nextInt() + ps[a - 1][b][c] + ps[a][b - 1][c] + ps[a][b][c - 1] - ps[a - 1][b - 1][c]
- ps[a - 1][b][c - 1] - ps[a][b - 1][c - 1] + ps[a - 1][b - 1][c - 1];
return ps;
}
public long[][][] nextLongPrefixSum(final int x, final int y, final int z) {
final long[][][] ps = new long[x + 1][y + 1][z + 1];
for (int a = 1; a <= x; a++)
for (int b = 1; b <= y; b++)
for (int c = 1; c <= z; c++)
ps[a][b][c] = nextLong() + ps[a - 1][b][c] + ps[a][b - 1][c] + ps[a][b][c - 1] - ps[a - 1][b - 1][c]
- ps[a - 1][b][c - 1] - ps[a][b - 1][c - 1] + ps[a - 1][b - 1][c - 1];
return ps;
}
public int[] nextIntInverseMapping(final int n) {
final int[] inv = new int[n];
for (int i = 0; i < n; i++) inv[nextInt() - 1] = i;
return inv;
}
public ArrayList<Integer> nextIntAL(final int n) {
return nextCollection(n, this::nextInt, () -> new ArrayList<>(n));
}
public HashSet<Integer> nextIntHS(final int n) {
return nextCollection(n, this::nextInt, () -> new HashSet<>(n));
}
public TreeSet<Integer> nextIntTS(final int n) {
return nextCollection(n, this::nextInt, TreeSet::new);
}
public ArrayList<Long> nextLongAL(final int n) {
return nextCollection(n, this::nextLong, () -> new ArrayList<>(n));
}
public HashSet<Long> nextLongHS(final int n) {
return nextCollection(n, this::nextLong, () -> new HashSet<>(n));
}
public TreeSet<Long> nextLongTS(final int n) {
return nextCollection(n, this::nextLong, TreeSet::new);
}
public ArrayList<Character> nextCharacterAL(final int n) {
return nextCollection(n, this::nextChar, () -> new ArrayList<>(n));
}
public HashSet<Character> nextCharacterHS(final int n) {
return nextCollection(n, this::nextChar, () -> new HashSet<>(n));
}
public TreeSet<Character> nextCharacterTS(final int n) {
return nextCollection(n, this::nextChar, TreeSet::new);
}
public ArrayList<String> nextStringAL(final int n) {
return nextCollection(n, this::next, () -> new ArrayList<>(n));
}
public HashSet<String> nextStringHS(final int n) {
return nextCollection(n, this::next, () -> new HashSet<>(n));
}
public TreeSet<String> nextStringTS(final int n) {
return nextCollection(n, this::next, TreeSet::new);
}
private <S, T extends Collection<S>> T nextCollection(int n, final Supplier<S> input, final Supplier<T> collection) {
final T t = collection.get();
while (n-- > 0) t.add(input.get());
return t;
}
public HashMap<Integer, Integer> nextIntMultisetHM(final int n) {
return nextMultiset(n, this::nextInt, () -> new HashMap<>(n));
}
public TreeMap<Integer, Integer> nextIntMultisetTM(final int n) {
return nextMultiset(n, this::nextInt, TreeMap::new);
}
public HashMap<Long, Integer> nextLongMultisetHM(final int n) {
return nextMultiset(n, this::nextLong, () -> new HashMap<>(n));
}
public TreeMap<Long, Integer> nextLongMultisetTM(final int n) {
return nextMultiset(n, this::nextLong, TreeMap::new);
}
public HashMap<Character, Integer> nextCharMultisetHM(final int n) {
return nextMultiset(n, this::nextChar, () -> new HashMap<>(n));
}
public TreeMap<Character, Integer> nextCharMultisetTM(final int n) {
return nextMultiset(n, this::nextChar, TreeMap::new);
}
public HashMap<String, Integer> nextStringMultisetHM(final int n) {
return nextMultiset(n, this::next, () -> new HashMap<>(n));
}
public TreeMap<String, Integer> nextStringMultisetTM(final int n) {
return nextMultiset(n, this::next, TreeMap::new);
}
private <S, T extends Map<S, Integer>> T nextMultiset(int n, final Supplier<S> input, final Supplier<T> map) {
final T multiSet = map.get();
while (n-- > 0) {
final S i = input.get();
multiSet.put(i, multiSet.getOrDefault(i, 0) + 1);
}
return multiSet;
}
public int[] nextIntMultiset(final int n, final int m) {
final int[] multiset = new int[m];
for (int i = 0; i < n; i++) multiset[nextInt() - 1]++;
return multiset;
}
public int[] nextUpperCharMultiset(final int n) {
return nextCharMultiset(n, 'A', 'Z');
}
public int[] nextLowerCharMultiset(final int n) {
return nextCharMultiset(n, 'a', 'z');
}
public int[] nextCharMultiset(int n, final char l, final char r) {
final int[] multiset = new int[r - l + 1];
while (n-- > 0) {
final int c = nextChar() - l;
multiset[c]++;
}
return multiset;
}
}
@SuppressWarnings("unused")
private static final class FastPrinter implements AutoCloseable {
private static final VarHandle BYTE_ARRAY_HANDLE = MethodHandles.arrayElementVarHandle(byte[].class);
private static final int MAX_INT_DIGITS = 11;
private static final int MAX_LONG_DIGITS = 20;
private static final int DEFAULT_BUFFER_SIZE = 65536;
private static final byte LINE = (byte) '\n';
private static final byte SPACE = (byte) ' ';
private static final byte[] TRUE_BYTES = {'Y', 'e', 's'};
private static final byte[] FALSE_BYTES = {'N', 'o'};
private static final byte[] DigitOnes = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
};
private static final byte[] DigitTens = {
'0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
'1', '1', '1', '1', '1', '1', '1', '1', '1', '1',
'2', '2', '2', '2', '2', '2', '2', '2', '2', '2',
'3', '3', '3', '3', '3', '3', '3', '3', '3', '3',
'4', '4', '4', '4', '4', '4', '4', '4', '4', '4',
'5', '5', '5', '5', '5', '5', '5', '5', '5', '5',
'6', '6', '6', '6', '6', '6', '6', '6', '6', '6',
'7', '7', '7', '7', '7', '7', '7', '7', '7', '7',
'8', '8', '8', '8', '8', '8', '8', '8', '8', '8',
'9', '9', '9', '9', '9', '9', '9', '9', '9', '9',
};
private static final long[] POW10 = {
1, 10, 100, 1_000, 10_000, 100_000, 1_000_000, 10_000_000, 100_000_000,
1_000_000_000, 10_000_000_000L, 100_000_000_000L, 1_000_000_000_000L,
10_000_000_000_000L, 100_000_000_000_000L, 1_000_000_000_000_000L,
10_000_000_000_000_000L, 100_000_000_000_000_000L, 1_000_000_000_000_000_000L
};
private final OutputStream out;
private final boolean autoFlush;
private byte[] buffer;
private int pos = 0;
public FastPrinter() {
this(System.out, DEFAULT_BUFFER_SIZE, false);
}
public FastPrinter(final OutputStream out) {
this(out, DEFAULT_BUFFER_SIZE, false);
}
public FastPrinter(final int bufferSize) {
this(System.out, bufferSize, false);
}
public FastPrinter(final boolean autoFlush) {
this(System.out, DEFAULT_BUFFER_SIZE, autoFlush);
}
public FastPrinter(final OutputStream out, final boolean autoFlush) {
this(out, DEFAULT_BUFFER_SIZE, autoFlush);
}
public FastPrinter(final int bufferSize, final boolean autoFlush) {
this(System.out, bufferSize, autoFlush);
}
public FastPrinter(final OutputStream out, final int bufferSize) {
this(out, bufferSize, false);
}
public FastPrinter(final OutputStream out, final int bufferSize, final boolean autoFlush) {
this.out = out;
this.buffer = new byte[roundUpToPowerOfTwo(max(bufferSize, 64))];
this.autoFlush = autoFlush;
}
private static int countDigits(final int i) {
if (i > -100000) {
if (i > -100) {
return i > -10 ? 1 : 2;
} else {
if (i > -10000) return i > -1000 ? 3 : 4;
else return 5;
}
} else {
if (i > -10000000) {
return i > -1000000 ? 6 : 7;
} else {
if (i > -1000000000) return i > -100000000 ? 8 : 9;
else return 10;
}
}
}
private static int countDigits(final long l) {
if (l > -1000000000) {
if (l > -10000) {
if (l > -100) {
return l > -10 ? 1 : 2;
} else {
return l > -1000 ? 3 : 4;
}
} else {
if (l > -1000000) {
return l > -100000 ? 5 : 6;
} else {
if (l > -100000000) return l > -10000000 ? 7 : 8;
else return 9;
}
}
} else {
if (l > -10000000000000L) {
if (l > -100000000000L) {
return l > -10000000000L ? 10 : 11;
} else {
return l > -1000000000000L ? 12 : 13;
}
} else {
if (l > -10000000000000000L) {
if (l > -1000000000000000L) return l > -100000000000000L ? 14 : 15;
else return 16;
} else {
if (l > -1000000000000000000L) return l > -100000000000000000L ? 17 : 18;
else return 19;
}
}
}
}
private static int roundUpToPowerOfTwo(int x) {
if (x <= 1) return 1;
x--;
x |= x >>> 1;
x |= x >>> 2;
x |= x >>> 4;
x |= x >>> 8;
x |= x >>> 16;
return x + 1;
}
@Override
public void close() {
try {
flush();
if (out != System.out) out.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public void flush() {
try {
if (pos > 0) {
out.write(buffer, 0, pos);
pos = 0;
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public FastPrinter println() {
ensureCapacity(1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, LINE);
if (autoFlush) flush();
return this;
}
public FastPrinter println(final int i) {
ensureCapacity(MAX_INT_DIGITS + 1);
write(i);
BYTE_ARRAY_HANDLE.set(buffer, pos++, LINE);
if (autoFlush) flush();
return this;
}
public FastPrinter println(final long l) {
ensureCapacity(MAX_LONG_DIGITS + 1);
write(l);
BYTE_ARRAY_HANDLE.set(buffer, pos++, LINE);
if (autoFlush) flush();
return this;
}
public FastPrinter println(final double d) {
return println(Double.toString(d));
}
public FastPrinter println(final char c) {
ensureCapacity(2);
BYTE_ARRAY_HANDLE.set(buffer, pos++, (byte) c);
BYTE_ARRAY_HANDLE.set(buffer, pos++, LINE);
if (autoFlush) flush();
return this;
}
public FastPrinter println(final boolean b) {
write(b);
BYTE_ARRAY_HANDLE.set(buffer, pos++, LINE);
if (autoFlush) flush();
return this;
}
public FastPrinter println(final String s) {
write(s);
ensureCapacity(1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, LINE);
if (autoFlush) flush();
return this;
}
public FastPrinter println(final StringBuilder s) {
write(s.toString());
ensureCapacity(1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, LINE);
if (autoFlush) flush();
return this;
}
public FastPrinter println(final Object o) {
return switch (o) {
case null -> this;
case String s -> println(s);
case Long l -> println(l.longValue());
case Integer i -> println(i.intValue());
case Double d -> println(d.toString());
case Boolean b -> println(b.booleanValue());
case Character c -> println(c.charValue());
case int[] arr -> println(arr);
case long[] arr -> println(arr);
case double[] arr -> println(arr);
case boolean[] arr -> println(arr);
case char[] arr -> println(arr);
case String[] arr -> println(arr);
case Object[] arr -> println(arr);
default -> println(o.toString());
};
}
public FastPrinter println(final BigInteger bi) {
return println(bi.toString());
}
public FastPrinter println(final BigDecimal bd) {
return println(bd.toString());
}
public FastPrinter print(final int i) {
ensureCapacity(MAX_INT_DIGITS);
write(i);
if (autoFlush) flush();
return this;
}
public FastPrinter print(final long l) {
ensureCapacity(MAX_LONG_DIGITS);
write(l);
if (autoFlush) flush();
return this;
}
public FastPrinter print(final double d) {
return print(Double.toString(d));
}
public FastPrinter print(final char c) {
ensureCapacity(1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, (byte) c);
if (autoFlush) flush();
return this;
}
public FastPrinter print(final boolean b) {
write(b);
if (autoFlush) flush();
return this;
}
public FastPrinter print(final String s) {
write(s);
if (autoFlush) flush();
return this;
}
public FastPrinter print(final StringBuilder s) {
write(s.toString());
if (autoFlush) flush();
return this;
}
public FastPrinter print(final Object o) {
return switch (o) {
case null -> this;
case String s -> print(s);
case Long l -> print(l.longValue());
case Integer i -> print(i.intValue());
case Double d -> print(d.toString());
case Boolean b -> print(b.booleanValue());
case Character c -> print(c.charValue());
case int[] arr -> print(arr);
case long[] arr -> print(arr);
case double[] arr -> print(arr);
case boolean[] arr -> print(arr);
case char[] arr -> print(arr);
case String[] arr -> print(arr);
case Object[] arr -> print(arr);
default -> print(o.toString());
};
}
public FastPrinter print(final BigInteger bi) {
return print(bi.toString());
}
public FastPrinter print(final BigDecimal bd) {
return print(bd.toString());
}
public FastPrinter printf(final String format, final Object... args) {
return print(String.format(format, args));
}
public FastPrinter printf(final Locale locale, final String format, final Object... args) {
return print(String.format(locale, format, args));
}
private void ensureCapacity(final int additional) {
final int required = pos + additional;
if (required <= buffer.length) return;
buffer = Arrays.copyOf(buffer, roundUpToPowerOfTwo(required));
}
private void write(final String s) {
final int len = s.length();
ensureCapacity(len);
final byte[] buf = buffer;
int p = pos, i = 0;
final int limit = len & ~7;
while (i < limit) {
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) s.charAt(i++));
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) s.charAt(i++));
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) s.charAt(i++));
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) s.charAt(i++));
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) s.charAt(i++));
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) s.charAt(i++));
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) s.charAt(i++));
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) s.charAt(i++));
}
while (i < len) BYTE_ARRAY_HANDLE.set(buf, p++, (byte) s.charAt(i++));
pos = p;
}
private void write(final boolean b) {
final byte[] src = b ? TRUE_BYTES : FALSE_BYTES;
final int len = src.length;
ensureCapacity(len);
System.arraycopy(src, 0, buffer, pos, len);
pos += len;
}
private void write(int i) {
final byte[] buf = buffer;
int p = pos;
if (i >= 0) i = -i;
else BYTE_ARRAY_HANDLE.set(buf, p++, (byte) '-');
final int digits = countDigits(i);
int writePos = p + digits;
while (i <= -100) {
final int q = i / 100;
final int r = (q << 6) + (q << 5) + (q << 2) - i;
BYTE_ARRAY_HANDLE.set(buf, --writePos, DigitOnes[r]);
BYTE_ARRAY_HANDLE.set(buf, --writePos, DigitTens[r]);
i = q;
}
final int r = -i;
BYTE_ARRAY_HANDLE.set(buf, --writePos, DigitOnes[r]);
if (r >= 10) BYTE_ARRAY_HANDLE.set(buf, --writePos, DigitTens[r]);
pos = p + digits;
}
private void write(long l) {
final byte[] buf = buffer;
int p = pos;
if (l >= 0) l = -l;
else BYTE_ARRAY_HANDLE.set(buf, p++, (byte) '-');
final int digits = countDigits(l);
int writePos = p + digits;
while (l <= -100) {
final long q = l / 100;
final int r = (int) ((q << 6) + (q << 5) + (q << 2) - l);
BYTE_ARRAY_HANDLE.set(buf, --writePos, DigitOnes[r]);
BYTE_ARRAY_HANDLE.set(buf, --writePos, DigitTens[r]);
l = q;
}
final int r = (int) -l;
BYTE_ARRAY_HANDLE.set(buf, --writePos, DigitOnes[r]);
if (r >= 10) BYTE_ARRAY_HANDLE.set(buf, --writePos, DigitTens[r]);
pos = p + digits;
}
public FastPrinter println(final int a, final int b) {
return println(a, b, LINE);
}
public FastPrinter println(final int a, final long b) {
return println(a, b, LINE);
}
public FastPrinter println(final long a, final int b) {
return println(a, b, LINE);
}
public FastPrinter println(final long a, final long b) {
return println(a, b, LINE);
}
public FastPrinter println(final long a, final long b, final byte delimiter) {
ensureCapacity((MAX_LONG_DIGITS << 1) + 2);
write(a);
BYTE_ARRAY_HANDLE.set(buffer, pos++, delimiter);
write(b);
BYTE_ARRAY_HANDLE.set(buffer, pos++, LINE);
if (autoFlush) flush();
return this;
}
public FastPrinter print(final int a, final int b) {
return print(a, b, SPACE);
}
public FastPrinter print(final int a, final long b) {
return print(a, b, SPACE);
}
public FastPrinter print(final long a, final int b) {
return print(a, b, SPACE);
}
public FastPrinter print(final long a, final long b) {
return print(a, b, SPACE);
}
public FastPrinter print(final long a, final long b, final byte delimiter) {
ensureCapacity((MAX_LONG_DIGITS << 1) + 1);
write(a);
BYTE_ARRAY_HANDLE.set(buffer, pos++, delimiter);
write(b);
if (autoFlush) flush();
return this;
}
public FastPrinter println(final double d, final int n) {
return print(d, n).println();
}
public FastPrinter print(double d, int n) {
if (n <= 0) return print(round(d));
if (d < 0) {
ensureCapacity(1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, (byte) '-');
d = -d;
}
if (n > 18) n = 18;
final long intPart = (long) d;
final long fracPart = (long) ((d - intPart) * POW10[n]);
print(intPart);
int leadingZeros = n - countDigits(-fracPart);
ensureCapacity(leadingZeros + 1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, (byte) '.');
while (leadingZeros-- > 0) BYTE_ARRAY_HANDLE.set(buffer, pos++, (byte) '0');
print(fracPart);
return this;
}
public FastPrinter println(final int[] arr) {
return println(arr, LINE);
}
public FastPrinter println(final long[] arr) {
return println(arr, LINE);
}
public FastPrinter println(final double[] arr) {
return println(arr, LINE);
}
public FastPrinter println(final char[] arr) {
return println(arr, LINE);
}
public FastPrinter println(final boolean[] arr) {
return println(arr, LINE);
}
public FastPrinter println(final String[] arr) {
return println(arr, LINE);
}
public FastPrinter println(final Object... arr) {
for (final Object o : arr) println(o);
return this;
}
public FastPrinter println(final int[] arr, final byte delimiter) {
return print(arr, delimiter).println();
}
public FastPrinter println(final long[] arr, final byte delimiter) {
return print(arr, delimiter).println();
}
public FastPrinter println(final double[] arr, final byte delimiter) {
return print(arr, delimiter).println();
}
public FastPrinter println(final char[] arr, final byte delimiter) {
return print(arr, delimiter).println();
}
public FastPrinter println(final boolean[] arr, final byte delimiter) {
return print(arr, delimiter).println();
}
public FastPrinter println(final String[] arr, final byte delimiter) {
return print(arr, delimiter).println();
}
public FastPrinter print(final int[] arr) {
return print(arr, SPACE);
}
public FastPrinter print(final long[] arr) {
return print(arr, SPACE);
}
public FastPrinter print(final double[] arr) {
return print(arr, SPACE);
}
public FastPrinter print(final char[] arr) {
return print(arr, SPACE);
}
public FastPrinter print(final boolean[] arr) {
return print(arr, SPACE);
}
public FastPrinter print(final String[] arr) {
return print(arr, SPACE);
}
public FastPrinter print(final Object... arr) {
final int len = arr.length;
if (len > 0) print(arr[0]);
for (int i = 1; i < len; i++) {
ensureCapacity(1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, (byte) ' ');
print(arr[i]);
}
return this;
}
public FastPrinter print(final int[] arr, final byte delimiter) {
final int len = arr.length;
if (len > 0) print(arr[0]);
for (int i = 1; i < len; i++) {
ensureCapacity(MAX_INT_DIGITS + 1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, delimiter);
write(arr[i]);
}
if (autoFlush) flush();
return this;
}
public FastPrinter print(final long[] arr, final byte delimiter) {
final int len = arr.length;
if (len > 0) print(arr[0]);
for (int i = 1; i < len; i++) {
ensureCapacity(MAX_LONG_DIGITS + 1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, delimiter);
write(arr[i]);
}
if (autoFlush) flush();
return this;
}
public FastPrinter print(final double[] arr, final byte delimiter) {
final int len = arr.length;
if (len > 0) print(arr[0], 16);
for (int i = 1; i < len; i++) {
ensureCapacity(1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, delimiter);
print(arr[i], 16);
}
if (autoFlush) flush();
return this;
}
public FastPrinter print(final char[] arr, final byte delimiter) {
final int len = arr.length;
if (len > 0) print(arr[0]);
int i = 1;
while (i < len) {
ensureCapacity(2);
final int BUFFER_SIZE = buffer.length;
int limit = min((BUFFER_SIZE - pos) >> 1, len - i);
while (limit-- > 0) {
BYTE_ARRAY_HANDLE.set(buffer, pos++, delimiter);
BYTE_ARRAY_HANDLE.set(buffer, pos++, (byte) arr[i++]);
}
}
if (autoFlush) flush();
return this;
}
public FastPrinter print(final boolean[] arr, final byte delimiter) {
final int len = arr.length;
if (len > 0) print(arr[0]);
for (int i = 1; i < len; i++) {
ensureCapacity(4);
BYTE_ARRAY_HANDLE.set(buffer, pos++, delimiter);
write(arr[i]);
}
if (autoFlush) flush();
return this;
}
public FastPrinter print(final String[] arr, final byte delimiter) {
final int len = arr.length;
if (len > 0) print(arr[0]);
for (int i = 1; i < len; i++) print(delimiter).print(arr[i]);
return this;
}
public <T> FastPrinter println(final int[] arr, final IntFunction<T> function) {
for (final int i : arr) println(function.apply(i));
return this;
}
public <T> FastPrinter println(final long[] arr, final LongFunction<T> function) {
for (final long l : arr) println(function.apply(l));
return this;
}
public <T> FastPrinter println(final double[] arr, final DoubleFunction<T> function) {
for (final double l : arr) println(function.apply(l));
return this;
}
public <T> FastPrinter println(final char[] arr, final IntFunction<T> function) {
for (final char c : arr) println(function.apply(c));
return this;
}
public <T> FastPrinter println(final boolean[] arr, final Function<Boolean, T> function) {
for (final boolean b : arr) println(function.apply(b));
return this;
}
public <T> FastPrinter println(final String[] arr, final Function<String, T> function) {
for (final String s : arr) println(function.apply(s));
return this;
}
public <T> FastPrinter print(final int[] arr, final IntFunction<T> function) {
final int len = arr.length;
if (len > 0) print(function.apply(arr[0]));
for (int i = 1; i < len; i++) {
ensureCapacity(1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, SPACE);
print(function.apply(arr[i]));
}
return this;
}
public <T> FastPrinter print(final long[] arr, final LongFunction<T> function) {
final int len = arr.length;
if (len > 0) print(function.apply(arr[0]));
for (int i = 1; i < len; i++) {
ensureCapacity(1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, SPACE);
print(function.apply(arr[i]));
}
return this;
}
public <T> FastPrinter print(final double[] arr, final DoubleFunction<T> function) {
final int len = arr.length;
if (len > 0) print(function.apply(arr[0]));
for (int i = 1; i < len; i++) {
ensureCapacity(1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, SPACE);
print(function.apply(arr[i]));
}
return this;
}
public <T> FastPrinter print(final char[] arr, final IntFunction<T> function) {
final int len = arr.length;
if (len > 0) print(function.apply(arr[0]));
for (int i = 1; i < len; i++) {
ensureCapacity(1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, SPACE);
print(function.apply(arr[i]));
}
return this;
}
public <T> FastPrinter print(final boolean[] arr, final Function<Boolean, T> function) {
final int len = arr.length;
if (len > 0) print(function.apply(arr[0]));
for (int i = 1; i < len; i++) {
ensureCapacity(1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, SPACE);
print(function.apply(arr[i]));
}
return this;
}
public <T> FastPrinter print(final String[] arr, final Function<String, T> function) {
final int len = arr.length;
if (len > 0) print(function.apply(arr[0]));
for (int i = 1; i < len; i++) {
ensureCapacity(1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, SPACE);
print(function.apply(arr[i]));
}
return this;
}
public FastPrinter println(final int[][] arr2d) {
return println(arr2d, SPACE);
}
public FastPrinter println(final long[][] arr2d) {
return println(arr2d, SPACE);
}
public FastPrinter println(final double[][] arr2d) {
return println(arr2d, SPACE);
}
public FastPrinter println(final char[][] arr2d) {
return println(arr2d, SPACE);
}
public FastPrinter println(final boolean[][] arr2d) {
return println(arr2d, SPACE);
}
public FastPrinter println(final String[][] arr2d) {
return println(arr2d, SPACE);
}
public FastPrinter println(final Object[][] arr2d) {
return println(arr2d, SPACE);
}
public FastPrinter println(final int[][] arr2d, final byte delimiter) {
for (final int[] arr : arr2d) println(arr, delimiter);
return this;
}
public FastPrinter println(final long[][] arr2d, final byte delimiter) {
for (final long[] arr : arr2d) println(arr, delimiter);
return this;
}
public FastPrinter println(final double[][] arr2d, final byte delimiter) {
for (final double[] arr : arr2d) println(arr, delimiter);
return this;
}
public FastPrinter println(final char[][] arr2d, final byte delimiter) {
for (final char[] arr : arr2d) println(arr, delimiter);
return this;
}
public FastPrinter println(final boolean[][] arr2d, final byte delimiter) {
for (final boolean[] arr : arr2d) println(arr, delimiter);
return this;
}
public FastPrinter println(final String[][] arr2d, final byte delimiter) {
for (final String[] arr : arr2d) println(arr, delimiter);
return this;
}
public FastPrinter println(final Object[][] arr2d, final byte delimiter) {
for (final Object[] arr : arr2d) {
final int len = arr.length;
if (len > 0) print(arr[0]);
for (int i = 1; i < len; i++) {
ensureCapacity(1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, delimiter);
print(arr[i]);
}
println();
}
return this;
}
public <T> FastPrinter println(final int[][] arr2d, final IntFunction<T> function) {
for (final int[] arr : arr2d) print(arr, function).println();
return this;
}
public <T> FastPrinter println(final long[][] arr2d, final LongFunction<T> function) {
for (final long[] arr : arr2d) print(arr, function).println();
return this;
}
public <T> FastPrinter println(final double[][] arr2d, final DoubleFunction<T> function) {
for (final double[] arr : arr2d) print(arr, function).println();
return this;
}
public <T> FastPrinter println(final char[][] arr2d, final IntFunction<T> function) {
for (final char[] arr : arr2d) print(arr, function).println();
return this;
}
public <T> FastPrinter println(final boolean[][] arr2d, final Function<Boolean, T> function) {
for (final boolean[] arr : arr2d) print(arr, function).println();
return this;
}
public <T> FastPrinter println(final String[][] arr2d, final Function<String, T> function) {
for (final String[] arr : arr2d) print(arr, function).println();
return this;
}
public FastPrinter printChars(final char[] arr) {
final int len = arr.length;
ensureCapacity(len);
final byte[] buf = buffer;
int p = pos, i = 0;
final int limit8 = len & ~7;
while (i < limit8) {
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) arr[i++]);
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) arr[i++]);
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) arr[i++]);
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) arr[i++]);
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) arr[i++]);
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) arr[i++]);
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) arr[i++]);
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) arr[i++]);
}
while (i < len) BYTE_ARRAY_HANDLE.set(buf, p++, (byte) arr[i++]);
pos = p;
if (autoFlush) flush();
return this;
}
public FastPrinter printChars(final char[] arr, final IntUnaryOperator function) {
final int len = arr.length;
ensureCapacity(len);
final byte[] buf = buffer;
int p = pos, i = 0;
final int limit = len & ~7;
while (i < limit) {
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) function.applyAsInt(arr[i++]));
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) function.applyAsInt(arr[i++]));
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) function.applyAsInt(arr[i++]));
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) function.applyAsInt(arr[i++]));
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) function.applyAsInt(arr[i++]));
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) function.applyAsInt(arr[i++]));
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) function.applyAsInt(arr[i++]));
BYTE_ARRAY_HANDLE.set(buf, p++, (byte) function.applyAsInt(arr[i++]));
}
while (i < len) BYTE_ARRAY_HANDLE.set(buf, p++, (byte) function.applyAsInt(arr[i++]));
pos = p;
if (autoFlush) flush();
return this;
}
public FastPrinter printChars(final char[][] arr2d) {
for (final char[] arr : arr2d) printChars(arr).println();
return this;
}
public FastPrinter printChars(final char[][] arr2d, final IntUnaryOperator function) {
for (final char[] arr : arr2d) printChars(arr, function).println();
return this;
}
public <T> FastPrinter println(final Iterable<T> iter) {
return print(iter, LINE).println();
}
public <T> FastPrinter println(final Iterable<T> iter, final byte delimiter) {
return print(iter, delimiter).println();
}
public <T, U> FastPrinter println(final Iterable<T> iter, final Function<T, U> function) {
return print(iter, function, LINE).println();
}
public <T> FastPrinter print(final Iterable<T> iter) {
return print(iter, SPACE);
}
public <T> FastPrinter print(final Iterable<T> iter, final byte delimiter) {
final Iterator<T> it = iter.iterator();
if (it.hasNext()) print(it.next());
while (it.hasNext()) {
ensureCapacity(1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, delimiter);
print(it.next());
}
return this;
}
public <T, U> FastPrinter print(final Iterable<T> iter, final Function<T, U> function) {
return print(iter, function, SPACE);
}
public <T, U> FastPrinter print(final Iterable<T> iter, final Function<T, U> function, final byte delimiter) {
final Iterator<T> it = iter.iterator();
if (it.hasNext()) print(function.apply(it.next()));
while (it.hasNext()) {
ensureCapacity(1);
BYTE_ARRAY_HANDLE.set(buffer, pos++, delimiter);
print(function.apply(it.next()));
}
return this;
}
}
}