結果
| 問題 | No.2599 Summer Project |
| ユーザー |
 Asahi
|
| 提出日時 | 2024-01-18 21:30:03 |
| 言語 | Java21 (openjdk 21) |
| 結果 |
AC
|
| 実行時間 | 120 ms / 2,000 ms |
| コード長 | 27,604 bytes |
| コンパイル時間 | 3,671 ms |
| コンパイル使用メモリ | 98,776 KB |
| 実行使用メモリ | 57,804 KB |
| 最終ジャッジ日時 | 2024-01-18 21:30:09 |
| 合計ジャッジ時間 | 5,521 ms |
|
ジャッジサーバーID （参考情報） |
judge11 / judge14 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 113 ms
57,312 KB |
| testcase_01 | AC | 115 ms
57,064 KB |
| testcase_02 | AC | 120 ms
57,804 KB |
| testcase_03 | AC | 112 ms
56,932 KB |
| testcase_04 | AC | 117 ms
57,688 KB |
| testcase_05 | AC | 109 ms
57,056 KB |
ソースコード
import java.util.*;
import java.io.*;
import java.math.*;
import java.util.stream.*;
import java.util.function.*;
class Main implements Runnable {
public void solve() {
String s = in.next() , t = in.next();
Set<Character> set = new HashSet<>();
set.add(s.charAt(0));
set.add(t.charAt(0));
if(!set.contains('b')) out.print("beachball");
else if(!set.contains('w')) out.print("watermelon");
else out.print("shrinebell");
}
// ===============================================================================================================
// ===============================================================================================================
public PrintWriter out = new PrintWriter(System.out);
public In in = new In() ;
public static final int inf = (1 << 30);
public static final long lnf = (1L << 60);
public static final String yes = "Yes" , no = "No" ;
public static final int mod7 = 1000000007 , mod9 = 998244353;
public static final int [] dy4 = {-1,0,1,0} , dx4 = {0,1,0,-1};
public static final int [] dy8 = {-1,-1,-1,0,1,1,1,0} , dx8 = {-1,0,1,1,1,0,-1,-1};
public record IntP(int fi , int se) { public String toString() { return fi + " "+ se ;} }
public record LongP(long fi , long se) { public String toString() { return fi + " "+ se ;} }
public record StringP(String fi , String se) { public String toString() { return fi + " "+ se ;} }
public record Edge(int to , long weight) { public String toString() { return to + " "+ weight ;}}
public record State(int now , long dist) { public String toString() { return now + " "+ dist ; }}
public record Pair<T,S> (T fi , S se) { public String toString() { return "("+fi+","+se+")";}}
// ===============================================================================================================
public static void main(String ... args) { new Thread(null, new Main(), "", Runtime.getRuntime().maxMemory()).start(); }
public void run() { solve(); out.flush(); }
// ===============================================================================================================
public static char shiftCharacter(char ch, int shift) {
if (Character.isLetter(ch)) {
char base = Character.isUpperCase(ch) ? 'A' : 'a';
shift = shift % 26;
return (char) (((ch - base + shift + 26) % 26) + base);
}
return ch;
}
public long toMultiple(long u , long m) { return m - (u % m); }
public boolean isOut(int uY , int uX , int qH , int qW) { return (0 < uY || 0 < uX || qH >= uY || qW >= uX) ; }
public void swap(int [] array, int n, int m) { int swap = array[n]; array[n] = array[m]; array[m] = swap; }
public <T> T getKth(TreeSet<T> set , int kth) { int count = 0 ; for(T u : set) if(kth == ++count) return u ; return null ; }
public <T extends Comparable<T>> int lowClosed(List<T> A , T key) { return upperbound(A, key); }
public <T extends Comparable<T>> int lowOpen(List<T> A , T key) { return lowerbound(A, key); }
public <T extends Comparable<T>> int highClosed(List<T> A , T key) { return A.size() - lowerbound(A, key); }
public <T extends Comparable<T>> int highOpen(List<T> A , T key) { return A.size() - upperbound(A, key); }
public <T extends Comparable<T>> int closedOpen(List<T> A, T a, T b) { return lowerbound(A, b) - lowerbound(A, a); }
public <T extends Comparable<T>> int closedClosed(List<T> A, T a, T b) { return upperbound(A, b) - lowerbound(A, a); }
public <T extends Comparable<T>> int openClosed(List<T> A, T a, T b) { return upperbound(A, b) - upperbound(A, a); }
public <T extends Comparable<T>> int openOpen(List<T> A, T a, T b) { return lowerbound(A, b) - upperbound(A, a); }
public <T extends Comparable<T>> int lowerbound(List<T> A, T key) {
int left = 0 , right = A.size();
while (left < right) {
int mid = (left + right) / 2;
if (A.get(mid).compareTo(key) < 0) left = mid + 1;
else right = mid;
}
return right;
}
public <T extends Comparable<T>> int upperbound(List<T> A, T key) {
int left = 0 , right = A.size();
while (left < right) {
int mid = (left + right) / 2;
if (A.get(mid).compareTo(key) <= 0) left = mid + 1;
else right = mid;
}
return right;
}
public <T> Map<T,Integer> compress(List<T> u) {
Set<T> order = new TreeSet<>(u); Map<T,Integer> res = new HashMap<>(); int rank = 0 ;
for(T obj : order) res.put(obj , rank++);
return res ;
}
public List<Long> subset(long u) {
List<Long> res = new ArrayList<>();
for (long sub = (u - 1) & u ; sub > 0 ; sub = (sub - 1) & u) res.add(sub);
return res ;
}
public long [][] pascal(int n) {
int MAX = n;
long [][] com = new long[MAX][MAX];
for(int i = 0; i < MAX; i ++ ) com[i][0] = 1;
for(int i = 1; i < MAX; i ++ ) for(int j = 1; j <= i; j ++ ) com[i][j] = com[i-1][j-1] + com[i-1][j];
return com ;
}
public boolean nextPermutation(int [] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] < array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) {
if (array[change] < array[mid = min + halfDiff]) min = mid;
else max = mid;
}
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
public boolean prevPermutation(int [] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] > array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] > array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
public int [] bfs(int start , List<Integer>[] G) {
int [] dist = new int[G.length];
Arrays.fill(dist , inf);
dist[start] = 0 ;
Queue<Integer> Q = new ArrayDeque<>();
Q.add(start);
while(!Q.isEmpty()) {
int now = Q.poll();
for(int next : G[now]) {
if(dist[next] < dist[now] + 1) continue;
dist[next] = dist[now] + 1 ;
Q.add(next);
}
}
return dist;
}
public long [] Dijkstra(int start , List<Edge>[] G) {
long [] cur = new long[G.length];
Set<Integer> visited = new HashSet<>();
long NULL = (long)1e18;
Arrays.fill(cur,NULL);
cur[start] = 0 ;
Queue<State> Q = new PriorityQueue<>(Comparator.comparing(State::dist));
Q.add(new State(start , 0));
while(!Q.isEmpty()){
State d = Q.poll();
int now = d.now;
if(visited.contains(now)) continue;
visited.add(now);
for(Edge v : G[now]){
int next = v.to;
long weights = v.weight;
if(cur[now] + weights < cur[next]){
cur[next] = cur[now] + weights ;
Q.add(new State(next , cur[next]));
}
}
}
return cur ;
}
// ===============================================================================================================
public Integer [] parseInt(int [] array) { return IntStream.of(array).boxed().toArray(Integer[]::new); }
public Long [] parseLong(long [] array) { return LongStream.of(array).boxed().toArray(Long[]::new); }
// ===============================================================================================================
class MultiSet<T> {
private TreeMap<T,Integer> set ;
private int count ;
MultiSet() {
this.set = new TreeMap<>();
this.count = 0 ;
}
public void add(T x) {
set.put(x , set.getOrDefault(x , 0) + 1);
count++;
}
public void add(T x , int cnt) {
set.put(x , set.getOrDefault(x , 0) + cnt);
count += cnt;
}
public void remove(T x) {
if(set.get(x) == 1) set.remove(x) ;
else set.put(x , set.get(x) - 1);
count--;
}
public void remove(T x , int cnt) {
if(set.get(x) - cnt == 0) set.remove(x) ;
else set.put(x , set.get(x) - cnt);
count -= cnt;
}
public void removeAll(T x) {
if(set.containsKey(x)) {
count -= set.get(x);
set.remove(x);
}
}
public T peekFirst() { return set.firstKey(); }
public T peekLast() { return set.lastKey(); }
public T pollFirst() {
count--;
T first = set.firstKey();
if(set.get(first) == 1) set.pollFirstEntry();
else set.put(first , set.get(first) - 1);
return first;
}
public T pollLast() {
count--;
T last = set.lastKey();
if(set.get(last) == 1) set.pollLastEntry();
else set.put(last , set.get(last) - 1);
return last;
}
public boolean isEmpty() { return set.isEmpty(); }
public int count(T x) { return set.get(x); }
public int size() { return count; }
public void clear() { set.clear(); this.count = 0 ; }
}
class Deque<E> {
private Object [] buf;
private int head;
private int tail;
private int N;
public Deque() {
this(300000);
}
public Deque(int max_size) {
this(new Object[0], max_size);
}
public Deque(Object[] src_arr, int max_size) {
N = Math.max(max_size, src_arr.length) + 1;
buf = Arrays.copyOf(src_arr, N);
head = 0;
tail = src_arr.length;
}
public void add(E x) {
addFirst(x);
}
public void addFirst(E x) {
if (isFull()) extend();
head = (head - 1 + N) % N;
buf[head] = x;
}
public void addLast(E x) {
if (isFull()) extend();
buf[tail] = x;
tail = (tail + 1) % N;
}
public E poll() {
return pollFirst();
}
public E pollFirst() {
if (isEmpty()) throw new IndexOutOfBoundsException("null");
@SuppressWarnings("unchecked")
E ret = (E)buf[head];
buf[head] = null;
head = (head + 1) % N;
return ret;
}
public E pollLast() {
if (isEmpty()) throw new IndexOutOfBoundsException("null");
tail = (tail - 1 + N) % N;
@SuppressWarnings("unchecked")
E ret = (E)buf[tail];
buf[tail] = null;
return ret;
}
@SuppressWarnings("unchecked")
public E peekFirst() {
return (E)buf[head];
}
@SuppressWarnings("unchecked")
public E peekLirst() {
return (E)buf[tail];
}
@SuppressWarnings("unchecked")
public E get(int key) {
return (E)buf[index(key)];
}
public void set(int key , E value) {
buf[index(key)] = value;
}
public boolean isFull() {
return size() >= N - 1;
}
public boolean isEmpty() {
return size() == 0;
}
private int index(int i) {
int l = size();
if (i < -l || i >= l) throw new IndexOutOfBoundsException("index out of range: " + i);
if (i < 0) i += l;
return (head + i) % N;
}
private void extend() {
int ex = N - 1;
buf = Arrays.copyOf(buf, buf.length + ex);
N = buf.length;
if (head > 0) head += ex;
}
public int size() {
return (tail - head + N) % N;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("Deque(");
for (int i = 0; i < size(); i++) {
if (i > 0) sb.append(", ");
sb.append(buf[(head + i) % N]);
}
sb.append(")");
return sb.toString();
}
}
class FenwickTree {
private long N;
private long [] data;
public FenwickTree(int n) {
N = n;
data = new long[n+1];
}
public long sum(int i) {
long s = 0;
while (i > 0) {
s += data[i];
i -= i & (-i);
}
return s;
}
public long range(int i, int j) {
return sum(j) - sum(i-1);
}
public void set(int i, long x) {
add(i, x-range(i, i));
}
public void add(int i, long x) {
while (i <= N) {
data[i] += x;
i += i & (-i);
}
}
}
class SegmentTree <T> {
private int n ;
private T init ;
private T [] tree ;
private int size ;
private BinaryOperator<T> op ;
@SuppressWarnings ("unchecked")
SegmentTree(int size , T init , BinaryOperator<T> op) {
this.size = size;
this.init = init ;
this.op = op ;
n = 1 ;
while(n <= size) n *= 2 ;
this.tree = (T []) new Object[2 * n];
for(int i = 0 ; i < 2 * n ; i ++ ) tree[i] = init ;
}
public void update(int index , T value) {
index += n ;
tree[index] = value ;
while(index > 0) {
index /= 2 ;
tree[index] = op.apply(tree[2 * index] , tree[2 * index + 1]);
}
}
public T query(int l , int r){
l += n ; r += n ;
T res = init ;
while(l < r){
if(l % 2 == 1){ res = op.apply(res , tree[l]) ; l ++ ; }
l /= 2 ;
if(r % 2 == 1){ res = op.apply(res , tree[r - 1]) ; r -- ; }
r /= 2 ;
}
return res ;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
for(int i = n ; i < n + size ; i ++ ) sb.append(tree[i]+" ");
return sb.toString() ;
}
}
class UnionFind {
private int [] rank , parents , size ;
private int group_count ;
UnionFind(int n) {
this.rank = new int[n];
this.parents = new int[n];
this.size = new int[n];
this.group_count = n ;
Arrays.fill(size , 1);
for(int i = 0 ; i < n ; i ++ ) parents[i] = i ;
}
public int groupcount() { return this.group_count ; }
public int membercount(int x) { return size[root(x)] ; }
public boolean same(int x , int y) { return root(x) == root(y) ; }
public int root(int x) {
if(x == parents[x]) return x ;
else parents[x] = root(parents[x]);
return parents[x];
}
public void unite(int l , int r) {
int left = root(l);
int right = root(r);
int parent = -1 , child = -1 ;
if(left == right) return ;
parent = rank[left] > rank[right] ? left : right;
child = rank[left] > rank[right] ? right : left ;
--group_count;
parents[child] = parent ;
if(rank[parent] == rank[child]) rank[parent] ++ ;
size[parent] += size[child] ;
}
@SuppressWarnings("unchecked")
public List<Integer> [] groupList() {
List<Integer> [] ret = new ArrayList[group_count];
int count = 0 ;
for(int i = 0 ; i < group_count ; i ++) ret[i] = new ArrayList<>();
Map<Integer,List<Integer>> mp = new HashMap<>();
for(int i = 0 ; i < parents.length ; i ++ ) {
int par = root(i);
if(!mp.containsKey(par)) mp.put(par , new ArrayList<>());
mp.get(par).add(i);
}
for(List<Integer> temp : mp.values()) ret[count++] = temp ;
return ret ;
}
}
class WaveletMatrix {
private int [][] data;
private int n, bit;
WaveletMatrix(int [] d, int bit) {
n = d.length;
this.bit = bit;
int[] dat = d.clone();
data = new int[bit][n];
int[] que = new int[n];
for (int k = bit - 1; k >= 0; k--) {
int que1 = 0, que2 = n;
for (int i = 0; i < n; i++) {
if ((data[k][i] = (dat[i] >> k) & 1) == 1)
que[--que2] = dat[i];
else
que[que1++] = dat[i];
}
for (int i = 0; i < que1; i++)
dat[i] = que[i];
for (int i = n - 1, j = que1; i >= que1; i--, j++)
dat[j] = que[i];
for (int i = 1; i < n; i++)
data[k][i] += data[k][i - 1];
}
}
WaveletMatrix(int [] dat) {
this(dat, 31);
}
private int get(int bi, int id) {
if (id == 0)
return data[bi][0];
return data[bi][id] - data[bi][id - 1];
}
public int access(int idx) {
int ans = 0;
for (int k = bit - 1; k >= 0; k--) {
if (get(k, idx) == 1) {
ans |= 1 << k;
idx = zer(k, n) + one(k, idx);
} else
idx -= data[k][idx];
}
return ans;
}
private int one(int bi, int l) {
if (l == 0)
return 0;
return data[bi][l - 1];
}
private int zer(int bi, int l) {
return l - one(bi, l);
}
private int sum(int bi, int l, int r) {
return one(bi, r) - one(bi, l);
}
public int kth_smallest(int l, int r, int kth) {
int ans = 0;
for (int k = bit - 1; k >= 0; k--) {
int s = r - l - sum(k, l, r);
if (kth < s) {
l = zer(k, l);
r = l + s;
} else {
kth -= s;
ans |= 1 << k;
int ran = r - l - s;
l = zer(k, n) + one(k, l);
r = l + ran;
}
}
return ans;
}
public int kth_largest(int l, int r, int kth) {
return kth_smallest(l, r, r - l - kth);
}
public int count_lower(int l, int r, int lower) {
int ans = 0;
for (int k = bit - 1; k >= 0; k--) {
int s = r - l - sum(k, l, r);
if (((lower >> k) & 1) == 1) {
ans += s;
int ran = r - l - s;
l = zer(k, n) + one(k, l);
r = l + ran;
} else {
l = zer(k, l);
r = l + s;
}
}
return ans;
}
public int count_upper(int l, int r, int upper) {
return r - l - count_lower(l, r, upper + 1);
}
public int count(int l, int r, int x) {
return count_lower(l, r, x + 1) - count_lower(l, r, x);
}
public int higher(int l, int r, int upper) {
int cnt = count_lower(l, r, upper + 1);
return kth_smallest(l, r, cnt);
}
public int lower(int l, int r, int lower) {
int cnt = count_upper(l, r, lower - 1);
return kth_largest(l, r, cnt);
}
}
class mint {
private long value;
private final long MOD;
public mint(long value, long MOD) {
this.MOD = MOD;
this.value = (value % MOD + MOD) % MOD;
}
public mint add(mint other) {
return new mint((this.value + other.value) % MOD, MOD);
}
public mint subtract(mint other) {
return new mint((this.value - other.value + MOD) % MOD, MOD);
}
public mint multiply(mint other) {
return new mint((this.value * other.value) % MOD, MOD);
}
public mint inverse() {
return new mint(pow(this.value, MOD - 2), MOD);
}
public mint divide(mint other) {
return this.multiply(other.inverse());
}
private long pow(long a, long b) {
long res = 1;
while (b > 0) {
if ((b & 1) != 0) {
res = (res * a) % MOD;
}
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
public long getVal() {
return value;
}
@Override
public String toString() {
return String.valueOf(value);
}
}
class Combination {
private final mint[] factorial;
private final mint[] inverseFactorial;
private final long MOD;
Combination(int maxN , long MOD) {
this.MOD = MOD;
this.factorial = new mint[maxN + 1];
this.inverseFactorial = new mint[maxN + 1];
init();
}
private void init() {
factorial[0] = new mint(1, MOD);
for (int i = 1 ; i < factorial.length ; i++ ) factorial[i] = factorial[i - 1].multiply(new mint(i, MOD));
inverseFactorial[factorial.length - 1] = factorial[factorial.length - 1].inverse();
for (int i = factorial.length - 2 ; i >= 0 ; i -- ) inverseFactorial[i] = inverseFactorial[i + 1].multiply(new mint(i + 1, MOD));
}
public mint fact(int x) {
return factorial[x];
}
//nCk
public mint comb(int n, int k) {
if (n < k) return new mint(0, MOD);
if (n < 0 || k < 0) return new mint(0, MOD);
return factorial[n].multiply(inverseFactorial[k]).multiply(inverseFactorial[n - k]);
}
//nPk
public mint perm(int n , int k) {
return comb(n ,k).multiply(fact(k));
}
}
}
class In {
private final InputStream in = System.in;
private final Scanner sc = new Scanner(System.in);
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++]; else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
private boolean hasNext() {
while(hasNextByte() && !isPrintableChar(buffer[ptr])) {
ptr++;
}
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public char nextChar() {
return next().charAt(0);
}
public BigInteger nextBigInteger() {
return sc.nextBigInteger();
}
public int [] nextInt(int n) {
int [] array = new int[n];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextInt();
}
return array ;
}
public int [][] nextInt(int n , int m) {
int [][] array = new int[n][m];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextInt(m);
}
return array ;
}
public long [] nextLong(int n) {
long [] array = new long[n];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextLong();
}
return array ;
}
public long [][] nextLong(int n , int m) {
long [][] array = new long[n][m];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextLong(m);
}
return array ;
}
public double [] nextDouble(int n) {
double [] array = new double[n];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextDouble();
}
return array ;
}
public String [] next(int n) {
String [] array = new String[n];
for(int i = 0 ; i < n ; i ++) {
array[i] = next();
}
return array ;
}
public String [][] next(int n , int m) {
String [][] array = new String[n][m];
for(int i = 0 ; i < n ; i ++) {
array[i] = next(m);
}
return array ;
}
public char [] nextChar(int n) {
char [] array = new char[n];
String string = next() ;
for(int i = 0 ; i < n ; i ++) {
array[i] = string.charAt(i);
}
return array ;
}
public char [][] nextChar(int n , int m) {
char [][] array = new char[n][m];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextChar(m);
}
return array ;
}
}