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

paizaラーニングレベルアップ問題集の【出力幅を指定して出力】をやってみました。
- - -
##### 問題
###### 数値を半角スペース埋めで出力
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__print_width_step1
###### 数値をゼロ埋めで出力
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__print_width_step2
###### 複数の数値を半角スペース埋めで出力
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__print_width_step3
###### 数値をMけた半角スペース埋めで出力
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__print_width_step4
###### N個の数値をMけた半角スペース埋めで出力
https://paiza.jp/works/mondai/stdout_primer/stdout_primer__print_width_boss
- - -
##### C
###### 数値を半角スペース埋めで出力
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	printf("%3d\n", n);
	return 0;
}
```
###### 数値をゼロ埋めで出力
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	printf("%03d\n", n);
	return 0;
}
```
###### 複数の数値を半角スペース埋めで出力
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	while (n--) {
		int m;
		scanf("%d", &m);
		printf("%3d\n", m);
	}
	return 0;
}
```
###### 数値をMけた半角スペース埋めで出力
```c
#include <stdio.h>

int main() {
	int n, m;
	scanf("%d %d", &n, &m);
	printf("%*d\n", m, n);
	return 0;
}
```
###### N個の数値をMけた半角スペース埋めで出力
```c
#include <stdio.h>

int main() {
	int n, m;
	scanf("%d %d", &n, &m);
	while (n--) {
		int a;
		scanf("%d", &a);
		printf("%*d\n", m, a);
	}
	return 0;
}
```
- - -
##### C++
###### 数値を半角スペース埋めで出力
```cpp
#include <iostream>
#include <iomanip>
using namespace std;

int main() {
	int n;
	cin >> n;
	cout << setw(3) << n << endl;
	return 0;
}
```
###### 数値をゼロ埋めで出力
```cpp
#include <iostream>
#include <iomanip>
using namespace std;

int main() {
	int n;
	cin >> n;
	cout << setw(3) << setfill('0') << n << endl;
	return 0;
}
```
###### 複数の数値を半角スペース埋めで出力
```cpp
#include <iostream>
#include <iomanip>
using namespace std;

int main() {
	int n;
	cin >> n;
	while (n--) {
		int m;
		cin >> m;
		cout << setw(3) << m << endl;
	}
	return 0;
}
```
###### 数値をMけた半角スペース埋めで出力
```cpp
#include <iostream>
#include <iomanip>
using namespace std;

int main() {
	int n, m;
	cin >> n >> m;
	cout << setw(m) << n << endl;
	return 0;
}
```
###### N個の数値をMけた半角スペース埋めで出力
```cpp
#include <iostream>
#include <iomanip>
using namespace std;

int main() {
	int n, m;
	cin >> n >> m;
	while (n--) {
		int a;
		cin >> a;
		cout << setw(m) << a << endl;
	}
	return 0;
}
```
- - -
##### C#
###### 数値を半角スペース埋めで出力
```cs
using System;

class Program
{
	public static void Main()
	{
		Console.WriteLine(Console.ReadLine().PadLeft(3, ' '));
	}
}
```
###### 数値をゼロ埋めで出力
```cs
using System;

class Program
{
	public static void Main()
	{
		Console.WriteLine(int.Parse(Console.ReadLine()).ToString("D3"));
	}
}
```
###### 複数の数値を半角スペース埋めで出力
```cs
using System;

class Program
{
	public static void Main()
	{
		for (int i = int.Parse(Console.ReadLine()); i > 0; i--) {
			Console.WriteLine(Console.ReadLine().PadLeft(3, ' '));
		}
	}
}
```
###### 数値をMけた半角スペース埋めで出力
```cs
using System;

class Program
{
	public static void Main()
	{
		int[] nm = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		Console.WriteLine(nm[0].ToString().PadLeft(nm[1], ' '));
	}
}
```
###### N個の数値をMけた半角スペース埋めで出力
```cs
using System;

class Program
{
	static void Main()
	{
		int[] nm = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		int n = nm[0];
		int m = nm[1];
		for (int i = 0; i < n; i++) {
			Console.WriteLine(Console.ReadLine().PadLeft(m, ' '));
		}
	}
}
```
- - -
##### Go
###### 数値を半角スペース埋めで出力
```go
package main
import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	fmt.Printf("%3d\n", n)
}
```
###### 数値をゼロ埋めで出力
```go
package main
import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	fmt.Printf("%03d\n", n)
}
```
###### 複数の数値を半角スペース埋めで出力
```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)
		fmt.Printf("%3d\n", m)
	}
}
```
###### 数値をMけた半角スペース埋めで出力
```go
package main
import "fmt"

