Как предотвратить повторение операторов в цикле for

Question

Я работаю над проектом, который содержит несколько операторов if внутри 2 для циклов. То, что я пытаюсь сделать, это каждый, если заявление выполнить только один раз, когда она верна Вот мой код

for (int i = 0; i < 4; i++) 
     { 
      for (int k = 0; k < 5; k++) 
      { 
       if (PokerCard[k] == two[i]) 
       { 
        PokerTwo++; 
       } 
       if (PokerTwo == 2) 
       { 
        cash = cash + 10; 
        winnings = winnings + 10; 
        Cash.Text = Convert.ToString(cash); 
        Winnings.Text = Convert.ToString(winnings); 
        PairWin.BackColor = Color.Red; 
        Winner.Visible = true; 
        return; 
       } 
       if (PokerCard[k] == three[i]) 
       { 
        PokerThree++; 
       } 
       if (PokerThree == 2) 
       { 
        cash = cash + 10; 
        winnings = winnings + 10; 
        Cash.Text = Convert.ToString(cash); 
        Winnings.Text = Convert.ToString(winnings); 
        PairWin.BackColor = Color.Red; 
        Winner.Visible = true; 
        return; 
       } 
       if (PokerCard[k] == four[i]) 
       { 
        PokerFour++; 
       } 
       if (PokerFour == 2) 
       { 
        cash = cash + 10; 
        winnings = winnings + 10; 
        Cash.Text = Convert.ToString(cash); 
        Winnings.Text = Convert.ToString(winnings); 
        PairWin.BackColor = Color.Red; 
        Winner.Visible = true; 
        return; 
       } 
       if (PokerCard[k] == five[i]) 
       { 
        PokerFive++; 
       } 
       if (PokerFive == 2) 
       { 
        cash = cash + 10; 
        winnings = winnings + 10; 
        Cash.Text = Convert.ToString(cash); 
        Winnings.Text = Convert.ToString(winnings); 
        PairWin.BackColor = Color.Red; 
        Winner.Visible = true; 
        return; 
       } 
       if (PokerCard[k] == six[i]) 
       { 
        PokerSix++; 
       } 
       if (PokerSix == 2) 
       { 
        cash = cash + 10; 
        winnings = winnings + 10; 
        Cash.Text = Convert.ToString(cash); 
        Winnings.Text = Convert.ToString(winnings); 
        PairWin.BackColor = Color.Red; 
        Winner.Visible = true; 
        return; 
       } 
       if (PokerCard[k] == seven[i]) 
       { 
        PokerSeven++; 
       } 
       if (PokerSeven == 2) 
       { 
        cash = cash + 10; 
        winnings = winnings + 10; 
        Cash.Text = Convert.ToString(cash); 
        Winnings.Text = Convert.ToString(winnings); 
        PairWin.BackColor = Color.Red; 
        Winner.Visible = true; 
        return; 
       } 
       if (PokerCard[k] == eight[i]) 
       { 
        PokerEight++; 
       } 
       if (PokerEight == 2) 
       { 
        cash = cash + 10; 
        winnings = winnings + 10; 
        Cash.Text = Convert.ToString(cash); 
        Winnings.Text = Convert.ToString(winnings); 
        PairWin.BackColor = Color.Red; 
        Winner.Visible = true; 
        return; 
       } 
       if (PokerCard[k] == nine[i]) 
       { 
        PokerNine++; 
       } 
       if (PokerNine == 2) 
       { 
        cash = cash + 10; 
        winnings = winnings + 10; 
        Cash.Text = Convert.ToString(cash); 
        Winnings.Text = Convert.ToString(winnings); 
        PairWin.BackColor = Color.Red; 
        Winner.Visible = true; 
        return; 
       } 
       if (PokerCard[k] == ten[i]) 
       { 
        PokerTen++; 
       } 
       if (PokerTen == 2) 
       { 
        cash = cash + 10; 
        winnings = winnings + 10; 
        Cash.Text = Convert.ToString(cash); 
        Winnings.Text = Convert.ToString(winnings); 
        PairWin.BackColor = Color.Red; 
        Winner.Visible = true; 
        return; 
       } 
       if (PokerCard[k] == jack[i]) 
       { 
        PokerJack++; 
       } 
       if (PokerJack == 2) 
       { 
        cash = cash + 10; 
        winnings = winnings + 10; 
        Cash.Text = Convert.ToString(cash); 
        Winnings.Text = Convert.ToString(winnings); 
        PairWin.BackColor = Color.Red; 
        Winner.Visible = true; 
        return; 
       } 
       if (PokerCard[k] == queen[i]) 
       { 
        PokerQueen++; 
       } 
       if (PokerQueen == 2) 
       { 
        cash = cash + 10; 
        winnings = winnings + 10; 
        Cash.Text = Convert.ToString(cash); 
        Winnings.Text = Convert.ToString(winnings); 
        PairWin.BackColor = Color.Red; 
        Winner.Visible = true; 
        return; 
       } 
       if (PokerCard[k] == king[i]) 
       { 
        PokerKing++; 
       } 
       if (PokerKing == 2) 
       { 
        cash = cash + 10; 
        winnings = winnings + 10; 
        Cash.Text = Convert.ToString(cash); 
        Winnings.Text = Convert.ToString(winnings); 
        PairWin.BackColor = Color.Red; 
        Winner.Visible = true; 
        return; 
       } 
       if (PokerCard[k] == ace[i]) 
       { 
        PokerAce++; 
       } 
       if (PokerAce == 2) 
       { 
        cash = cash + 10; 
        winnings = winnings + 10; 
        Cash.Text = Convert.ToString(cash); 
        Winnings.Text = Convert.ToString(winnings); 
        PairWin.BackColor = Color.Red; 
        Winner.Visible = true; 
        return; 
       } 
      } 
     } 

