comparing b89f1c3291777d32d87ddcec2bf45e3f438f77cc and main on treybastian.com/advent-of-code

.gitignore

···

       1
       +
       input.txt

     

       2
       +
       input_test.txt

+2 -1

2024/.gitignore

+36 -36

2024/day_01.f90

···

       1
       -
       module sorting 

     

       2
       -
         ! apparently you need to put the subroutine in a module

     

       3
       -
         implicit none

     

       4
       -
         contains 

     

       5
       -
         subroutine sort(arr)

     

       6
        
             !! a little insertion sort KISS

     

       7
        
             !! also yea we have no in built sorting

     

       8
       -
           implicit none

     

       9
       -
           integer, intent(inout) :: arr(1000)

     

       10
       -
           integer :: i, j, key

     

       11
       -
           do i = 2, 1000 

     

       12
       -
             key = arr(i)

     

       13
       -
             j = i - 1

     

       14
       -
             do while (j > 0 .and. arr(j) > key)

     

       15
       -
               arr(j+1) = arr(j)

     

       16
       -
               j = j - 1

     

       0
        
       
     

       0
        
       
     

       17
        
             end do

     

       18
       -
             arr(j+1) = key

     

       19
       -
           end do

     

       20
       -
         end subroutine sort

     

       21
        
       end module sorting

     

       22
        
       

     

       23
        
       program day_01

     

       24
       -
         use sorting

     

       25
       -
         implicit none

     

       26
       -
         integer :: io, i, dist, sim, left(1000), right(1000) ! yea we are coding to the input file and not generic

     

       27
       -
         open(newunit=io, file='./day_01_input.txt', status='old', action='read')

     

       28
        
       

     

       29
       -
         do i = 1, 1000

     

       30
       -
           read(io, *) left(i), right(i) ! read both values in line

     

       31
       -
         end do

     

       32
        
       

     

       33
       -
         close(10) ! close the file

     

       34
        
       

     

       35
       -
         call sort(left)

     

       36
       -
         call sort(right)

     

       37
        
       

     

       38
       -
         ! if we dont init these bad things happen on multiple runs

     

       39
       -
         dist = 0 

     

       40
       -
         sim = 0

     

       41
        
       

     

       42
       -
         do i = 1, 1000

     

       43
       -
          dist = dist + abs(left(i) - right(i)) 

     

       44
       -
          sim = sim + left(i) * count(right == left(i)) 

     

       45
       -
         end do

     

       46
        
       

     

       47
       -
           print*, "distance: ", dist

     

       48
       -
           print*, "similarity: ", sim

     

       49
        
       end program day_01

     

       50

···

       1
       +
       module sorting

     

       2
       +
          ! apparently you need to put the subroutine in a module

     

       3
       +
          implicit none

     

       4
       +
       contains

     

       5
       +
          subroutine sort(arr)

     

       6
        
             !! a little insertion sort KISS

     

       7
        
             !! also yea we have no in built sorting

     

       8
       +
             implicit none

     

       9
       +
             integer, intent(inout) :: arr(1000)

     

       10
       +
             integer :: i, j, key

     

       11
       +
             do i = 2, 1000

     

       12
       +
                key = arr(i)

     

       13
       +
                j = i - 1

     

       14
       +
                do while (j > 0 .and. arr(j) > key)

     

       15
       +
                   arr(j+1) = arr(j)

     

       16
       +
                   j = j - 1

     

       17
       +
                end do

     

       18
       +
                arr(j+1) = key

     

       19
        
             end do

     

       20
       +
          end subroutine sort

     

       0
        
       
     

       0
        
       
     

       21
        
       end module sorting

     

       22
        
       

     

       23
        
       program day_01

     

       24
       +
          use sorting

     

       25
       +
          implicit none

     

       26
       +
          integer :: io, i, dist, sim, left(1000), right(1000) ! yea we are coding to the input file and not generic

     

       27
       +
          open(newunit=io, file='./day_01_input.txt', status='old', action='read')

     

       28
        
       

     

       29
       +
          do i = 1, 1000

     

       30
       +
             read(io, *) left(i), right(i) ! read both values in line

     

       31
       +
          end do

     

       32
        
       

     

       33
       +
          close(10) ! close the file

     

       34
        
       

     

       35
       +
          call sort(left)

     

       36
       +
          call sort(right)

     

       37
        
       

     

       38
       +
          ! if we dont init these bad things happen on multiple runs

     

       39
       +
          dist = 0

     

       40
       +
          sim = 0

     

       41
        
       

     

       42
       +
          do i = 1, 1000

     

       43
       +
             dist = dist + abs(left(i) - right(i))

     

       44
       +
             sim = sim + left(i) * count(right == left(i))

     

       45
       +
          end do

     

       46
        
       

     

       47
       +
          print*, "distance: ", dist

     

       48
       +
          print*, "similarity: ", sim

     

       49
        
       end program day_01

     

       50

+30

2024/day_01.ml

···

       1
       +
       let filename = "./day_01_input.txt"

     

       2
       +
       let try_read ic = try Some (input_line ic) with End_of_file -> None

     

       3
       +
       

     

       4
       +
       let line_to_ints s =

     

       5
       +
         Str.split_delim (Str.regexp "   ") s |> List.map int_of_string

     

       6
       +
       

     

       7
       +
       let rec read_lines left right ic =

     

       8
       +
         match try_read ic with

     

       9
       +
         | Some line -> (

     

       10
       +
             line_to_ints line |> fun ints ->

     

       11
       +
             match ints with

     

       12
       +
             | [ a; b ] -> read_lines (a :: left) (b :: right) ic

     

       13
       +
             | _ -> failwith "invalid")

     

       14
       +
         | None ->

     

       15
       +
             close_in ic;

     

       16
       +
             (List.sort compare left, List.sort compare right)

     

       17
       +
       

     

       18
       +
       let calc_sum left right =

     

       19
       +
         List.map2 ( - ) left right |> List.map abs |> List.fold_left ( + ) 0

     

       20
       +
       

     

       21
       +
       let calc_sim left right =

     

       22
       +
         List.map

     

       23
       +
           (fun x -> x * (List.filter (fun y -> x == y) right |> List.length))

     

       24
       +
           left

     

       25
       +
         |> List.fold_left ( + ) 0

     

       26
       +
       

     

       27
       +
       let () =

     

       28
       +
         let left, right = open_in filename |> read_lines [] [] in

     

       29
       +
         calc_sum left right |> Printf.sprintf "Sum %d" |> print_endline;

     

       30
       +
         calc_sim left right |> Printf.sprintf "Part 2 Simularity %d" |> print_endline

-1000

2024/day_01_input.txt

