paizaラーニングレベルアップ問題集の【標準入出力】をやってみた。

paizaラーニングレベルアップ問題集の
Cランクレベルアップメニュー【標準入出力】をやってみました。
- - -
##### 問題
###### 単純な入出力
https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_std_in_out_step1
###### 複数行にわたる出力
https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_std_in_out_step2
###### 複数行にわたる入力
https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_std_in_out_step3
###### 入力の配列による保持
https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_std_in_out_step4
###### 半角スペース区切りでの出力
https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_std_in_out_step5
###### 改行区切りでの出力
https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_std_in_out_step6
###### 標準入出力
https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_std_in_out_boss
- - -
##### C
###### 単純な入出力
```c
#include <stdio.h>

char* chomp(char* s) {
	if (!s) return s;
	char* c = s;
	while (*c) c++;
	while (--c >= s)
		if (*c == '\n') *c = '\0';
		else break;
	return s;
}

int main() {
	char s[12];
	if (fgets(s, sizeof(s), stdin)) puts(chomp(s));
	return 0;
}
```
###### 複数行にわたる出力
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	while (n--) puts("paiza");
	return 0;
}
```
###### 複数行にわたる入力
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	while (n--) {
		int a;
		scanf("%d", &a);
		printf("%d\n", a);
	}
	return 0;
}
```
###### 入力の配列による保持
```c
#include <stdio.h>

int max(int n, int A[n]) {
	int m = A[0];
	for (int i = 1; i < n; i++) if (A[i] > m) m = A[i];
	return m;
}

int main() {
	int n;
	scanf("%d", &n);
	int A[n];
	for (int i = 0; i < n; i++) scanf("%d", &A[i]);
	printf("%d\n", max(n, A));
	return 0;
}
```
###### 半角スペース区切りでの出力
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	while (n--) {
		printf("paiza");
		if (n) putchar(' ');
	}
	puts("");
	return 0;
}
```
###### 改行区切りでの出力
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	while (n--) {
		int a;
		scanf("%d", &a);
		printf("%d\n", a);
	}
	return 0;
}
```
###### 標準入出力
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	while (n--) {
		char s[11];
		int a;
		scanf("%s %d", s, &a);
		printf("%s %d\n", s, a + 1);
	}
	return 0;
}
```
- - -
##### C++
###### 単純な入出力
```cpp
#include <iostream>
using namespace std;

int main() {
	string s;
	getline(cin, s);
	cout << s << endl;
	return 0;
}
```
###### 複数行にわたる出力
```cpp
#include <iostream>
using namespace std;

int main() {
	int n;
	cin >> n;
	while (n--) cout << "paiza" << endl;
	return 0;
}
```
###### 複数行にわたる入力
```cpp
#include <iostream>
using namespace std;

int main() {
	int n;
	cin >> n;
	while (n--) {
		int a;
		cin >> a;
		cout << a << endl;
	}
	return 0;
}
```
###### 入力の配列による保持
```cpp
#include <iostream>
#include <algorithm>
using namespace std;

int main() {
	int n;
	cin >> n;
	int A[n];
	for (int i = 0; i < n; i++) cin >> A[i];
	cout << *max_element(A, A + n) << endl;
	return 0;
}
```
###### 半角スペース区切りでの出力
```cpp
#include <iostream>
using namespace std;

int main() {
	int n;
	cin >> n;
	while (n--) {
		cout << "paiza";
		if (n) cout << ' ';
	}
	cout << endl;
	return 0;
}
```
###### 改行区切りでの出力
```cpp
#include <iostream>
using namespace std;

int main() {
	int n;
	cin >> n;
	while (n--) {
		int a;
		cin >> a;
		cout << a << endl;
	}
	return 0;
}
```
###### 標準入出力
```cpp
#include <iostream>
using namespace std;

int main() {
	int n;
	cin >> n;
	while (n--) {
		string s;
		int a;
		cin >> s >> a;
		cout << s << ' ' << (a + 1) << endl;
	}
	return 0;
}
```
- - -
##### C#
###### 単純な入出力
```cs
using System;

class Program
{
	public static void Main()
	{
		Console.WriteLine(Console.ReadLine());
	}
}
```
###### 複数行にわたる出力
```cs
using System;

class Program
{
	public static void Main()
	{
		for (int n = int.Parse(Console.ReadLine()); n > 0; n--) {
			Console.WriteLine("paiza");
		}
	}
}
```
###### 複数行にわたる入力
```cs
using System;

