commit d6fd7f21632af7b2233726a18c26a1b0356fe06d · treybastian.com/advent-of-code

+26 -16
2024/day_09.f90
···

       38
       38
        
          integer :: io, ios, i, j, block_n, ct, block_start, block_end, space_start, space_end

     

       39
       39
        
          integer(kind=int64) :: res

     

       40
       40
        
          character(len=1) :: c

     

       41
       41
       -
          integer, allocatable :: system(:), work(:)

     

       41
       41
       +
          integer, allocatable :: system(:), work(:), done(:)

     

       42
       42
        
          logical :: is_space, space_block_start

     

       43
       43
        
       

     

       44
       44
        
          open(newunit=io, file='./day_09_input.txt', status='old', action='read', access='stream')

     
···

       97
       97
        
          block_n = -1

     

       98
       98
        
          block_start = -1

     

       99
       99
        
          block_end = -1

     

       100
       100
       -
          do i = 0, size(work) -1

     

       101
       101
       -
             if(block_n == -1 .and. work(size(work) - i) > -1) then

     

       100
       100
       +
          do i = size(work), 1, -1

     

       101
       101
       +
             if(block_n == -1 .and. work(i) /= -1) then

     

       102
       102
        
                ! we are starting a block

     

       103
       103
       -
                block_end = size(work) - i

     

       104
       104
       -
                block_n = work(size(work) - i)

     

       105
       105
       -
             else if (block_n /= -1 .and. block_n /= work(size(work)-i)) then

     

       103
       103
       +
                block_end = i

     

       104
       104
       +
                block_n = work(i)

     

       105
       105
       +
                if(allocated(done) .and. count(done == block_n) > 0) then

     

       106
       106
       +
                   block_n = -1

     

       107
       107
       +
                   block_start = -1

     

       108
       108
       +
                   block_end = -1

     

       109
       109
       +
                   cycle

     

       110
       110
       +
                else if(.not. allocated(done)) then

     

       111
       111
       +
                   allocate(done(1))

     

       112
       112
       +
                   done(1) = block_n

     

       113
       113
       +
                else

     

       114
       114
       +
                   call append_to_integer_array_times(done, block_n, 1)

     

       115
       115
       +
                end if

     

       116
       116
       +
             else if (block_n /= -1 .and. block_n /= work(i)) then

     

       106
       117
        
                ! we are ending the block

     

       107
       107
       -
                block_start = size(work) - i

     

       118
       118
       +
                block_start = i

     

       119
       119
       +
       

     

       108
       120
        
                ! lets try to move the block

     

       109
       121
        
                space_block_start = .true.

     

       110
       122
        
                do j = 1, size(work)

     

       111
       111
       -
                   if (j >= block_start) exit

     

       123
       123
       +
                   if (j > block_start) exit

     

       112
       124
        
                   if(space_block_start .and. work(j) == -1) then

     

       113
       125
        
                      space_start = j

     

       114
       126
        
                      space_block_start = .false.

     
···

       116
       128
        
                      space_end = j

     

       117
       129
        
                      space_block_start = .true.

     

       118
       130
        
                      if(space_end - space_start >= block_end - block_start) then

     

       119
       119
       -
                         work(space_start:(space_start + (block_end - (block_start +1) ))) = work((block_start +1):block_end)

     

       131
       131
       +
                         work(space_start:space_start + (block_end - (block_start +1))) = block_n

     

       120
       132
        
                         work(block_start+1:block_end) = -1

     

       121
       121
       -
                         block_n = -1

     

       122
       122
       -
                         block_start = -1

     

       123
       123
       -
                         block_end = -1

     

       124
       124
       -
       

     

       125
       133
        
                         exit

     

       126
       134
        
                      end if

     

       135
       135
       +
                      space_end = -1

     

       136
       136
       +
                      space_start = -1

     

       127
       137
        
                   end if

     

       128
       138
        
                end do

     

       129
       129
       -
                block_n = work(size(work) - i)

     

       130
       130
       -
                block_end = size(work) - i

     

       139
       139
       +
                block_n = work(i)

     

       140
       140
       +
                block_end = i

     

       131
       141
        
                block_start = -1

     

       132
       142
        
             end if

     

       133
       143
        
          end do

     

       134
       144
        
          do i = 1, size(work)

     

       135
       135
       -
             if(work(i) > -1) then

     

       145
       145
       +
             if(work(i) /= -1) then

     

       136
       146
        
                res = res + ((i-1) * work(i))

     

       137
       147
        
             end if

     

       138
       148
        
          end do