···

       1
       -
       64430   75582

     

       2
       -
       87936   20843

     

       3
       -
       98310   72035

     

       4
       -
       98142   69076

     

       5
       -
       73170   50561

     

       6
       -
       65508   20716

     

       7
       -
       72642   84718

     

       8
       -
       63792   89556

     

       9
       -
       88319   66913

     

       10
       -
       38149   43160

     

       11
       -
       88982   10253

     

       12
       -
       34137   95932

     

       13
       -
       79589   92389

     

       14
       -
       49164   98263

     

       15
       -
       49746   92762

     

       16
       -
       53896   43420

     

       17
       -
       21240   95725

     

       18
       -
       88691   37648

     

       19
       -
       47697   66763

     

       20
       -
       38234   98154

     

       21
       -
       74901   20452

     

       22
       -
       70760   11404

     

       23
       -
       16084   74024

     

       24
       -
       77408   32178

     

       25
       -
       81054   45709

     

       26
       -
       68478   92252

     

       27
       -
       52984   55239

     

       28
       -
       14952   20843

     

       29
       -
       42548   69422

     

       30
       -
       21427   20329

     

       31
       -
       92508   81533

     

       32
       -
       22650   76459

     

       33
       -
       48388   81843

     

       34
       -
       49540   25697

     

       35
       -
       65666   12373

     

       36
       -
       45713   16199

     

       37
       -
       42419   10468

     

       38
       -
       64757   30375

     

       39
       -
       58273   43473

     

       40
       -
       10576   20540

     

       41
       -
       31508   42210

     

       42
       -
       21718   52578

     

       43
       -
       55862   92252

     

       44
       -
       29892   20716

     

       45
       -
       35978   50547

     

       46
       -
       18953   43473

     

       47
       -
       51379   31038

     

       48
       -
       16417   83883

     

       49
       -
       66023   24679

     

       50
       -
       28031   55268

     

       51
       -
       69178   45771

     

       52
       -
       56463   93602

     

       53
       -
       33368   20147

     

       54
       -
       16434   43473

     

       55
       -
       97551   73418

     

       56
       -
       46904   19198

     

       57
       -
       25697   60996

     

       58
       -
       37363   35781

     

       59
       -
       11282   92252

     

       60
       -
       35209   72035

     

       61
       -
       66763   27103

     

       62
       -
       85271   69322

     

       63
       -
       33759   94633

     

       64
       -
       17008   83883

     

       65
       -
       97073   21870

     

       66
       -
       24061   55053

     

       67
       -
       53095   92252

     

       68
       -
       12374   92762

     

       69
       -
       25571   51808

     

       70
       -
       37178   10953

     

       71
       -
       88710   67938

     

       72
       -
       64979   48065

     

       73
       -
       49734   80760

     

       74
       -
       73780   81067

     

       75
       -
       55802   37177

     

       76
       -
       78442   90493

     

       77
       -
       97220   32178

     

       78
       -
       39845   25697

     

       79
       -
       27359   39117

     

       80
       -
       66371   17473

     

       81
       -
       50236   82028

     

       82
       -
       54937   41865

     

       83
       -
       11989   69107

     

       84
       -
       61602   78467

     

       85
       -
       83376   75395

     

       86
       -
       84545   42210

     

       87
       -
       24250   55446

     

       88
       -
       29247   37936

     

       89
       -
       48897   21653

     

       90
       -
       89795   26960

     

       91
       -
       60748   39097

     

       92
       -
       32745   20716

     

       93
       -
       66967   43473

     

       94
       -
       63073   21718

     

       95
       -
       71949   83590

     

       96
       -
       30876   83883

     

       97
       -
       43640   21718

     

       98
       -
       37703   37133

     

       99
       -
       19198   43473

     

       100
       -
       43605   42609

     

       101
       -
       35757   54910

     

       102
       -
       20959   23081

     

       103
       -
       29302   52984

     

       104
       -
       56530   82308

     

       105
       -
       95611   42671

     

       106
       -
       60818   39516

     

       107
       -
       18302   61539

     

       108
       -
       25344   25697

     

       109
       -
       91669   80760

     

       110
       -
       67090   98098

     

       111
       -
       44280   59977

     

       112
       -
       17423   65400

     

       113
       -
       56952   78467

     

       114
       -
       23067   72035

     

       115
       -
       45925   76133

     

       116
       -
       84963   87050

     

       117
       -
       29175   32178

     

       118
       -
       89724   74826

     

       119
       -
       85282   49648

     

       120
       -
       86399   77097

     

       121
       -
       34615   52896

     

       122
       -
       47895   52578

     

       123
       -
       68604   72035

     

       124
       -
       30689   20716

     

       125
       -
       66582   92521

     

       126
       -
       72688   76209

     

       127
       -
       47389   87846

     

       128
       -
       66229   64769

     

       129
       -
       32205   70746

     

       130
       -
       95885   83814

     

       131
       -
       56440   19941

     

       132
       -
       87356   21436

     

       133
       -
       67641   92252

     

       134
       -
       20678   45960

     

       135
       -
       31065   75217

     

       136
       -
       95705   69076

     

       137
       -
       90463   44022

     

       138
       -
       51401   36472

     

       139
       -
       73186   48543

     

       140
       -
       45910   49551

     

       141
       -
       26499   84718

     

       142
       -
       94815   20415

     

       143
       -
       46840   43473

     

       144
       -
       47483   94710

     

       145
       -
       11870   43473

     

       146
       -
       28799   14080

     

       147
       -
       24832   79589

     

       148
       -
       83929   51875

     

       149
       -
       39407   53253

     

       150
       -
       73986   62364

     

       151
       -
       66614   44738

     

       152
       -
       75392   21277

     

       153
       -
       70204   55613

     

       154
       -
       99686   21718

     

       155
       -
       85726   19198

     

       156
       -
       47638   92252

     

       157
       -
       81669   30026

     

       158
       -
       70370   60748

     

       159
       -
       53783   11004

     

       160
       -
       54371   35046

     

       161
       -
       72567   87098

     

       162
       -
       87969   32178

     

       163
       -
       81067   60748

     

       164
       -
       61446   98023

     

       165
       -
       76471   92252

     

       166
       -
       64431   25697

     

       167
       -
       42080   80760

     

       168
       -
       14486   13466

     

       169
       -
       82716   52984

     

       170
       -
       49351   15539

     

       171
       -
       36159   15090

     

       172
       -
       56913   88064

     

       173
       -
       96843   44738

     

       174
       -
       66639   89714

     

       175
       -
       91239   42210

     

       176
       -
       65785   76459

     

       177
       -
       49114   86785

     

       178
       -
       58894   41438

     

       179
       -
       45307   79589

     

       180
       -
       38693   80286

     

       181
       -
       21963   52722

     

       182
       -
       46504   44738

     

       183
       -
       22201   84718

     

       184
       -
       15556   61539

     

       185
       -
       86120   86377

     

       186
       -
       21887   81067

     

       187
       -
       32242   92762

     

       188
       -
       61544   37648

     

       189
       -
       29147   73990

     

       190
       -
       24239   62852

     

       191
       -
       30163   48652

     

       192
       -
       95900   83883

     

       193
       -
       71487   60590

     

       194
       -
       69076   47403

     

       195
       -
       68557   70174

     

       196
       -
       80423   85726

     

       197
       -
       92873   10245

     

       198
       -
       59391   87955

     

       199
       -
       15416   80760

     

       200
       -
       90803   70939

     

       201
       -
       25081   81067

     

       202
       -
       10323   46564

     

       203
       -
       75418   60748

     

       204
       -
       92762   43409

     

       205
       -
       32178   20716

     

       206
       -
       72035   25025

     

       207
       -
       30702   11797

     

       208
       -
       70262   20843

     

       209
       -
       10801   60970

     

       210
       -
       69510   56933

     

       211
       -
       38295   27487

     

       212
       -
       57266   71215

     

       213
       -
       39071   92542

     

       214
       -
       20540   21718

     

       215
       -
       57027   81151

     

       216
       -
       77729   90745

     

       217
       -
       96980   28442

     

       218
       -
       65961   19198

     

       219
       -
       55385   82179

     

       220
       -
       86139   91952

     

       221
       -
       72873   61041

     

       222
       -
       95457   44738

     

       223
       -
       84209   83883

     

       224
       -
       93774   92762

     

       225
       -
       67731   14982

     

       226
       -
       81176   26473

     

       227
       -
       50239   13336

     

       228
       -
       74772   81067

     

       229
       -
       91982   80690

     

       230
       -
       40004   89466

     

       231
       -
       52769   72035

     

       232
       -
       40693   42210

     

       233
       -
       50506   26856

     

       234
       -
       71898   68597

     

       235
       -
       99210   32178

     

       236
       -
       45079   53505

     

       237
       -
       17581   94678

     

       238
       -
       83211   28309

     

       239
       -
       52582   50257

     

       240
       -
       62597   92762

     

       241
       -
       20716   38593

     

       242
       -
       18630   73077

     

       243
       -
       20835   30809

     

       244
       -
       75099   18088

     

       245
       -
       56109   42210

     

       246
       -
       31503   72884

     

       247
       -
       60392   83711

     

       248
       -
       26052   17008

     

       249
       -
       49938   20540

     

       250
       -
       16604   85679

     

       251
       -
       94700   29256

     

       252
       -
       52740   69859

     

       253
       -
       84337   25174

     

       254
       -
       46814   64723

     

       255
       -
       68259   34542

     

       256
       -
       79927   18036

     

       257
       -
       57010   78467

     

       258
       -
       73378   90472

     

       259
       -
       83131   30214

     

       260
       -
       84704   37648

     

       261
       -
       36494   40475

     

       262
       -
       43734   90827

     

       263
       -
       85678   61539

     

       264
       -
       65197   81067

     

       265
       -
       80121   24363

     

       266
       -
       97038   85579

     

       267
       -
       59873   72035

     

       268
       -
       54928   17827

     

       269
       -
       46120   33920

     

       270
       -
       68979   32133

     

       271
       -
       88690   90929

     

       272
       -
       38840   92762

     

       273
       -
       66900   67817

     

       274
       -
       59182   85839

     

       275
       -
       15538   81151

     

       276
       -
       60198   54586

     

       277
       -
       57452   71692

     

       278
       -
       12212   79875

     

       279
       -
       62853   67888

     

       280
       -
       67754   53532

     

       281
       -
       86454   52984

     

       282
       -
       94629   92403

     

       283
       -
       80986   30351

     

       284
       -
       76966   77097

     

       285
       -
       78419   92762

     

       286
       -
       12343   20540

     

       287
       -
       26294   75804

     

       288
       -
       18240   23339

     

       289
       -
       72971   58631

     

       290
       -
       69610   81067

     

       291
       -
       96198   31081

     

       292
       -
       25389   13525

     

       293
       -
       29670   76459

     

       294
       -
       39477   79589

     

       295
       -
       58028   21718

     

       296
       -
       77097   27842

     

       297
       -
       95031   78097

     

       298
       -
       32844   43989

     

       299
       -
       12618   96437

     

       300
       -
       82959   43688

     

       301
       -
       40438   20716

     

       302
       -
       58980   80760

     

       303
       -
       26176   39610

     

       304
       -
       81464   24846

     

       305
       -
       31997   35781

     

       306
       -
       82384   83883

     

       307
       -
       54010   20844

     

       308
       -
       63959   45452

     

       309
       -
       43239   16738

     

       310
       -
       45375   87524

     

       311
       -
       36278   95715

     

       312
       -
       96601   80760

     

       313
       -
       82935   27550

     

       314
       -
       13493   58808

     

       315
       -
       17988   92762

     

       316
       -
       59523   67650

     

       317
       -
       69133   44178

     

       318
       -
       59959   77097

     

       319
       -
       89068   20843

     

       320
       -
       31067   36430

     

       321
       -
       55300   23059

     

       322
       -
       36759   48277

     

       323
       -
       91317   46947

     

       324
       -
       58240   85726

     

       325
       -
       22368   92356

     

       326
       -
       60765   84751

     

       327
       -
       72733   26888

     

       328
       -
       19688   62073

     

       329
       -
       90158   57933

     

       330
       -
       11176   28442

     

       331
       -
       53051   50769

     

       332
       -
       76632   97012

     

       333
       -
       98132   80760

     

       334
       -
       73098   83281

     

       335
       -
       46753   25697

     

       336
       -
       44849   15301

     

       337
       -
       62899   74187

     

       338
       -
       71237   81067

     

       339
       -
       56670   20649

     

       340
       -
       18624   82808

     

       341
       -
       32614   34732

     

       342
       -
       98452   76464

     

       343
       -
       51626   35781

     

       344
       -
       55943   89986

     

       345
       -
       59443   72035

     

       346
       -
       96628   73132

     

       347
       -
       77928   45659

     

       348
       -
       76256   74161

     

       349
       -
       13944   94048

     

       350
       -
       12446   20843

     

       351
       -
       70331   46956

     

       352
       -
       46097   39097

     

       353
       -
       46415   83883

     

       354
       -
       29460   44307

     

       355
       -
       73685   89046

     

       356
       -
       53969   52578

     

       357
       -
       82435   40606

     

       358
       -
       65769   45167

     

       359
       -
       89700   50621

     

       360
       -
       80281   43473

     

       361
       -
       97402   60748

     

       362
       -
       11127   87361

     

       363
       -
       50692   60748

     

       364
       -
       43989   61539

     

       365
       -
       40319   11156

     

       366
       -
       85446   71698

     

       367
       -
       58820   89274

     

       368
       -
       77545   80760

     

       369
       -
       34103   37577

     

       370
       -
       83858   33573

     

       371
       -
       23402   61991

     

       372
       -
       82147   48488

     

       373
       -
       15719   80760

     

       374
       -
       16987   22112

     

       375
       -
       41519   29897

     

       376
       -
       29178   47932

     

       377
       -
       92027   25765

     

       378
       -
       92998   92252

     

       379
       -
       52103   77097

     

       380
       -
       64962   32490

     

       381
       -
       81888   29503

     

       382
       -
       92252   57018

     

       383
       -
       88397   32178

     

       384
       -
       13852   89473

     

       385
       -
       73603   20540

     

       386
       -
       95704   32178

     

       387
       -
       36045   46227

     

       388
       -
       38834   72035

     

       389
       -
       85241   60748

     

       390
       -
       94036   77097

     

       391
       -
       90984   92762

     

       392
       -
       44738   44738

     

       393
       -
       48078   76459

     

       394
       -
       40832   24578

     

       395
       -
       78789   78634

     

       396
       -
       42210   92252

     

       397
       -
       16967   61124

     

       398
       -
       76704   65696

     

       399
       -
       69647   51055

     

       400
       -
       41412   35781

     

       401
       -
       50365   63580

     

       402
       -
       33725   79129

     

       403
       -
       90837   17116

     

       404
       -
       25000   52578

     

       405
       -
       55672   81986

     

       406
       -
       50507   73820

     

       407
       -
       82260   92762

     

       408
       -
       58284   33808

     

       409
       -
       79462   43473

     

       410
       -
       76384   23808

     

       411
       -
       49652   81151

     

       412
       -
       24386   44424

     

       413
       -
       76993   77003

     

       414
       -
       11077   79166

     

       415
       -
       58255   43047

     

       416
       -
       81122   28757

     

       417
       -
       63846   30206

     

       418
       -
       69361   76459

     

       419
       -
       19338   35781

     

       420
       -
       28857   37648

     

       421
       -
       33643   89353

     

       422
       -
       61915   52984

     

       423
       -
       54227   18855

     

       424
       -
       16162   92252

     

       425
       -
       21546   60184

     

       426
       -
       15120   61012

     

       427
       -
       63185   68250

     

       428
       -
       44681   89512

     

       429
       -
       25644   80760

     

       430
       -
       12963   42210

     

       431
       -
       41952   17962

     

       432
       -
       46649   89796

     

       433
       -
       46412   68405

     

       434
       -
       32401   61539

     

       435
       -
       81393   20540

     

       436
       -
       13678   78467

     

       437
       -
       68025   99213

     

       438
       -
       27934   35781

     

       439
       -
       91794   61539

     

       440
       -
       98970   71396

     

       441
       -
       18314   69562

     

       442
       -
       19908   97620

     

       443
       -
       69828   60768

     

       444
       -
       89139   36928

     

       445
       -
       71402   25697

     

       446
       -
       64070   32178

     

       447
       -
       55145   38138

     

       448
       -
       65851   25697

     

       449
       -
       98808   67787

     

       450
       -
       57244   21718

     

       451
       -
       18541   79589

     

       452
       -
       88135   84731

     

       453
       -
       77694   61539

     

       454
       -
       52608   83313

     

       455
       -
       67204   91715

     

       456
       -
       47233   39097

     

       457
       -
       99317   37648

     

       458
       -
       84111   30506

     

       459
       -
       71316   39097

     

       460
       -
       24604   61539

     

       461
       -
       28504   58867

     

       462
       -
       64952   35781

     

       463
       -
       72718   43275

     

       464
       -
       55834   44738

     

       465
       -
       30446   92252

     

       466
       -
       37415   29159

     

       467
       -
       41743   78467

     

       468
       -
       26267   59675

     

       469
       -
       33658   11262

     

       470
       -
       50677   44738

     

       471
       -
       71609   78322

     

       472
       -
       26047   52977

     

       473
       -
       31723   21718

     

       474
       -
       44390   72035

     

       475
       -
       53788   89828

     

       476
       -
       84829   60748

     

       477
       -
       57972   32178

     

       478
       -
       93241   27703

     

       479
       -
       38576   20540

     

       480
       -
       44958   84718

     

       481
       -
       94256   47639

     

       482
       -
       41263   85109

     

       483
       -
       75946   67054

     

       484
       -
       20333   77097

     

       485
       -
       55509   95680

     

       486
       -
       39858   40117

     

       487
       -
       88032   21718

     

       488
       -
       98778   76619

     

       489
       -
       89995   18411

     

       490
       -
       28456   62071

     

       491
       -
       61789   72035

     

       492
       -
       78073   70754

     

       493
       -
       77073   31065

     

       494
       -
       86999   21718

     

       495
       -
       42298   40782

     

       496
       -
       50995   43473

     

       497
       -
       32947   20843

     

       498
       -
       40617   22994

     

       499
       -
       84633   40716

     

       500
       -
       19900   28627

     

       501
       -
       17816   68538

     

       502
       -
       32530   25156

     

       503
       -
       17673   77097

     

       504
       -
       38208   77097

     

       505
       -
       54880   78467

     

       506
       -
       10746   36942

     

       507
       -
       36110   23213

     

       508
       -
       80179   61360

     

       509
       -
       55819   35781

     

       510
       -
       28442   79589

     

       511
       -
       88289   92066

     

       512
       -
       83346   28171

     

       513
       -
       37597   74543

     

       514
       -
       45978   84718

     

       515
       -
       52946   28442

     

       516
       -
       64609   92762

     

       517
       -
       24593   39097

     

       518
       -
       92409   92252

     

       519
       -
       60718   60223

     

       520
       -
       26498   70229

     

       521
       -
       14277   35781

     

       522
       -
       90961   79589

     

       523
       -
       19915   79965

     

       524
       -
       68301   14227

     

       525
       -
       56321   80760

     

       526
       -
       15922   67051

     

       527
       -
       80444   72035

     

       528
       -
       49913   39097

     

       529
       -
       97519   83883

     

       530
       -
       81867   76459

     

       531
       -
       72049   32178

     

       532
       -
       98003   81151

     

       533
       -
       29774   84718

     

       534
       -
       83596   92936

     

       535
       -
       65711   41869

     

       536
       -
       94799   72035

     

       537
       -
       52228   74833

     

       538
       -
       35681   15295

     

       539
       -
       86161   47398

     

       540
       -
       99764   44738

     

       541
       -
       13342   66763

     

       542
       -
       19557   41667

     

       543
       -
       85701   24392

     

       544
       -
       67265   54679

     

       545
       -
       24579   60748

     

       546
       -
       99212   72720

     

       547
       -
       11279   20540

     

       548
       -
       81879   36662

     

       549
       -
       42791   12924

     

       550
       -
       98914   75630

     

       551
       -
       29879   52984

     

       552
       -
       87696   69076

     

       553
       -
       54212   32065

     

       554
       -
       30014   76459

     

       555
       -
       43433   64434

     

       556
       -
       31827   43749

     

       557
       -
       27323   32614

     

       558
       -
       47887   78467

     

       559
       -
       12778   90971

     

       560
       -
       38504   25697

     

       561
       -
       11985   12152

     

       562
       -
       88281   32178

     

       563
       -
       60313   18405

     

       564
       -
       84487   44738

     

       565
       -
       10753   76459

     

       566
       -
       11349   59672

     

       567
       -
       58532   69076

     

       568
       -
       37463   81151

     

       569
       -
       74158   17588

     

       570
       -
       47713   16319

     

       571
       -
       52617   99026

     

       572
       -
       75642   54241

     

       573
       -
       86070   84718

     

       574
       -
       89264   68926

     

       575
       -
       13839   84718

     

       576
       -
       16425   22018

     

       577
       -
       15973   35781

     

       578
       -
       97324   39267

     

       579
       -
       74858   93659

     

       580
       -
       30114   82028

     

       581
       -
       91599   92765

     

       582
       -
       47093   37648

     

       583
       -
       50285   60748

     

       584
       -
       14846   15314

     

       585
       -
       89741   83883

     

       586
       -
       27133   42151

     

       587
       -
       38409   39097

     

       588
       -
       34370   60748

     

       589
       -
       43982   69423

     

       590
       -
       22858   20843

     

       591
       -
       57345   34197

     

       592
       -
       40807   61764

     

       593
       -
       75561   28363

     

       594
       -
       14111   34713

     

       595
       -
       49442   81067

     

       596
       -
       61122   53151

     

       597
       -
       97636   25131

     

       598
       -
       43772   25697

     

       599
       -
       55030   83358

     

       600
       -
       52741   23263

     

       601
       -
       74578   81559

     

       602
       -
       50656   34834

     

       603
       -
       62586   23884

     

       604
       -
       99380   73924

     

       605
       -
       41885   46691

     

       606
       -
       95691   23340

     

       607
       -
       68929   18409

     

       608
       -
       32180   25515

     

       609
       -
       27880   69609

     

       610
       -
       15658   25697

     

       611
       -
       40225   76459

     

       612
       -
       54028   95026

     

       613
       -
       51248   83206

     

       614
       -
       55585   44495

     

       615
       -
       34730   36987

     

       616
       -
       72713   43473

     

       617
       -
       48744   43473

     

       618
       -
       50628   44738

     

       619
       -
       66099   81067

     

       620
       -
       84471   82826

     

       621
       -
       74726   43646

     

       622
       -
       63777   80760

     

       623
       -
       38782   10687

     

       624
       -
       62565   32178

     

       625
       -
       30082   36088

     

       626
       -
       66224   25697

     

       627
       -
       17798   39097

     

       628
       -
       65148   37648

     

       629
       -
       50731   66803

     

       630
       -
       60010   16037

     

       631
       -
       71057   20540

     

       632
       -
       79087   47464

     

       633
       -
       63666   37648

     

       634
       -
       61860   74023

     

       635
       -
       46372   33274

     

       636
       -
       40076   97575

     

       637
       -
       81205   25697

     

       638
       -
       29232   48419

     

       639
       -
       91161   25173

     

       640
       -
       80675   51474

     

       641
       -
       45465   75816

     

       642
       -
       80432   80760

     

       643
       -
       84712   73906

     

       644
       -
       32924   96322

     

       645
       -
       27386   25697

     

       646
       -
       35781   80760

     

       647
       -
       28248   77822

     

       648
       -
       33634   48276

     

       649
       -
       93878   48409

     

       650
       -
       26858   59450

     

       651
       -
       63868   42103

     

       652
       -
       94063   13352

     

       653
       -
       26657   52984

     

       654
       -
       65635   92762

     

       655
       -
       47508   11445

     

       656
       -
       87138   83597

     

       657
       -
       33328   62612

     

       658
       -
       70031   85726

     

       659
       -
       81151   23518

     

       660
       -
       42263   32662

     

       661
       -
       85424   71871

     

       662
       -
       21504   72035

     

       663
       -
       76646   90060

     

       664
       -
       36770   31991

     

       665
       -
       76459   43473

     

       666
       -
       58215   44495

     

       667
       -
       20418   86232

     

       668
       -
       68543   81067

     

       669
       -
       71082   52984

     

       670
       -
       24484   86494

     

       671
       -
       70941   98749

     

       672
       -
       71613   24014

     

       673
       -
       98938   35781

     

       674
       -
       42671   25697

     

       675
       -
       11798   25697

     

       676
       -
       55015   81601

     

       677
       -
       92532   78131

     

       678
       -
       10415   43260

     

       679
       -
       89920   11599

     

       680
       -
       36610   30402

     

       681
       -
       11196   46252

     

       682
       -
       61243   80760

     

       683
       -
       47794   15435

     

       684
       -
       10054   40848

     

       685
       -
       90743   52578

     

       686
       -
       12980   92252

     

       687
       -
       43206   92762

     

       688
       -
       23376   69724

     

       689
       -
       45693   77097

     

       690
       -
       79629   70562

     

       691
       -
       69524   20540

     

       692
       -
       30811   48749

     

       693
       -
       76688   51485

     

       694
       -
       50584   77097

     

       695
       -
       46173   35918

     

       696
       -
       22138   92762

     

       697
       -
       98933   52984

     

       698
       -
       55451   42210

     

       699
       -
       97723   34368

     

       700
       -
       39097   60748

     

       701
       -
       29080   78467

     

       702
       -
       58962   78467

     

       703
       -
       71265   13782

     

       704
       -
       14559   20716

     

       705
       -
       14366   20540

     

       706
       -
       68344   72035

     

       707
       -
       48432   88048

     

       708
       -
       38005   43473

     

       709
       -
       85989   93533

     

       710
       -
       98422   83883

     

       711
       -
       20685   80045

     

       712
       -
       69814   72035

     

       713
       -
       11356   28819

     

       714
       -
       39329   20843

     

       715
       -
       52898   19198

     

       716
       -
       43135   25697

     

       717
       -
       20409   25697

     

       718
       -
       52446   34899

     

       719
       -
       63515   84718

     

       720
       -
       19371   20540

     

       721
       -
       16430   20540

     

       722
       -
       45803   74304

     

       723
       -
       66092   33425

     

       724
       -
       80760   95646

     

       725
       -
       64945   37648

     

       726
       -
       43951   78467

     

       727
       -
       87271   17766

     

       728
       -
       91354   75924

     

       729
       -
       32506   37648

     

       730
       -
       15452   79052

     

       731
       -
       87783   42991

     

       732
       -
       90937   75439

     

       733
       -
       68208   97868

     

       734
       -
       91228   92252

     

       735
       -
       35773   92762

     

       736
       -
       74252   32178

     

       737
       -
       96573   74280

     

       738
       -
       29447   31544

     

       739
       -
       61206   62085

     

       740
       -
       75242   75894

     

       741
       -
       76850   77838

     

       742
       -
       22095   24247

     

       743
       -
       78467   55285

     

       744
       -
       27611   20540

     

       745
       -
       18974   84363

     

       746
       -
       74621   83883

     

       747
       -
       19469   19323

     

       748
       -
       26785   25697

     

       749
       -
       99803   77726

     

       750
       -
       96042   21449

     

       751
       -
       61772   39950

     

       752
       -
       21746   79309

     

       753
       -
       44817   14075

     

       754
       -
       65817   54251

     

       755
       -
       90360   84880

     

       756
       -
       40529   83883

     

       757
       -
       63336   62916

     

       758
       -
       57489   39191

     

       759
       -
       41980   76639

     

       760
       -
       61947   69076

     

       761
       -
       72393   92252

     

       762
       -
       72994   20540

     

       763
       -
       38393   42671

     

       764
       -
       61264   25490

     

       765
       -
       28725   27770

     

       766
       -
       68461   83883

     

       767
       -
       68050   19198

     

       768
       -
       97146   44738

     

       769
       -
       13195   32178

     

       770
       -
       48395   14399

     

       771
       -
       55269   12291

     

       772
       -
       43616   62312

     

       773
       -
       76357   19177

     

       774
       -
       50496   55565

     

       775
       -
       97083   24002

     

       776
       -
       32806   69076

     

       777
       -
       71713   47157

     

       778
       -
       91635   92762

     

       779
       -
       23121   20540

     

       780
       -
       27917   92762

     

       781
       -
       61595   77858

     

       782
       -
       96038   78467

     

       783
       -
       51300   30664

     

       784
       -
       99332   39795

     

       785
       -
       49914   33272

     

       786
       -
       87083   54823

     

       787
       -
       39253   99039

     

       788
       -
       98686   23548

     

       789
       -
       63961   20540

     

       790
       -
       76429   42671

     

       791
       -
       84657   78621

     

       792
       -
       18867   58861

     

       793
       -
       28534   92703

     

       794
       -
       20843   72035

     

       795
       -
       40011   42210

     

       796
       -
       28716   35781

     

       797
       -
       64363   94627

     

       798
       -
       41215   39358

     

       799
       -
       74285   77374

     

       800
       -
       37245   20843

     

       801
       -
       53602   35781

     

       802
       -
       73935   90042

     

       803
       -
       35283   25697

     

       804
       -
       84164   92252

     

       805
       -
       26264   19198

     

       806
       -
       49434   92252

     

       807
       -
       67281   76459

     

       808
       -
       47315   37648

     

       809
       -
       21216   70552

     

       810
       -
       57730   44738

     

       811
       -
       55530   83883

     

       812
       -
       23807   60687

     

       813
       -
       79378   65500

     

       814
       -
       81270   19442

     

       815
       -
       89580   78935

     

       816
       -
       81287   76459

     

       817
       -
       37987   82563

     

       818
       -
       29721   71638

     

       819
       -
       76282   93445

     

       820
       -
       82973   44738

     

       821
       -
       43095   76459

     

       822
       -
       57911   42481

     

       823
       -
       15665   30034

     

       824
       -
       97099   20843

     

       825
       -
       77440   61539

     

       826
       -
       61564   40937

     

       827
       -
       38697   50046

     

       828
       -
       91585   71537

     

       829
       -
       66058   44507

     

       830
       -
       96221   92762

     

       831
       -
       80464   31623

     

       832
       -
       52031   88911

     

       833
       -
       74599   81151

     

       834
       -
       44495   81151

     

       835
       -
       37781   50336

     

       836
       -
       42333   92252

     

       837
       -
       25393   37648

     

       838
       -
       31875   40879

     

       839
       -
       25513   60748

     

       840
       -
       52578   20540

     

       841
       -
       83883   67476

     

       842
       -
       13961   80760

     

       843
       -
       86512   72429

     

       844
       -
       52957   37648

     

       845
       -
       70656   20843

     

       846
       -
       32267   78467

     

       847
       -
       67751   23702

     

       848
       -
       83650   76459

     

       849
       -
       11249   44738

     

       850
       -
       82052   44240

     

       851
       -
       60178   19059

     

       852
       -
       78052   80760

     

       853
       -
       92063   42210

     

       854
       -
       47149   42671

     

       855
       -
       82429   61080

     

       856
       -
       24749   68627

     

       857
       -
       26862   32614

     

       858
       -
       77843   56271

     

       859
       -
       24471   41563

     

       860
       -
       15084   62867

     

       861
       -
       15444   43417

     

       862
       -
       15492   61539

     

       863
       -
       22651   80760

     

       864
       -
       62625   21763

     

       865
       -
       49448   48757

     

       866
       -
       47125   36097

     

       867
       -
       45650   21134

     

       868
       -
       76382   40592

     

       869
       -
       28236   81067

     

       870
       -
       24712   28270

     

       871
       -
       26908   63823

     

       872
       -
       51661   92252

     

       873
       -
       33112   54575

     

       874
       -
       59018   52984

     

       875
       -
       12648   35781

     

       876
       -
       47726   76268

     

       877
       -
       16833   15099

     

       878
       -
       17720   24491

     

       879
       -
       64016   31467

     

       880
       -
       62900   37648

     

       881
       -
       66411   97080

     

       882
       -
       47653   32178

     

       883
       -
       78845   16864

     

       884
       -
       98508   26852

     

       885
       -
       83446   10379

     

       886
       -
       50837   40936

     

       887
       -
       85485   63694

     

       888
       -
       41709   37648

     

       889
       -
       84178   28689

     

       890
       -
       27821   57472

     

       891
       -
       89199   43473

     

       892
       -
       95089   43852

     

       893
       -
       80677   20716

     

       894
       -
       84551   20125

     

       895
       -
       84718   11853

     

       896
       -
       14520   20843

     

       897
       -
       61473   92762

     

       898
       -
       69357   37320

     

       899
       -
       36592   24917

     

       900
       -
       88660   35781

     

       901
       -
       92407   20540

     

       902
       -
       17708   20540

     

       903
       -
       27217   12607

     

       904
       -
       51540   44495

     

       905
       -
       93978   77706

     

       906
       -
       83790   34181

     

       907
       -
       46160   69737

     

       908
       -
       21508   54282

     

       909
       -
       20593   84718

     

       910
       -
       12368   38902

     

       911
       -
       46760   16081

     

       912
       -
       46693   75780

     

       913
       -
       90007   89913

     

       914
       -
       63689   76234

     

       915
       -
       98781   92745

     

       916
       -
       77580   44738

     

       917
       -
       24571   39242

     

       918
       -
       37950   98910

     

       919
       -
       63333   76587

     

       920
       -
       14765   74779

     

       921
       -
       41979   55432

     

       922
       -
       65602   13148

     

       923
       -
       34240   32614

     

       924
       -
       40909   22506

     

       925
       -
       25236   78757

     

       926
       -
       56096   32614

     

       927
       -
       85735   39877

     

       928
       -
       37637   52969

     

       929
       -
       34344   33132

     

       930
       -
       53389   47303

     

       931
       -
       66490   36750

     

       932
       -
       18024   48801

     

       933
       -
       45153   91679

     

       934
       -
       94052   20540

     

       935
       -
       67564   74190

     

       936
       -
       54685   84718

     

       937
       -
       89848   69076

     

       938
       -
       15698   44738

     

       939
       -
       67033   35486

     

       940
       -
       23435   24004

     

       941
       -
       99883   69819

     

       942
       -
       32300   68680

     

       943
       -
       82028   21625

     

       944
       -
       19382   78452

     

       945
       -
       40073   37648

     

       946
       -
       86881   31642

     

       947
       -
       42474   41279

     

       948
       -
       59165   80760

     

       949
       -
       60370   34541

     

       950
       -
       74295   73389

     

       951
       -
       98654   42210

     

       952
       -
       87697   39399

     

       953
       -
       68417   55320

     

       954
       -
       32125   87304

     

       955
       -
       23153   51288

     

       956
       -
       32963   12352

     

       957
       -
       18366   57673

     

       958
       -
       74792   50327

     

       959
       -
       78281   43473

     

       960
       -
       41693   49359

     

       961
       -
       41188   35781

     

       962
       -
       19719   72035

     

       963
       -
       44395   72831

     

       964
       -
       75495   78467

     

       965
       -
       14585   21023

     

       966
       -
       94358   23804

     

       967
       -
       13464   23423

     

       968
       -
       58483   85726

     

       969
       -
       44941   69076

     

       970
       -
       91349   12344

     

       971
       -
       95485   83883

     

       972
       -
       58981   65861

     

       973
       -
       43473   61539

     

       974
       -
       51945   69762

     

       975
       -
       40385   44738

     

       976
       -
       32646   42174

     

       977
       -
       73150   81067

     

       978
       -
       12154   37648

     

       979
       -
       55441   20843

     

       980
       -
       98025   39097

     

       981
       -
       15339   38796

     

       982
       -
       31543   42210

     

       983
       -
       65949   42245

     

       984
       -
       31434   32614

     

       985
       -
       57312   57203

     

       986
       -
       91833   76885

     

       987
       -
       23286   52984

     

       988
       -
       58987   32178

     

       989
       -
       12591   37648

     

       990
       -
       37648   32316

     

       991
       -
       97542   35781

     

       992
       -
       33381   44140

     

       993
       -
       69851   92540

     

       994
       -
       60076   19198

     

       995
       -
       86697   32614

     

       996
       -
       25533   96431

     

       997
       -
       68777   15175

     

       998
       -
       47390   75651

     

       999
       -
       94550   80760

     

       1000
       -
       61539   20843

