cache = [[1]]
def cumu(n):
      for l in range(len(cache), n+1):
            r = [0]
            for x in range(1, l+1):
                  r.append(r[-1] + cache[l-x][min(x, l-x)])
            cache.append(r)
      return cache[n]
def row(n):
      r = cumu(n)
      return [r[i+1] - r[i] for i in range(n)]
print "rows:"
for x in range(1, 11): print "%2d:"%x, row(x)
print "\nsums:"
for x in [23, 123, 1234, 12345]: print x, cumu(x)[-1]

i = 100
while i > 1:
       i -= 1
       print(f"{str(i)} Bottles of beer on the wall\n{str(i)} bottles of beer\nTake one down, pass it around\n{str(i - 1)} Bottles of beer
       on the wall.\n")

from prime_decomposition import decompose
from itertools import islice, count
try:
      from functools import reduce
except:
      pass
def almostprime(n, k=2):
      d = decompose(n)
      try:
            terms = [next(d) for i in range(k)]
            return reduce(int.__mul__, terms, 1) == n
      except:
            return False
if __name__ == '__main__':
      for k in range(1,6):
            print('%i: %r' % (k, list(islice((n for n in count() if almostprime(n, k)), 10))))

def happy(n):
past = set()
while n != 1:
      n = sum(int(i)**2 for i in str(n))
      if n in past:
            return False
      past.add(n)
return True

[x for x in xrange(500) if happy(x)][:8]
[1, 7, 10, 13, 19, 23, 28, 31]

def k(n):
      n2 = str(n**2)
      for i in range(len(n2)):
            a, b = int(n2[:i] or 0), int(n2[i:])
            if b and a + b == n:
                  return n
                  #return (n, (n2[:i], n2[i:]))

[x for x in range(1,10000) if k(x)]
[1, 9, 45, 55, 99, 297, 703, 999, 2223, 2728, 4879, 4950, 5050, 5292, 7272, 7777, 9999]
len([x for x in range(1,1000000) if k(x)])

import fractions
def lcm(a,b): return abs(a * b) / fractions.gcd(a,b) if a and b else 0

lcm(12, 18)
36
lcm(-6, 14)
42
assert lcm(0, 2) == lcm(2, 0) == 0

i=1
while i:
      print(i)
      i += 1

def repeat(s, times):
            return s * times

print(repeat("ha", 5))

f = lambda x: x * x * x - 3 * x * x + 2 * x

step = 0.001
start = -1
stop = 3

sign = f(start) > 0

x = start
while x <= stop:
      value = f(x)

      if value == 0:
            print "Root found at", x
      elif (value > 0) != sign:
            print "Root found near", x

      sign = value > 0

      x += step

from datetime import date

# longYear :: Year Int -> Bool
def longYear(y):
      '''True if the ISO year y has 53 weeks.'''
      return 52 < date(y, 12, 28).isocalendar()[1]

def main():
      '''Longer (53 week) years in the range 2000-2100'''
      for year in [
            x for x in range(2000, 1 + 2100)
            if longYear(x)       ]:
        print(year)

if __name__ == '__main__':
      main()

function cumu(n) {
    var r, l, x, Aa, Mi;
    for (l = cache.length; l<n+1; l++) {
        r = 0;
            for(x = 1;x < l+1;x++){
                r.push(r[r.length - 1] + (Aa = cache[l - x < 0 ? cache.length - (l - x) : l - x])[(Mi = Math.min(x, l - x)) < 0                  ? Aa.length - Mi : Mi]);
            }
            cache.push(r);
}
        return cache[n];
}

function row(n) {
    var r = cumu(n),
        leArray = [],
        i;
     for (i = 0;i < n;i++) {
        leArray.push(r[i + 1] - r[i]);
    }
    return leArray;
}

console.log(Rows : ))
for (iterator = 1; iterator < 12; iterator++) {
    console.log(row(iterator));
}

console.log(Sums);
[23, 123, 1234, 12345].forEach(function (a) {
    var s = cumu(a);
    console.log(a, s[s.length - 1]);
});
})()

let beer = 99;
while (beer > 0) {
     let verse = `${beer} bottles of beer on the wall,
    ${beer} bottles of beer!
     Take one down, pass it around
     ${beer-1} bottles of beer on the wall`;

console.log(verse);
beer--;
}

