paizaラーニングレベルアップ問題集の「二重ループメニュー」をやってみた。(1)

paizaラーニングレベルアップ問題集の「二重ループメニュー」をやってみました。
- - -
##### 問題
###### 指定された数字までの出力（半角スペース区切り）
https://paiza.jp/works/mondai/double_roop_problems/double_roop_problems__print_column_new
###### 指定された数字までの出力（改行区切り）
https://paiza.jp/works/mondai/double_roop_problems/double_roop_problems__print_num_new
###### 指定された行数の数字の出力
https://paiza.jp/works/mondai/double_roop_problems/double_roop_problems__print_column
###### 指定された範囲・行数の数字の出力
https://paiza.jp/works/mondai/double_roop_problems/double_roop_problems__print_range
- - -
##### C
###### 指定された数字までの出力（半角スペース区切り）
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) {
		printf("%d", i);
		if (i < n) putchar(' ');
	}
	puts("");
	return 0;
}
```
###### 指定された数字までの出力（改行区切り）
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) {
		printf("%d\n", i);
	}
	return 0;
}
```
###### 指定された行数の数字の出力
```c
#include <stdio.h>

const int M = 5;

int main() {
	int n;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		for (int j = 1; j <= M; j++) {
			printf("%d", j);
			if (j < M) putchar(' ');
		}
		puts("");
	}
	return 0;
}
```
###### 指定された範囲・行数の数字の出力
```c
#include <stdio.h>

int main() {
	int n, k;
	scanf("%d %d", &n, &k);
	for (int i = 0; i < k; i++) {
		for (int j = 1; j <= n; j++) {
			printf("%d", j);
			if (j < n) putchar(' ');
		}
		puts("");
	}
	return 0;
}
```
- - -
##### C++
###### 指定された数字までの出力（半角スペース区切り）
```cpp
#include <iostream>
using namespace std;

int main() {
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cout << i;
		if (i < n) cout << ' ';
	}
	cout << endl;
	return 0;
}
```
###### 指定された数字までの出力（改行区切り）
```cpp
#include <iostream>
using namespace std;

int main() {
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cout << i << endl;
	}
	return 0;
}
```
###### 指定された行数の数字の出力
```cpp
#include <iostream>
using namespace std;

const int M = 5;

int main() {
	int n, k;
	cin >> n >> k;
	for (int i = 0; i < n; i++) {
		for (int j = 1; j <= M; j++) {
			cout << j;
			if (j < M) cout << ' ';
		}
		cout << endl;
	}
	return 0;
}
```
###### 指定された範囲・行数の数字の出力
```cpp
#include <iostream>
using namespace std;

int main() {
	int n, k;
	cin >> n >> k;
	for (int i = 0; i < k; i++) {
		for (int j = 1; j <= n; j++) {
			cout << j;
			if (j < n) cout << ' ';
		}
		cout << endl;
	}
	return 0;
}
```
- - -
##### C#
###### 指定された数字までの出力（半角スペース区切り）
```cs
using System;

class Program
{
	public static void Main()
	{
		int n = int.Parse(Console.ReadLine());
		for (int i = 1; i <= n; i++) {
			Console.Write(i);
			if (i < n) Console.Write(' ');
		}
		Console.WriteLine();
	}
}
```
###### 指定された数字までの出力（改行区切り）
```cs
using System;

class Program
{
	public static void Main()
	{
		int n = int.Parse(Console.ReadLine());
		for (int i = 1; i <= n; i++) {
			Console.WriteLine(i);
		}
	}
}
```
###### 指定された行数の数字の出力
```cs
using System;

class Program
{
	const int M = 5;
	
	public static void Main()
	{
		int n = int.Parse(Console.ReadLine());
		for (int i = 0; i < n; i++) {
			for (int j = 1; j <= M; j++) {
				Console.Write(j);
				if (j < M) Console.Write(' ');
			}
			Console.WriteLine();
		}
	}
}
```
###### 指定された範囲・行数の数字の出力
```cs
using System;

class Program
{
	public static void Main()
	{
		int[] nk = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		int n = nk[0], k = nk[1];
		for (int i = 0; i < k; i++) {
			for (int j = 1; j <= n; j++) {
				Console.Write(j);
				if (j < n) Console.Write(' ');
			}
			Console.WriteLine();
		}
	}
}
```
- - -
##### Go
###### 指定された数字までの出力（半角スペース区切り）
```go
package main
import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	for i := 1; i <= n; i++ {
		fmt.Print(i)
		if i < n {
			fmt.Print(" ")
		}
	}
	fmt.Println()
}
```
###### 指定された数字までの出力（改行区切り）
```go
package main
import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	for i := 1; i <= n; i++ {
		fmt.Println(i)
	}
}
```
###### 指定された行数の数字の出力
```go
package main
import "fmt"

const M = 5

func main() {
	var n int
	fmt.Scan(&n)
	for i := 0; i < n; i++ {
		for j := 1; j <= M; j++ {
			fmt.Print(j)
			if j < M {
				fmt.Print(" ")
			}
		}
		fmt.Println()
	}
}
```
###### 指定された範囲・行数の数字の出力
```go
package main
import "fmt"

func main() {
	var n, k int
	fmt.Scan(&n, &k)
	for i := 0; i < k; i++ {
		for j := 1; j <= n; j++ {
			fmt.Print(j)
			if j < n {
				fmt.Print(" ")
			}
		}
		fmt.Println()
	}
}
```
- - -
##### Java
###### 指定された数字までの出力（半角スペース区切り）
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		sc.close();
		for (int i = 1; i <= n; i++) {
			System.out.print(i);
			if (i < n) System.out.print(' ');
		}
		System.out.println();
	}
}
```
###### 指定された数字までの出力（改行区切り）
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		sc.close();
		for (int i = 1; i <= n; i++) {
			System.out.println(i);
		}
	}
}
```
###### 指定された行数の数字の出力
```java
import java.util.*;

public class Main {

	static final int M = 5;
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		sc.close();
		for (int i = 0; i < n; i++) {
			for (int j = 1; j <= M; j++) {
				System.out.print(j);
				if (j < M) System.out.print(' ');
			}
			System.out.println();
		}
	}
}
```
###### 指定された範囲・行数の数字の出力
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int k = sc.nextInt();
		sc.close();
		for (int i = 0; i < k; i++) {
			for (int j = 1; j <= n; j++) {
				System.out.print(j);
				if (j < n) System.out.print(' ');
			}
			System.out.println();
		}
	}
}
```
- - -
##### JavaScript
###### 指定された数字までの出力（半角スペース区切り）
```js
const N = Number(require("fs").readFileSync("/dev/stdin", "utf8"));
let s = ""
for (var i = 1; i <= N; i++) {
	s += i;
	if (i < N) s += " ";
}
console.log(s);
```
###### 指定された数字までの出力（改行区切り）
```js
const N = Number(require("fs").readFileSync("/dev/stdin", "utf8"));
for (var i = 1; i <= N; i++) {
	console.log(i);
}
```
###### 指定された行数の数字の出力
```js
const N = Number(require("fs").readFileSync("/dev/stdin", "utf8"));
const M = 5;
for (var i = 0; i < N; i++) {
	let s = ""
	for (var j = 1; j <= M; j++) {
		s += j;
		if (j < M) s += " ";
	}
	console.log(s);
}
```
###### 指定された範囲・行数の数字の出力
```js
const [N, K] = require("fs").readFileSync("/dev/stdin", "utf8").split(' ').map(Number);
for (var i = 0; i < K; i++) {
	let s = ""
	for (var j = 1; j <= N; j++) {
		s += j;
		if (j < N) s += " ";
	}
	console.log(s);
}
```
- - -
##### Kotlin
###### 指定された数字までの出力（半角スペース区切り）
```kotlin
fun main() {
	val n = readLine()!!.toInt()
	for (i in 1..n) {
		print(i)
		if (i < n) print(' ')
	}
	println()
}
```
###### 指定された数字までの出力（改行区切り）
```kotlin
fun main() {
	val n = readLine()!!.toInt()
	for (i in 1..n) {
		println(i)
	}
}
```
###### 指定された行数の数字の出力
```kotlin
fun main() {
	val M = 5
	repeat (readLine()!!.toInt()) {
		for (j in 1..M) {
			print(j)
			if (j < M) print(' ')
		}
		println()
	}
}
```
###### 指定された範囲・行数の数字の出力
```kotlin
fun main() {
	val (n, k) = readLine()!!.split(' ').map { it.toInt() }
	repeat (k) {
		for (j in 1..n) {
			print(j)
			if (j < n) print(' ')
		}
		println()
	}
}
```
- - -
##### PHP
###### 指定された数字までの出力（半角スペース区切り）
```php
<?php
	$n = intval(fgets(STDIN));
	for ($i = 1; $i <= $n; $i++) {
		echo $i;
		if ($i < $n) echo ' ';
	}
	echo PHP_EOL;
