import itertools
from collections import Counter
 
lines = open("puzzle6.txt","r" ).readlines()
 
print("-----------Part 1-----------" )
groups, group  = [], []
# had to add 2 empty lines at the end of the txt file else the count is off by 1
for line in lines:
    if line in ['\n', '\r\n']:
        groups.append(group)
        group = []
    else:
        group.append(line.strip())
 
def count_group(group):
    words = [list(word) for word in group]
    letters = list(itertools.chain(*words))
    c = Counter(letters)
    return sum([len(c.items())])
 
print(sum([count_group(g) for g in groups]))
 
print("-----------Part 2-----------" )
 
def count2_group(group):
    l = len(group)
    words = [list(word) for word in group]
    letters = list(itertools.chain(*words))
    count = Counter(letters)
    s = sum([x == l for x in count.values()])
    return s
 
print(sum([count2_group(g) for g in groups]))

let count = 0;
inputs.forEach((group) => {
    const uniqueAnswers = new Set();
    group.forEach((answers) => {
        [...answers].forEach((letter) => uniqueAnswers.add(letter));
    });
    count += uniqueAnswers.size;
});
 
console.log(count);

function findCommonElement(setA, setB) {
    const common = new Set();
    setB.forEach((element) => {
        if (setA.has(element)) {
            common.add(element);
        }
    });
 
    return common;
}
 
let count = 0;
inputs.forEach((group) => {
    if (group.length === 1) {
        count += group[0].length;
    } else {
        let uniqueAnswers = new Set();
        group.forEach((answers, index) => {
            if (index === 0) {
                [...answers].forEach((letter) => uniqueAnswers.add(letter));
            } else {
                uniqueAnswers = findCommonElement(
                    uniqueAnswers,
                    new Set([...answers])
                );
            }
        });
        count += uniqueAnswers.size;
    }
});
 
console.log(count);

Array.prototype.uniq = function() {
  return this.filter((v, i) => this.indexOf(v) === i)
}
console.log('one star', inputs
   .split("\n\n" )
  .map(g => g.split("\n" ).join(''))
  .map(l =>l.split('').uniq())
  .reduce((a,v)=>a+v.length, 0)
  ) 
 
 
 
// et le 2 
let nbByGroups = inputs
  .map(group=>{
    let responses = group.split("\n" )
    let nbGroups = responses.length
    let t = responses.join('').split('')
    t.sort();
    let letter ='';
    let nbByLetter = 0;
    let nbAllYes = 0;
    for(let i=0; i < t.length; i ++){
      if(t[i] === letter){
        nbByLetter ++;
      } else {
        if(nbByLetter === nbGroups){
          nbAllYes ++
        }
        letter=t[i]
        nbByLetter = 1;
      }
    }
    if(nbByLetter === nbGroups){
      nbAllYes ++
    }
    return nbAllYes
  })
 
  console.log('two stars',nbByGroups.reduce((a,v)=>a+v, 0))

lines = open("puzzle6.txt","r" ).readlines()

[list(word) for word in group]

list(itertools.chain(*words))

words = [list(word) for word in group]
    letters = list(itertools.chain(*words))

letters = ''.join(group)

letters = [letter for word in group for letter in word]

sum([len(c.items())])

c = Counter(letters)
    return sum([len(c.items())])

s = sum([x == l for x in count.values()])

s = sum(1 for x in count.values() if x == l)

<?php
 
$inputFile = __DIR__.'/input.txt';
 
$passports = getRawPassports($inputFile);
 
debug($passports);
 
$nbValidPassports = 0;
foreach ($passports as $passport) {
    $rawFields = explode(' ', $passport);
 
    $fields = [];
    foreach ($rawFields as $rawField) {
        list($key, $value) = explode(':', $rawField);
        $fields[$key] = $value;
    }
 
    $isValid = isPassportValid($fields);
 
    if ($isValid) {
        $nbValidPassports++;
    }
}
 
var_dump($nbValidPassports);
 
