paizaラーニングレベルアップ問題集の【特定の文字で区切り1行で出力】をやってみた。

paizaラーニングレベルアップ問題集の【特定の文字で、区切り1行で出力】をやってみました。
- - -
##### 問題
###### カンマ区切りで2つ出力
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__specific_split_step1
###### バーティカルライン区切りで3つの文字列を出力
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__specific_split_step2
###### カンマ区切りで10個出力1
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__specific_split_step3
###### カンマ区切りで10個出力2
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__specific_split_step4
###### 半角スペースとバーティカルライン区切りで10個出力
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__specific_split_step5
- - -
##### C
###### カンマ区切りで2つ出力
```c
#include <stdio.h>

int main() {
	int n, m;
	scanf("%d %d", &n, &m);
	printf("%d,%d\n", n, m);
	return 0;
}
```
###### バーティカルライン区切りで3つの文字列を出力
```c
#include <stdio.h>

int main() {
	char s1[11], s2[11], s3[11];
	scanf("%s", s1);
	scanf("%s", s2);
	scanf("%s", s3);
	printf("%s|%s|%s\n", s1, s2, s3);
	return 0;
}
```
###### カンマ区切りで10個出力1
```c
#include <stdio.h>

const int N = 10;

int main() {
	for (int i = 0; i < N; i++) {
		int n;
		scanf("%d", &n);
		printf("%d,", n);
	}
	return 0;
}
```
###### カンマ区切りで10個出力2
```c
#include <stdio.h>

const int N = 10;

int main() {
	int n;
	for (int i = 1; i < N; i++) {
		scanf("%d", &n);
		printf("%d,", n);
	}
	scanf("%d", &n);
	printf("%d\n", n);
	return 0;
}
```
###### 半角スペースとバーティカルライン区切りで10個出力
```c
#include <stdio.h>

const int N = 10;

int main() {
	int n;
	for (int i = 1; i < N; i++) {
		scanf("%d", &n);
		printf("%d | ", n);
	}
	scanf("%d", &n);
	printf("%d\n", n);
	return 0;
}
```
- - -
##### C++
###### カンマ区切りで2つ出力
```cpp
#include <iostream>
using namespace std;

int main() {
	int n, m;
	cin >> n >> m;
	cout << n << ',' << m << endl;
	return 0;
}
```
###### バーティカルライン区切りで3つの文字列を出力
```cpp
#include <iostream>
using namespace std;

int main() {
	string s1, s2, s3;
	cin >> s1;
	cin >> s2;
	cin >> s3;
	cout << s1 << '|' << s2 << '|' << s3 << endl;
	return 0;
}
```
###### カンマ区切りで10個出力1
```cpp
#include <iostream>
using namespace std;

const int N = 10;

int main() {
	for (int i = 0; i < N; i++) {
		int n;
		cin >> n;
		cout << n << ',';
	}
	cout << endl;
	return 0;
}
```
###### カンマ区切りで10個出力2
```cpp
#include <iostream>
using namespace std;

const int N = 10;

int main() {
	int n;
	for (int i = 1; i < N; i++) {
		cin >> n;
		cout << n << ',';
	}
	cin >> n;
	cout << n << endl;
	return 0;
}
```
###### 半角スペースとバーティカルライン区切りで10個出力
```cpp
#include <iostream>
using namespace std;

const int N = 10;

int main() {
	int n;
	for (int i = 1; i < N; i++) {
		cin >> n;
		cout << n << " | ";
	}
	cin >> n;
	cout << n << endl;
	return 0;
}
```
- - -
##### C#
###### カンマ区切りで2つ出力
```cs
using System;

class Program
{
	public static void Main()
	{
		int[] nm = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		Console.WriteLine(nm[0] + "," + nm[1]);
	}
}
```
###### バーティカルライン区切りで3つの文字列を出力
```cs
using System;

class Program
{
	public static void Main()
	{
		string s1 = Console.ReadLine();
		string s2 = Console.ReadLine();
		string s3 = Console.ReadLine();
		Console.WriteLine(s1 + "|" + s2 + "|" + s3);
	}
}
```
###### カンマ区切りで10個出力1
```cs
using System;

class Program
{
	public static void Main()
	{
		int[] N = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		foreach (int n in N)
			Console.Write(n + ",");
		Console.WriteLine();
	}
}
```
###### カンマ区切りで10個出力2
```cs
using System;

class Program
{
	public static void Main()
	{
		Console.WriteLine(string.Join(",", Console.ReadLine().Split()));
	}
}
```
###### 半角スペースとバーティカルライン区切りで10個出力
```cs
using System;

class Program
{

	const int N = 10;
	
	public static void Main()
	{
		for (int i = 1; i < N; i++) {
			Console.Write(Console.ReadLine() + " | ");
		}
		Console.WriteLine(Console.ReadLine());
	}
}
```
- - -
##### Go
###### カンマ区切りで2つ出力
```go
package main
import "fmt"

func main() {
	var n, m int
	fmt.Scan(&n, &m)
	fmt.Printf("%d,%d\n", n, m)
}
```
###### バーティカルライン区切りで3つの文字列を出力
```go
package main
import "fmt"

func main() {
	var s1, s2, s3 string
	fmt.Scan(&s1)
	fmt.Scan(&s2)
	fmt.Scan(&s3)
	fmt.Printf("%s|%s|%s\n", s1, s2, s3)
}
```
###### カンマ区切りで10個出力1
```go
package main
import "fmt"

const N = 10

func main() {
	for i := 0; i < N; i++ {
		var n int
		fmt.Scan(&n)
		fmt.Printf("%d,", n)
	}
	fmt.Println()
}
```
###### カンマ区切りで10個出力2
```go
package main
import "fmt"

const N = 10

func main() {
	var n int
	for i := 1; i < N; i++ {
		fmt.Scan(&n)
		fmt.Printf("%d,", n)
	}
	fmt.Scan(&n)
	fmt.Println(n)
}
```
###### 半角スペースとバーティカルライン区切りで10個出力
```go
package main
import "fmt"

const N = 10

func main() {
	var n int
	for i := 1; i < N; i++ {
		fmt.Scan(&n)
		fmt.Printf("%d | ", n)
	}
	fmt.Scan(&n)
	fmt.Println(n)
}
```
- - -
##### Java
###### カンマ区切りで2つ出力
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		System.out.println(n + "," + m);
		sc.close();
	}
}
```
###### バーティカルライン区切りで3つの文字列を出力
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String s1 = sc.nextLine();
		String s2 = sc.nextLine();
		String s3 = sc.nextLine();
		System.out.println(s1 + "|" + s2 + "|" + s3);
		sc.close();
	}
}
```
###### カンマ区切りで10個出力1
```java
import java.util.*;

public class Main {
	
	static final int N = 10;
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		for (int i = 0; i < N; i++)
			System.out.print(sc.nextInt() + ",");
		sc.close();
	}
}
```
###### カンマ区切りで10個出力2
```java
import java.util.*;

public class Main {
	
	static final int N = 10;
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		for (int i = 1; i < N; i++)
			System.out.print(sc.nextInt() + ",");
		System.out.println(sc.nextInt());
		sc.close();
	}
}
```
###### 半角スペースとバーティカルライン区切りで10個出力
```java
import java.util.*;

public class Main {
	
	static final int N = 10;
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		for (int i = 1; i < N; i++)
			System.out.print(sc.next() + " | ");
		System.out.println(sc.next());
		sc.close();
	}
}
```
- - -
##### JavaScript
###### カンマ区切りで2つ出力
```js
const [n, m] = require("fs").readFileSync("/dev/stdin", "utf8").split(' ').map(Number);
console.log(n + ',' + m);
```
###### バーティカルライン区切りで3つの文字列を出力
```js
const [s1, s2, s3] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n');
console.log(s1 + '|' + s2 + '|' + s3);
```
###### カンマ区切りで10個出力1
```js
console.log(require("fs").readFileSync("/dev/stdin", "utf8").trim().split(" ").map(Number).reduce((S, s) => S + s + ',', ""));
```
###### カンマ区切りで10個出力2
```js
console.log(require("fs").readFileSync("/dev/stdin", "utf8").trim().split(" ").join(','));
```
###### 半角スペースとバーティカルライン区切りで10個出力
```js
console.log(require("fs").readFileSync("/dev/stdin", "utf8").trim().split("\n").join(" | "));
```
- - -
##### Kotlin
###### カンマ区切りで2つ出力
```kotlin
fun main() {
	val (n, m) = readLine()!!.split(' ').map { it.toInt() }
	println("" + n + ',' + m)
}
```
###### バーティカルライン区切りで3つの文字列を出力
```kotlin
fun main() {
	println(readLine()!! + '|' + readLine()!! + '|' + readLine()!!)
}
```
###### カンマ区切りで10個出力1
```kotlin
import java.util.*

val N = 10

fun main() {
	val sc = Scanner(System.`in`)
	for (i in 1..N) {
		print("" + sc.nextInt() + ",")
	}
	println()
}
```
###### カンマ区切りで10個出力2
```kotlin
fun main() {
	println(readLine()!!.split(" ").map { it.toInt() }.joinToString(","))
}
```
###### 半角スペースとバーティカルライン区切りで10個出力
```kotlin
val N = 10

fun main() {
	println(Array(N) { readLine()!!.toInt() }.joinToString(" | "))
}
```
- - -
##### PHP
###### カンマ区切りで2つ出力
```php
<?php
	[$n, $m] = array_map("intval", explode(' ', trim(fgets(STDIN))));
	echo "$n,$m\n";
?>
```
###### バーティカルライン区切りで3つの文字列を出力
```php
<?php
	echo trim(fgets(STDIN)), '|', trim(fgets(STDIN)), '|', trim(fgets(STDIN)), PHP_EOL;
?>
```
###### カンマ区切りで10個出力1
```php
<?php
	foreach (array_map("intval", explode(' ', trim(fgets(STDIN)))) as $n)
		echo "$n,";
	echo PHP_EOL;
?>
```
###### カンマ区切りで10個出力2
```php
<?php
	echo implode(',', array_map("intval", explode(' ', trim(fgets(STDIN))))), PHP_EOL;
?>
```
###### 半角スペースとバーティカルライン区切りで10個出力
```php
<?php
	$N = 10;
	for ($i = 1; $i < $N; $i++)
		echo trim(fgets(STDIN)), " | ";
	echo trim(fgets(STDIN)), PHP_EOL;
?>
```
- - -
##### Perl
###### カンマ区切りで2つ出力
```pl
my ($n, $m) = split " ", <STDIN>;
print "$n,$m$/";
```
###### バーティカルライン区切りで3つの文字列を出力
```pl
chomp(my $s1 = <STDIN>);
chomp(my $s2 = <STDIN>);
chomp(my $s3 = <STDIN>);
print "$s1|$s2|$s3$/";
```
###### カンマ区切りで10個出力1
```pl
foreach $n (map { int($_) } split " ", <STDIN>) {
	print "$n,";
}
print $/;
```
###### カンマ区切りで10個出力2
```pl
print join(',', map { int($_) } split(' ', <STDIN>)), $/;
```
###### 半角スペースとバーティカルライン区切りで10個出力
```pl
print join(',', map { int($_) } <STDIN>), $/;
```
- - -
##### Python3
###### カンマ区切りで2つ出力
```py
n, m = map(int, input().split())
print(str(n) + ',' + str(m))
```
###### バーティカルライン区切りで3つの文字列を出力
```py
print(input() + '|' + input() + '|' + input())
```
###### カンマ区切りで10個出力1
```py
for n in input().split():
	print(n, end=',')
print()
```
###### カンマ区切りで10個出力2
```py
print(*map(int, input().split()), sep=',')
```
###### 半角スペースとバーティカルライン区切りで10個出力
```py
print(*map(int, open(0).readlines()), sep=" | ")
```
- - -
##### Ruby
###### カンマ区切りで2つ出力
```rb
n, m = gets.split.map(&:to_i)
print n, ',', m
puts
```
###### バーティカルライン区切りで3つの文字列を出力
```rb
print gets.chomp, '|', gets.chomp, '|', gets.chomp
puts
```
###### カンマ区切りで10個出力1
```rb
gets.split.map(&:to_i).each do |n|
	print n, ','
end
puts
```
###### カンマ区切りで10個出力2
```rb
puts gets.split.map(&:to_i).join(',')
```
###### 半角スペースとバーティカルライン区切りで10個出力
```rb
puts ARGF.each_line.map(&:to_i).join(" | ")
```
- - -
##### Scala
###### カンマ区切りで2つ出力
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(a, b) = readLine().split(" ").map(_.toInt)
	println("" + a + ',' + b)
}
```
###### バーティカルライン区切りで3つの文字列を出力
```scala
import scala.io.StdIn._

