迭代R中的变量名

Question

I'm trying to shorten my code and make it a bit more efficient.

My use case is this:

It will (roughly) take input from a user in order to describe the type of data basically. Then, it takes count of how many of each type.

As it stands right now, it is very inefficient but it works. Currently, my code is this:

#############
#1 = 2g4    #
#2 = 5g     #
#3 = dual   #
#############

num_of_Antennas = 4

ant1 = 1
ant2 = 2
ant3 = 2
ant4 = 1


#initialize each count to 0
count2g4 = 0
count5g = 0
countDual = 0

if (num_of_Antennas==4){


  #check type for ant1
  if (ant1==1){
    count2g4 = count2g4+1
  } else if (ant1==2){
    count5g = count5g+1
  } else if (ant1==3){
    countDual = countDual+1;
  } 
  ###############

  #check type for ant2  
  if (ant2==1){
    count2g4 = count2g4 +1
  } else if (ant2==2){
    count5g = count5g +1
  } else if (ant2==3){
    countDual = countDual +1;
  }
  ###############

  #check type for ant3  
  if (ant3==1){
    count2g4 = count2g4 +1
  } else if (ant3==2){
    count5g = count5g +1
  } else if (ant3==3){
    countDual = countDual +1;
  }
  ###############

  #check type for ant4  
  if (ant4==1){
    count2g4 = count2g4 +1
  } else if (ant4==2){
    count5g = count5g +1
  } else if (ant4==3){
    countDual = countDual +1;
  }
  ###############




} else if (num_of_Antennas==3){
  #check type for ant1
  if (ant1==1){
    count2g4 = count2g4+1
  } else if (ant1==2){
    count5g = count5g+1
  } else if (ant1==3){
    countDual = countDual+1;
  } 
  ###############

  #check type for ant2  
  if (ant2==1){
    count2g4 = count2g4 +1
  } else if (ant2==2){
    count5g = count5g +1
  } else if (ant2==3){
    countDual = countDual +1;
  }
  ###############

  #check type for ant3  
  if (ant3==1){
    count2g4 = count2g4 +1
  } else if (ant3==2){
    count5g = count5g +1
  } else if (ant3==3){
    countDual = countDual +1;
  }
  ###############




} else if (num_of_Antennas==2){
  #check type for ant1
  if (ant1==1){
    count2g4 = count2g4+1
  } else if (ant1==2){
    count5g = count5g+1
  } else if (ant1==3){
    countDual = countDual+1;
  } 
  ###############

  #check type for ant2  
  if (ant2==1){
    count2g4 = count2g4 +1
  } else if (ant2==2){
    count5g = count5g +1
  } else if (ant2==3){
    countDual = countDual +1;
  }
  ###############

} else if (num_of_Antennas==1){
  #check type for ant1
  if (ant1==1){
    count2g4 = count2g4+1
  } else if (ant1==2){
    count5g = count5g+1
  } else if (ant1==3){
    countDual = countDual+1;
  } 




} else (print("ERROR, Num of antennas = 0"))

I'm a bit of a noob when it comes to coding, but I'm sure theres a better way of doing this.

I started playing with the idea of turning it into some sort of parametric function, but I'm not finding a good way of doing that just yet. So how can I go about doing this without compromising flexibility? I'm also looking to expand this to a 12 antenna maximum, which will increase the number of code for such a simple task EXPONENTIALLY.

Thanks in advance! Cody

EDIT: As has been pointed out, using factors will be extremely beneficial, but it still leaves me looking for some sort of raw user interface thats a bit easier to follow than just filling in a vector. I'd like something similar to this:

#(not working)
ant1 = 1
ant2 = 2
ant3 = 3
ant4 = 1


data = paste(ant1, ant2, ant3, ant4 sep = ",")
data


  ant <- c(data)

  ant_f <- factor(ant, levels=c(1:3),labels =c("2G4", "5G", "Dual"))
  table(ant_f)

Answer 1

Thank you for providing a snippet of your code. I hope I understood correctly what you are trying to do. I suggest you keep antennas in a vector. Length of the vector will tell you how many antennas you are trying to count. Here's an example for 12 antennas.

#ant <- c(1,2,2,1)
ant <- c(1,2,2,1,3,2,2,3,1,1,3,2)

ant_f <- factor(ant, levels=c(1:3),labels =c("2g", "5g", "dual"))
table(ant_f)
#> 
#> ant_f
#>   2g   5g dual 
#>    4    5    3 

Basically all you need to do it so define interpretation of possible values (factors should work nicely in this case), which will serve as a dictionary. Then just count occurrences with table()

You can refer to individual antennas by vector subsetting. Because it is a factor, it will carry its label with it.

ant_f[5]
#> [1] dual
#> Levels: 2g 5g dual