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

paizaラーニングレベルアップ問題集の【文字列の出力】をやってみました。
- - -
##### 問題
###### 1つの文字列を出力
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__string_output_step1
###### 2つの文字列を出力
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__string_output_step2
###### 入力された2つの文字列を出力
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__string_output_step3
###### 入力された10個の文字列を出力（改行区切り⇒半角空白区切り）
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__string_output_step4
###### 入力された10個の文字列を出力（半角空白区切り⇒改行区切り）
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__string_output_boss
- - -
##### C
###### 1つの文字列を出力
```c
#include <stdio.h>

int main() {
	puts("paiza");
	return 0;
}
```
###### 2つの文字列を出力
```c
#include <stdio.h>

int main() {
	puts("paiza learning");
	return 0;
}
```
###### 入力された2つの文字列を出力
```c
#include <stdio.h>

int main() {
	char s[11];
	scanf("%s", s);
	puts(s);
	char t[11];
	scanf("%s", t);
	puts(t);
	return 0;
}
```
###### 入力された10個の文字列を出力（改行区切り⇒半角空白区切り）
```c
#include <stdio.h>

const int N = 10;

int main() {
	char s[11];
	for (int i = 1; i < N; i++) {
		scanf("%s", s);
		printf("%s ", s);
	}
	scanf("%s", s);
	puts(s);
	return 0;
}
```
###### 入力された10個の文字列を出力（半角空白区切り⇒改行区切り）
```c
#include <stdio.h>

int main() {
	char s[11];
	while (scanf("%s", s) == 1) {
		puts(s);
	}
	return 0;
}
```
- - -
##### C++
###### 1つの文字列を出力
```cpp
#include <iostream>
using namespace std;

int main() {
	cout << "paiza" << endl;
	return 0;
}
```
###### 2つの文字列を出力
```cpp
#include <iostream>
using namespace std;

int main() {
	cout << "paiza" << ' ' << "learning" << endl;
	return 0;
}
```
###### 入力された2つの文字列を出力
```cpp
#include <iostream>
using namespace std;

int main() {
	string s;
	cin >> s;
	cout << s << endl;
	string t;
	cin >> t;
	cout << t << endl;
	return 0;
}
```
###### 入力された10個の文字列を出力（改行区切り⇒半角空白区切り）
```cpp
#include <iostream>
using namespace std;

const int N = 10;

int main() {
	string s;
	for (int i = 1; i < N; i++) {
		cin >> s;
		cout << s << ' ';
	}
	cin >> s;
	cout << s << endl;
	return 0;
}
```
###### 入力された10個の文字列を出力（半角空白区切り⇒改行区切り）
```cpp
#include <iostream>
using namespace std;

int main() {
	string s;
	cin >> s;
	while (cin) {
		cout << s << endl;
		cin >> s;
	}
	return 0;
}
```
- - -
##### C#
###### 1つの文字列を出力
```cs
using System;

class Program
{
	public static void Main()
	{
		Console.WriteLine("paiza");
	}
}
```
###### 2つの文字列を出力
```cs
using System;

class Program
{
	public static void Main()
	{
		Console.WriteLine("paiza" + ' ' + "learning");
	}
}
```
###### 入力された2つの文字列を出力
```cs
using System;

class Program
{
	public static void Main()
	{
		Console.WriteLine(Console.ReadLine());
		Console.WriteLine(Console.ReadLine());
	}
}
```
###### 入力された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());
	}
}
```
###### 入力された10個の文字列を出力（半角空白区切り⇒改行区切り）
```cs
using System;

class Program
{
	public static void Main()
	{
		foreach (string s in Console.ReadLine().Split()) {
			Console.WriteLine(s);
		}
	}
}
```
- - -
##### Go
###### 1つの文字列を出力
```go
package main
import "fmt"

func main() {
	fmt.Println("paiza")
}
```
###### 2つの文字列を出力
```go
package main
import "fmt"

