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

paizaラーニングレベルアップ問題集の「二重ループメニュー」をやってみました。
- - -
##### 問題
###### 二次元配列の出力
https://paiza.jp/works/mondai/double_roop_problems/double_roop_problems__print_map
###### 二次元配列での要素の検索
https://paiza.jp/works/mondai/double_roop_problems/double_roop_problems__search
###### 二次元配列の最大の要素
https://paiza.jp/works/mondai/double_roop_problems/double_roop_problems__search_max
- - -
##### C
###### 二次元配列の出力
```c
#include <stdio.h>

int main() {
	int n, k;
	scanf("%d %d", &n, &k);
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < k; j++) {
			if (j) putchar(' ');
			int a;
			scanf("%d", &a);
			printf("%d", a);
		}
		puts("");
	}
	return 0;
}
```
###### 二次元配列での要素の検索
```c
#include <stdio.h>

int main() {
	int n, k;
	scanf("%d %d", &n, &k);
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < k; j++) {
			int a;
			scanf("%d", &a);
			if (a == 1) printf("%d %d\n", i + 1, j + 1);
		}
	}
	return 0;
}
```
###### 二次元配列の最大の要素
```c
#include <stdio.h>

int main() {
	int n, k;
	scanf("%d %d", &n, &k);
	int max = 0;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < k; j++) {
			int a;
			scanf("%d", &a);
			if (a > max) max = a;
		}
	}
	printf("%d\n", max);
	return 0;
}
```
- - -
##### C++
###### 二次元配列の出力
```cpp
#include <iostream>
using namespace std;

int main() {
	int n, k;
	cin >> n >> k;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < k; j++) {
			if (j) cout << ' ';
			int a;
			cin >> a;
			cout << a;
		}
		cout << endl;
	}
	return 0;
}
```
###### 二次元配列での要素の検索
```cpp
#include <iostream>
using namespace std;

int main() {
	int n, k;
	cin >> n >> k;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < k; j++) {
			int a;
			cin >> a;
			if (a == 1) cout << i + 1 << ' ' << j + 1 << endl;
		}
	}
	return 0;
}
```
###### 二次元配列の最大の要素
```cpp
#include <iostream>
using namespace std;

int main() {
	int n, k;
	cin >> n >> k;
	int m = 0;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < k; j++) {
			int a;
			cin >> a;
			if (a > m) m = a;
		}
	}
	cout << m << endl;
	return 0;
}
```
- - -
##### C#
###### 二次元配列の出力
```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 < n; i++) {
			int[] A = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
			for (int j = 0; j < k; j++) {
				if (j > 0) Console.Write(' ');
				Console.Write(A[j]);
			}
			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 < n; i++) {
			int[] A = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
			for (int j = 0; j < k; j++) {
				if (A[j] == 1) Console.WriteLine("" + (i + 1) + ' ' + (j + 1));
			}
		}
	}
}
```
###### 二次元配列の最大の要素
```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];
		int max = 0;
		for (int i = 0; i < n; i++) {
			int[] A = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
			for (int j = 0; j < k; j++) {
				if (A[j] > max) max = A[j];
			}
		}
		Console.WriteLine(max);
	}
}
```
- - -
##### Go
###### 二次元配列の出力
```go
package main
import "fmt"

func main() {
	var n, k int
	fmt.Scan(&n, &k)
	for i := 0; i < n; i++ {
		for j := 0; j < k; j++ {
			if j > 0 {
				fmt.Print(" ")
			}
			var a int
			fmt.Scan(&a)
			fmt.Print(a)
		}
		fmt.Println()
	}
}
```
###### 二次元配列での要素の検索
```go
package main
import "fmt"

func main() {
	var n, k int
	fmt.Scan(&n, &k)
	for i := 0; i < n; i++ {
		for j := 0; j < k; j++ {
			var a int
			fmt.Scan(&a)
			if a == 1 {
				fmt.Println(i + 1, j + 1)
			}
		}
	}
}
```
###### 二次元配列の最大の要素
```go
package main
import "fmt"

func main() {
	var n, k int
	fmt.Scan(&n, &k)
	max := 0
	for i := 0; i < n; i++ {
		for j := 0; j < k; j++ {
			var a int
			fmt.Scan(&a)
			if a > max {
				max = a
			}
		}
	}
	fmt.Println(max)
}
```
- - -
##### Java
###### 二次元配列の出力
```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.nextLine();
		for (int i = 0; i < n; i++) {
			int[] A = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
			for (int j = 0; j < k; j++) {
				if (j > 0) System.out.print(' ');
				System.out.print(A[j]);
			}
			System.out.println();
		}
		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();
		int k = sc.nextInt();
		sc.nextLine();
		for (int i = 0; i < n; i++) {
			int[] A = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
			for (int j = 0; j < k; j++) {
				if (A[j] == 1) System.out.println("" + (i + 1) + ' ' + (j + 1));
			}
		}
		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();
		int k = sc.nextInt();
		sc.nextLine();
		int max = 0;
		for (int i = 0; i < n; i++) {
			int[] A = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
			for (int j = 0; j < k; j++) {
				if (A[j] > max) max = A[j];
			}
		}
		sc.close();
		System.out.println(max);
	}
}
```
- - -
##### JavaScript
###### 二次元配列の出力
```js
const [[N, K], ...A] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n').map(s => s.split(' ').map(Number));
for (var i = 0; i < N; i++) {
	let s = "";
	for (var j = 0; j < K; j++) {
		if (j) s += ' ';
		s += A[i][j];
	}
	console.log(s);
}
```
###### 二次元配列での要素の検索
```js
const [[N, K], ...A] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n').map(s => s.split(' ').map(Number));
for (var i = 0; i < N; i++) {
	for (var j = 0; j < K; j++) {
		if (A[i][j] == 1) console.log(i + 1, j + 1);
	}
}
```
###### 二次元配列の最大の要素
```js
const [[N, K], ...A] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n').map(s => s.split(' ').map(Number));
let max = 0;
for (var i = 0; i < N; i++) {
	for (var j = 0; j < K; j++) {
		if (A[i][j] > max) max = A[i][j];
	}
}
console.log(max);
```
- - -
##### Kotlin
###### 二次元配列の出力
```kotlin
fun main() {
	val (n, k) = readLine()!!.split(' ').map { it.toInt() }
	for (i in 0 until n) {
		val A = readLine()!!.split(' ').map { it.toInt() }
		for (j in 0 until k) {
			if (j > 0) print(' ')
			print(A[j])
		}
		println()
	}
}
```
###### 二次元配列での要素の検索
```kotlin
fun main() {
	val (n, k) = readLine()!!.split(' ').map { it.toInt() }
	for (i in 0 until n) {
		val A = readLine()!!.split(' ').map { it.toInt() }
		for (j in 0 until k) {
			if (A[j] == 1) println("" + (i + 1) + ' ' + (j + 1))
		}
	}
}
```
###### 二次元配列の最大の要素
```kotlin
fun main() {
	val (n, k) = readLine()!!.split(' ').map { it.toInt() }
	var max = 0
	for (i in 0 until n) {
		val A = readLine()!!.split(' ').map { it.toInt() }
		for (j in 0 until k) {
			if (A[j] > max) max = A[j]
		}
	}
	println(max)
}
```
- - -
##### PHP
###### 二次元配列の出力
```php
<?php
	[$n, $k] = array_map("intval", explode(' ', fgets(STDIN)));
	for ($i = 0; $i < $n; $i++) {
		$A = array_map("intval", explode(' ', fgets(STDIN)));
		for ($j = 0; $j < $k; $j++) {
			if ($j) echo ' ';
			echo $A[$j];
		}
		echo PHP_EOL;
	}
?>
```
###### 二次元配列での要素の検索
```php
<?php
	[$n, $k] = array_map("intval", explode(' ', fgets(STDIN)));
	for ($i = 0; $i < $n; $i++) {
		$A = array_map("intval", explode(' ', fgets(STDIN)));
		for ($j = 0; $j < $k; $j++) {
			if ($A[$j] == 1) echo $i + 1, ' ', $j + 1, PHP_EOL;
		}
	}
?>
```
###### 二次元配列の最大の要素
```php
<?php
	[$n, $k] = array_map("intval", explode(' ', fgets(STDIN)));
	$max = 0;
	for ($i = 0; $i < $n; $i++) {
		$A = array_map("intval", explode(' ', fgets(STDIN)));
		for ($j = 0; $j < $k; $j++) {
			if ($A[$j] > $max) $max = $A[$j];
		}
	}
	echo $max, PHP_EOL;
?>
```
- - -
##### Perl
###### 二次元配列の出力
```pl
my ($n, $k) = map { int($_) } split ' ', <STDIN>;
for (my $i = 0; $i < $n; $i++) {
	my @A = map { int($_) } split ' ', <STDIN>;
	for (my $j = 0; $j < $k; $j++) {
		if ($j) {
			print ' ';
		}
		print $A[$j];
	}
	print $/;
}
```
###### 二次元配列での要素の検索
```pl
my ($n, $k) = map { int($_) } split ' ', <STDIN>;
for (my $i = 0; $i < $n; $i++) {
	my @A = map { int($_) } split ' ', <STDIN>;
	for (my $j = 0; $j < $k; $j++) {
		if ($A[$j] == 1) {
			print $i + 1, ' ', $j + 1, $/;
		}
	}
}
```
###### 二次元配列の最大の要素
```pl
my ($n, $k) = map { int($_) } split ' ', <STDIN>;
my $max = 0;
for (my $i = 0; $i < $n; $i++) {
	my @A = map { int($_) } split ' ', <STDIN>;
	for (my $j = 0; $j < $k; $j++) {
		if ($A[$j] > $max) {
			$max = $A[$j];
		}
	}
}
print $max, $/;
```
- - -
##### Python3
###### 二次元配列の出力
```py
n, k = map(int, input().split())
for i in range(n):
	A = list(map(int, input().split()))
	print(*A)
```
###### 二次元配列での要素の検索
```py
n, k = map(int, input().split())
for i in range(n):
	A = list(map(int, input().split()))
	for j in range(k):
		if A[j] == 1:
			print(i + 1, j + 1)
```
###### 二次元配列の最大の要素
```py
n, k = map(int, input().split())
m = 0
for i in range(n):
	A = list(map(int, input().split()))
	for j in range(k):
		if A[j] > m:
			m = A[j]
print(m)
```
- - -
##### Ruby
###### 二次元配列の出力
```rb
N, K = gets.split.map(&:to_i)
N.times do
	a = gets.split.map(&:to_i)
	K.times do |j|
		if j > 0
			print ' '
		end
		print a[j]
	end
	puts
end
```
###### 二次元配列での要素の検索
```rb
N, K = gets.split.map(&:to_i)
N.times do |i|
	a = gets.split.map(&:to_i)
	K.times do |j|
		if a[j] == 1
			print i + 1, ' ', j + 1
			puts
		end
	end
end
```
###### 二次元配列の最大の要素
```rb
N, K = gets.split.map(&:to_i)
max = 0
N.times do |i|
	a = gets.split.map(&:to_i)
	K.times do |j|
		if a[j] > max
			max = a[j]
		end
	end
end
p max
```
- - -
##### Scala
###### 二次元配列の出力
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(n, k) = readLine().split(' ').map { _.toInt }
	for (i <- 0 until n) {
		val A = readLine().split(' ').map { _.toInt }
		for (j <- 0 until k) {
			if (j > 0) print(' ')
			print(A(j))
		}
		println()
	}
}
```
###### 二次元配列での要素の検索
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(n, k) = readLine().split(' ').map { _.toInt }
	for (i <- 0 until n) {
		val A = readLine().split(' ').map { _.toInt }
		for (j <- 0 until k) {
			if (A(j) == 1) println("" + (i + 1) + ' ' + (j + 1))
		}
	}
}
```
###### 二次元配列の最大の要素
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(n, k) = readLine().split(' ').map { _.toInt }
	var max = 0
	for (i <- 0 until n) {
		val A = readLine().split(' ').map { _.toInt }
		for (j <- 0 until k) {
			if (A(j) > max) max = A(j) 
		}
	}
	println(max)
}
```
- - -
##### Swift
###### 二次元配列の出力
```swift
let nk = readLine()!.split(separator: " ").compactMap { Int($0) }
let (n, k) = (nk[0], nk[1])
for _ in 0..<n {
	let A = readLine()!.split(separator: " ").compactMap { Int($0) }
	print(A.map { String($0) }.joined(separator: " "))
}
```
###### 二次元配列での要素の検索
```swift
let nk = readLine()!.split(separator: " ").compactMap { Int($0) }
let (n, k) = (nk[0], nk[1])
for i in 0..<n {
	let A = readLine()!.split(separator: " ").compactMap { Int($0) }
	for j in 0..<k {
		if A[j] == 1 {
			print(i + 1, j + 1)
		}
	}
}
```
###### 二次元配列の最大の要素
```swift
let nk = readLine()!.split(separator: " ").compactMap { Int($0) }
let (n, k) = (nk[0], nk[1])
var m = 0
for _ in 0..<n {
	let A = readLine()!.split(separator: " ").compactMap { Int($0) }
	for j in 0..<k {
		if A[j] > m {
			m = A[j]
		}
	}
}
print(m)
```