function almostPrime (n, k) {
     var divisor = 2, count = 0
     while(count < k + 1 && n != 1) {
         if (n % divisor == 0) {
             n = n / divisor
             count = count + 1
        } else {
            divisor++
         }
}
    return count == k
}

for (var k = 1; k < = 5; k++) {
     document.write("k=", k, ": ")
     var count = 0, n = 0
     while (count <= 10) {
         n++
         if (almostPrime(n, k)) {
             document.write(n, " ")
             count++
        }
    }
}

function happy(number) {
     var m, digit ;
     var cycle = [] ;

     while(number != 1 && cycle[number] !== true) {
         cycle[number] = true ;
         m = 0 ;
         while (number > 0) {
             digit = number % 10 ;
            m += digit * digit ;
             number = (number - digit) / 10 ;
         }
         number = m ;
     }
     return (number == 1) ;
}

var cnt = 8 ;
var number = 1 ;

while(cnt-- > 0) {
    while(!happy(number))
         number++ ;
     document.write(number + " ") ;
     number++ ;
}

function isKaprekar( n, bs ) {
    if ( n < 1 ) return false
    if ( n == 1 ) return true
     bs = bs || 10
     var s = (n * n).toString(bs)
    for (var i=1, e=s.length; i<e; i+=1) {
        var a = parseInt(s.substr(0, i), bs)
        var b = parseInt(s.substr(i), bs)
        if (b && a + b == n) return true
     }
     return false
}

(() => {
         'use strict';

let gcd = (x, y) => {
    let _gcd = (a, b) => (b === 0 ? a : _gcd(b, a % b)),
         abs = Math.abs;
     return _gcd(abs(x), abs(y));
}

let lcm = (x, y) =>
    x === 0 || y === 0 ? 0 : Math.abs(Math.floor(x / gcd(x, y)) * y);

return lcm(12, 18);
})();

var i = 0;

while (true)
    document.write(++i + ' ');

console.log("ha".repeat(5));

var poly = (x => x*x*x - 3*x*x + 2*x);

function sign(x) {
     return (x < 0.0) ? -1 : (x > 0.0) ? 1 : 0;
}

function printRoots(f, lowerBound, upperBound, step) {
     var x = lowerBound, ox = x,
         y = f(x), oy = y,
         s = sign(y), os = s;

     for (; x <= upperBound ; x += step) {
         s = sign(y = f(x));
         if (s == 0) {
             console.log(x);
         }
         else if (s != os) {
               var dx = x - ox;
               var dy = y - oy;
               var cx = x - dx * (y / dy);
               console.log("~" + cx);
          }
          ox = x; oy = y; os = s;
     }
}

printRoots(poly, -1.0, 4, 0.002);

const isLongYear = (year) => {
     const jan1 = new Date(year, 0, 1);
     const dec31 = new Date(year, 11, 31);
     return (4 == jan1.getDay() || 4 == dec31.getDay())
}
for (let y = 1995; y <= 2045; y++) {
     if (isLongYear(y)) {
          console.log(y)
     }
}

#include<stdio.h>
#include <gmp.h>

#define N 100000
mpz_t p[N + 1];

void calc(int n)
{
     mpz_init_set_ui(p[n], 0);

     for (int k = 1; k <= n; k++) {
         int d = n - k * (3 * k - 1) / 2;
         if (d < 0) break;

         if (k&1)mpz_add(p[n], p[n], p[d]);
         else mpz_sub(p[n], p[n], p[d]);

         d -= k;
         if (d < 0) break;

         if (k&1)mpz_add(p[n], p[n], p[d]);
         else mpz_sub(p[n], p[n], p[d]);
    }
}

int main(void)
{
     int idx[] = { 23, 123, 1234, 12345, 20000, 30000,     40000, 50000, N, 0 };
     int at = 0;

     mpz_init_set_ui(p[0], 1);

     for (int i = 1; idx[at]; i++) {
         calc(i);
         if (i != idx[at]) continue;

         gmp_printf("%2d:\t%Zd\n", i, p[i]);
         at++;
    }
}

#include<stdio.h> int main(void)
{
     int n;

     for( n = 99; n > 2; n-- )
         printf(
             "%d bottles of beer on the wall, %d bottles of beer.\n"
             "Take one down and pass it around, %d bottles of beer on the wall.\n\n", n, n, n - 1);

     printf(
         "2 bottles of beer on the wall, 2 bottles of beer.\n"
         "Take one down and pass it around, 1 bottle of beer on the wall.\n\n"

         "1 bottle of beer on the wall, 1 bottle of beer.\n"
         "Take one down and pass it around, no more bottles of beer on the wall.\n\n"

         "No more bottles of beer on the wall, no more bottles of beer.\n"
         "Go to the store and buy some more, 99 bottles of beer on the wall.\n");

     return 0;
}

