Adil Aliyev's blog

Recently I needed to get the line numbers that was changed in particular git commit to extract some data based on.

The git has a functionality to create a patch using:

git diff commit1 commit2

The command above gives you just the patch in unified diff format. Unfortunately git diff has no feature to get the modified line numbers followed by the changes as (unified format does) in normal diff normat (diff -n or default).

There are a lot of ways to get those line numbers based on diff of course, but I want to share very simple awk script that can be used directly in command line as a pipe.

/^diff .*$/{ print $3; } /^@@.*$/ { str = $3; split(str, arr, "[+,]"); for (i=arr[2];i<=arr[2]+arr[3];i++) { print i; } }

In command line:

git diff commit1 commit2 | awk -f script.awk

or

git diff commit1 commit2 | awk '/^diff .*$/{print $3;}/^@@.*$/ {str = $3;split(str, arr, "[+,]");for (i=arr[2];i<=arr[2]+arr[3];i++) {print i;}}'

We use some sequences for generating unique identifiers in tables. It is used different techniques for generating UIDs. In Oracle or PgSQL we create a sequence and use next value of it every time when we insert into the particular table. In mysql there is an attribute for the column to be a autoincrement field. 

Sometimes we need to take its last value. The first idea will be using LAST_INSERT_ID() function in MySQL. But it will not work for your every scenario. It is useful when you have just inserted a row. 

What about to see AI value for any table in any schema when you want? Googling did not give an adequate result for me. So I used different approach. As you know mysql keeps all information about db in schema named information_schema . 

You can fetch any data related to table structures using informaton_schema. The table called “TABLES” keeps list of tables and attributes for all tables in database. 

mysql> show columns from tables; +-----------------+---------------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +-----------------+---------------------+------+-----+---------+-------+ | TABLE_CATALOG | varchar(512) | NO | | | | | TABLE_SCHEMA | varchar(64) | NO | | | | | TABLE_NAME | varchar(64) | NO | | | | | TABLE_TYPE | varchar(64) | NO | | | | | ENGINE | varchar(64) | YES | | NULL | | | VERSION | bigint(21) unsigned | YES | | NULL | | | ROW_FORMAT | varchar(10) | YES | | NULL | | | TABLE_ROWS | bigint(21) unsigned | YES | | NULL | | | AVG_ROW_LENGTH | bigint(21) unsigned | YES | | NULL | | | DATA_LENGTH | bigint(21) unsigned | YES | | NULL | | | MAX_DATA_LENGTH | bigint(21) unsigned | YES | | NULL | | | INDEX_LENGTH | bigint(21) unsigned | YES | | NULL | | | DATA_FREE | bigint(21) unsigned | YES | | NULL | | | AUTO_INCREMENT | bigint(21) unsigned | YES | | NULL | | | CREATE_TIME | datetime | YES | | NULL | | | UPDATE_TIME | datetime | YES | | NULL | | | CHECK_TIME | datetime | YES | | NULL | | | TABLE_COLLATION | varchar(32) | YES | | NULL | | | CHECKSUM | bigint(21) unsigned | YES | | NULL | | | CREATE_OPTIONS | varchar(255) | YES | | NULL | | | TABLE_COMMENT | varchar(2048) | NO | | | | +-----------------+---------------------+------+-----+---------+-------+ 21 rows in set (0.00 sec)

The column AUTO_INCREMENT is what we need. The following query will be useful for our purpose:

SELECT AUTO_INCREMENT FROM information_schema.TABLES WHERE TABLE_SCHEMA='db_name' AND TABLE_NAME='table_name'

To make it more user-friendly I have created a function that returns that value for any table:

CREATE FUNCTION `current_ai_value`(p_schema_name VARCHAR(255), p_table_name VARCHAR(255)) RETURNS int(11) BEGIN DECLARE current_value INT; select AUTO_INCREMENT INTO current_value FROM information_schema.TABLES WHERE TABLE_NAME=p_table_name and table_schema=p_schema_name; RETURN current_value; END

Let we have a following task: It is given list of times in format "HH mm ss" and we need to sort it asceding (original task can be found here).

