paizaラーニングレベルアップ問題集の【ループメニュー】をやってみた。(1)

paizaラーニングレベルアップ問題集の【ループメニュー】をやってみました。
- - -
##### 問題
###### ある数字までの出力1
https://paiza.jp/works/mondai/loop_problems/loop_problems__print_num_step1
###### ある数字までの出力2
https://paiza.jp/works/mondai/loop_problems/loop_problems__print_num_step2
###### 数字の受け取り1
https://paiza.jp/works/mondai/loop_problems/loop_problems__input_num_step1
###### 数字の受け取り2
https://paiza.jp/works/mondai/loop_problems/loop_problems__input_num_step2
###### ある数をある回数表示1
https://paiza.jp/works/mondai/loop_problems/loop_problems__rep_num_step1
###### ある数をある回数表示2
https://paiza.jp/works/mondai/loop_problems/loop_problems__rep_num_step2
###### a～zまでを表示
https://paiza.jp/works/mondai/loop_problems/loop_problems__print_alpha
- - -
今回は、あまり
```py
print(*range(1, 11), sep='\n')
```
の様なことはせずに…
- - -
##### C
###### ある数字までの出力1
```c
#include <stdio.h>

int main() {
	for (int i = 1; i <= 10; i++) printf("%d\n", i);
	return 0;
}
```
###### ある数字までの出力2
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) printf("%d\n", i);
	return 0;
}
```
###### 数字の受け取り1
```c
#include <stdio.h>

int main() {
	for (int i = 0; i < 10; i++) {
		int k;
		scanf("%d", &k);
		printf("%d\n", k);
	}
	return 0;
}
```
###### 数字の受け取り2
```c
#include <stdio.h>

int main() {
	int n;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		int k;
		scanf("%d", &k);
		printf("%d\n", k);
	}
	return 0;
}
```
###### ある数をある回数表示1
```c
#include <stdio.h>

int main() {
	for (int i = 0; i < 8; i++) printf("%d\n", 3);
	return 0;
}
```
###### ある数をある回数表示2
```c
#include <stdio.h>

int main() {
	int n, k;
	scanf("%d %d", &n, &k);
	for (int i = 0; i < k; i++) printf("%d\n", n);
	return 0;
}
```
###### a～zまでを表示
```c
#include <stdio.h>

int main() {
	for (char c = 'a'; c <= 'z'; c++) {
		putchar(c);
		puts("");
	}
	return 0;
}
```
- - -
##### C++
###### ある数字までの出力1
```cpp
#include <iostream>
using namespace std;

int main() {
	for (int i = 1; i <= 10; i++) cout << i << endl;
	return 0;
}
```
###### ある数字までの出力2
```cpp
#include <iostream>
using namespace std;

int main() {
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++) cout << i << endl;
	return 0;
}
```
###### 数字の受け取り1
```cpp
#include <iostream>
using namespace std;

int main() {
	for (int i = 0; i < 10; i++) {
		int k;
		cin >> k;
		cout << k << endl;
	}
	return 0;
}
```
###### 数字の受け取り2
```cpp
#include <iostream>
using namespace std;

int main() {
	int n;
	cin >> n;
	for (int i = 0; i < n; i++) {
		int k;
		cin >> k;
		cout << k << endl;
	}
	return 0;
}
```
###### ある数をある回数表示1
```cpp
#include <iostream>
using namespace std;

int main() {
	for (int i = 0; i < 8; i++) cout << 3 << endl;
	return 0;
}
```
###### ある数をある回数表示2
```cpp
#include <iostream>
using namespace std;

int main() {
	int n, k;
	cin >> n >> k;
	for (int i = 0; i < k; i++) cout << n << endl;
	return 0;
}
```
###### a～zまでを表示
```cpp
#include <iostream>
using namespace std;

int main() {
	for (char c = 'a'; c <= 'z'; c++) cout << c << endl;
	return 0;
}
```
- - -
##### C#
###### ある数字までの出力1
```cs
using System;

class Program
{
	public static void Main()
	{
		for (int i = 1; i <= 10; i++) Console.WriteLine(i);
	}
}
```
###### ある数字までの出力2
```cs
using System;

