채점 정보

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);
    printf("%d\n", a + b);
}

#include <iostream>
using namespace std;

int main() {
    int a, b;
    cin >> a >> b;
    cout << a + b << "\n";
}

a, b = map(int, input().split())
print(a + b)

a, b = map(int, input().split())
print(a + b)

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        System.out.println(a + b);
    }
}

fun main() {
    val (a, b) = readLine()!!.split(" ").map { it.toInt() }
    println(a + b)
}

use std::io;

fn main() {
    let mut line = String::new();
    io::stdin().read_line(&mut line).unwrap();
    let nums: Vec<i32> = line.split_whitespace().map(|x| x.parse().unwrap()).collect();
    println!("{}", nums[0] + nums[1]);
}

package main

import "fmt"

func main() {
    var a, b int
    fmt.Scan(&a, &b)
    fmt.Println(a + b)
}

const [a, b] = require("fs").readFileSync(0, "utf8").split(" ").map(Number);
console.log(a + b);

import * as fs from "fs";

const [a, b] = fs.readFileSync(0, "utf8").split(" ").map(Number);
console.log(a + b);

using System;

class Program {
    static void Main() {
        string[] parts = Console.ReadLine().Split(' ');
        int a = int.Parse(parts[0]);
        int b = int.Parse(parts[1]);
        Console.WriteLine(a + b);
    }
}

program Main;
var
    a, b: Integer;
begin
    ReadLn(a, b);
    WriteLn(a + b);
end.

local a, b = io.read("n", "n")
print(a + b)

a, b = gets.split.map(&:to_i)
puts a + b

x <- scan(file("stdin"), quiet = TRUE)
cat(x[1] + x[2], "\n", sep = "")

def (a, b) = System.in.newReader().readLine().split(" ").collect { it as int }
println(a + b)

Imports System

Module Program
    Sub Main()
        Dim parts = Console.ReadLine().Split(" "c)
        Dim a = Integer.Parse(parts(0))
        Dim b = Integer.Parse(parts(1))
        Console.WriteLine(a + b)
    End Sub
End Module

let parts = System.Console.ReadLine().Split(' ')
let a = int parts.[0]
let b = int parts.[1]
printfn "%d" (a + b)

let () =
    let a, b = Scanf.scanf " %d %d" (fun a b -> (a, b)) in
    Printf.printf "%d\n" (a + b)

program main
    implicit none
    integer :: a, b
    read (*, *) a, b
    print "(I0)", a + b
end program main

       IDENTIFICATION DIVISION.
       PROGRAM-ID. MAIN.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 LINE-IN PIC X(32).
       01 A PIC 9(9).
       01 B PIC 9(9).
       01 C PIC Z(9)9.
       PROCEDURE DIVISION.
           ACCEPT LINE-IN.
           UNSTRING LINE-IN DELIMITED BY ALL SPACE INTO A B.
           COMPUTE C = A + B.
           DISPLAY FUNCTION TRIM(C).
           STOP RUN.

read a b
echo $((a + b))

~+n

my ($a, $b) = split ' ', <STDIN>;
print $a + $b, "\n";

{ print $1 + $2 }

<?php
[$a, $b] = explode(' ', trim(fgets(STDIN)));
echo $a + $b, "\n";

gets stdin line
lassign $line a b
puts [expr {$a + $b}]

import 'dart:io';

void main() {
    var parts = stdin.readLineSync()!.split(' ');
    print(int.parse(parts[0]) + int.parse(parts[1]));
}

let parts = readLine()!.split(separator: " ").map { Int($0)! }
print(parts[0] + parts[1])

const std = @import("std");

pub fn main(init: std.process.Init) !void {
    var in_buf: [1024]u8 = undefined;
    var stdin = std.Io.File.stdin().reader(init.io, &in_buf);
    const line = (try stdin.interface.takeDelimiter('\n')) orelse "";
    var it = std.mem.tokenizeScalar(u8, line, ' ');
    const a = try std.fmt.parseInt(i64, it.next().?, 10);
    const b = try std.fmt.parseInt(i64, it.next().?, 10);
    var out_buf: [64]u8 = undefined;
    var stdout = std.Io.File.stdout().writer(init.io, &out_buf);
    try stdout.interface.print("{d}\n", .{a + b});
    try stdout.interface.flush();
}

import strutils

let parts = readLine(stdin).split(' ')
echo parseInt(parts[0]) + parseInt(parts[1])

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

procedure Main is
    A, B : Integer;
begin
    Get(A);
    Get(B);
    Put(A + B, Width => 0);
    New_Line;
end Main;

#import <stdio.h>
#import <objc/Object.h>

@interface Adder : Object
+ (int)add:(int)a to:(int)b;
@end

@implementation Adder
+ (int)add:(int)a to:(int)b {
    return a + b;
}
@end

int main() {
    int a, b;
    scanf("%d %d", &a, &b);
    printf("%d\n", [Adder add:a to:b]);
    return 0;
}

BEGIN
    INT a, b;
    read((a, b));
    print((whole(a + b, 0), new line))
END

section .bss
    buf resb 32

section .text
global _start

_start:
    mov rax, 0
    mov rdi, 0
    mov rsi, buf
    mov rdx, 32
    syscall

    mov rsi, buf
    call read_int
    mov r12, rax
    call read_int
    add rax, r12

    mov rdi, buf + 31
    mov byte [rdi], 10
    mov rbx, 10
.digit:
    dec rdi
    xor rdx, rdx
    div rbx
    add dl, '0'
    mov [rdi], dl
    test rax, rax
    jnz .digit

    mov rax, 1
    mov rsi, rdi
    mov rdx, buf + 32
    sub rdx, rdi
    mov rdi, 1
    syscall

    mov rax, 60
    xor rdi, rdi
    syscall

; rsi가 가리키는 위치부터 공백을 건너뛰고 십진수 하나를 rax로 읽는다
read_int:
    xor rax, rax
.skip:
    movzx ecx, byte [rsi]
    cmp cl, '0'
    jb .next
    cmp cl, '9'
    ja .next
    jmp .parse
.next:
    inc rsi
    jmp .skip
.parse:
    movzx ecx, byte [rsi]
    cmp cl, '0'
    jb .done
    cmp cl, '9'
    ja .done
    sub cl, '0'
    imul rax, 10
    add rax, rcx
    inc rsi
    jmp .parse
.done:
    ret