+54

2024/day_02.f90

···

       1
       +
       program day_02

     

       2
       +
          implicit none

     

       3
       +
          logical :: is_decrement, fail

     

       4
       +
          integer :: io, i,x, spaces, res

     

       5
       +
          integer, dimension(:), allocatable :: list

     

       6
       +
          character(len=100) :: line

     

       7
       +
       

     

       8
       +
          open(newunit=io, file='./day_02_input.txt', status='old', action='read')

     

       9
       +
       

     

       10
       +
          res = 0

     

       11
       +
          do i = 1, 1000

     

       12
       +
             read(io, '(a)') line ! reading the line

     

       13
       +
             spaces = 1 ! reset space count

     

       14
       +
             do x = 1, len(trim(line))

     

       15
       +
                ! counting spaces to see how big of an array we need to allocate

     

       16
       +
                if(iachar(line(x:x))== 32 ) then

     

       17
       +
                   spaces = spaces+1

     

       18
       +
                end if

     

       19
       +
             end do

     

       20
       +
       

     

       21
       +
             allocate(list(spaces))

     

       22
       +
             read(line, *) list !reading the ints into an array

     

       23
       +
             fail = .false.

     

       24
       +
       

     

       25
       +
             do x = 1, size(list) -1

     

       26
       +
                if (list(x) == list(x+1)) then

     

       27
       +
                   fail = .true.

     

       28
       +
                   exit

     

       29
       +
                end if

     

       30
       +
                if(x == 1 .and. list(x) > list(x+1)) then

     

       31
       +
                   is_decrement = .true.

     

       32
       +
                else if (x==1 .and. list(x) < list(x+1)) then

     

       33
       +
                   is_decrement = .false.

     

       34
       +
                end if

     

       35
       +
       

     

       36
       +
                if(is_decrement)  then

     

       37
       +
                   if (list(x) < list(x+1) .or. abs(list(x) - list(x+1)) > 3) then

     

       38
       +
                      fail = .true.

     

       39
       +
                      exit

     

       40
       +
                   end if

     

       41
       +
                else

     

       42
       +
                   if (list(x) >  list(x+1) .or. abs(list(x) - list(x+1)) > 3) then

     

       43
       +
                      fail = .true.

     

       44
       +
                      exit

     

       45
       +
                   end if

     

       46
       +
                end if

     

       47
       +
             end do

     

       48
       +
             if (fail .eqv. .false.) then

     

       49
       +
                res = res + 1

     

       50
       +
             endif

     

       51
       +
             deallocate(list)

     

       52
       +
          end do

     

       53
       +
          print*, res

     

       54
       +
       end program day_02

+50

2024/day_02.ml

···

       1
       +
       let filename = "./day_02_input.txt"

     

       2
       +
       let try_read ic = try Some (input_line ic) with End_of_file -> None

     

       3
       +
       

     

       4
       +
       let is_values_safe a b direction =

     

       5
       +
         match direction with

     

       6
       +
         | "up" -> a < b && abs (a - b) < 4

     

       7
       +
         | "down" -> a > b && abs (a - b) < 4

     

       8
       +
         | _ -> false

     

       9
       +
       

     

       10
       +
       let direction a b = if a < b then "up" else "down"

     

       11
       +
       

     

       12
       +
       let is_line_safe list =

     

       13
       +
         let a, b = (List.hd list, List.tl list |> List.hd) in

     

       14
       +
         let direction = direction a b in

     

       15
       +
         List.fold_left

     

       16
       +
           (fun (acc, prev) x ->

     

       17
       +
             if prev > -1 then (acc && is_values_safe prev x direction, x) else (acc, x))

     

       18
       +
           (true, -1) list

     

       19
       +
         |> fst

     

       20
       +
       

     

       21
       +
       let is_line_safe_part_2 list =

     

       22
       +
         List.mapi

     

       23
       +
           (fun i _ -> List.filteri (fun j _ -> j <> i) list |> is_line_safe)

     

       24
       +
           list

     

       25
       +
         |> List.exists (fun x -> x)

     

       26
       +
       

     

       27
       +
       let calculate_safe_score ic is_line_safe =

     

       28
       +
         let rec calculate acc =

     

       29
       +
           match try_read ic with

     

       30
       +
           | Some line -> (

     

       31
       +
               match

     

       32
       +
                 is_line_safe (String.split_on_char ' ' line |> List.map int_of_string)

     

       33
       +
               with

     

       34
       +
               | true -> calculate (acc + 1)

     

       35
       +
               | false -> calculate acc)

     

       36
       +
           | None ->

     

       37
       +
               close_in ic;

     

       38
       +
               acc

     

       39
       +
         in

     

       40
       +
         calculate 0

     

       41
       +
       

     

       42
       +
       let () =

     

       43
       +
         let ic = open_in filename in

     

       44
       +
         calculate_safe_score ic is_line_safe

     

       45
       +
         |> Printf.sprintf "Safe %d" |> print_endline;

     

       46
       +
       

     

       47
       +
         let ic = open_in filename in

     

       48
       +
         calculate_safe_score ic is_line_safe_part_2

     

       49
       +
         |> Printf.sprintf "Part 2 Safe %d"

     

       50
       +
         |> print_endline

+90

2024/day_02_part_2.f90

···

       1
       +
       module day2_utils

     

       2
       +
          implicit none

     

       3
       +
       contains

     

       4
       +
          subroutine is_safe(list, res)

     

       5
       +
             implicit none

     

       6
       +
             integer, allocatable, intent(in) :: list(:)

     

       7
       +
             logical, intent(out):: res

     

       8
       +
             integer :: i, diff

     

       9
       +
             logical is_decrement

     

       10
       +
       

     

       11
       +
             res = .true.

     

       12
       +
             is_decrement = .false.

     

       13
       +
             do i = 1, size(list) - 1

     

       14
       +
                if(i == 1 .and. list(i) > list(i+1)) then

     

       15
       +
                   is_decrement = .true.

     

       16
       +
                end if

     

       17
       +
                diff = abs(list(i) - list(i+1))

     

       18
       +
                if(is_decrement)  then

     

       19
       +
                   if (list(i) < list(i+1) .or. diff > 3 .or. diff < 1) then

     

       20
       +
                      res = .false.

     

       21
       +
                      exit

     

       22
       +
                   end if

     

       23
       +
                else

     

       24
       +
                   if (list(i) >  list(i+1) .or. diff > 3 .or. diff < 1) then

     

       25
       +
                      res = .false.

     

       26
       +
                      exit

     

       27
       +
                   end if

     

       28
       +
                end if

     

       29
       +
             end do

     

       30
       +
          end subroutine is_safe

     

       31
       +
          subroutine safe_with_dampener(list, res)

     

       32
       +
             implicit none

     

       33
       +
             integer, allocatable, intent(in) :: list(:)

     

       34
       +
             integer, allocatable :: work(:)

     

       35
       +
             logical, intent(out):: res

     

       36
       +
             integer :: i, x, idx

     

       37
       +
             res = .true.

     

       38
       +
             call is_safe(list, res)

     

       39
       +
             if(.not. res) then

     

       40
       +
                allocate(work(size(list)-1))

     

       41
       +
                do i = 1, size(list)

     

       42
       +
                   idx = 1

     

       43
       +
                   do x = 1, size(list)

     

       44
       +
                      if (x /= i) then

     

       45
       +
                         work(idx) = list(x)

     

       46
       +
                         idx = idx + 1

     

       47
       +
                      end if

     

       48
       +
                   end do

     

       49
       +
                   res = .true.

     

       50
       +
                   call is_safe(work, res)

     

       51
       +
                   if(res) then

     

       52
       +
                      exit

     

       53
       +
                   end if

     

       54
       +
                end do

     

       55
       +
             end if

     

       56
       +
          end subroutine safe_with_dampener

     

       57
       +
       end module day2_utils

     

       58
       +
       

     

       59
       +
       program day_02_part_2

     

       60
       +
          use day2_utils

     

       61
       +
          implicit none

     

       62
       +
          logical :: is_decrement, safe

     

       63
       +
          integer :: io, i, x, spaces, res

     

       64
       +
          integer, dimension(:), allocatable :: list

     

       65
       +
          character(len=100) :: line

     

       66
       +
       

     

       67
       +
          open(newunit=io, file='./day_02_input.txt', status='old', action='read')

     

       68
       +
       

     

       69
       +
          res = 0

     

       70
       +
          do i = 1, 1000

     

       71
       +
             read(io, '(a)') line ! reading the line

     

       72
       +
             spaces = 1 ! reset space count

     

       73
       +
             do x = 1, len(trim(line))

     

       74
       +
                ! counting spaces to see how big of an array we need to allocate

     

       75
       +
                if(iachar(line(x:x))== 32 ) then

     

       76
       +
                   spaces = spaces+1

     

       77
       +
                end if

     

       78
       +
             end do

     

       79
       +
       

     

       80
       +
             allocate(list(spaces))

     

       81
       +
             read(line, *) list !reading the ints into an array

     

       82
       +
             safe = .true. !set fail to false by default

     

       83
       +
             call safe_with_dampener(list, safe) ! check if the array has a fail idx

     

       84
       +
             if (safe) then

     

       85
       +
                res = res + 1

     

       86
       +
             endif

     

       87
       +
             deallocate(list)

     

       88
       +
          end do

     

       89
       +
          print*, res

     

       90
       +
       end program day_02_part_2