?>
```
###### 指定された数字までの出力（改行区切り）
```php
<?php
	$n = intval(fgets(STDIN));
	for ($i = 1; $i <= $n; $i++) {
		echo $i, PHP_EOL;
	}
?>
```
###### 指定された行数の数字の出力
```php
<?php
	const M = 5;
	$n = intval(fgets(STDIN));
	for ($i = 0; $i < $n; $i++) {
		for ($j = 1; $j <= M; $j++) {
			echo $j;
			if ($j < M) echo ' ';
		}
		echo PHP_EOL;
	}
?>
```
###### 指定された範囲・行数の数字の出力
```php
<?php
	[$n, $k] = array_map("intval", explode(' ', fgets(STDIN)));
	for ($i = 0; $i < $k; $i++) {
		for ($j = 1; $j <= $n; $j++) {
			echo $j;
			if ($j < $n) echo ' ';
		}
		echo PHP_EOL;
	}
?>
```
- - -
##### Perl
###### 指定された数字までの出力（半角スペース区切り）
```pl
my $n = int(<STDIN>);
for $i (1..$n) {
	print $i;
	if ($i < $n) {
		print ' ';
	}
}
print $/;
```
###### 指定された数字までの出力（改行区切り）
```pl
my $n = int(<STDIN>);
for (1..$n) {
	print "$_$/";
}
```
###### 指定された行数の数字の出力
```pl
my $n = int(<STDIN>);
my $m = 5;
for (1..$n) {
	for $j (1..$m) {
		print $j;
		if ($j < $m) {
			print ' ';
		}
	}
	print $/;
}
```
###### 指定された範囲・行数の数字の出力
```pl
my ($n, $k) = map { int($_) } split ' ', <STDIN>;
for (1..$k) {
	for $j (1..$n) {
		print $j;
		if ($j < $n) {
			print ' ';
		}
	}
	print $/;
}
```
- - -
##### Python3
###### 指定された数字までの出力（半角スペース区切り）
```py
n = int(input())
for i in range(1, n + 1):
	print(i, end='\n' if i == n else ' ')