class Program
{
	public static void Main()
	{
		for (int n = int.Parse(Console.ReadLine()); n > 0; n--)
			Console.WriteLine(int.Parse(Console.ReadLine()));
	}
}
```
###### 入力の配列による保持
```cs
using System;
using System.Linq;

class Program
{
	static void Main()
	{
		Console.WriteLine(Enumerable.Range(0, int.Parse(Console.ReadLine())).Select(_ => int.Parse(Console.ReadLine())).Max());
	}
}
```
###### 半角スペース区切りでの出力
```cs
using System;
using System.Linq;

class Program
{
	static void Main()
	{
		Console.WriteLine(string.Join(" ", Enumerable.Repeat("paiza", int.Parse(Console.ReadLine()))));
	}
}
```
###### 改行区切りでの出力
```cs
using System;

class Program
{
	public static void Main()
	{
		int n = int.Parse(Console.ReadLine());
		int[] A = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		for (int i = 0; i < n; i++) Console.WriteLine(A[i]);
	}
}
```
###### 標準入出力
```cs
using System;

class Program
{
	public static void Main()
	{
		for (int n = int.Parse(Console.ReadLine()); n > 0; n--) {
			string[] sa = Console.ReadLine().Split();
			string s = sa[0];
			int a = int.Parse(sa[1]);
			Console.WriteLine(s + ' ' + (a + 1));
		}
	}
}
```
- - -
##### Go
###### 単純な入出力
```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	sc := bufio.NewScanner(os.Stdin)
	if sc.Scan() {
		fmt.Println(sc.Text())
	}
}
```
###### 複数行にわたる出力
```go
package main
import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	for i := 0; i < n; i++ {
		fmt.Println("paiza")
	}
}
```
###### 複数行にわたる入力
```go
package main
import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	for i := 0; i < n; i++ {
		var a int
		fmt.Scan(&a)
		fmt.Println(a)
	}
}
```
###### 入力の配列による保持
```go
package main
import "fmt"

func max(A []int) int {
	m := A[0]
	for i := 1; i < len(A); i++ {
		if A[i] > m {
			m = A[i]
		}
	}
	return m
}