+65

2024/day_03.f90

···

       1
       +
       program day_03

     

       2
       +
          implicit none

     

       3
       +
          logical :: find_a

     

       4
       +
          integer ::io, ios, a, b, state, res

     

       5
       +
          character(len=1) :: c

     

       6
       +
          character(len=10) :: buffer

     

       7
       +
          character(len=4) :: mul_cmd = 'mul('

     

       8
       +
       

     

       9
       +
          res = 0

     

       10
       +
          open(newunit=io, file='./day_03_input.txt', status='old', action='read', access='stream')

     

       11
       +
          state = 0 ! 0 = find command, 1 = find number, 2 = calculate

     

       12
       +
          find_a = .true.

     

       13
       +
          buffer = ''

     

       14
       +
          do

     

       15
       +
             read(io, iostat=ios) c

     

       16
       +
             if (ios /= 0) exit

     

       17
       +
             select case(state)

     

       18
       +
              case (0) ! find command

     

       19
       +
                buffer = trim(buffer) // c

     

       20
       +
                if(buffer == mul_cmd) then

     

       21
       +
                   state = 1

     

       22
       +
                   buffer = ''

     

       23
       +
                else if(trim(buffer) /= mul_cmd(1:len(trim(buffer)))) then

     

       24
       +
                   state = 0

     

       25
       +
                   buffer = ''

     

       26
       +
                end if

     

       27
       +
              case (1) ! find digits

     

       28
       +
                select case (iachar(c))

     

       29
       +
                 case (48:57) ! 0-9

     

       30
       +
                   buffer = trim(buffer) // c

     

       31
       +
                 case (44) ! ,

     

       32
       +
                   if (find_a .and. len(trim(buffer)) > 0) then

     

       33
       +
                      read(buffer, *) a

     

       34
       +
                      buffer = ''

     

       35
       +
                      find_a = .false.

     

       36
       +
                   else

     

       37
       +
                      state = 0 ! invalid

     

       38
       +
                      find_a = .true.

     

       39
       +
                      buffer = ''

     

       40
       +
                   end if

     

       41
       +
                 case (41) ! )

     

       42
       +
                   if(.not. find_a .and. len(trim(buffer)) > 0) then

     

       43
       +
                      read(buffer, *) b

     

       44
       +
                      state = 2

     

       45
       +
                      find_a = .true.

     

       46
       +
                      buffer = ''

     

       47
       +
                   else

     

       48
       +
                      state = 0

     

       49
       +
                      find_a = .true.

     

       50
       +
                      buffer = ''

     

       51
       +
                   end if

     

       52
       +
                 case default

     

       53
       +
                   state = 0

     

       54
       +
                   find_a = .true.

     

       55
       +
                   buffer = ''

     

       56
       +
                end select

     

       57
       +
             end select

     

       58
       +
             if(state == 2) then

     

       59
       +
                res = res + (a * b)

     

       60
       +
                state = 0

     

       61
       +
                buffer = ''

     

       62
       +
             end if

     

       63
       +
          end do

     

       64
       +
          print*, res

     

       65
       +
       end program day_03

+45

2024/day_03.ml

···

       1
       +
       let filename = "./day_03_input.txt"

     

       2
       +
       let try_read ic = try Some (input_line ic) with End_of_file -> None

     

       3
       +
       

     

       4
       +
       let read_file ic =

     

       5
       +
         let rec read acc =

     

       6
       +
           match try_read ic with

     

       7
       +
           | Some line -> read (line :: acc)

     

       8
       +
           | None ->

     

       9
       +
               close_in ic;

     

       10
       +
               acc

     

       11
       +
         in

     

       12
       +
         read [] |> List.rev |> String.concat ""

     

       13
       +
       

     

       14
       +
       let regex_mul = Str.regexp "mul(\\([0-9]+\\),\\([0-9]+\\))"

     

       15
       +
       let regex_mul_part_2 = Str.regexp "mul(\\([0-9]+\\),\\([0-9]+\\))\\|don't()"

     

       16
       +
       let regex_do_part_2 = Str.regexp "do()"

     

       17
       +
       

     

       18
       +
       let calculate_total str regexp =

     

       19
       +
         let rec calculate str regexp acc =

     

       20
       +
           try

     

       21
       +
             let _ = Str.search_forward regexp str 0 in

     

       22
       +
             let cmd = Str.matched_group 0 str in

     

       23
       +
             let new_str =

     

       24
       +
               String.sub str (Str.match_end ()) (String.length str - Str.match_end ())

     

       25
       +
             in

     

       26
       +
             match cmd with

     

       27
       +
             | "do()" -> calculate new_str regex_mul_part_2 acc

     

       28
       +
             | "don't()" -> calculate new_str regex_do_part_2 acc

     

       29
       +
             | cmd when String.starts_with ~prefix:"mul" cmd ->

     

       30
       +
                 let a = Str.matched_group 1 str |> int_of_string in

     

       31
       +
                 let b = Str.matched_group 2 str |> int_of_string in

     

       32
       +
                 calculate new_str regexp (acc + (a * b))

     

       33
       +
             | _ -> acc

     

       34
       +
           with Not_found -> acc

     

       35
       +
         in

     

       36
       +
         calculate str regexp 0

     

       37
       +
       

     

       38
       +
       let () =

     

       39
       +
         let ic = open_in filename in

     

       40
       +
         let data = read_file ic in

     

       41
       +
         calculate_total data regex_mul |> Printf.sprintf "Sum %d" |> print_endline;

     

       42
       +
       

     

       43
       +
         calculate_total data regex_mul_part_2

     

       44
       +
         |> Printf.sprintf "Part 2 Sum %d"

     

       45
       +
         |> print_endline

+83

2024/day_03_part_2.f90

···

       1
       +
       program day_03_part_2

     

       2
       +
          implicit none

     

       3
       +
          logical :: find_a, is_dont

     

       4
       +
          integer ::io, ios, a, b, state, res

     

       5
       +
          character(len=1) :: c

     

       6
       +
          character(len=10) :: buffer

     

       7
       +
          character(len=4) :: mul_cmd = 'mul('

     

       8
       +
          character(len=7) :: dont_cmd = "don't()"

     

       9
       +
          character(len=4) :: do_cmd = 'do()'

     

       10
       +
       

     

       11
       +
          res = 0

     

       12
       +
          open(newunit=io, file='./day_03_input.txt', status='old', action='read', access='stream')

     

       13
       +
          state = 0 ! 0 = find command, 1 = find number, 2 = calculate

     

       14
       +
          find_a = .true.

     

       15
       +
          is_dont = .false.

     

       16
       +
          buffer = ''

     

       17
       +
          do

     

       18
       +
             read(io, iostat=ios) c

     

       19
       +
             if (ios /= 0) exit

     

       20
       +
             select case(state)

     

       21
       +
              case (0) ! find command

     

       22
       +
                buffer = trim(buffer) // c

     

       23
       +
                if(is_dont) then

     

       24
       +
                   if (trim(buffer) == do_cmd) then

     

       25
       +
                      state = 0

     

       26
       +
                      buffer = ''

     

       27
       +
                      is_dont = .false.

     

       28
       +
                   else if (trim(buffer) /= do_cmd(1:len(trim(buffer)))) then

     

       29
       +
                      state = 0

     

       30
       +
                      buffer = ''

     

       31
       +
                   end if

     

       32
       +
                else

     

       33
       +
                   if (trim(buffer) == dont_cmd) then

     

       34
       +
                      state = 0

     

       35
       +
                      buffer = ''

     

       36
       +
                      is_dont = .true.

     

       37
       +
                   else if(trim(buffer) == mul_cmd) then

     

       38
       +
                      state = 1

     

       39
       +
                      buffer = ''

     

       40
       +
                   else if(trim(buffer) /= mul_cmd(1:len(trim(buffer))) .and. trim(buffer) /= dont_cmd(1:len(trim(buffer)))) then

     

       41
       +
                      state = 0

     

       42
       +
                      buffer = ''

     

       43
       +
                   end if

     

       44
       +
                end if

     

       45
       +
              case (1) ! find digits

     

       46
       +
                select case (iachar(c))

     

       47
       +
                 case (48:57) ! 0-9

     

       48
       +
                   buffer = trim(buffer) // c

     

       49
       +
                 case (44) ! ,

     

       50
       +
                   if (find_a .and. len(trim(buffer)) > 0) then

     

       51
       +
                      read(buffer, *) a

     

       52
       +
                      buffer = ''

     

       53
       +
                      find_a = .false.

     

       54
       +
                   else

     

       55
       +
                      state = 0 ! invalid

     

       56
       +
                      find_a = .true.

     

       57
       +
                      buffer = ''

     

       58
       +
                   end if

     

       59
       +
                 case (41) ! )

     

       60
       +
                   if(.not. find_a .and. len(trim(buffer)) > 0) then

     

       61
       +
                      read(buffer, *) b

     

       62
       +
                      state = 2

     

       63
       +
                      find_a = .true.

     

       64
       +
                      buffer = ''

     

       65
       +
                   else

     

       66
       +
                      state = 0

     

       67
       +
                      find_a = .true.

     

       68
       +
                      buffer = ''

     

       69
       +
                   end if

     

       70
       +
                 case default

     

       71
       +
                   state = 0

     

       72
       +
                   find_a = .true.

     

       73
       +
                   buffer = ''

     

       74
       +
                end select

     

       75
       +
             end select

     

       76
       +
             if(state == 2) then

     

       77
       +
                res = res + (a * b)

     

       78
       +
                state = 0

     

       79
       +
                buffer = ''

     

       80
       +
             end if

     

       81
       +
          end do

     

       82
       +
          print*, res

     

       83
       +
       end program day_03_part_2

+78

2024/day_04.f90

···

       1
       +
       module day_04_utils

     

       2
       +
          implicit none

     

       3
       +
       contains

     

       4
       +
          recursive function find_xmas(arr, row, col,row_dir, col_dir, search_letter) result(found)

     

       5
       +
             implicit none

     

       6
       +
             character(len=140), intent(in), allocatable :: arr(:)

     

       7
       +
             character(len=1), intent(in) :: search_letter

     

       8
       +
             integer, intent(in) :: row, col, row_dir, col_dir

     

       9
       +
             integer :: new_row, new_col

     

       10
       +
             logical :: found

     

       11
       +
       

     

       12
       +
             if(arr(row)(col:col) == search_letter) then

     

       13
       +
                if(search_letter == 'S') then

     

       14
       +
                   found = .true.

     

       15
       +
                else

     

       16
       +
                   new_row = row + row_dir

     

       17
       +
                   new_col = col + col_dir

     

       18
       +
                   if(new_row > len(arr(row)) .or. new_row < 1 .or. new_col > size(arr) .or. new_col < 1) then

     

       19
       +
                      found = .false.

     

       20
       +
                   else

     

       21
       +
                      select case(search_letter)

     

       22
       +
                       case('M')

     

       23
       +
                         found = find_xmas(arr, new_row, new_col, row_dir, col_dir, 'A')

     

       24
       +
                       case('A')

     

       25
       +
                         found = find_xmas(arr, new_row, new_col, row_dir, col_dir, 'S')

     

       26
       +
                      end select

     

       27
       +
                   end if

     

       28
       +
                end if

     

       29
       +
             else

     

       30
       +
                found = .false.

     

       31
       +
             end if

     

       32
       +
          end function find_xmas

     

       33
       +
       end module day_04_utils

     

       34
       +
       program day_04

     

       35
       +
          use day_04_utils

     

       36
       +
          implicit none

     

       37
       +
          character(len=140) , allocatable :: lines(:)

     

       38
       +
          integer :: io, row, col, score, z

     

       39
       +
          logical :: found

     

       40
       +
       

     

       41
       +
          score = 0

     

       42
       +
          open(newunit=io, file='./day_04_input.txt', status='old', action='read')

     

       43
       +
          allocate(lines(140))

     

       44
       +
          read(io, '(a)') lines

     

       45
       +
          do row = 1, size(lines)

     

       46
       +
             do col = 1, len(lines(row))

     

       47
       +
                if (lines(row)(col:col) == 'X') then

     

       48
       +
                   do z = 1, 8

     

       49
       +
                      found = .false.

     

       50
       +
                      select case (z)

     

       51
       +
                       case(1)

     

       52
       +
                         found = find_xmas(lines, row, col-1, 0, -1, 'M')

     

       53
       +
                       case(2)

     

       54
       +
                         found = find_xmas(lines, row-1, col-1, -1, -1, 'M')

     

       55
       +
                       case(3)

     

       56
       +
                         found = find_xmas(lines, row-1, col, -1, 0, 'M')

     

       57
       +
                       case(4)

     

       58
       +
                         found = find_xmas(lines, row-1, col+1,  -1, 1, 'M')

     

       59
       +
                       case(5)

     

       60
       +
                         found = find_xmas(lines, row, col+1, 0, 1, 'M')

     

       61
       +
                       case(6)

     

       62
       +
                         found = find_xmas(lines, row+1, col+1, 1, 1, 'M')

     

       63
       +
                       case(7)

     

       64
       +
                         found = find_xmas(lines, row+1, col, 1, 0, 'M')

     

       65
       +
                       case(8)

     

       66
       +
                         found = find_xmas(lines, row+1, col-1, 1, -1, 'M')

     

       67
       +
                      end select

     

       68
       +
                      if(found) then

     

       69
       +
                         score = score + 1

     

       70
       +
                      end if

     

       71
       +
                   end do

     

       72
       +
                end if

     

       73
       +
             end do

     

       74
       +
          end do

     

       75
       +
          deallocate(lines)

     

       76
       +
          print*, score

     

       77
       +
       

     

       78
       +
       end program day_04

+39

2024/day_04_part_2.f90

···

       1
       +
       program day_04

     

       2
       +
          implicit none

     

       3
       +
          character(len=140) ::  lines(140)

     

       4
       +
          character(len=1) :: c

     

       5
       +
          integer :: io, row, col, score, z

     

       6
       +
          logical :: left_m, right_m

     

       7
       +
       

     

       8
       +
          left_m = .false.

     

       9
       +
          right_m = .false.

     

       10
       +
          score = 0

     

       11
       +
          open(newunit=io, file='./day_04_input.txt', status='old', action='read')

     

       12
       +
          read(io, '(a)') lines

     

       13
       +
          do row = 2, size(lines) - 1

     

       14
       +
             do col = 2, len(lines(row)) - 1

     

       15
       +
                if (lines(row)(col:col) == 'A') then

     

       16
       +
                   c = lines(row-1)(col-1:col-1)

     

       17
       +
                   if (c == 'S' .or. c == 'M') then

     

       18
       +
                      left_m = c == 'M'

     

       19
       +
                      c = lines(row-1)(col+1:col+1)

     

       20
       +
                      if (c == 'S' .or. c == 'M') then

     

       21
       +
                         right_m = c == 'M'

     

       22
       +
                         c = lines(row+1)(col-1:col-1)

     

       23
       +
                         if (right_m .and. c == 'S' .or. (.not. right_m .and. c == 'M')) then

     

       24
       +
                            c = lines(row+1)(col+1:col+1)

     

       25
       +
                            if (left_m .and. c == 'S' .or. (.not. left_m .and. c =='M')) then

     

       26
       +
                               score = score + 1

     

       27
       +
                            end if

     

       28
       +
                         end if

     

       29
       +
                      end if

     

       30
       +
                   end if

     

       31
       +
                end if

     

       32
       +
                left_m = .false.

     

       33
       +
                right_m = .false.

     

       34
       +
                c = ''

     

       35
       +
             end do

     

       36
       +
          end do

     

       37
       +
          print*, score

     

       38
       +
       

     

       39
       +
       end program day_04

+193

2024/day_05.f90

