Mrrl

Записать условие в виде (a+1)*(b+1) == n*(n+1)/2+1 = N, и для чисел a от (n+1)/2 до n проверить, делится ли N на a+1. Если делится, то b=N/(a+1)-1. На всякий случай, проверить, что b < n+1.
При желании, перебор можно сократить примерно в 12 раз. Но тогда вместо проверки делимости надо будет быстро проверять, является ли число полным квадратом - что может быть не очень просто.

Страшноватый алгоритм...
Сначала создаём строку, содержащую всю информацию из списка (то есть, нас вообще не волнует, что где-то была структура "список" - мы его убиваем, чтобы потом построить заново из сырых данных)...
Потом превращаем строку в массив из строк! С помощью Split, разделяя её по пробелам!!! Зачем? Почему сразу не заполнить массив строк? А если строки в списке будут сами содержать пробелы, как "Новый список:"?
Потом разворачиваем этот массив! Зачем? А потому, что нас не научили вставлять элементы в конец списка, мы можем вставить их только в начало. Проходить массив в обратном порядке, вероятно, тоже не умеем.
Потом, уже при построении списка, у нас вызывается загадочная функция addNode(). Что она делает - неизвестно, поскольку, если бы она вставляла новый элемент после current - её бы вызвали ещё в двух местах кода, а не писали бы её код в развёрнутом виде.
И, наконец, независимо от того, что делает addNode(), элемент tt[n+1] будет вставлен в список дважды.

static Node SwapFirst(Node c) {
    if(c==null || c.next==null) return c;
    Node result=c.next;
    c.next=result.next;
    result.next=c;
    return result;
}
public static Node reverseMyList (Node c,int n) {
   if(n==0) return SwapFirst(c);
   Node d=c;
   for(;n>1 && d.next!=null;n--) d=d.next;
   if(n==1) d.next=SwapFirst(d.next);
   return c;
}

Возьмём программу, в которой есть и циклы, и goto. Например, проверка, есть ли в матрице нулевая строка:

void Check(int M[5][5]){
  for(int a=0;a<5;a++){
    for(int b=0;b<5;b++){
      if(M[a][b]!=0) goto L1;
   }
   goto L2;
L1: continue;
  }
  printf("No\n"); return;
L2:
  printf("Yes\n"); 
}

Опишем все переменные в начале, а циклы распишем прямо по определению.
Кроме того, return превратим в goto на метку Return в конце функции:

void Check(int M[5][5]){
  int a,b;
  a=0;
  goto Loop1_Check;
Loop1_Body:
  b=0;
  goto Loop2_Check;
Loop2_Body:
      if(M[a][b]!=0) goto L1;
      b++;
Loop2_Check:
      if(b<5) goto Loop2_Body;  
   goto L2;
L1: 
Loop1_End:
   a++;
Loop1_Check:  
  if(a<5) goto Loop1_Body;
  printf("No\n"); goto Return;
L2:
  printf("Yes\n"); 
Return: ;
}

Теперь между любыми двумя метками у нас находится линейная последовательность, в которой могут встретиться конструкции if(condition) goto label;
Заводим переменную state.
Каждой метке присваиваем какое-нибудь значение этой переменной, и вместо goto label пишем state=label; а вместо if(condition) goto label; - if(condition) state=label; else{ остаток кода до следующей метки }. Если перед какой-нибудь меткой label не было безусловного goto, пишем перед ней state=label;

void Check(int M[5][5]){
  const int Return=0;
  const int Loop1_Check=1;
  const int Loop1_Body=2;
  const int Loop2_Check=3;
  const int Loop2_Body=4;
  const int L1=5;
  const int L2=6;

  int state;
  int a,b;
  a=0;
  state=Loop1_Check;
Loop1_Body:
  b=0;
 state=Loop2_Check;
Loop2_Body:
      if(M[a][b]!=0) state=L1;
      else{
         b++;
         state=Loop2_Check;
      }
Loop2_Check:
      if(b<5) state=Loop2_Body;  
      else state=L2;
L1: 
      a++;
      state=Loop1_Check;
Loop1_Check:  
  if(a<5) state=Loop1_Body;
  else{
      printf("No\n"); 
      state=Return;
  }
L2:
  printf("Yes\n"); 
  state=Return;
Return: ;
}

