Сохранение и восстановление состояния обработки

[ЫукпШ]

Цитата OpenGL @ 26.08.22, 20:48

Тут же while очевидный, который и понятнее, и пишется быстрее. Как принцип - сойдёт, в реальности же это эталон, достойный govnokod.ru

Здесь нет циклов, это инкремент счётчиков.
Цикл один, внешний, для всех работающих автоматов.

[OpenGL]

Цитата macomics @ 26.08.22, 20:51

А тут и не должно быть циклов. Эта функция должна сделать один инкремент для этих 5 циклов.

Вот это "не должно быть циклов"?

Цитата macomics @ 26.08.22, 16:42

if (++i[5] >= MAXI) { // for (size_t i5 = 0; i5 < MAXI; ++i5)
i[5] = 0;
if (++i[4] >= MAXI) { // for (size_t i4 = 0; i4 < MAXI; ++i4)
i[4] = 0;
if (++i[3] >= MAXI) { // for (size_t i3 = 0; i3 < MAXI; ++i3)
i[3] = 0;
if (++i[2] >= MAXI) { // for (size_t i2 = 0; i2 < MAXI; ++i2)
i[2] = 0;
if (++i[1] >= MAXI) // for (size_t i1 = 0; i1 < MAXI; ++i1)
return false;
}
}
}
}
return true;
}

Тут скорее вопрос может возникать - как в принципе тут очевидный цикл можно не увидеть?

Добавлено 26.08.22, 21:51

Цитата ЫукпШ @ 26.08.22, 21:02

Здесь нет циклов, это инкремент счётчиков.

Инкремент, который легко запихнуть в цикл.
Вон сделай как Киля выше предложил - 87 счётчиков. Накопипастишь 87 одинаковых условий, которые буквой цикла отличаются, или в этом случае лень уже пересилит, и заставит в цикл это обернуть?

[macomics]

Вот и написал бы свой вариант (с циклом), который однозначно лучше прежних.

Сообщение отредактировано: macomics - 26.08.22, 22:05

[OpenGL]

А смысл? Если кто-то не видит, как из набора последовательности однотипных условий, отличающихся друг от друга одним индексом, сделать цикл, то человек просто далёк от программирования, но тогда он вряд ли бы тут вообще появился. А если видит, то пусть идёт в другое место, кормить я не буду его.

[ЫукпШ]

Цитата OpenGL @ 26.08.22, 21:48

Инкремент, который легко запихнуть в цикл.

я делаю именно то, что мне нужно в данном алгоритме.
Подобное использование счётчиков носит принципиальный характер
для решения именно поставленной задачи.
Поскольку цикл - один.
Он не только для данного автомата.
Но и для всех других, которые потребуются.

[macomics]

Цитата OpenGL @ 26.08.22, 22:11

Если кто-то не видит, как из набора последовательности однотипных условий, отличающихся друг от друга одним индексом, сделать цикл, то человек просто далёк от программирования, но тогда он вряд ли бы тут вообще появился. А если видит, то пусть идёт в другое место, кормить я не буду его.

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

Все прямо такие вумные как вутки, только вотруби не клюют!

Сообщение отредактировано: macomics - 26.08.22, 22:49

[Wound]

Цитата macomics @ 26.08.22, 22:48

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

Он все правильно пишет. ТС выдумал свои циклы в надежде оправдать goto. Давай зайдем с другой стороны: Покажите юзкейс, чтоб был предмет разговора. Пока это похоже на унылое говно. Я могу так же 87 вложенных циклов сделать и задать тот же вопрос. Я выше именно это и сделал, собственно. И что?
На кой хер нужны 6 вложенных циклов и еще останавливаться где то там и потом продолжать? Я ровно так же могу написать макрос - который будет функцией с пятью вложенными циклами и повпендюливать его в 10 мест и спросить - объясните, как тут без макроса жить то... Вот так же и с циклами из примера ТС. Да никак - это высосаный из пальца пример, нигде не нужный, ну разве что для оправдания goto в теме ТС.

Сообщение отредактировано: Wound - 26.08.22, 23:59

[Qraizer]

Цитата Wound @ 26.08.22, 20:55

Приведи реальный пример когда надо именно 5-6 вложенных циклов и без этого никуда?

Подсчёт статистики по счастливым билетам.

[Qraizer]