function isPassportValid($fields) {
    unset($fields['cid']);
    ksort($fields);
 
    $listFields = implode(array_keys($fields));
 
    if ($listFields !== 'byrecleyrhclhgtiyrpid') {
        return false;
    }
 
    /**
     * byr (Birth Year) - four digits; at least 1920 and at most 2002.
     * iyr (Issue Year) - four digits; at least 2010 and at most 2020.
     * eyr (Expiration Year) - four digits; at least 2020 and at most 2030.
     * hgt (Height) - a number followed by either cm or in:
     *   If cm, the number must be at least 150 and at most 193.
     *   If in, the number must be at least 59 and at most 76.
     * hcl (Hair Color) - a # followed by exactly six characters 0-9 or a-f.
     * ecl (Eye Color) - exactly one of: amb blu brn gry grn hzl oth.
     * pid (Passport ID) - a nine-digit number, including leading zeroes.
     */
 
    if ($fields['byr'] < 1920 || $fields['byr'] > 2002) {
        return false;
    }
    if ($fields['iyr'] < 2010 || $fields['iyr'] > 2020) {
        return false;
    }
    if ($fields['eyr'] < 2020 || $fields['eyr'] > 2030) {
        return false;
    }
    $heightUnit = substr($fields['hgt'], -2);
    if ($heightUnit !== 'cm' && $heightUnit !== 'in') {
        return false;
    }
    $height = substr($fields['hgt'], 0, strlen($fields['hgt'])-2);
    if ($heightUnit === 'cm' && ($height < 150 || $height > 193)) {
        return false;
    }
    if ($heightUnit === 'in' && ($height < 59 || $height > 76)) {
        return false;
    }
    if (!preg_match('/^#[0-9a-f]{6}$/', $fields['hcl'])) {
        return false;
    }
    if (!in_array($fields['ecl'], ['amb', 'blu', 'brn', 'gry', 'grn', 'hzl', 'oth'], true)) {
        return false;
    }
    if (!preg_match('/^\d{9}$/', $fields['pid'])) {
        return false;
    }
 
    return true;
}
 
function getRawPassports($inputFile) {
 
    $passports = [];
 
    $passport = '';
    foreach (file($inputFile, FILE_IGNORE_NEW_LINES) as $line) {
        if (strlen($line) == 0) {
            $passports[] = trim($passport);
            $passport = '';
            continue;
        }
 
        $passport .= ' '.$line;
    }
    $passports[] = trim($passport);
 
    return $passports;
}
 
 
function debug($v) {
    print_r($v);
}

<?php
 
$inputFile = __DIR__.'/input.txt';
 
$boardingPasses = getBoardingPasses($inputFile);
 
$seats = [];
foreach ($boardingPasses as $boardingPass) {
    $seats[$boardingPass['seat']] = $boardingPass['seat'];
}
asort($seats);
 
for ($i = 12; $i < 858; $i++) {
    if (!isset($seats[$i])) {
        printf("Seat %d available\n", $i);
    }
}
 
 
function getBoardingPasses($inputFile) {
 
    $boardingPasses = [];
 
    foreach (file($inputFile, FILE_IGNORE_NEW_LINES) as $line) {
        $line = trim($line);
 
        $rowStr = substr($line, 0, 7);
        $rowBin = strtr($rowStr, ['B' => 1, 'F' => 0]);
        $row = bindec($rowBin);
 
        $columnStr = substr($line, -3);
        $columnBin = strtr($columnStr, ['R' => 1, 'L' => 0]);
        $column = bindec($columnBin);
 
        $boardingPasses[] = [
            'boarding_pass' => $line,
            'row' => $row,
            'column' => $column,
            'seat' => 8 * $row + $column,
        ];
    }
 
    return $boardingPasses;
}
 
 
function debug($v) {
    print_r($v);
}

<?php
 
// Solved in 6 minutes
$inputFile = __DIR__ . '/input.txt';
 
