paizaラーニングレベルアップ問題集の【行によって長さが違う二次元配列の表示】をやってみた。

paizaラーニングレベルアップ問題集の【行によって長さが違う二次元配列の表示】をやってみました。
- - -
##### 問題
###### N個の文字を半分ずつ出力
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__variable_array_step1
###### 数値を異なる長さで2行出力
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__variable_array_step2
###### 直角三角形の出力
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__variable_array_step3
###### すべての行の長さが不定な2次元配列の出力
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__variable_array_step4
###### すべての行の長さと値が不定な2次元配列の出力
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__variable_array_boss
- - -
##### C
###### N個の文字を半分ずつ出力
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	int m = n / 2;
	for (int i = 1; i < m; i++) {
		printf("%d ", i);
	}
	printf("%d\n", m);
	for (int i = m + 1; i < n; i++) {
		printf("%d ", i);
	}
	printf("%d\n", n);
	return 0;
}
```
###### 数値を異なる長さで2行出力
```c
#include <stdio.h>

int main() {
	int n, m;
	scanf("%d %d", &n, &m);
	for (int i = 1; i < n; i++) {
		printf("%d ", i);
	}
	printf("%d\n", n);
	for (int i = 1; i < m; i++) {
		printf("%d ", i);
	}
	printf("%d\n", m);
	return 0;
}
```
###### 直角三角形の出力
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j < i; j++) {
			printf("%d ", j);
		}
		printf("%d\n", i);
	}
	return 0;
}
```
###### すべての行の長さが不定な2次元配列の出力
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		int m;
		scanf("%d", &m);
		for (int j = 1; j < m; j++) {
			printf("%d ", j);
		}
		printf("%d\n", m);
	}
	return 0;
}
```
###### すべての行の長さと値が不定な2次元配列の出力
```c
#include <stdio.h>

int main() {
	int n, m;
	scanf("%d %d", &n, &m);
	int A[n];
	for (int i = 0; i < n; i++) {
		scanf("%d", &A[i]);
	}
	int B[m];
	for (int i = 0; i < m; i++) {
		scanf("%d", &B[i]);
	}
	int k = 0;
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < B[i]; j++) {
			if (j > 0) putchar(' ');
			printf("%d", A[k++]);
		}
		puts("");
	}
	return 0;
}
```
- - -
##### C++
###### N個の文字を半分ずつ出力
```cpp
#include <iostream>
using namespace std;

int main() {
	int n;
	cin >> n;
	int m = n / 2;
	for (int i = 1; i < m; i++) {
		cout << i << ' ';
	}
	cout << m << endl;
	for (int i = m + 1; i < n; i++) {
		cout << i << ' ';
	}
	cout << n << endl;
	return 0;
}
```
###### 数値を異なる長さで2行出力
```cpp
#include <iostream>
using namespace std;

int main() {
	int n, m;
	cin >> n >> m;
	for (int i = 1; i < n; i++) {
		cout << i << ' ';
	}
	cout << n << endl;
	for (int i = 1; i < m; i++) {
		cout << i << ' ';
	}
	cout << m << endl;
	return 0;
}
```
###### 直角三角形の出力
```cpp
#include <iostream>
using namespace std;

int main() {
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j < i; j++) {
			cout << j << ' ';
		}
		cout << i << endl;
	}
	return 0;
}
```
###### すべての行の長さが不定な2次元配列の出力
```cpp
#include <iostream>
using namespace std;

int main() {
	int n;
	cin >> n;
	for (int i = 0; i < n; i++) {
		int m;
		cin >> m;
		for (int j = 1; j < m; j++) {
			cout << j << ' ';
		}
		cout << m << endl;
	}
	return 0;
}
```
###### すべての行の長さと値が不定な2次元配列の出力
```cpp
#include <iostream>
using namespace std;

