74181

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

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

My favourite one is:

i -=- 1

// 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

Why not wait for a random bit flip to increment it?

int i = 0;
while (i != i + 1);
//i is now incremented

That’s a tricky problem, I think you might be able to create a script that increments it recursively.

I’m sure this project that computes Fibonacci recursively spawning several docker containers can be tweaked to do just that.

https://github.com/dgageot/fiboid

I can’t think of a more efficient way to do this.

// this increments i
var i = new AtomicInteger(0);
i.increment(); 

int toIncrement = ...;
int result;
do {
  result = randomInt();
} while (result != (toIncrement + 1));
print(result);

Your intermediate increment looks like serious JavaScript code I’ve seen.

// C++20

#include <concepts>
#include <cstdint>

template <typename T>
concept C = requires (T t) { { b(t) } -> std::same_as<int>; };

char b(bool v) { return char(uintmax_t(v) % 5); }
#define Int jnt=i
auto b(char v) { return 'int'; }

// this increments i:
void inc(int& i) {
  auto Int == 1;
  using c = decltype(b(jnt));
  i += decltype(jnt)(C<decltype(b(c))>);
}

I’m not quite sure it compiles, I wrote this on my phone and with the sheer amount of landmines here making a mistake is almost inevitable.

Typing on mobile please excuse.

i = 0
while i != 1:
  pass

# i is now 1

++i;

i = max(sorted(range(val, 0, -1))) + 2

Everything is easier in PHP!

<?php

/**
 * This increments $i
 * 
 * @param int $i The number to increment.
 *
 * @return int The incremented number.
 */
function increment(int $i) {
  $factor = 1;
  $adjustment = 0;
  if ($i < 0) {
    $factor *= -1;
    $adjustment = increment(increment($adjustment));
  }
  $i *= $factor;
  $a = array_fill(1, $i, 'not_i');
  if ($i === 0) {
    array_push($a, 'not_i');
  }
  array_push($a, $i);
  return array_search($i, $a, true) * $factor + $adjustment;
}

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.

Create a python file that only contains this function

def increase_by_one(i):
    # this increments i
    f=open(__file__).read()
    st=f[28:-92][0]
    return i+f.count(st)

Then you can import this function and it will raise an index error if the comment is not there, coming close to the most literal way

Any code which does not contain the comment “this increments i:” will produce a compile error and fail to run.

could be interpreted in python