···

       1
       +
       module day_05_utils

     

       2
       +
          implicit none

     

       3
       +
       contains

     

       4
       +
          subroutine append_to_integer_array(arr, val)

     

       5
       +
             implicit none

     

       6
       +
             integer, allocatable, intent(inout) :: arr(:)

     

       7
       +
             integer, intent(in) :: val

     

       8
       +
             integer, allocatable :: temp(:)

     

       9
       +
             if(.not. allocated(arr)) then

     

       10
       +
                ERROR STOP 'Array not allocated'

     

       11
       +
             end if

     

       12
       +
             allocate(temp(size(arr) + 1))

     

       13
       +
             temp(1:size(arr)) = arr

     

       14
       +
             temp(size(arr) + 1) = val

     

       15
       +
             call move_alloc(temp, arr)

     

       16
       +
          end subroutine append_to_integer_array

     

       17
       +
          function fix_and_get_middle_value(arr, left, right) result(res)

     

       18
       +
             ! we are going to fix the array swapping until its right

     

       19
       +
             ! there's probably a better way maybe? but I just want to get it done

     

       20
       +
             implicit none

     

       21
       +
             integer, allocatable, intent(in) :: arr(:), left(:), right(:)

     

       22
       +
             integer, allocatable :: work(:), copy(:)

     

       23
       +
             integer :: res, i, j, tmp

     

       24
       +
             logical :: found

     

       25
       +
             allocate(copy(size(arr)))

     

       26
       +
             copy = arr

     

       27
       +
             do

     

       28
       +
                found = .false.

     

       29
       +
                outer: do i = 1, size(copy)

     

       30
       +
                   if(i+1 < size(copy)) then ! if we can check forward

     

       31
       +
                      if(allocated(work)) then

     

       32
       +
                         deallocate(work)

     

       33
       +
                      end if

     

       34
       +
                      do j = 1, size(right) ! find value in right and save left to work

     

       35
       +
                         if (copy(i) == right(j)) then

     

       36
       +
                            if(.not. allocated(work)) then

     

       37
       +
                               allocate(work(1))

     

       38
       +
                               work(1) = left(j)

     

       39
       +
                            else

     

       40
       +
                               call append_to_integer_array(work, left(j))

     

       41
       +
                            end if

     

       42
       +
                         end if

     

       43
       +
                      end do

     

       44
       +
                      do j = i+1, size(copy)

     

       45
       +
                         if(any(work == copy(j))) then

     

       46
       +
                            tmp = copy(i)

     

       47
       +
                            copy(i) = copy(j)

     

       48
       +
                            copy(j) = tmp

     

       49
       +
                            found = .true.

     

       50
       +
                            exit outer

     

       51
       +
                         end if

     

       52
       +
                      end do

     

       53
       +
                   end if

     

       54
       +
       

     

       55
       +
                   if(.not. found) then ! if we are still valid lets keep going

     

       56
       +
                      if(allocated(work)) then

     

       57
       +
                         deallocate(work)

     

       58
       +
                      end if

     

       59
       +
                      if(i-1 > 0) then ! if we can check backwards

     

       60
       +
                         do j = 1, size(left) ! find value in left and save left to work

     

       61
       +
       

     

       62
       +
                            if (copy(i) == left(j)) then

     

       63
       +
                               if(.not. allocated(work)) then

     

       64
       +
                                  allocate(work(1))

     

       65
       +
                                  work(1) = right(j)

     

       66
       +
                               else

     

       67
       +
                                  call append_to_integer_array(work, right(j))

     

       68
       +
                               end if

     

       69
       +
                            end if

     

       70
       +
                         end do

     

       71
       +
                         do j = 1, size(copy)

     

       72
       +
                            if(any(work == copy(j) .and. j < i)) then

     

       73
       +
                               tmp = copy(i)

     

       74
       +
                               copy(i) = copy(j)

     

       75
       +
                               copy(j) = tmp

     

       76
       +
                               found = .true.

     

       77
       +
                               exit outer

     

       78
       +
                            end if

     

       79
       +
                         end do

     

       80
       +
                      end if

     

       81
       +
                   else

     

       82
       +
                      exit outer

     

       83
       +
                   end if

     

       84
       +
                end do outer

     

       85
       +
                if(.not. found) exit

     

       86
       +
             end do

     

       87
       +
             res = copy((size(copy) + 1)/2)

     

       88
       +
             deallocate(copy)

     

       89
       +
             if(allocated(work)) then

     

       90
       +
                deallocate(work)

     

       91
       +
             end if

     

       92
       +
          end function fix_and_get_middle_value

     

       93
       +
       end module day_05_utils

     

       94
       +
       program day_05

     

       95
       +
          use day_05_utils

     

       96
       +
          implicit none

     

       97
       +
          integer :: io, ios, idx, a, b, ct, i, j, res, res_part2

     

       98
       +
          integer, allocatable :: left(:), right(:), print_list(:), work(:)

     

       99
       +
          character(len=100) ::line

     

       100
       +
          logical :: found

     

       101
       +
       

     

       102
       +
          open(newunit=io, file='./day_05_input.txt', status='old', action='read')

     

       103
       +
          res = 0

     

       104
       +
          res_part2 = 0

     

       105
       +
          do

     

       106
       +
             read(io, '(a)', iostat=ios) line

     

       107
       +
             if(ios /= 0) exit !eof

     

       108
       +
             idx = index(line, '|')

     

       109
       +
             if(idx > 0) then ! rules

     

       110
       +
                read(line(1:idx-1), *) a

     

       111
       +
                read(line(idx+1:), *) b

     

       112
       +
                if(.not. allocated(left)) then

     

       113
       +
                   allocate(left(1))

     

       114
       +
                   left(1) = a

     

       115
       +
                else

     

       116
       +
                   call append_to_integer_array(left, a)

     

       117
       +
                end if

     

       118
       +
                if(.not. allocated(right)) then

     

       119
       +
                   allocate(right(1))

     

       120
       +
                   right(1) = b

     

       121
       +
                else

     

       122
       +
                   call append_to_integer_array(right, b)

     

       123
       +
                end if

     

       124
       +
             end if

     

       125
       +
             idx = index(line, ',')

     

       126
       +
             if (idx > 0 ) then ! print_list

     

       127
       +
                ct = 1

     

       128
       +
                do i = 1 , len_trim(line)

     

       129
       +
                   if(line(i:i) == ',') then

     

       130
       +
                      ct = ct + 1

     

       131
       +
                   end if

     

       132
       +
                end do

     

       133
       +
                allocate(print_list(ct))

     

       134
       +
                read(line, *) print_list

     

       135
       +
                found = .false.

     

       136
       +
                do i = 1, size(print_list)

     

       137
       +
                   if(i+1 < size(print_list)) then ! if we can check forward

     

       138
       +
                      do j = 1, size(right) ! find value in right and save left to work

     

       139
       +
                         if (print_list(i) == right(j)) then

     

       140
       +
                            if(.not. allocated(work)) then

     

       141
       +
                               allocate(work(1))

     

       142
       +
                               work(1) = left(j)

     

       143
       +
                            else

     

       144
       +
                               call append_to_integer_array(work, left(j))

     

       145
       +
                            end if

     

       146
       +
                         end if

     

       147
       +
                      end do

     

       148
       +
                      do j = 1, size(work)

     

       149
       +
                         if(any(print_list(i+1:size(print_list)) == work(j))) then

     

       150
       +
                            found = .true.

     

       151
       +
                            exit

     

       152
       +
                         end if

     

       153
       +
                      end do

     

       154
       +
                      deallocate(work)

     

       155
       +
                   end if

     

       156
       +
                   if(.not. found) then ! if we are still valid lets keep going

     

       157
       +
                      if(i-1 > 0) then ! if we can check backwards

     

       158
       +
                         do j = 1, size(left) ! find value in left and save left to work

     

       159
       +
                            if (print_list(i) == left(j)) then

     

       160
       +
                               if(.not. allocated(work)) then

     

       161
       +
                                  allocate(work(1))

     

       162
       +
                                  work(1) = right(j)

     

       163
       +
                               else

     

       164
       +
                                  call append_to_integer_array(work, right(j))

     

       165
       +
                               end if

     

       166
       +
                            end if

     

       167
       +
                         end do

     

       168
       +
                         do j = 1, size(work)

     

       169
       +
                            if(any(print_list(1:i-1) == work(j))) then

     

       170
       +
                               found = .true.

     

       171
       +
                               exit

     

       172
       +
                            end if

     

       173
       +
                         end do

     

       174
       +
                         deallocate(work)

     

       175
       +
                      end if

     

       176
       +
                   else

     

       177
       +
                      exit

     

       178
       +
                   end if

     

       179
       +
                end do

     

       180
       +
                if (.not. found) then

     

       181
       +
                   res = res + print_list((size(print_list) + 1)/2)

     

       182
       +
                else

     

       183
       +
                   res_part2 = res_part2 + fix_and_get_middle_value(print_list, left, right)

     

       184
       +
                end if

     

       185
       +
                deallocate(print_list)

     

       186
       +
             end if

     

       187
       +
          end do

     

       188
       +
       

     

       189
       +
          deallocate(left)

     

       190
       +
          deallocate(right)

     

       191
       +
          print*, "Result ", res

     

       192
       +
          print*, "Part 2 Result ", res_part2

     

       193
       +
       end program day_05

+64

2024/day_06.f90

···

       1
       +
       program day_06

     

       2
       +
          implicit none

     

       3
       +
          character(len=130) :: line, lines(130)

     

       4
       +
          integer:: io, x,y, xd,yd, i, ct

     

       5
       +
       

     

       6
       +
          open(newunit=io, file='./day_06_input.txt', status='old', action='read')

     

       7
       +
          read(io, '(a)') lines

     

       8
       +
       

     

       9
       +
          ct = 0

     

       10
       +
          ! find starting position

     

       11
       +
          do i = 1, size(lines)

     

       12
       +
             if (index(lines(i), '^') > 0) then

     

       13
       +
                y = i

     

       14
       +
                x = index(lines(i), '^')

     

       15
       +
                xd = 0

     

       16
       +
                yd = -1

     

       17
       +
                exit

     

       18
       +
             end if

     

       19
       +
          end do

     

       20
       +
       

     

       21
       +
          ! move until we leave the bounds when we hit a valid spot mark it with an X and increase count

     

       22
       +
          do

     

       23
       +
             ! are we going out of bounds?

     

       24
       +
             if (x+xd < 1 .or. x+xd > len(lines(y)) .or. y+yd < 1 .or. y+yd > size(lines)) then

     

       25
       +
                ct = ct + 1

     

       26
       +
                lines(y)(x:x) = 'X'

     

       27
       +
                exit

     

       28
       +
             end if

     

       29
       +
       

     

       30
       +
             ! try to move

     

       31
       +
             select case(lines(y+yd)(x+xd:x+xd))

     

       32
       +
              case('.')

     

       33
       +
                ! valid move

     

       34
       +
                ct = ct + 1

     

       35
       +
                x = x + xd

     

       36
       +
                y = y + yd

     

       37
       +
                lines(y)(x:x) = 'X'

     

       38
       +
              case('X')

     

       39
       +
                ! valid move but we've been here before

     

       40
       +
                x = x + xd

     

       41
       +
                y = y + yd

     

       42
       +
              case('#')

     

       43
       +
                ! we are blocked lets rotate 90 degrees

     

       44
       +
                if(xd == 0 .and. yd == -1) then

     

       45
       +
                   xd = 1

     

       46
       +
                   yd = 0

     

       47
       +
                else if (xd == 1 .and. yd == 0) then

     

       48
       +
                   xd = 0

     

       49
       +
                   yd = 1

     

       50
       +
                else if (xd == 0 .and. yd == 1) then

     

       51
       +
                   xd = -1

     

       52
       +
                   yd = 0

     

       53
       +
                else if (xd == -1 .and. yd == 0) then

     

       54
       +
                   xd = 0

     

       55
       +
                   yd = -1

     

       56
       +
                end if

     

       57
       +
              case default

     

       58
       +
                exit

     

       59
       +
             end select

     

       60
       +
          end do

     

       61
       +
          print*, lines

     

       62
       +
          print*, "distinct: ", ct

     

       63
       +
       end program day_06

     

       64
       +

+97

2024/day_06_part_2.f90

···

       1
       +
       program day_06_part_2

     

       2
       +
          implicit none

     

       3
       +
          character(len=130) :: line, lines(130), temp_lines(130)

     

       4
       +
          integer:: io, x,y, xd,yd, i, j, ct, o_ct, init_x, init_y, init_xd, init_yd

     

       5
       +
       

     

       6
       +
          open(newunit=io, file='./day_06_input.txt', status='old', action='read')

     

       7
       +
          read(io, '(a)') lines

     

       8
       +
       

     

       9
       +
          ct = 0

     

       10
       +
          ! find starting position

     

       11
       +
          do i = 1, size(lines)

     

       12
       +
             if (index(lines(i), '^') > 0) then

     

       13
       +
                y = i

     

       14
       +
                x = index(lines(i), '^')

     

       15
       +
                lines(i)(x:x) = '.' ! replace with a dot to not confuse this part

     

       16
       +
                xd = 0

     

       17
       +
                yd = -1

     

       18
       +
                init_x = x

     

       19
       +
                init_y = y

     

       20
       +
                init_xd = xd

     

       21
       +
                init_yd = yd

     

       22
       +
                exit

     

       23
       +
             end if

     

       24
       +
          end do

     

       25
       +
       

     

       26
       +
          do i = 1, size(lines)

     

       27
       +
             do j = 1, len(lines(i))

     

       28
       +
                o_ct = 0

     

       29
       +
                ! reset positions

     

       30
       +
                x = init_x

     

       31
       +
                y = init_y

     

       32
       +
                xd = init_xd

     

       33
       +
                yd = init_yd

     

       34
       +
                temp_lines = lines ! fresh board every run

     

       35
       +
                if(temp_lines(i)(j:j) == '.') then

     

       36
       +
                   temp_lines(i)(j:j) = 'O'  ! place obstacle to test

     

       37
       +
                   ! move until we leave the bounds when we hit a valid spot mark it with an X and increase count

     

       38
       +
                   do

     

       39
       +
                      ! are we going out of bounds?

     

       40
       +
                      if (x+xd < 1 .or. x+xd > len(temp_lines(y)) .or. y+yd < 1 .or. y+yd > size(temp_lines)) then

     

       41
       +
                         exit

     

       42
       +
                      end if

     

       43
       +
       

     

       44
       +
                      ! try to move

     

       45
       +
                      select case(temp_lines(y+yd)(x+xd:x+xd))

     

       46
       +
                       case('.')

     

       47
       +
                         ! valid move

     

       48
       +
                         x = x + xd

     

       49
       +
                         y = y + yd

     

       50
       +
                       case('O')

     

       51
       +
                         ! we are blocked lets rotate 90 degrees and count obstacle

     

       52
       +
                         o_ct = o_ct + 1

     

       53
       +
                         if(xd == 0 .and. yd == -1) then

     

       54
       +
                            xd = 1

     

       55
       +
                            yd = 0

     

       56
       +
                         else if (xd == 1 .and. yd == 0) then

     

       57
       +
                            xd = 0

     

       58
       +
                            yd = 1

     

       59
       +
                         else if (xd == 0 .and. yd == 1) then

     

       60
       +
                            xd = -1

     

       61
       +
                            yd = 0

     

       62
       +
                         else if (xd == -1 .and. yd == 0) then

     

       63
       +
                            xd = 0

     

       64
       +
                            yd = -1

     

       65
       +
                         end if

     

       66
       +
                       case('#')

     

       67
       +
                         ! we are blocked lets rotate 90 degrees

     

       68
       +
                         ! change this to an O to try and detect when stuck

     

       69
       +
                         temp_lines(y+yd)(x+xd:x+xd) = 'O'

     

       70
       +
                         if(xd == 0 .and. yd == -1) then

     

       71
       +
                            xd = 1

     

       72
       +
                            yd = 0

     

       73
       +
                         else if (xd == 1 .and. yd == 0) then

     

       74
       +
                            xd = 0

     

       75
       +
                            yd = 1

     

       76
       +
                         else if (xd == 0 .and. yd == 1) then

     

       77
       +
                            xd = -1

     

       78
       +
                            yd = 0

     

       79
       +
                         else if (xd == -1 .and. yd == 0) then

     

       80
       +
                            xd = 0

     

       81
       +
                            yd = -1

     

       82
       +
                         end if

     

       83
       +
                       case default

     

       84
       +
                         exit

     

       85
       +
                      end select

     

       86
       +
                      if(o_ct > 100) then

     

       87
       +
                         exit ! probably stuck

     

       88
       +
                      end if

     

       89
       +
                   end do

     

       90
       +
                end if

     

       91
       +
                if(o_ct > 100) then ! we got stuck probably 100 is so arbitrary

     

       92
       +
                   ct = ct + 1

     

       93
       +
                end if

     

       94
       +
             end do

     

       95
       +
          end do

     

       96
       +
          print*, "block points: ", ct

     

       97
       +
       end program day_06_part_2

+57

2024/day_07.f90

···

       1
       +
       module day_07_utils

     

       2
       +
          use iso_fortran_env, only: int64

     

       3
       +
          implicit none

     

       4
       +
       contains

     

       5
       +
          recursive function test_values(arr, target, next_idx, current_value) result(pass)

     

       6
       +
             implicit none

     

       7
       +
             integer(kind=int64), intent(in) :: target, current_value, arr(:)

     

       8
       +
             integer, intent(in) :: next_idx

     

       9
       +
             logical :: pass

     

       10
       +
             if(next_idx > size(arr)) then

     

       11
       +
                pass = current_value == target

     

       12
       +
                return

     

       13
       +
             end if

     

       14
       +
             pass = test_values(arr, target, next_idx + 1, current_value + arr(next_idx)) .or. &

     

       15
       +
                test_values(arr, target, next_idx + 1, current_value * arr(next_idx))

     

       16
       +
          end function test_values

     

       17
       +
          logical function is_calibrated(arr, target)

     

       18
       +
             implicit none

     

       19
       +
             integer(kind=int64), intent(in) :: target, arr(:)

     

       20
       +
             is_calibrated = test_values(arr, target, 2, arr(1))

     

       21
       +
          end function is_calibrated

     

       22
       +
       end module day_07_utils

     

       23
       +
       program day_07

     

       24
       +
          use iso_fortran_env, only: int64

     

       25
       +
          use day_07_utils

     

       26
       +
          implicit none

     

       27
       +
          integer(kind=int64) :: test_number, res

     

       28
       +
          integer(kind=int64), allocatable:: work(:)

     

       29
       +
          integer :: io, ios, idx, i, ct

     

       30
       +
          character(len=200) :: line, work_line

     

       31
       +
          logical :: pass

     

       32
       +
          res = 0

     

       33
       +
          open(newunit=io, file='./day_07_input.txt', status='old', action='read')

     

       34
       +
          do

     

       35
       +
             read(io, '(a)', iostat=ios) line

     

       36
       +
             if (ios /= 0) exit

     

       37
       +
             idx = index(line, ':')

     

       38
       +
             if (idx > 0) then

     

       39
       +
                read(line(1:idx-1), *) test_number

     

       40
       +
                ct = 0

     

       41
       +
                work_line = trim(line(idx+1:len(trim(line))))

     

       42
       +
                do i = 1 , len(trim(work_line))

     

       43
       +
                   if(work_line(i:i) == ' ') then

     

       44
       +
                      ct = ct + 1

     

       45
       +
                   end if

     

       46
       +
                end do

     

       47
       +
                allocate(work(ct))

     

       48
       +
                read(work_line, *) work(:)

     

       49
       +
             end if

     

       50
       +
             pass = is_calibrated(work, test_number)

     

       51
       +
             if(pass) then

     

       52
       +
                res = res + test_number

     

       53
       +
             end if

     

       54
       +
             deallocate(work)

     

       55
       +
          end do

     

       56
       +
          print*, "Result: ", res

     

       57
       +
       end program day_07