Смею вас заверить, что "такое никогда не нужно" суть любимый аргумент... та много какой темы. Множественного наследования реализаций например. Или ленивых вычислений. Увы, но "такое" иногда становится очень даже актуальным, и тогда ты сидишь и хреначишь костыль.

Добавлено 27.08.22, 01:32
Вы тут покостыльте, я пока за рыбкой к пиву сбегаю.

[Majestio]

Цитата Wound @ 26.08.22, 23:56

ТС выдумал свои циклы в надежде оправдать goto

Киля, не кипятись! Смею тебя уверить, что оператор goto очень надежный. Он действительно может тебе помочь в трудных ситуациях. Но в этой теме не о том речь. Соглашусь, суть темы - обсуждение сферического коня в вакууме. Тем не менее, тема не перестает быть интересной. А если еще и бывает ...

Цитата Qraizer @ 27.08.22, 01:20

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

Бывает, и тогда вообще ахтунг!

Прочитавши ваши рассуждения, я пришел к определенным выводам:

• Использование оператора goto в принципе возможно. Более того, на первый взгляд кажется самым "естественным" решением. Но оно только кажется
• Для использования возможностей "приостановки/возобновления" вычислений - лучше всего переработать сам алгоритм, а именно завернуть все в бесконечный цикл, и использовать подход программирования автоматов

Вместо много-вложенных циклов используем другой подход (псевдокод):

// тут условие входа - или инициализация, или загрузка сохраненных данных
while(1+1) {
  // 1) проверка на выход - все просчитали, или нет
  // 2) меняем переменные, даже если их 87
  // 3) делаем единичный пересчет или сохраняемся для приостановки
}

[Majestio]

Цитата Wound @ 26.08.22, 23:56

оправдать goto

Я вчера использовал оператор goto! Правда не помню где.

[korvin]

Цитата Majestio @ 26.08.22, 15:49

Какие варианты, кроме как использовать метки и оператор goto, могут быть для решения данного вопроса?

Ну, можно костыли накостылять. Основной метод: инкапсулировать все состояния в один объект, его и сохранять/восстанавливать.

Как-то так, например:

import java.util.*;
import java.lang.*;
 
class Rextester
{
    public static void main(String args[])
    {
        Loop<State4> loop = new Loop<>(new State4(0,0,0,0), new State4(5,5,5,5), new State4(0,0,0,0));
        
        System.out.println("Run from the start:");
        
        run(loop, false).ifPresent(state -> {
            System.out.println("\nSave state 1: " + state);
            loop.cur = state;
        });
        
        System.out.println("Continue from state 1: " + loop.cur);
        
        run(loop, true).ifPresent(state -> {
            System.out.println("\nSave state 2: " + state);
            loop.cur = state;
        });
        
        System.out.println("Continue from state 2: " + loop.cur);
        
        run(loop, true).ifPresent(state -> {
            System.out.println("\nSave state 3: " + state);
            loop.cur = state;
        });
    }
    
    static Optional<State4> run(Loop<State4> loop, boolean cont)
    {
        // restore
        int i1 = loop.cur.i1;
        int i2 = loop.cur.i2;
        int i3 = loop.cur.i3;
        int i4 = loop.cur.i4;
        
        for (; i1 < loop.max.i1; i1++) {
            for (; i2 < loop.max.i2; i2++) {
                for (; i3 < loop.max.i3; i3++) {
                    if (i2 == 2 && i3 == 3) {
                        if (cont) {
                            cont = false;
                        } else {
                            // save
                            return Optional.of(new State4(i1, i2, i3, i4));
                        }
                    }
                    if (i2 == 3 && i3 == 1) {
                        if (cont) {
                            cont = false;
                        } else {
                            // save
                            return Optional.of(new State4(i1, i2, i3, i4));
                        }
                    }
                    for (; i4 < loop.max.i4; i4++) {
                        System.out.printf("%d,%d,%d,%d; ", i1, i2, i3, i4);
                    }
                    i4 = loop.min.i4;
                }
                i3 = loop.min.i3;
            }
            i2 = loop.min.i2;
        }
        return Optional.empty();
    }
}
            
class Loop<S>
{
    S min;
    S max;
    S cur;
    
    Loop(S min, S max, S cur)
    {
        this.min = min;
        this.max = max;
        this.cur = cur;
    }
}
 
class State4
{
    int i1, i2, i3, i4;
    
    State4(int i1, int i2, int i3, int i4)
    {
        this.i1 = i1;
        this.i2 = i2;
        this.i3 = i3;
        this.i4 = i4;
    }
    