```
###### 指定された数字までの出力（改行区切り）
```py
n = int(input())
for i in range(1, n + 1):
	print(i)
```
###### 指定された行数の数字の出力
```py
n = int(input())
m = 5
for _ in range(n):
	for j in range(1, m + 1):
		print(j, end='\n' if j == m else ' ')
```
###### 指定された範囲・行数の数字の出力
```py
n, k = map(int, input().split())
for _ in range(k):
	for j in range(1, n + 1):
		print(j, end='\n' if j == n else ' ')
```
- - -
##### Ruby
###### 指定された数字までの出力（半角スペース区切り）
```rb
N = gets.to_i
(1..N).each do |i|
	print i
	if i < N
		print ' '
	end
end
puts
```
###### 指定された数字までの出力（改行区切り）
```rb
N = gets.to_i
(1..N).each do |i|
	p i
end
```
###### 指定された行数の数字の出力
```rb
N = gets.to_i
M = 5
N.times do
	(1..M).each do |j|
		print j
		if j < M
			print ' '
		end
	end
	puts
end
```
###### 指定された範囲・行数の数字の出力
```rb
N, K = gets.split.map(&:to_i)
K.times do
	(1..N).each do |j|
		print j
		if j < N
			print ' '
		end
	end
	puts
end
```
- - -
##### Scala
###### 指定された数字までの出力（半角スペース区切り）
```scala
import scala.io.StdIn._

object Main extends App{
	val n = readInt()
	for (i <- 1 to n) {
		print(i)
		if (i < n) print(' ')
	}
	println()
}
```
###### 指定された数字までの出力（改行区切り）
```scala
import scala.io.StdIn._

object Main extends App{
	val n = readInt()
	for (i <- 1 to n) {
		println(i)
	}
}
```
###### 指定された行数の数字の出力
```scala
import scala.io.StdIn._

object Main extends App{
	val n = readInt()
	val m = 5
	for (i <- 1 to n) {
		for (j <- 1 to m) {
			print(j)
			if (j < m) print(' ')
		}
		println()
	}
}
```
###### 指定された範囲・行数の数字の出力
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(n, k) = readLine().split(' ').map { _.toInt }
	for (i <- 1 to k) {
		for (j <- 1 to n) {
			print(j)
			if (j < n) print(' ')
		}
		println()
	}
}
```
- - -
##### Swift
###### 指定された数字までの出力（半角スペース区切り）
```swift
let n = Int(readLine()!)!
for i in 1...n {
	print(i, terminator: i < n ? " " : "\n")
}
```
###### 指定された数字までの出力（改行区切り）
```swift
let n = Int(readLine()!)!
for i in 1...n {
	print(i)
}
```
###### 指定された行数の数字の出力
```swift
let n = Int(readLine()!)!
let m = 5
for _ in 0..<n {
	for j in 1...m {
		print(j, terminator: j < m ? " " : "\n")
	}
}
```
###### 指定された範囲・行数の数字の出力
```swift
let nk =  readLine()!.split(separator: " ").compactMap { Int($0) }
let (n, k) = (nk[0], nk[1])
for _ in 0..<k {
	for j in 1...n {
		print(j, terminator: j < n ? " " : "\n")
	}
}
```