+68

2024/day_07_part_2.f90

···

       1
       +
       module day_07_part_2_utils

     

       2
       +
          use iso_fortran_env, only: int64

     

       3
       +
          implicit none

     

       4
       +
       contains

     

       5
       +
          recursive function test_values(arr, target, next_idx, current_value) result(pass)

     

       6
       +
             implicit none

     

       7
       +
             integer(kind=int64), intent(in) :: target, current_value, arr(:)

     

       8
       +
             integer, intent(in) :: next_idx

     

       9
       +
             character(len=20) :: str_1, str_2, concat_str

     

       10
       +
             integer(kind=int64) :: concat_value

     

       11
       +
             logical :: pass

     

       12
       +
       

     

       13
       +
             if(next_idx > size(arr)) then

     

       14
       +
                pass = current_value == target

     

       15
       +
                return

     

       16
       +
             end if

     

       17
       +
       

     

       18
       +
             write(str_1, '(I0)') current_value

     

       19
       +
             write(str_2, '(I0)') arr(next_idx)

     

       20
       +
             concat_str = trim(str_1) // trim(str_2)

     

       21
       +
             read(concat_str, '(I20)') concat_value

     

       22
       +
       

     

       23
       +
             pass = test_values(arr, target, next_idx + 1, current_value + arr(next_idx)) .or. &

     

       24
       +
                test_values(arr, target, next_idx + 1, current_value * arr(next_idx)) .or. &

     

       25
       +
                test_values(arr, target, next_idx + 1, concat_value)

     

       26
       +
          end function test_values

     

       27
       +
          logical function is_calibrated(arr, target)

     

       28
       +
             implicit none

     

       29
       +
             integer(kind=int64), intent(in) :: target, arr(:)

     

       30
       +
       

     

       31
       +
             is_calibrated = test_values(arr, target, 2, arr(1))

     

       32
       +
          end function is_calibrated

     

       33
       +
       end module day_07_part_2_utils

     

       34
       +
       program day_07_part_2

     

       35
       +
          use iso_fortran_env, only: int64

     

       36
       +
          use day_07_part_2_utils

     

       37
       +
          implicit none

     

       38
       +
          integer(kind=int64) :: test_number, res

     

       39
       +
          integer(kind=int64), allocatable:: work(:)

     

       40
       +
          integer :: io, ios, idx, i, ct

     

       41
       +
          character(len=200) :: line, work_line

     

       42
       +
          logical :: pass

     

       43
       +
          res = 0

     

       44
       +
          open(newunit=io, file='./day_07_input.txt', status='old', action='read')

     

       45
       +
          do

     

       46
       +
             read(io, '(a)', iostat=ios) line

     

       47
       +
             if (ios /= 0) exit

     

       48
       +
             idx = index(line, ':')

     

       49
       +
             if (idx > 0) then

     

       50
       +
                read(line(1:idx-1), *) test_number

     

       51
       +
                ct = 0

     

       52
       +
                work_line = trim(line(idx+1:len(trim(line))))

     

       53
       +
                do i = 1 , len(trim(work_line))

     

       54
       +
                   if(work_line(i:i) == ' ') then

     

       55
       +
                      ct = ct + 1

     

       56
       +
                   end if

     

       57
       +
                end do

     

       58
       +
                allocate(work(ct))

     

       59
       +
                read(work_line, *) work(:)

     

       60
       +
             end if

     

       61
       +
             pass = is_calibrated(work, test_number)

     

       62
       +
             if(pass) then

     

       63
       +
                res = res + test_number

     

       64
       +
             end if

     

       65
       +
             deallocate(work)

     

       66
       +
          end do

     

       67
       +
          print*, "Result: ", res

     

       68
       +
       end program day_07_part_2

+142

2024/day_08.f90

···

       1
       +
       module day_08_utils

     

       2
       +
          implicit none

     

       3
       +
          type node

     

       4
       +
             character :: c

     

       5
       +
             integer, allocatable :: x(:), y(:)

     

       6
       +
          end type node

     

       7
       +
       contains

     

       8
       +
          subroutine append_to_integer_array(arr, val)

     

       9
       +
             implicit none

     

       10
       +
             integer, allocatable, intent(inout) :: arr(:)

     

       11
       +
             integer, intent(in) :: val

     

       12
       +
             integer, allocatable :: temp(:)

     

       13
       +
             if(.not. allocated(arr)) then

     

       14
       +
                ERROR STOP 'Array not allocated'

     

       15
       +
             end if

     

       16
       +
             allocate(temp(size(arr) + 1))

     

       17
       +
             temp(1:size(arr)) = arr

     

       18
       +
             temp(size(arr) + 1) = val

     

       19
       +
             call move_alloc(temp, arr)

     

       20
       +
          end subroutine append_to_integer_array

     

       21
       +
       

     

       22
       +
          subroutine add_node(nodes, c, x, y)

     

       23
       +
             type(node), allocatable, intent(inout) :: nodes(:)

     

       24
       +
             type(node), allocatable :: temp(:)

     

       25
       +
             character, intent(in) :: c

     

       26
       +
             integer, intent(in) :: x, y

     

       27
       +
             integer :: i

     

       28
       +
             do i = 1, size(nodes)

     

       29
       +
                if (nodes(i)%c == c) then

     

       30
       +
                   if(.not. allocated(nodes(i)%x)) then

     

       31
       +
                      allocate(nodes(i)%x(1))

     

       32
       +
                      nodes(i)%x(1) = x

     

       33
       +
                   else

     

       34
       +
                      call append_to_integer_array(nodes(i)%x, x)

     

       35
       +
                   end if

     

       36
       +
                   if(.not. allocated(nodes(i)%y)) then

     

       37
       +
                      allocate(nodes(i)%y(1))

     

       38
       +
                      nodes(i)%y(1) = y

     

       39
       +
                   else

     

       40
       +
                      call append_to_integer_array(nodes(i)%y, y)

     

       41
       +
                   end if

     

       42
       +
                   return

     

       43
       +
                end if

     

       44
       +
             end do

     

       45
       +
             allocate(temp(size(nodes) + 1))

     

       46
       +
             temp(1:size(nodes)) = nodes

     

       47
       +
             allocate(temp(size(nodes) + 1)%x(1))

     

       48
       +
             allocate(temp(size(nodes) + 1)%y(1))

     

       49
       +
             temp(size(nodes) + 1)%c = c

     

       50
       +
             temp(size(nodes) + 1)%x(1) = x

     

       51
       +
             temp(size(nodes) + 1)%y(1) = y

     

       52
       +
             call move_alloc(temp, nodes)

     

       53
       +
          end subroutine add_node

     

       54
       +
       end module day_08_utils

     

       55
       +
       

     

       56
       +
       program day_08

     

       57
       +
          use day_08_utils

     

       58
       +
          implicit none

     

       59
       +
          character(len=50) :: lines(50)

     

       60
       +
          integer :: io, i, j, k, l, score, xdist, ydist

     

       61
       +
          integer, allocatable :: anti_x(:), anti_y(:)

     

       62
       +
          type(node), allocatable :: nodes(:)

     

       63
       +
          logical :: found

     

       64
       +
       

     

       65
       +
          open(newunit=io, file='day_08_input.txt', status='old', action='read')

     

       66
       +
          read(io, '(A)') lines

     

       67
       +
          score = 0

     

       68
       +
          do i = 1, 50

     

       69
       +
             do j = 1, 50

     

       70
       +
                if(lines(i)(j:j) /= '.') then

     

       71
       +
                   if(.not. allocated(nodes)) then

     

       72
       +
                      allocate(nodes(1))

     

       73
       +
                      nodes(1)%c = lines(i)(j:j)

     

       74
       +
                      allocate(nodes(1)%x(1))

     

       75
       +
                      allocate(nodes(1)%y(1))

     

       76
       +
                      nodes(1)%x(1) = j

     

       77
       +
                      nodes(1)%y(1) = i

     

       78
       +
                   else

     

       79
       +
                      call add_node(nodes, lines(i)(j:j), j, i)

     

       80
       +
                   end if

     

       81
       +
                end if

     

       82
       +
             end do

     

       83
       +
          end do

     

       84
       +
          do i = 1, size(nodes)

     

       85
       +
             do j = 1, size(nodes(i)%x)

     

       86
       +
                do l = 1, size(nodes(i)%x)

     

       87
       +
                   if(nodes(i)%x(j) == nodes(i)%x(l) .and. nodes(i)%y(j) == nodes(i)%y(l)) cycle ! don't compare same values

     

       88
       +
                   xdist = nodes(i)%x(j) - nodes(i)%x(l)

     

       89
       +
                   ydist = nodes(i)%y(j) - nodes(i)%y(l)

     

       90
       +
                   if(nodes(i)%x(j) + xdist > 0 .and. nodes(i)%x(j) + xdist <= 50 .and. &

     

       91
       +
                      nodes(i)%y(j) + ydist > 0 .and. nodes(i)%y(j) + ydist <= 50) then

     

       92
       +
                      if(.not. allocated(anti_x)) then

     

       93
       +
                         allocate(anti_x(1))

     

       94
       +
                         anti_x(1) = nodes(i)%x(j) + xdist

     

       95
       +
                         allocate(anti_y(1))

     

       96
       +
                         anti_y(1) = nodes(i)%y(j) + ydist

     

       97
       +
                         score = score + 1

     

       98
       +
                      else

     

       99
       +
                         found = .false.

     

       100
       +
                         do k = 1, size(anti_x)

     

       101
       +
                            if(anti_x(k) == nodes(i)%x(j) + xdist .and. anti_y(k) == nodes(i)%y(j) + ydist) then

     

       102
       +
                               found = .true.

     

       103
       +
                               exit

     

       104
       +
                            end if

     

       105
       +
                         end do

     

       106
       +
                         if(.not. found) then

     

       107
       +
                            call append_to_integer_array(anti_x, nodes(i)%x(j) + xdist)

     

       108
       +
                            call append_to_integer_array(anti_y, nodes(i)%y(j) + ydist)

     

       109
       +
       

     

       110
       +
                            score = score + 1

     

       111
       +
                         end if

     

       112
       +
                      end if

     

       113
       +
                   end if

     

       114
       +
                   if(nodes(i)%x(l) - xdist > 0 .and. nodes(i)%x(l) - xdist <= 50 .and. &

     

       115
       +
                      nodes(i)%y(l) - ydist > 0 .and. nodes(i)%y(l) - ydist <= 50) then

     

       116
       +
                      if(.not. allocated(anti_x)) then

     

       117
       +
                         allocate(anti_x(1))

     

       118
       +
                         anti_x(1) = nodes(i)%x(l) - xdist

     

       119
       +
                         allocate(anti_y(1))

     

       120
       +
                         anti_y(1) = nodes(i)%y(l) - ydist

     

       121
       +
                         score = score + 1

     

       122
       +
                      else

     

       123
       +
                         found = .false.

     

       124
       +
                         do k = 1, size(anti_x)

     

       125
       +
                            if(anti_x(k) == nodes(i)%x(l) - xdist .and. anti_y(k) == nodes(i)%y(l) - ydist) then

     

       126
       +
                               found = .true.

     

       127
       +
                               exit

     

       128
       +
                            end if

     

       129
       +
                         end do

     

       130
       +
                         if(.not. found) then

     

       131
       +
                            call append_to_integer_array(anti_x, nodes(i)%x(l) - xdist)

     

       132
       +
                            call append_to_integer_array(anti_y, nodes(i)%y(l) - ydist)

     

       133
       +
       

     

       134
       +
                            score = score + 1

     

       135
       +
                         end if

     

       136
       +
                      end if

     

       137
       +
                   end if

     

       138
       +
                end do

     

       139
       +
             end do

     

       140
       +
          end do

     

       141
       +
          print*, "Total : ", score

     

       142
       +
       end program day_08

+164

2024/day_08_part_2.f90

···

       1
       +
       module day_08_utils

     

       2
       +
          implicit none

     

       3
       +
          type node

     

       4
       +
             character :: c

     

       5
       +
             integer, allocatable :: x(:), y(:)

     

       6
       +
          end type node

     

       7
       +
       contains

     

       8
       +
          subroutine append_to_integer_array(arr, val)

     

       9
       +
             implicit none

     

       10
       +
             integer, allocatable, intent(inout) :: arr(:)

     

       11
       +
             integer, intent(in) :: val

     

       12
       +
             integer, allocatable :: temp(:)

     

       13
       +
             if(.not. allocated(arr)) then

     

       14
       +
                ERROR STOP 'Array not allocated'

     

       15
       +
             end if

     

       16
       +
             allocate(temp(size(arr) + 1))

     

       17
       +
             temp(1:size(arr)) = arr

     

       18
       +
             temp(size(arr) + 1) = val

     

       19
       +
             call move_alloc(temp, arr)

     

       20
       +
          end subroutine append_to_integer_array

     

       21
       +
       

     

       22
       +
          subroutine add_node(nodes, c, x, y)

     

       23
       +
             type(node), allocatable, intent(inout) :: nodes(:)

     

       24
       +
             type(node), allocatable :: temp(:)

     

       25
       +
             character, intent(in) :: c

     

       26
       +
             integer, intent(in) :: x, y

     

       27
       +
             integer :: i

     

       28
       +
             do i = 1, size(nodes)

     

       29
       +
                if (nodes(i)%c == c) then

     

       30
       +
                   if(.not. allocated(nodes(i)%x)) then

     

       31
       +
                      allocate(nodes(i)%x(1))

     

       32
       +
                      nodes(i)%x(1) = x

     

       33
       +
                   else

     

       34
       +
                      call append_to_integer_array(nodes(i)%x, x)

     

       35
       +
                   end if

     

       36
       +
                   if(.not. allocated(nodes(i)%y)) then

     

       37
       +
                      allocate(nodes(i)%y(1))

     

       38
       +
                      nodes(i)%y(1) = y

     

       39
       +
                   else

     

       40
       +
                      call append_to_integer_array(nodes(i)%y, y)

     

       41
       +
                   end if

     

       42
       +
                   return

     

       43
       +
                end if

     

       44
       +
             end do

     

       45
       +
             allocate(temp(size(nodes) + 1))

     

       46
       +
             temp(1:size(nodes)) = nodes

     

       47
       +
             allocate(temp(size(nodes) + 1)%x(1))

     

       48
       +
             allocate(temp(size(nodes) + 1)%y(1))

     

       49
       +
             temp(size(nodes) + 1)%c = c

     

       50
       +
             temp(size(nodes) + 1)%x(1) = x

     

       51
       +
             temp(size(nodes) + 1)%y(1) = y

     

       52
       +
             call move_alloc(temp, nodes)

     

       53
       +
          end subroutine add_node

     

       54
       +
       end module day_08_utils

     

       55
       +
       

     

       56
       +
       program day_08

     

       57
       +
          use day_08_utils

     

       58
       +
          implicit none

     

       59
       +
          character(len=50) :: lines(50)

     

       60
       +
          integer :: io, i, j, k, l, score, xdist, ydist, next_x, next_y

     

       61
       +
          integer, allocatable :: anti_x(:), anti_y(:)

     

       62
       +
          type(node), allocatable :: nodes(:)

     

       63
       +
          logical :: found

     

       64
       +
       

     

       65
       +
          open(newunit=io, file='day_08_input.txt', status='old', action='read')

     

       66
       +
          read(io, '(A)') lines

     

       67
       +
          score = 0

     

       68
       +
          do i = 1, 50

     

       69
       +
             do j = 1, 50

     

       70
       +
                if(lines(i)(j:j) /= '.') then

     

       71
       +
                   if(.not. allocated(nodes)) then

     

       72
       +
                      allocate(nodes(1))

     

       73
       +
                      nodes(1)%c = lines(i)(j:j)

     

       74
       +
                      allocate(nodes(1)%x(1))

     

       75
       +
                      allocate(nodes(1)%y(1))

     

       76
       +
                      nodes(1)%x(1) = j

     

       77
       +
                      nodes(1)%y(1) = i

     

       78
       +
                   else

     

       79
       +
                      call add_node(nodes, lines(i)(j:j), j, i)

     

       80
       +
                   end if

     

       81
       +
                end if

     

       82
       +
             end do

     

       83
       +
          end do

     

       84
       +
          do i = 1, size(nodes)

     

       85
       +
             do j = 1, size(nodes(i)%x)

     

       86
       +
                if(.not. allocated(anti_x)) then

     

       87
       +
                   allocate(anti_x(1))

     

       88
       +
                   anti_x(1) = nodes(i)%x(j)

     

       89
       +
                   allocate(anti_y(1))

     

       90
       +
                   anti_y(1) = nodes(i)%y(j)

     

       91
       +
                   score = score + 1

     

       92
       +
                else

     

       93
       +
                   found = .false.

     

       94
       +
                   do k = 1, size(anti_x)

     

       95
       +
                      if(anti_x(k) == nodes(i)%x(j) .and. anti_y(k) == nodes(i)%y(j)) then

     

       96
       +
                         found = .true.

     

       97
       +
                         exit

     

       98
       +
                      end if

     

       99
       +
                   end do

     

       100
       +
                   if(.not. found) then

     

       101
       +
                      call append_to_integer_array(anti_x, nodes(i)%x(j))

     

       102
       +
                      call append_to_integer_array(anti_y, nodes(i)%y(j))

     

       103
       +
       

     

       104
       +
                      score = score + 1

     

       105
       +
                   end if

     

       106
       +
                end if

     

       107
       +
                do l = 1, size(nodes(i)%x)

     

       108
       +
                   if(nodes(i)%x(j) == nodes(i)%x(l) .and. nodes(i)%y(j) == nodes(i)%y(l)) cycle ! don't compare same values

     

       109
       +
                   xdist = nodes(i)%x(j) - nodes(i)%x(l)

     

       110
       +
                   ydist = nodes(i)%y(j) - nodes(i)%y(l)

     

       111
       +
                   next_x = nodes(i)%x(j) + xdist

     

       112
       +
                   next_y = nodes(i)%y(j) + ydist

     

       113
       +
                   do

     

       114
       +
                      if(next_x> 0 .and. next_x <= 50 .and. &

     

       115
       +
                         next_y > 0 .and. next_y  <= 50) then

     

       116
       +
                         found = .false.

     

       117
       +
                         do k = 1, size(anti_x)

     

       118
       +
                            if(anti_x(k) == next_x .and. anti_y(k) == next_y) then

     

       119
       +
                               found = .true.

     

       120
       +
                               exit

     

       121
       +
                            end if

     

       122
       +
                         end do

     

       123
       +
                         if(.not. found) then

     

       124
       +
                            call append_to_integer_array(anti_x, next_x)

     

       125
       +
                            call append_to_integer_array(anti_y, next_y)

     

       126
       +
       

     

       127
       +
                            score = score + 1

     

       128
       +
                         end if

     

       129
       +
                         next_x = next_x + xdist

     

       130
       +
                         next_y = next_y + ydist

     

       131
       +
                      else

     

       132
       +
                         exit

     

       133
       +
                      end if

     

       134
       +
                   end do

     

       135
       +
                   next_x = nodes(i)%x(l) - xdist

     

       136
       +
                   next_y = nodes(i)%y(l) - ydist

     

       137
       +
                   do

     

       138
       +
                      if(next_x > 0 .and. next_x  <= 50 .and. &

     

       139
       +
                         next_y > 0 .and. next_y <= 50) then

     

       140
       +
                         found = .false.

     

       141
       +
                         do k = 1, size(anti_x)

     

       142
       +
                            if(anti_x(k) == next_x .and. anti_y(k) == next_y) then

     

       143
       +
                               found = .true.

     

       144
       +
                               exit

     

       145
       +
                            end if

     

       146
       +
                         end do

     

       147
       +
                         if(.not. found) then

     

       148
       +
                            call append_to_integer_array(anti_x, next_x)

     

       149
       +
                            call append_to_integer_array(anti_y, next_y)

     

       150
       +
       

     

       151
       +
                            score = score + 1

     

       152
       +
                         end if

     

       153
       +
                         next_x = next_x - xdist

     

       154
       +
                         next_y = next_y - ydist

     

       155
       +
       

     

       156
       +
                      else

     

       157
       +
                         exit

     

       158
       +
                      end if

     

       159
       +
                   end do

     

       160
       +
                end do

     

       161
       +
             end do

     

       162
       +
          end do

     

       163
       +
          print*, "Total : ", score

     

       164
       +
       end program day_08