    @Override
    public String toString()
    {
        return String.format("(%d,%d,%d,%d)", i1, i2, i3, i4);
    }
}

=>

Run from the start:
0,0,0,0; 0,0,0,1; 0,0,0,2; 0,0,0,3; 0,0,0,4; 0,0,1,0; 0,0,1,1; 0,0,1,2; 0,0,1,3; 0,0,1,4; 0,0,2,0; 0,0,2,1; 0,0,2,2; 0,0,2,3; 0,0,2,4; 0,0,3,0; 0,0,3,1; 0,0,3,2; 0,0,3,3; 0,0,3,4; 0,0,4,0; 0,0,4,1; 0,0,4,2; 0,0,4,3; 0,0,4,4; 0,1,0,0; 0,1,0,1; 0,1,0,2; 0,1,0,3; 0,1,0,4; 0,1,1,0; 0,1,1,1; 0,1,1,2; 0,1,1,3; 0,1,1,4; 0,1,2,0; 0,1,2,1; 0,1,2,2; 0,1,2,3; 0,1,2,4; 0,1,3,0; 0,1,3,1; 0,1,3,2; 0,1,3,3; 0,1,3,4; 0,1,4,0; 0,1,4,1; 0,1,4,2; 0,1,4,3; 0,1,4,4; 0,2,0,0; 0,2,0,1; 0,2,0,2; 0,2,0,3; 0,2,0,4; 0,2,1,0; 0,2,1,1; 0,2,1,2; 0,2,1,3; 0,2,1,4; 0,2,2,0; 0,2,2,1; 0,2,2,2; 0,2,2,3; 0,2,2,4;
Save state 1: (0,2,3,0)
Continue from state 1: (0,2,3,0)
0,2,3,0; 0,2,3,1; 0,2,3,2; 0,2,3,3; 0,2,3,4; 0,2,4,0; 0,2,4,1; 0,2,4,2; 0,2,4,3; 0,2,4,4; 0,3,0,0; 0,3,0,1; 0,3,0,2; 0,3,0,3; 0,3,0,4;
Save state 2: (0,3,1,0)
Continue from state 2: (0,3,1,0)
0,3,1,0; 0,3,1,1; 0,3,1,2; 0,3,1,3; 0,3,1,4; 0,3,2,0; 0,3,2,1; 0,3,2,2; 0,3,2,3; 0,3,2,4; 0,3,3,0; 0,3,3,1; 0,3,3,2; 0,3,3,3; 0,3,3,4; 0,3,4,0; 0,3,4,1; 0,3,4,2; 0,3,4,3; 0,3,4,4; 0,4,0,0; 0,4,0,1; 0,4,0,2; 0,4,0,3; 0,4,0,4; 0,4,1,0; 0,4,1,1; 0,4,1,2; 0,4,1,3; 0,4,1,4; 0,4,2,0; 0,4,2,1; 0,4,2,2; 0,4,2,3; 0,4,2,4; 0,4,3,0; 0,4,3,1; 0,4,3,2; 0,4,3,3; 0,4,3,4; 0,4,4,0; 0,4,4,1; 0,4,4,2; 0,4,4,3; 0,4,4,4; 1,0,0,0; 1,0,0,1; 1,0,0,2; 1,0,0,3; 1,0,0,4; 1,0,1,0; 1,0,1,1; 1,0,1,2; 1,0,1,3; 1,0,1,4; 1,0,2,0; 1,0,2,1; 1,0,2,2; 1,0,2,3; 1,0,2,4; 1,0,3,0; 1,0,3,1; 1,0,3,2; 1,0,3,3; 1,0,3,4; 1,0,4,0; 1,0,4,1; 1,0,4,2; 1,0,4,3; 1,0,4,4; 1,1,0,0; 1,1,0,1; 1,1,0,2; 1,1,0,3; 1,1,0,4; 1,1,1,0; 1,1,1,1; 1,1,1,2; 1,1,1,3; 1,1,1,4; 1,1,2,0; 1,1,2,1; 1,1,2,2; 1,1,2,3; 1,1,2,4; 1,1,3,0; 1,1,3,1; 1,1,3,2; 1,1,3,3; 1,1,3,4; 1,1,4,0; 1,1,4,1; 1,1,4,2; 1,1,4,3; 1,1,4,4; 1,2,0,0; 1,2,0,1; 1,2,0,2; 1,2,0,3; 1,2,0,4; 1,2,1,0; 1,2,1,1; 1,2,1,2; 1,2,1,3; 1,2,1,4; 1,2,2,0; 1,2,2,1; 1,2,2,2; 1,2,2,3; 1,2,2,4;
Save state 3: (1,2,3,0)