$groupsAnswers = getGroupsAnswers($inputFile);
debug($groupsAnswers);
 
$sumGroupsAnswers = 0;
foreach ($groupsAnswers as $groupAnswers) {
 
    $singleAnswers = explode(' ', $groupAnswers);
    $groupSize = count($singleAnswers);
 
    $nbAnswersByQuestion = [];
    foreach ($singleAnswers as $singleAnswer) {
        $answers = str_split($singleAnswer);
        foreach ($answers as $answer) {
            if (!isset($nbAnswersByQuestion[$answer])) {
                $nbAnswersByQuestion[$answer] = 0;
            }
            $nbAnswersByQuestion[$answer]++;
        }
    }
 
    debug($groupSize);
    debug($nbAnswersByQuestion);
 
    foreach ($nbAnswersByQuestion as $nbAnswers) {
        if ($nbAnswers === $groupSize) {
            $sumGroupsAnswers++;
        }
    }
}
 
var_dump($sumGroupsAnswers);
 
function getGroupsAnswers($inputFile) {
 
    $groupsAnswers = [];
 
    $groupAnswers = '';
    foreach (file($inputFile, FILE_IGNORE_NEW_LINES) as $line) {
        if (strlen($line) == 0) {
            $groupsAnswers[] = trim($groupAnswers);
            $groupAnswers = '';
            continue;
        }
 
        $groupAnswers .= ' '.$line;
    }
    $groupsAnswers[] = trim($groupAnswers);
    return $groupsAnswers;
}
 
function debug($v) {
    //print_r($v);
}

const inputs= 'grosse chaine '.split("\n" )
.map(t =>parseInt(t,10))
.filter(i => !!i)
inputs.sort()
const map = {}
inputs
  .forEach(i => map[i] = true)
  
 
inputs.forEach(first=>{
  let sum = 2020 - first
  if(map[2020 -first ]){
    console.log("1 star ", first, 2020 - first, first * (2020 - first))
  }
 
  for(let counter = 0 ; counter < inputs.length && inputs[counter] < sum ; counter++){
    if(map[2020 - first - inputs[counter]]){
      console.log('2 stars', first, inputs[counter], 2020 - first - inputs[counter], (first*inputs[counter]*2020 - first - inputs[counter]))
    }
  }
})

const inputs= 'grosse chaine '.split("\n" ).filter(t=>!!t)
 
let valid = 0;
for(let counter = 0; counter < inputs.length; counter ++){
  const line = inputs[counter]
  let [_,min, max, letter, pw ] = line.match(/^([0-9]+)-([0-9]+) ([a-z]): ([a-z]+)$/)
  min = parseInt(min,10)
  max = parseInt(max,10)
  const nb = pw.split(letter).length - 1
  if(nb >= min && nb <=max){
    valid ++
  }
}
console.log('1 star ', valid)
 
valid = 0;
for(let counter = 0; counter < inputs.length; counter ++){
  const line = inputs[counter]
  let [_,min, max, letter, pw ] = line.match(/^([0-9]+)-([0-9]+) ([a-z]): ([a-z]+)$/)
  min = parseInt(min,10) -1
  max = parseInt(max,10) -1 
  const nb = pw.split(letter).length - 1
  if((pw[min] === letter || pw[max] === letter) && pw[min] != pw[max]){
    valid ++;
  }
}
console.log('2 star ', valid)

const inputs = 'grosse chaine '.split("\n" ).filter(t=>!!t)
 
var pattern = inputs.map(line=>{
  return line.split('').map(c => c ==='#')
})
let x = 0, y= 0 , yMax = inputs.length
let impacts = 0
while(y < yMax){
  if(pattern[y][x]){
    impacts ++
  }
  x = (x+3) % pattern[y].length
  y += 1
}
 