Как вы можете видеть, когда если утверждение верно, то это добавит 10 к выигрышу, но я только хотите, чтобы он делал это один раз, поэтому, когда он возвращается через цикл, он не будет запускать этот же оператор if, но может быть другой, если он станет истинным. Кроме того, я попытался использовать возврат в конце инструкции if, который работает до некоторой степени, но это позволит только выполнить оператор if, и с проектом, над которым я работаю, мне иногда нужно, чтобы он прошел через два из if заявления. удаление возвращаемого значения приведет к тому, что он перейдет через более операторы if, но также будет запускать один и тот же один раз, что я не хочу. любая помощь будет оценена. Спасибо

Answer 1

Если вы хотите выполнить каждый, если только один раз для каждой итерации 'i', тогда вы должны объявить счетчик для каждого, если; инициализируйте все с помощью 0 после оператора внешнего цикла и увеличивайте соответствующий счетчик после выполнения каждого оператора if. Например:

for (int i = 0; i < 4; i++) 
    { 
     c1=0; 
     c2=0; 
     for (int k = 0; k < 5; k++) 
     { 
      if (PokerCard[k] == two[i] && c1==0) 
      { 
       PokerTwo++; 
       c1++; 
      } 
      if (PokerTwo == 2 && c2==0) 
      { 
       cash = cash + 10; 
       winnings = winnings + 10; 
       Cash.Text = Convert.ToString(cash); 
       Winnings.Text = Convert.ToString(winnings); 
       PairWin.BackColor = Color.Red; 
       Winner.Visible = true; 
       c2++; 
      } 
      } 
      } 

А также удалить оператор возврата.

Answer 2

Надеется, что это поможет,

установить переменный флаг значение по умолчанию говорят 0 внутри вашего, если, который будет проверять, если флаг равен 0, то только запустить необходимые заявления, и внутри этого блока сам установить переменный флаг в ненулевое значение этого ограничения блока, который будет выполняться только один раз в ближайшем окончании итерации, а если выполняются

примера блочных ПОЛУЧИТЬ в