class Program
{
	public static void Main()
	{
		int n = int.Parse(Console.ReadLine());
		for (int i = 1; i <= n; i++) Console.WriteLine(i);
	}
}
```
###### 数字の受け取り1
```cs
using System;

class Program
{
	public static void Main()
	{
		int[] K = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		for (int i = 0; i < 10; i++) Console.WriteLine(K[i]);
	}
}
```
###### 数字の受け取り2
```cs
using System;

class Program
{
	public static void Main()
	{
		int n = int.Parse(Console.ReadLine());
		int[] K = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		for (int i = 0; i < n; i++) Console.WriteLine(K[i]);
	}
}
```
###### ある数をある回数表示1
```cs
using System;

class Program
{
	public static void Main()
	{
		for (int i = 0; i < 8; i++) Console.WriteLine(3);
	}
}
```
###### ある数をある回数表示2
```cs
using System;

class Program
{
	public static void Main()
	{
		int[] nk = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
		int n = nk[0];
		int k = nk[1];
		for (int i = 0; i < k; i++) Console.WriteLine(n);
	}
}
```
###### a～zまでを表示
```cs
using System;

class Program
{
	public static void Main()
	{
		for (char c = 'a'; c <= 'z'; c++) Console.WriteLine(c);
	}
}
```
- - -
##### Go
###### ある数字までの出力1
```go
package main
import "fmt"

func main() {
	for i := 1; i <= 10; i++ {
		fmt.Println(i)
	}
}
```
###### ある数字までの出力2
```go
package main
import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	for i := 1; i <= n; i++ {
		fmt.Println(i)
	}
}
```
###### 数字の受け取り1
```go
package main
import "fmt"

func main() {
	for i := 0; i < 10; i++ {
		var k int
		fmt.Scan(&k)
		fmt.Println(k)
	}
}
```
###### 数字の受け取り2
```go
package main
import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	for i := 0; i < n; i++ {
		var k int
		fmt.Scan(&k)
		fmt.Println(k)
	}
}
```
###### ある数をある回数表示1
```go
package main
import "fmt"

func main() {
	for i := 0; i < 8; i++ {
		fmt.Println(3)
	}
}
```
###### ある数をある回数表示2
```go
package main
import "fmt"

func main() {
	var n, k int
	fmt.Scan(&n, &k)
	for i := 0; i < k; i++ {
		fmt.Println(n)
	}
}
```
###### a～zまでを表示
```go
package main
import "fmt"