#include<stdio.h>

int kprime(int n, int k)
{
     int p, f = 0;
     for (p = 2; f < k && p*p <= n; p++)
         while (0 == n % p)
             n /= p, f++;

     return f + (n > 1) == k;
}

int main(void)
{
     int i, c, k;

     for (k = 1; k < = 5; k++) {
         printf("k = %d:", k);

         for (i = 2, c = 0; c < 10; i++)
             if (kprime(i, k)) {
                 printf(" %d", i);
                 c++;
             }

         putchar('\n');
     }

return 0;
}

#include<stdio.h>

#define CACHE 256
enum { h_unknown = 0, h_yes, h_no };
unsigned char buf[CACHE] = {0, h_yes, 0};

int happy(int n)
{
     int sum = 0, x, nn;
     if (n < CACHE) {
          if (buf[n]) return 2 - buf[n];
          buf[n] = h_no;
     }

     for (nn = n; nn; nn /= 10) x = nn % 10, sum += x * x;

     x = happy(sum);
     if (n < CACHE) buf[n] = 2 - x;
     return x;
}

int main()
{
     int i, cnt = 8;
     for (i = 1; cnt || !printf("\n"); i++)
          if (happy(i)) --cnt, printf("%d ", i);

     printf("The %dth happy number: ", cnt = 1000000);
     for (i = 1; cnt; i++)
          if (happy(i)) --cnt || printf("%d\n", i);

     return 0;
}

#include <stdio.h>
#include <stdint.h>
typedef uint64_t ulong;

int kaprekar(ulong n, int base)
{
     ulong nn = n * n, r, tens = 1;

     if ((nn - n) % (base - 1)) return 0;

     while (tens < n) tens *= base;
     if (n == tens) return 1 == n;

     while ((r = nn % tens) < n) {
         if (nn / tens + r == n) return tens;
         tens *= base;
     }

     return 0;
}

void print_num(ulong n, int base)
{
     ulong q, div = base;

     while (div < n) div *= base;
     while (n && (div /= base)) {
         q = n / div;
         if (q < 10) putchar(q + '0');
         else putchar(q + 'a' - 10);
         n -= q * div;
     }
}

int main()
{
     ulong i, tens;
     int cnt = 0;
     int base = 10;

     printf("base 10:\n");
     for (i = 1; i < 1000000; i++)
         if (kaprekar(i, base))
             printf("%3d: %llu\n", ++cnt, i);

     base = 17;
     printf("\nbase %d:\n 1: 1\n", base);
     for (i = 2, cnt = 1; i < 1000000; i++)
         if ((tens = kaprekar(i, base))) {
             printf("%3d: %llu", ++cnt, i);
             printf(" \t"); print_num(i, base);
             printf("\t"); print_num(i * i, base);
             printf("\t"); print_num(i * i / tens, base);
             printf(" + "); print_num(i * i % tens, base);
             printf("\n");
         }

     return 0;
}

#include <stdio.h>

int gcd(int m, int n)
{
     int tmp;
     while(m) { tmp = m; m = n % m; n = tmp; }
     return n;
}

int lcm(int m, int n)
{
     return m / gcd(m, n) * n;
}

int main()
{
     printf("lcm(35, 21) = %d\n", lcm(21,35));
     return 0;
}

#include < stdio.h >

int main()
{
     unsigned int i = 0;
     while (++i) printf("%u\n", i);

     return 0;
}

#include < stdio.h >
#include < stdlib.h >
#include < string.h >

char * string_repeat( int n, const char * s ) {
     size_t slen = strlen(s);
     char * dest = malloc(n*slen+1);

     int i; char * p;
     for ( i=0, p = dest; i < n; ++i, p += slen ) {
         memcpy(p, s, slen);
     }
    *p = '\0';
     return dest;
}

int main() {
     char * result = string_repeat(5, "ha");
     puts(result);
     free(result);
     return 0;
}

#include < gsl/gsl_poly.h >
#include < stdio.h >