Block1_Flag=0 
continue_run=0 
//Statement_Block1 
while(condition){ 
{ 
if(Block1_Flag == 0) 
{ 
//so this bolck executed one so need to execute this again hence set Flag to 1 or any other number other then 1 
Flag = 1 
continue_run = 1 
} 
if(continue_run == 0){ 
return 
} 
} 

рассматривать это как родовую логику, вы можете обратиться к проблеме

Answer 3

Итак, у меня есть несколько предложений по очистке кода.

Во-первых, использовать массив для подсчета карт, вместо PokerTwo, PokerThree и т.д. Это позволит вам заменить все эти 13 if заявления с одной петлей, так как он выглядит как действие является одинаковым для каждого ранга ,

Во-вторых, если вы храните ваши карты как int с, от 0-51, вы можете использовать PokerCard/4, чтобы получить костюм и PokerCard % 13, чтобы получить звание (если вы сортировать по масти, а затем ранга. Если сортировать по рангу затем костюм, используйте PokerCard % 4 и PokerCard/13). Теперь вы можете избавиться от внешней петли for, а также от two, three и т. Д. Массивов.

В-третьих, поскольку вы хотите только один раз выполнить каждый оператор if, переместите их за пределы основного цикла, так что вы будете проверять только один раз после того, как вы сделаете подсчет, а не после каждой карты.

Это уменьшает ваш код на что-то вроде

var CardCount = new int[13]; 

for (int k = 0; k < 5; k++) 
{ 
    CardCount[PokerCard[k] % 13]++; 
} 
for (int c = 0; c < 12; c++) 
{ 
    if (CardCount[c] >= 2) 
    { 
     //do winning stuff 
    } 
} 

Это намного проще в управлении.

Answer 4

Хмм, не пытаясь понять, что вы пытаетесь сделать в точности, я могу ответить на ваш вопрос, хотя и не «правильный» ответ, это также неверный ответ. (я бы сильно советую использовать другой алгоритм/подход, чем вы используете, - переосмысление того, как вы решаете эту проблему, это просто не выглядит правильным, многократно повторяющимся кодом, ненужными ветвями и будет очень сложно поддерживать и т. д., я отвлекаюсь ..)

Чтобы ответить на ваш вопрос буквально;

Самый простой способ заключается в том, чтобы просто добавить проверку, если эта инструкция if выполнена. (Я предполагаю, что вы не хотите запускать инструкции «if» более одного раза, пока вы находитесь внутри внешнего цикла. Я также предполагаю, что вы do намереваетесь, чтобы скомпилированные операторы if (инкрементирование) выполнялись более одного раза) ,

// I'm assuming this code adds winnings for any pairs of cards found? 
var PairedWinFlags = new bool[13]; // 13 cards 

// Your outer loop 
for (int i = 0; i < 4; i++) 
{ 
    for (int k = 0; k < 5; k++) 
    { 
     ... 
     if (PokerCard[k] == two[i]) 
     { 
      PokerTwo++; 
     } 
     if (PokerTwo == 2 && !PairedWinFlags[1])) 
     { 
      PairedWinFlags[1] = true; // Set this card flag to true 
      cash = cash + 10; 
      winnings = winnings + 10; 
      Cash.Text = Convert.ToString(cash); 
      Winnings.Text = Convert.ToString(winnings); 
      PairWin.BackColor = Color.Red; 
      Winner.Visible = true; 
      return; 
     } 
     ... 

     // ... Do the same for all other card types 

     if (PokerAce == 2 && !PairedWinFlags[0])) 
     { 
      PairedWinFlags[0] = true; 
     ... 

     if (PokerQueen == 2 && !PairedWinFlags[11])) 
     { 
      PairedWinFlags[11] = true; 
     ... 
    } 
} 

Честно говоря, я бы посоветовал против этого решения, если вы хотите сохранить этот код и, возможно, сохранить/понять. Если да, то вы должны начать комментировать через код осмысленно - и, возможно, задать вопрос, такие как

Любой путь удачи :)

Answer 5

Ваш код «как я считаю пары целых чисел в массиве?» явно нужен шаблон strategy.

Поскольку я не знаю вашей бизнес-логики, я буду использовать общие имена для классов/интерфейсов; пожалуйста, настройте их на свои нужды. Другое предположение, которое я буду делать для упрощения кода, - это доступ ко всем свойствам вашего кода из другого класса. Опять же, настройте его на свой код.

Теперь опишите код. Объявите интерфейс для стратегии:

public interface IStrategy 
{ 
    bool IsApplicable(YourClass instance); 

    void Apply(YourClass instance); 
} 

Теперь для каждого if в вашем коде создать класс, который реализует IStrategy:

public class PokerTwoStrategy : IStrategy 
{ 
    public bool IsApplicable(YourClass instance) 
    { 
     return instance.PokerTwo == 2; 
    } 

    public void Apply(YourClass instance) 
    { 
     instance.cash = cash + 10; 
     instance.winnings = winnings + 10; 
     instance.Cash.Text = Convert.ToString(cash); 
     instance.Winnings.Text = Convert.ToString(winnings); 
     instance.PairWin.BackColor = Color.Red; 
     instance.Winner.Visible = true; 
    } 
} 

После создания стратегий, в YourClass создать коллекцию IStrategy случаев и в вашем методе итерации по этой коллекции и применять стратегию, которая может быть применена:

public class YourClass 
{ 
    private readonly IEnumerable<IStrategy> _strategies; 

    // Inject the strategies using DI container or build them manually 
    public YourClass(IEnumerable<IStrategy> strategies) 
    { 
     _strategies = strategies; 
    } 

    public void YourMethod() 
    { 
     for(int i = 0; i < 4; i++) 
     { 
      for(int k = 0; k < 5; k++) 
      { 
       _strategies.Where(s=>s.IsApplicable(this)) 
        .ToList() 
        .ForEach(s => s.Apply(this)); 
      } 
     } 
    } 
} 

Теперь, хотя вы ввели больше типов, ваш код более удобен в обслуживании и легче читать/понимать.