paizaラーニングレベルアップ問題集の【実数をフォーマット指定して出力】をやってみた。

paizaラーニングレベルアップ問題集の【実数をフォーマット指定して出力】をやってみました。
- - -
##### 問題
###### 1つの実数を出力1（0.001以上99.999未満）
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__format_real_number_step1
###### 1つの実数を出力2（0.001以上1兆未満）
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__format_real_number_step2
###### 1つの実数を出力3（小数第3位まで出力）
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__format_real_number_step3
###### 1つの実数を出力4（小数第M位まで出力）
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__format_real_number_step4
###### 複数の実数を出力
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__format_real_number_boss
- - -
##### C
###### 1つの実数を出力1（0.001以上99.999未満）
```c
#include <stdio.h>

int main() {
	double n;
	scanf("%lf", &n);
	printf("%lf\n", n); //小数第6位まで出力されるが正解
	return 0;
}
```
###### 1つの実数を出力2（0.001以上1兆未満）
```c
#include <stdio.h>

int main() {
	char n[17];
	scanf("%s", n);
	printf("%s\n", n);
	return 0;
}
```
###### 1つの実数を出力3（小数第3位まで出力）
```c
#include <stdio.h>

int main() {
	double n;
	scanf("%lf", &n);
	printf("%.3lf\n", n);
	return 0;
}
```
###### 1つの実数を出力4（小数第M位まで出力）
```c
#include <stdio.h>

int main() {
	double n;
	int m;
	scanf("%lf %d", &n, &m);
	printf("%.*lf\n", m, n);
	return 0;
}
```
###### 複数の実数を出力
```c
#include <stdio.h>

int main() {
	int q;
	scanf("%d", &q);
	while (q--) {
		double n;
		int m;
		scanf("%lf %d", &n, &m);
		printf("%.*lf\n", m, n);
	}
	return 0;
}
```
- - -
##### C++
###### 1つの実数を出力1（0.001以上99.999未満）
```cpp
#include <iostream>
using namespace std;

int main() {
	double n;
	cin >> n;
	cout << n << endl; //有効数字6桁で出力されるが制約条件下では正解
	return 0;
}
```
###### 1つの実数を出力2（0.001以上1兆未満）
```cpp
#include <iostream>
using namespace std;

int main() {
	string n;
	cin >> n;
	cout << n << endl;
	return 0;
}
```
###### 1つの実数を出力3（小数第3位まで出力）
```cpp
#include <iostream>
#include <iomanip>
using namespace std;

int main() {
	double n;
	cin >> n;
	cout << fixed << setprecision(3) << n << endl;
	return 0;
}
```
###### 1つの実数を出力4（小数第M位まで出力）
```cpp
#include <iostream>
#include <iomanip>
using namespace std;

int main() {
	double n;
	int m;
	cin >> n >> m;
	cout << fixed << setprecision(m) << n << endl;
	return 0;
}
```
###### 複数の実数を出力
```cpp
#include <iostream>
#include <iomanip>
using namespace std;

int main() {
	int q;
	cin >> q;
	while (q--) {
		double n;
		int m;
		cin >> n >> m;
		cout << fixed << setprecision(m) << n << endl;
	}
	return 0;
}
```
- - -
##### C#
###### 1つの実数を出力1（0.001以上99.999未満）
```cs
using System;

class Program
{
	public static void Main()
	{
		Console.WriteLine(double.Parse(Console.ReadLine()));
	}
}
```
###### 1つの実数を出力2（0.001以上1兆未満）
```cs
using System;

class Program
{
	public static void Main()
	{
		Console.WriteLine(Console.ReadLine());
	}
}
```
###### 1つの実数を出力3（小数第3位まで出力）
```cs
using System;

class Program
{
	static void Main()
	{
		double n = double.Parse(Console.ReadLine());
		Console.WriteLine(n.ToString("F3"));
	}
}
```
###### 1つの実数を出力4（小数第M位まで出力）
```cs
using System;

class Program
{
	static void Main()
	{
		string[] nm = Console.ReadLine().Split();
		Console.WriteLine(double.Parse(nm[0]).ToString("F" + nm[1]));
	}
}
```
###### 複数の実数を出力
```cs
using System;

class Program
{
	static void Main()
	{
		for (int q = int.Parse(Console.ReadLine()); q > 0; q--) {
			string[] nm = Console.ReadLine().Split();
			Console.WriteLine(double.Parse(nm[0]).ToString("F" + nm[1]));
		}
	}
}
```
- - -
##### Go
###### 1つの実数を出力1（0.001以上99.999未満）
```go
package main
import "fmt"

func main() {
	var n float64
	fmt.Scan(&n)
	fmt.Println(n)
}
```
###### 1つの実数を出力2（0.001以上1兆未満）
```go
package main
import "fmt"

func main() {
	var n string
	fmt.Scan(&n)
	fmt.Println(n)
}
```
###### 1つの実数を出力3（小数第3位まで出力）
```go
package main
import "fmt"

func main() {
	var n float64
	fmt.Scan(&n)
	fmt.Printf("%.3f\n", n)
}
```
###### 1つの実数を出力4（小数第M位まで出力）
```go
package main
import "fmt"

func main() {
	var n float64
	var m int
	fmt.Scan(&n, &m)
	fmt.Printf("%.*f\n", m, n)
}
```
###### 複数の実数を出力
```go
package main
import "fmt"

func main() {
	var Q int
	fmt.Scan(&Q)
	for q := 0; q < Q; q++ {
		var n float64
		var m int
		fmt.Scan(&n, &m)
		fmt.Printf("%.*f\n", m, n)
	}
}
```
- - -
##### Java
###### 1つの実数を出力1（0.001以上99.999未満）
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println(sc.nextDouble());
		sc.close();
	}
}
```
###### 1つの実数を出力2（0.001以上1兆未満）
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println(sc.next());
		sc.close();
	}
}
```
###### 1つの実数を出力3（小数第3位まで出力）
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.printf("%.3f%n", sc.nextDouble());
		sc.close();
	}
}
```
###### 1つの実数を出力4（小数第M位まで出力）
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		double n = sc.nextDouble();
		int m = sc.nextInt();
		System.out.printf("%." + m + "f%n", n);
		sc.close();
	}
}
```
###### 複数の実数を出力
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		for (int q = sc.nextInt(); q > 0 ; q--) {
			double n = sc.nextDouble();
			int m = sc.nextInt();
			System.out.printf("%." + m + "f%n", n);
		}
		sc.close();
	}
}
```
- - -
##### JavaScript
###### 1つの実数を出力1（0.001以上99.999未満）
```js
console.log(Number(require("fs").readFileSync("/dev/stdin", "utf8")));
```
###### 1つの実数を出力2（0.001以上1兆未満）
```js
console.log(require("fs").readFileSync("/dev/stdin", "utf8").trim());
```
###### 1つの実数を出力3（小数第3位まで出力）
```js
console.log(Number(require("fs").readFileSync("/dev/stdin", "utf8").trim()).toFixed(3));
```
###### 1つの実数を出力4（小数第M位まで出力）
```js
const [n, m] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split(' ').map(Number);
console.log(n.toFixed(m));
```
###### 複数の実数を出力
```js
const [Q, ...NM] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n').map(s => s.split(' ').map(Number));
for (var q = 0; q < Q[0]; q++) {
	let [n, m] = NM[q]; 
	console.log(n.toFixed(m));
}
```
- - -
##### Kotlin
###### 1つの実数を出力1（0.001以上99.999未満）
```kotlin
fun main() {
	println(readLine()!!.toDouble())
}
```
###### 1つの実数を出力2（0.001以上1兆未満）
```kotlin
fun main() {
	println(readLine())
}
```
###### 1つの実数を出力3（小数第3位まで出力）
```kotlin
fun main() {
	println("%.3f".format(readLine()!!.toDouble()))
}
```
###### 1つの実数を出力4（小数第M位まで出力）
```kotlin
import java.util.*;