+152

2024/day_09.f90

···

       1
       +
       module day_09_utils

     

       2
       +
          implicit none

     

       3
       +
       contains

     

       4
       +
          subroutine swap_to_first_positive_integer_from_end(arr, idx)

     

       5
       +
             implicit none

     

       6
       +
             integer, allocatable, intent(inout) :: arr(:)

     

       7
       +
             integer, intent(in) :: idx

     

       8
       +
             integer, allocatable :: temp(:)

     

       9
       +
             integer :: i, res

     

       10
       +
             do i = 0, size(arr) - 1

     

       11
       +
                if(arr(size(arr) - i) > -1) then

     

       12
       +
                   arr(idx) = arr(size(arr) - i)

     

       13
       +
                   allocate(temp(size(arr) - (i +1)))

     

       14
       +
                   temp = arr(1:size(arr) - (i+1))

     

       15
       +
                   call move_alloc(temp, arr)

     

       16
       +
                   return

     

       17
       +
                end if

     

       18
       +
             end do

     

       19
       +
          end subroutine swap_to_first_positive_integer_from_end

     

       20
       +
          subroutine append_to_integer_array_times(arr, val, times)

     

       21
       +
             implicit none

     

       22
       +
             integer, allocatable, intent(inout) :: arr(:)

     

       23
       +
             integer, intent(in) :: val, times

     

       24
       +
             integer, allocatable :: temp(:)

     

       25
       +
             if(.not. allocated(arr)) then

     

       26
       +
                ERROR STOP 'Array not allocated'

     

       27
       +
             end if

     

       28
       +
             allocate(temp(size(arr) + times))

     

       29
       +
             temp(1:size(arr)) = arr

     

       30
       +
             temp(size(arr) + 1:size(temp)) = val

     

       31
       +
             call move_alloc(temp, arr)

     

       32
       +
          end subroutine append_to_integer_array_times

     

       33
       +
       end module day_09_utils

     

       34
       +
       program day_09

     

       35
       +
          use iso_fortran_env, only: int64

     

       36
       +
          use day_09_utils

     

       37
       +
          implicit none

     

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

     

       39
       +
          integer(kind=int64) :: res

     

       40
       +
          character(len=1) :: c

     

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

     

       42
       +
          logical :: is_space, space_block_start

     

       43
       +
       

     

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

     

       45
       +
          is_space = .false.

     

       46
       +
          block_n = 0

     

       47
       +
          do

     

       48
       +
             read(io, iostat=ios) c

     

       49
       +
             if (ios /= 0) exit

     

       50
       +
             read(c, *, iostat=ios) i

     

       51
       +
             if(ios /= 0) exit

     

       52
       +
             if (i == 0) then

     

       53
       +
                is_space = .false.

     

       54
       +
                cycle

     

       55
       +
             end if

     

       56
       +
             if (.not. allocated(system)) then

     

       57
       +
                allocate(system(i))

     

       58
       +
                system(1:i) = block_n

     

       59
       +
                is_space = .true.

     

       60
       +
                block_n = block_n + 1

     

       61
       +
             else

     

       62
       +
                if (is_space) then

     

       63
       +
                   call append_to_integer_array_times(system, -1, i)

     

       64
       +
                   is_space = .false.

     

       65
       +
                else

     

       66
       +
                   call append_to_integer_array_times(system, block_n, i)

     

       67
       +
                   block_n = block_n + 1

     

       68
       +
                   is_space = .true.

     

       69
       +
                end if

     

       70
       +
             end if

     

       71
       +
          end do

     

       72
       +
          allocate(work(size(system)))

     

       73
       +
          work = system

     

       74
       +
          ct = count(work > -1)

     

       75
       +
          outer: do

     

       76
       +
             do i = 1, size(work)

     

       77
       +
                if (i == ct) exit outer ! we are done

     

       78
       +
                if(work(i) < 0) then

     

       79
       +
                   call swap_to_first_positive_integer_from_end(work, i)

     

       80
       +
                   exit

     

       81
       +
                end if

     

       82
       +
             end do

     

       83
       +
          end do outer

     

       84
       +
          res = 0

     

       85
       +
          do i = 1, size(work)

     

       86
       +
             if(work(i) > -1) then

     

       87
       +
                res = res + ((i-1) * work(i))

     

       88
       +
             else

     

       89
       +
             end if

     

       90
       +
          end do

     

       91
       +
          print *, res

     

       92
       +
          ! start_part_2

     

       93
       +
          res = 0

     

       94
       +
          deallocate(work)

     

       95
       +
          allocate(work(size(system)))

     

       96
       +
          work = system

     

       97
       +
          block_n = -1

     

       98
       +
          block_start = -1

     

       99
       +
          block_end = -1

     

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

     

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

     

       102
       +
                ! we are starting a block

     

       103
       +
                block_end = i

     

       104
       +
                block_n = work(i)

     

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

     

       106
       +
                   block_n = -1

     

       107
       +
                   block_start = -1

     

       108
       +
                   block_end = -1

     

       109
       +
                   cycle

     

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

     

       111
       +
                   allocate(done(1))

     

       112
       +
                   done(1) = block_n

     

       113
       +
                else

     

       114
       +
                   call append_to_integer_array_times(done, block_n, 1)

     

       115
       +
                end if

     

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

     

       117
       +
                ! we are ending the block

     

       118
       +
                block_start = i

     

       119
       +
       

     

       120
       +
                ! lets try to move the block

     

       121
       +
                space_block_start = .true.

     

       122
       +
                do j = 1, size(work)

     

       123
       +
                   if (j > block_start) exit

     

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

     

       125
       +
                      space_start = j

     

       126
       +
                      space_block_start = .false.

     

       127
       +
                   else if (.not. space_block_start .and. work(j) /= -1) then

     

       128
       +
                      space_end = j

     

       129
       +
                      space_block_start = .true.

     

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

     

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

     

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

     

       133
       +
                         exit

     

       134
       +
                      end if

     

       135
       +
                      space_end = -1

     

       136
       +
                      space_start = -1

     

       137
       +
                   end if

     

       138
       +
                end do

     

       139
       +
                block_n = work(i)

     

       140
       +
                block_end = i

     

       141
       +
                block_start = -1

     

       142
       +
             end if

     

       143
       +
          end do

     

       144
       +
          do i = 1, size(work)

     

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

     

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

     

       147
       +
             end if

     

       148
       +
          end do

     

       149
       +
          print *, res

     

       150
       +
       end program day_09

     

       151
       +
       

     

       152
       +

2024/dune

···

       1
       +
       (executable (name day_01)

     

       2
       +
       (libraries str))

     

       3
       +
       (executable (name day_02))

     

       4
       +
       (executable (name day_03)

     

       5
       +
       (libraries str))

2024/dune-project

···

       0

···

       1
       +
       (lang dune 3.6)

+51

2025/day_01.cbl

···

       1
       +
              IDENTIFICATION DIVISION.

     

       2
       +
              PROGRAM-ID. day_01.

     

       3
       +
              AUTHOR. Trey Bastian.

     

       4
       +
              ENVIRONMENT DIVISION.

     

       5
       +
              INPUT-OUTPUT SECTION.

     

       6
       +
              FILE-CONTROL.

     

       7
       +
              SELECT input-file ASSIGN TO "./input.txt"

     

       8
       +
                  ORGANIZATION IS LINE SEQUENTIAL.

     

       9
       +
              DATA DIVISION.

     

       10
       +
              FILE SECTION.

     

       11
       +
              FD input-file.

     

       12
       +
              01 input-line.

     

       13
       +
                02 direction PIC X.

     

       14
       +
                02 move-text PIC XXX.

     

       15
       +
              WORKING-STORAGE SECTION.

     

       16
       +
              01 dial-position PIC 9(2) VALUE 50.

     

       17
       +
              01 move-num PIC S9(3).

     

       18
       +
              01 zero-count PIC 9(4) VALUE ZEROS.

     

       19
       +
              01 eof PIC X.

     

       20
       +
                  88 eof-y VALUE "Y".

     

       21
       +
                  88 eof-n VALUE "N".

     

       22
       +
       

     

       23
       +
              

     

       24
       +
              PROCEDURE DIVISION.

     

       25
       +
                OPEN INPUT input-file.

     

       26
       +
                SET eof-n to TRUE.

     

       27
       +
                PERFORM UNTIL eof-y

     

       28
       +
                    READ input-file AT END

     

       29
       +
                        SET eof-y to TRUE

     

       30
       +
                    NOT AT END

     

       31
       +
                      MOVE FUNCTION NUMVAL(move-text) TO move-num

     

       32
       +
                      IF direction = "L"

     

       33
       +
                       COMPUTE move-num = 0 - move-num 

     

       34
       +
                      END-IF

     

       35
       +
                      

     

       36
       +
                      COMPUTE dial-position = FUNCTION MOD(dial-position +

     

       37
       +
                      move-num, 100) 

     

       38
       +
       

     

       39
       +
                      if dial-position < 0

     

       40
       +
                        ADD 100 to dial-position

     

       41
       +
                      END-IF

     

       42
       +
       

     

       43
       +
                      if dial-position = 0 

     

       44
       +
                        ADD 1 to zero-count

     

       45
       +
                      END-IF

     

       46
       +
                     END-READ

     

       47
       +
                END-PERFORM.

     

       48
       +
                CLOSE input-file.

     

       49
       +
                DISPLAY zero-count.

     

       50
       +
              STOP-RUN.

     

       51
       +

+67

2025/day_01_part2.cbl

···

       1
       +
              IDENTIFICATION DIVISION.

     

       2
       +
              PROGRAM-ID. day_01_part2.

     

       3
       +
              AUTHOR. Trey Bastian.

     

       4
       +
              ENVIRONMENT DIVISION.

     

       5
       +
              INPUT-OUTPUT SECTION.

     

       6
       +
              FILE-CONTROL.

     

       7
       +
              SELECT input-file ASSIGN TO "./input.txt"

     

       8
       +
                  ORGANIZATION IS LINE SEQUENTIAL.

     

       9
       +
              DATA DIVISION.

     

       10
       +
              FILE SECTION.

     

       11
       +
              FD input-file.

     

       12
       +
              01 input-line.

     

       13
       +
                02 direction PIC X.

     

       14
       +
                02 move-text PIC XXX.

     

       15
       +
              WORKING-STORAGE SECTION.

     

       16
       +
              01 dial-position PIC 9(2) VALUE 50.

     

       17
       +
              01 new-position PIC 9(2).

     

       18
       +
              01 move-num PIC S9(3).

     

       19
       +
              01 zero-count PIC 9(4) VALUE ZEROS.

     

       20
       +
              01 eof PIC X.

     

       21
       +
                  88 eof-y VALUE "Y".

     

       22
       +
                  88 eof-n VALUE "N".

     

       23
       +
       

     

       24
       +
              

     

       25
       +
              PROCEDURE DIVISION.

     

       26
       +
                OPEN INPUT input-file.

     

       27
       +
                SET eof-n to TRUE.

     

       28
       +
                PERFORM UNTIL eof-y

     

       29
       +
                    READ input-file AT END

     

       30
       +
                        SET eof-y to TRUE

     

       31
       +
                    NOT AT END

     

       32
       +
                      MOVE FUNCTION NUMVAL(move-text) TO move-num

     

       33
       +
                      IF move-num > 99 

     

       34
       +
                        COMPUTE zero-count = zero-count + (move-num / 100) 

     

       35
       +
                      END-IF

     

       36
       +
       

     

       37
       +
                      IF direction = "L"

     

       38
       +
                       COMPUTE move-num = 0 - move-num 

     

       39
       +
                      END-IF

     

       40
       +
                      

     

       41
       +
                      COMPUTE new-position = FUNCTION MOD(dial-position +

     

       42
       +
                      move-num, 100) 

     

       43
       +
       

     

       44
       +
                      if new-position < 0

     

       45
       +
                        ADD 100 to new-position

     

       46
       +
                      END-IF

     

       47
       +
       

     

       48
       +
                      EVALUATE new-position

     

       49
       +
                        WHEN 0

     

       50
       +
                          ADD 1 to zero-count

     

       51
       +
                         WHEN < dial-position AND direction = "R" AND

     

       52
       +
                           dial-position <> 0

     

       53
       +
                           ADD 1 to zero-count

     

       54
       +
                         WHEN > dial-position AND direction = "L" AND

     

       55
       +
                           dial-position <> 0

     

       56
       +
                           ADD 1 to zero-count

     

       57
       +
                       END-EVALUATE

     

       58
       +
       

     

       59
       +
                      

     

       60
       +
                      MOVE new-position TO dial-position

     

       61
       +
       

     

       62
       +
                     END-READ

     

       63
       +
                END-PERFORM.

     

       64
       +
                CLOSE input-file.

     

       65
       +
                DISPLAY zero-count.

     

       66
       +
              STOP-RUN.

     

       67
       +

+76

2025/day_02.cbl