object Main extends App{
	println(readLine() + '|' + readLine() + '|' + readLine())
}
```
###### カンマ区切りで10個出力1
```scala
import scala.io.StdIn._

object Main extends App{
	readLine().split(' ').foreach(n => print(n + ","))
	println()
}
```
###### カンマ区切りで10個出力2
```scala
import scala.io.StdIn._

object Main extends App{
	println(readLine().split(' ').mkString(","))
}
```
###### 半角スペースとバーティカルライン区切りで10個出力
```scala
import scala.io.Source._

object Main extends App{
	println(stdin.getLines().mkString(" | "))
}
```
- - -
##### Swift
###### カンマ区切りで2つ出力
```swift
let nm = readLine()!.split(separator: " ").compactMap { Int($0) }
print(String(nm[0]) + "," + String(nm[1]))
```
###### バーティカルライン区切りで3つの文字列を出力
```swift
print(readLine()! + "|" + readLine()! + "|" + readLine()!)
```
###### カンマ区切りで10個出力1
```swift
for n in readLine()!.split(separator: " ").compactMap({ Int($0) }){
	print(n, terminator: ",")
}
print()
```
###### カンマ区切りで10個出力2
```swift
print(readLine()!.split(separator: " ").compactMap { Int($0) }.map { String($0) }.joined(separator: ","))
```
###### 半角スペースとバーティカルライン区切りで10個出力
```swift
import Foundation

print(String(data: FileHandle.standardInput.readDataToEndOfFile(), encoding: .utf8)!.split(separator: "\n").joined(separator: " | "))
```