message stringlengths 2 59.7k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 37 108k | cluster float64 20 20 | __index_level_0__ int64 74 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
There was once young lass called Mary,
Whose jokes were occasionally scary.
On this April's Fool
Fixed limerick rules
Allowed her to trip the unwary.
Can she fill all the lines
To work at all times?
On juggling the words
Right around two-thirds
She nearly ran out of rhymes.
Input
The input contains a single integer a (4 ≤ a ≤ 998). Not every integer in the range is a valid input for the problem; you are guaranteed that the input will be a valid integer.
Output
Output a single number.
Examples
Input
35
Output
57
Input
57
Output
319
Input
391
Output
1723 | instruction | 0 | 56,525 | 20 | 113,050 |
Tags: *special, math, number theory
Correct Solution:
```
# factors
def factors(n):
for f in range(2, n):
if n % f == 0:
q = n // f
if q < f:
return f'{q}{f}'
else:
return f'{f}{q}'
if __name__ == '__main__':
n = int(input())
print(factors(n))
``` | output | 1 | 56,525 | 20 | 113,051 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There was once young lass called Mary,
Whose jokes were occasionally scary.
On this April's Fool
Fixed limerick rules
Allowed her to trip the unwary.
Can she fill all the lines
To work at all times?
On juggling the words
Right around two-thirds
She nearly ran out of rhymes.
Input
The input contains a single integer a (4 ≤ a ≤ 998). Not every integer in the range is a valid input for the problem; you are guaranteed that the input will be a valid integer.
Output
Output a single number.
Examples
Input
35
Output
57
Input
57
Output
319
Input
391
Output
1723 | instruction | 0 | 56,526 | 20 | 113,052 |
Tags: *special, math, number theory
Correct Solution:
```
n = int(input())
i = 2
ans = []
while i <= n:
while n%i == 0:
n /= i
ans.append(i)
i+=1
print(str(ans)[1:-1].replace(", ", ""))
``` | output | 1 | 56,526 | 20 | 113,053 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There was once young lass called Mary,
Whose jokes were occasionally scary.
On this April's Fool
Fixed limerick rules
Allowed her to trip the unwary.
Can she fill all the lines
To work at all times?
On juggling the words
Right around two-thirds
She nearly ran out of rhymes.
Input
The input contains a single integer a (4 ≤ a ≤ 998). Not every integer in the range is a valid input for the problem; you are guaranteed that the input will be a valid integer.
Output
Output a single number.
Examples
Input
35
Output
57
Input
57
Output
319
Input
391
Output
1723 | instruction | 0 | 56,527 | 20 | 113,054 |
Tags: *special, math, number theory
Correct Solution:
```
n=int(input())
ans=''
flag=0
for i in range(2,(n//2)+1):
if n%i==0 and flag==0:
flag=1
b=int(i)
ans+=str(int(i))
ans+=str(int(n/b))
break
print(ans)
``` | output | 1 | 56,527 | 20 | 113,055 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There was once young lass called Mary,
Whose jokes were occasionally scary.
On this April's Fool
Fixed limerick rules
Allowed her to trip the unwary.
Can she fill all the lines
To work at all times?
On juggling the words
Right around two-thirds
She nearly ran out of rhymes.
Input
The input contains a single integer a (4 ≤ a ≤ 998). Not every integer in the range is a valid input for the problem; you are guaranteed that the input will be a valid integer.
Output
Output a single number.
Examples
Input
35
Output
57
Input
57
Output
319
Input
391
Output
1723 | instruction | 0 | 56,528 | 20 | 113,056 |
Tags: *special, math, number theory
Correct Solution:
```
"""
CONTESTANT: ngtien2
CONTEST: April Fools Day Contest 2020
LANGUAGE: Python 3.7
PROBLEM: B. Limericks
"""
def factors(n):
p = 2
f = []
while n > 1:
if n % p:
p += 1
else:
n //= p
if p not in f:
f.append(f"{p}")
return "".join(f)
n = int(input())
print(factors(n))
``` | output | 1 | 56,528 | 20 | 113,057 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There was once young lass called Mary,
Whose jokes were occasionally scary.
On this April's Fool
Fixed limerick rules
Allowed her to trip the unwary.
Can she fill all the lines
To work at all times?
On juggling the words
Right around two-thirds
She nearly ran out of rhymes.
Input
The input contains a single integer a (4 ≤ a ≤ 998). Not every integer in the range is a valid input for the problem; you are guaranteed that the input will be a valid integer.
Output
Output a single number.
Examples
Input
35
Output
57
Input
57
Output
319
Input
391
Output
1723 | instruction | 0 | 56,529 | 20 | 113,058 |
Tags: *special, math, number theory
Correct Solution:
```
n=int(input())
for i in range(2,n+1):
if n%i==0:
b=str(i)
b+=str(n//i)
break
print(b)
``` | output | 1 | 56,529 | 20 | 113,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There was once young lass called Mary,
Whose jokes were occasionally scary.
On this April's Fool
Fixed limerick rules
Allowed her to trip the unwary.
Can she fill all the lines
To work at all times?
On juggling the words
Right around two-thirds
She nearly ran out of rhymes.
Input
The input contains a single integer a (4 ≤ a ≤ 998). Not every integer in the range is a valid input for the problem; you are guaranteed that the input will be a valid integer.
Output
Output a single number.
Examples
Input
35
Output
57
Input
57
Output
319
Input
391
Output
1723 | instruction | 0 | 56,530 | 20 | 113,060 |
Tags: *special, math, number theory
Correct Solution:
```
a = int(input())
n = 2
while a % n != 0:
n += 1
print(str(n) + (str(a // n)))
``` | output | 1 | 56,530 | 20 | 113,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There was once young lass called Mary,
Whose jokes were occasionally scary.
On this April's Fool
Fixed limerick rules
Allowed her to trip the unwary.
Can she fill all the lines
To work at all times?
On juggling the words
Right around two-thirds
She nearly ran out of rhymes.
Input
The input contains a single integer a (4 ≤ a ≤ 998). Not every integer in the range is a valid input for the problem; you are guaranteed that the input will be a valid integer.
Output
Output a single number.
Examples
Input
35
Output
57
Input
57
Output
319
Input
391
Output
1723 | instruction | 0 | 56,531 | 20 | 113,062 |
Tags: *special, math, number theory
Correct Solution:
```
n = int(input())
for i in range(2, 2333):
if n % i == 0:
print(str(i) + str(n // i))
break
``` | output | 1 | 56,531 | 20 | 113,063 |
Provide tags and a correct Python 2 solution for this coding contest problem.
The year 2015 is almost over.
Limak is a little polar bear. He has recently learnt about the binary system. He noticed that the passing year has exactly one zero in its representation in the binary system — 201510 = 111110111112. Note that he doesn't care about the number of zeros in the decimal representation.
Limak chose some interval of years. He is going to count all years from this interval that have exactly one zero in the binary representation. Can you do it faster?
Assume that all positive integers are always written without leading zeros.
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 1018) — the first year and the last year in Limak's interval respectively.
Output
Print one integer – the number of years Limak will count in his chosen interval.
Examples
Input
5 10
Output
2
Input
2015 2015
Output
1
Input
100 105
Output
0
Input
72057594000000000 72057595000000000
Output
26
Note
In the first sample Limak's interval contains numbers 510 = 1012, 610 = 1102, 710 = 1112, 810 = 10002, 910 = 10012 and 1010 = 10102. Two of them (1012 and 1102) have the described property. | instruction | 0 | 56,737 | 20 | 113,474 |
Tags: bitmasks, brute force, implementation
Correct Solution:
```
#!/usr/bin/python 3
a,b = map(int,raw_input().split())
ans = 0
for l in range(2,65):
for i in range(l-1):
ans += a<= 2 ** l - 1 - 2 ** i <= b
print(ans)
``` | output | 1 | 56,737 | 20 | 113,475 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The year 2015 is almost over.
Limak is a little polar bear. He has recently learnt about the binary system. He noticed that the passing year has exactly one zero in its representation in the binary system — 201510 = 111110111112. Note that he doesn't care about the number of zeros in the decimal representation.
Limak chose some interval of years. He is going to count all years from this interval that have exactly one zero in the binary representation. Can you do it faster?
Assume that all positive integers are always written without leading zeros.
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 1018) — the first year and the last year in Limak's interval respectively.
Output
Print one integer – the number of years Limak will count in his chosen interval.
Examples
Input
5 10
Output
2
Input
2015 2015
Output
1
Input
100 105
Output
0
Input
72057594000000000 72057595000000000
Output
26
Note
In the first sample Limak's interval contains numbers 510 = 1012, 610 = 1102, 710 = 1112, 810 = 10002, 910 = 10012 and 1010 = 10102. Two of them (1012 and 1102) have the described property. | instruction | 0 | 56,738 | 20 | 113,476 |
Tags: bitmasks, brute force, implementation
Correct Solution:
```
## necessary imports
import sys
input = sys.stdin.readline
from math import ceil, floor, factorial;
# swap_array function
def swaparr(arr, a,b):
temp = arr[a];
arr[a] = arr[b];
arr[b] = temp
## gcd function
def gcd(a,b):
if a == 0:
return b
return gcd(b%a, a)
## nCr function efficient using Binomial Cofficient
def nCr(n, k):
if(k > n - k):
k = n - k
res = 1
for i in range(k):
res = res * (n - i)
res = res / (i + 1)
return int(res)
## upper bound function code -- such that e in a[:i] e < x;
def upper_bound(a, x, lo=0):
hi = len(a)
while lo < hi:
mid = (lo+hi)//2
if a[mid] < x:
lo = mid+1
else:
hi = mid
return lo
## prime factorization
def primefs(n):
## if n == 1 ## calculating primes
primes = {}
while(n%2 == 0):
primes[2] = primes.get(2, 0) + 1
n = n//2
for i in range(3, int(n**0.5)+2, 2):
while(n%i == 0):
primes[i] = primes.get(i, 0) + 1
n = n//i
if n > 2:
primes[n] = primes.get(n, 0) + 1
## prime factoriazation of n is stored in dictionary
## primes and can be accesed. O(sqrt n)
return primes
## MODULAR EXPONENTIATION FUNCTION
def power(x, y, p):
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
## DISJOINT SET UNINON FUNCTIONS
def swap(a,b):
temp = a
a = b
b = temp
return a,b
# find function with path compression included (recursive)
# def find(x, link):
# if link[x] == x:
# return x
# link[x] = find(link[x], link);
# return link[x];
# find function with path compression (ITERATIVE)
def find(x, link):
p = x;
while( p != link[p]):
p = link[p];
while( x != p):
nex = link[x];
link[x] = p;
x = nex;
return p;
# the union function which makes union(x,y)
# of two nodes x and y
def union(x, y, link, size):
x = find(x, link)
y = find(y, link)
if size[x] < size[y]:
x,y = swap(x,y)
if x != y:
size[x] += size[y]
link[y] = x
## returns an array of boolean if primes or not USING SIEVE OF ERATOSTHANES
def sieve(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
#### PRIME FACTORIZATION IN O(log n) using Sieve ####
MAXN = int(1e6 + 5)
def spf_sieve():
spf[1] = 1;
for i in range(2, MAXN):
spf[i] = i;
for i in range(4, MAXN, 2):
spf[i] = 2;
for i in range(3, ceil(MAXN ** 0.5), 2):
if spf[i] == i:
for j in range(i*i, MAXN, i):
if spf[j] == j:
spf[j] = i;
## function for storing smallest prime factors (spf) in the array
################## un-comment below 2 lines when using factorization #################
# spf = [0 for i in range(MAXN)]
# spf_sieve()
def factoriazation(x):
ret = {};
while x != 1:
ret[spf[x]] = ret.get(spf[x], 0) + 1;
x = x//spf[x]
return ret
## this function is useful for multiple queries only, o/w use
## primefs function above. complexity O(log n)
## taking integer array input
def int_array():
return list(map(int, input().strip().split()))
## taking string array input
def str_array():
return input().strip().split();
#defining a couple constants
MOD = int(1e9)+7;
CMOD = 998244353;
INF = float('inf'); NINF = -float('inf');
################### ---------------- TEMPLATE ENDS HERE ---------------- ###################
a, b = int_array();
bb = '0' + bin(b).replace('0b', '');
bx = len(bb); ans = 0;
for i in range(bx):
this = ['1']*(i+1);
for j in range(1, i+1):
this[j] = '0';
s = ''.join(this);
year = int(s, 2);
if year <= b and year >= a:
ans += 1;
this[j] = '1';
print(ans);
``` | output | 1 | 56,738 | 20 | 113,477 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The year 2015 is almost over.
Limak is a little polar bear. He has recently learnt about the binary system. He noticed that the passing year has exactly one zero in its representation in the binary system — 201510 = 111110111112. Note that he doesn't care about the number of zeros in the decimal representation.
Limak chose some interval of years. He is going to count all years from this interval that have exactly one zero in the binary representation. Can you do it faster?
Assume that all positive integers are always written without leading zeros.
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 1018) — the first year and the last year in Limak's interval respectively.
Output
Print one integer – the number of years Limak will count in his chosen interval.
Examples
Input
5 10
Output
2
Input
2015 2015
Output
1
Input
100 105
Output
0
Input
72057594000000000 72057595000000000
Output
26
Note
In the first sample Limak's interval contains numbers 510 = 1012, 610 = 1102, 710 = 1112, 810 = 10002, 910 = 10012 and 1010 = 10102. Two of them (1012 and 1102) have the described property. | instruction | 0 | 56,739 | 20 | 113,478 |
Tags: bitmasks, brute force, implementation
Correct Solution:
```
a, b = [int(x) for x in input().split()]
a_repr, b_repr = bin(a)[2:], bin(b)[2:]
a_l, a_k = len(a_repr), a_repr.find('0')
b_l, b_k = len(b_repr), b_repr.find('0')
count = (a_l + b_l - 2) * (b_l - a_l + 1) // 2
if a_k != -1:
count -= a_k - 1
else:
count -= a_l - 1
if b_k != -1:
count -= b_l - b_k
if b == (2 ** b_l - 1) - (2 ** (b_l - b_k - 1)):
count += 1
print(count)
``` | output | 1 | 56,739 | 20 | 113,479 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The year 2015 is almost over.
Limak is a little polar bear. He has recently learnt about the binary system. He noticed that the passing year has exactly one zero in its representation in the binary system — 201510 = 111110111112. Note that he doesn't care about the number of zeros in the decimal representation.
Limak chose some interval of years. He is going to count all years from this interval that have exactly one zero in the binary representation. Can you do it faster?
Assume that all positive integers are always written without leading zeros.
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 1018) — the first year and the last year in Limak's interval respectively.
Output
Print one integer – the number of years Limak will count in his chosen interval.
Examples
Input
5 10
Output
2
Input
2015 2015
Output
1
Input
100 105
Output
0
Input
72057594000000000 72057595000000000
Output
26
Note
In the first sample Limak's interval contains numbers 510 = 1012, 610 = 1102, 710 = 1112, 810 = 10002, 910 = 10012 and 1010 = 10102. Two of them (1012 and 1102) have the described property. | instruction | 0 | 56,740 | 20 | 113,480 |
Tags: bitmasks, brute force, implementation
Correct Solution:
```
def binn_c(i):
if "0" not in str(bin(i))[2:]:
i-=1
g = list(str(bin(i))[2:])
j = g.index("0")
if g.count("0")!=1:
ans = j-1
else:
ans = j
g.pop()
while len(g)>1:
g.pop()
ans+=len(g)
return ans
def main():
mode="filee"
if mode=="file":f=open("test.txt","r")
get = lambda :[int(x) for x in (f.readline() if mode=="file" else input()).split()]
[a,b]=get()
print(binn_c(b) - binn_c(a-1))
if mode=="file":f.close()
if __name__=="__main__":
main()
``` | output | 1 | 56,740 | 20 | 113,481 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The year 2015 is almost over.
Limak is a little polar bear. He has recently learnt about the binary system. He noticed that the passing year has exactly one zero in its representation in the binary system — 201510 = 111110111112. Note that he doesn't care about the number of zeros in the decimal representation.
Limak chose some interval of years. He is going to count all years from this interval that have exactly one zero in the binary representation. Can you do it faster?
Assume that all positive integers are always written without leading zeros.
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 1018) — the first year and the last year in Limak's interval respectively.
Output
Print one integer – the number of years Limak will count in his chosen interval.
Examples
Input
5 10
Output
2
Input
2015 2015
Output
1
Input
100 105
Output
0
Input
72057594000000000 72057595000000000
Output
26
Note
In the first sample Limak's interval contains numbers 510 = 1012, 610 = 1102, 710 = 1112, 810 = 10002, 910 = 10012 and 1010 = 10102. Two of them (1012 and 1102) have the described property. | instruction | 0 | 56,741 | 20 | 113,482 |
Tags: bitmasks, brute force, implementation
Correct Solution:
```
a, b = map(int, input().split())
u = bin(a)
v = bin(b)
a = len(u) - 2
b = len(v) - 2
c = 0
if a == b:
for i in range(1, a):
s = '0b' + '1' * i + '0' + '1' * (a-i-1)
if u <= s and s <= v:
c += 1
else:
for i in range(1, a):
s = '0b' + '1' * i + '0' + '1' * (a-i-1)
if u <= s:
c += 1
for i in range(1, b+1):
s = '0b' + '1' * i + '0' + '1' * (b-i-1)
if s <= v:
c += 1
for i in range(a+1, b):
c += i - 1
print(c)
``` | output | 1 | 56,741 | 20 | 113,483 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The year 2015 is almost over.
Limak is a little polar bear. He has recently learnt about the binary system. He noticed that the passing year has exactly one zero in its representation in the binary system — 201510 = 111110111112. Note that he doesn't care about the number of zeros in the decimal representation.
Limak chose some interval of years. He is going to count all years from this interval that have exactly one zero in the binary representation. Can you do it faster?
Assume that all positive integers are always written without leading zeros.
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 1018) — the first year and the last year in Limak's interval respectively.
Output
Print one integer – the number of years Limak will count in his chosen interval.
Examples
Input
5 10
Output
2
Input
2015 2015
Output
1
Input
100 105
Output
0
Input
72057594000000000 72057595000000000
Output
26
Note
In the first sample Limak's interval contains numbers 510 = 1012, 610 = 1102, 710 = 1112, 810 = 10002, 910 = 10012 and 1010 = 10102. Two of them (1012 and 1102) have the described property. | instruction | 0 | 56,742 | 20 | 113,484 |
Tags: bitmasks, brute force, implementation
Correct Solution:
```
def z(n):
n = bin(n)[2:]
k = len(n) - 1
r = n.find("0")
s = k * (k-1) // 2 + (n.count("0") == 1)
s += k if r == -1 else r-1
return s;
a, b = map(int, input().split());
print (z(b) - z(a - 1))
``` | output | 1 | 56,742 | 20 | 113,485 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The year 2015 is almost over.
Limak is a little polar bear. He has recently learnt about the binary system. He noticed that the passing year has exactly one zero in its representation in the binary system — 201510 = 111110111112. Note that he doesn't care about the number of zeros in the decimal representation.
Limak chose some interval of years. He is going to count all years from this interval that have exactly one zero in the binary representation. Can you do it faster?
Assume that all positive integers are always written without leading zeros.
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 1018) — the first year and the last year in Limak's interval respectively.
Output
Print one integer – the number of years Limak will count in his chosen interval.
Examples
Input
5 10
Output
2
Input
2015 2015
Output
1
Input
100 105
Output
0
Input
72057594000000000 72057595000000000
Output
26
Note
In the first sample Limak's interval contains numbers 510 = 1012, 610 = 1102, 710 = 1112, 810 = 10002, 910 = 10012 and 1010 = 10102. Two of them (1012 and 1102) have the described property. | instruction | 0 | 56,743 | 20 | 113,486 |
Tags: bitmasks, brute force, implementation
Correct Solution:
```
def fun(x):
ans=0
for i in range(2,63):
mask=(1<<i)-1
for j in range(i-1):
y=mask^(1<<j)
if y<=x:
ans+=1
return ans
a,b=map(int,input().split())
print(fun(b)-fun(a-1))
``` | output | 1 | 56,743 | 20 | 113,487 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The year 2015 is almost over.
Limak is a little polar bear. He has recently learnt about the binary system. He noticed that the passing year has exactly one zero in its representation in the binary system — 201510 = 111110111112. Note that he doesn't care about the number of zeros in the decimal representation.
Limak chose some interval of years. He is going to count all years from this interval that have exactly one zero in the binary representation. Can you do it faster?
Assume that all positive integers are always written without leading zeros.
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 1018) — the first year and the last year in Limak's interval respectively.
Output
Print one integer – the number of years Limak will count in his chosen interval.
Examples
Input
5 10
Output
2
Input
2015 2015
Output
1
Input
100 105
Output
0
Input
72057594000000000 72057595000000000
Output
26
Note
In the first sample Limak's interval contains numbers 510 = 1012, 610 = 1102, 710 = 1112, 810 = 10002, 910 = 10012 and 1010 = 10102. Two of them (1012 and 1102) have the described property. | instruction | 0 | 56,744 | 20 | 113,488 |
Tags: bitmasks, brute force, implementation
Correct Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
a,b=map(int,input().split())
ans = 0
for i in range(1, 65):
for j in range(i - 1):
x = (1 << i) - (1 << j) - 1
if x >= a and x <= b:
ans += 1
print(ans)
``` | output | 1 | 56,744 | 20 | 113,489 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The year 2015 is almost over.
Limak is a little polar bear. He has recently learnt about the binary system. He noticed that the passing year has exactly one zero in its representation in the binary system — 201510 = 111110111112. Note that he doesn't care about the number of zeros in the decimal representation.
Limak chose some interval of years. He is going to count all years from this interval that have exactly one zero in the binary representation. Can you do it faster?
Assume that all positive integers are always written without leading zeros.
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 1018) — the first year and the last year in Limak's interval respectively.
Output
Print one integer – the number of years Limak will count in his chosen interval.
Examples
Input
5 10
Output
2
Input
2015 2015
Output
1
Input
100 105
Output
0
Input
72057594000000000 72057595000000000
Output
26
Note
In the first sample Limak's interval contains numbers 510 = 1012, 610 = 1102, 710 = 1112, 810 = 10002, 910 = 10012 and 1010 = 10102. Two of them (1012 and 1102) have the described property. | instruction | 0 | 56,745 | 20 | 113,490 |
Tags: bitmasks, brute force, implementation
Correct Solution:
```
s = 0
a, b = map(int, input().split())
for i in range(0, 63):
if 2**i-2**(i-2)-1 > b:
break
for j in range(0, i-1):
if a<=2**i-2**j-1<=b:
s+=1
print(s)
``` | output | 1 | 56,745 | 20 | 113,491 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The year 2015 is almost over.
Limak is a little polar bear. He has recently learnt about the binary system. He noticed that the passing year has exactly one zero in its representation in the binary system — 201510 = 111110111112. Note that he doesn't care about the number of zeros in the decimal representation.
Limak chose some interval of years. He is going to count all years from this interval that have exactly one zero in the binary representation. Can you do it faster?
Assume that all positive integers are always written without leading zeros.
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 1018) — the first year and the last year in Limak's interval respectively.
Output
Print one integer – the number of years Limak will count in his chosen interval.
Examples
Input
5 10
Output
2
Input
2015 2015
Output
1
Input
100 105
Output
0
Input
72057594000000000 72057595000000000
Output
26
Note
In the first sample Limak's interval contains numbers 510 = 1012, 610 = 1102, 710 = 1112, 810 = 10002, 910 = 10012 and 1010 = 10102. Two of them (1012 and 1102) have the described property.
Submitted Solution:
```
__author__ = 'nikita'
a, b = map(int, input().split())
m = bin(a)[2:]
n = bin(b)[2:]
if len(n) == len(m):
cnt = 0
for k in range(1, len(n)):
str = '1' * k + '0' + '1' * (len(n) - 1 - k)
t = int(str, 2)
if (a <= t <= b):
cnt += 1
print(cnt)
else:
cnt = 0
for q in range(len(m) + 1, len(n)):
cnt += q - 1
#print(cnt)
cnt = max(0, cnt)
# print(cnt)
for k in range(1, len(n)):
str = '1' * k + '0' + '1' * (len(n) - 1 - k)
t = int(str, 2)
if (a <= t <= b):
#print(t)
cnt += 1
for k in range(1, len(m)):
str = '1' * k + '0' + '1' * (len(m) - 1 - k)
t = int(str, 2)
if (a <= t <= b):
#print(t)
cnt += 1
print(cnt)
``` | instruction | 0 | 56,748 | 20 | 113,496 |
Yes | output | 1 | 56,748 | 20 | 113,497 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The year 2015 is almost over.
Limak is a little polar bear. He has recently learnt about the binary system. He noticed that the passing year has exactly one zero in its representation in the binary system — 201510 = 111110111112. Note that he doesn't care about the number of zeros in the decimal representation.
Limak chose some interval of years. He is going to count all years from this interval that have exactly one zero in the binary representation. Can you do it faster?
Assume that all positive integers are always written without leading zeros.
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 1018) — the first year and the last year in Limak's interval respectively.
Output
Print one integer – the number of years Limak will count in his chosen interval.
Examples
Input
5 10
Output
2
Input
2015 2015
Output
1
Input
100 105
Output
0
Input
72057594000000000 72057595000000000
Output
26
Note
In the first sample Limak's interval contains numbers 510 = 1012, 610 = 1102, 710 = 1112, 810 = 10002, 910 = 10012 and 1010 = 10102. Two of them (1012 and 1102) have the described property.
Submitted Solution:
```
a, b = map(int, input().split())
ans = 0
for l in range(1, 70):
for pos in range(l - 1):
x = 2 ** l - 1 - 2 ** pos
if a <= x <= b:
ans += 1
print(ans)
``` | instruction | 0 | 56,749 | 20 | 113,498 |
Yes | output | 1 | 56,749 | 20 | 113,499 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The year 2015 is almost over.
Limak is a little polar bear. He has recently learnt about the binary system. He noticed that the passing year has exactly one zero in its representation in the binary system — 201510 = 111110111112. Note that he doesn't care about the number of zeros in the decimal representation.
Limak chose some interval of years. He is going to count all years from this interval that have exactly one zero in the binary representation. Can you do it faster?
Assume that all positive integers are always written without leading zeros.
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 1018) — the first year and the last year in Limak's interval respectively.
Output
Print one integer – the number of years Limak will count in his chosen interval.
Examples
Input
5 10
Output
2
Input
2015 2015
Output
1
Input
100 105
Output
0
Input
72057594000000000 72057595000000000
Output
26
Note
In the first sample Limak's interval contains numbers 510 = 1012, 610 = 1102, 710 = 1112, 810 = 10002, 910 = 10012 and 1010 = 10102. Two of them (1012 and 1102) have the described property.
Submitted Solution:
```
#!/usr/bin/env python3
import sys, itertools
a, b = input().split(' ')
a, b = int(a), int(b)
def exactlyOneZero():
for totalLength in itertools.count(1):
for zeroPosition in range(1, totalLength):
leftOnes = totalLength - zeroPosition
rightOnes = zeroPosition - 1
yield int("1"*leftOnes + "0" + "1"*rightOnes, 2)
def count(a, b):
ret = 0
for i in exactlyOneZero():
if i < a:
continue
if i > b:
return ret
ret += 1
print(count(a, b))
``` | instruction | 0 | 56,750 | 20 | 113,500 |
No | output | 1 | 56,750 | 20 | 113,501 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The year 2015 is almost over.
Limak is a little polar bear. He has recently learnt about the binary system. He noticed that the passing year has exactly one zero in its representation in the binary system — 201510 = 111110111112. Note that he doesn't care about the number of zeros in the decimal representation.
Limak chose some interval of years. He is going to count all years from this interval that have exactly one zero in the binary representation. Can you do it faster?
Assume that all positive integers are always written without leading zeros.
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 1018) — the first year and the last year in Limak's interval respectively.
Output
Print one integer – the number of years Limak will count in his chosen interval.
Examples
Input
5 10
Output
2
Input
2015 2015
Output
1
Input
100 105
Output
0
Input
72057594000000000 72057595000000000
Output
26
Note
In the first sample Limak's interval contains numbers 510 = 1012, 610 = 1102, 710 = 1112, 810 = 10002, 910 = 10012 and 1010 = 10102. Two of them (1012 and 1102) have the described property.
Submitted Solution:
```
x = input().split()
binary = bin(int(x[0]))
binary = binary[2:]
isFirst = True
new_binary = ''
for i in range(len(binary)):
if (binary[i] == '0'):
if (isFirst):
new_binary = new_binary + '0'
isFirst = False
else:
new_binary = new_binary + '1'
else:
new_binary = new_binary + binary[i]
inDecimal = int(new_binary, 2)
total = 0
while (int(x[0]) <= inDecimal and inDecimal <= int(x[1]) ):
total += 1
if (new_binary == '1'):
new_binary = '10'
elif (new_binary[-1] == '0'):
new_binary = '10' + new_binary[:-1]
else:
new_binary = '1' + new_binary[:-1]
inDecimal = int(new_binary, 2)
print(total)
``` | instruction | 0 | 56,751 | 20 | 113,502 |
No | output | 1 | 56,751 | 20 | 113,503 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The year 2015 is almost over.
Limak is a little polar bear. He has recently learnt about the binary system. He noticed that the passing year has exactly one zero in its representation in the binary system — 201510 = 111110111112. Note that he doesn't care about the number of zeros in the decimal representation.
Limak chose some interval of years. He is going to count all years from this interval that have exactly one zero in the binary representation. Can you do it faster?
Assume that all positive integers are always written without leading zeros.
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 1018) — the first year and the last year in Limak's interval respectively.
Output
Print one integer – the number of years Limak will count in his chosen interval.
Examples
Input
5 10
Output
2
Input
2015 2015
Output
1
Input
100 105
Output
0
Input
72057594000000000 72057595000000000
Output
26
Note
In the first sample Limak's interval contains numbers 510 = 1012, 610 = 1102, 710 = 1112, 810 = 10002, 910 = 10012 and 1010 = 10102. Two of them (1012 and 1102) have the described property.
Submitted Solution:
```
a,b=map(int,input().split())
bin_a=bin(a).replace("0b", "")
counter=0
q=''
bin_b=bin(b).replace("0b", "")
for p in range(len(bin_a)-1):
for i in range(len(bin_a)):
if p==len(bin_a)-1-i:
q=q+'0'
else:
q = q + '1'
#print(q)
if (int(q,2)>=a) and (b>=int(q,2)):
counter+=1
q = ''
if (len(bin_b)-len(bin_a))!=0:
for j in range(1,len(bin_b)-len(bin_a)):
counter=counter+len(bin_a)+j-1
print(counter)
``` | instruction | 0 | 56,752 | 20 | 113,504 |
No | output | 1 | 56,752 | 20 | 113,505 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem differs from the previous one only in the absence of the constraint on the equal length of all numbers a_1, a_2, ..., a_n.
A team of SIS students is going to make a trip on a submarine. Their target is an ancient treasure in a sunken ship lying on the bottom of the Great Rybinsk sea. Unfortunately, the students don't know the coordinates of the ship, so they asked Meshanya (who is a hereditary mage) to help them. He agreed to help them, but only if they solve his problem.
Let's denote a function that alternates digits of two numbers f(a_1 a_2 ... a_{p - 1} a_p, b_1 b_2 ... b_{q - 1} b_q), where a_1 ... a_p and b_1 ... b_q are digits of two integers written in the decimal notation without leading zeros.
In other words, the function f(x, y) alternately shuffles the digits of the numbers x and y by writing them from the lowest digits to the older ones, starting with the number y. The result of the function is also built from right to left (that is, from the lower digits to the older ones). If the digits of one of the arguments have ended, then the remaining digits of the other argument are written out. Familiarize with examples and formal definitions of the function below.
For example: $$$f(1111, 2222) = 12121212 f(7777, 888) = 7787878 f(33, 44444) = 4443434 f(555, 6) = 5556 f(111, 2222) = 2121212$$$
Formally,
* if p ≥ q then f(a_1 ... a_p, b_1 ... b_q) = a_1 a_2 ... a_{p - q + 1} b_1 a_{p - q + 2} b_2 ... a_{p - 1} b_{q - 1} a_p b_q;
* if p < q then f(a_1 ... a_p, b_1 ... b_q) = b_1 b_2 ... b_{q - p} a_1 b_{q - p + 1} a_2 ... a_{p - 1} b_{q - 1} a_p b_q.
Mishanya gives you an array consisting of n integers a_i, your task is to help students to calculate ∑_{i = 1}^{n}∑_{j = 1}^{n} f(a_i, a_j) modulo 998 244 353.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in the array. The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print the answer modulo 998 244 353.
Examples
Input
3
12 3 45
Output
12330
Input
2
123 456
Output
1115598 | instruction | 0 | 57,234 | 20 | 114,468 |
Tags: combinatorics, math, number theory
Correct Solution:
```
mod = 998244353
ten = [1]
for i in range(1, 30):
ten.append(ten[i - 1] * 10 % mod)
def funcxy(bit, x_l, y_l):
if x_l >= y_l:
if y_l > bit:
return ten[2 * bit + 1]
else:
return ten[bit + y_l]
else:
return ten[2 * bit + 1]
def funcyx(bit, x_l, y_l):
if x_l > y_l:
if y_l > bit:
return ten[2 * bit]
else:
return ten[bit + y_l]
else:
return ten[2 * bit]
n = int(input())
a = [x for x in input().split()]
length = [len(x) for x in a]
d = {}
for x in length:
if x in d:
d[x] += 1
else:
d[x] = 1
len_set = set(length)
res = 0
for x in a:
x_l = len(x)
x = [int(x_) for x_ in x[::-1]]
for i, xi in enumerate(x):
for y_l in len_set:
res += xi * funcxy(i, x_l, y_l) * d[y_l]
res += xi * funcyx(i, x_l, y_l) * d[y_l]
print(res % mod)
'''
if __name__ == "__main__":
print(funcxy(4, 2, 3))
print(funcyx(4, 2, 3))
'''
``` | output | 1 | 57,234 | 20 | 114,469 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem differs from the previous one only in the absence of the constraint on the equal length of all numbers a_1, a_2, ..., a_n.
A team of SIS students is going to make a trip on a submarine. Their target is an ancient treasure in a sunken ship lying on the bottom of the Great Rybinsk sea. Unfortunately, the students don't know the coordinates of the ship, so they asked Meshanya (who is a hereditary mage) to help them. He agreed to help them, but only if they solve his problem.
Let's denote a function that alternates digits of two numbers f(a_1 a_2 ... a_{p - 1} a_p, b_1 b_2 ... b_{q - 1} b_q), where a_1 ... a_p and b_1 ... b_q are digits of two integers written in the decimal notation without leading zeros.
In other words, the function f(x, y) alternately shuffles the digits of the numbers x and y by writing them from the lowest digits to the older ones, starting with the number y. The result of the function is also built from right to left (that is, from the lower digits to the older ones). If the digits of one of the arguments have ended, then the remaining digits of the other argument are written out. Familiarize with examples and formal definitions of the function below.
For example: $$$f(1111, 2222) = 12121212 f(7777, 888) = 7787878 f(33, 44444) = 4443434 f(555, 6) = 5556 f(111, 2222) = 2121212$$$
Formally,
* if p ≥ q then f(a_1 ... a_p, b_1 ... b_q) = a_1 a_2 ... a_{p - q + 1} b_1 a_{p - q + 2} b_2 ... a_{p - 1} b_{q - 1} a_p b_q;
* if p < q then f(a_1 ... a_p, b_1 ... b_q) = b_1 b_2 ... b_{q - p} a_1 b_{q - p + 1} a_2 ... a_{p - 1} b_{q - 1} a_p b_q.
Mishanya gives you an array consisting of n integers a_i, your task is to help students to calculate ∑_{i = 1}^{n}∑_{j = 1}^{n} f(a_i, a_j) modulo 998 244 353.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in the array. The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print the answer modulo 998 244 353.
Examples
Input
3
12 3 45
Output
12330
Input
2
123 456
Output
1115598 | instruction | 0 | 57,235 | 20 | 114,470 |
Tags: combinatorics, math, number theory
Correct Solution:
```
n=int(input())
ans=[0]*30
length=[0]*11
lol=[o for o in input().split()]
count=[0]*30
for i in range(n):
length[len(lol[i])-1]+=1
#print(length)
for i in range(n):
lol[i]=lol[i][::-1]
for j in range(len(lol[i])):
for k in range(j):
ans[2*k+(j-k)+1]+=2*(int(lol[i][j])*length[k])
# print("kuch?",2*k+j-k,lol[i][j],int(lol[i][j])*length[k])
for k in range(j,10):
ans[2*j]+= (int(lol[i][j])*length[k])
ans[2*j+1]+= (int(lol[i][j])*length[k])
#print(ans)
realans=["0"]*30
c=0
for i in range(30):
realans[i]=str(int(ans[i]+c)%10)
c=((ans[i]+c)//10)
#print(realans[i],c,ans[i])
print((int("".join(realans[::-1])))%998244353)
``` | output | 1 | 57,235 | 20 | 114,471 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem differs from the previous one only in the absence of the constraint on the equal length of all numbers a_1, a_2, ..., a_n.
A team of SIS students is going to make a trip on a submarine. Their target is an ancient treasure in a sunken ship lying on the bottom of the Great Rybinsk sea. Unfortunately, the students don't know the coordinates of the ship, so they asked Meshanya (who is a hereditary mage) to help them. He agreed to help them, but only if they solve his problem.
Let's denote a function that alternates digits of two numbers f(a_1 a_2 ... a_{p - 1} a_p, b_1 b_2 ... b_{q - 1} b_q), where a_1 ... a_p and b_1 ... b_q are digits of two integers written in the decimal notation without leading zeros.
In other words, the function f(x, y) alternately shuffles the digits of the numbers x and y by writing them from the lowest digits to the older ones, starting with the number y. The result of the function is also built from right to left (that is, from the lower digits to the older ones). If the digits of one of the arguments have ended, then the remaining digits of the other argument are written out. Familiarize with examples and formal definitions of the function below.
For example: $$$f(1111, 2222) = 12121212 f(7777, 888) = 7787878 f(33, 44444) = 4443434 f(555, 6) = 5556 f(111, 2222) = 2121212$$$
Formally,
* if p ≥ q then f(a_1 ... a_p, b_1 ... b_q) = a_1 a_2 ... a_{p - q + 1} b_1 a_{p - q + 2} b_2 ... a_{p - 1} b_{q - 1} a_p b_q;
* if p < q then f(a_1 ... a_p, b_1 ... b_q) = b_1 b_2 ... b_{q - p} a_1 b_{q - p + 1} a_2 ... a_{p - 1} b_{q - 1} a_p b_q.
Mishanya gives you an array consisting of n integers a_i, your task is to help students to calculate ∑_{i = 1}^{n}∑_{j = 1}^{n} f(a_i, a_j) modulo 998 244 353.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in the array. The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print the answer modulo 998 244 353.
Examples
Input
3
12 3 45
Output
12330
Input
2
123 456
Output
1115598 | instruction | 0 | 57,236 | 20 | 114,472 |
Tags: combinatorics, math, number theory
Correct Solution:
```
mod = 998244353
def count_digits(x):
return len(str(x))
n = int(input())
a = [int(x) for x in input().split(' ')]
digs = [0] * 11
ans = 0
for ai in a:
digs[count_digits(ai)] += 1
for ai in a:
x = ai
g = 1
for d in range(1, 11):
x = (x % g) + (x // g) * 10 * g
g *= 100
ans = (ans + ( (digs[d] * x) % mod ) ) % mod
x = ai
g = 10
for d in range(1, 11):
x = (x % g) + (x // g) * 10 * g
g *= 100
ans = (ans + ( (digs[d] * x) % mod )) % mod
print(ans)
``` | output | 1 | 57,236 | 20 | 114,473 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem differs from the previous one only in the absence of the constraint on the equal length of all numbers a_1, a_2, ..., a_n.
A team of SIS students is going to make a trip on a submarine. Their target is an ancient treasure in a sunken ship lying on the bottom of the Great Rybinsk sea. Unfortunately, the students don't know the coordinates of the ship, so they asked Meshanya (who is a hereditary mage) to help them. He agreed to help them, but only if they solve his problem.
Let's denote a function that alternates digits of two numbers f(a_1 a_2 ... a_{p - 1} a_p, b_1 b_2 ... b_{q - 1} b_q), where a_1 ... a_p and b_1 ... b_q are digits of two integers written in the decimal notation without leading zeros.
In other words, the function f(x, y) alternately shuffles the digits of the numbers x and y by writing them from the lowest digits to the older ones, starting with the number y. The result of the function is also built from right to left (that is, from the lower digits to the older ones). If the digits of one of the arguments have ended, then the remaining digits of the other argument are written out. Familiarize with examples and formal definitions of the function below.
For example: $$$f(1111, 2222) = 12121212 f(7777, 888) = 7787878 f(33, 44444) = 4443434 f(555, 6) = 5556 f(111, 2222) = 2121212$$$
Formally,
* if p ≥ q then f(a_1 ... a_p, b_1 ... b_q) = a_1 a_2 ... a_{p - q + 1} b_1 a_{p - q + 2} b_2 ... a_{p - 1} b_{q - 1} a_p b_q;
* if p < q then f(a_1 ... a_p, b_1 ... b_q) = b_1 b_2 ... b_{q - p} a_1 b_{q - p + 1} a_2 ... a_{p - 1} b_{q - 1} a_p b_q.
Mishanya gives you an array consisting of n integers a_i, your task is to help students to calculate ∑_{i = 1}^{n}∑_{j = 1}^{n} f(a_i, a_j) modulo 998 244 353.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in the array. The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print the answer modulo 998 244 353.
Examples
Input
3
12 3 45
Output
12330
Input
2
123 456
Output
1115598 | instruction | 0 | 57,237 | 20 | 114,474 |
Tags: combinatorics, math, number theory
Correct Solution:
```
import sys
def input():
return sys.stdin.readline().strip()
def dinput():
return int(input())
def tinput():
return input().split()
def rinput():
return map(str, tinput())
def rt(a, s):
t = ""
z = 0
x = len(a)
y = len(s)
while z < x and z < y:
t = t + a[z] + s[z]
z += 1
print(y, x , t)
if y > x:
t = t + s[z:]
else:
t = t + a[z:]
return int(t)
def main():
n = dinput()
q = list(rinput())
w = {}
ans = 0
for i in q:
if len(i) not in w:
w[len(i)] = 1
else:
w[len(i)] = w[len(i)] + 1
for i in range(n):
y = ""
x = ""
for j in range(1, 11):
c = q[i]
if len(c) > j:
a = c[0 : len(c) - j]
else:
a = ""
if len(c) - j >= 0:
y = "0" + c[len(c) - j] + y
x = c[len(c) - j] + "0" + x
l = a + y
r = a + x
if j in w:
ans += int(l) * w[j]
ans += int(r) * w[j]
print(ans % 998244353)
main()
``` | output | 1 | 57,237 | 20 | 114,475 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem differs from the previous one only in the absence of the constraint on the equal length of all numbers a_1, a_2, ..., a_n.
A team of SIS students is going to make a trip on a submarine. Their target is an ancient treasure in a sunken ship lying on the bottom of the Great Rybinsk sea. Unfortunately, the students don't know the coordinates of the ship, so they asked Meshanya (who is a hereditary mage) to help them. He agreed to help them, but only if they solve his problem.
Let's denote a function that alternates digits of two numbers f(a_1 a_2 ... a_{p - 1} a_p, b_1 b_2 ... b_{q - 1} b_q), where a_1 ... a_p and b_1 ... b_q are digits of two integers written in the decimal notation without leading zeros.
In other words, the function f(x, y) alternately shuffles the digits of the numbers x and y by writing them from the lowest digits to the older ones, starting with the number y. The result of the function is also built from right to left (that is, from the lower digits to the older ones). If the digits of one of the arguments have ended, then the remaining digits of the other argument are written out. Familiarize with examples and formal definitions of the function below.
For example: $$$f(1111, 2222) = 12121212 f(7777, 888) = 7787878 f(33, 44444) = 4443434 f(555, 6) = 5556 f(111, 2222) = 2121212$$$
Formally,
* if p ≥ q then f(a_1 ... a_p, b_1 ... b_q) = a_1 a_2 ... a_{p - q + 1} b_1 a_{p - q + 2} b_2 ... a_{p - 1} b_{q - 1} a_p b_q;
* if p < q then f(a_1 ... a_p, b_1 ... b_q) = b_1 b_2 ... b_{q - p} a_1 b_{q - p + 1} a_2 ... a_{p - 1} b_{q - 1} a_p b_q.
Mishanya gives you an array consisting of n integers a_i, your task is to help students to calculate ∑_{i = 1}^{n}∑_{j = 1}^{n} f(a_i, a_j) modulo 998 244 353.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in the array. The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print the answer modulo 998 244 353.
Examples
Input
3
12 3 45
Output
12330
Input
2
123 456
Output
1115598 | instruction | 0 | 57,238 | 20 | 114,476 |
Tags: combinatorics, math, number theory
Correct Solution:
```
import io, sys
input = lambda f=io.StringIO(sys.stdin.buffer.read().decode()).readline: f().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
MOD = 998244353
pow10 = [10 ** i % MOD for i in range(21)]
n = ii()
a = li()
rec = [0] * 11
cnt = [0] * 11
for x in a:
i = -1
while x:
i += 1
rec[i] += pow10[2 * i + 1]
x //= 10
cnt[i] += 1
j = 2 * i + 1
while i < 10:
i += 1
j += 1
rec[i] += pow10[j]
suf = [0] * 12
for i in range(10, -1, -1):
suf[i] = suf[i + 1] + cnt[i]
ans = 0
for x in a:
i = -1
while x:
i += 1
d = x % 10
ans += rec[i] * d
ans += d * pow10[2 * i] * suf[i] % MOD
x //= 10
ans += x * pow10[2 * i + 2] * cnt[i] % MOD
ans %= MOD
print(ans)
``` | output | 1 | 57,238 | 20 | 114,477 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem differs from the previous one only in the absence of the constraint on the equal length of all numbers a_1, a_2, ..., a_n.
A team of SIS students is going to make a trip on a submarine. Their target is an ancient treasure in a sunken ship lying on the bottom of the Great Rybinsk sea. Unfortunately, the students don't know the coordinates of the ship, so they asked Meshanya (who is a hereditary mage) to help them. He agreed to help them, but only if they solve his problem.
Let's denote a function that alternates digits of two numbers f(a_1 a_2 ... a_{p - 1} a_p, b_1 b_2 ... b_{q - 1} b_q), where a_1 ... a_p and b_1 ... b_q are digits of two integers written in the decimal notation without leading zeros.
In other words, the function f(x, y) alternately shuffles the digits of the numbers x and y by writing them from the lowest digits to the older ones, starting with the number y. The result of the function is also built from right to left (that is, from the lower digits to the older ones). If the digits of one of the arguments have ended, then the remaining digits of the other argument are written out. Familiarize with examples and formal definitions of the function below.
For example: $$$f(1111, 2222) = 12121212 f(7777, 888) = 7787878 f(33, 44444) = 4443434 f(555, 6) = 5556 f(111, 2222) = 2121212$$$
Formally,
* if p ≥ q then f(a_1 ... a_p, b_1 ... b_q) = a_1 a_2 ... a_{p - q + 1} b_1 a_{p - q + 2} b_2 ... a_{p - 1} b_{q - 1} a_p b_q;
* if p < q then f(a_1 ... a_p, b_1 ... b_q) = b_1 b_2 ... b_{q - p} a_1 b_{q - p + 1} a_2 ... a_{p - 1} b_{q - 1} a_p b_q.
Mishanya gives you an array consisting of n integers a_i, your task is to help students to calculate ∑_{i = 1}^{n}∑_{j = 1}^{n} f(a_i, a_j) modulo 998 244 353.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in the array. The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print the answer modulo 998 244 353.
Examples
Input
3
12 3 45
Output
12330
Input
2
123 456
Output
1115598 | instruction | 0 | 57,239 | 20 | 114,478 |
Tags: combinatorics, math, number theory
Correct Solution:
```
from collections import Counter
_MODER = 998244353
# split s
# def split_str(s):
# return '0'.join(list(s)) + '0'
def solve(n, a):
r = 0
c = Counter() # c[k]; number of elements whose length is k
for e in a:
c[len(str(e))] += 1
for e in a:
s = str(e)
current_len = len(s)
for k, v in c.items():
# s is a
if k >= current_len:
ns = '0'.join(list(s)) + '0'
else:
ns = s[:current_len - k] + '0'.join(list(s[current_len - k:])) + '0'
r = (r + (int(ns) * v) % _MODER) % _MODER
# s is b
if k >= current_len - 1:
ns = '0'.join(list(s))
else:
ns = s[:current_len - k - 1] + '0'.join(list(s[current_len - k - 1:]))
r = (r + (int(ns) * v) % _MODER) % _MODER
return r
n = int(input())
a = list(map(int, input().split()))
r = solve(n, a)
print(r)
``` | output | 1 | 57,239 | 20 | 114,479 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem differs from the previous one only in the absence of the constraint on the equal length of all numbers a_1, a_2, ..., a_n.
A team of SIS students is going to make a trip on a submarine. Their target is an ancient treasure in a sunken ship lying on the bottom of the Great Rybinsk sea. Unfortunately, the students don't know the coordinates of the ship, so they asked Meshanya (who is a hereditary mage) to help them. He agreed to help them, but only if they solve his problem.
Let's denote a function that alternates digits of two numbers f(a_1 a_2 ... a_{p - 1} a_p, b_1 b_2 ... b_{q - 1} b_q), where a_1 ... a_p and b_1 ... b_q are digits of two integers written in the decimal notation without leading zeros.
In other words, the function f(x, y) alternately shuffles the digits of the numbers x and y by writing them from the lowest digits to the older ones, starting with the number y. The result of the function is also built from right to left (that is, from the lower digits to the older ones). If the digits of one of the arguments have ended, then the remaining digits of the other argument are written out. Familiarize with examples and formal definitions of the function below.
For example: $$$f(1111, 2222) = 12121212 f(7777, 888) = 7787878 f(33, 44444) = 4443434 f(555, 6) = 5556 f(111, 2222) = 2121212$$$
Formally,
* if p ≥ q then f(a_1 ... a_p, b_1 ... b_q) = a_1 a_2 ... a_{p - q + 1} b_1 a_{p - q + 2} b_2 ... a_{p - 1} b_{q - 1} a_p b_q;
* if p < q then f(a_1 ... a_p, b_1 ... b_q) = b_1 b_2 ... b_{q - p} a_1 b_{q - p + 1} a_2 ... a_{p - 1} b_{q - 1} a_p b_q.
Mishanya gives you an array consisting of n integers a_i, your task is to help students to calculate ∑_{i = 1}^{n}∑_{j = 1}^{n} f(a_i, a_j) modulo 998 244 353.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in the array. The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print the answer modulo 998 244 353.
Examples
Input
3
12 3 45
Output
12330
Input
2
123 456
Output
1115598 | instruction | 0 | 57,240 | 20 | 114,480 |
Tags: combinatorics, math, number theory
Correct Solution:
```
n = int(input())
a = input().split()
b = {}
c = {}
for x in a:
y = len(x)
z = int(x)
b[y] = b.get(y, 0) + 1
c[z] = c.get(z, 0) + 1
M = 998244353
p = [1] * 30
for i in range(1, len(p)):
p[i] = p[i - 1] * 10 % M
ans = 0
for key, val in c.items():
w = 0
while key > 0:
d = key % 10
key //= 10
z = 0
for x, y in b.items():
z += y * (p[min(w, x)] + p[min(w + 1, x)])
ans += val * d * p[w] * z % M
w += 1
print(ans % M)
``` | output | 1 | 57,240 | 20 | 114,481 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem differs from the previous one only in the absence of the constraint on the equal length of all numbers a_1, a_2, ..., a_n.
A team of SIS students is going to make a trip on a submarine. Their target is an ancient treasure in a sunken ship lying on the bottom of the Great Rybinsk sea. Unfortunately, the students don't know the coordinates of the ship, so they asked Meshanya (who is a hereditary mage) to help them. He agreed to help them, but only if they solve his problem.
Let's denote a function that alternates digits of two numbers f(a_1 a_2 ... a_{p - 1} a_p, b_1 b_2 ... b_{q - 1} b_q), where a_1 ... a_p and b_1 ... b_q are digits of two integers written in the decimal notation without leading zeros.
In other words, the function f(x, y) alternately shuffles the digits of the numbers x and y by writing them from the lowest digits to the older ones, starting with the number y. The result of the function is also built from right to left (that is, from the lower digits to the older ones). If the digits of one of the arguments have ended, then the remaining digits of the other argument are written out. Familiarize with examples and formal definitions of the function below.
For example: $$$f(1111, 2222) = 12121212 f(7777, 888) = 7787878 f(33, 44444) = 4443434 f(555, 6) = 5556 f(111, 2222) = 2121212$$$
Formally,
* if p ≥ q then f(a_1 ... a_p, b_1 ... b_q) = a_1 a_2 ... a_{p - q + 1} b_1 a_{p - q + 2} b_2 ... a_{p - 1} b_{q - 1} a_p b_q;
* if p < q then f(a_1 ... a_p, b_1 ... b_q) = b_1 b_2 ... b_{q - p} a_1 b_{q - p + 1} a_2 ... a_{p - 1} b_{q - 1} a_p b_q.
Mishanya gives you an array consisting of n integers a_i, your task is to help students to calculate ∑_{i = 1}^{n}∑_{j = 1}^{n} f(a_i, a_j) modulo 998 244 353.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in the array. The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print the answer modulo 998 244 353.
Examples
Input
3
12 3 45
Output
12330
Input
2
123 456
Output
1115598 | instruction | 0 | 57,241 | 20 | 114,482 |
Tags: combinatorics, math, number theory
Correct Solution:
```
import sys
input = sys.stdin.readline
n=int(input())
A=list(input().split())
mod= 998244353
def calc(a,k):
a0=a[-k:]
a1=a[:-k]
A1=0
if a1!="":
A1 = int(a1)*(10**(k*2))*2
ANS=""
for k in a0:
ANS+=k*2
return A1+int(ANS)
L=[len(a) for a in A]
from collections import Counter
C=Counter(L)
ANS=0
for a in A:
#LEN_a=len(a)
for k in range(1,11):
x=C[k]
#if k==LEN_a:
# x-=1
ANS=(ANS+calc(a,k)*x)%mod
print(ANS)
``` | output | 1 | 57,241 | 20 | 114,483 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem differs from the previous one only in the absence of the constraint on the equal length of all numbers a_1, a_2, ..., a_n.
A team of SIS students is going to make a trip on a submarine. Their target is an ancient treasure in a sunken ship lying on the bottom of the Great Rybinsk sea. Unfortunately, the students don't know the coordinates of the ship, so they asked Meshanya (who is a hereditary mage) to help them. He agreed to help them, but only if they solve his problem.
Let's denote a function that alternates digits of two numbers f(a_1 a_2 ... a_{p - 1} a_p, b_1 b_2 ... b_{q - 1} b_q), where a_1 ... a_p and b_1 ... b_q are digits of two integers written in the decimal notation without leading zeros.
In other words, the function f(x, y) alternately shuffles the digits of the numbers x and y by writing them from the lowest digits to the older ones, starting with the number y. The result of the function is also built from right to left (that is, from the lower digits to the older ones). If the digits of one of the arguments have ended, then the remaining digits of the other argument are written out. Familiarize with examples and formal definitions of the function below.
For example: $$$f(1111, 2222) = 12121212 f(7777, 888) = 7787878 f(33, 44444) = 4443434 f(555, 6) = 5556 f(111, 2222) = 2121212$$$
Formally,
* if p ≥ q then f(a_1 ... a_p, b_1 ... b_q) = a_1 a_2 ... a_{p - q + 1} b_1 a_{p - q + 2} b_2 ... a_{p - 1} b_{q - 1} a_p b_q;
* if p < q then f(a_1 ... a_p, b_1 ... b_q) = b_1 b_2 ... b_{q - p} a_1 b_{q - p + 1} a_2 ... a_{p - 1} b_{q - 1} a_p b_q.
Mishanya gives you an array consisting of n integers a_i, your task is to help students to calculate ∑_{i = 1}^{n}∑_{j = 1}^{n} f(a_i, a_j) modulo 998 244 353.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in the array. The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print the answer modulo 998 244 353.
Examples
Input
3
12 3 45
Output
12330
Input
2
123 456
Output
1115598
Submitted Solution:
```
from collections import Counter
b = 998244353
if __name__ == '__main__':
n = int(input())
arr = input().split()
mp = list(map(lambda x: len(x),arr))
cnt = Counter(mp)
s = 0
for a in arr:
l = list(reversed(a))
for num, ln in cnt.items():
l1 = int("".join(list(reversed(["%s0" % x if i < num else x for i, x in enumerate(l)]))))
l2 = int("".join(list(reversed(["0%s" % x if j < num else x for j, x in enumerate(l)]))))
s = (s + l1 * ln) % b
s = (s + l2 * ln) % b
print(s)
``` | instruction | 0 | 57,242 | 20 | 114,484 |
Yes | output | 1 | 57,242 | 20 | 114,485 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem differs from the previous one only in the absence of the constraint on the equal length of all numbers a_1, a_2, ..., a_n.
A team of SIS students is going to make a trip on a submarine. Their target is an ancient treasure in a sunken ship lying on the bottom of the Great Rybinsk sea. Unfortunately, the students don't know the coordinates of the ship, so they asked Meshanya (who is a hereditary mage) to help them. He agreed to help them, but only if they solve his problem.
Let's denote a function that alternates digits of two numbers f(a_1 a_2 ... a_{p - 1} a_p, b_1 b_2 ... b_{q - 1} b_q), where a_1 ... a_p and b_1 ... b_q are digits of two integers written in the decimal notation without leading zeros.
In other words, the function f(x, y) alternately shuffles the digits of the numbers x and y by writing them from the lowest digits to the older ones, starting with the number y. The result of the function is also built from right to left (that is, from the lower digits to the older ones). If the digits of one of the arguments have ended, then the remaining digits of the other argument are written out. Familiarize with examples and formal definitions of the function below.
For example: $$$f(1111, 2222) = 12121212 f(7777, 888) = 7787878 f(33, 44444) = 4443434 f(555, 6) = 5556 f(111, 2222) = 2121212$$$
Formally,
* if p ≥ q then f(a_1 ... a_p, b_1 ... b_q) = a_1 a_2 ... a_{p - q + 1} b_1 a_{p - q + 2} b_2 ... a_{p - 1} b_{q - 1} a_p b_q;
* if p < q then f(a_1 ... a_p, b_1 ... b_q) = b_1 b_2 ... b_{q - p} a_1 b_{q - p + 1} a_2 ... a_{p - 1} b_{q - 1} a_p b_q.
Mishanya gives you an array consisting of n integers a_i, your task is to help students to calculate ∑_{i = 1}^{n}∑_{j = 1}^{n} f(a_i, a_j) modulo 998 244 353.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in the array. The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print the answer modulo 998 244 353.
Examples
Input
3
12 3 45
Output
12330
Input
2
123 456
Output
1115598
Submitted Solution:
```
# -*- coding: utf-8 -*-
# @Date : 2019-07-18 08:25:39
# @Author : raj lath (oorja.halt@gmail.com)
# @Link : link
# @Version : 1.0.0
# Thanks to proizvedenie
import sys
sys.setrecursionlimit(10**5+1)
inf = int(10 ** 20)
max_val = inf
min_val = -inf
RW = lambda : sys.stdin.readline().strip()
RI = lambda : int(RW())
RMI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
RWI = lambda : [x for x in sys.stdin.readline().strip().split()]
MOD = 998244353
def pads(x, k):
e , r = 1, 0
while x > 0:
x, m = divmod(x, 10)
r += e * m
e *= [10, 100][k > 0]
k -= 1
return r % MOD
nb = RI()
arr = RMI()
lcnt= [0] * 11
for i in arr:
lcnt[len(str(i))] += 1
#print(lcnt)
r = 0
for j in range(1, 11):
for i in range(nb):
r = (r + lcnt[j] * (pads(arr[i], j) + 10 * pads(arr[i], j-1))) % MOD
print(r)
``` | instruction | 0 | 57,243 | 20 | 114,486 |
Yes | output | 1 | 57,243 | 20 | 114,487 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem differs from the previous one only in the absence of the constraint on the equal length of all numbers a_1, a_2, ..., a_n.
A team of SIS students is going to make a trip on a submarine. Their target is an ancient treasure in a sunken ship lying on the bottom of the Great Rybinsk sea. Unfortunately, the students don't know the coordinates of the ship, so they asked Meshanya (who is a hereditary mage) to help them. He agreed to help them, but only if they solve his problem.
Let's denote a function that alternates digits of two numbers f(a_1 a_2 ... a_{p - 1} a_p, b_1 b_2 ... b_{q - 1} b_q), where a_1 ... a_p and b_1 ... b_q are digits of two integers written in the decimal notation without leading zeros.
In other words, the function f(x, y) alternately shuffles the digits of the numbers x and y by writing them from the lowest digits to the older ones, starting with the number y. The result of the function is also built from right to left (that is, from the lower digits to the older ones). If the digits of one of the arguments have ended, then the remaining digits of the other argument are written out. Familiarize with examples and formal definitions of the function below.
For example: $$$f(1111, 2222) = 12121212 f(7777, 888) = 7787878 f(33, 44444) = 4443434 f(555, 6) = 5556 f(111, 2222) = 2121212$$$
Formally,
* if p ≥ q then f(a_1 ... a_p, b_1 ... b_q) = a_1 a_2 ... a_{p - q + 1} b_1 a_{p - q + 2} b_2 ... a_{p - 1} b_{q - 1} a_p b_q;
* if p < q then f(a_1 ... a_p, b_1 ... b_q) = b_1 b_2 ... b_{q - p} a_1 b_{q - p + 1} a_2 ... a_{p - 1} b_{q - 1} a_p b_q.
Mishanya gives you an array consisting of n integers a_i, your task is to help students to calculate ∑_{i = 1}^{n}∑_{j = 1}^{n} f(a_i, a_j) modulo 998 244 353.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in the array. The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print the answer modulo 998 244 353.
Examples
Input
3
12 3 45
Output
12330
Input
2
123 456
Output
1115598
Submitted Solution:
```
mod = 998244353
pws = [1]
for i in range(1, 22):
pws.append(pws[i - 1] * 10)
n = int(input())
h = list(map(int, input().split()))
a = [[] for i in range(n)]
for i in range(n):
x = h[i]
while x:
a[i].append(x % 10)
x = x // 10
cnt = [0] * 11
for i in range(n):
cnt[len(a[i])] += 1
s = 0
for i in range(n):
for j in range(len(a[i])):
cur = 0
for k in range(1, j):
s = (s + a[i][j] * pws[j + k] * cnt[k]) % mod
cur += cnt[k]
s = (s + a[i][j] * pws[2 * j] * (n - cur)) % mod
cur = 0
for k in range(1, j + 1):
s = (s + a[i][j] * pws[j + k] * cnt[k]) % mod
cur += cnt[k]
s = (s + a[i][j] * pws[2 * j + 1] * (n - cur)) % mod
print(s)
``` | instruction | 0 | 57,244 | 20 | 114,488 |
Yes | output | 1 | 57,244 | 20 | 114,489 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem differs from the previous one only in the absence of the constraint on the equal length of all numbers a_1, a_2, ..., a_n.
A team of SIS students is going to make a trip on a submarine. Their target is an ancient treasure in a sunken ship lying on the bottom of the Great Rybinsk sea. Unfortunately, the students don't know the coordinates of the ship, so they asked Meshanya (who is a hereditary mage) to help them. He agreed to help them, but only if they solve his problem.
Let's denote a function that alternates digits of two numbers f(a_1 a_2 ... a_{p - 1} a_p, b_1 b_2 ... b_{q - 1} b_q), where a_1 ... a_p and b_1 ... b_q are digits of two integers written in the decimal notation without leading zeros.
In other words, the function f(x, y) alternately shuffles the digits of the numbers x and y by writing them from the lowest digits to the older ones, starting with the number y. The result of the function is also built from right to left (that is, from the lower digits to the older ones). If the digits of one of the arguments have ended, then the remaining digits of the other argument are written out. Familiarize with examples and formal definitions of the function below.
For example: $$$f(1111, 2222) = 12121212 f(7777, 888) = 7787878 f(33, 44444) = 4443434 f(555, 6) = 5556 f(111, 2222) = 2121212$$$
Formally,
* if p ≥ q then f(a_1 ... a_p, b_1 ... b_q) = a_1 a_2 ... a_{p - q + 1} b_1 a_{p - q + 2} b_2 ... a_{p - 1} b_{q - 1} a_p b_q;
* if p < q then f(a_1 ... a_p, b_1 ... b_q) = b_1 b_2 ... b_{q - p} a_1 b_{q - p + 1} a_2 ... a_{p - 1} b_{q - 1} a_p b_q.
Mishanya gives you an array consisting of n integers a_i, your task is to help students to calculate ∑_{i = 1}^{n}∑_{j = 1}^{n} f(a_i, a_j) modulo 998 244 353.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in the array. The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print the answer modulo 998 244 353.
Examples
Input
3
12 3 45
Output
12330
Input
2
123 456
Output
1115598
Submitted Solution:
```
input() # discard n
a = list(map(int, input().split()))
cl = [0]*10
for i in a: cl[len(str(i))-1] += 1
ans, M = 0, 998244353
pad = lambda a, d: a%d + (a - a%d) * 10
for i in a:
for p,le in enumerate(cl):
ans = (ans + i*10 * le) # bottom zero pad
i = pad(i, 10 * 100**p)
ans = (ans + i * le) # top zero pad
print(ans % M)
``` | instruction | 0 | 57,245 | 20 | 114,490 |
Yes | output | 1 | 57,245 | 20 | 114,491 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem differs from the previous one only in the absence of the constraint on the equal length of all numbers a_1, a_2, ..., a_n.
A team of SIS students is going to make a trip on a submarine. Their target is an ancient treasure in a sunken ship lying on the bottom of the Great Rybinsk sea. Unfortunately, the students don't know the coordinates of the ship, so they asked Meshanya (who is a hereditary mage) to help them. He agreed to help them, but only if they solve his problem.
Let's denote a function that alternates digits of two numbers f(a_1 a_2 ... a_{p - 1} a_p, b_1 b_2 ... b_{q - 1} b_q), where a_1 ... a_p and b_1 ... b_q are digits of two integers written in the decimal notation without leading zeros.
In other words, the function f(x, y) alternately shuffles the digits of the numbers x and y by writing them from the lowest digits to the older ones, starting with the number y. The result of the function is also built from right to left (that is, from the lower digits to the older ones). If the digits of one of the arguments have ended, then the remaining digits of the other argument are written out. Familiarize with examples and formal definitions of the function below.
For example: $$$f(1111, 2222) = 12121212 f(7777, 888) = 7787878 f(33, 44444) = 4443434 f(555, 6) = 5556 f(111, 2222) = 2121212$$$
Formally,
* if p ≥ q then f(a_1 ... a_p, b_1 ... b_q) = a_1 a_2 ... a_{p - q + 1} b_1 a_{p - q + 2} b_2 ... a_{p - 1} b_{q - 1} a_p b_q;
* if p < q then f(a_1 ... a_p, b_1 ... b_q) = b_1 b_2 ... b_{q - p} a_1 b_{q - p + 1} a_2 ... a_{p - 1} b_{q - 1} a_p b_q.
Mishanya gives you an array consisting of n integers a_i, your task is to help students to calculate ∑_{i = 1}^{n}∑_{j = 1}^{n} f(a_i, a_j) modulo 998 244 353.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in the array. The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print the answer modulo 998 244 353.
Examples
Input
3
12 3 45
Output
12330
Input
2
123 456
Output
1115598
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
# ------------------------------
def main():
n = N()
arr = RLL()
res = 0
ldic = defaultdict(int)
for i in arr:
ldic[len(str(i))]+=1
for i in arr:
pre = suf = 0
tag = 1
ole = len(str(i))
while i>0:
lst = i%10
pre += lst*tag
suf += lst*(tag*10)
tag*=100
i//=10
le = ldic[ole-(len(str(i)) if i!=0 else 0)]
if le!=0:
res = (res + pre * le % mod + suf * le % mod + 2*i*tag) % mod
grt = 0
for j in ldic:
if j>ole: grt+=ldic[j]
res = (res + pre * grt % mod + suf * grt % mod) % mod
print(res%mod)
if __name__ == "__main__":
main()
``` | instruction | 0 | 57,246 | 20 | 114,492 |
No | output | 1 | 57,246 | 20 | 114,493 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem differs from the previous one only in the absence of the constraint on the equal length of all numbers a_1, a_2, ..., a_n.
A team of SIS students is going to make a trip on a submarine. Their target is an ancient treasure in a sunken ship lying on the bottom of the Great Rybinsk sea. Unfortunately, the students don't know the coordinates of the ship, so they asked Meshanya (who is a hereditary mage) to help them. He agreed to help them, but only if they solve his problem.
Let's denote a function that alternates digits of two numbers f(a_1 a_2 ... a_{p - 1} a_p, b_1 b_2 ... b_{q - 1} b_q), where a_1 ... a_p and b_1 ... b_q are digits of two integers written in the decimal notation without leading zeros.
In other words, the function f(x, y) alternately shuffles the digits of the numbers x and y by writing them from the lowest digits to the older ones, starting with the number y. The result of the function is also built from right to left (that is, from the lower digits to the older ones). If the digits of one of the arguments have ended, then the remaining digits of the other argument are written out. Familiarize with examples and formal definitions of the function below.
For example: $$$f(1111, 2222) = 12121212 f(7777, 888) = 7787878 f(33, 44444) = 4443434 f(555, 6) = 5556 f(111, 2222) = 2121212$$$
Formally,
* if p ≥ q then f(a_1 ... a_p, b_1 ... b_q) = a_1 a_2 ... a_{p - q + 1} b_1 a_{p - q + 2} b_2 ... a_{p - 1} b_{q - 1} a_p b_q;
* if p < q then f(a_1 ... a_p, b_1 ... b_q) = b_1 b_2 ... b_{q - p} a_1 b_{q - p + 1} a_2 ... a_{p - 1} b_{q - 1} a_p b_q.
Mishanya gives you an array consisting of n integers a_i, your task is to help students to calculate ∑_{i = 1}^{n}∑_{j = 1}^{n} f(a_i, a_j) modulo 998 244 353.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in the array. The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print the answer modulo 998 244 353.
Examples
Input
3
12 3 45
Output
12330
Input
2
123 456
Output
1115598
Submitted Solution:
```
modulo = 998244353
from collections import Counter
def conv(x):
res = 0
for v in x:
res = (res * 100 + int(v)) % modulo
return res
n = int(input())
x = list(input().split())
c = Counter(len(v) for v in x)
res = 0
for v in x:
u = len(v)
for w, k in c.items():
if w >= u:
res += k * 11 * conv(v)
else:
d = u - w
res += k * 11 * conv(v[d:])
res += k * 2 * int(v[:d]) * (10 ** (w+1))
res %= modulo
print(res)
``` | instruction | 0 | 57,247 | 20 | 114,494 |
No | output | 1 | 57,247 | 20 | 114,495 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem differs from the previous one only in the absence of the constraint on the equal length of all numbers a_1, a_2, ..., a_n.
A team of SIS students is going to make a trip on a submarine. Their target is an ancient treasure in a sunken ship lying on the bottom of the Great Rybinsk sea. Unfortunately, the students don't know the coordinates of the ship, so they asked Meshanya (who is a hereditary mage) to help them. He agreed to help them, but only if they solve his problem.
Let's denote a function that alternates digits of two numbers f(a_1 a_2 ... a_{p - 1} a_p, b_1 b_2 ... b_{q - 1} b_q), where a_1 ... a_p and b_1 ... b_q are digits of two integers written in the decimal notation without leading zeros.
In other words, the function f(x, y) alternately shuffles the digits of the numbers x and y by writing them from the lowest digits to the older ones, starting with the number y. The result of the function is also built from right to left (that is, from the lower digits to the older ones). If the digits of one of the arguments have ended, then the remaining digits of the other argument are written out. Familiarize with examples and formal definitions of the function below.
For example: $$$f(1111, 2222) = 12121212 f(7777, 888) = 7787878 f(33, 44444) = 4443434 f(555, 6) = 5556 f(111, 2222) = 2121212$$$
Formally,
* if p ≥ q then f(a_1 ... a_p, b_1 ... b_q) = a_1 a_2 ... a_{p - q + 1} b_1 a_{p - q + 2} b_2 ... a_{p - 1} b_{q - 1} a_p b_q;
* if p < q then f(a_1 ... a_p, b_1 ... b_q) = b_1 b_2 ... b_{q - p} a_1 b_{q - p + 1} a_2 ... a_{p - 1} b_{q - 1} a_p b_q.
Mishanya gives you an array consisting of n integers a_i, your task is to help students to calculate ∑_{i = 1}^{n}∑_{j = 1}^{n} f(a_i, a_j) modulo 998 244 353.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in the array. The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print the answer modulo 998 244 353.
Examples
Input
3
12 3 45
Output
12330
Input
2
123 456
Output
1115598
Submitted Solution:
```
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
import math
n=int(input());mod=998244353
vals=[[int(i) for i in k] for k in input().split()]
#only the lengths of the digits matter i think
#the length of the digit is at most 9 so O(2*9n) time
length=[0 for s in range(9)]
for i in range(n):
digits=len(vals[i])
length[digits-1]+=1
ans=0
#this is for the last entry
for i in range(n):
digits=len(vals[i])
for s in range(9):
cv=0;count=0
if digits-2<=s:
#if the digit is less than or equal to the number before it
for b in range(digits-1,-1,-1):
count+=vals[i][b]*pow(10,cv,mod)
count=count%mod
cv+=2
else:
count+=vals[i][-1]
cv+=2
#then the digit is greater
for b in range(digits-2,digits-3-s,-1):
count+=vals[i][b]*pow(10,cv,mod)
count=count%mod
cv+=2
cv-=1
for b in range(digits-3-s,-1,-1):
count+=vals[i][b]*pow(10,cv,mod)
count=count%mod
cv+=1
ans+=(count*length[s])%mod
ans=ans%mod
#first entry now
for i in range(n):
digits=len(vals[i])
for s in range(9):
cv=1;count=0
if digits-1<=s:
#if the digits is less than or equal to s
for b in range(digits-1,-1,-1):
count+=vals[i][b]*pow(10,cv,mod)
count=count%mod
cv+=2
else:
#digits are greater than s
for b in range(digits-1,digits-2-s,-1):
count+=vals[i][b]*pow(10,cv,mod)
count=count%mod
cv+=2
cv-=1
for b in range(digits-2-s,-1,-1):
count+=vals[i][b]*pow(10,cv,mod)
count=count%mod
cv+=1
ans+=(count*length[s])%mod
print(ans)
``` | instruction | 0 | 57,248 | 20 | 114,496 |
No | output | 1 | 57,248 | 20 | 114,497 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem differs from the previous one only in the absence of the constraint on the equal length of all numbers a_1, a_2, ..., a_n.
A team of SIS students is going to make a trip on a submarine. Their target is an ancient treasure in a sunken ship lying on the bottom of the Great Rybinsk sea. Unfortunately, the students don't know the coordinates of the ship, so they asked Meshanya (who is a hereditary mage) to help them. He agreed to help them, but only if they solve his problem.
Let's denote a function that alternates digits of two numbers f(a_1 a_2 ... a_{p - 1} a_p, b_1 b_2 ... b_{q - 1} b_q), where a_1 ... a_p and b_1 ... b_q are digits of two integers written in the decimal notation without leading zeros.
In other words, the function f(x, y) alternately shuffles the digits of the numbers x and y by writing them from the lowest digits to the older ones, starting with the number y. The result of the function is also built from right to left (that is, from the lower digits to the older ones). If the digits of one of the arguments have ended, then the remaining digits of the other argument are written out. Familiarize with examples and formal definitions of the function below.
For example: $$$f(1111, 2222) = 12121212 f(7777, 888) = 7787878 f(33, 44444) = 4443434 f(555, 6) = 5556 f(111, 2222) = 2121212$$$
Formally,
* if p ≥ q then f(a_1 ... a_p, b_1 ... b_q) = a_1 a_2 ... a_{p - q + 1} b_1 a_{p - q + 2} b_2 ... a_{p - 1} b_{q - 1} a_p b_q;
* if p < q then f(a_1 ... a_p, b_1 ... b_q) = b_1 b_2 ... b_{q - p} a_1 b_{q - p + 1} a_2 ... a_{p - 1} b_{q - 1} a_p b_q.
Mishanya gives you an array consisting of n integers a_i, your task is to help students to calculate ∑_{i = 1}^{n}∑_{j = 1}^{n} f(a_i, a_j) modulo 998 244 353.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in the array. The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print the answer modulo 998 244 353.
Examples
Input
3
12 3 45
Output
12330
Input
2
123 456
Output
1115598
Submitted Solution:
```
n=int(input())
l=list(input().strip().split())
sum=0
dic={}
for i in range(n):
if len(l[i]) in dic:
dic[len(l[i])]+=1
else:
dic[len(l[i])]=1
def calc(a,k):
a0=a[-k:]
a1=a[:-k]
A1=0
if a1!='':
A1=int(a1)*(10**(k*2))*2
ans=''
for k in a0:
ans+=k*2
return A1+int(ans)
for i in range(n):
for k in dic:
sum+=calc(l[i],k)*dic[k]%998244353
print(sum)
``` | instruction | 0 | 57,249 | 20 | 114,498 |
No | output | 1 | 57,249 | 20 | 114,499 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation.
The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3.
You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum.
Input
The first line contains a non-empty string s — the sum Xenia needs to count. String s contains no spaces. It only contains digits and characters "+". Besides, string s is a correct sum of numbers 1, 2 and 3. String s is at most 100 characters long.
Output
Print the new sum that Xenia can count.
Examples
Input
3+2+1
Output
1+2+3
Input
1+1+3+1+3
Output
1+1+1+3+3
Input
2
Output
2 | instruction | 0 | 57,435 | 20 | 114,870 |
Tags: greedy, implementation, sortings, strings
Correct Solution:
```
s = input()
s_len = len(s)
if s_len is 1:
print(s)
exit()
else:
new_list = s.split("+")
new_list.sort()
for number in range(len(new_list) - 1):
print(new_list[number] + "+", end="")
print(new_list[len(new_list) - 1])
``` | output | 1 | 57,435 | 20 | 114,871 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation.
The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3.
You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum.
Input
The first line contains a non-empty string s — the sum Xenia needs to count. String s contains no spaces. It only contains digits and characters "+". Besides, string s is a correct sum of numbers 1, 2 and 3. String s is at most 100 characters long.
Output
Print the new sum that Xenia can count.
Examples
Input
3+2+1
Output
1+2+3
Input
1+1+3+1+3
Output
1+1+1+3+3
Input
2
Output
2 | instruction | 0 | 57,436 | 20 | 114,872 |
Tags: greedy, implementation, sortings, strings
Correct Solution:
```
k=input()
l=k.split('+')
l=sorted(list(map(int,l)))
l=list(map(str,l))
print("+".join(l))
``` | output | 1 | 57,436 | 20 | 114,873 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation.
The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3.
You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum.
Input
The first line contains a non-empty string s — the sum Xenia needs to count. String s contains no spaces. It only contains digits and characters "+". Besides, string s is a correct sum of numbers 1, 2 and 3. String s is at most 100 characters long.
Output
Print the new sum that Xenia can count.
Examples
Input
3+2+1
Output
1+2+3
Input
1+1+3+1+3
Output
1+1+1+3+3
Input
2
Output
2 | instruction | 0 | 57,437 | 20 | 114,874 |
Tags: greedy, implementation, sortings, strings
Correct Solution:
```
mas = input()
if len(mas) == 1:
print(mas)
else:
print('+'.join(sorted(mas.split('+'))))
``` | output | 1 | 57,437 | 20 | 114,875 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation.
The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3.
You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum.
Input
The first line contains a non-empty string s — the sum Xenia needs to count. String s contains no spaces. It only contains digits and characters "+". Besides, string s is a correct sum of numbers 1, 2 and 3. String s is at most 100 characters long.
Output
Print the new sum that Xenia can count.
Examples
Input
3+2+1
Output
1+2+3
Input
1+1+3+1+3
Output
1+1+1+3+3
Input
2
Output
2 | instruction | 0 | 57,438 | 20 | 114,876 |
Tags: greedy, implementation, sortings, strings
Correct Solution:
```
def main():
numbers = sorted(list(map(int, input().split("+"))))
def can_calculate(numbers, current_number = 0):
if current_number == len(numbers) - 1:
return f"{numbers[current_number]}"
return f"{numbers[current_number]}+" + can_calculate(numbers, current_number + 1)
print(can_calculate(numbers))
if __name__ == '__main__':
main()
``` | output | 1 | 57,438 | 20 | 114,877 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation.
The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3.
You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum.
Input
The first line contains a non-empty string s — the sum Xenia needs to count. String s contains no spaces. It only contains digits and characters "+". Besides, string s is a correct sum of numbers 1, 2 and 3. String s is at most 100 characters long.
Output
Print the new sum that Xenia can count.
Examples
Input
3+2+1
Output
1+2+3
Input
1+1+3+1+3
Output
1+1+1+3+3
Input
2
Output
2 | instruction | 0 | 57,439 | 20 | 114,878 |
Tags: greedy, implementation, sortings, strings
Correct Solution:
```
inp = input()
tokens = list(map(int, inp.split("+")))
tokens.sort()
print('+'.join(map(str,tokens)))
``` | output | 1 | 57,439 | 20 | 114,879 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation.
The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3.
You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum.
Input
The first line contains a non-empty string s — the sum Xenia needs to count. String s contains no spaces. It only contains digits and characters "+". Besides, string s is a correct sum of numbers 1, 2 and 3. String s is at most 100 characters long.
Output
Print the new sum that Xenia can count.
Examples
Input
3+2+1
Output
1+2+3
Input
1+1+3+1+3
Output
1+1+1+3+3
Input
2
Output
2 | instruction | 0 | 57,440 | 20 | 114,880 |
Tags: greedy, implementation, sortings, strings
Correct Solution:
```
word=input()
final_str=""
num_list=list(map(int,word.split("+")))
num_list.sort()
for i in range(0,len(num_list)):
final_str+=str(num_list[i])+"+"
print(final_str[0:len(final_str)-1])
``` | output | 1 | 57,440 | 20 | 114,881 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation.
The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3.
You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum.
Input
The first line contains a non-empty string s — the sum Xenia needs to count. String s contains no spaces. It only contains digits and characters "+". Besides, string s is a correct sum of numbers 1, 2 and 3. String s is at most 100 characters long.
Output
Print the new sum that Xenia can count.
Examples
Input
3+2+1
Output
1+2+3
Input
1+1+3+1+3
Output
1+1+1+3+3
Input
2
Output
2 | instruction | 0 | 57,441 | 20 | 114,882 |
Tags: greedy, implementation, sortings, strings
Correct Solution:
```
a = input("").split("+")
a = sorted(a)
print("+".join(a))
``` | output | 1 | 57,441 | 20 | 114,883 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation.
The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3.
You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum.
Input
The first line contains a non-empty string s — the sum Xenia needs to count. String s contains no spaces. It only contains digits and characters "+". Besides, string s is a correct sum of numbers 1, 2 and 3. String s is at most 100 characters long.
Output
Print the new sum that Xenia can count.
Examples
Input
3+2+1
Output
1+2+3
Input
1+1+3+1+3
Output
1+1+1+3+3
Input
2
Output
2 | instruction | 0 | 57,442 | 20 | 114,884 |
Tags: greedy, implementation, sortings, strings
Correct Solution:
```
print("+".join(sorted(list(input().split("+"))))) # whatever
``` | output | 1 | 57,442 | 20 | 114,885 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation.
The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3.
You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum.
Input
The first line contains a non-empty string s — the sum Xenia needs to count. String s contains no spaces. It only contains digits and characters "+". Besides, string s is a correct sum of numbers 1, 2 and 3. String s is at most 100 characters long.
Output
Print the new sum that Xenia can count.
Examples
Input
3+2+1
Output
1+2+3
Input
1+1+3+1+3
Output
1+1+1+3+3
Input
2
Output
2
Submitted Solution:
```
s = list(map(int,input().split("+")))
s.sort()
s = list(map(str,s))
print('+'.join(s))
``` | instruction | 0 | 57,443 | 20 | 114,886 |
Yes | output | 1 | 57,443 | 20 | 114,887 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation.
The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3.
You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum.
Input
The first line contains a non-empty string s — the sum Xenia needs to count. String s contains no spaces. It only contains digits and characters "+". Besides, string s is a correct sum of numbers 1, 2 and 3. String s is at most 100 characters long.
Output
Print the new sum that Xenia can count.
Examples
Input
3+2+1
Output
1+2+3
Input
1+1+3+1+3
Output
1+1+1+3+3
Input
2
Output
2
Submitted Solution:
```
numbers = list(map(int,input().split("+")))
numbers.sort()
result = ""
for i in range(len(numbers)):
if i != len(numbers)-1:
result += str(numbers[i])+"+"
else:
result += str(numbers[i])
print(result)
``` | instruction | 0 | 57,445 | 20 | 114,890 |
Yes | output | 1 | 57,445 | 20 | 114,891 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation.
The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3.
You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum.
Input
The first line contains a non-empty string s — the sum Xenia needs to count. String s contains no spaces. It only contains digits and characters "+". Besides, string s is a correct sum of numbers 1, 2 and 3. String s is at most 100 characters long.
Output
Print the new sum that Xenia can count.
Examples
Input
3+2+1
Output
1+2+3
Input
1+1+3+1+3
Output
1+1+1+3+3
Input
2
Output
2
Submitted Solution:
```
ar = list(input().rstrip().split('+'))
ar.sort()
print("+".join(ar))
``` | instruction | 0 | 57,446 | 20 | 114,892 |
Yes | output | 1 | 57,446 | 20 | 114,893 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation.
The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3.
You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum.
Input
The first line contains a non-empty string s — the sum Xenia needs to count. String s contains no spaces. It only contains digits and characters "+". Besides, string s is a correct sum of numbers 1, 2 and 3. String s is at most 100 characters long.
Output
Print the new sum that Xenia can count.
Examples
Input
3+2+1
Output
1+2+3
Input
1+1+3+1+3
Output
1+1+1+3+3
Input
2
Output
2
Submitted Solution:
```
st = input()
one = two = three = 0
for s in st:
if s == '1':
one += 1
elif s == '2':
two += 1
elif s == '3':
three += 1
def mix(ch, count):
ans = ''
for i in range(count):
ans += ch
ans += '+'
return ans[:-1]
on = mix('1', one)
tw = mix('2', two)
th = mix('3', three)
# print(on, tw, th)
if len(tw) > 0 and len(on) > 0:
on += "+"
if len(th) > 0 and len(tw) > 0:
tw += "+"
print(on+tw+th)
``` | instruction | 0 | 57,447 | 20 | 114,894 |
No | output | 1 | 57,447 | 20 | 114,895 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation.
The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3.
You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum.
Input
The first line contains a non-empty string s — the sum Xenia needs to count. String s contains no spaces. It only contains digits and characters "+". Besides, string s is a correct sum of numbers 1, 2 and 3. String s is at most 100 characters long.
Output
Print the new sum that Xenia can count.
Examples
Input
3+2+1
Output
1+2+3
Input
1+1+3+1+3
Output
1+1+1+3+3
Input
2
Output
2
Submitted Solution:
```
s = input()
count1 = 0
count2 = 0
count3 = 0
for let in s:
if let == '1':
count1 += 1
elif let == '2':
count2 += 1
elif let == '3':
count3 += 1
for i in range(count1):
print('1'+'+', end='')
for i in range(count2):
print('2'+'+', end='')
for i in range(count3 - 1):
print('3'+'+', end='')
print('3')
``` | instruction | 0 | 57,448 | 20 | 114,896 |
No | output | 1 | 57,448 | 20 | 114,897 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.