fun main() {
	val sc = Scanner(System.`in`)
	val n = sc.nextDouble()
	val m = sc.nextInt()
	println("%.${m}f".format(n))
	sc.close()
}
```
###### 複数の実数を出力
```kotlin
import java.util.*;

fun main() {
	val sc = Scanner(System.`in`)
	for (q in 1..sc.nextInt()) {
		val n = sc.nextDouble()
		val m = sc.nextInt()
		println("%.${m}f".format(n))
	}
	sc.close()
}
```
- - -
##### PHP
###### 1つの実数を出力1（0.001以上99.999未満）
```php
<?php
	echo floatval(trim(fgets(STDIN))), PHP_EOL;
?>
```
###### 1つの実数を出力2（0.001以上1兆未満）
```php
<?php
	echo trim(fgets(STDIN)), PHP_EOL;
?>
```
###### 1つの実数を出力3（小数第3位まで出力）
```php
<?php
	echo number_format(floatval(trim(fgets(STDIN))), 3, '.', ''), PHP_EOL;
?>
```
###### 1つの実数を出力4（小数第M位まで出力）
```php
<?php
	[$n, $m] = explode(' ', trim(fgets(STDIN)));
	echo number_format($n, $m, '.', ''), PHP_EOL;
?>
```
###### 複数の実数を出力
```php
<?php
	for ($q = intval(trim(fgets(STDIN))); $q > 0; $q--) {
		[$n, $m] = explode(' ', trim(fgets(STDIN)));
		echo number_format($n, $m, '.', ''), PHP_EOL;
	}