Of course there are several ways of solving this task. I used to create a new class named Time that implements Comparator interface and then parsed the input. The solution below I wrote to explain students how they can use Collections API for problem solving at programming contests.

import java.util.List; import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; public class Main_Imperative { static class Time implements Comparable { int h = 0, m = 0, s = 0; public Time(int h, int m, int s) { this.h = h; this.m = m; this.s = s; } @Override public int compareTo(Time o) { long t1 = this.h * 3600 + this.m * 60 + this.s; long t2 = o.h * 3600 + o.m * 60 + o.s; if (t1 > t2) { return 1; } else if (t1 < t2) { return -1; } else { return 0; } } public String toString() { return h + " " + m + " " + s; } } public static void main(String[] args) { List times = new ArrayList< Time>(); Scanner in = new Scanner(System.in); int n = in.nextInt(); int h, m, s; for (int i = 0; i < n; i++) { h = in.nextInt(); m = in.nextInt(); s = in.nextInt(); times.add(new Time(h, m, s)); } Collections.sort(times); for (Time t : times) { System.out.println(t.toString()); } } }

However the lambdas and functional programming in Java looks weird to most "older" Java programmers, it can reduce a lot of coding. Really, this makes sense especially during contests. Solution for the task above can be rewritten in functional way as follows:

