(define (get-lines parse-line)
  (with-input-from-file "input"
    (lambda ()
      (let loop ((line (read-line))
                 (lines '()))
        (if (eof-object? line)
            (reverse lines)
            (loop (read-line)
                  (cons (parse-line line) lines)))))))

(define lines (get-lines string->number))

(define (2sum target numbers)
  (let ((passed (make-weak-eq-hash-table)))
    (let loop ((numbers numbers))
      (if (null? numbers) #f
          (let ((x (car numbers)))
            (let ((complement (- target x)))
              (if (and (>= complement 0)
                       (hash-table/get passed complement #f))
                  (* x complement)
                  (begin
                    (hash-table/put! passed x #t)
                    (loop (cdr numbers))))))))))

(define (3sum target numbers)
  (if (null? numbers) #f
      (let ((x (car numbers))
            (remaining (cdr numbers)))
        (let ((complement (- target x)))
          (if (>= complement 0)
              (let ((complement-product (2sum complement remaining)))
                (if complement-product
                    (* x complement-product)
                    (3sum target remaining)))
              (3sum target remaining))))))

(define (one numbers) (2sum 2020 numbers))
(define (two numbers) (3sum 2020 numbers))
(one lines)
(two lines)

(define (get-lines parse-line)
  (with-input-from-file "input"
    (lambda ()
      (let loop ((line (read-line))
                 (lines '()))
        (if (eof-object? line)
            (reverse lines)
            (loop (read-line)
                  (cons (parse-line line) lines)))))))

(define (make-pass-line start end char pass)
  (list start end char pass))
(define (get-start x)
  (car x))
(define (get-end x)
  (cadr x))
(define (get-char x)
  (caddr x))
(define (get-pass x)
  (cadddr x))

(define (parse-password pass-line)
  (let ((split-line ((string-splitter) pass-line)))
    (let ((range ((string-splitter 'delimiter #\-) (car split-line)))
          (char (string-ref (cadr split-line) 0))
          (password (caddr split-line)))
      (let ((start (string->number (car range)))
            (end (string->number (cadr range))))
        (make-pass-line start end char password)))))

(define lines (get-lines parse-password))

(define (count-char char string)
  (string-count (lambda (char2) (eq? char char2)) string))

(define (is-valid-one? pass-line)
  (let ((char-count (count-char (get-char pass-line)
                                (get-pass pass-line))))
    (and (>= char-count (get-start pass-line))
         (<= char-count (get-end pass-line)))))

(define (is-valid-two? pass-line)
  (let ((pass (get-pass pass-line))
        (char (get-char pass-line))
        (start (- (get-start pass-line) 1))
        (end (- (get-end pass-line) 1)))
    (let ((a (string-ref pass start))
          (b (string-ref pass end)))
      (and (or (eq? a char)
               (eq? b char))
           (not (eq? a b))))))

(count is-valid-one? lines)
(count is-valid-two? lines)

export function solvePart1(input) {
  input = U.linesToNumbers(input)
  for (let i = 0; i < input.length; i++) {
    for (let k = 0; k < input.length; k++) {
      if (input[i] + input[k] === 2020) {
        return input[i] * input[k]
      }
    }
  }
}

export function solvePart2(input) {
  input = U.linesToNumbers(input)
  for (let i = 0; i < input.length; i++) {
    for (let j = 0; j < input.length; j++) {
      for (let k = 0; k < input.length; k++) {
        if (input[i] + input[k] + input[j] === 2020) {
          return input[i] * input[k] * input[j]
        }
      }
    }
  }
}

export function solvePart1(input) {
  return input.split('\n').filter(line => {
    let [, min, max, letter, str] = /(\d+)-(\d+) (.): (.*)/.exec(line)
    min = Number(min)
    max = Number(max)

    const count = str.split('').filter(c => c === letter).length
    return count >= min && count <= max
  }).length
}

export function solvePart2(input) {
  return input.split('\n').filter(line => {
    let [, min, max, letter, str] = /(\d+)-(\d+) (.): (.*)/.exec(line)
    min = Number(min)
    max = Number(max)

    return U.xor(str[min - 1] === letter, str[max - 1] === letter)
  }).length
}

test_data = '''1721
979
366
299
675
1456'''

numbers = test_data.split('\n')

for i in range(0, len(numbers)): 
    numbers[i] = int(numbers[i]) 
    
    
for num1 in numbers:
    for num2 in numbers:
         if num1 != num2 and num1 + num2 == 2020:
                print(f"Match Found: {num1} + {num2} = 2020")
                print(f"{num1} * {num2} = {num1 * num2}")

test_data = '''1721
979
366
299
675
1456'''

numbers = test_data.split('\n')

for i in range(0, len(numbers)): 
    numbers[i] = int(numbers[i]) 
    
    
for num1 in numbers:
    for num2 in numbers:
        for num3 in numbers:
            if num1 != num2 and num1 != num3 and num2 != num3 and num1 + num2 + num3 == 2020:
                print(f"Match Found: {num1} + {num2} + {num3} = 2020")
                print(f"{num1} * {num2} * {num3} = {num1 * num2 * num3}")

Regular expressions are somewhat cryptic, and if you haven't learned how to deal with them, I highly recommend https://regexone.com/
It does take a bit of work to learn how to use them, but they are excellent at solving certain types of problems

import re
test_data = '''1-3 a: abcde
1-3 b: cdefg
2-9 c: ccccccccc'''

passwords = test_data.split('\n')

pattern = re.compile(r'(\d+)-(\d+)\s(\w):\s(\w+)')

valid_passwords = 0
for password in passwords:
    match = pattern.match(password)
    min_val = int(match.group(1))
    max_val = int(match.group(2))
    important_char = match.group(3)
    passphrase = match.group(4)
    count = passphrase.count(important_char)
    if count >= min_val and count <= max_val:
        valid_passwords = valid_passwords + 1
        #print(f"{password} meets the criteria")
    else:
        pass
        #print(f"{password} does not meet the criteria")
print(f'A total of {valid_passwords} passwords were valid')

This is basically an XOR logic gate, where it will be true if exactly one of the parameters is TRUE and FALSE if neither or both of the parameters are TRUE. I put a quick one together by starting with 0. Each of the criteria that was TRUE would add +1. If the value at the end was exactly 1, I knew my result was valid. If it was anything other than 1, I knew the result was invalid.

In the code below I separated out 0 and 2 as results for my own debugging purposes, but really the only check you need to make is if it equals 1.

import re
test_data = '''1-3 a: abcde
1-3 b: cdefg
2-9 c: ccccccccc'''

passwords = test_data.split('\n')

pattern = re.compile(r'(\d+)-(\d+)\s(\w):\s(\w+)')

valid_passwords = 0
for password in passwords:
    match = pattern.match(password)
    first_val = int(match.group(1))
    second_val = int(match.group(2))
    important_char = match.group(3)
    passphrase = match.group(4)
    first_char = passphrase[first_val - 1]
    second_char = passphrase[second_val - 1]
    check = 0
    if first_char == important_char:
        check = check + 1
    if second_char == important_char:
        check = check + 1
    if check == 0:
        pass
        #print('Invalid: No characters matched')
    elif check == 1:
        valid_passwords = valid_passwords + 1
        #print('Valid: Exactly 1 character matched')
    else:
        pass
        #print('Invalid: Both characters matched')

• Don't worry about the competition part, just compete against yourself.

• Don't be afraid to ask for help. But if you ask for help, try to understand what people are telling you, rather than just copying it

• These will get substantially harder as time goes one. The later ones especially will be a challenge even for experienced programmers. Don't beat yourself up if you can't figure them out

• Sometimes the hardest part is just getting started. Even getting to the point where you can even start working on the problem takes some effort. Before you even start trying to solve it you need 1)Somewhere to run the code. 2)The problem data in a place you can work with it. I recommend downloading Anaconda and using Jupyter Notebook. Then you can just copy-paste the data into a variable (but you'll need to reformat it or use triple quotes like in my examples

use std::io;
use std::process;
use std::env;

fn recursive_sum(remaining_entries: &[i32], considered: &mut Vec<i32>, target_num_terms: i32, target_sum: i32) {
    if considered.len() as i32 == target_num_terms - 1 {
        for x in remaining_entries {
            if considered.iter().sum::<i32>() + x == target_sum {
                let product: i32 = considered.iter().product::<i32>() * x;
                println!("{}", product);
                process::exit(0);
            }
        }
    } else {
        for x in 0..remaining_entries.len() {
            considered.push(remaining_entries[x]);
            recursive_sum(&remaining_entries[x+1..], considered, target_num_terms, target_sum);
            considered.pop();
        }
    }
}

fn main() -> io::Result<()> {
    let args: Vec<String> = env::args().collect();

    let target_num_terms: i32 = args[1].parse().unwrap();
    let target_sum: i32 = args[2].parse().unwrap();

    let mut entries = Vec::new();
    let mut buffer = String::new();
    let mut considered = Vec::new();

    let stdin = io::stdin();

    while let Ok(_) = stdin.read_line(&mut buffer) {
        let new = buffer.trim().parse::<i32>().unwrap();
        buffer.clear();

        entries.push(new);

        if entries.len() >= target_num_terms as usize {
            recursive_sum(&entries, &mut considered, target_num_terms, target_sum);
	    considered.clear();
        }
    }

    Ok(())
}

extern crate crossbeam;

use std::io;
use std::io::prelude::*;

use crossbeam::channel::{unbounded};
use crossbeam::thread;

fn find_range(range_str: &str) -> (usize, usize) {
    let mut range_iter = range_str.split('-');

    let lower = range_iter.next().unwrap().parse::<usize>().unwrap();
    let upper = range_iter.next().unwrap().parse::<usize>().unwrap();

    (lower, upper)
}

fn part1_test(range: (usize, usize), test_char: char, test_password: &str) -> bool {
    let mut test_char_count = 0;

    for c in test_password.chars() {
        if c == test_char {
            test_char_count += 1;
        }
    }

    range.0 <= test_char_count && test_char_count <= range.1
}

fn part2_test(indices: (usize, usize), test_char: char, test_password: &str) -> bool {
    let pw_bytes = test_password.as_bytes();
    let mut num_pos = 0;

    if pw_bytes[indices.0 - 1] as char == test_char {
        num_pos += 1;
    }

    if pw_bytes[indices.1 - 1] as char == test_char {
        num_pos += 1;
    }

    num_pos == 1
}

fn process_line(line: &str) ->  (bool, bool) {
    let mut line_iter = line.split_whitespace();
    let range = find_range(line_iter.next().unwrap());
    let subject_char = line_iter.next().unwrap().chars().next().unwrap();
    let subject_password = line_iter.next().unwrap();

    (
        part1_test(range, subject_char, subject_password),
        part2_test(range, subject_char, subject_password),
    )
}

fn main() {
    let stdin = io::stdin();
    let num_threads = 2;


    let lines: Vec<String> = stdin.lock().lines().collect::<Result<_, _>>().unwrap();
    let mut p1_matches = 0;
    let mut p2_matches = 0;

    let (line_send, line_recv) = unbounded();
    let (result_send, result_recv) = unbounded();

    thread::scope(|s| {
        for l in lines.iter() {
            line_send.send(l).unwrap();
        }

        drop(line_send);

        for _ in 0..num_threads {
            let r_clone = line_recv.clone();
            let s_clone = result_send.clone();

            s.spawn(move |_| {
                let mut p1_valid_count = 0;
                let mut p2_valid_count = 0;

                while let Ok(line) = r_clone.recv() {
                    let (p1_valid, p2_valid) = process_line(line);

                    if p1_valid {
                        p1_valid_count += 1;
                    }
                    if p2_valid {
                        p2_valid_count += 1;
                    }
                }

                s_clone.send((p1_valid_count, p2_valid_count)).unwrap();
                drop(s_clone);
            });
        }

    }).unwrap();

    drop(line_recv);
    drop(result_send);

    while let Ok((p1_valid_count, p2_valid_count)) = result_recv.recv() {
        p1_matches += p1_valid_count;
        p2_matches += p2_valid_count;
    }

    println!("Part1: {}", p1_matches);
    println!("Part2: {}", p2_matches);
}