···

       1
       +
              IDENTIFICATION DIVISION.

     

       2
       +
              PROGRAM-ID. day_02.

     

       3
       +
              AUTHOR. Trey Bastian.

     

       4
       +
              ENVIRONMENT DIVISION.

     

       5
       +
              INPUT-OUTPUT SECTION.

     

       6
       +
              FILE-CONTROL.

     

       7
       +
              SELECT input-file ASSIGN TO "./input.txt"

     

       8
       +
                  ORGANIZATION IS LINE SEQUENTIAL.

     

       9
       +
              DATA DIVISION.

     

       10
       +
              FILE SECTION.

     

       11
       +
              FD input-file.

     

       12
       +
              01 input-line PIC X(4096). 

     

       13
       +
              WORKING-STORAGE SECTION.

     

       14
       +
              01 ptr PIC 9(4) Value 1.

     

       15
       +
              01 len PIC 9(4).

     

       16
       +
              01 left-val PIC 9(32).

     

       17
       +
              01 right-val PIC 9(32).

     

       18
       +
              01 grouping PIC X(65).

     

       19
       +
       

     

       20
       +
              01 val-string PIC Z(32).

     

       21
       +
              01 val-string-len PIC 9(2).

     

       22
       +
              01 val-string-start-idx PIC 9(2).

     

       23
       +
              01 val-string-half PIC 9(2).

     

       24
       +
              01 result PIC 9(32) VALUE ZEROS.

     

       25
       +
       

     

       26
       +
              01 eof PIC X.

     

       27
       +
                  88 eof-y VALUE "Y".

     

       28
       +
                  88 eof-n VALUE "N".

     

       29
       +
              PROCEDURE DIVISION.

     

       30
       +
                OPEN INPUT input-file.

     

       31
       +
                SET eof-n to TRUE.

     

       32
       +
                PERFORM UNTIL eof-y

     

       33
       +
                    READ input-file AT END

     

       34
       +
                        SET eof-y to TRUE

     

       35
       +
                    NOT AT END

     

       36
       +
                     INSPECT input-line TALLYING len FOR CHARACTERS BEFORE

     

       37
       +
                     SPACE

     

       38
       +
       

     

       39
       +
                     PERFORM UNTIL ptr > len

     

       40
       +
                       UNSTRING input-line DELIMITED BY "," INTO grouping WITH

     

       41
       +
                       POINTER ptr

     

       42
       +
                       END-UNSTRING

     

       43
       +
       

     

       44
       +
                       UNSTRING grouping DELIMITED BY "-" INTO left-val,

     

       45
       +
                       right-val

     

       46
       +
                       END-UNSTRING

     

       47
       +
                       

     

       48
       +
                       PERFORM VARYING  left-val FROM left-val BY 1 UNTIL

     

       49
       +
                         left-val > right-val

     

       50
       +
                         MOVE left-val TO val-string

     

       51
       +
       

     

       52
       +
                         COMPUTE val-string-len = FUNCTION LENGTH(FUNCTION

     

       53
       +
                         TRIM(val-string))

     

       54
       +
                         IF FUNCTION MOD(val-string-len, 2) = 0

     

       55
       +
       

     

       56
       +
                           COMPUTE val-string-start-idx = 

     

       57
       +
                           (FUNCTION LENGTH(val-string) - val-string-len ) + 1

     

       58
       +
                           COMPUTE val-string-half = val-string-len / 2

     

       59
       +
       

     

       60
       +
                           IF val-string(val-string-start-idx:val-string-half) 

     

       61
       +
                             = val-string(val-string-start-idx +

     

       62
       +
                             val-string-half:val-string-half)

     

       63
       +
       

     

       64
       +
                             ADD left-val TO result 

     

       65
       +
                           END-IF

     

       66
       +
                         END-IF

     

       67
       +
                       END-PERFORM

     

       68
       +
       

     

       69
       +
                     END-PERFORM

     

       70
       +
       

     

       71
       +
                     END-READ

     

       72
       +
                END-PERFORM.

     

       73
       +
                CLOSE input-file.

     

       74
       +
                DISPLAY result.

     

       75
       +
              STOP-RUN.

     

       76
       +

+103

2025/day_02_part2.cbl

···

       1
       +
              IDENTIFICATION DIVISION.

     

       2
       +
              PROGRAM-ID. day_02_part2.

     

       3
       +
              AUTHOR. Trey Bastian.

     

       4
       +
              ENVIRONMENT DIVISION.

     

       5
       +
              INPUT-OUTPUT SECTION.

     

       6
       +
              FILE-CONTROL.

     

       7
       +
              SELECT input-file ASSIGN TO "./input.txt"

     

       8
       +
                  ORGANIZATION IS LINE SEQUENTIAL.

     

       9
       +
              DATA DIVISION.

     

       10
       +
              FILE SECTION.

     

       11
       +
              FD input-file.

     

       12
       +
              01 input-line PIC X(4096). 

     

       13
       +
              WORKING-STORAGE SECTION.

     

       14
       +
              01 ptr PIC 9(4) Value 1.

     

       15
       +
              01 len PIC 9(4).

     

       16
       +
              01 left-val PIC 9(32).

     

       17
       +
              01 right-val PIC 9(32).

     

       18
       +
              01 grouping PIC X(65).

     

       19
       +
       

     

       20
       +
              01 val-string PIC Z(32).

     

       21
       +
              01 val-string-len PIC 9(2).

     

       22
       +
              01 val-string-start-idx PIC 9(2).

     

       23
       +
              01 val-string-half PIC 9(2).

     

       24
       +
              01 val-window PIC 9(2) VALUE 1. 

     

       25
       +
              01 c-idx PIC 9(2).

     

       26
       +
              01 s-left PIC Z(16).

     

       27
       +
              01 s-right PIC Z(16).

     

       28
       +
              01 no-match PIC X VALUE "N".

     

       29
       +
              01 result PIC 9(32) VALUE ZEROS.

     

       30
       +
       

     

       31
       +
              01 eof PIC X.

     

       32
       +
                  88 eof-y VALUE "Y".

     

       33
       +
                  88 eof-n VALUE "N".

     

       34
       +
              PROCEDURE DIVISION.

     

       35
       +
                OPEN INPUT input-file.

     

       36
       +
                SET eof-n to TRUE.

     

       37
       +
                PERFORM UNTIL eof-y

     

       38
       +
                    READ input-file AT END

     

       39
       +
                        SET eof-y to TRUE

     

       40
       +
                    NOT AT END

     

       41
       +
                     INSPECT input-line TALLYING len FOR CHARACTERS BEFORE

     

       42
       +
                     SPACE

     

       43
       +
       

     

       44
       +
                     PERFORM UNTIL ptr > len

     

       45
       +
                       UNSTRING input-line DELIMITED BY "," INTO grouping WITH

     

       46
       +
                       POINTER ptr

     

       47
       +
                       END-UNSTRING

     

       48
       +
       

     

       49
       +
                       UNSTRING grouping DELIMITED BY "-" INTO left-val,

     

       50
       +
                       right-val

     

       51
       +
                       END-UNSTRING

     

       52
       +
                       

     

       53
       +
                       PERFORM VARYING  left-val FROM left-val BY 1 UNTIL

     

       54
       +
                         left-val > right-val

     

       55
       +
                         MOVE left-val TO val-string

     

       56
       +
       

     

       57
       +
                         COMPUTE val-string-len = FUNCTION LENGTH(FUNCTION

     

       58
       +
                         TRIM(val-string))

     

       59
       +
       

     

       60
       +
                         COMPUTE val-string-start-idx = 

     

       61
       +
                         (FUNCTION LENGTH(val-string) - val-string-len ) + 1

     

       62
       +
       

     

       63
       +
                         COMPUTE val-string-half = val-string-len / 2

     

       64
       +
       

     

       65
       +
                         PERFORM VARYING val-window FROM 1 BY 1 

     

       66
       +
                           UNTIL val-window > val-string-half

     

       67
       +
                           COMPUTE c-idx = val-string-start-idx + val-window

     

       68
       +
                           MOVE "N" to no-match

     

       69
       +
                           PERFORM VARYING c-idx 

     

       70
       +
                             FROM c-idx 

     

       71
       +
                             BY val-window

     

       72
       +
                             UNTIL c-idx

     

       73
       +
                             > FUNCTION LENGTH(val-string)  

     

       74
       +
       

     

       75
       +
                             MOVE val-string(val-string-start-idx:val-window)

     

       76
       +
                             TO s-left

     

       77
       +
       

     

       78
       +
                             IF (c-idx + val-window 

     

       79
       +
                               > FUNCTION LENGTH(val-string))

     

       80
       +
                                  MOVE val-string(c-idx:) TO s-right

     

       81
       +
                              ELSE

     

       82
       +
                                  MOVE val-string(c-idx:val-window) TO s-right

     

       83
       +
                              END-IF

     

       84
       +
                             

     

       85
       +
                             IF NOT s-left = s-right 

     

       86
       +
                               MOVE "Y" to no-match

     

       87
       +
                               EXIT PERFORM

     

       88
       +
                             END-IF

     

       89
       +
                           END-PERFORM

     

       90
       +
                           IF no-match = "N"

     

       91
       +
                             ADD left-val to result

     

       92
       +
                             EXIT PERFORM

     

       93
       +
                           END-IF

     

       94
       +
                         END-PERFORM

     

       95
       +
                       END-PERFORM

     

       96
       +
                     END-PERFORM

     

       97
       +
       

     

       98
       +
                     END-READ

     

       99
       +
                END-PERFORM.

     

       100
       +
                CLOSE input-file.

     

       101
       +
                DISPLAY result.

     

       102
       +
              STOP-RUN.

     

       103
       +

+63

2025/day_03.cbl

···

       1
       +
              IDENTIFICATION DIVISION.

     

       2
       +
              PROGRAM-ID. day_03.

     

       3
       +
              AUTHOR. Trey Bastian.

     

       4
       +
              ENVIRONMENT DIVISION.

     

       5
       +
              INPUT-OUTPUT SECTION.

     

       6
       +
              FILE-CONTROL.

     

       7
       +
              SELECT input-file ASSIGN TO "./input.txt"

     

       8
       +
                  ORGANIZATION IS LINE SEQUENTIAL.

     

       9
       +
              DATA DIVISION.

     

       10
       +
              FILE SECTION.

     

       11
       +
              FD input-file.

     

       12
       +
              01 input-line PIC Z(4096). 

     

       13
       +
              WORKING-STORAGE SECTION.

     

       14
       +
              01 idx PIC 9(4).

     

       15
       +
              01 idx-2 PIC 9(4).

     

       16
       +
              01 len PIC 9(4).

     

       17
       +
       

     

       18
       +
              01 maxim PIC 9 VALUE 0.

     

       19
       +
              01 digit PIC 9 VALUE 0.

     

       20
       +
       

     

       21
       +
              01 joltage PIC XX.

     

       22
       +
              01 result PIC 9(10) VALUE 0.

     

       23
       +
       

     

       24
       +
              

     

       25
       +
              01 eof PIC X.

     

       26
       +
                  88 eof-y VALUE "Y".

     

       27
       +
                  88 eof-n VALUE "N".

     

       28
       +
       

     

       29
       +
              PROCEDURE DIVISION.

     

       30
       +
                OPEN INPUT input-file.

     

       31
       +
                SET eof-n to TRUE.

     

       32
       +
                PERFORM UNTIL eof-y

     

       33
       +
                    READ input-file AT END

     

       34
       +
                        SET eof-y to TRUE

     

       35
       +
                    NOT AT END

     

       36
       +
                       MOVE FUNCTION LENGTH(FUNCTION TRIM(input-line)) TO len

     

       37
       +
                       MOVE 0 TO maxim

     

       38
       +
             *first pass leave something on the right

     

       39
       +
                       PERFORM VARYING idx FROM 1 UNTIL idx > len - 1 

     

       40
       +
                           MOVE FUNCTION NUMVAL(input-line(idx:1)) TO digit

     

       41
       +
                           IF maxim < digit

     

       42
       +
                             MOVE digit TO maxim

     

       43
       +
                             MOVE idx TO idx-2

     

       44
       +
                           END-IF

     

       45
       +
                       END-PERFORM 

     

       46
       +
             * need the next index 

     

       47
       +
                       MOVE maxim TO joltage(1:1)

     

       48
       +
                       MOVE 0 TO maxim

     

       49
       +
                       ADD 1 TO idx-2 

     

       50
       +
                       PERFORM VARYING idx-2 FROM idx-2  UNTIL idx-2 > len

     

       51
       +
                         MOVE FUNCTION NUMVAL(input-line(idx-2:1)) TO digit

     

       52
       +
                         IF maxim < digit

     

       53
       +
                           MOVE digit TO maxim

     

       54
       +
                         END-IF

     

       55
       +
                       END-PERFORM

     

       56
       +
                       MOVE maxim TO joltage(2:1)

     

       57
       +
                       ADD FUNCTION NUMVAL(joltage) TO result

     

       58
       +
                     END-READ

     

       59
       +
                END-PERFORM.

     

       60
       +
                CLOSE input-file.

     

       61
       +
                DISPLAY result.

     

       62
       +
              STOP-RUN.

     

       63
       +

+64

2025/day_03_part2.cbl

···

       1
       +
              IDENTIFICATION DIVISION.

     

       2
       +
              PROGRAM-ID. day_03_part2.

     

       3
       +
              AUTHOR. Trey Bastian.

     

       4
       +
              ENVIRONMENT DIVISION.

     

       5
       +
              INPUT-OUTPUT SECTION.

     

       6
       +
              FILE-CONTROL.

     

       7
       +
              SELECT input-file ASSIGN TO "./input.txt"

     

       8
       +
                  ORGANIZATION IS LINE SEQUENTIAL.

     

       9
       +
              DATA DIVISION.

     

       10
       +
              FILE SECTION.

     

       11
       +
              FD input-file.

     

       12
       +
              01 input-line PIC Z(4096). 

     

       13
       +
              WORKING-STORAGE SECTION.

     

       14
       +
              01 idx PIC 9(4) VALUE 1.

     

       15
       +
              01 idx-2 PIC 9(4).

     

       16
       +
              01 len PIC 9(4).

     

       17
       +
       

     

       18
       +
              01 maxim PIC 9 VALUE 0.

     

       19
       +
              01 digit PIC 9 VALUE 0.

     

       20
       +
              01 remaining PIC 99 VALUE 12.

     

       21
       +
              01 rem-idx PIC 99 VALUE 1.

     

       22
       +
       

     

       23
       +
              01 joltage PIC X(12).

     

       24
       +
              01 result PIC 9(32) VALUE 0.

     

       25
       +
       

     

       26
       +
              

     

       27
       +
              01 eof PIC X.

     

       28
       +
                  88 eof-y VALUE "Y".

     

       29
       +
                  88 eof-n VALUE "N".

     

       30
       +
       

     

       31
       +
              PROCEDURE DIVISION.

     

       32
       +
                OPEN INPUT input-file.

     

       33
       +
                SET eof-n to TRUE.

     

       34
       +
                PERFORM UNTIL eof-y

     

       35
       +
                    READ input-file AT END

     

       36
       +
                        SET eof-y to TRUE

     

       37
       +
                    NOT AT END

     

       38
       +
                       MOVE FUNCTION LENGTH(FUNCTION TRIM(input-line)) TO len

     

       39
       +
                       MOVE 1 TO idx

     

       40
       +
                       MOVE 12 TO remaining

     

       41
       +
                       MOVE 1 TO rem-idx

     

       42
       +
                       PERFORM UNTIL remaining < 1

     

       43
       +
                         MOVE 0 TO maxim

     

       44
       +
                         PERFORM VARYING idx FROM idx UNTIL idx > 

     

       45
       +
                           (len - remaining + 1)

     

       46
       +
                           MOVE FUNCTION NUMVAL(input-line(idx:1)) to digit

     

       47
       +
                           IF maxim < digit

     

       48
       +
                             MOVE digit TO maxim

     

       49
       +
                             MOVE idx TO idx-2

     

       50
       +
                           END-IF

     

       51
       +
                         END-PERFORM

     

       52
       +
                           MOVE maxim TO joltage(rem-idx:1)

     

       53
       +
                           ADD 1 TO rem-idx

     

       54
       +
                           SUBTRACT 1 FROM remaining

     

       55
       +
                           MOVE idx-2 TO idx

     

       56
       +
                           ADD 1 TO idx

     

       57
       +
                       END-PERFORM

     

       58
       +
                       ADD FUNCTION NUMVAL(joltage) TO result

     

       59
       +
                     END-READ

     

       60
       +
                END-PERFORM.

     

       61
       +
                CLOSE input-file.

     

       62
       +
                DISPLAY result.

     

       63
       +
              STOP-RUN.

     

       64
       +

+5 -2

README.md

···

       1
        
       # Advent of Code Repo

     

       2
        
       This repository contains my solutions to the Advent of Code challenges.

     

       3
        
       

     

       4
       -
       I stream all my solutions live on Twitch at [twitch.tv/treybastian](https://twitch.tv/treybastian).

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5
        
       

     

       6
        
       ## 2024 - Fortran

     

       7
        
       You'll need GNUFortran to run these solutions.

     

       8
        
       

     

       9
       -
       On MacOS, you can install it with Homebrew with `brew install gcc`.

···

       1
        
       # Advent of Code Repo

     

       2
        
       This repository contains my solutions to the Advent of Code challenges.

     

       3
        
       

     

       4
       +
       ## 2025 - COBOL 

     

       5
       +
       You'll need to install GNUCobol to run these solutions.

     

       6
       +
       

     

       7
       +
       On MacOS you can install it with Homebrew: `brew install gnucobol`

     

       8
        
       

     

       9
        
       ## 2024 - Fortran

     

       10
        
       You'll need GNUFortran to run these solutions.

     

       11
        
       

     

       12
       +
       On MacOS, you can install it with Homebrew:  `brew install gcc`.

Compare changes