int main() {
	int n, m;
	cin >> n >> m;
	int A[n];
	for (int i = 0; i < n; i++) {
		cin >> A[i];
	}
	int k = 0;
	for (int i = 0; i < m; i++) {
		int b;
		cin >> b;
		for (int j = 0; j < b; j++) {
			if (j > 0) cout << ' ';
			cout << A[k++];
		}
		cout << endl;
	}
	return 0;
}
```
- - -
##### C#
###### N個の文字を半分ずつ出力
```cs
using System;

class Program
{
	public static void Main()
	{
		int n = int.Parse(Console.ReadLine());
		int m = n / 2;
		for (int i = 1; i < m; i++) {
			Console.Write(i + " ");
		}
		Console.WriteLine(m);
		for (int i = m + 1; i < n; i++) {
			Console.Write(i + " ");
		}
		Console.WriteLine(n);
	}
}
```
###### 数値を異なる長さで2行出力
```cs
using System;

class Program
{
	public static void Main()
	{
		int[] nm = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		int n = nm[0];
		int m = nm[1];
		for (int i = 1; i < n; i++) {
			Console.Write(i + " ");
		}
		Console.WriteLine(n);
		for (int i = 1; i < m; i++) {
			Console.Write(i + " ");
		}
		Console.WriteLine(m);
	}
}
```
###### 直角三角形の出力
```cs
using System;

class Program
{
	public static void Main()
	{
		int n = int.Parse(Console.ReadLine());
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j < i; j++) {
				Console.Write(j + " ");
			}
			Console.WriteLine(i);
		}
	}
}
```
###### すべての行の長さが不定な2次元配列の出力
```cs
using System;

class Program
{
	public static void Main()
	{
		Console.ReadLine();
		foreach (int m in Array.ConvertAll(Console.ReadLine().Split(), int.Parse)) {
			for (int j = 1; j < m; j++) {
				Console.Write(j + " ");
			}
			Console.WriteLine(m);
		}
	}
}
```
###### すべての行の長さと値が不定な2次元配列の出力
```cs
using System;

class Program
{
	public static void Main()
	{
		Console.ReadLine().Split();
		int[] A = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		int k = 0;
		foreach (int b in Array.ConvertAll(Console.ReadLine().Split(), int.Parse)) {
			for (int j = 0; j < b; j++) {
				if (j > 0) Console.Write(' ');
				Console.Write(A[k++]);
			}
			Console.WriteLine();
		}
	}
}
```
- - -
##### Go
###### N個の文字を半分ずつ出力
```go
package main
import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	m := n / 2;
	for i := 1; i < m; i++ {
		fmt.Printf("%d ", i)
	}
	fmt.Println(m)
	for i := m + 1; i < n; i++ {
		fmt.Printf("%d ", i)
	}
	fmt.Println(n)
}
```
###### 数値を異なる長さで2行出力
```go
package main
import "fmt"

func main() {
	var n, m int
	fmt.Scan(&n, &m)
	for i := 1; i < n; i++ {
		fmt.Printf("%d ", i)
	}
	fmt.Println(n)
	for i := 1; i < m; i++ {
		fmt.Printf("%d ", i)
	}
	fmt.Println(m)
}
```
###### 直角三角形の出力
```go
package main
import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	for i := 1; i <= n; i++ {
		for j := 1; j < i; j++ {
			fmt.Printf("%d ", j)
		}
		fmt.Println(i)
	}
}
```
###### すべての行の長さが不定な2次元配列の出力
```go
package main
import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	for i := 0; i < n; i++ {
		var m int
		fmt.Scan(&m)
		for j := 1; j < m; j++ {
			fmt.Printf("%d ", j)
		}
		fmt.Println(m)
	}
}
```
###### すべての行の長さと値が不定な2次元配列の出力
```go
package main
import "fmt"

