language stringclasses 5
values | dataset stringclasses 1
value | code stringlengths 26 25k | id stringlengths 10 10 | test_IO listlengths 1 1 |
|---|---|---|---|---|
Go | codenet | package main
import (
"fmt"
"sort"
)
func main() {
in := make([]int, 3)
fmt.Scan(&in[0], &in[1], &in[2])
sort.Ints(in)
fmt.Println(in[2]*10 + in[1] + in[0])
}
| s635143344 | [
{
"input": "1 5 2\n",
"output": "53\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
"strings"
)
var stdin = bufio.NewScanner(os.Stdin)
func main() {
arr := scanArrayInt()
a, b := arr[0], arr[1]
tap := 0
consent := 1
for consent < b {
consent = consent + a - 1
tap++
}
fmt.Println(tap)
}
func scanArrayInt() []int {
var ret = []int{}... | s217679680 | [
{
"input": "4 10\n",
"output": "3\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
func out(x ...interface{}) {
fmt.Println(x...)
}
var sc = bufio.NewScanner(os.Stdin)
func getInt() int {
sc.Scan()
i, e := strconv.Atoi(sc.Text())
if e != nil {
panic(e)
}
return i
}
func getString() string {
sc.Scan()
return sc.Text()
}
func main... | s480530100 | [
{
"input": "5 5\n1 2 3 4 5\n1 0 5\n1 2 4\n0 3 10\n1 0 5\n1 0 3\n",
"output": "15\n7\n25\n6\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"sort"
"strconv"
)
var (
sc = bufio.NewScanner(os.Stdin)
wr = bufio.NewWriter(os.Stdout)
)
func scanInt() int {
sc.Scan()
a, _ := strconv.Atoi(sc.Text())
return a
}
func scanInt64() int64 {
sc.Scan()
a, _ := strconv.ParseInt(sc.Text(), 10, 64)
return a
}
func s... | s495252714 | [
{
"input": "1\n1000000000\n",
"output": "999999993\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var day int
fmt.Scan(&day)
switch day {
case 25:
fmt.Println("Christmas")
case 24:
fmt.Println("Christmas Eve")
case 23:
fmt.Println("Christmas Eve Eve")
case 22:
fmt.Println("Christmas Eve Eve Eve")
}
}
| s053342495 | [
{
"input": "25\n",
"output": "Christmas\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"sort"
"strconv"
)
func getScanner(fp *os.File) *bufio.Scanner {
scanner := bufio.NewScanner(fp)
scanner.Split(bufio.ScanWords)
scanner.Buffer(make([]byte, 500001), 500000)
return scanner
}
func getNextString(scanner *bufio.Scanner) string {
scanner.Scan()
return s... | s228769347 | [
{
"input": "4\n3 4 2 1\n",
"output": "1\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var A, B, C int
fmt.Scanf("%d %d %d", &A, &B, &C)
if C >= A && C <= B {
fmt.Println("Yes")
} else {
fmt.Println("No")
}
}
| s407800036 | [
{
"input": "1 3 2\n",
"output": "Yes\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"io"
"os"
"strconv"
)
var in = NewScanner(os.Stdin, 0)
func main() {
n, k := in.Int(), in.Int()
if n%k == 0 {
Pln(0)
} else {
Pln(1)
}
}
type Scanner struct {
*bufio.Scanner
}
func NewScanner(r io.Reader, max int) *Scanner {
s := bufio.NewScanner(r)
s.Split(scanW... | s791445247 | [
{
"input": "7 3\n",
"output": "1\n"
}
] |
Go | codenet | package main
import (
"fmt"
"strings"
)
func main() {
var a string
fmt.Scan(&a)
tmp := strings.Replace(a, "1", "0", -1)
b := strings.Replace(tmp, "9", "1", -1)
ans := strings.Replace(b, "0", "9", -1)
fmt.Println(ans)
}
| s278875041 | [
{
"input": "119\n",
"output": "991\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"sort"
"strconv"
)
const (
constMod = int(1e9) + 7
)
var (
sc = bufio.NewScanner(os.Stdin)
wr = bufio.NewWriter(os.Stdout)
)
func getInt() int {
sc.Scan()
i, e := strconv.Atoi(sc.Text())
if e != nil {
panic(e)
}
return i
}
func getIntSlice(n int) []int {
ns ... | s819591647 | [
{
"input": "4 1\n5 4 2 1\n",
"output": "Yes\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
"strings"
)
type Pair struct {
p1, p2 interface{}
}
const (
initialBufSize = 1e4
maxBufSize = 1e8
)
var (
scanner = bufio.NewScanner(os.Stdin)
writer = bufio.NewWriter(os.Stdout)
)
func main() {
buf := make([]byte, initialBufSize)
scanner.Buffer(b... | s583952795 | [
{
"input": "11 2\n",
"output": "4\n"
}
] |
Go | codenet | package main
import (
"fmt"
"strings"
)
func main() {
var s string
fmt.Scan(&s)
s = strings.Replace(s, "dream", "D", -1)
s = strings.Replace(s, "erase", "E", -1)
s = strings.Replace(s, "Der", "", -1)
s = strings.Replace(s, "Er", "", -1)
s = strings.Replace(s, "D", "", -1)
s = strings.Replace(s, "E", "", -1)... | s876834921 | [
{
"input": "erasedream\n",
"output": "YES\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"math"
"os"
"strconv"
)
func nextStr() string {
sc.Scan()
return sc.Text()
}
func nextInt() int {
sc.Scan()
i, e := strconv.Atoi(sc.Text())
if e != nil {
panic(e)
}
return i
}
func maxInt(a, b int) int {
if a > b {
return a
} else {
return b
}
}
func minInt(... | s493522692 | [
{
"input": "1 6\n",
"output": "2\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"math"
"os"
"strconv"
)
const (
initialBufSize = 10000
maxBufSize = 1000000
)
var (
sc *bufio.Scanner = func() *bufio.Scanner {
sc := bufio.NewScanner(os.Stdin)
buf := make([]byte, initialBufSize)
sc.Buffer(buf, maxBufSize)
sc.Split(bufio.ScanWords)
return sc... | s554610878 | [
{
"input": "SAT\n",
"output": "1\n"
}
] |
Go | codenet | package main
import (
"fmt"
)
func group(n int) string {
if n == 4 || n == 6 || n == 9 || n == 11 {
return "B"
} else {
return "A"
}
}
func main() {
var x, y int
fmt.Scan(&x, &y)
if x == 2 || y == 2 {
fmt.Println("No")
return
}
xg := group(x)
yg := group(y)
if xg == yg {
fmt.Println("Yes")
}... | s032855181 | [
{
"input": "1 3\n",
"output": "Yes\n"
}
] |
Go | codenet | package main
import (
"bufio"
"errors"
"fmt"
"io"
"math"
"os"
"strconv"
)
const (
MOD = 1000000000 + 7
ALPHABET_NUM = 26
INF_INT64 = math.MaxInt64
INF_BIT60 = 1 << 60
INF_INT32 = math.MaxInt32
INF_BIT30 = 1 << 30
NIL = -1
WHITE = 0
GRAY = 1
BLACK = 2
)
func init() {
ReadStr... | s557024716 | [
{
"input": "7 2 5\n3\n",
"output": "Yes\n"
}
] |
Go | codenet | package main
import (
"fmt"
)
func main() {
var n, x int
for {
fmt.Scan(&n, &x)
if n == 0 && x == 0 {
break
}
c := 0
for i := 1; i <= n-2; i++ {
for j := i + 1; j <= n-1; j++ {
for k := j + 1; k <= n; k++ {
if i+j+k == x {
c++
}
}
}
}
fmt.Println(c)
}
}
| s273611899 | [
{
"input": "5 9\n0 0\n",
"output": "2\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
func getScanner(fp *os.File) *bufio.Scanner {
scanner := bufio.NewScanner(fp)
scanner.Split(bufio.ScanWords)
scanner.Buffer(make([]byte, 500001), 500000)
return scanner
}
func getNextString(scanner *bufio.Scanner) string {
scanner.Scan()
return scanner.T... | s482866535 | [
{
"input": "6\n30 35\n35 15\n15 5\n5 10\n10 20\n20 25\n",
"output": "15125\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var s string
fmt.Scan(&s)
if (s[0] == s[1] && s[1] == s[2]) || (s[1] == s[2] && s[2] == s[3]) {
fmt.Println("Yes")
} else {
fmt.Println("No")
}
}
| s426245140 | [
{
"input": "1118\n",
"output": "Yes\n"
}
] |
Go | codenet | package main
import (
"fmt"
"sort"
)
func main() {
var N int
fmt.Scanf("%d", &N)
A := make([]int, N)
for i := 0; i < N; i++ {
fmt.Scanf("%d", &A[i])
}
sort.Sort(sort.IntSlice(A))
var ans int
for i := 1; i < N; i++ {
ans += A[i] - A[i-1]
}
fmt.Println(ans)
}
| s562422877 | [
{
"input": "4\n2 3 7 9\n",
"output": "7\n"
}
] |
Go | codenet | package main
import (
"fmt"
"strings"
)
func main() {
var s1, s2, s3 string
fmt.Scan(&s1, &s2, &s3)
s1s := strings.Split(s1, "")
s2s := strings.Split(s2, "")
s3s := strings.Split(s3, "")
fmt.Println(strings.ToUpper(s1s[0]) + strings.ToUpper(s2s[0]) + strings.ToUpper(s3s[0]))
}
| s503150457 | [
{
"input": "atcoder beginner contest\n",
"output": "ABC\n"
}
] |
Go | codenet | package main
import (
"fmt"
"strings"
)
func main() {
var s string
fmt.Scanf("%s", &s)
fmt.Println(strings.Replace(s, "2017", "2018", -1))
}
| s695286684 | [
{
"input": "2017/01/07\n",
"output": "2018/01/07\n"
}
] |
Go | codenet | package main
import "fmt"
func Abs(x int) int {
if x < 0 {
return -x
}
return x
}
func min(a, b int) int {
if a > b {
return b
}
return a
}
func main() {
var N, K int
fmt.Scan(&N, &K)
var x int
x = N % K
x = min(Abs(x-K), x)
fmt.Println(x)
}
| s206203202 | [
{
"input": "7 4\n",
"output": "1\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"math"
"os"
"strconv"
"strings"
)
type bufReader struct {
r *bufio.Reader
buf []byte
i int
}
var reader = &bufReader{
bufio.NewReader(os.Stdin),
make([]byte, 0),
0,
}
func (r *bufReader) readLine() {
if r.i < len(r.buf) {
return
}
r.buf = make([]byte, 0)
r.i... | s998080221 | [
{
"input": "3 2\n100 50 200\n",
"output": "1\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"sort"
"strconv"
)
var sc = bufio.NewScanner(os.Stdin)
func Scanner() string {
sc.Scan()
return sc.Text()
}
func intScanner() int {
n, _ := strconv.Atoi(Scanner())
return n
}
func floatScanner() float64 {
n, _ := strconv.ParseFloat(Scanner(), 64)
return n
}
func ... | s963048401 | [
{
"input": "5\n2\n1\n4\n5\n3\n",
"output": "2\n"
}
] |
Go | codenet | package main
import "fmt"
var n, ans int
const arraySize = 101
var a = [arraySize][arraySize]int{}
func findAns(i, j, sum int) {
if i == 1 && j == n-1 && sum+a[i][j] > ans {
ans = sum + a[i][j]
return
}
if i == 0 {
findAns(i+1, j, sum+a[i][j])
}
if j+1 < n {
findAns(i, j+1, sum+a[i][j])
}
}
func main... | s099670837 | [
{
"input": "5\n3 2 2 4 1\n1 2 2 2 1\n",
"output": "14\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"io"
"os"
"strconv"
)
var in = NewScanner(os.Stdin, 0)
func main() {
n, k := in.Int(), in.Int()
if n%k == 0 {
Pln(0)
} else {
Pln(1)
}
}
type Scanner struct {
*bufio.Scanner
}
func NewScanner(r io.Reader, max int) *Scanner {
s := bufio.NewScanner(r)
s.Split(scanW... | s376370885 | [
{
"input": "7 3\n",
"output": "1\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"sort"
"strconv"
)
func out(x ...interface{}) {
}
var sc = bufio.NewScanner(os.Stdin)
func nextInt() int {
sc.Scan()
i, e := strconv.Atoi(sc.Text())
if e != nil {
panic(e)
}
return i
}
func nextString() string {
sc.Scan()
return sc.Text()
}
type Data struct ... | s330691347 | [
{
"input": "3 3\ndxx\naxx\ncxx\n",
"output": "axxcxxdxx\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var a [3]int
fmt.Scan(&a[0], &a[1], &a[2])
five := 0
seven := 0
for i := 0; i < 3; i++ {
if a[i] == 5 {
five++
}
if a[i] == 7 {
seven++
}
}
if five == 2 && seven == 1 {
fmt.Println("YES")
} else {
fmt.Println("NO")
}
}
| s984784526 | [
{
"input": "5 5 7\n",
"output": "YES\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
var sc = bufio.NewScanner(os.Stdin)
func main() {
scanInit()
s := nextStr()
c := 'a'
for j := 0; j < 26; j++ {
found := false
for i := 0; i < len(s); i++ {
if s[i] == byte(c) {
found = true
break
}
}
if found == false {
fmt.Prin... | s726858931 | [
{
"input": "atcoderregularcontest\n",
"output": "b\n"
}
] |
Go | codenet | package main
import (
"fmt"
)
func main() {
var s string
fmt.Scan(&s)
ans := 0
for _, c := range s {
if c == '1' {
ans++
}
}
fmt.Println(ans)
}
| s306917423 | [
{
"input": "111100\n",
"output": "4\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
var sc *bufio.Scanner
func nextStr() string {
sc.Scan()
return sc.Text()
}
func nextInt() int {
sc.Scan()
i, e := strconv.Atoi(sc.Text())
if e != nil {
panic(e)
}
return i
}
func main() {
sc = bufio.NewScanner(os.Stdin)
sc.Buffer(make([]byte, 0), ... | s476359676 | [
{
"input": "4\n0\n1\n1\n2\n",
"output": "3\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"sort"
"strconv"
)
var sc = bufio.NewScanner(os.Stdin)
func scanInt() int {
sc.Scan()
iv, _ := strconv.Atoi(sc.Text())
return iv
}
func init() {
sc.Split(bufio.ScanWords)
}
func main() {
n := scanInt()
type arm struct{ l, r int }
as := make([]arm, n)
for i := r... | s648707342 | [
{
"input": "4\n2 4\n4 3\n9 3\n100 5\n",
"output": "3\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"math"
"os"
"sort"
"strconv"
)
func main() {
INF := int(math.Pow10(11))
A := nextInt()
B := nextInt()
Q := nextInt()
s := make([]int, A+2)
s[0], s[A+1] = -INF, INF
for i := 1; i <= A; i++ {
s[i] = nextInt()
}
t := make([]int, B+2)
t[0], t[B+1] = -INF, INF
for i... | s219662687 | [
{
"input": "2 3 4\n100\n600\n400\n900\n1000\n150\n2000\n899\n799\n",
"output": "350\n1400\n301\n399\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"sort"
"strconv"
)
func main() {
N, K := ReadInt(), ReadInt()
As := ReadInts(N)
Fs := ReadInts(N)
sort.Ints(As)
sort.Sort(sort.Reverse(sort.IntSlice(Fs)))
scores := make([]int, N)
for i := 0; i < N; i++ {
scores[i] = As[i] * Fs[i]
}
sort.Sort(sort.Reverse(sort... | s733602892 | [
{
"input": "3 5\n4 2 1\n2 3 1\n",
"output": "2\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var x int
fmt.Scan(&x)
fmt.Println(x * x * x)
}
| s178339312 | [
{
"input": "2\n",
"output": "8\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
func main() {
var N int
fmt.Scan(&N)
scanner := bufio.NewScanner(os.Stdin)
scanner.Split(bufio.ScanWords)
v := make([]int, N)
var a int
for i := 1; i < N; i++ {
scanner.Scan()
a, _ = strconv.Atoi(scanner.Text())
v[a-1]++
}
w := bufio.NewWriter(... | s563519278 | [
{
"input": "5\n1 1 2 2\n",
"output": "2\n2\n0\n0\n0\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var r, D, x int
fmt.Scan(&r, &D, &x)
for i := 1; i <= 10; i++ {
fmt.Println(r*x - D)
x = r*x - D
}
}
| s400924672 | [
{
"input": "2 10 20\n",
"output": "30\n50\n90\n170\n330\n650\n1290\n2570\n5130\n10250\n"
}
] |
Go | codenet | package main
import (
"fmt"
"os"
"strings"
)
var (
s string
)
func main() {
fmt.Scan(&s)
for i := 0; i < len(s); i++ {
if strings.Contains(s[i+1:], string(s[i])) {
fmt.Println("no")
os.Exit(0)
}
}
fmt.Println("yes")
}
| s079891640 | [
{
"input": "uncopyrightable\n",
"output": "yes\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
func genid(a, b int) int {
if b < a {
a, b = b, a
}
return a*100000 + b
}
func main() {
N := readInt()
ab := make([][2]int, N-1)
edges := make([][]int, N)
for i := 0; i < N-1; i++ {
a := readInt() - 1
b := readInt() - 1
ab[i][0], ab[i][1] = a, ... | s954015601 | [
{
"input": "3\n1 2\n2 3\n",
"output": "2\n1\n2\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var n int
fmt.Scan(&n)
ans := 0
for i := 1; i*i < n; i++ {
if n%i == 0 && n%(n/i-1) == i {
ans += n/i - 1
}
}
fmt.Println(ans)
}
| s283266035 | [
{
"input": "8\n",
"output": "10\n"
}
] |
Go | codenet | package main
import (
"bufio"
"errors"
"fmt"
"io"
"math"
"os"
"strconv"
)
const (
MOD = 1000000000 + 7
ALPHABET_NUM = 26
INF_INT64 = math.MaxInt64
INF_BIT60 = 1 << 60
INF_INT32 = math.MaxInt32
INF_BIT30 = 1 << 30
NIL = -1
WHITE = 0
GRAY = 1
BLACK = 2
)
func init() {
ReadStr... | s620841407 | [
{
"input": "3 100\n1 2\n2 3\n",
"output": "3\n4\n3\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"io"
"math"
"os"
"strconv"
"strings"
)
func Run(r io.Reader, w io.Writer) {
sc := NewScanner(r)
a := sc.ReadLine().Ints()
N, D := a[0], a[1]
lines := sc.ReadLines(N).Ints()
count := 0
for _, line := range lines {
d := math.Sqrt(float64(line[0]*line[0] + line[1]*li... | s497491075 | [
{
"input": "4 5\n0 5\n-2 4\n3 4\n4 -4\n",
"output": "3\n"
}
] |
Go | codenet | package main
import "fmt"
var e [][]int
var n, m int
func printEdge(e [][]int) {
for i := 1; i < n+1; i++ {
fmt.Printf("%d: ", i)
for _, v := range e[i] {
fmt.Printf("%d ", v)
}
fmt.Println()
}
}
func dfs(v int, visited []bool) int {
comp := true
for i := 1; i < n+1; i++ {
if !visited[i] {
comp... | s406008869 | [
{
"input": "3 3\n1 2\n1 3\n2 3\n",
"output": "2\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var S string
fmt.Scan(&S)
switch S {
case "Sunny":
fmt.Println("Cloudy")
case "Cloudy":
fmt.Println("Rainy")
case "Rainy":
fmt.Println("Sunny")
}
}
| s201004620 | [
{
"input": "Sunny\n",
"output": "Cloudy\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"log"
"os"
"strconv"
)
var inf int = 1e14
func main() {
log.SetFlags(log.Lshortfile)
next := newScanner()
n := next.Int()
x := next.Int()
a := make([]int, n)
for i := 0; i < n; i++ {
a[i] = next.Int()
}
v := make([]int, n)
copy(v, a)
ans := inf
for k := 0; k < n;... | s462906333 | [
{
"input": "2 10\n1 100\n",
"output": "12\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var a string
fmt.Scan(&a)
var ans = "Good"
for i := 0; i < 3; i++ {
if a[i] == a[i+1] {
ans = "Bad"
}
}
fmt.Println(ans)
}
| s879077700 | [
{
"input": "3776\n",
"output": "Bad\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
func main() {
fsc := NewFastScanner()
A, B, C := fsc.NextInt(), fsc.NextInt(), fsc.NextInt()
if B-A == C-B {
fmt.Println("YES")
} else {
fmt.Println("NO")
}
}
type FastScanner struct {
r *bufio.Reader
buf []byte
p int
}
func NewFastScanner() *... | s680776563 | [
{
"input": "2 4 6\n",
"output": "YES\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
)
type Block struct {
Value string
Len int
}
func main() {
var N, K, ans int
fmt.Scan(&N, &K)
var S string
s := bufio.NewScanner(os.Stdin)
b := make([]byte, 1000000)
s.Buffer(b, 1000000)
s.Scan()
S = s.Text()
blocks := RunLength(S)
sum, zero, l := 0, 0, 0
fo... | s712890349 | [
{
"input": "5 1\n00010\n",
"output": "4\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
func main() {
sc := NewScanner()
n := sc.ReadInt()
k := sc.ReadInt()
total := int64(0)
for i := k; i <= n+1; i++ {
total += combi(n, i)
total = total % (Pow64(10, 9) + 7)
}
fmt.Println(total)
}
func combi(n int, k int) int64 {
min := int64(k-1) *... | s684434772 | [
{
"input": "3 2\n",
"output": "10\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"io"
"os"
"strconv"
)
const mod = 998244353
const facNum = 300001
func main() {
sc := newScanner(os.Stdin)
N := sc.i()
sum := 0
for i := 1; i <= N; i++ {
if i%3 == 0 || i%5 == 0 {
continue
}
sum += i
}
fmt.Println(sum)
}
type scanner struct {
sc *bufio.Scanne... | s716019902 | [
{
"input": "15\n",
"output": "60\n"
}
] |
Go | codenet | package main
import (
"fmt"
"math"
)
func main() {
var n float64
var k float64
fmt.Scan(&n, &k)
var x float64 = 0.0
for {
under := math.Pow(k, x)
upper := math.Pow(k, x+1)
if under <= n && n < upper {
fmt.Println(x + 1)
return
}
x++
}
}
| s209996417 | [
{
"input": "11 2\n",
"output": "4\n"
}
] |
Go | codenet | package main
import (
"fmt"
)
func solution(n, m int) int {
n = n - 2
m = m - 2
if n < 0 {
n = 1
}
if m < 0 {
m = 1
}
return n * m
}
func main() {
var n, m int
fmt.Scan(&n, &m)
fmt.Println(solution(n, m))
}
| s060770256 | [
{
"input": "2 2\n",
"output": "0\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
"strings"
)
type node struct {
key int
parent *node
left *node
right *node
}
type tree struct {
root *node
}
func (tree *tree) insert(key int) {
if tree.root == nil {
tree.root = &node{key: key}
return
}
var currentNode, prevNode *node
curr... | s632215495 | [
{
"input": "8\ninsert 30\ninsert 88\ninsert 12\ninsert 1\ninsert 20\ninsert 17\ninsert 25\nprint\n",
"output": " 1 12 17 20 25 30 88\n 30 12 1 20 17 25 88\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"math"
"os"
"reflect"
"sort"
"strconv"
"strings"
)
type pair struct {
index int64
p1, p2 interface{}
}
type pairs []pair
func (slice pairs) Len() int {
return len(slice)
}
func (slice pairs) Less(i, j int) bool {
return slice[i].index < slice[j].index
}
func (slice ... | s684610901 | [
{
"input": "1 3 2\n",
"output": "Yes\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var a, b int
fmt.Scan(&a, &b)
if a*b%2 == 0 {
fmt.Println("Even")
} else {
fmt.Println("Odd")
}
}
| s824543330 | [
{
"input": "3 4\n",
"output": "Even\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
var reader = bufio.NewReaderSize(os.Stdin, 1000000)
var writer = bufio.NewWriter(os.Stdout)
func NextLine() string {
var line, buffer []byte
var isPrefix bool = true
var err error
for isPrefix {
line, isPrefix, err = reader.ReadLine()
if err != nil {
... | s537465285 | [
{
"input": "2\n01\n10\n",
"output": "2\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
)
var in = bufio.NewReader(os.Stdin)
func solve(a, b, c int) int {
var temp_ int
if c == a+b {
temp_ = b + c
} else if c-1 > a+b {
temp := (c - 1) - (a + b)
temp_ = b + c - temp
} else {
temp_ = b + c
}
return temp_
}
func main() {
var a, b, c int
fmt.Fsca... | s336868078 | [
{
"input": "3 1 4\n",
"output": "5\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
"sort"
)
func main() {
sc := NewScanner()
n := sc.NextInt()
arr := make([]float64, n)
for i := 0; i < n; i++ {
arr[i] = float64(sc.NextInt())
}
sort.Float64s(arr)
prev := arr[0]
for i := 1; i < len(arr); i++ {
prev = (prev + arr[i]) / 2
}
fmt.Pr... | s479324991 | [
{
"input": "2\n3 4\n",
"output": "3.5\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"math"
"os"
"strconv"
"strings"
)
func main() {
io, flash := NewIO()
defer flash()
n, t, a := io.ScanInt(), io.ScanFloat64(), io.ScanFloat64()
heights := io.ScanFloat64s(n)
minDiff := AbsDiffFloat64(t-heights[0]*0.006, a)
minIdx := 0
for i, h := range heights[1:] {
... | s753839476 | [
{
"input": "2\n12 5\n1000 2000\n",
"output": "1\n"
}
] |
Go | codenet | package main
import "fmt"
type Dice struct {
Nums []int
}
func (d *Dice) rotate(direction string, times int) {
times %= 4
switch direction {
case "W":
for i := 0; i < times; i++ {
d.Nums[0], d.Nums[2], d.Nums[5], d.Nums[3] = d.Nums[2], d.Nums[5], d.Nums[3], d.Nums[0]
}
case "E":
for i := 0; i < times; ... | s446670437 | [
{
"input": "1 2 3 4 5 6\n6 2 4 3 5 1\n",
"output": "Yes\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
)
var mod = 1000000007
var INF = 1000000007
func main() {
r := bufio.NewReader(os.Stdin)
var n, m, R int
fmt.Fscan(r, &n)
fmt.Fscan(r, &m)
fmt.Fscan(r, &R)
rs := make([]int, R)
for i := 0; i < R; i++ {
fmt.Fscan(r, &rs[i])
rs[i]--
}
costs := make([][]int, n)... | s853386130 | [
{
"input": "3 3 3\n1 2 3\n1 2 1\n2 3 1\n3 1 4\n",
"output": "2\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
"strings"
)
const size = 1000000
var reader = bufio.NewReaderSize(os.Stdin, size)
func NextLine() string {
var line, buffer []byte
var isPrefix bool = true
var err error
for isPrefix {
line, isPrefix, err = reader.ReadLine()
if err != nil {
panic(er... | s301190573 | [
{
"input": "5 2\n5 3 1 4 2\n1 3\n5 4\n",
"output": "2\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
var sc = bufio.NewScanner(os.Stdin)
func main() {
sc.Split(bufio.ScanWords)
n := nextInt()
m := nextInt()
h := make([]int, n)
good := make([]bool, n)
for i := 0; i < n; i++ {
h[i] = nextInt()
good[i] = true
}
for i := 0; i < m; i++ {
ai := nextIn... | s302163336 | [
{
"input": "4 3\n1 2 3 4\n1 3\n2 3\n2 4\n",
"output": "2\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var n, m int
fmt.Scanf("%d %d", &n, &m)
h := make([]int, n)
for i := 0; i < n; i++ {
fmt.Scan(&h[i])
}
var a, b int
counter := make(map[int]struct{})
for i := 0; i < m; i++ {
fmt.Scanf("%d %d", &a, &b)
if h[a-1] < h[b-1] {
counter[a] = struct{}{}
} else if h[... | s860368733 | [
{
"input": "4 3\n1 2 3 4\n1 3\n2 3\n2 4\n",
"output": "2\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var n int
fmt.Scan(&n)
as := make([]int, n+1)
bs := make([]int, n)
for i := range as {
fmt.Scan(&as[i])
}
for i := range bs {
fmt.Scan(&bs[i])
}
var sum int
for i := 0; i <= n-1; i++ {
a := as[i]
b := bs[i]
if a <= b {
sum += a
b -= a
if i+1 <= ... | s451489327 | [
{
"input": "2\n3 5 2\n4 5\n",
"output": "9\n"
}
] |
Go | codenet | package main
import "fmt"
type problem struct {
number, bonus int
}
func min(a, b int) int {
if a >= b {
return b
}
return a
}
func main() {
var D, G int
fmt.Scan(&D, &G)
problems := make([]problem, D)
for i := range problems {
fmt.Scan(&problems[i].number)
fmt.Scan(&problems[i].bonus)
}
ans := 100... | s699619001 | [
{
"input": "2 700\n3 500\n5 800\n",
"output": "3\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
func getScanner(fp *os.File) *bufio.Scanner {
scanner := bufio.NewScanner(fp)
scanner.Split(bufio.ScanWords)
scanner.Buffer(make([]byte, 500001), 500000)
return scanner
}
func getNextString(scanner *bufio.Scanner) string {
scanner.Scan()
return scanner.T... | s033683118 | [
{
"input": "2 900\n",
"output": "Yes\n"
}
] |
Go | codenet | package main
import (
"bufio"
"errors"
"fmt"
"io"
"math"
"os"
"sort"
"strconv"
"strings"
)
var (
ReadString func() string
stdout *bufio.Writer
)
func init() {
ReadString = newReadString(os.Stdin)
stdout = bufio.NewWriter(os.Stdout)
}
func newReadString(ior io.Reader) func() string {
r := bufio.New... | s032857139 | [
{
"input": "3 70\n20 30 10\n",
"output": "2\n"
}
] |
Go | codenet | package main
import (
"fmt"
)
func searchRange(text *string, start, limit int) (int, int, int) {
middle := -1
for i := start; i < limit; i++ {
if (*text)[i] != 'R' {
middle = i
break
}
}
end := limit
for i := middle; i < limit; i++ {
if (*text)[i] != 'L' {
end = i
break
}
}
return star... | s134607050 | [
{
"input": "RRLRL\n",
"output": "0 1 2 1 1\n"
}
] |
Go | codenet | package main
import (
"fmt"
"sort"
"strings"
)
func main() {
var s string
fmt.Scan(&s)
count := 0
var counter []int
if s == "" {
return
}
counter = append(counter, 0)
li := strings.Split(s, "")
for _, s := range li {
if s == "A" || s == "C" || s == "G" || s == "T" {
count++
} else {
counter... | s120583500 | [
{
"input": "ATCODER\n",
"output": "3\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var a, b, c int
fmt.Scanf("%d %d %d", &a, &b, &c)
if a < b && b < c {
fmt.Println("Yes")
} else {
fmt.Println("No")
}
return
}
| s344381425 | [
{
"input": "1 3 8\n",
"output": "Yes\n"
}
] |
Go | codenet | package main
import (
"fmt"
"math"
)
const inf = 10000000000.0
func main() {
var n int
fmt.Scan(&n)
arrA := make([]int, n)
for i := 0; i < n; i++ {
fmt.Scan(&arrA[i])
}
cumSumA := make([]int, n+1)
cumSumA[0] = 0
for i, a := range arrA {
cumSumA[i+1] = cumSumA[i] + a
}
ans := inf
for i := 1; i < n... | s716011659 | [
{
"input": "6\n1 2 3 4 5 6\n",
"output": "1\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"sort"
"strconv"
)
func main() {
scanner := bufio.NewScanner(os.Stdin)
scanner.Split(bufio.ScanWords)
N := ScanInt(scanner)
X := make([]int, N)
Y := make([]int, N)
for i := 0; i < N; i++ {
X[i] = ScanInt(scanner)
Y[i] = X[i]
}
sort.Sort(sort.IntSlice(Y))
m1... | s841275808 | [
{
"input": "4\n2 4 4 3\n",
"output": "4\n3\n3\n4\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
func main() {
scanner := bufio.NewScanner(os.Stdin)
scanner.Split(bufio.ScanWords)
var c [3][3]int
var a, b [3]int
for i := 0; i < 3; i++ {
for j := 0; j < 3; j++ {
scanner.Scan()
c[i][j], _ = strconv.Atoi(scanner.Text())
}
}
b[0] = c[0][0] - ... | s394238127 | [
{
"input": "1 0 1\n2 1 2\n1 0 1\n",
"output": "Yes\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var n int
var s string
fmt.Scan(&n, &s)
max := 0
cnt := 0
for _, r := range s {
if r == 'I' {
cnt++
} else {
cnt--
}
if cnt > max {
max = cnt
}
}
fmt.Println(max)
}
| s414601790 | [
{
"input": "5\nIIDID\n",
"output": "2\n"
}
] |
Go | codenet | package main
import (
"fmt"
)
func main() {
var N, K, R, S, P int
var T string
fmt.Scan(&N, &K, &R, &S, &P)
fmt.Scan(&T)
dict := map[string]int{"r": 0, "s": 0, "p": 0}
char := ""
s := make([]bool, N)
for i := 0; i < N; i++ {
s[i] = true
}
r := make([]bool, N)
p := make([]bool, N)
copy(r, s)
copy(p, s... | s934374308 | [
{
"input": "5 2\n8 7 6\nrsrpr\n",
"output": "27\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
for i := 0; i < 5; i++ {
var a int
fmt.Scan(&a)
if a == 0 {
fmt.Println(i + 1)
}
}
}
| s760945395 | [
{
"input": "0 2 3 4 5\n",
"output": "1\n"
}
] |
Go | codenet | package main
import (
"fmt"
)
func main() {
var a, b, c int
fmt.Scan(&a, &b, &c)
if b-a == c-b {
fmt.Println("YES")
} else {
fmt.Println("NO")
}
}
| s783520158 | [
{
"input": "2 4 6\n",
"output": "YES\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var x int
fmt.Scan(&x)
ans := 0
if x >= 400 && x <= 599 {
ans = 8
}
if x >= 600 && x <= 799 {
ans = 7
}
if x >= 800 && x <= 999 {
ans = 6
}
if x >= 1000 && x <= 1199 {
ans = 5
}
if x >= 1200 && x <= 1399 {
ans = 4
}
if x >= 1400 && x <= 1599 {
ans = 3... | s808499721 | [
{
"input": "725\n",
"output": "7\n"
}
] |
Go | codenet | package main
import (
"fmt"
"sort"
)
func main() {
var n int
fmt.Scan(&n)
a := make([]int, n)
for i := 0; i < n; i++ {
fmt.Scan(&a[i])
}
s := make([]int, n+1)
for i := 0; i < n; i++ {
s[i+1] = s[i] + a[i]
}
sort.Sort(sort.IntSlice(s))
ans := 0
count := 0
for i := 0; i < n; i++ {
if s[i] == s[i... | s443186486 | [
{
"input": "6\n1 3 -4 2 2 -2\n",
"output": "3\n"
}
] |
Go | codenet | package main
import (
"fmt"
"strings"
)
func main() {
var s string
fmt.Scan(&s)
n := strings.Count(s, "o")
fmt.Println(700 + n*100)
}
| s235491884 | [
{
"input": "oxo\n",
"output": "900\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"sort"
"strconv"
)
func out(x ...interface{}) {
fmt.Println(x...)
}
var sc = bufio.NewScanner(os.Stdin)
func getInt() int {
sc.Scan()
i, e := strconv.Atoi(sc.Text())
if e != nil {
panic(e)
}
return i
}
func getString() string {
sc.Scan()
return sc.Text()
}
f... | s390866994 | [
{
"input": "5 3 5\n1\n2\n3\n6\n12\n",
"output": "3\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var K, X int
fmt.Scan(&K, &X)
if 500*K >= X {
fmt.Println("Yes")
} else {
fmt.Println("No")
}
}
| s101529434 | [
{
"input": "2 900\n",
"output": "Yes\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
func main() {
N := nextInt()
h := nextInts(N)
dp := make([]int, N)
for i := 0; i < N; i++ {
dp[i] = 0
}
dp[1] = Abs(h[0] - h[1])
for i := 2; i < N; i++ {
dp[i] = Min([]int{dp[i-1] + Abs(h[i]-h[i-1]),
dp[i-2] + Abs(h[i]-h[i-2])})
}
fmt.Printl... | s114239323 | [
{
"input": "4\n10 30 40 20\n",
"output": "30\n"
}
] |
Go | codenet | package main
import (
"fmt"
"strings"
)
func main() {
var n int
var s string
fmt.Scanf("%d", &n)
fmt.Scanf("%s", &s)
fmt.Printf("%d\n", strings.Count(s, "ABC"))
}
| s894183124 | [
{
"input": "10\nZABCDBABCQ\n",
"output": "2\n"
}
] |
Go | codenet | package main
import (
"bufio"
"errors"
"fmt"
"io"
"math"
"os"
"strconv"
)
var (
ReadString func() string
stdout *bufio.Writer
)
func init() {
ReadString = newReadString(os.Stdin)
stdout = bufio.NewWriter(os.Stdout)
}
func newReadString(ior io.Reader) func() string {
r := bufio.NewScanner(ior)
r.Bu... | s635098814 | [
{
"input": "This is a pen.\n",
"output": "a : 1\nb : 0\nc : 0\nd : 0\ne : 1\nf : 0\ng : 0\nh : 1\ni : 2\nj : 0\nk : 0\nl : 0\nm : 0\nn : 1\no : 0\np : 1\nq : 0\nr : 0\ns : 2\nt : 1\nu : 0\nv : 0\nw : 0\nx : 0\ny : 0\nz : 0\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var A, B, C int
fmt.Scan(&A, &B, &C)
if A+B >= C {
fmt.Println("Yes")
} else {
fmt.Println("No")
}
}
| s469293815 | [
{
"input": "50 100 120\n",
"output": "Yes\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
)
var sc = bufio.NewScanner(os.Stdin)
func ri() (n int) {
sc.Scan()
for _, v := range sc.Bytes() {
n = n*10 + int(v-48)
}
return
}
func ave(s []float64) float64 {
var sum float64
for _, v := range s {
sum += v
}
return float64(sum) / float64(len(s))
}
func di... | s108967797 | [
{
"input": "3\n1 2 3\n",
"output": "1\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var n, m, x int
fmt.Scan(&n, &m, &x)
a := make([][]int, n)
p := make([]int, n)
for i := 0; i < n; i++ {
fmt.Scan(&p[i])
a[i] = make([]int, m)
for j := 0; j < m; j++ {
fmt.Scan(&a[i][j])
}
}
ans := 1200001
var tot int
var ok bool
for bits := 0; bits < 1<<... | s006130616 | [
{
"input": "3 3 10\n60 2 2 4\n70 8 7 9\n50 2 3 9\n",
"output": "120\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
func main() {
sc := newInputScanner(true, 256)
N, P, S := sc.nextInt(), sc.nextInt(), sc.nextStr()
answer := checkSubNumbers(N, P, S)
fmt.Println(answer)
}
func checkSubNumbers(N int, P int, S string) int {
switch P {
case 2, 5:
return checkTwoOrFive(N... | s832289582 | [
{
"input": "4 3\n3543\n",
"output": "6\n"
}
] |
Go | codenet | package main
import (
"fmt"
)
func main() {
var n int
var x int
var l []int
fmt.Scan(&n)
fmt.Scan(&x)
for i := 0; i < n; i++ {
var tmpL int
fmt.Scan(&tmpL)
l = append(l, tmpL)
}
var tmpSum int
var rs int
for i, v := range l {
tmpSum += v
if i >= n {
rs = n
break
}
if tmpSum <= x {
r... | s201528373 | [
{
"input": "3 6\n3 4 5\n",
"output": "2\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
)
const (
initialBufSize = 1e4
maxBufSize = 1e8
)
var sc = bufio.NewScanner(os.Stdin)
func init() {
buf := make([]byte, initialBufSize)
sc.Buffer(buf, maxBufSize)
sc.Split(bufio.ScanWords)
}
func next() string {
sc.Scan()
return sc.Text()
}
func min(x, y int)... | s801212431 | [
{
"input": "0011\n",
"output": "4\n"
}
] |
Go | codenet | package main
import "fmt"
func main() {
var a, b, c, d, e int
fmt.Scan(&a, &b, &c, &d, &e)
al := []int{a, b, c, d, e}
for n, i := range al {
if i == 0 {
fmt.Println(n + 1)
break
}
}
}
| s672628848 | [
{
"input": "0 2 3 4 5\n",
"output": "1\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"sort"
"strconv"
)
func mainFn() {
n := getInt()
ls := getIntSlice(n)
lsRev := make([]int, n)
copy(lsRev, ls)
sort.Ints(ls)
sort.Sort(sort.Reverse(sort.IntSlice(lsRev)))
ans := 0
for i := 0; i < n; i++ {
for j := i + 1; j < n; j++ {
p, q := min(ls[i], ls[j])... | s068639994 | [
{
"input": "4\n3 4 2 1\n",
"output": "1\n"
}
] |
Go | codenet | package main
import "fmt"
type data struct {
n, m int
nImg, mImg []string
}
func main() {
d := newData()
if d.exist() {
fmt.Println("Yes")
} else {
fmt.Println("No")
}
}
func newData() data {
var n, m int
fmt.Scanf("%d %d", &n, &m)
nImg := load(n)
mImg := load(m)
return data{n: n, m: m, nImg: ... | s864554008 | [
{
"input": "3 2\n#.#\n.#.\n#.#\n#.\n.#\n",
"output": "Yes\n"
}
] |
Go | codenet | package main
import (
"fmt"
)
func solution(n int, a []int) int {
var memo [1e5 + 2]int
for _, num := range a {
memo[num]++
memo[num+1]++
memo[num+2]++
}
out := 0
for _, num := range memo {
if num > 0 {
out = max(out, num)
}
}
return out
}
func max(x, y int) int {
if x > y {
return x
}
retu... | s054878611 | [
{
"input": "7\n3 1 4 1 5 9 2\n",
"output": "4\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"math"
"os"
"strconv"
)
var sc = bufio.NewScanner(os.Stdin)
func nextInt() int {
sc.Scan()
t, err := strconv.Atoi(sc.Text())
if err != nil {
panic(err)
}
return t
}
func scanNums(len int) (nums []int) {
var num int
for i := 0; i < len; i++ {
fmt.Scan(&num)
nums ... | s356695182 | [
{
"input": "1500 2000 1600 3 2\n",
"output": "7900\n"
}
] |
Go | codenet | package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
type Scanner struct {
sc *bufio.Scanner
}
func NewScanner() *Scanner {
sc := bufio.NewScanner(os.Stdin)
sc.Split(bufio.ScanWords)
sc.Buffer(make([]byte, 1024), int(1e+9))
return &Scanner{sc}
}
func (s *Scanner) nextStr() string {
s.sc.Scan()
return s.s... | s211556675 | [
{
"input": "5 3 11\n1\n",
"output": "30\n"
}
] |
Go | codenet | package main
import (
"fmt"
"math"
)
func main() {
var n, m int
fmt.Scan(&n, &m)
x := m*1900 + (n-m)*100
fmt.Println(x * int(math.Pow(2.0, float64(m))))
}
| s739018217 | [
{
"input": "1 1\n",
"output": "3800\n"
}
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.