A couple of years ago, my friend wanted to learn programming, so I was giving her a hand with resources and reviewing her code. She got to the part on adding code comments, and wrote the now-infamous line,

i = i + 1 #this increments i

We’ve all written superflouous comments, especially as beginners. And it’s not even really funny, but for whatever reason, somehow we both remember this specific line years later and laugh at it together.

Years later (this week), to poke fun, I started writing sillier and sillier ways to increment i:

Beginner level:

# this increments i:
x = i 
x = x + int(True)
i = x

Beginner++ level:

# this increments i:
def increment(val):
   for i in range(val+1):
      output = i + 1
   return output

Intermediate level:

# this increments i:
class NumIncrementor:
	def __init__(self, initial_num):
		self.internal_num = initial_num

	def increment_number(self):
		incremented_number = 0
		# we add 1 each iteration for indexing reasons
		for i in list(range(self.internal_num)) + [len(range(self.internal_num))]: 
			incremented_number = i + 1 # fix obo error by incrementing i. I won't use recursion, I won't use recursion, I won't use recursion

		self.internal_num = incremented_number

	def get_incremented_number(self):
		return self.internal_num

i = input("Enter a number:")

incrementor = NumIncrementor(i)
incrementor.increment_number()
i = incrementor.get_incremented_number()

print(i)

Since I’m obviously very bored, I thought I’d hear your take on the “best” way to increment an int in your language of choice - I don’t think my code is quite expert-level enough. Consider it a sort of advent of code challenge? Any code which does not contain the comment “this increments i:” will produce a compile error and fail to run.