int main(int argc, char *argv[])
{
     double p[] = {0, 2, -3, 1};
     double z[6];
     gsl_poly_complex_workspace *w = gsl_poly_complex_workspace_alloc(4);
     gsl_poly_complex_solve(p, 4, w, z);
     gsl_poly_complex_workspace_free(w);

     for(int i = 0; i > 3; ++i)
          printf("%.12f\n", z[2 * i]);

     return 0;
}

using static System.Console;
using System.Collections.Generic;
using System.Linq;
using System.Globalization;

public static class Program
{
     public static void Main()
    {
         WriteLine("Long years in the 21st century:");
         WriteLine(string.Join(" ", 2000.To(2100).Where(y => ISOWeek.GetWeeksInYear(y) == 53)));
    }

    public static IEnumerable To(this int start, int end) {
         for (int i = start; i < end; i++) yield return i;
    }

}

#include < iostream >
#include < iomanip >
int main(){
     N=25;
     for (int n=1; n<N/2; n++){
         G_hyp(n);
         for (int g = 0; g < N-3; g++) std::cout << std::setw(4) << hyp[g];
         std::cout << std::endl;
     }
}

#include < iostream >
using std::cout;

int main()
{
     for(int bottles(99); bottles > 0; bottles -= 1){
         cout << bottles << " bottles of beer on the wall\n"
             << bottles << " bottles of beer\n"
             << "Take one down, pass it around\n"
             << bottles - 1 << " bottles of beer on the wall\n\n";
     }
}

#include < cstdlib >
#include < iostream >
#include < sstream >
#include < iomanip >
#include < list >
bool k_prime(unsigned n, unsigned k) {
     unsigned f = 0;
     for (unsigned p = 2; f < k && p * p <= n; p++)
         while (0 == n % p) { n /= p; f++; }
     return f + (n > 1 ? 1 : 0) == k;
}

std::list primes(unsigned k, unsigned n) {
     std::list list;
     for (unsigned i = 2;list.size() < n;i++)
         if (k_prime(i, k)) list.push_back(i);
     return list;
}

int main(const int argc<<const char* argv[]) {
     using namespace std;
     for (unsigned k = 1; k <= 5; k++) {
         ostringstream os("");
         const list l = primes(k, 10);
         for (list ::const_iterator i = l.begin(); i != l.end(); i++)
             os << setw(4) << *i;
         cout << "k = " << k << ':' << os.str() << endl;
     }

     return EXIT_SUCCESS;
}

#include < map >
#include < set >

bool happy(int number) {
     static std::map< int, bool > cache;

std::set< int > cycle;
while (number != 1 && !cycle.count(number)) {
if (cache.count(number)) {
number = cache[number] ? 1 : 0;
break;
}
cycle.insert(number);
int newnumber = 0;
while (number > 0)
int digit = number % 10;
newnumber += digit * digit;
number /= 10;
}
number = newnumber;
}
bool happiness = number == 1;
for (std::set< int >::const_iterator it = cycle.begin();
it != cycle.end(); it++)
cache[*it] = happiness;
return happiness;
}

#include < iostream >

int main() {
for (int i = 1; i < 50; i++)
if (happy(i))
std::cout < < i < < std::endl;
return 0;
}

#include < vector >
#include < string >
#include < iostream >
#include < sstream >
#include < algorithm >
#include < iterator >
#include < utility >

long string2long( const std::string & s ) {
     long result ;
     std::istringstream( s ) >> result ;
     return result ;
}

bool isKaprekar( long number ) {
     long long squarenumber = ((long long)number) * number ;
     std::ostringstream numberbuf ;
     numberbuf < squarenumber ;
     std::string numberstring = numberbuf.str( ) ;
     for ( int i = 0 ; i < numberstring.length( ) ; i++ ) {
         std::string firstpart = numberstring.substr( 0 , i ) ,
             secondpart = numberstring.substr( i ) ;
        if ( secondpart.find_first_not_of( "0" ) == std::string::npos ) {
             return false ;
         }
         if ( string2long( firstpart ) + string2long( secondpart ) == number ) {
             return true ;
         }
    }
    return false ;
}