func main() {
	var n int
	fmt.Scan(&n)
	A := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&A[i])
	}
	fmt.Println(max(A))
}
```
###### 半角スペース区切りでの出力
```go
package main
import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	for i := 0; i < n; i++ {
		if (i > 0) {
			fmt.Print(" ")
		}
		fmt.Print("paiza")
	}
	fmt.Println()
}
```
###### 改行区切りでの出力
```go
package main
import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	for i := 0; i < n; i++ {
		var a int
		fmt.Scan(&a)
		fmt.Println(a)
	}
}
```
###### 標準入出力
```go
package main
import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	for i := 0; i < n; i++ {
		var s string
		var a int
		fmt.Scan(&s, &a)
		fmt.Println(s, a + 1)
	}
}
```
- - -
##### Java
###### 単純な入出力
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println(sc.nextLine());
		sc.close();
	}
}
```
###### 複数行にわたる出力
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		for (int n = sc.nextInt(); n > 0; n--) {
			System.out.println("paiza");
		}
		sc.close();
	}
}
```
###### 複数行にわたる入力
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		for (int n = sc.nextInt(); n > 0; n--) {
			System.out.println(sc.nextInt());
		}
		sc.close();
	}
}
```
###### 入力の配列による保持
```java
import java.util.*;
import java.util.stream.IntStream;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println(IntStream.range(0, sc.nextInt()).map(i -> sc.nextInt()).max().getAsInt());
		sc.close();
	}
}
```
###### 半角スペース区切りでの出力
```java
import java.util.*;
import java.util.stream.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println(Stream.generate(() -> "paiza").limit(sc.nextInt()).collect(Collectors.joining(" ")));
		sc.close();
	}
}
```
###### 改行区切りでの出力
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		sc.nextLine();
		int[] A = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
		for (int i = 0; i < n; i++) System.out.println(A[i]);
	}
}
```
###### 標準入出力
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		for (int n = sc.nextInt(); n > 0; n--) {
			System.out.println(sc.next() + ' ' + (sc.nextInt() + 1));
		}
		sc.close();
	}
}
```
- - -
##### JavaScript
###### 単純な入出力
```js
console.log(require("fs").readFileSync("/dev/stdin", "utf8").trim());
```
###### 複数行にわたる出力
```js
Array(Number(require("fs").readFileSync("/dev/stdin", "utf8"))).fill("paiza").forEach((s, _) => console.log(s));
```
###### 複数行にわたる入力
```js
const [N, ...A] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n').map(Number);
for (var i = 0; i < N; i++) console.log(A[i]);
```
###### 入力の配列による保持
```js
const [N, ...A] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n').map(Number);
console.log(Math.max(...A));
```
###### 半角スペース区切りでの出力
```js
console.log(Array(Number(require("fs").readFileSync("/dev/stdin", "utf8"))).fill("paiza").join(' '));
```
###### 改行区切りでの出力
```js
const [N, A] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n').map(s => s.split(' ').map(Number));
const n = N[0];
for (var i = 0; i < n; i++) console.log(A[i]);
```
###### 標準入出力
```js
const [N, ...SA] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n').map(s => s.split(' '));
const n = Number(N[0]);
for (var i = 0; i < n; i++) {
	const [s, a] = SA[i];
	console.log(s, Number(a) + 1);
}
```
- - -
##### Kotlin
###### 単純な入出力
```kotlin
fun main() {
	println(readLine()!!)
}
```
###### 複数行にわたる出力
```kotlin
fun main() {
	repeat (readLine()!!.toInt()) {
		println("paiza")
	}
}
```
###### 複数行にわたる入力
```kotlin
fun main() {
	repeat (readLine()!!.toInt()) {
		println(readLine()!!.toInt())
	}
}
```
###### 入力の配列による保持
```kotlin
fun main() {
	println(Array(readLine()!!.toInt()) { readLine()!!.toInt() }.max())
}
```
###### 半角スペース区切りでの出力
```kotlin
fun main() {
	println(Array(readLine()!!.toInt()) { "paiza" }.joinToString(" "))
}
```
###### 改行区切りでの出力
```kotlin
fun main() {
	val n = readLine()!!.toInt()
	val A = readLine()!!.split(' ').map { it.toInt() }
	for (i in 0 until n) println(A[i])
}
```
###### 標準入出力
```kotlin
fun main() {
	repeat(readLine()!!.toInt()) {
		val (s, a) = readLine()!!.split(' ')
		println(s + ' ' + (a.toInt() + 1))
	}
}
```
- - -
##### PHP
###### 単純な入出力
```php
<?php
	echo trim(fgets(STDIN)), PHP_EOL;
?>
```
###### 複数行にわたる出力
```php
<?php
	for ($n = intval(fgets(STDIN)); $n > 0; $n--) echo "paiza", PHP_EOL;
?>
```
###### 複数行にわたる入力
```php
<?php
	for ($n = intval(fgets(STDIN)); $n > 0; $n--) echo intval(fgets(STDIN)), PHP_EOL;
?>
```
###### 入力の配列による保持
```php
<?php
	$A = [];
	for ($n = intval(fgets(STDIN)); $n > 0; $n--) $A[] = intval(fgets(STDIN));
	echo max($A), PHP_EOL;
?>
```
###### 半角スペース区切りでの出力
```php
<?php
	echo implode(" ", array_fill(0, intval(fgets(STDIN)), "paiza")), PHP_EOL;
?>
```
###### 改行区切りでの出力
```php
<?php
	$n = intval(fgets(STDIN));
	$A = array_map("intval", explode(' ', fgets(STDIN)));
	for ($i = 0; $i < $n; $i++) echo $A[$i], PHP_EOL;
?>
```
###### 標準入出力
```php
<?php
	for ($n = intval(fgets(STDIN)); $n > 0; $n--) {
		[$s, $a] = explode(' ', fgets(STDIN));
		echo $s, ' ', intval($a) + 1, PHP_EOL;
	}
?>
```
- - -
##### Perl
###### 単純な入出力
```pl
chomp(my $s = <STDIN>);
print "$s$/";
```
###### 複数行にわたる出力
```pl
for (1..int(<STDIN>)) {
	print "paiza$/";
}
```
###### 複数行にわたる入力
```pl
for (1..int(<STDIN>)) {
	print int(<STDIN>), $/;
}
```
###### 入力の配列による保持
```pl
use List::Util qw(max);

my @A;
for (1..int(<STDIN>)) {
	push @A, int(<STDIN>);
}
print max(@A);
```
###### 半角スペース区切りでの出力
```pl
print join ' ', ("paiza") x int(<STDIN>);
```
###### 改行区切りでの出力
```pl
my $n = int(<STDIN>);
my @A = map { int($_) } split ' ', <STDIN>;
for (my $i = 0; $i < $n; $i++) {
	print $A[$i], $/;
}
```
###### 標準入出力
```pl
for (1..int(<STDIN>)) {
	my ($s, $a) = split ' ', <STDIN>;
	print $s, ' ', int($a) + 1, $/;
}
```
- - -
##### Python3
###### 単純な入出力
```py
print(input())
```
###### 複数行にわたる出力
```py
for _ in range(int(input())):
	print("paiza")
```
###### 複数行にわたる入力
```py
for _ in range(int(input())):
	print(int(input()))
```
###### 入力の配列による保持
```py
print(max(int(input()) for _ in range(int(input()))))
```
###### 半角スペース区切りでの出力
```py
print(' '.join(["paiza"] * int(input())))
```
###### 改行区切りでの出力
```py
n = int(input())
A = list(map(int, input().split()))
for i in range(n):
	print(A[i])
```
###### 標準入出力
```py
for _ in range(int(input())):
	s, a = input().split()
	print(s, int(a) + 1)
```
- - -
##### Ruby
###### 単純な入出力
```rb
puts gets
```
###### 複数行にわたる出力
```rb
gets.to_i.times do
	puts "paiza"
end
```
###### 複数行にわたる入力
```rb
gets.to_i.times do
	p gets.to_i
end
```
###### 入力の配列による保持
```rb
p gets.to_i.times.map { gets.to_i }.max
```
###### 半角スペース区切りでの出力
```rb
puts (["paiza"] * gets.to_i).join(' ')
```
###### 改行区切りでの出力
```rb
n = gets.to_i
A = gets.split.map(&:to_i)
n.times do |i|
	p A[i]
end
```
###### 標準入出力
```rb
gets.to_i.times do
	s, a = gets.split
	print s, ' ', a.to_i + 1, "\n"
end
```
- - -
##### Scala
###### 単純な入出力
```scala
object Main extends App{
	println(scala.io.StdIn.readLine())
}
```
###### 複数行にわたる出力
```scala
import scala.io.StdIn._

object Main extends App{
	for (_ <- 0 until readInt()) println("paiza")
}
```
###### 複数行にわたる入力
```scala
import scala.io.StdIn._

object Main extends App{
	for (_ <- 0 until readInt()) println(readInt())
}
```
###### 入力の配列による保持
```scala
import scala.io.StdIn._

object Main extends App{
	println(Array.fill(readInt()) { readInt() }.max)
}
```
###### 半角スペース区切りでの出力
```scala
import scala.io.StdIn._

object Main extends App{
	println(Array.fill(readInt()) { "paiza" }.mkString(" "))
}
```
###### 改行区切りでの出力
```scala
import scala.io.StdIn._

object Main extends App{
	val n = readInt()
	val A = readLine().split(' ').map { _.toInt }
	for (i <- 0 until n) {
		println(A(i))
	}
}
```
###### 標準入出力
```scala
import scala.io.StdIn._

object Main extends App{
	for (_ <- 0 until readInt()) {
		val Array(s, a) = readLine().split(' ')
		println(s + ' ' + (a.toInt + 1))
	}
}
```
- - -
##### Swift
###### 単純な入出力
```swift
print(readLine()!)
```
###### 複数行にわたる出力
```swift
for i in 0..<Int(readLine()!)! {
	print("paiza")
}
```
###### 複数行にわたる入力
```swift
for i in 0..<Int(readLine()!)! {
	print(Int(readLine()!)!)
}
```
###### 入力の配列による保持
```swift
var A = [Int]()
for _ in 0..<Int(readLine()!)! {
	A.append(Int(readLine()!)!)
}
print(A.max()!)
```
###### 半角スペース区切りでの出力
```swift
print(Array(repeating: "paiza", count: Int(readLine()!)!).joined(separator: " "))
```
###### 改行区切りでの出力
```swift
let n = Int(readLine()!)!
let A = readLine()!.split(separator: " ").compactMap { Int($0) }
for i in 0..<n {
	print(A[i])
}
```
###### 標準入出力
```swift
for _ in 0..<Int(readLine()!)! {
	let sa = readLine()!.split(separator: " ")
	let (s, a) = (sa[0], Int(sa[1])!)
	print(s, a + 1)
}
```