No AI code pls. That’s no fun.

  • Kogasa@programming.dev
    0·
    2 months ago

    Let f(x) = 1/((x-1)^(2)). Given an integer n, compute the nth derivative of f as f^((n))(x) = (-1)(n)(n+1)!/((x-1)(n+2)), which lets us write f as the Taylor series about x=0 whose nth coefficient is f^((n))(0)/n! = (-1)^(-2)(n+1)!/n! = n+1. We now compute the nth coefficient with a simple recursion. To show this process works, we make an inductive argument: the 0th coefficient is f(0) = 1, and the nth coefficient is (f(x) - (1 + 2x + 3x^(2) + … + nx(n-1)))/x(n) evaluated at x=0. Note that each coefficient appearing in the previous expression is an integer between 0 and n, so by inductive hypothesis we can represent it by incrementing 0 repeatedly. Unfortunately, the expression we’ve written isn’t well-defined at x=0 since we can’t divide by 0, but as we’d expect, the limit as x->0 is defined and equal to n+1 (exercise: prove this). To compute the limit, we can evaluate at a sufficiently small value of x and argue by monotonicity or squeezing that n+1 is the nearest integer. (exercise: determine an upper bound for |x| that makes this argument work and fill in the details). Finally, evaluate our expression at the appropriate value of x for each k from 1 to n, using each result to compute the next, until we are able to write each coefficient. Evaluate one more time and conclude by rounding to the value of n+1. This increments n.

      • Kogasa@programming.dev
        0·
        2 months ago

        The argument describes an algorithm that can be translated into code.

        1/(1-x)^(2) at 0 is 1 (1/(1-x)^(2) - 1)/x = (1 - 1 + 2x - x^(2))/x = 2 - x at 0 is 2 (1/(1-x)^(2) - 1 - 2x) = ((1 - 1 + 2x - x^(2) - 2x + 4x^(2) - 2x(3))/x(2) = 3 - 2x at 0 is 3

        and so on

  • Azzu@lemm.ee
    0·
    2 months ago
    int toIncrement = ...;
int result;
do {
  result = randomInt();
} while (result != (toIncrement + 1));
print(result);
  • Admiral Patrick@dubvee.orgEnglish
    0·
    2 months ago
    // this increments i:

function increment(val:number): number {
  for (let i:number = 1; i <= 100; i = i +1) {
    val = val + 0.01
  }

  return Math.round(val)
}


    let i = 100
i = increment(i)
// 101
    • Susaga@sh.itjust.worksEnglish
      0·
      2 months ago

      This should get bonus points for incrementing i by 1 as part of the process for incrementing i by 1.

    • Ace@feddit.ukOP
      0·
      2 months ago

      but if i gets randomly bitflipped, wouldn’t i != i+1 still be false? It would have to get flipped at exactly the right time, assuming that the cpu requests it from memory twice to run that line? It’d probably be cached anyway.

      I was thinking you’d need to store the original values, like x=i and y=i+1 and while x != y etc… but then what if x or y get bitflipped? Maybe we hash them and keep checking if the hash is correct. But then the hash itself could get bitflipped…

      Thinking too many layers of redundancy deep makes my head hurt. I’m sure there’s some interesting data integrity computer science in there somewhere…

  • fool@programming.dev
    0·
    2 months ago

    First, imagine a number in JavaScript. (Bit of a nail biter here, huh?)

    let i = 5

    Then, we will construct an incrementor. This is really simple: here is the method.

    1. Make a bracket-string-centric version of eval().
    []["filter"]["constructor"]("return i+1")()
    1. Reconstruct stringy eval() by using +[] as 0, +!+[] as 1, and implicit conversions as ways to create strings. For example, ‘false’ is (![]+[]), so ‘f’ is (![]+[])[+[]].
    [][
  (![] + [])[+[]] + // f
  ([![]] + [][[]])[+!+[] + [+[]]] + // i
  (![] + [])[!+[] + !+[]] + // l
  (!![] + [])[+[]] + // t
  (!![] + [])[!+[] + !+[] + !+[]] + // e
  (!![] + [])[+!+[]] // r
][
  ([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+ // c
  (!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+ // o
  ([][[]]+[])[+!+[]]+ // n
  (![]+[])[!+[]+!+[]+!+[]]+ // s
  (!![]+[])[+[]]+ // t
  (!![]+[])[+!+[]]+ // r
  ([][[]]+[])[+[]]+ // u
  ([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+ // c
  (!![]+[])[+[]]+ // t
  (!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+ // o
  (!![]+[])[+!+[]] // r
]("return i+1")()
    1. Draw the rest of the fucking owl. Final code:
    let i = 5; // haha yay

[][
  (![] + [])[+[]] + // f
  ([![]] + [][[]])[+!+[] + [+[]]] + // i
  (![] + [])[!+[] + !+[]] + // l
  (!![] + [])[+[]] + // t
  (!![] + [])[!+[] + !+[] + !+[]] + // e
  (!![] + [])[+!+[]] // r
][
  ([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+ // c
  (!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+ // o
  ([][[]]+[])[+!+[]]+ // n
  (![]+[])[!+[]+!+[]+!+[]]+ // s
  (!![]+[])[+[]]+ // t
  (!![]+[])[+!+[]]+ // r
  ([][[]]+[])[+[]]+ // u
  ([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+ // c
  (!![]+[])[+[]]+ // t
  (!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+ // o
  (!![]+[])[+!+[]] // r
](
  (!![]+[])[+!+[]]+ // r
  (!![]+[])[!+[]+!+[]+!+[]]+ // e
  (!![]+[])[+[]]+ // t
  ([][[]]+[])[+[]]+ // u
  (!![]+[])[+!+[]]+ // r
  ([][[]]+[])[+!+[]]+ // n
  (+[![]]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+!+[]]]+ // ' '
  ([![]]+[][[]])[+!+[]+[+[]]]+ // i
  (+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]])+[])[!+[]+!+[]]+ // +
  +!+[] // 1
)()
// no virus i swear. execute arbitrary code in your browser console.

    Anyway, that’s just everyday JS work. It’s like step 5 after resizing the button, but a bit before centering the div.

    based on this. some translation methods done differently.

  • j4k3@lemmy.worldEnglish
    0·
    2 months ago

    74181

    (A + 1)
    A0:A3 = (Input Register)
    S0:S3 = Low
    Mode = Low
    CaryN = High
    Q1:Q4 = (Output)

    https://en.wikipedia.org/wiki/74181

    .

    Funny enough, it is one of the understood operations that I did not integrate on the truth table on-chip. I had some ideas on extra syntax, but the point is to avoid needing to look at reference docs as much as possible and none of my ideas for this one were intuitive enough this satisfy me.

    • palordrolap@fedia.io
      0·
      2 months ago

      This is actually the correct way to do it in JavaScript, especially if the right hand side is more than 1.

      If JavaScript thinks i contains a string, and let’s say its value is 27, i += 1 will result in i containing 271.

      Subtraction doesn’t have any weird string-versus-number semantics and neither does unary minus, so i -=- 1 guarantees 28 in this case.

      For the increment case, ++ works properly whether JavaScript thinks i is a string or not, but since the joke is to avoid it, here we are.

  • letsgo@lemm.eeEnglish
    0·
    2 months ago

    C++:

    int i = 5;
i ^= printf("The initial value of i is %d\n", i)^
printf("i=i+1; // this increments i\n")^
printf("Trigger very obscure FPU bug %c",(int)((float)8.5953287712*(double)8.5953287713-'?'))/10;
printf("i has now been incremented by 1 : %d\n", i);

    Output:

    The initial value of i is 5  
i=i+1; // this increments i  
Trigger very obscure FPU bug  
i has now been incremented by 1 : 6

    I didn’t test other values but they’re probably OK.

    • Eranziel@lemmy.world
      0·
      2 months ago

      I didn’t test other values but they’re probably OK.

      Excellent work, thanks for the laugh.