(это преобразование было неэквивалентным).
Теперь перед первой меткой вставляем while(state!=Return){ switch(state){
а каждую метку label: заменяем на break; case label:
break; перед первой меткой убираем, а case Return: меняем на } }

void Check(int M[5][5]){
  const int Return=0;
  const int Loop1_Check=1;
  const int Loop1_Body=2;
  const int Loop2_Check=3;
  const int Loop2_Body=4;
  const int L1=5;
  const int L2=6;

  int state;
  int a,b;
  a=0;
  state=Loop1_Check;
  while(state!=Return){
    switch(state){
      case Loop1_Body:
        b=0;
        state=Loop2_Check;
        break;
      case Loop2_Body:
        if(M[a][b]!=0) state=L1;
        else{
          b++;
          state=Loop2_Check;
        }
        break;
      case Loop2_Check:
        if(b<5) state=Loop2_Body;  
        else state=L2;
        break;
      case L1: 
        a++;
        state=Loop1_Check;
        break;
      case Loop1_Check:  
         if(a<5) state=Loop1_Body;
         else{
            printf("No\n"); 
            state=Return;
         }
         break;
       case L2:
          printf("Yes\n"); 
          state=Return;
          break;
     }
  }
  ;
}

Всё.

А чем не нравится goto? Вполне легальный оператор. В случае чего, от него легко избавиться, преобразовав код в конечный автомат (получится цикл с одним switch внутри). Хотя чаще хватает одной дополнительной логической переменной.
И какого типа ограничения? И есть ли ограничение на порядок выдачи перестановок?

UPD. Вот вариант решения на C#. Не самый эффективный, правда.

class Program{
        static IEnumerable<int[]> Permutations(int N,Func<int,int,bool>Cond1,Func<int,int,int,int,bool> Cond2) {
            int[] res=new int[N];
            int k=0;
            res[0]=0;
            while(k>=0){
                if(++res[k]<=N){
                    if(Cond1(k+1,res[k]) && GoodValue(res,k,Cond2)){
                        if(k==N-1) yield return res;
                        else res[++k]=0;
                    }
                }else k--;
            }
        }
        static private bool GoodValue(int[] res,int k,Func<int,int,int,int,bool> Cond) {
            for(int i=0;i<k;i++) {
                if(res[i]==res[k] || !Cond(i+1,res[i],k+1,res[k])) return false;
            }
            return true;
        }

        static int N=6;
        static bool Cond1(int a,int va) {
            if(a==1) return va==1;
            if(a==N) return va==N;
            return true;
        }
        static bool Cond2(int a,int va,int b,int vb) { 
            return Math.Abs(a-b)>1 || Math.Abs(va-vb)<=3;
        }
        static void Main(string[] args) {
            foreach(int[] perm in Permutations(N,Cond1,Cond2))
                Console.WriteLine(String.Join(",",perm));
        }
    }

Функции Permutations передаются два условия. Первое Cond1(a,va) проверяет, может ли элемент va находиться в позиции a, второе Cond2(a,va,b,vb) - могут ли одновременно находиться va в позиции a и vb в позиции b.
В качестве примера - печать перестановок из задачи про лягушку из ProjectEuler: https://projecteuler.net/problem=490
Для N=6 выдаёт ожидаемые 14 перестановок:

1,2,3,4,5,6
1,2,3,5,4,6
1,2,4,3,5,6
1,2,4,5,3,6
1,2,5,3,4,6
1,2,5,4,3,6
1,3,2,4,5,6
1,3,2,5,4,6
1,3,4,2,5,6
1,3,5,2,4,6
1,4,2,3,5,6
1,4,2,5,3,6
1,4,3,2,5,6
1,4,5,2,3,6

Если не нравится конструкция yield return - вставьте вместо неё свою обработку перестановки, а функцию опишите, как void. Если из GoodValue yбрать проверку res[I]==res[k], то вместо перестановок будут печататься все N-элементные наборы из чисел 1..N, удовлетворяющие условию.