func main() {
	var n, m int
	fmt.Scan(&n, &m)
	A := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&A[i])
	}
	k := 0
	for i := 0; i < m; i++ {
		var b int
		fmt.Scan(&b)
		for j := 0; j < b; j++ {
			if j > 0 {
				fmt.Print(" ")
			}
			fmt.Print(A[k])
			k += 1
		}
		fmt.Println()
	}
}
```
- - -
##### Java
###### N個の文字を半分ずつ出力
```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();
		int m = n / 2;
		for (int i = 1; i < m; i++) {
			System.out.print(i + " ");
		}
		System.out.println(m);
		for (int i = m + 1; i < n; i++) {
			System.out.print(i + " ");
		}
		System.out.println(n);
	}
}
```
###### 数値を異なる長さで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();
		sc.close();
		for (int i = 1; i < n; i++) {
			System.out.print(i + " ");
		}
		System.out.println(n);
		for (int i = 1; i < m; i++) {
			System.out.print(i + " ");
		}
		System.out.println(m);
	}
}
```
###### 直角三角形の出力
```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++) {
			for (int j = 1; j < i; j++) {
				System.out.print(j + " ");
			}
			System.out.println(i);
		}
	}
}
```
###### すべての行の長さが不定な2次元配列の出力
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		for (int i = 0; i < n; i++) {
			int m = sc.nextInt();
			for (int j = 1; j < m; j++) {
				System.out.print(j + " ");
			}
			System.out.println(m);
		}
		sc.close();
	}
}
```
###### すべての行の長さと値が不定な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();
		int[] A = new int[n];
		for (int i = 0; i < n; i++) {
			A[i] = sc.nextInt();
		}
		int k = 0;
		for (int i = 0; i < m; i++) {
			int b = sc.nextInt();
			for (int j = 0; j < b; j++) {
				if (j > 0) System.out.print(' ');
				System.out.print(A[k++]);
			}
			System.out.println();
		}
		sc.close();
	}
}
```
- - -
##### JavaScript
###### N個の文字を半分ずつ出力
```js
const n = Number(require("fs").readFileSync("/dev/stdin", "utf8").trim());
const m = n / 2;
console.log(...Array(m).fill(1).map((i, j) => i + j));
console.log(...Array(m).fill(1).map((i, j) => m + i + j));
```
###### 数値を異なる長さで2行出力
```js
const [n, m] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split(' ').map(Number);
console.log(...Array(n).fill(1).map((i, j) => i + j));
console.log(...Array(m).fill(1).map((i, j) => i + j));
```
###### 直角三角形の出力
```js
const n = require("fs").readFileSync("/dev/stdin", "utf8").trim().split(' ').map(Number);
for (var i = 1; i <= n; i++) {
	console.log(...Array(i).fill(1).map((k, j) => k + j));
}
```
###### すべての行の長さが不定な2次元配列の出力
```js
const lines = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n');
lines[1].split(' ').map(Number).forEach(m => console.log(...Array(m).fill(1).map((i, j) => i + j)));
```
###### すべての行の長さと値が不定な2次元配列の出力
```js
const lines = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n');
const A = lines[1].split(' ');
let k = 0;
lines[2].split(' ').map(Number).forEach(function (b) {
	console.log(A.slice(k, k + b).join(' '));
	k += b;
});
```
- - -
##### Kotlin
###### N個の文字を半分ずつ出力
```kotlin
fun main() {
	val n = readLine()!!.toInt()
	val m = n / 2
	println((1..m).joinToString(" "))
	println((m+1..n).joinToString(" "))
}
```
###### 数値を異なる長さで2行出力
```kotlin
fun main() {
	val (n, m) = readLine()!!.split(' ').map { it.toInt() }
	println((1..n).joinToString(" "))
	println((1..m).joinToString(" "))
}
```
###### 直角三角形の出力
```kotlin
fun main() {
	for (i in 1..readLine()!!.toInt()) {
		println((1..i).joinToString(" "))
	}
}
```
###### すべての行の長さが不定な2次元配列の出力
```kotlin
fun main() {
	val n = readLine()!!.toInt()
	val M = readLine()!!.split(" ").map { it.toInt() }
	for (i in 0 until n) {
		println((1..M[i]).joinToString(" "))
	}
}
```
###### すべての行の長さと値が不定な2次元配列の出力
```kotlin
fun main() {
	val (_, m) = readLine()!!.split(' ').map { it.toInt() }
	val A = readLine()!!.split(' ').map { it.toInt() }
	val B = readLine()!!.split(' ').map { it.toInt() }
	var k = 0
	for (i in 0 until m) {
		println(A.subList(k, k + B[i]).joinToString(" "))
		k += B[i]
	}
}
```
- - -
##### PHP
###### N個の文字を半分ずつ出力
```php
<?php
	$n = intval(trim(fgets(STDIN)));
	$m = intval($n / 2);
	for ($i = 1; $i < $m; $i++) {
		echo "$i ";
	}
	echo $m, PHP_EOL;
	for ($i = $m + 1; $i < $n; $i++) {
		echo "$i ";
	}
	echo $n, PHP_EOL;
?>
```
###### 数値を異なる長さで2行出力
```php
<?php
	[$n, $m] = array_map('intval', explode(' ', fgets(STDIN)));
	for ($i = 1; $i < $n; $i++) {
		echo "$i ";
	}
	echo $n, PHP_EOL;
	for ($i = 1; $i < $m; $i++) {
		echo "$i ";
	}
	echo $m, PHP_EOL;
?>
```
###### 直角三角形の出力
```php
<?php
	$n = intval(trim(fgets(STDIN)));
	for ($i = 1; $i <= $n; $i++) {
		for ($j = 1; $j < $i; $j++) {
			echo "$j ";
		}
		echo $i, PHP_EOL;
	}
?>
```
###### すべての行の長さが不定な2次元配列の出力
```php
<?php
	$n = intval(trim(fgets(STDIN)));
	foreach (array_map('intval', explode(' ', fgets(STDIN))) as $m) {
		for ($j = 1; $j < $m; $j++) {
			echo "$j ";
		}
		echo $m, PHP_EOL;
	}
?>
```
###### すべての行の長さと値が不定な2次元配列の出力
```php
<?php
	[$n, $m] = array_map('intval', explode(' ', fgets(STDIN)));
	$A = explode(' ', trim(fgets(STDIN)));
	$k = 0;
	foreach (array_map('intval', explode(' ', fgets(STDIN))) as $b) {
		for ($j = 0; $j < $b; $j++) {
			if ($j > 0) echo ' ';
			echo $A[$k++];
		}
		echo PHP_EOL;
	}
?>
```
- - -
##### Perl
###### N個の文字を半分ずつ出力
```pl
my $n = int(<STDIN>);
my $m = int($n / 2);
print join(' ', 1..$m), $/;
print join(' ', ($m+1)..$n), $/;
```
###### 数値を異なる長さで2行出力
```pl
my ($n, $m) = split(' ', <STDIN>);
print join(' ', 1..$n), $/;
print join(' ', 1..$m), $/;
```
###### 直角三角形の出力
```pl
my $n = int(<STDIN>);
for (my $i = 1; $i <= $n; $i++) {
	print join(' ', 1..$i), $/;
}
```
###### すべての行の長さが不定な2次元配列の出力
```pl
my $n = int(<STDIN>);
foreach my $m (split(' ', <STDIN>)) {
	print join(' ', 1..$m), $/;
}
```
###### すべての行の長さと値が不定な2次元配列の出力
```pl
my ($n, $m) = split(' ', <STDIN>);
my @A = split(' ', <STDIN>);
my $k = 0;
foreach my $b (split(' ', <STDIN>)) {
	print join(' ', @A[$k..$k+$b-1]), $/;
	$k += $b;
}
```
- - -
##### Python3
###### N個の文字を半分ずつ出力
```py
n = int(input())
m = n // 2
print(*range(1, m + 1))
print(*range(m + 1, n + 1))
```
###### 数値を異なる長さで2行出力
```py
n, m = map(int, input().split())
print(*range(1, n + 1))
print(*range(1, m + 1))
```
###### 直角三角形の出力
```py
for i in range(1, int(input()) + 1):
	print(*range(1, i + 1))
```
###### すべての行の長さが不定な2次元配列の出力
```py
n = int(input())
for m in list(map(int, input().split())):
	print(*range(1, m + 1))
```
###### すべての行の長さと値が不定な2次元配列の出力
```py
n, m = map(int, input().split())
A = input().split()
k = 0
for b in list(map(int, input().split())):
	print(*A[k:k+b])
	k += b
```
- - -
##### Ruby
###### N個の文字を半分ずつ出力
```rb
n = gets.to_i
m = n / 2
puts (1..m).to_a.join(' ')
puts (m+1..n).to_a.join(' ')
```
###### 数値を異なる長さで2行出力
```rb
n, m = gets.split.map(&:to_i)
puts (1..n).to_a.join(' ')
puts (1..m).to_a.join(' ')
```
###### 直角三角形の出力
```rb
n = gets.to_i
(1..n).each do |i|
	puts (1..i).to_a.join(' ')
end
```
###### すべての行の長さが不定な2次元配列の出力
```rb
n = gets.to_i
gets.split.map(&:to_i).each do |m|
	puts (1..m).to_a.join(' ')
end
```
###### すべての行の長さと値が不定な2次元配列の出力
```rb
n, m = gets.split.map(&:to_i)
A = gets.split
k = 0
gets.split.map(&:to_i).each do |b|
	puts A[k...k+b].join(' ')
	k += b
end
```
- - -
##### Scala
###### N個の文字を半分ずつ出力
```scala
import scala.io.StdIn._

object Main extends App{
	val n = readInt()
	val m = n / 2
	println((1 to m).mkString(" "))
	println((m+1 to n).mkString(" "))
}
```
###### 数値を異なる長さで2行出力
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(n, m) = readLine().split(" ").map(_.toInt)
	println((1 to n).mkString(" "))
	println((1 to m).mkString(" "))
}
```
###### 直角三角形の出力
```scala
import scala.io.StdIn._