func main() {
	for c := 'a'; c <= 'z'; c++ {
		fmt.Printf("%c\n", c)
	}
}
```
- - -
##### Java
###### ある数字までの出力1
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		for (int i = 1; i <= 10; i++) 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();
		sc.close();
		for (int i = 1; i <= n; i++) System.out.println(i);
	}
}
```
###### 数字の受け取り1
```java
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		for (int i = 0; i < 10; i++) System.out.println(sc.nextInt());
		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();
		for (int i = 0; i < n; i++) System.out.println(sc.nextInt());
		sc.close();
	}
}
```
###### ある数をある回数表示1
```java
public class Main {
	public static void main(String[] args) {
		for (int i = 0; i < 8; i++) System.out.println(3);
	}
}
```
###### ある数をある回数表示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 k = sc.nextInt();
		sc.close();
		for (int i = 0; i < k; i++) System.out.println(n);
	}
}
```
###### a～zまでを表示
```java
public class Main {
	public static void main(String[] args) {
		for (char c = 'a'; c <= 'z'; c++) System.out.println(c);
	}
}
```
- - -
##### JavaScript
###### ある数字までの出力1
```js
for (var i = 1; i <= 10; i++) console.log(i);
```
###### ある数字までの出力2
```js
const n = Number(require("fs").readFileSync("/dev/stdin", "utf8"));
for (var i = 1; i <= n; i++) console.log(i);
```
###### 数字の受け取り1
```js
const K = require("fs").readFileSync("/dev/stdin", "utf8").split(' ').map(Number);
for (var i = 0; i < 10; i++) console.log(K[i]);
```
###### 数字の受け取り2
```js
const [N, K] =  require("fs").readFileSync("/dev/stdin", "utf8").trim().split('\n').map(s => s.split(' '));
const n = N[0];
for (var i = 0; i < n; i++) console.log(K[i]);
```
###### ある数をある回数表示1
```js
for (var i = 0; i < 8; i++) console.log(3);
```
###### ある数をある回数表示2
```js
const [N, K] = require("fs").readFileSync("/dev/stdin", "utf8").split(' ').map(Number);
for (var i = 0; i < K; i++) console.log(N);
```
###### a～zまでを表示
```js
for (let c = 'a'; c <= 'z'; c = String.fromCharCode(c.charCodeAt(0) + 1)) console.log(c);
```
- - -
##### Kotlin
###### ある数字までの出力1
```kotlin
fun main() {
	for (i in 1..10) println(i)
}
```
###### ある数字までの出力2
```kotlin
fun main() {
	for (i in 1..readLine()!!.toInt()) println(i)
}
```
###### 数字の受け取り1
```kotlin
fun main() {
	val K = readLine()!!.split(' ').map { it.toInt() }
	for (i in 0 until 10) println(K[i])
}
```
###### 数字の受け取り2
```kotlin
fun main() {
	val n = readLine()!!.toInt()
	val K = readLine()!!.split(' ').map { it.toInt() }
	for (i in 0 until n) println(K[i])
}
```
###### ある数をある回数表示1
```kotlin
fun main() {
	repeat (8) { println(3) }
}
```
###### ある数をある回数表示2
```kotlin
fun main() {
	val (n, k) = readLine()!!.split(' ').map { it.toInt() }
	repeat (k) { println(n) }
}
```
###### a～zまでを表示
```kotlin
fun main() {
	for (c in 'a'..'z') println(c)
}
```
- - -
##### PHP
###### ある数字までの出力1
```php
<?php
	for ($i = 1; $i <= 10; $i++) echo $i, PHP_EOL;
?>
```
###### ある数字までの出力2
```php
<?php
	$n = intval(fgets(STDIN));
	for ($i = 1; $i <= $n; $i++) echo $i, PHP_EOL;
?>
```
###### 数字の受け取り1
```php
<?php
	$K = array_map("intval", explode(' ', fgets(STDIN)));
	for ($i = 0; $i < 10; $i++) echo $K[$i], PHP_EOL;
?>
```
###### 数字の受け取り2
```php
<?php
	$n = intval(fgets(STDIN));
	$K = array_map("intval", explode(' ', fgets(STDIN)));
	for ($i = 0; $i < $n; $i++) echo $K[$i], PHP_EOL;
?>
```
###### ある数をある回数表示1
```php
<?php
	for ($i = 0; $i < 8; $i++) echo 3, PHP_EOL;
?>
```
###### ある数をある回数表示2
```php
<?php
	[$n, $k] = array_map("intval", explode(' ', fgets(STDIN)));
	for ($i = 0; $i < $k; $i++) echo $n, PHP_EOL;
?>
```
###### a～zまでを表示
```php
<?php
	for ($c = 'a'; $c <= 'z'; $c++) echo $c, PHP_EOL;
?>
```
- - -
##### Perl
###### ある数字までの出力1
```pl
for (my $i = 1; $i <= 10; $i++) {
	print "$i$/";
}
```
```pl
for (1..10) {
	print "$_$/";
}
```
###### ある数字までの出力2
```pl
my $n = int(<STDIN>);
for (my $i = 1; $i <= $n; $i++) {
	print "$i$/";
}
```
```pl
for (1..int(<STDIN>)) {
	print "$_$/";
}
```
###### 数字の受け取り1
```pl
my @K = map { int($_) } split ' ', <STDIN>;
for (my $i = 0; $i < 10; $i++) {
	print "$K[$i]$/";
}
```
###### 数字の受け取り2
```pl
my $n = int(<STDIN>);
my @K = map { int($_) } split ' ', <STDIN>;
for (my $i = 0; $i < $n; $i++) {
	print "$K[$i]$/";
}
```
###### ある数をある回数表示1
```pl
for (1..8) {
	print "3$/";
}
```
###### ある数をある回数表示2
```pl
my ($n, $k) = map { int($_) } split ' ', <STDIN>;
for (1..$k) {
	print "$n$/";
}
```
###### a～zまでを表示
```pl
for ('a'..'z') {
	print "$_$/";
}
```
- - -
##### Python3
###### ある数字までの出力1
```py
for i in range(1, 11):
	print(i)
