const dgmf = (init, lim) => {
    let count = 0

    for (var i = init-1;i < lim+1;i++) {
        count = String(i).includes('5') ? count : count + 1
        // count = i % 5 != 0 ? count + 1 : count
    }

    return count
}

#! /usr/bin/perl
use warnings;
use strict;

sub count_without_5 {
    my ($from, $to) = @_;
    return scalar grep $_ !~ /5/, $from .. $to
}

use Test::More tests => 2;
is count_without_5(1,9), 8;
is count_without_5(4,17), 12;

const dontGiveMeFive = (min, max) =>
  [...Array(max - min + 1).keys()]
  .map(n => n + min)
  .filter(n => !`${n}`.includes('5'))

dont_give_me_five :: [Int] -> Int
dont_give_me_five = foldl (\x y -> if notElem '5' $ show y then x + y else x) 0

dont_give_me_five :: [Int] -> Int
dont_give_me_five = foldl1 (\x y -> if notElem '5' $ show y then x + y else x)

(defn no5? [num]
  (not-any? #{\5} (str num)))

(defn dont-give-me-five! [start end]
  (->>
    (range start (inc end))
    (filter no5?)
    count))

user=> (dont-give-me-five! 1 9)
8
user=> (dont-give-me-five! 4 17)
12

(defun dont-give-me-five (start end)
  (loop for x from start to end
     when (not (contains-5-p x)) collect x))

(defun contains-5-p (n)
  (position #\5 (write-to-string n)))

const dontGiveMeFive = (start, end) => range(start, end).filter(noFive).length;
const range = (start, end) => [...Array(end - start + 1).keys()].map(i => i + start);
const noFive = num => !`${num}`.includes('5');

import strutils # for the 'find' procedure

proc my_filter(start, stop: int): seq[int] =
  for i in start..stop:
    if find($i, "5") == -1:
      result.add(i)

echo my_filter(1,9).len
echo my_filter(4,17).len

no_fives = fn x, y -> x..y |> Enum.map(& Integer.to_string(&1)) |> Enum.filter(& !String.contains?(&1, "5")) |> Enum.count() end

let no_fives x y =
  [x .. y]
  |> Seq.map string
  |> Seq.filter (fun x -> x.Contains("5") |> not)
  |> Seq.length

-- The first line is not necessary
dont_give_me_five :: [Int] -> Int
dont_give_me_five list = sum $ filter (\x -> notElem '5' $ show x) list

def dont_give_me_five(start, end)
  (start..end).to_a.reject { |n| n.to_s.include? "5" }.size
end

def dont_give_me_five(start, end):
    return len([n for n in range(start, end + 1) if '5' not in str(n)])

fn dont_give_me_5(start: usize, end: usize) -> u8 {
    (start..=end)
        .map(|n| n.to_string())
        .filter(|n| !n.contains('5'))
        .count() as u8
}

const format_words = words =>
  words
    .filter(Boolean)
    .join(', ')
    .split('').reverse().join('')
    .replace(' ,', ' dna ')
    .split('').reverse().join('')

fn format_words(words: &[&str]) -> String {
    let words: Vec<&str> = words
        .into_iter()
        .filter(|&w| !w.is_empty())
        .map(|&x| x)    // deref &&str -> &str
        .collect();
      words
        .iter()
        .enumerate()
        .fold(String::new(), |mut sent, (i, w)| {
            if i == 0 {
                sent += w
            } else if i == words.len() - 1 {
                sent += &format!(" and {}", w);
            } else {
                sent += &format!(", {}", w);
            }
            sent
        })
}

def format_words(words):
    sentence = ''
    if words:
        words = [word for word in words if word]
        for index, word in enumerate(words):
            if index == 0:
                sentence += word
            elif index == len(words) - 1:
                sentence += " and " + word
            else:
                sentence += ", " + word
    return sentence

function formatWords(words) {
  if (!words || words.length < 1) return '';

  words = words.filter(val => !!val);
  const length = words.length;

  if (!length) return '';


  return words.reduce((acc, cumul, index) => {
    return index + 1 === length ?
      `${acc} and ${cumul}` :
      `${acc}, ${cumul}`
  });
}

import sequtils # for filter

proc format_words(words: seq[string]): string =
  result = ""
  if words.len > 0:
    var filtered = filter(words, proc(w: string): bool = w.len > 0)
    for word in filtered[0..^2]:
      result.add(word & ", ")
    return result[0..^3] & (" and " & filtered[^1])

echo format_words(@["ninja","samurai","ronin","leonardo","michelangelo","donatello","raphael"])
echo format_words(@["ninja","samurai","ronin"])
echo format_words(@["ninja","", "ronin"])
echo format_words(@[])

(defun format-words (words)
  (format nil "~{~#[~;~a~;~a and ~a~:;~@{~a~#[~;, and ~:;, ~]~}~]~}" words))

(defun format-words (words)
  (with-output-to-string (s)
    (format s "~{~a~^, ~}" (butlast words))
    (unless (= 1 (length words))
      (format s " and "))
    (format s "~a" (car (last words)))))

function formatWords(words) {
    if(!words) return '';
    words = words.filter((word) => word.length);
    let returnString = '';
    for(let i=0; i<words.length; i++) {
        if(i === words.length - 1 && i > 0) {
        returnString += ` and `;
        }
        else if (i > 0){
            returnString += `, `;
        }
        returnString += words[i];
    }
    return returnString;
}

#! /usr/bin/perl
use warnings;
use strict;

sub format_words {
    my @words = grep length, @_;
    my $last = pop @words;
    return join(', ', @words) . (@words ? " and $last" : "")
}

use Test::More tests => 3;
is format_words('ninja', 'samurai', 'ronin'), 'ninja, samurai and ronin';
is format_words('ninja', '', 'ronin'), 'ninja and ronin';
is format_words(), "";

def format_words(words)
  words.reject(&:blank?).join(", ").reverse.sub(',', 'dna ').reverse
end

public class Kata {
  public static int rentalCarCost(int d) {
    int total = d * 40;
    if(d >= 7)
      total -= 50;
    else if(d >= 3)
      total -= 20;
    return total;
  }
}

transportation_on_vacation :: Int -> Int
transportation_on_vacation days
    | days > 6 = max_costs - 50
    | days > 3 = max_costs - 20
    | otherwise = max_costs
    where
    max_costs = 40 * days 

#! /usr/bin/perl
use warnings;
use strict;

my @discounts = ([7, 50], [3, 20], [0, 0]);
sub total {
    my ($days) = @_;
    my $total = $days * 40;
    for (@discounts) {
        my ($at_least, $discount) = @$_;
        return $total - $discount if $days >= $at_least;
    }
}

use Test::More tests => 8;
is total(1), 40;
is total(2), 80;
is total(3), 3 * 40 - 20;
is total(4), 4 * 40 - 20;
is total(5), 5 * 40 - 20;
is total(6), 6 * 40 - 20;
is total(7), 7 * 40 - 50;
is total(8), 8 * 40 - 50;

let
  rate = 40.0
  weekly_discount = 50.0
  weekend_discount = 20.0
  test_data = [1, 2, 3, 4, 5, 6, 7, 8, 9]

proc total_cost(days: int): float =
  result = days.float * rate
  if days >= 7:
    result -= weekly_discount
  elif days >= 3:
    result -= weekend_discount

for n in test_data:
  echo "Cost for ", n, " days is: ", total_cost(n)

function rentalCarCost(d : number) : number {
    let discount : number = 0;
    if(d >= 7) discount = 50;
    else if(d >= 3) discount = 20;
    return (d * 40) - discount;
}

//one-liner
function rentalCarCost2(d : number) : number {
    return d >= 7 ? ((d * 40) - 50) : (d >= 3 ? (d * 40) - 20 : d * 40);
}

fn rental_car_cost(days: i32) -> i32 {
    (days * 40) - match days {
        n if n > 7 => 50,
        n if n >= 3 => 20,
        _ => 0,
    }
}

def rental_price(num_days)
  price = num_days * 40
  return price - 50 if num_days >= 7
  return price - 20 if num_days >= 3
  price
end

#! /usr/bin/perl
use warnings;
use strict;
use feature qw{ say };

{   package Queue;

    use enum qw( LIFO FIFO );

    sub new  { bless [[], []], shift }
    sub Push { push @{ $_[0][LIFO] }, $_[1]; }
    sub Pop  { @{ $_[0][FIFO] } or $_[0]->_restack; pop @{ $_[0][FIFO] }; }
    sub Peek { @{ $_[0][FIFO] } or $_[0]->_restack; say $_[0][FIFO][-1]; }
    sub _restack {
        push @{ $_[0][FIFO] }, pop @{ $_[0][LIFO] } while @{ $_[0][LIFO] };
    }
}

my %dispatch = (
    1 => 'Push',
    2 => 'Pop',
    3 => 'Peek',
);

my $q = 'Queue'->new;

<>;  # skip the 1st line.
while (<>) {
    my ($operation, $argument) = split;
    $q->${\$dispatch{$operation}}($argument);
}

const Queue = {
    in: [],
    out: [],
    enqueue: function(x) {
        this.in.push(x);
    },
    dequeue: function() {
        if (this.out.length == 0) {
            while (this.in.length != 0) {
                this.out.push(this.in.pop());
            }
        }
        return this.out.length == 0 ? "Cannot dequeue" : this.out.pop();
    },
    front: function() {
        if (this.out.length == 0) {
            while (this.in.length != 0) {
                this.out.push(this.in.pop());
            }
        }
        return this.out.length == 0 ? "Cannot show front value" : this.out[this.out.length - 1];
    }
};

class MyQueue(object):
    def __init__(self):
        self.stack1 = []
        self.stack2 = []

    def peek(self):
        if not self.stack2:
            while self.stack1:
                self.stack2.append(self.stack1.pop())
        return self.stack2[-1]

    def pop(self):
        if not self.stack2: 
            while self.stack1:
                self.stack2.append(self.stack1.pop())
        return self.stack2.pop()

    def put(self, value):
        self.stack1.append(value)

function processData(input) {
    class Node {...}
    class Stack {...}
    const inputArray = input.split('\n');
    let stackIn = new Stack();
    let stackOut = new Stack();
    let valArry, result = '';
    for(let i=1; i<=inputArray[0]; i++) {
        valArry = inputArray[i].split(' ');
        switch(valArry[0]) {
            case '1':
                enqueue(valArry[1]);
                break;
            case '2':
                dequeue();
                break;
            case '3':
                result += `${front()}\n`;
                break;
        }
    } 

    function enqueue(val) {
        stackIn.push(val);
    }

    function dequeue() {
        if(stackOut.size === 0) {
            while(stackIn.size > 0) {
                let item = stackIn.pop();
                stackOut.push(item);
            }
        }
        stackOut.pop();
    }

    function front() {
        if(stackOut.size === 0) {
            while(stackIn.size > 0) {
                let item = stackIn.pop();
                stackOut.push(item);
            }
        }
        return stackOut.peek();
    }
    return process.stdout.write(result);
} 

struct MyQueue {
    stack1: Vec<i32>,
    stack2: Vec<i32>,
}

impl MyQueue {
    pub fn new() -> Self {
        MyQueue {
            stack1: vec![],
            stack2: vec![],
        }
    }

    pub fn push(&mut self, x: i32) {
        self.stack1.push(x);
    }

    pub fn pop(&mut self) {
        if self.stack2.is_empty() {
            while !self.stack1.is_empty() {
                self.stack2.push(self.stack1.pop().unwrap());
            }
        }
        self.stack2.pop();
    }

    pub fn peek(&mut self) -> i32 {
        if self.stack2.is_empty() {
            while !self.stack1.is_empty() {
                self.stack2.push(self.stack1.pop().unwrap());
            }
        }
        *self.stack2.last().unwrap()
    }
}

#!/usr/bin/perl
use warnings;
use strict;
use feature qw{ say };

my $test_count = <>;
for my $test_case (1 .. $test_count) {
    my ($destination, $horse_count) = split ' ', <>;
    my $other_max = 0;
    for my $horse (1 .. $horse_count) {
        my ($position, $max_speed) = split ' ', <>;
        my $speed = ($destination - $position) / $max_speed;
        $other_max = $speed if $other_max < $speed;
    }
    say "Case #$test_case: ", $destination / $other_max;
}

use std::f64;
use std::io::{self, prelude::*};

fn cruise_control(distance: f64, horses: &[(f64, f64)]) -> f64 {
    let time = horses
        .iter()
        .map(|&(d, s)| (distance - d) / s)
        .fold(f64::NAN, f64::max);
    distance / time
}

fn parse_line(s: &str) -> (f64, f64) {
    let vec: Vec<f64> = s
        .to_string()
        .split_whitespace()
        .map(|c| c.to_string().parse().unwrap())
        .collect();
    (vec[0], vec[1])
}

fn main() -> Result<(), io::Error> {
    let mut buffer = String::new();
    io::stdin().read_to_string(&mut buffer)?;
    let mut buf_lines = buffer.lines();
    let cases: u8 = buf_lines.next().unwrap().parse().unwrap();
    for case in 0..cases {
        let (dist, number) = parse_line(buf_lines.next().unwrap());
        let mut horses_info = buf_lines.clone().take(number as usize);
        let mut horses = vec![];
        for horse in horses_info {
            buf_lines.next();
            horses.push(parse_line(horse));
        }
        match io::stdout()
            .write(format!("Case #{}: {}\n", case + 1, cruise_control(dist, &horses)).as_bytes())
        {
            Ok(_) => (),
            Err(why) => panic!(why),
        }
    }
    Ok(())
}

def clean_input_file(file_name):
    inp = open(file_name)
    inp = inp.read()
    inp = inp.split('\n')
    cases = int(inp[0])
    inp.pop(0)
    inp.pop()
    return inp, cases


def cruise_control(distance, horse):
    return float(distance - horse[0]) / horse[1]


def get_speeds(distance, horses):
    speeds = []
    for horse in horses:
        speeds.append(cruise_control(distance, horse))
    return distance / max(speeds)

input_file, cases = clean_input_file('test.in')
write_file = open('solution.txt', 'w+')

row = 0

for case in range(cases):
    case_info = input_file[row].split(' ')
    speed = int(case_info[0])
    n_horses = int(case_info[1])

    horses = []
    for _ in range(n_horses):
        row += 1
        horse = input_file[row].split(' ')
        horses.append((int(horse[0]), int(horse[1])))
    write_file.write("Case #{}: {}\n".format(case + 1, "{0:.2f}".format(get_speeds(speed, horses))))
    row += 1

function processData(input) {
    let resultStr = '';
    const inputArray = input.split('\n');
    const cases = parseInt(inputArray.shift());
    for(let i=0; i<cases; i++) {
        resultStr += `Case # ${i+1}: `;
        let me = inputArray.shift().split(' ');
        let destination = parseFloat(me[0]);
        let numHorses = parseInt(me[1]);
        let horses = [];
        for(let j=0; j<numHorses; j++) {
            let horse = inputArray.shift().split(' ');
            horses.push({ velocity: parseFloat(horse[1]), location: parseFloat(horse[0])});
        }
        let sortedHorses = horses.sort((a, b) => b.location-a.location);
        resultStr += `${cruiseControl(destination, sortedHorses)}\n`;
    }
    return process.stdout.write(resultStr);
}

function cruiseControl(dest, horseArry) {
    let B = horseArry[0].location, vB = horseArry[0].velocity;
    for (let i=1; i<horseArry.length; i++) {
        let A = horseArry[i].location, vA = horseArry[i].velocity;
        if(vB === vA) B = A, vB = vA;
        else {
            let x = (vB * A - vA * B) / (vB - vA);
            if(x > dest || x < A) {
                B = A, vB = vA;
            } 
        }
    }
    let tB = (dest - B) / vB;
    return dest / tB;
}