func main() {
	fmt.Println("paiza", "learning")
}
```
###### 入力された2つの文字列を出力
```go
package main
import "fmt"

func main() {
	var s string
	fmt.Scan(&s)
	fmt.Println(s)
	var t string
	fmt.Scan(&t)
	fmt.Println(t)
}
```
###### 入力された10個の文字列を出力（改行区切り⇒半角空白区切り）
```go
package main
import "fmt"

const N = 10

func main() {
	var s string
	for i := 1; i < N; i++ {
		fmt.Scan(&s)
		fmt.Printf("%s ", s)
	}
	fmt.Scan(&s)
	fmt.Println(s)
}
```
###### 入力された10個の文字列を出力（半角空白区切り⇒改行区切り）
```go
package main
import "fmt"

func main() {
	var s string
	for _, err := fmt.Scan(&s); err == nil; _, err = fmt.Scan(&s) {
		fmt.Println(s)
	}
}
```
- - -
##### Java
###### 1つの文字列を出力
```java
public class Main {
	public static void main(String[] args) {
		System.out.println("paiza");
	}
}
```
###### 2つの文字列を出力
```java
public class Main {
	public static void main(String[] args) {
		System.out.println("paiza" + ' ' + "learning");
	}
}
```
###### 入力された2つの文字列を出力
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println(sc.nextLine());
		System.out.println(sc.nextLine());
		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.nextLine() + ' ');
		}
		System.out.println(sc.nextLine());
		sc.close();
	}
}
```
###### 入力された10個の文字列を出力（半角空白区切り⇒改行区切り）
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		for (String s : sc.nextLine().split(" ")) {
			System.out.println(s);
		}
		sc.close();
	}
}
```
- - -
##### JavaScript
###### 1つの文字列を出力
```js
console.log("paiza");
```
###### 2つの文字列を出力
```js
console.log("paiza" + ' ' + "learning");
```
###### 入力された2つの文字列を出力
```js
require("fs").readFileSync("/dev/stdin", "utf8").trim().split("\n").forEach(function (s) { console.log(s) });
```
###### 入力された10個の文字列を出力（改行区切り⇒半角空白区切り）
```js
console.log(...require("fs").readFileSync("/dev/stdin", "utf8").trim().split("\n"));
```
###### 入力された10個の文字列を出力（半角空白区切り⇒改行区切り）
```js
require("fs").readFileSync("/dev/stdin", "utf8").trim().split(" ").forEach(function (s) { console.log(s) });
```
- - -
##### Kotlin
###### 1つの文字列を出力
```kotlin
fun main() {
	println("paiza")
}
```
###### 2つの文字列を出力
```kotlin
fun main() {
	println("paiza" + ' ' + "learning")
}
```
###### 入力された2つの文字列を出力
```kotlin
fun main() {
	println(readLine())
	println(readLine())
}
```
###### 入力された10個の文字列を出力（改行区切り⇒半角空白区切り）
```kotlin
val N = 10

fun main() {
	for (i in 1 until N) {
		print(readLine() + ' ')
	}
	println(readLine())
}
```
###### 入力された10個の文字列を出力（半角空白区切り⇒改行区切り）
```kotlin
fun main() {
	for (s in readLine()!!.split(' ')) {
		println(s)
	}
}
```
- - -
##### PHP
###### 1つの文字列を出力
```php
<?php
	echo "paiza" . PHP_EOL;
?>
```
###### 2つの文字列を出力
```php
<?php
	echo "paiza" . ' ' . "learning" . PHP_EOL;
?>
```
###### 入力された2つの文字列を出力
```php
<?php
	echo trim(fgets(STDIN)) . PHP_EOL;
	echo trim(fgets(STDIN)) . PHP_EOL;