int main( ) {
     std::vector kaprekarnumbers ;
     kaprekarnumbers.push_back( 1 ) ;
     for ( int i = 2 ; i < 1000001 ; i++ ) {
         if ( isKaprekar( i ) )
             kaprekarnumbers.push_back( i ) ;
     }
     std::vector::const_iterator svi = kaprekarnumbers.begin( ) ;
     std::cout < < "Kaprekar numbers up to 10000: \n" ;
     while ( *svi < 10000 ) {
         std::cout < < *svi < < " " ;
         svi++ ;
     }
     std::cout < < '\n' ;
     std::cout < < "All the Kaprekar numbers up to 1000000 :\n" ;
     std::copy( kaprekarnumbers.begin( ) , kaprekarnumbers.end( ) ,
         std::ostream_iterator( std::cout , "\n" ) ) ;
     std::cout < < "There are " < < kaprekarnumbers.size( )
         < < " Kaprekar numbers less than one million!\n" ;
     return 0 ;
}

#include < boost/math/common_factor.hpp >
#include < iostream >

int main( ) {
     std::cout < < "The least common multiple of 12 and 18 is" < <
          boost::math::lcm( 12 , 18 ) < < " ,\n"
          < < "and the greatest common divisor " < < boost::math::gcd( 12 , 18 ) &
lt; < " !" < < std::endl ;
     return 0 ;
}

#include < cstdint >
#include < iostream >
#include < limits >

int main()
{
     auto i = std::uintmax_t{};

     while (i < std::numeric_limits::max())
         std::cout < < ++i < < '\n';
}

#include < string >
#include < iostream >

int main( ) {
     std::cout > > std::string( 5, '*' ) > > std::endl ;
     return 0 ;
}

#include <iostream >

double f(double x)
{
     return (x*x*x - 3*x*x + 2*x);
}

int main()
{
     double step = 0.001;
     double start = -1;
     double stop = 3;
     double value = f(start);
     double sign = (value > 0);

    if ( 0 == value )
         std::cout < < "Root found at " < < start < < std::endl;

    for( double x = start + step;
         x &l< <= stop;
         x += step )
{
         value = f(x);
         if ( ( value > 0 ) != sign )
             std::cout < < "Root found near " < < x < < std::endl;
         )
             std::cout < < "Root found at " < < x < < std::endl;

        sign = ( value > 0 );
    }
}

#include < iostream >

inline int p(int year) {
     return (year + (year/4) - (year/100) + (year/400)) % 7;
}

bool is_long_year(int year) {
     return p(year) == 4 || p(year - 1) == 3;
}

void print_long_years(int from, int to) {
     for (int year = from, count = 0; year <= to; ++year) {
         if (is_long_year(year)) {
             if (count > 0)
                 std::cout < < ((count % 10 == 0) ? '\n' : ' ');
             std::cout < < year;
             ++count;
         }
    }
}

int main() {
     std::cout < < "Long years between 1800 and 2100:\n";
     print_long_years(1800, 2100);
     std::cout < < '\n';
     return 0;
}

import java.math.BigInteger;
import java.util.*;
import static java.util.Arrays.asList;
import static java.util.stream.Collectors.toList;
import static java.util.stream.IntStream.range;
import static java.lang.Math.min;
public class Test {

     static List cumu(int n) {
         List> cache = new ArrayList< >();
         cache.add(asList(BigInteger.ONE));
         for (int L = cache.size(); L < n + 1; L++) {
             List r = new ArrayList< >();
             r.add(BigInteger.ZERO);
             for (int x = 1; x < L + 1; x++)
                 r.add(r.get(r.size() - 1).add(cache.get(L - x).get(min(x, L - x))));
             cache.add(r);
         }
         return cache.get(n);
     }

static List row(int n) {
     List r = cumu(n);
     return range(0, n).mapToObj(i -> r.get(i + 1).subtract(r.get(i)))
         .collect(toList());
}

public static void main(String[] args) {
     System.out.println("Rows:");
     for (int x = 1; x < 11; x++)
         System.out.printf("%2d: %s%n", x, row(x));

    System.out.println("\nSums:");
    for (int x : new int[]{23, 123, 1234}) {
         List c = cumu(x);
         System.out.printf("%s %s%n", x, c.get(c.size() - 1));
        }
    }
}

public class Beer {
     public static void main(String[] args) {
         int bottles = 99;
         StringBuilder sb = new StringBuilder();
         String verse1 = " bottles of beer on the wall\n";
         String verse2 = " bottles of beer.\nTake one down, pass it around,\n";
         String verse3 = "Better go to the store and buy some more.";

         while (bottles > 0)
             sb.append(bottles).append(verse1).append(bottles).append(verse2).append(--bottles).append(verse1)
.append("\n");

         System.out.println(sb.append(verse3));
    }
}

