paizaラーニングレベルアップ問題集の「ソート」をやってみた。

paizaラーニングレベルアップ問題集の「ソート」をやってみました。
- - -
##### 問題
###### 昇順ソート
https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_sort_step1
###### 降順ソート
https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_sort_step2
###### 辞書式ソート
https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_sort_step3
###### FINAL問題: ソート
https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_sort_boss
- - -
##### 方針(例)
###### 降順ソート
[昇順ソート](https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_sort_step1)の結果を反転させます。
###### 辞書式ソート
$P_1=(a_1,b_1)$, $P_2=(a_2,b_2)$が$P_1>P_2$であるとは、
- $a_1>b_1$
- $a_1=b_1$かつ$a_2>b_2$
のいずれかが成立することをいいます。但し、普通にソート関数を使うと昇順になりますので、本問では反転させて降順にする必要があります。
###### FINAL問題: ソート
入力は(金,銀)で与えられますが、内部で(銀,金)とすることにより、前問の辞書式ソートが使えます。

以下のコードは、上記の方針以外の解法もあります。
- - -
##### C
###### 昇順ソート
```c
#include <stdio.h>
#include <stdlib.h>

int cmp(const void *a, const void *b) {
	int x = *(int*) a;
	int y = *(int*) b;
	if (x < y) return -1;
	if (x > y) return 1;
	return 0;
}

int main() {
	int n;
	scanf("%d", &n);
	int A[n];
	for (int i = 0; i < n; i++) scanf("%d", &A[i]);
	qsort(A, n, sizeof(A[0]), cmp);
	for (int i = 0; i < n; i++) printf("%d\n", A[i]);
	return 0;
}
```
###### 降順ソート
```c
#include <stdio.h>
#include <stdlib.h>

int cmp(const void *a, const void *b) {
	int x = *(int*) a;
	int y = *(int*) b;
	if (x < y) return 1;
	if (x > y) return -1;
	return 0;
}

int main() {
	int n;
	scanf("%d", &n);
	int A[n];
	for (int i = 0; i < n; i++) scanf("%d", &A[i]);
	qsort(A, n, sizeof(A[0]), cmp);
	for (int i = 0; i < n; i++) printf("%d\n", A[i]);
	return 0;
}
```
###### 辞書式ソート
```c
#include <stdio.h>
#include <stdlib.h>

int cmp(const void *a, const void *b) {
	int *x = (int*) a;
	int *y = (int*) b;
	for (int i = 0; i < 2; i++) {
		if (x < y) return 1;
		if (x > y) return -1;
	}
	return 0;
}

int main() {
	int n;
	scanf("%d", &n);
	int A[n][2];
	for (int i = 0; i < n; i++) scanf("%d %d", &A[i][0], &A[i][1]);
	qsort(A, n, sizeof(A[0]), cmp);
	for (int i = 0; i < n; i++) printf("%d %d\n", A[i][0], A[i][1]);
	return 0;
}
```
###### FINAL問題: ソート
```c
#include <stdio.h>
#include <stdlib.h>

int cmp(const void *a, const void *b) {
	int *x = (int*) a;
	int *y = (int*) b;
	for (int i = 0; i < 2; i++) {
		if (x < y) return 1;
		if (x > y) return -1;
	}
	return 0;
}

int main() {
	int n;
	scanf("%d", &n);
	int A[n][2];
	for (int i = 0; i < n; i++) scanf("%d %d", &A[i][1], &A[i][0]);
	qsort(A, n, sizeof(A[0]), cmp);
	for (int i = 0; i < n; i++) printf("%d %d\n", A[i][1], A[i][0]);
	return 0;
}
```
- - -
##### C++
###### 昇順ソート
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
	int n;
	cin >> n;
	vector<int> A(n);
	for (int i = 0; i < n; i++) cin >> A[i];
	sort(A.begin(), A.end());
	for (int i = 0; i < n; i++) cout << A[i] << endl;
	return 0;
}
```
###### 降順ソート
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
	int n;
	cin >> n;
	vector<int> A(n);
	for (int i = 0; i < n; i++) cin >> A[i];
	sort(A.begin(), A.end());
	reverse(A.begin(), A.end());
	for (int i = 0; i < n; i++) cout << A[i] << endl;
	return 0;
}
```
###### 辞書式ソート
```cpp
#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
using namespace std;

int main() {
	int n;
	cin >> n;
	vector<pair<int, int>> P(n);
	for (int i = 0; i < n; i++) cin >> P[i].first >> P[i].second;
	sort(P.begin(), P.end());
	reverse(P.begin(), P.end());
	for (int i = 0; i < n; i++) cout << P[i].first << ' ' << P[i].second << endl;
	return 0;
}
```
###### FINAL問題: ソート
```cpp
#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
using namespace std;

int main() {
	int n;
	cin >> n;
	vector<pair<int, int>> P(n);
	for (int i = 0; i < n; i++) cin >> P[i].second >> P[i].first;
	sort(P.begin(), P.end());
	reverse(P.begin(), P.end());
	for (int i = 0; i < n; i++) cout << P[i].second << ' ' << P[i].first << endl;
	return 0;
}
```
- - -
##### C#
###### 昇順ソート
```cs
using System;

class Program
{
	public static void Main()
	{
		int n = int.Parse(Console.ReadLine());
		int[] A = new int[n];
		for (int i = 0; i < n; i++) A[i] = int.Parse(Console.ReadLine());
		Array.Sort(A);
		for (int i = 0; i < n; i++) Console.WriteLine(A[i]);
	}
}
```
###### 降順ソート
```cs
using System;

class Program
{
	public static void Main()
	{
		int n = int.Parse(Console.ReadLine());
		int[] A = new int[n];
		for (int i = 0; i < n; i++) A[i] = int.Parse(Console.ReadLine());
		Array.Sort(A);
		Array.Reverse(A);
		for (int i = 0; i < n; i++) Console.WriteLine(A[i]);
	}
}
```
###### 辞書式ソート
```cs
using System;

class Program
{
	public static void Main()
	{
		int n = int.Parse(Console.ReadLine());
		Tuple<int, int>[] P = new Tuple<int, int>[n];
		for (int i = 0; i < n; i++) {
			int[] ab = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
			P[i] = new Tuple<int, int>(ab[0], ab[1]);
		}
		Array.Sort(P);
		Array.Reverse(P);
		for (int i = 0; i < n; i++) Console.WriteLine("" + P[i].Item1 + ' ' + P[i].Item2);
	}
}
```
###### FINAL問題: ソート
```cs
using System;

class Program
{
	public static void Main()
	{
		int n = int.Parse(Console.ReadLine());
		Tuple<int, int>[] P = new Tuple<int, int>[n];
		for (int i = 0; i < n; i++) {
			int[] gs = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
			P[i] = new Tuple<int, int>(gs[1], gs[0]);
		}
		Array.Sort(P);
		Array.Reverse(P);
		for (int i = 0; i < n; i++) Console.WriteLine("" + P[i].Item2 + ' ' + P[i].Item1);
	}
}
```
- - -
##### Go
###### 昇順ソート
```go
package main
import (
	"fmt"
	"sort"
)

func main() {
	var n int
	fmt.Scan(&n)
	A := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&A[i])
	}
	sort.Ints(A)
	for i := 0; i < n; i++ {
		fmt.Println(A[i])
	}
}
```
###### 降順ソート
```go
package main
import (
	"fmt"
	"sort"
)

func main() {
	var n int
	fmt.Scan(&n)
	A := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&A[i])
	}
	sort.Sort(sort.Reverse(sort.IntSlice(A)))
	for i := 0; i < n; i++ {
		fmt.Println(A[i])
	}
}
```
###### 辞書式ソート
```go
package main
import (
	"fmt"
	"sort"
)

func main() {
	var n int
	fmt.Scan(&n)
	P := make([][2]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&P[i][0], &P[i][1])
	}
	sort.Slice(P, func(i, j int) bool {
		if P[i][0] != P[j][0] {
			return P[i][0] > P[j][0]
		} else {
			return P[i][1] > P[j][1]
		}
	})
	for i := 0; i < n; i++ {
		fmt.Println(P[i][0], P[i][1])
	}
}
```
###### FINAL問題: ソート
```go
package main
import (
	"fmt"
	"sort"
)

func main() {
	var n int
	fmt.Scan(&n)
	P := make([][2]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&P[i][0], &P[i][1])
	}
	sort.Slice(P, func(i, j int) bool {
		if P[i][1] != P[j][1] {
			return P[i][1] > P[j][1]
		} else {
			return P[i][0] > P[j][0]
		}
	})
	for i := 0; i < n; i++ {
		fmt.Println(P[i][0], P[i][1])
	}
}
```
- - -
##### 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[] A = new int[n];
		for (int i = 0; i < n; i++) A[i] = sc.nextInt();
		sc.close();
		Arrays.sort(A);
		for (int i = 0; i < n; i++) System.out.println(A[i]);
	}
}
```
###### 降順ソート
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		Integer[] A = new Integer[n];
		for (int i = 0; i < n; i++) A[i] = sc.nextInt();
		sc.close();
		Arrays.sort(A);
		Collections.reverse(Arrays.asList(A));
		for (int i = 0; i < n; i++) System.out.println(A[i]);
	}
}
```
###### 辞書式ソート
```java
import java.util.*;

class Pair {
	public int a;
	public int b;   
}

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		Pair[] P = new Pair[n];
		for (int i = 0; i < n; i++) {
			P[i] = new Pair();
			P[i].a = sc.nextInt();
			P[i].b = sc.nextInt();
		}
		sc.close();
		Arrays.sort(P, new Comparator<Pair>() {
			public int compare(Pair p, Pair q) {
				if (p.a != q.a) return p.a < q.a ? -1 : 1;
				if (p.b != q.b) return p.b < q.b ? -1 : 1;
				return 0;
			}
		});
		Collections.reverse(Arrays.asList(P));
		for (int i = 0; i < n; i++) {
			System.out.println("" + P[i].a + ' ' + P[i].b);
		}
	}
}
```
###### FINAL問題: ソート
```java
import java.util.*;

class Pair {
	public int g;
	public int s;   
}

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		Pair[] P = new Pair[n];
		for (int i = 0; i < n; i++) {
			P[i] = new Pair();
			P[i].g = sc.nextInt();
			P[i].s = sc.nextInt();
		}
		sc.close();
		Arrays.sort(P, new Comparator<Pair>() {
			public int compare(Pair p, Pair q) {
				if (p.s != q.s) return p.s < q.s ? -1 : 1;
				if (p.g != q.g) return p.g < q.g ? -1 : 1;
				return 0;
			}
		});
		Collections.reverse(Arrays.asList(P));
		for (int i = 0; i < n; i++) {
			System.out.println("" + P[i].g + ' ' + P[i].s);
		}
	}
}
```
- - -
##### JavaScript
###### 昇順ソート
```js
const [n, ...A] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n').map(Number);
A.sort();
for (var i = 0; i < n; i++) console.log(A[i]);
```
###### 降順ソート
```js
const [n, ...A] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n').map(Number);
A.sort();
A.reverse();
for (var i = 0; i < n; i++) console.log(A[i]);
```
###### 辞書式ソート
```js
const [n, ...A] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n').map((s, i) => i ? s.split(' ').map(Number) : Number(s));
A.sort();
A.reverse();
for (var i = 0; i < n; i++) console.log(...A[i]);
```
###### FINAL問題: ソート
```js
const [n, ...A] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n').map((s, i) => i ? s.split(' ').map(Number) : Number(s));
A.forEach(a => a.reverse());
A.sort();
A.reverse();
A.forEach(a => a.reverse());
for (var i = 0; i < n; i++) console.log(...A[i]);
```
- - -
##### Kotlin
###### 昇順ソート
```kotlin
fun main() {
	val n = readLine()!!.toInt()
	var A = Array(n) { readLine()!!.toInt() }
	A.sort()
	for (i in 0 until n) println(A[i])
}
```
###### 降順ソート
```kotlin
fun main() {
	val n = readLine()!!.toInt()
	var A = Array(n) { readLine()!!.toInt() }
	A.sort()
	A.reverse()
	for (i in 0 until n) println(A[i])
}
```
###### 辞書式ソート
```kotlin
fun main() {
	val n = readLine()!!.toInt()
	val P = Array<Pair<Int, Int>>(n) { Pair(0, 0) }
	for (i in 0 until n) {
		val (a, b) = readLine()!!.split(' ').map { it.toInt() }
		P[i] = Pair(a, b)
	}
	P.sortWith(compareByDescending<Pair<Int, Int>> { it.first }.thenByDescending { it.second })
	for (i in 0 until n) println("" + P[i].first + ' ' + P[i].second)
}
```
###### FINAL問題: ソート
```kotlin
fun main() {
	val n = readLine()!!.toInt()
	val P = Array<Pair<Int, Int>>(n) { Pair(0, 0) }
	for (i in 0 until n) {
		val (g, s) = readLine()!!.split(' ').map { it.toInt() }
		P[i] = Pair(g, s)
	}
	P.sortWith(compareByDescending<Pair<Int, Int>> { it.second }.thenByDescending { it.first })
	for (i in 0 until n) println("" + P[i].first + ' ' + P[i].second)
}
```
- - -
##### PHP
###### 昇順ソート
```php
<?php
	$n = intval(fgets(STDIN));
	$A = [];
	for ($i = 0; $i < $n; $i++) $A[] = intval(fgets(STDIN));
	sort($A);
	for ($i = 0; $i < $n; $i++) echo $A[$i], PHP_EOL;
?>
```
###### 降順ソート
```php
<?php
	$n = intval(fgets(STDIN));
	$A = [];
	for ($i = 0; $i < $n; $i++) $A[] = intval(fgets(STDIN));
	rsort($A);
	for ($i = 0; $i < $n; $i++) echo $A[$i], PHP_EOL;
?>
```
###### 辞書式ソート
```php
<?php
	$n = intval(fgets(STDIN));
	$A = [];
	for ($i = 0; $i < $n; $i++) $A[] = array_map("intval", explode(' ', fgets(STDIN)));
	rsort($A);
	for ($i = 0; $i < $n; $i++) echo $A[$i][0], ' ', $A[$i][1], PHP_EOL;
?>
```
###### FINAL問題: ソート
```php
<?php
	$n = intval(fgets(STDIN));
	$A = [];
	for ($i = 0; $i < $n; $i++) $A[] = array_reverse(array_map("intval", explode(' ', fgets(STDIN))));
	rsort($A);
	for ($i = 0; $i < $n; $i++) echo $A[$i][1], ' ', $A[$i][0], PHP_EOL;
?>
```
- - -
##### Perl
###### 昇順ソート
```pl
my $n = int(<STDIN>);
my @A;
for (1...$n) {
	push @A, int(<STDIN>);
}
@A = sort @A;
for (my $i = 0; $i < $n; $i++) {
	print "$A[$i]$/";
}
```
###### 降順ソート
```pl
my $n = int(<STDIN>);
my @A;
for (1...$n) {
	push @A, int(<STDIN>);
}
@A = reverse sort @A;
for (my $i = 0; $i < $n; $i++) {
	print "$A[$i]$/";
}
```
###### 辞書式ソート
```pl
my $n = int(<STDIN>);
my @A;
for (1...$n) {
	push @A, [map { int($_) } split ' ', <STDIN>];
}
@A = sort { $b->[0] <=> $a->[0] } sort { $b->[1] <=> $a->[1] } @A;
for (my $i = 0; $i < $n; $i++) {
	print "$A[$i][0] $A[$i][1]$/";
}
```
###### FINAL問題: ソート
```pl
my $n = int(<STDIN>);
my @A;
for (1...$n) {
	push @A, [map { int($_) } split ' ', <STDIN>];
}
@A = sort { $b->[1] <=> $a->[1] } sort { $b->[0] <=> $a->[0] } @A;
for (my $i = 0; $i < $n; $i++) {
	print "$A[$i][0] $A[$i][1]$/";
}
```
- - -
##### Python3
###### 昇順ソート
```py
print(*sorted(int(input()) for _ in range(int(input()))), sep='\n')
```
###### 降順ソート
```py
print(*sorted([int(input()) for _ in range(int(input()))], reverse=True), sep='\n')
```
###### 辞書式ソート
```py
for a, b in sorted([(a, b) for a, b in [tuple(map(int, input().split())) for _ in range(int(input()))]], reverse=True): print(a, b)
```
###### FINAL問題: ソート
```py
for s, g in sorted([(s, g) for g, s in [tuple(map(int, input().split())) for _ in range(int(input()))]], reverse=True): print(g, s)
```
- - -
##### Ruby
###### 昇順ソート
```rb
gets.to_i.times.map { gets.to_i }.sort.each do |a|
	p a
end
```
###### 降順ソート
```rb
gets.to_i.times.map { gets.to_i }.sort.reverse.each do |a|
	p a
end
```
###### 辞書式ソート
```rb
gets.to_i.times.map { gets.split.map(&:to_i) }.sort.reverse.each do |a, b|
	print a, ' ', b, "\n"
end
```
###### FINAL問題: ソート
```rb
gets.to_i.times.map { gets.split.map(&:to_i).reverse }.sort.reverse.each do |s, g|
	print g, ' ', s, "\n"
end
```
- - -
##### Scala
###### 昇順ソート
```scala
import scala.io.StdIn._

object Main extends App{
	val A = (0 until readInt()).map { _ => readInt() }.sorted
	for (a <- A) println(a)
}
```
###### 降順ソート
```scala
import scala.io.StdIn._

object Main extends App{
	val A = (0 until readInt()).map { _ => readInt() }.sorted.reverse
	for (a <- A) println(a)
}
```
###### 辞書式ソート
```scala
import scala.io.StdIn._

object Main extends App{
	val A = (0 until readInt()).map { _ => readLine().split(' ').map { _.toInt } }.sortBy { case a => (-a(0), -a(1)) }
	for (a <- A) println("" + a(0) + ' ' + a(1))
}
```
###### FINAL問題: ソート
```scala
import scala.io.StdIn._

object Main extends App{
	val A = (0 until readInt()).map { _ => readLine().split(' ').map { _.toInt } }.sortBy { case a => (-a(1), -a(0)) }
	for (a <- A) println("" + a(0) + ' ' + a(1))
}
```
- - -
##### Swift
###### 昇順ソート
```swift
let n = Int(readLine()!)!
var A: [Int] = []
for _ in 0..<n {
	A.append(Int(readLine()!)!)
}
A.sort()
for a in A {
	print(a)
}
```
###### 降順ソート
```swift
let n = Int(readLine()!)!
var A: [Int] = []
for _ in 0..<n {
	A.append(Int(readLine()!)!)
}
A.sort(by: >)
for a in A {
	print(a)
}
```
###### 辞書式ソート
```swift
let n = Int(readLine()!)!
var P: [(Int, Int)] = []
for _ in 0..<n {
	let ab = readLine()!.split(separator: " ").compactMap { Int($0) }
	P.append((ab[0], ab[1]))
}
P.sort(by: >)
for p in P {
	print(p.0, p.1)
}
```
###### FINAL問題: ソート
```swift
let n = Int(readLine()!)!
var P: [(Int, Int)] = []
for _ in 0..<n {
	let gs = readLine()!.split(separator: " ").compactMap { Int($0) }
	P.append((gs[1], gs[0]))
}
P.sort(by: >)
for p in P {
	print(p.1, p.0)
}
```