func main() {
	var n, m int
	fmt.Scan(&n, &m)
	fmt.Printf("%*d\n", m, n)
}
```
###### N個の数値をMけた半角スペース埋めで出力
```go
package main
import "fmt"

func main() {
	var n, m int
	fmt.Scan(&n, &m)
	for i := 0; i < n; i++ {
		var a int
		fmt.Scanf("%d", &a)
		fmt.Printf("%*d\n", m, a)
	}
}
```
- - -
##### Java
###### 数値を半角スペース埋めで出力
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.printf("%3d%n", sc.nextInt());
		sc.close();
	}
}
```
###### 数値をゼロ埋めで出力
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.printf("%03d%n", sc.nextInt());
		sc.close();
	}
}
```
###### 複数の数値を半角スペース埋めで出力
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		for (int i = sc.nextInt(); i > 0; i--) {
			System.out.printf("%3d%n", sc.nextInt());
		}
		sc.close();
	}
}
```
###### 数値をMけた半角スペース埋めで出力
```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();
		System.out.printf("%" + m + "d%n", n);
		sc.close();
	}
}
```
###### N個の数値をMけた半角スペース埋めで出力
```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();
		for (int i = 0; i < n; i++) {
			System.out.printf("%" + m + "d%n", sc.nextInt());
		}
		sc.close();
	}
}
```
- - -
##### JavaScript
###### 数値を半角スペース埋めで出力
```js
console.log(require("fs").readFileSync("/dev/stdin", "utf8").trim().padStart(3));
```
###### 数値をゼロ埋めで出力
```js
console.log(require("fs").readFileSync("/dev/stdin", "utf8").trim().padStart(3, '0'));
```
###### 複数の数値を半角スペース埋めで出力
```js
const [N, ...M] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n');
const n = Number(N);
for (var i = 0; i < n; i++) {
	console.log(M[i].padStart(3));
}
```
###### 数値をMけた半角スペース埋めで出力
```js
const [n, m] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split(' ');
console.log(n.padStart(Number(m)));
```
###### N個の数値をMけた半角スペース埋めで出力
```js
const [NM, ...A] = require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n');
const [n, m] = NM.split(' ').map(Number);
for (var i = 0; i < n; i++) {
	console.log(A[i].padStart(m));
}
```
- - -
##### Kotlin
###### 数値を半角スペース埋めで出力
```kotlin
fun main() {
	println("%3d".format(readLine()!!.toInt()))
}
```
###### 数値をゼロ埋めで出力
```kotlin
fun main() {
	println("%03d".format(readLine()!!.toInt()))
}
```
###### 複数の数値を半角スペース埋めで出力
```kotlin
fun main() {
	for (i in 1..readLine()!!.toInt()) {
		println("%3d".format(readLine()!!.toInt()))
	}
}
```
###### 数値をMけた半角スペース埋めで出力
```kotlin
fun main() {
	val (n, m) = readLine()!!.split(' ').map { it.toInt() }
	println("%${m}d".format(n))
}
```
###### N個の数値をMけた半角スペース埋めで出力
```kotlin
fun main() {
	val (n, m) = readLine()!!.split(' ').map { it.toInt() }
	for (i in 1..n) {
		println("%${m}d".format(readLine()!!.toInt()))
	}
}
```
- - -
##### PHP
###### 数値を半角スペース埋めで出力
```php
<?php
	printf("%3d\n", intval(fgets(STDIN)));
?>
```
###### 数値をゼロ埋めで出力
```php
<?php
	printf("%03d\n", intval(fgets(STDIN)));
?>
```
###### 複数の数値を半角スペース埋めで出力
```php
<?php
	for ($i = intval(fgets(STDIN)); $i > 0; $i--) {
		printf("%3d\n", intval(fgets(STDIN)));
	}
?>
```
###### 数値をMけた半角スペース埋めで出力
```php
<?php
	[$n, $m] = array_map("intval", explode(' ', fgets(STDIN)));
	printf("%*d\n", $m, $n);
?>
```
###### N個の数値をMけた半角スペース埋めで出力
```php
<?php
	[$n, $m] = array_map("intval", explode(' ', fgets(STDIN)));
	while ($n--) {
		printf("%*d\n", $m, intval(fgets(STDIN)));
	}
?>
```
- - -
##### Perl
###### 数値を半角スペース埋めで出力
```pl
print sprintf("%3d$/", int(<STDIN>));
```
###### 数値をゼロ埋めで出力
```pl
print sprintf("%03d$/", int(<STDIN>));
```
###### 複数の数値を半角スペース埋めで出力
```pl
chomp(my $n = <STDIN>);
while ($n--) {
	print sprintf("%3d$/", int(<STDIN>));
}
```
###### 数値をMけた半角スペース埋めで出力
```pl
my ($n, $m) = map { int($_) } split(' ', <STDIN>);
print sprintf("%*d$/", $m, $n);
```
###### N個の数値をMけた半角スペース埋めで出力
```pl
my ($n, $m) = map { int($_) } split(' ', <STDIN>);
while ($n--) {
	print sprintf("%*d$/", $m, int(<STDIN>));
}
```
- - -
##### Python3
###### 数値を半角スペース埋めで出力
```py
print(f"{int(input()):3d}")
```
###### 数値をゼロ埋めで出力
```py
print(f"{int(input()):03d}")
```
###### 複数の数値を半角スペース埋めで出力
```py
for _ in range(int(input())):
	print(f"{int(input()):3d}")
```
###### 数値をMけた半角スペース埋めで出力
```py
n, m = map(int, input().split())
print(f"{n:{m}d}")
```
###### N個の数値をMけた半角スペース埋めで出力
```py
n, m = map(int, input().split())
for _ in range(m):
	print(f"{int(input()):{m}d}")
```
- - -
##### Ruby
###### 数値を半角スペース埋めで出力
```rb
puts "%3d" % gets.to_i
```
###### 数値をゼロ埋めで出力
```rb
puts "%03d" % gets.to_i
```
###### 複数の数値を半角スペース埋めで出力
```rb
gets.to_i.times do
	puts "%3d" % gets.to_i
end
```
###### 数値をMけた半角スペース埋めで出力
```rb
n, m = gets.split.map(&:to_i)
puts "%#{"%d" % m}d" % n
```
###### N個の数値をMけた半角スペース埋めで出力
```rb
n, m = gets.split.map(&:to_i)
n.times do
	puts "%#{"%d" % m}d" % gets.to_i
end
```
- - -
##### Scala
###### 数値を半角スペース埋めで出力
```scala
import scala.io.StdIn._

object Main extends App{
	printf("%3d\n", readInt())
}
```
###### 数値をゼロ埋めで出力
```scala
import scala.io.StdIn._

object Main extends App{
	printf("%03d\n", readInt())
}
```
###### 複数の数値を半角スペース埋めで出力
```scala
import scala.io.StdIn._

object Main extends App{
	for (i <- 1 to readInt()) {
		printf("%3d\n", readInt())
	}
}
```
###### 数値をMけた半角スペース埋めで出力
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(n, m) = readLine().split(' ').map { _.toInt }
	printf(s"%${m}d\n", n)
}
```
###### N個の数値をMけた半角スペース埋めで出力
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(n, m) = readLine().split(" ").map { _.toInt }
	for (i <- 1 to n) {
		printf(s"%${m}d\n", readInt())
	}
}
```
- - -
##### Swift
###### 数値を半角スペース埋めで出力
```swift
import Foundation

print(String(format: "%3d", Int(readLine()!)!))
```
###### 数値をゼロ埋めで出力
```swift
import Foundation

print(String(format: "%03d", Int(readLine()!)!))
```
###### 複数の数値を半角スペース埋めで出力
```swift
import Foundation

for _ in 1...Int(readLine()!)! {
	print(String(format: "%3d", Int(readLine()!)!))
}
```
###### 数値をMけた半角スペース埋めで出力
```swift
import Foundation

let nm = readLine()!.split(separator: " ").map { Int($0)! }
let n = nm[0]
let m = nm[1]
print(String(format: "%\(m)d", n))
```
###### N個の数値をMけた半角スペース埋めで出力
```swift
import Foundation

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