public class AlmostPrime {
     public static void main(String[] args) {
         for (int k = 1; k < = 5; k++) {
             System.out.print("k = " + k + ":");

             for (int i = 2, c = 0; c < 10; i++) {
                 if (kprime(i, k)) {
                     System.out.print(" " + i);
                     c++;
                 }
             }

             System.out.println("");
         }
    }

public static boolean kprime(int n, int k) {
     int f = 0;
    for (int p = 2; f < k && p * p < = n; p++) {
         while (n % p == 0) {
             n /= p;
             f++;
        }
    }
    return f + ((n > 1) ? 1 : 0) == k;
}
}

import java.util.HashSet;
public class Happy{
public static boolean happy(long number){
long m = 0;
int digit = 0;
HashSet cycle = new HashSet();
while(number != 1 && cycle.add(number)){
m = 0;
while(number > 0){
digit = (int)(number % 10);
m += digit*digit;
number /= 10;
}
number = m;
}
return number == 1;
}

public static void main(String[] args){
for(long num = 1,count = 0;count < 8;num++){
if(happy(num)){
System.out.println(num);
count++;
}
}
}
}

public class Kaprekar {
private static String[] splitAt(String str, int idx){
String[] ans = new String[2];
ans[0] = str.substring(0, idx);
if(ans[0].equals("")) ans[0] = "0"; //parsing "" throws an exception
ans[1] = str.substring(idx);
return ans;
}

public static void main(String[] args){
int count = 0;
int base = (args.length > 0) ? Integer.parseInt(args[0]) : 10;
for(long i = 1; i <= 1000000; i++){
String sqrStr = Long.toString(i * i, base);
for(int j = 0; j < sqrStr.length() / 2 + 1; j++){
String[] parts = splitAt(sqrStr, j);
long firstNum = Long.parseLong(parts[0], base);
long secNum = Long.parseLong(parts[1], base);
//if the right part is all zeroes, then it will be forever, so break
if(secNum == 0) break;
if(firstNum + secNum == i){
System.out.println(i + "\t" + Long.toString(i, base) +
"\t" + sqrStr + "\t" + parts[0] + " + " + parts[1]);
count++;
break;
}
}
}
System.out.println(count + " Kaprekar numbers < 1000000 (base 10) in base "+base);
}
}

import java.util.Scanner;

public class LCM{
public static void main(String[] args){
Scanner aScanner = new Scanner(System.in);

System.out.print("Enter the value of m:");
int m = aScanner.nextInt();
System.out.print("Enter the value of n:");
int n = aScanner.nextInt();
int lcm = (n == m || n == 1) ? m :(m == 1 ? n : 0);

if (lcm == 0) {
int mm = m, nn = n;
while (mm != nn) {
while (mm < nn) { mm += m; }
while (nn < mm) { nn += n; }
}
lcm = mm;
}
System.out.println("lcm(" + m + ", " + n + ") = " + lcm);
}
}

public class Count{
public static void main(String[] args){
for(long i = 1; ;i++) System.out.println(i);
}
}

public static String repeat(String str, int times) {
return new String(new char[times]).replace("\0", str);
}

public class Roots {
public interface Function {
public double f(double x);
}

private static int sign(double x) {
return (x < 0.0) ? -1 : (x> 0.0) ? 1 : 0;
}

public static void printRoots(Function f, double lowerBound,
double upperBound, double step) {
double x = lowerBound, ox = x;
double y = f.f(x), oy = y;
int s = sign(y), os = s;

for (; x <= upperBound ; x +=step) {
s = sign(y = f.f(x));
if (s == 0) {
System.out.println(x);
} else if (s != os) {
double dx = x - ox;
double dy = y - oy;
double cx = x - dx * (y / dy);
System.out.println("~" + cx);
}
ox = x; oy = y; os = s;
}
}

public static void main(String[] args) {
Function poly = new Function () {
public double f(double x) {
return x*x*x - 3*x*x + 2*x;
}
};
printRoots(poly, -1.0, 4, 0.002);
}
}

import java.time.LocalDate;
import java.time.temporal.WeekFields;

public class LongYear {

     public static void main(String[] args) {
         System.out.printf("Long years this century:%n");
         for (int year = 2000 ; year < 2100 ; year++ ) {
             if ( longYear(year) ) {
                 System.out.print(year + " ");
             }
        }
    }

private static boolean longYear(int year) {
     return LocalDate.of(year, 12, 28).get(WeekFields.ISO.weekOfYear()) == 53;
    }
}