```
###### ある数字までの出力2
```py
for i in range(1, int(input()) + 1):
	print(i)
```
###### 数字の受け取り1
```py
K = list(map(int, input().split()))
for i in range(10):
	print(K[i])
```
###### 数字の受け取り2
```py
n = int(input())
K = list(map(int, input().split()))
for i in range(n):
	print(K[i])
```
###### ある数をある回数表示1
```py
for _ in range(8):
	print(3)
```
###### ある数をある回数表示2
```py
n, k = map(int, input().split())
for _ in range(k):
	print(n)
```
###### a～zまでを表示
```py
for c in range(ord('a'), ord('z') + 1):
	print(chr(c))
```
- - -
##### Ruby
###### ある数字までの出力1
```rb
for i in 1..10 do
	p i
end
```
```rb
(1..10).each do |i|
	p i
end
```
###### ある数字までの出力2
```rb
for i in 1..gets.to_i do
	p i
end
```
```rb
(1..gets.to_i).each do |i|
	p i
end
```
###### 数字の受け取り1
```rb
K = gets.split.map(&:to_i)
10.times do |i|
	p K[i]
end
```
###### 数字の受け取り2
```rb
N = gets.to_i
K = gets.split.map(&:to_i)
N.times do |i|
	p K[i]
end
```
###### ある数をある回数表示1
```rb
8.times do
	p 3
end
```
###### ある数をある回数表示2
```rb
n, k = gets.split.map(&:to_i)
k.times do
	p n
end
```
###### a～zまでを表示
```rb
for c in 'a'..'z'
	puts c
end
```
```rb
('a'..'z').each do |c|
	puts c
end
```
- - -
##### Scala
###### ある数字までの出力1
```scala
import scala.io.StdIn._

object Main extends App{
	for (i <- 1 to 10) println(i)
}
```
###### ある数字までの出力2
```scala
import scala.io.StdIn._

object Main extends App{
	for (i <- 1 to readInt()) println(i) 
}
```
###### 数字の受け取り1
```scala
import scala.io.StdIn._

object Main extends App{
	val K = readLine().split(' ').map { _.toInt }
	for (i <- 0 until 10) println(K(i))
}
```
###### 数字の受け取り2
```scala
import scala.io.StdIn._

object Main extends App{
	val N = readInt()
	val K = readLine().split(' ').map { _.toInt }
	for (i <- 0 until N) println(K(i))
}
```
###### ある数をある回数表示1
```scala
import scala.io.StdIn._

object Main extends App{
	for (_ <- 0 until 8) println(3)
}
```
###### ある数をある回数表示2
```scala
import scala.io.StdIn._

object Main extends App{
	val Array(n, k) = readLine().split(' ').map { _.toInt }
	for (_ <- 0 until k) println(n)
}
```
###### a～zまでを表示
```scala
object Main extends App{
	for (c <- 'a' to 'z') println(c)
}
```
- - -
##### Swift
###### ある数字までの出力1
```swift
for i in 1...10 {
	print(i)
}
```
###### ある数字までの出力2
```swift
for i in 1...Int(readLine()!)! {
	print(i)
}
```
###### 数字の受け取り1
```swift
let K = readLine()!.split(separator: " ").compactMap { Int($0) }
for i in 0..<10 {
	print(K[i])
}
```
###### 数字の受け取り2
```swift
let n = Int(readLine()!)!
let K = readLine()!.split(separator: " ").compactMap { Int($0) }
for i in 0..<n {
	print(K[i])
}
```
###### ある数をある回数表示1
```swift
for _ in 0..<8 {
	print(3)
}
```
###### ある数をある回数表示2
```swift
let nk = readLine()!.split(separator: " ").compactMap { Int($0) }
let (n, k) = (nk[0], nk[1])
for _ in 0..<k {
	print(n)
}
```
###### a～zまでを表示
```swift
for c in "a".unicodeScalars.first!.value..."z".unicodeScalars.first!.value {
	print(String(UnicodeScalar(c)!))
}
```