console.log('1 star', impacts)
impacts = [];
[{dx:1,dy:1},{dx:3,dy:1},{dx:5, dy:1},{dx:7, dy:1},{dx:1,dy:2}].forEach(({dx,dy}, index) => {
  let x = 0, y= 0 , yMax = inputs.length
  impacts[index] = 0
  while(y < yMax){
    if(pattern[y][x]){
      impacts[index] ++
    }
    x = (x+dx) % pattern[y].length
    y += dy
  }
});
console.log('2 star',impacts.reduce((p,c)=>p*c,1))

const inputs= 'grosse chaine ' .split("\n\n" )
  .map(lines => lines.split("\n" ).join(' '))
 
 const fields = {
   byr: str =>{
     return str.length === 4 && parseInt(str, 10) >= 1920 && parseInt(str, 10) <= 2002
   },
   iyr: str=>{
    return str.length === 4 && parseInt(str, 10) >= 2010 && parseInt(str, 10) <= 2020
   },
   eyr: str=>{
    return str.length === 4 && parseInt(str, 10) >= 2020 && parseInt(str, 10) <= 2030
   },
   hgt: str => {
     if(str.length < 4){
       return false
     }
     let unit = str.substr(str.length - 2, 2)
     let nb = parseInt(str.substr(0, str.length - 2))
     switch(unit){
      case 'cm':
        return nb >= 150 && nb <= 193
       case 'in':
         return nb >= 59 && nb <= 76
        
     }
     return false
   },
   hcl: str=>{
    return !!str.match(/^\#[0-9,a-f]{6}$/)
   },
   ecl: str =>{
    return ['amb','blu','brn','gry','grn','hzl','oth'].indexOf(str) >= 0
   },
   pid: str=> {
     return !!str.match(/^[0-9]{9}$/)
   }, 
  cid: false
 }
 let valid = 0;
 let checks = []
 let nbMandatory =  Object
 .keys(fields)
 .filter(f => fields[f])
 .length
let ok = 0
 
 
 inputs.forEach(line=>{
 
  let tokens = line.split(' ')
  tokens.sort()
  let founds = tokens
    .filter(token => {
      const [field,val] = token.split(':');
      if(!fields[field]){
        return false
      }
      const res = fields[field](val)
      if(res){
        if(!checks[field]){
          checks[field] = {}
        }
        if(!checks[field][val]){
          checks[field][val] = 1
        }
        checks[field][val] ++
      }
      return res
    })
 
  if(founds.length === nbMandatory){
    ok ++    
 
  }
 })
 
 Object.keys(checks).forEach(k=>{
   checks[k] = Object.keys(checks[k])
    checks[k].sort()
 })
console.log('2star',ok)

const inputs= 'grosse chaine '.split("\n" )
.filter(t=>!!t)
 
const computeMap = (base, remainingDepth, letters)=>{
  let subMap = []
  if(!remainingDepth){
    return [base]
  }
  letters.forEach(letter =>{
    subMap = subMap.concat(computeMap(base+letter, remainingDepth - 1, letters))
  
  })
  return subMap
}
let ROWS = 7, COLS = 3
 
let rows = computeMap('', ROWS, ['F','B'])
let cols = computeMap('', COLS, ['L','R'])
let max = 0;
inputs.forEach(line=>{
  let row = rows.indexOf(line.substr(0,ROWS))
  let col = cols.indexOf(line.substr(ROWS,COLS))
  let seatId = row * 8 + col
  max = Math.max(max,  seatId )
  console.log(line, rows.indexOf(line.substr(0,ROWS)) , cols.indexOf(line.substr(ROWS,COLS)))
})
 
 
console.log('one star  ', max)
inputs.sort()
let map = {}
inputs.forEach(line=>{
  let row = rows.indexOf(line.substr(0,ROWS))
  let col = cols.indexOf(line.substr(ROWS,COLS))
  let seatId = row * 8 + col
  map[seatId] = line
})
ids = Object.keys(map)
ids.sort((a,b)=>a-b)
let prec = null
ids.forEach(id => {
  if(id-prec !=1 && prec !== null){
    console.log('2star' , id -1)
  }
  prec = id
})