常連

### 前提・実現したいこと

C言語で、入力値以下（1000以下の入力値n)の素数の最大値を求めて表示したい。

### 該当のソースコード

```ここに言語名を入力
#include<stdio.h>
int prime(int);

int main(void){
    int n,i,j;
    scanf("%d",&n);
    printf("入力値:%d\n",n);
    
        for(i=1000;i>1;i--){
            j=prime(i);
            if(j==2){
                break;
            }
        }
    
    printf("%d",i);
    
    return 0;
}

int prime(const int n){
    int i,j;
    j=0;
    for(i=2;i<=n;i++){
        if(n%i==0){
            j++;
        }
    }
    return j;
}
```

### 試したこと
素数を計算する関数のなかで入力してその入力値をもとに素数の計算をおこなうように考えてみました。
```
#include<stdio.h>
int primeNumber(int);

int main(void){
    int n,i,j;
    
    printf("入力値:%d\n",n);
    
        for(i=1000;i>1;i--){
            j=primeNumber(i);
            if(j==2){
                break;
            }
        }
    
    printf("%d",i);
    
    return 0;
}

int primeNumber(const int n){
    int i,j;
    scanf("%d",&n);
    if(n>=2&&n<=1000){
        return n;
    }
    j=0;
    for(i=2;i<=n;i++){
        if(n%i==0){
            j++;
        }
    }
    return j;
}
```
この場合だと永続的に入力を要求されるようになります。
### 補足情報（FW/ツールのバージョンなど）
visual studio codeでプログラムしています。

C言語で入力値以下の素数の最大値を求めたい

プログラムを作成していて、以下の2つのソースコードのような
Resourceアノテーションを使用した場合と、インスタンス生成をした場合とで違いがあるのか気になり
今回質問させていただきました。

```java
@Service
public class ServiceA{
    public void test1(){
          // 何らかの処理
    }
}
```
```java
@Service
public class ServiceB{
     @Resource
     private ServiceA serviceA;

     public function test2(){
                          
            serviceA.test1();    //① @Resourceを利用したメソッドへのアクセス
             
            ServiceA sA = new ServiceA(); 
            sA.test1();         //② インスタンス生成後メソッドへのアクセス

     }
}
```


ServiceBにある注釈①と注釈②の処理は、結局同じ結果になると認識しており
同じ結果になるのであれば
「2つの方法を使いわける明確な基準というのはあるのだろうか(この場合は、@Resourceを使った方がいい等)」
とふと思いました。

そこで、@Resourceを使用したメソッドへのアクセス、インスタンス生成後のメソッドへのアクセス
それぞれにメリット・デメリットがあるのではと思い調査してみましたが
ピンとくるような答えを得られなかったので、今回質問させていただきました。。

調査を踏まえた私なりの見解では
- @Resourceを使用したケース

|区分|メリット|デメリット|
|:--|:--|:--:|
|@Resourceを使用したケース|newをする手間が省ける|@Resourceが定義されているクラスの内容がメモリにずっと展開されてしまう|
|newからインスタンスを生成したケース|newをすることで、メモリ上にクラスの内容を展開するので不必要な時にクラスの内容をメモリ上に展開しなくてすむ|newしてインスタンスを生成しないとメソッドが使えない|



このようなメリット・デメリットがあると考えてますが
「全然違う」や「こういうメリット・デメリットがある」等のアドバイスをいただけると幸いです。

色々と勉強不足で恐縮ですが、よろしくお願い致します。

@Resourceとnewによるインスタンス生成の違い