— https://rextester.com/LYV19256

Добавлено 27.08.22, 08:16
Можно ещё попробовать с Continuation-passing style поиграть. Правда, продолжения в файл не сохранишь, так что не всегда подойдёт.

Сообщение отредактировано: korvin - 27.08.22, 08:38

[korvin]

Собственно, пример с продолжениями:

Скрытый текст

#lang racket
 
(define ((start save-and-exit))
  (for* ((i1 (in-range 0 5))
         (i2 (in-range 0 5))
         (i3 (in-range 0 5)))
    (when (and (= i2 2)
               (= i3 3))
      ; save
      (save-and-exit))
    (when (and (= i2 3)
               (= i3 1))
      ; save
      (save-and-exit))
    (for ((i4 (in-range 0 5)))
      (printf "~a,~a,~a,~a; " i1 i2 i3 i4))))
 
(define (main)
  (define exit #f)
  (define state #f)
 
  (define (save-and-exit)
    (let/cc k
      (printf "~nSaving state...~n")
      (set! state k)
      (exit)))
 
  (define (loop)
    (let/cc k
      (set! exit k)
      (state)))
 
  (set! state (start save-and-exit))
 
  (printf "Run from start:~n")
  (loop)
 
  (printf "~nContinue from state 1:~n")
  (loop)
 
  (printf "~nContinue from state 2:~n")
  (loop)
 
  (printf "~nContinue from state 3:~n")
  (loop)
 
  (printf "~ndone"))

=>

> (main)
Run from start:
0,0,0,0; 0,0,0,1; 0,0,0,2; 0,0,0,3; 0,0,0,4; 0,0,1,0; 0,0,1,1; 0,0,1,2; 0,0,1,3; 0,0,1,4; 0,0,2,0; 0,0,2,1; 0,0,2,2; 0,0,2,3; 0,0,2,4; 0,0,3,0; 0,0,3,1; 0,0,3,2; 0,0,3,3; 0,0,3,4; 0,0,4,0; 0,0,4,1; 0,0,4,2; 0,0,4,3; 0,0,4,4; 0,1,0,0; 0,1,0,1; 0,1,0,2; 0,1,0,3; 0,1,0,4; 0,1,1,0; 0,1,1,1; 0,1,1,2; 0,1,1,3; 0,1,1,4; 0,1,2,0; 0,1,2,1; 0,1,2,2; 0,1,2,3; 0,1,2,4; 0,1,3,0; 0,1,3,1; 0,1,3,2; 0,1,3,3; 0,1,3,4; 0,1,4,0; 0,1,4,1; 0,1,4,2; 0,1,4,3; 0,1,4,4; 0,2,0,0; 0,2,0,1; 0,2,0,2; 0,2,0,3; 0,2,0,4; 0,2,1,0; 0,2,1,1; 0,2,1,2; 0,2,1,3; 0,2,1,4; 0,2,2,0; 0,2,2,1; 0,2,2,2; 0,2,2,3; 0,2,2,4;
Saving state...
 
Continue from state 1:
0,2,3,0; 0,2,3,1; 0,2,3,2; 0,2,3,3; 0,2,3,4; 0,2,4,0; 0,2,4,1; 0,2,4,2; 0,2,4,3; 0,2,4,4; 0,3,0,0; 0,3,0,1; 0,3,0,2; 0,3,0,3; 0,3,0,4;
Saving state...
 
Continue from state 2:
0,3,1,0; 0,3,1,1; 0,3,1,2; 0,3,1,3; 0,3,1,4; 0,3,2,0; 0,3,2,1; 0,3,2,2; 0,3,2,3; 0,3,2,4; 0,3,3,0; 0,3,3,1; 0,3,3,2; 0,3,3,3; 0,3,3,4; 0,3,4,0; 0,3,4,1; 0,3,4,2; 0,3,4,3; 0,3,4,4; 0,4,0,0; 0,4,0,1; 0,4,0,2; 0,4,0,3; 0,4,0,4; 0,4,1,0; 0,4,1,1; 0,4,1,2; 0,4,1,3; 0,4,1,4; 0,4,2,0; 0,4,2,1; 0,4,2,2; 0,4,2,3; 0,4,2,4; 0,4,3,0; 0,4,3,1; 0,4,3,2; 0,4,3,3; 0,4,3,4; 0,4,4,0; 0,4,4,1; 0,4,4,2; 0,4,4,3; 0,4,4,4; 1,0,0,0; 1,0,0,1; 1,0,0,2; 1,0,0,3; 1,0,0,4; 1,0,1,0; 1,0,1,1; 1,0,1,2; 1,0,1,3; 1,0,1,4; 1,0,2,0; 1,0,2,1; 1,0,2,2; 1,0,2,3; 1,0,2,4; 1,0,3,0; 1,0,3,1; 1,0,3,2; 1,0,3,3; 1,0,3,4; 1,0,4,0; 1,0,4,1; 1,0,4,2; 1,0,4,3; 1,0,4,4; 1,1,0,0; 1,1,0,1; 1,1,0,2; 1,1,0,3; 1,1,0,4; 1,1,1,0; 1,1,1,1; 1,1,1,2; 1,1,1,3; 1,1,1,4; 1,1,2,0; 1,1,2,1; 1,1,2,2; 1,1,2,3; 1,1,2,4; 1,1,3,0; 1,1,3,1; 1,1,3,2; 1,1,3,3; 1,1,3,4; 1,1,4,0; 1,1,4,1; 1,1,4,2; 1,1,4,3; 1,1,4,4; 1,2,0,0; 1,2,0,1; 1,2,0,2; 1,2,0,3; 1,2,0,4; 1,2,1,0; 1,2,1,1; 1,2,1,2; 1,2,1,3; 1,2,1,4; 1,2,2,0; 1,2,2,1; 1,2,2,2; 1,2,2,3; 1,2,2,4;
Saving state...
 
Continue from state 3:
1,2,3,0; 1,2,3,1; 1,2,3,2; 1,2,3,3; 1,2,3,4; 1,2,4,0; 1,2,4,1; 1,2,4,2; 1,2,4,3; 1,2,4,4; 1,3,0,0; 1,3,0,1; 1,3,0,2; 1,3,0,3; 1,3,0,4;
Saving state...
 
done

[ЫукпШ]

Цитата Majestio @ 27.08.22, 04:41

Киля, не кипятись! Смею тебя уверить, что оператор goto очень надежный.

я в детстве прочитал одну хорошую книгу, вот отрывок:

Цитата

Запомните, что я вам скажу: один стакан рому вас, конечно, не убьет,
но если вы выпьете один стакан, вам захочется выпить еще и еще.
И клянусь вам моим париком: если вы не бросите пить, вы в самом скором
времени умрете. Понятно?
– Так помните, я говорю вам по чистой совести: слово «ром» и слово «смерть»
для вас теперь означают одно и то же.

От одного специалиста мне достались для работы некие важные исходные тексты.
Он использовал С компилятор как ассемблер и goto - его любимый оператор.
Надо ли продолжать описание ситуации ? =:0


А вот так нельзя было ?

    for (size_t i1 = 0; i1< IMAX; ++i1) {
      for (size_t i2 = 0; i2< IMAX; ++i2) {
        for (size_t i3 = 0; i3< IMAX; ++i3) {
 
if(какое то условие) iWorkFlag=1;
else                 iWorkFlag=0;
 
          for (size_t i4 = 0; i4< IMAX; ++i4) {
 
if(какое то условие) iWorkFlag=2;
 
            for (size_t i5 = 0; i5< IMAX; ++i5) {
              // ─────► нам нужно остановиться тут, запомнить состояние, а потом вернуться сюда
 
// iWorkFlag = 0 - ничего не делаем
// iWorkFlag = 1 - работаем, пока флаг установлен
// iWorkFlag = 2 - работаем один раз, для этого флаг сбрасываем
 
 SomeRoutine(iWorkFlag); // фактически ушли куда-то, потом вернулись. Состояние не испортили.
 
 
              for (size_t i87 = 0; i87< IMAX; ++i87) {
                 // ...
              }  
            }  
          }  
        }
      }
    }

Сообщение отредактировано: ЫукпШ - 27.08.22, 18:46

[macomics]

Цитата ЫукпШ @ 27.08.22, 18:40

А вот так нельзя было ?

И ведь самый очевидный ответ был самым невероятным.