object Main extends App{
	val n = readInt()
	for (i <- 1 to n) {
		println((1 to i).mkString(" "))
	}
}
```
###### すべての行の長さが不定な2次元配列の出力
```scala
import scala.io.StdIn._

object Main extends App{
	val n = readInt()
	for (m <- readLine().split(" ").map(_.toInt)) {
		println((1 to m).mkString(" "))
	}
}
```
###### すべての行の長さと値が不定な2次元配列の出力
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(n, m) = readLine().split(" ").map(_.toInt)
	val A = readLine().split(" ")
	var k = 0
	for (b <- readLine().split(" ").map(_.toInt)) {
		println(A.slice(k, k+b).mkString(" "))
		k += b
	}
}
```
- - -
##### Swift
###### N個の文字を半分ずつ出力
```swift
let n = Int(readLine()!)!
let m = n / 2
print((1...m).map { String($0) }.joined(separator: " "))
print((m+1...n).map { String($0) }.joined(separator: " "))
```
###### 数値を異なる長さで2行出力
```swift
let nm = readLine()!.split(separator: " ").map { Int($0)! }
print((1...nm[0]).map { String($0) }.joined(separator: " "))
print((1...nm[1]).map { String($0) }.joined(separator: " "))
```
###### 直角三角形の出力
```swift
let n = Int(readLine()!)!
for i in 1...n {
	print((1...i).map { String($0) }.joined(separator: " "))
}
```
###### すべての行の長さが不定な2次元配列の出力
```swift
let n = Int(readLine()!)!
for m in readLine()!.split(separator: " ").map({ Int($0)! }){
	print((1...m).map { String($0) }.joined(separator: " "))
}
```
###### すべての行の長さと値が不定な2次元配列の出力
```swift
let nm = readLine()!.split(separator: " ").map { Int($0)! }
let A = readLine()!.split(separator: " ")
var k = 0
for b in readLine()!.split(separator: " ").map({ Int($0)! }){
	print(A[k..<k+b].joined(separator: " "))
	k += b
}
```