import java.util.List; import java.util.ArrayList; import java.util.Scanner; public class Main_Functional { public static void main(String[] args) { List times = new ArrayList<>(); Scanner in = new Scanner(System.in); int n = Integer.parseInt(in.nextLine()); for (int i = 0; i < n; i++) { String s = in.nextLine(); times.add(s); } times.stream() .map(s -> s.split(" ")) // Splitting string into three strings (hours, minutes, seconds) .map(t -> Integer.parseInt(t[0]) * 3600 + Integer.parseInt(t[1]) * 60 + Integer.parseInt(t[2])) // mapping it into one integer .sorted() // sort .map(i -> (i / 3600) + " " + ((i % 3600) / 60) + " " + (i % 60)) // formatting in HH mm ss .forEachOrdered(System.out::println); // printing out } }

It is pretty simple, easy to debug, needs less time to code. :)

There are several new improvements in Java 8 and one of them is about Map in java.util. 

The forEach method in Map is useful for iterating through Map without using loop. 

For instance the code below iterates over the map elements and prints the key/value pairs:

Map<String,String> map = new Map<>(); map.put("key1", "val1"); map.put("key2", "val2"); map.put("key3", "val3"); for (Map.Entry<String, String> entry : map.entrySet()) { String key = entry.getKey(); String value = entry.getValue(); System.out.println(key+"=>"+value); }

The code above can be rewritten as follows using forEach method:

The problem described as:

A non-empty zero-indexed array A consisting of N integers is given. Array A represents numbers on a tape.

Any integer P, such that 0 < P < N, splits this tape into two non−empty parts: A[0], A[1], ..., A[P − 1] and A[P], A[P + 1], ..., A[N − 1].

The difference between the two parts is the value of: |(A[0] + A[1] + ... + A[P − 1]) − (A[P] + A[P + 1] + ... + A[N − 1])|

In other words, it is the absolute difference between the sum of the first part and the sum of the second part.

For example, consider array A such that:

A[0] = 3 A[1] = 1 A[2] = 2 A[3] = 4 A[4] = 3

We can split this tape in four places:

P = 1, difference = |3 − 10| = 7 

P = 2, difference = |4 − 9| = 5 

P = 3, difference = |6 − 7| = 1 

P = 4, difference = |10 − 3| = 7 

Write a function:

class Solution { public int solution(int[] A); }

that, given a non-empty zero-indexed array A of N integers, returns the minimal difference that can be achieved.

For example, given:

A[0] = 3 A[1] = 1 A[2] = 2 A[3] = 4 A[4] = 3

the function should return 1, as explained above.

Assume that:

N is an integer within the range [2..100,000];

each element of array A is an integer within the range [−1,000..1,000].

Complexity:

expected worst-case time complexity is O(N);

expected worst-case space complexity is O(N), beyond input storage (not counting the storage required for input arguments).

Elements of input arrays can be modified.

Copyright 2009–2014 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

The Idea for solution can be dividing the array into two pieces and then find out the minimal difference. Workflow will be as follow:

The minimal difference is 1 as you see. 

If you google about this task you'll see a lot of solutions on different blogs and also at github repos with this idea. Unfortunately most of them doesn't pass all tests. Most of them pay attention to design not for code itself and they don't care about complexity. 

One of the authors created two methods on Java one for the main body of the solution and another for calculating the sum of elements in an array. The calculation process has a one "for" loop. And if you write a loop in main body and you use this method inside of it the complexity will be O(N^2). And for large inputs it'll fail. As you see in description of the task it's written "expected worst-case time complexity is O(N)". 

Actually the solution I describe is O(N+M). So in the first time. I calculate the sum of elements starting from 2nd item (1st index of array). And on every iteration I check the difference if it's less than previous minimum then I save it. Most solutions found on internet start from zero index. But the zero index in this idea has no any meaning. Before the first iteration our "left side" will be 3 and right side will be 1+2+4+3. And the first minimum difference will be difference of them. Then we must begin from 1st indexed element (2nd element) till pre-last element. Another common mistake on the solutions is they go till the last element and some test cases fail for them. 

So the full solution will be:

The FROM_DAYS function in MySQL is opposite of TO_DAYS function. The TO_DAYS returns number of days from the year of 0 (Gregorian calendar). 

If you migrate your tables to Oracle where you keep date values using TO_DAYS function you'll have little problems, because, Oracle has no built-in FROM_DAYS function as in MySQL. Instead Oracle has more powerful functions for working with dates. 

The below code-snipped will help you to use instead of FROM_DAYS function when migrating data from MySQL to Oralce:

UPDATE <TABLE_NAME> SET <DATE_FIELD>=TO_DATE('19700101','YYYY-MM-DD') + (<DATE_FIELD> - 719528) +TO_NUMBER(SUBSTR(TZ_OFFSET(SESSIONTIMEZONE),1,3))/24

If you want to install Oracle Linux from a USB drive, keep in mind that not all hardware supports USB device booting. Also, during the boot process you may have to instruct your BIOS to boot from that specific USB device. Finally, keep in mind that this method of installation is not officially sanctioned by Oracle support.

Prerequisites

The first thing you will need is an ISO image of Oracle Linux. The quickest way to obtain an ISO image is from the Oracle Software Delivery Cloud

You will need a desktop or server system running Oracle Linux in order to prepare your USB drive.

You will also need to download this script to create the bootable USB drive.

Your Oracle Linux system will also need the package syslinux installed. You can install syslinuxusing yum with the following command:

Googling about "~" (tilde) operator in Java didn't give a clear explanation which beginners can understand without problem. Additionally removing questions about bit-wise operators from Java exam since Java SE6 is a reason that some people don't learn bit-wise operations. My personal opinion is every programmer must know and understand clearly bit-wise operations and how to use them in software development. 

In simple words the "~" (tilde) operator is just bit-wise NOT. What does it mean? Let's write a couple of code and try it: 

public class Tilde { public static void main(String args[]) { int x=3; int y=~x; System.out.println(x); System.out.println(y); } }

The result will be:

3 -4

How 3 transformed to -4? As I said the tilde is bit-wise NOT operator. So the operations are performed with their binary representation. The binary representation of 3 is 11. We declared the x as int, and theres are 4 bytes (32 bits) allocated for x in memory. The representation in memory of 3 is:

00000000000000000000000000000011

When we perform a tilde operator on 3, all zeros in binary representation of 3 will be 1 and all ones will be 0:

11111111111111111111111111111100

In JVM's implementation this equals to -4. If you try to perform tilde operation on -4 you'll get 3.

To get the current date and time in Java is pretty easy:

If you use foreign keys in your database tables, you'll probably have problems on migrating data from one database to another.

To solve this problem you need temporarily disable the foreign key constraints check  before import. To do so, simply add this line to the beginning of the import file.

SET foreign_key_checks = 0

And add this line to the end of the file.