[Java：「じゃんけんゲーム」でコンパイルしてもスコアが反映されない状態です・・・](https://teratail.com/questions/147558)
上記質問への回答で幸いにもコメントを頂き、ほぼ初めてのEnumを使って実装し直してみました。
実装してみたものの３つの状態グーチョキパー1,2,3しか無いものでもEnumにするメリットがいまいち分からず、
戸惑いながらの実装でこのような使い方で合っているのか自信がありません。

[コードの添削をteratailで依頼するのはいいか](https://teratail.com/questions/146435)
添削については賛否があるようですが、差し支えない範囲で改善点や間違った使い方などあればご指摘ご教示頂けると助かります。

-追記-
ご教示頂いたことを意識して書き直しました。
なるべく人や物や行動などのオブジェクト指向も意識したつもりです。
まだまだ改善するところはあるかと思いますが自分なりにはとても満足しています。
ありがとうございました。

出力結果
```
CPU1   vs CPU2
グー　 vs グー　 引分
チョキ vs チョキ 引分
パー　 vs パー　 引分
チョキ vs パー　 勝者 CPU1
グー　 vs パー　 勝者 CPU2
チョキ vs パー　 勝者 CPU1
パー　 vs パー　 引分
チョキ vs グー　 勝者 CPU2
チョキ vs グー　 連勝 CPU2
パー　 vs パー　 引分
パー　 vs チョキ 連勝 CPU2
チョキ vs パー　 勝者 CPU1

最終勝者は CPU1
```


書き直したプログラム
```java
package _memo;

import java.util.Random;

public class memo_qa147649 {

    public static void main(String[] args) {

        Player[] players = new Player[2];
        players[0] = new Player("CPU1");
        players[1] = new Player("CPU2");

        System.out.printf("%n最終勝者は %s%n", game(players, 3).name);

    }

    private static class Player {

        private String name;
        private int wins;
        private Hands hand;

        Player(String name) {
            this.name = name;
            this.wins = 0;
        }
    }

    private static Player game(Player[] players, int winCount) {
        Player winner = null;
        Player lastWinner = null;
        Player theWinner = null;

        Hands[] hand = new Hands[2];

        System.out.printf("%s   vs %s%n", players[0].name, players[1].name);

        while (theWinner == null) {

            players[0].hand = Hands.choice();
            players[1].hand = Hands.choice();

            System.out.printf("%s vs %s ", players[0].hand.text, players[1].hand.text);

            WLD wld = rsp(players[0].hand, players[1].hand);

            if (wld == WLD.DRAW) {
                System.out.println(WLD.DRAW.text);
                continue;
            }

            if (wld == WLD.WIN) {
                winner = players[0];
            } else
                winner = players[1];

            if (lastWinner == winner) {
                lastWinner = winner;
                System.out.printf("連勝 %s%n", winner.name);
            } else {
                winner.wins += 1;
                lastWinner = winner;
                System.out.printf("勝者 %s%n", winner.name);
            }

            if (winner.wins == winCount) {
                theWinner = winner;
            }
        }
        return theWinner;
    }

    private static WLD rsp(Hands hand1, Hands hand2) {
        WLD wld = WLD.DRAW;

        if (hand1 != hand2) {

            switch (hand1) {

            // player1:グー
            case ROCK:
                if (hand2 == Hands.SCISSORS) {
                    wld = WLD.WIN;
                } else {
                    wld = WLD.LOSE;
                }
                break;

            // player1:チョキ
            case SCISSORS:
                if (hand2 == Hands.PAPER) {
                    wld = WLD.WIN;
                } else {
                    wld = WLD.LOSE;
                }
                break;

            // player1:パー
            case PAPER:
                if (hand2 == Hands.ROCK) {
                    wld = WLD.WIN;
                } else {
                    wld = WLD.LOSE;
                }
                break;
            }
        }
        return wld;
    }

    private enum WLD {
        DRAW(-1, "引分"), LOSE(0, "負け"), WIN(1, "勝ち");
        private final int id;
        private final String text;

        private WLD(final int id, final String text) {
            this.id = id;
            this.text = text;
        }
    }

    private enum Hands {
        ROCK(0, "グー　"), SCISSORS(1, "チョキ"), PAPER(2, "パー　");

        private final int id;
        private final String text;

        private Hands(final int id, final String text) {
            this.id = id;
            this.text = text;
        }

        private static Hands choice() {
            //r:1:グー s:2:チョ p:3:パー
            Random rnd = new Random();
            return getHands(rnd.nextInt(3));
        }

        private int getInt() {
            return this.id;
        }

        private String getText() {
            return this.text;
        }

        private static Hands getHands(final int id) {
            Hands[] Handss = Hands.values();
            for (Hands hand : Handss) {
                if (hand.getInt() == id) {
                    return hand;
                }
            }
            return null;
        }
    }
}
```


-以下初期プログラム-
```java
package _memo;

import java.util.Random;

import _memo.Enums.Jnk;

public class qa147558 {

    private static int rsp(Jnk h1, Jnk h2) {
        int win = -1;

        int a = Jnk.p.getInt();
        if (h1 != h2) {

            switch (h1) {

            case r:
                // =1=グー
                if (h2 == Jnk.s) {
                    win = 0;
                } else {
                    win = 1;
                }
                break;
            case s:
                // =2=チョ
                if (h2 == Jnk.p) {
                    win = 0;
                } else {
                    win = 1;
                }
                break;
            case p:
                // =3=パー
                if (h2 == Jnk.r) {
                    win = 0;
                } else {
                    win = 1;
                }
                break;
            }
        }
        return win;
    }

    public static void main(String[] args) {

        int winner = -1;
        int lastwin = -2;
        int[][] players = { { 0, 0 }, { 1, 0 } };

        String[] m_p = { "CPU1", "CPU2" };
        System.out.printf("%svs%s%n", m_p[0], m_p[1]);

        Random rnd = new Random();

        while (winner < 0) {

            //Enum型 r:1:グー s:2:チョ p:3:パー
            Jnk[] hand = new Jnk[2];
            hand[0] = Jnk.getJnk(rnd.nextInt(3) + 1);
            hand[1] = Jnk.getJnk(rnd.nextInt(3) + 1);

            int win = rsp(hand[0], hand[1]);

            System.out.printf("%svs%s ", hand[0].getText(), hand[0].getText());

            if (win == -1) {
                System.out.println("引分");
                continue;
            }
            if (lastwin == win) {
                lastwin = -2;
                System.out.printf("連勝 %s%n", m_p[win]);
            } else {
                players[win][1] += 1;
                lastwin = win;
                System.out.printf("勝者 %s%n", m_p[win]);
            }
            if (players[win][1] == 3) {
                winner = win;
            }
        }
        System.out.println();
        System.out.printf("最終勝者は %s%n", m_p[winner]);
    }
}
```
Enum
```java
package _memo;

public class Enums {
    public static enum Jnk {
        //出力の桁合わせで「チョキ」は「チョ」としています。
        r(1, "グー"), s(2, "チョ"), p(3, "パー");

        private final int id;
        private final String text;

        private Jnk(final int id, final String text) {
            this.id = id;
            this.text = text;
        }
        public int getInt() {
            return this.id;
        }
        public String getText() {
            return this.text;
        }
        public static Jnk getJnk(final int id) {
            Jnk[] Jnks = Jnk.values();
            for (Jnk jnk : Jnks) {
                if (jnk.getInt() == id) {
                    return jnk;
                }
            }
            return null;
        }
    }
}
```

Java Enum （ほぼ初めての）使い方は合っていますか？

初めて質問させていただきます。
最近Rubyを触り始めた初心者です。
現在、2つのCSVファイルから特定の列だけを抜き出して新しいCSVファイルに出力するというプログラムをRubyで組みたいと考えているのですが、どのようなプログラムを組めばいいか全くわかりません。
イメージとしては、
![元データ][WIDTH:300](79627f7621ae68d241a5b038af8e6f08.png)
![元データ][WIDTH:300](cebaf819b49e975cd5b5c8561702aa5b.png)
上記のような2つのCSVファイルを下記のように新しいファイルに出力したいのです。
どうかご教授よろしくお願いします。
![新しいファイル][WIDTH:400](466ffb078b0f97acda3c7b5be868e448.png)

[Ruby}2つのCSVから特定の列だけを抜き出して、新しいCSVに出力

このソースコードは変数xが入力された値を格納しint型のyへ渡しているという認識です。
初歩的な質問かもしれませんが、なぜforの中でさらにwhileで繰り返す必要があるのかわかりません。
for、whileの中のコードの理解が出来ていないです。
そもそも、繰り返し処理を記述しなければいけないのでしょうか？
条件分岐でもこのプログラムは実現出来る気がするのですが、解説お願いします。


###該当のソースコード
```
	public static void main(String[] args) {

		System.out.println("数値を入力して下さい");
		Scanner num = new Scanner(System.in);
		int x = num.nextInt();
		int y = x;

		for (int i = 2; x > i; i++) {
			while ((y % i) == 0) {
				System.out.println(i);
				y = y / i;
			}
		}
	}
}
```

２以上の数値で素因数分解を求めるプログラム

いつもお世話になっております。

ちょっとした思いつきでFizzBuzz問題をcase文で解けないかと書いてみました。
```ruby
def fizz_buzz(n)
  case
  when (n % 15).zero?
    'FizzBuzz'
  when (n % 3).zero?
    'Fizz'
  when (n % 5).zero?
    'Buzz'
  else
    n
  end
end


(1..15).each do |n|
  puts fizz_buzz(n)
end
```
正常に動作すするのですが、Rubocopにcase文の対象オブジェクト名なしで書いてはいけない、と注意されます。

正しいcase文を使ったFizzBuzzの書き方を教えてください。