Когда список пуст, Current и Head равны null. После добавления первого элемента Current и Head являются одним и тем же объектом, а при добавлении второго срабатывает строчка Current.Next = node; - и в этот момент устанавливается Head.Next (поскольку Current и Head совпадают).

Видны две ошибки. Первая не должна влиять на результат, но может привести к выходу индекса за границу массива:

if ((i < leftLen && left[i] < right[j]) || j >= rightLen) {

В случае, когда j==rightLen, у вас будет проверяться элемент right[j]. Условия здесь надо поменять местами:

if ( j >= rightLen || (i < leftLen && left[i] < right[j])) {

Вторая - что элемент array[mid] не будет участвовать ни в первом, ни во втором рекурсивных вызовах mergeSort. Второй вызов надо было сделать
mergeSort(array, mid, end);
А чтобы не было бесконечной рекурсии, изменить условие в mergeSort на
if (start < end-1) {
(или на if(start < mid) ).

Ну, и в классическом С невозможна конструкция

int leftLen = mid - start,
      left[leftLen];

Там массивы могут быть только фиксированной длины, а для динамического захвата приходится использовать malloc. Но если компилируется, значит, ваша версия компилятора такое позволяет.

UPD. В С99 действительно возможны массивы переменной длины, и пишут, что gcc их поддерживает. Ну и ладно. Visual Studio такое не позволяет.

Можно взять остаток от деления на 37, и дальше по табличке. Но это может оказаться дороже, чем цикл.
Или за 5 операций AND:

int n=0;
if(x&0xffff0000) n+=16;
if(x&0xff00ff00) n+=8;
if(x&0xf0f0f0f0) n+=4;
if(x&0xcccccccc) n+=2;
if(x&0xaaaaaaaa) n++;

Хотя через CLZ лучше.

Я обычно делаю так. Предположим, что желаемая форма графика известна - прямая, парабола, синусоида, поверхность второго порядка... Ищу коэффициенты наилучшего приближения по методу наименьших квадратов. Смотрю для каждой точки величину остаточной ошибки, считаю средний квадрат ошибок (сигму). Отбрасываю все точки, для которых ошибка больше 2.5*сигма, для остальных ищу график снова. И так, пока процесс не стабилизируется.
А вообще надо подробнее написать, что за данные, откуда они взялись, в каком диапазоне, что нужно от графика - например, должен ли он строго проходить через точки, или должен проходить в области наибольшего сгущения, известно ли что-нибудь про зависимость заранее... А так задача слишком общая.

Как-то так:

int S0[37],S1[37],S2[37],S3[37],S4[37];

void Expand(int *a,int *b,int n){
	int s0=0;
	for(int i=0;i<n+10;i++){
		if(i<n) s0+=a[i];
		if(i>=10) s0-=a[i-10];
		b[i]=s0;
	}
}

int Conv(int *S,int balance,int m){
	int res=0;
	while(--m>=0) res+=S[m]*S4[balance+m];
	return res;
}

// number of tickets in 0..u-1
int NHappy(int u){
	int res=0;
	int balance=0;
	int digit;

	digit=u/10000000; u%=10000000;
	for(int i=0;i<digit;i++) res+=Conv(S3,balance++,28);
	digit=u/1000000; u%=1000000;
	for(int i=0;i<digit;i++) res+=Conv(S2,balance++,19);
	digit=u/100000; u%=100000;
	for(int i=0;i<digit;i++) res+=Conv(S1,balance++,10);
	digit=u/10000; u%=10000;
	for(int i=0;i<digit;i++) res+=S4[balance++];
	digit=u/1000; u%=1000;
	for(int i=0;i<digit && balance>=0;i++) res+=S3[balance--];
	digit=u/100; u%=100;
	for(int i=0;i<digit && balance>=0;i++) res+=S2[balance--];
	digit=u/10; u%=10;
	for(int i=0;i<digit && balance>=0;i++) res+=S1[balance--];
	if(balance>=0 && balance<u) res++;
	return res;
}

void __cdecl main(){
	S0[0]=1;
	Expand(S0,S1,10);
	Expand(S1,S2,19);
	Expand(S2,S3,28);
	Expand(S3,S4,37);

	int m,n;
	for(;;){
		printf("m,n: ");
		scanf("%d%d",&m,&n);
		printf("Result: %d\n",NHappy(99999999)+1-NHappy(m)-NHappy(99999999-n));
	}
}

Проверок входных данных не делается. На простых тестах результаты были правильными. Работает, по моим оценкам, быстрее, чем за 2000 операций. Если нужно проверять много диапазонов, то можно предварительно вычислить частичные суммы Conv() в циклах, и тогда любой диапазон сосчитается за два десятка операций (и при этом не будет требовать гигабайта памяти).

UPD: Вот оптимизированный вариант:

int S[8][38];

void InitS(){
	for(int i=1;i<38;i++) S[0][i]=1;
	for(int a=1;a<9;a++){
		int s0=0;
		for(int i=1;i<=37;i++){
			s0+=S[a-1][i];
			if(i>10) s0-=S[a-1][i-10];
			S[a][i]=s0;
		}
	}
}

// number of tickets in 0..u-1
int NHappy(int u){
	int res=0;
	int balance=36;
	for(int a=7,b=10000000;a>=0;a--,b/=10){
		int digit=u/b;
		u%=b;
		int b1;
		if(a>3){
			balance-=9;
			res+=S[a][b1=balance+digit]-S[a][balance];
		} else{
			b1=balance-digit; if(b1<0) b1=-1;
			res+=S[a][balance+1]-S[a][b1+1];
		}
		balance=b1;
	}
	return res;
}

void __cdecl main(){
	InitS();
	int m,n;
	for(;;){
		printf("m,n: ");
		scanf("%d%d",&m,&n);
		printf("Result: %d\n",NHappy(99999999)+1-NHappy(m)-NHappy(99999999-n));
	}
}

Не спрашивайте, почему :)

Зависит от длины константы. Что короче - загрузить её в регистр непосредственно в команде, или взять из памяти (указав в команде адрес)? Сильно зависит от процессора.
В целом, одинаковые константы в алгоритме это не страшно. Хуже, когда одно и то же условие приходится проверять много раз. Или, что ещё страшнее, условия, следующие одно из другого (проверили, что a < b, а потом проверяем, что a+c < b+c). Такое часто встречается в геометрии. И в этом случае над алгоритмом стоит поработать.

Если вы хотите экономить память, то проблема будет не в переменных, а в больших структурах (списки, массивы, словари...). Мне чаще всего встречаются такие ситуации:
- память в обмен на время. Запоминать результаты или вычислять заново? Иногда здесь удаётся обменять экспоненциальное время на полиномиальное, или уменьшить степень полинома на 1 или на 2. Но чаще выигрыш идёт только в константу раз (хотя в узком месте это может быть немаловажно). Впрочем, иногда вычислить функцию оказывается быстрее, чем найти её значение в таблице - так что надо такие оптимизации проверять.
- замена обработки большого массива в памяти на послойную обработку (когда очередной фрагмент/строка/двумерный слой трёхмерного массива... вычисляется, обрабатывается, а уже ненужный слой забывается). Здесь память экономится за счёт серьёзного усложнения кода - приходится писать всякие конвейеры. Зато появляется шанс сэкономить ещё и время с помощью параллельной обработки.
- хранение данных, которые должны быть в памяти, в упакованном виде. Трудно читать, очень трудно писать, код усложняется, время теряется. Но появляется шанс уложиться в 3 ГБ и остаться в 32-битном режиме (если это важно).
- хранение в памяти против чтения из файла. Либо будет теряться время, либо усложняться код (если сумеете воспользоваться асинхронным чтением/записью).
- в тяжелых случаях - экономия байтов кода (это если пишете на ассемблере). Может пригодиться, если действительно пишете сервер для кофеварки. Но возможно, здесь лучше попытаться поставить процессор помощнее.

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