?>
```
###### 入力された10個の文字列を出力（改行区切り⇒半角空白区切り）
```php
<?php
	const N = 10;
	for ($i = 1; $i < N; $i++)
		echo trim(fgets(STDIN)) . ' ';
	echo trim(fgets(STDIN)) . PHP_EOL;
?>
```
###### 入力された10個の文字列を出力（半角空白区切り⇒改行区切り）
```php
<?php
	foreach (explode(" ", trim(fgets(STDIN))) as $s)
		echo "$s\n";
?>
```
- - -
##### Perl
###### 1つの文字列を出力
```pl
print "paiza$/";
```
###### 2つの文字列を出力
```pl
print "paiza", " ", "learning", $/;
```
###### 入力された2つの文字列を出力
```pl
chomp(my $s = <STDIN>);
print "$s\n";
chomp(my $t = <STDIN>);
print "$t\n";
```
- - -
###### 入力された10個の文字列を出力（改行区切り⇒半角空白区切り）
```pl
my $N = 10;
for (my $i = 1; $i < $N; $i++) {
	chomp(my $s = <STDIN>);
	print "$s ";
}
chomp(my $s = <STDIN>);
print "$s\n";
```
###### 入力された10個の文字列を出力（半角空白区切り⇒改行区切り）
```pl
foreach (split(" ", <STDIN>)) {
	print "$_$/";
}
```
- - -
##### Python3
###### 1つの文字列を出力
```py
print("paiza")
```
###### 2つの文字列を出力
```py
print("paiza", "learning")
```
###### 入力された2つの文字列を出力
```py
print(input())
print(input())
```
###### 入力された10個の文字列を出力（改行区切り⇒半角空白区切り）
```py
print(*[input() for _ in range(10)])
```
###### 入力された10個の文字列を出力（半角空白区切り⇒改行区切り）
```py
for s in input().split():
	print(s)
```
- - -
##### Ruby
###### 1つの文字列を出力
```rb
puts "paiza"
```
###### 2つの文字列を出力
```rb
print "paiza", ' ', "learning"
puts
```
###### 入力された2つの文字列を出力
```rb
puts gets
puts gets
```
###### 入力された10個の文字列を出力（改行区切り⇒半角空白区切り）
```rb
N = 10
(1...N).each do
	print gets.chomp, ' '
end
puts gets
```
###### 入力された10個の文字列を出力（半角空白区切り⇒改行区切り）
```rb
gets.split.each do |s|
	puts s
end
```
- - -
##### Scala
###### 1つの文字列を出力
```scala
object Main extends App{
	println("paiza")
}
```
###### 2つの文字列を出力
```scala
object Main extends App{
	println("paiza" + ' ' + "learning")
}
```
###### 入力された2つの文字列を出力
```scala
import scala.io.StdIn._

object Main extends App{
	println(readLine())
	println(readLine())
}
```
###### 入力された10個の文字列を出力（改行区切り⇒半角空白区切り）
```scala
import scala.io.StdIn._

object Main extends App{
	
	val N = 10
	
	for (i <- 1 until N) {
		print(readLine() + ' ')
	}
	println(readLine())
}
```
###### 入力された10個の文字列を出力（半角空白区切り⇒改行区切り）
```scala
import scala.io.StdIn._

object Main extends App{
	readLine().split(' ').foreach(println)
}
```
- - -
##### Swift
###### 1つの文字列を出力
```swift
print("paiza")
```
###### 2つの文字列を出力
```swift
print("paiza", "learning")
```
###### 入力された2つの文字列を出力
```swift
print(readLine()!)
print(readLine()!)
```
###### 入力された10個の文字列を出力（改行区切り⇒半角空白区切り）
```swift
let N = 10

for _ in 1..<N {
	print(readLine()!, terminator: " ")
}
print(readLine()!)
```
###### 入力された10個の文字列を出力（半角空白区切り⇒改行区切り）
```swift
for s in readLine()!.split(separator: " ") {
	print(s)
}
```