?>
```
- - -
##### Perl
###### 1つの実数を出力1（0.001以上99.999未満）
```pl
$n = 0 + <STDIN>;
print $n, $/;
```
###### 1つの実数を出力2（0.001以上1兆未満）
```pl
chomp(my $n = <STDIN>);
print $n, $/;
```
###### 1つの実数を出力3（小数第3位まで出力）
```pl
print sprintf("%.3f$/", <STDIN>);
```
###### 1つの実数を出力4（小数第M位まで出力）
```pl
my @nm = split(' ', <STDIN>);
print sprintf("%.*f$/", $nm[1], $nm[0]);
```
###### 複数の実数を出力
```pl
for (my $q = <STDIN>; $q > 0; $q--) {
	my @nm = split(' ', <STDIN>);
	print sprintf("%.*f$/", $nm[1], $nm[0]);
}
```
- - -
##### Python3
###### 1つの実数を出力1（0.001以上99.999未満）
```py
print(float(input()))
```
###### 1つの実数を出力2（0.001以上1兆未満）
```py
print(input())
```
###### 1つの実数を出力3（小数第3位まで出力）
```py
print(f"{float(input()):.3f}")
```
###### 1つの実数を出力4（小数第M位まで出力）
```py
n, m = input().split()
print(f"{float(n):.{m}f}")
```
###### 複数の実数を出力
```py
for _ in range(int(input())):
	n, m = input().split()
	print(f"{float(n):.{m}f}")
```
- - -
##### Ruby
###### 1つの実数を出力1（0.001以上99.999未満）
```rb
p gets.to_f
```
###### 1つの実数を出力2（0.001以上1兆未満）
```rb
puts gets
```
###### 1つの実数を出力3（小数第3位まで出力）
```rb
puts "%.3f" % gets.to_f
```
###### 1つの実数を出力4（小数第M位まで出力）
```rb
n, m = gets.split
puts "%.#{"%d" % m.to_i}f" % n.to_f
```
###### 複数の実数を出力
```rb
gets.to_i.times do
	n, m = gets.split
	puts "%.#{"%d" % m.to_i}f" % n.to_f
end
```
- - -
##### Scala
###### 1つの実数を出力1（0.001以上99.999未満）
```scala
import scala.io.StdIn._

object Main extends App{
	println(readDouble())
}
```
###### 1つの実数を出力2（0.001以上1兆未満）
```scala
import scala.io.StdIn._

object Main extends App{
	println(readLine())
}
```
###### 1つの実数を出力3（小数第3位まで出力）
```scala
import scala.io.StdIn._

object Main extends App{
	printf("%.3f\n", readDouble())
}
```
###### 1つの実数を出力4（小数第M位まで出力）
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(n, m) = readLine().split(" ")
	printf(s"%.${m}f\n", n.toDouble)
}
```
###### 複数の実数を出力
```scala
import scala.io.StdIn._

object Main extends App{
	for (_ <- 1 to readInt()) {
		val Array(n, m) = readLine().split(" ")
		printf(s"%.${m}f\n", n.toDouble)
	}
}
```
- - -
##### Swift
###### 1つの実数を出力1（0.001以上99.999未満）
```swift
print(Double(readLine()!)!)
```
###### 1つの実数を出力2（0.001以上1兆未満）
```swift
print(readLine()!)
```
###### 1つの実数を出力3（小数第3位まで出力）
```swift
import Foundation

print(String(format: "%.3f", Double(readLine()!)!))
```
###### 1つの実数を出力4（小数第M位まで出力）
```swift
import Foundation

let nm = readLine()!.split(separator: " ")
let n = Double(nm[0])!
let m = Int(nm[1])!
print(String(format: "%.\(m)f", n))
```
###### 複数の実数を出力
```swift
import Foundation

for _ in 1...Int(readLine()!)! {
	let nm = readLine()!.split(separator: " ")
	let n = Double(nm[0])!
	let m = Int(nm[1])!
	print(String(format: "%.\(m)f", n))
}
```