niceideas.ch

My take on Vibe-Coding

Jerome Kehrli — Thu, 9 Apr 2026 06:13:17 -0400

Following this post on linkedin, I thought that I could share one of my own experiences.

A fairly senior developer had an idea for a new product and spent a couple of weeks vibe-coding it. Hundreds of prompts, lots of iterative .md plans and in the end more than half a hundred thousands of lines of code produced in a surprisingly short time.

When the project reached (what was deemed) a first "complete" state, it was handed over to me to take care of the remaining steps, mostly industrialization concerns: CI/CD pipeline and deployment automation, database migrations, security review, that kind of things.

At first glance, I was honestly impressed. That was really a lot of work delivered very quickly.

But as an architect, I tend to look at things through a slightly different lens: overarching structure, code quality, consistency, maintainability, testability... all the boring but essential stuff.
So before jumping in, I spent some time trying to understand where things stood on those aspects.

Well I guess I got a good grasp on the feelings Pandora must have experienced when opening her famous box.

While there were a few good ideas in there and clearly a lot of energy put into it, it was first and foremost lacking consistency all over the place: different architectural patterns used in parallel, some partially applied, some overlapping. Seldom parts of the codebase felt somewhat solid, but most of it was lacking even a minimal design. There was some dead code, quite a few tests but most that didn't pass, and overall again a lack of a clear, unifying structure.

It was the most chaotic codebase I've ever looked at.

The result is that what took roughly two weeks to build would now require a significant amount of time to consolidate, refactor and bring to a proper production-ready state, mostly because it wasn't shaped progressively along the way. I estimated it to 3 months, minimum.

So the "2 weeks" is nothing more than an illusion.

To be fair, even with that, there's still a net gain. If I compare it to building everything from scratch without any AI assistance, I'd probably estimate something like 7–8 months. So ending up around 3–4 months total is still a very decent improvement.

But the second phase, the cleanup and consolidation, is where things can get really tricky and cause quite a bit of a headache if everything is deferred until the end.

The key takeaway

The real leverage with these tools isn't just speed. It's how one uses that speed.

If the architectural thinking, refactoring and validation are done continuously during the process, not postponed, then the outcome is very different. One can still move quite fast, but one also keeps the system coherent as it grows.

In that scenario, I'm pretty convinced the whole thing could have landed in a solid production-ready state in maybe a couple of months, without the heavy stabilization phase afterward.

So the issue isn't vibe-coding itself. It's doing it blindly for too long without stepping back, reviewing and reshaping.

There's a whole world of a difference between "code that works" and "code that's ready to live in production."

(Source : https://medium.com/kairi-ai/how-to-vibe-code-without-creating-tech-debt-04b3ce7d29e1

How I personally use AI

For me, AI is a coding assistant. A very powerful one, but still really just an assistant.

I use it for things like these (among others):

writing utility functions I don't want to spend time on
helping with large refactorings
generating straightforward unit tests
wiring things end-to-end (API - service - DB - migration script)
quickly prototyping ideas

Basically, all the repetitive or low-value parts where it's amazingly helpful.

And every time it produces code, I go through it carefully. Line by line when needed. And quite frankly, I do have very frequently things to say on these lines.

But then where it really shines as well is outside of pure coding:

challenging design ideas
helping explore (and even deploy!) unfamiliar tech
debugging tricky issues
spotting potential performance hotspots or security concerns
etc.

Sometimes it misses obvious things and that's fine. But sometimes it surfaces insights surprisingly fast, and that's where it really feels like a force multiplier.

At the end of the day, tools like Codex or Claude Code feel like superpowers.
But they're MY superpowers, not autonomous developers.

So how much faster in the end?

I'd say that my extensive use of both Claude Code and Codex (they each have their own strengths) gives me roughly a 4x boost in my overall TECHNICAL productivity.
(They definitely don't help with slides though. Forget about that. It's rubbish.)

And that kind of gain is amazing. A real game changer.

Two Books, One Journey Through Computing

Jerome Kehrli — Tue, 23 Dec 2025 06:12:10 -0500

From Transistors to Intelligence

We live surrounded by computers.

They sit in our pockets, run our cars, power global markets, filter our information, and increasingly make decisions that affect our lives. And yet, for most people, including many professionals who work with them every day, computers remain strangely opaque.
We use them fluently. But do we truly understand them?

That question is the quiet thread running through two complementary books:

Together, they form a single intellectual journey: from the physical foundations of computing to the abstract ideas that gave birth to algorithms, cryptography, and artificial intelligence.
They can be read independently. But together, they tell a deeper story, one that is rarely told in a structured, accessible, and honest way.

A Project Born Long Before the First Page

This project did not start with a publishing contract.
It started in 1987, when a father chose to give his child a Commodore 128D instead of a game console.
It continued years later, when a twelve-year-old wrote his first lines of BASIC without knowing that these clumsy instructions would open the door to a lifelong exploration.

What followed was not a straight line, but a long accumulation of questions:

How does a machine really work?
Why do architectures look the way they do?
Where do our algorithms come from?
Why do some problems resist computation?
And how did we end up building systems that can now learn?

These books are not encyclopedias.
They are the result of years of ordering knowledge, making choices, and accepting renunciations, because clarity always comes at the price of exclusion.

Book I - From Matter to Systems

L'informatique – Des transistors aux microservices

The first book is firmly anchored in the concrete reality of machines.
It starts at the lowest possible level - electricity, transistors, logic gates - and slowly builds upward:

microprocessors,
memory and execution,
operating systems,
networking,
virtualization,
distributed systems,
cloud architectures,
and finally, microservices.

But the ambition is not to list technologies.
The goal is to explain why things evolved the way they did.

Why abstraction layers exist.
Why operating systems look the way they do.
Why distributed systems are hard.
Why modern infrastructures inherit constraints that date back decades.

This book is for readers who want to reconnect the dots between:

hardware and software,
systems and applications,
historical constraints and modern design choices.

It is written with the intent to be particularly valuable for:

junior engineers who learned tools before foundations,
developers who want to understand what happens below their code,
architects who need a coherent mental model across layers,
curious readers who want a structured entry point into computing as a system.

Book II - From Ideas to Intelligence

Les sciences informatiques – De Turing à l'intelligence artificielle

If the first book explains what machines are, the second explores what they can compute, and why.
This is the more abstract book.
It is also the one that required the most difficult choices.

Computer science is vast: computability, complexity, data structures, logic, formal languages, graphs, optimization, cryptography, machine learning...
Everything matters.
But a book is not an encyclopedia.

So this volume focuses on a coherent intellectual trajectory:

algorithmic thinking and problem construction,

hard problems and computational limits,
optimization as a unifying discipline,
cryptography as a bridge between pure mathematics and real-world security,
blockchain viewed technically rather than symbolically,
and finally, machine learning - from the perceptron to generative AI.

The goal is not to turn readers into specialists, but to give them conceptual depth: to understand what is happening behind the buzzwords, to see how modern AI is rooted in decades of theory, and to grasp the limits as clearly as the possibilities.

This book is ideal for:

students who want meaning behind formulas,
engineers who use ML without fully understanding it,
professionals navigating AI discourse with critical thinking,
educators looking for a narrative that connects ideas rather than isolating them.

Why These Books Are in French - And Why That Matters

Many excellent books on these topics already exist in English. Much fewer in french.
And that is not the point.
The point is that language is not neutral when it comes to understanding.

For a large part of the francophone world, English technical literature creates friction, translation dilutes nuance and conceptual depth often gets lost behind vocabulary barriers.

Writing these books in French is not a limitation, it is a deliberate choice:

to make deep technical knowledge accessible without linguistic overhead,
to serve students, engineers, and educators who think and teach in French,
to contribute durable reference material to francophone technical culture.

These books assume intelligence, curiosity and rigor, but they do not assume perfect fluency in English.
And that matters.

Emotion, Doubt and the Discipline of Renunciation

Writing these books was not about accumulating content. That was the easy part. It was much more about:

cutting chapters,
abandoning beloved topics,
rewriting explanations until they were both precise and readable,
redrawing diagrams,
verifying references,
and constantly choosing clarity over exhaustiveness.

The hardest part was not technical. It was accepting that some things would not make it into the book.
That discipline is what gives these volumes their coherence.
They are not showcases of erudition. They are guided paths through complexity.

Who These Books Are Really For

These books are not for people looking for quick answers or shortcuts. But rather for people who want:

to understand rather than memorize,
to build mental models rather than collect tools,
to connect history, theory, and practice.

They belong on the shelves of:

junior engineers building their foundations,
experienced professionals filling conceptual gaps,
educators seeking coherent narratives,
and lifelong learners who refuse to treat technology as magic.

Two Independent Books. One Coherent Vision.

Each book stands on its own. But together, they offer something rare: a complete, structured exploration of computing, from physical reality to abstract intelligence.
They explain:

how machines are built,
how computation is defined,
how limits emerge,
and how modern AI fits into a much longer story.

Not as hype. Not as prophecy. But as engineering, science, and human ingenuity.

Final Thought

Technology moves fast.
Understanding lasts longer.
These books were written for those who want to slow down just enough to truly understand what they are building, using, and shaping.

And once you see the whole picture, you never quite look at a computer the same way again.

AI - what do we do differently at NetGuardians ?

Jerome Kehrli — Mon, 18 Feb 2019 02:42:15 -0500

The world of fraud prevention in banking institutions has always been largely based on rules.
Bankers and their engineers were integrating rules engines on the banking information system to prevent or detect most common fraud patterns.
And for quite a long time, this was sufficient.

But today we are experiencing a change of society, a new industrial revolution.
Today, following the first iPhone and the later mobile internet explosion, people are interconnected all the time, everywhere and for all kind of use.
This is the digital era and the digitization of means and behaviours forces corporations to transform their business model.

As a consequence, banking institutions are going massively online and digital first. Both the bank users and customers have evolved their behaviours with the new means offered by the digital era.
And the problem is:
How do you want to protect your customer's assets with rules at a time when, for instance, people connect to their swiss ebanking platform from New York to pay for a holiday house rental in Morocco? How would you want to define rules to detect frauds when there are almost as many different behaviours as there are customers?

At NetGuardians, we prevent fraud using a completely different approach. We use Artificial Intelligence to monitor financial transactions and user behaviour in real time and detect suspicious transactions or activities.
With our Big Data Analytics Platform - NG|Screener - the machine analyzes the past transactions of the customers to understand their transactional behaviour, as well as past activities of users on the banking information system.
The machine is able to analyze a very important depth of history in real time, capturing what customers and users usually do in so called Dynamic Profiles.
Then, whenever a transaction is input on the system, the Artificial Intelligence is able to compare that specific transaction against the customer profile and compute a risk score for it. If the risk score is sufficiently high, the machine will decide to block the transaction and qualify it for further investigation by the bank.

Using advanced machine learning techniques, we are able to have a very broad spectrum of detection, while minimizing wrong alerts, these famous false positives, to an unprecedented low ratio. Instead of focusing on identifying fraudsters, at NetGuardians we focus on understanding user and customer behaviours and habits. In order to find frauds, we don't look only for Fraud. Our approach is to detect and block every transaction that is simply too unusual and risky for the banking institution to afford letting it go out without a further investigation. And it turns out the frauds are simply always part of this set of risky transactions.
Our unique combination of unsupervised and supervised approaches makes it possible to minimize false positives, while still being able to detect fraud patterns never encountered before. In the world of Fraud Prevention Solutions, this is the Holy Grail, being able to use models that can detect what has never been encountered before while at the same time keeping the amount of alerts very low. This is hardly seen in other AI solutions on the market today.

Over the time, we have been able to develop our Artificial Intelligence further to make it smarter and smarter. For instance, pretty soon we started to compare transactions against different background sets, the past customer or user activities of course, but also the banking institution past activities as a whole or even the customer or user peer group.
The peer groups are also built using Machine Learning to analyze customers and users past activities, this time to group them together, and achieve better and more accurate scoring of risky transactions or other activities.

Today, our unique Artificial Intelligence platform is able to use a dozen of different Analytics and Machine Learning approaches going much beyond solely transaction scoring. For instance, we are able to qualify the legitimacy of a specific interaction on the ebanking platform, or to monitor PSD2 providers activity, or even to do frequency and timing anomalies detection on card transactions.

At NetGuardians, we use AI to detect anomalies and prevent fraud by providing the experts and investigators within the bank with the tools aimed at making them more efficient than has ever been possible before.
We enhance the human investigation and analytics process, but we don't supplant it.
This is called Augmented Intelligence, the core of what we do at NetGuardians.

Interview on Artificial Intelligence

Jerome Kehrli — Fri, 29 Jun 2018 10:29:52 -0400

This is a collection of three videos I recorded for the "Empowerment Fundation" as part of their file on Artificial Intelligence.

In parallel and in addition to BeCurious, the Empowerment Foundation launched in 2018 a project of curation files thematic through the bee² program.

Taking up the practice of curating video content, bee² means: exploring the issues that build our world, expand the perspectives of analysis, stimulate awareness to enable everyone to act in a more enlightened and responsible way facing tomorrow's challenges.
It's about bringing out specific issues and allowing everyone to easily discover videos the most relevant, validated by experts, on the given topic without having to browse many sources of information.

The three videos I contributed to are::

The interview was in french (sorry ...)

The three videos can be viewed directly on this very page below.

Enjoy :-)

Blockchain 2.0 - From Bitcoin Transactions to Smart Contract applications

Jerome Kehrli — Tue, 22 Nov 2016 15:29:02 -0500

Since Satoshi's White paper came online, other cryptocurrencies have proliferated on the market. But irrespective of the actual currency and the frequently debated deflation issues, the actual revolution here is the Blockchain protocol and the distributed computing architecture is supports.

Just as thirty years ago the open communications protocol created profitable business services by catapulting innovation, the blockchain protocol has the potential of being the same kind of breakthrough, by offering a just as disruptive foundation on which businesses start to emerge. Using the integrity lattice of the transactions, a whole suite of value trading innovations are beginning to enter the market.

The key innovation here are Smart Contracts. This relatively new concept involves the development of programs that can be entrusted with money.

Smart Contracts are autonomous computer programs that, once started, execute automatically and mandatorily the conditions defined beforehand, such as the facilitation, verification or enforcement of the negotiation or performance of a contract.
They are most of the time defined in a Programming Language, which in the case of the Ethereum Blockchain 2.0 technology form a Turing Complete Programming Language.
Smart Contracts are implemented as any other software program, using conditions, loops, function calls, etc.

If blockchains give us distributed trustworthy storage, then smart contracts give us distributed trustworthy computations.

To illustrate a possible use of smart contracts, let's take the example of travel insurance: finding that 60% of the passengers insured against the delay of their flight never claimed their money, a team created during a hackathon in London in 2015 an Automated Insurance system based on smart contracts.
With this service, passengers are automatically compensated when their flight is delayed, without having to fill out any form, and thus without the company having to process the requests. The blockchain's contribution here consists in generating the confidence and security necessary to automate the declarative phases without resorting to a third party.

The main advantage of putting Smart Contracts in a blockchain is the guarantee provided by the blockchain that the contract terms cannot be modified. The blockchain makes it impossible to tamper or hack the contract terms.
By developing ready to use programs that function on predetermined conditions between the supplier and the client, smart programs ensure a secure escrow service in real time at near zero marginal cost.

Smart Contracts enable to reduce the costs of verification, execution, arbitration and fraud prevention. They enable to overcome the moral hazard problem. The american cryptograph Nick Szabo is deemed to be the inventor of the concept, whom he spoked about in 1995 already. He used to mention the example of a rented car, whose smart contract could return the control to the owner in case the renter forgives the paiements.
Interestingly, as a sidenote, Nick Szabo is also believed by some to be one of the person behind the Satoshi Nakamoto identity.

In a general way, Smart Contracts from the heart of the Ethereum blockchain. Even if Rootstock aims at enabling the implementation of Smart Contracts on the bitcoin blockchain, the development of Smart Contracts technology is really rather related to Ethereum. The next versions of Ethereum are increasingly targeted to offering end users an App-Store-like User Experience to Smart Contracts.

This article intents to be a pretty complete introduction to Blockchain 2.0 technology and Smart Contract applications, detailing both of them as well as list the state of the state of the art of possible use cases being currently studied or discussed.
A big part of this article focuses on the Ethereum blockchain.

(See first article in this serie : Blockchain explained that provides a pretty complete introduction to the initial bitcoin blockchain technology)

Or see part of this article as a slideshare presentation available here : http://www.slideshare.net/JrmeKehrli/blockchain-20-69472625.

Also, this article is available in PDF format here: https://www.niceideas.ch/blockchain_2.0.pdf.

Summary

1. Blockchain 2.0 and Smart Contracts
2. Smart Contracts Operation
3. Blockchain 2.0 projects
4. Ethereum in details
5. Smart Contracts use cases
6. Issues and challenges
7. Conclusion

1. Blockchain 2.0 and Smart Contracts

Smart Contracts are most often the central component of the next-generation blockchain platforms.

Blockchain technology is much broader than just bitcoin. The sustained levels of robust security achieved by public cryptocurrencies have today really proven that this new wave of blockchain technologies can provide efficiencies and intangible technological benefits very similar to what the internet has done in the early 90s.
Blockchains are a very powerful technology, capable of going much further than only "simple" financial transaction; a technology capable of performing complex operations, capable of understanding much more than just how many bitcoins one currently has in his digital wallet.

This is where the idea of Smart Contracts comes in. They form the cornerstone for coming enterprise blockchain applications.

In this article, we will explore what a smart contract is, how it works, and how it is being used.

1.1 From Transactions to Smart Contracts

The Blockchain 2.0 is an evolution of the blockchain protocol enabling not only to exchange transaction but rather code and programs in the form of Smart Contracts
Now developers are allowed to build programs and API's on the Blockchain Protocol.
This relatively new concept involves the development of programs that can be entrusted with money.
Smart contracts are programs that encode certain conditions and outcomes.
For instance, When a transaction between two parties occurs, the program can verify if the product/service has been sent by the supplier. And only after this verification is the sum transmitted to the suppliers account.

By developing ready to use programs that function on predetermined conditions between the supplier and the client, smart programs ensure a secure escrow service in real time at near zero marginal cost

Apart from Financial transactions, smart contracts are now entering a whole lot of different industry.
One can refer to the section 5. Smart Contracts use cases to have a look at the use cases and the industries that can and will be disrupted by the blockchain technology.

Ethereum

Ethereum intends to bring together both a crypto ledger and a Turing-complete programming language. Ethereum's objectives is to turn a simple browser to a Swiss-army knife of blockchain applications by providing tools that allow non-technical users to truly leverage the technology.

Ethereum aims to implement a globally decentralized, un-ownable, digital computer for executing peer-to-peer contracts in the form of actual software programs.
Put more simply, Ethereum is a world computer you can't shut down.

Smart Contract Definition

Smart contract is a term used to describe computer program code that is capable of facilitating, executing, and enforcing the negotiation or performance of an agreement (i.e. contract) using blockchain technology.
The entire process is automated can act as a complement, or substitute, for legal contracts, where the terms of the smart contract are recorded in a computer language as a set of instructions.

1.2 Smart Contracts Overview

A smart contract is a digitally signed, computable agreement between two or more parties. A virtual third party - a software agent - can execute and enforce (at least some of) the terms of such agreements.
In the context of the blockchain, where it truly takes it sense, a smart-contract is an event-driven program, with state, that runs on a replicated, shared ledger and which can take custody over assets on that ledger.

Smart contracts provide a viable method of issuing tracking ownership of unique digital representations of value, which we call money.

Smart contracts are simply computer programs that act as agreements where the terms of the agreement can be preprogrammed with the ability to self-execute and self-enforce itself.
The main goal of a smart contract is to enable two anonymous parties to trade and do business with each other, usually over the internet, without the need for a trusted middleman.
The origin and history of smart contracts is much older than bitcoin and dates back to the 90's. The term "Smart Contract' was first used in 1993 by one of bitcoin's alleged creators, Nick Szabo, and referred to self-automated computer programs that can carry out the terms of any contract.

Traditional physical contracts, such as those created by legal professionals today, contain legal language on a vast amounts of printed documents and heavily rely on third parties for enforcement. This type of enforcement is not only very time consuming, but also very ambiguous. If things go astray, contract parties must often rely on the public judicial system to remedy the situation, which can be very costly and time consuming, down to sometimes useless.
Smart contracts on the blockchain, created by computer programmers, are entirely digital and written using programming code languages. This code defines the rules and consequences in the same way that a traditional legal document would, stating the obligations, benefits and penalties which may be due to either party in various different circumstances. The big difference is that this code is automatically executed by a distributed ledger system, in a non-repudiable and unbreakable way.

Smart Contract code have some unique characteristics.

Deterministic : Since a Smart Contract code is executed on multiple distributed nodes simultaneously, it needs to be deterministic i.e. given an input, all nodes should produce the same output. That implies the Smart Contract code should not have any randomness; it should be independent of time (within a small time window because the code might get executed a slightly different time in each of the nodes); and it should be possible to execute the code multiple times (idempotence).
Immutable : Smart Contract code is immutable. This means that once deployed, it cannot be changed. This of course is beneficial from the trust perspective but it also raises some challenges (e.g. how to fix a code bug) and implies that Smart Contract code requires additional due diligence/governance.
Verifiable: Once deployed, Smart Contract code gets a unique address. Before using the Smart Contract, interested parties can and should view or verify the code.

Smart Contracts benefits

For a wide range of potential applications, blockchain-based smart contracts could offer a number of benefits:

Speed and real-time updates : because smart contracts use software code to automate tasks that are otherwise typically accomplished through manual means, they can increase the speed of a wide variety of business processes.
Accuracy : automated transactions are not only faster but less prone to manual error.
Lower execution risk. The decentralized process of execution virtually eliminates the risk of manipulation, nonperformance, or errors, since execution is managed automatically by the network rather than an individual party.
Fewer intermediaries : smart contracts can reduce or eliminate reliance on third-party intermediaries that provide "trust" services such as escrow between counterparties.
Lower cost : new processes enabled by smart contracts require less human intervention and fewer intermediaries and will therefore reduce costs.
New business or operational models : because smart contracts provide a low-cost way of ensuring that the transactions are reliably performed as agreed upon, they will enable new kinds of businesses, from peer-to-peer renewable energy trading to automated access to vehicles and storage units.

1.3 A little glimpse of Smart Contracts from finance perspective

Just as a Bank account with embedded instructions

There are some elements of bank accounts that behave like smart contracts.
For instance, a bank account has a balance. Every month, for instance, there can be automated payments deducting amounts to pay various bills or fees, for instance for pension plans, If there isn't enough money on the bank account, the payment fails, the owner can get fined, and another workflow is triggered.
There are instructions that need to be set up and associated with the account.

This is similar to what a smart contract can do, except that a smart contract running on a blockchain is run by many parties rather than being controlled by a single one.

How is this different to automated banking payments?

Control : The bank is the ultimate guardian of any bank account. It has complete control, and can arbitrarily add money to an account (well, that never happens !) or subtract some (this does happen, and one needs to argue to get it back). In a blockchain ecosystem, there are no single source of control and participant agrees on decisions by distributed consensus, meaning that multiple parties are constantly checking and re-checking updates to the ledgers, and anything that doesn't conform to pre-agreed rules is rejected by all participants.
Code : With a bank account, there is some logic creating transactions on a monthly basis. That code sits on one computer and is executed by one party (the bank). There are internal controls and reconciliations, but there is no external validation.
With smart contracts running on a blockchain, the logic is run in parallel on all the participating computers, and the results are compared by all participants. Participants only change their own version of the ledger if they agree the results. No one can cheat a blockchain, in theory of course.
Transparency : For all participants in a blockchain ecosystem to run the same code, each verifying the other, the logic of the smart contract must be visible to all. This means anyone can look into a smart contract, and if use it if one wants.
There will be smart contracts for general usage, and also very specific smart contracts. The transparency is both a pro and a con. It's useful to all stakeholders of the contract to agree on what happens; on the other hand it's not just the stakeholders that can see what happens - it's everyone on the network. Privacy in blockchains is a contentious issue. There are solutions to the privacy-vs-validation tension being discussed, some using zero-knowledge proofs; which will be the subject of another post.
Flexibility : The single logic that applies to a bank account is pretty much limited to automating payments. It would be difficult, for instance, to automate a payment from a salary account to a savings account every day it's sunny, then have it all sent back when there is a storm (the 'saving up for a rainy day' smart contract).
A so-called "Turing complete" smart contract can do anything that a normal computer can do, though the blockchain version will run much more slowly and be more expensive to run than on a regular computer (depending on the set-up of the blockchain), because ultimately all computers on the network need to the code in parallel and of course they have to be paid for it.

2. Smart Contracts Operation

In order to understand how smart contracts work, it is important to first make the distinction between the smart contract code and how/what that code is being applied to.

2.1 Smart Contracts Design

A smart contract can be broken down into two separate components:

Smart Contract Code - The code that is stored, verified and executed on a blockchain.
Smart Legal Contracts - The use of the smart contract code that can be used as a complement, or substitute, for legal contracts.

A Smart Contract is a computer program that runs on a shared, replicated ledger, which can process and store information, as well as receive, store and send value.

How Smart Contracts work

Coding : what goes into a Smart Contract
Because smart contracts work like computer programs, it is very important that they do exactly what the parties want them to do. This is achieved by inputting the proper logic when writing a smart contract (more on that later). The code behaves in predefined ways and doesn't have the linguistic nuances of human languages, thus, it has now automated the "if this happens then do that" part of traditional contracts.
Distributed Ledgers : how the smart contract is sent out
The code is encrypted and sent out to other computers via a distributed network of nodes running a distributed ledger. If this is done via public permissionless blockchain such as bitcoin, the contract is sent out similar to the way that a network update of a bitcoin transaction would occur. This can also be done in a permissioned or hybrid distributed ledger platform such as the R3 Distributed Ledger.
Execution : how it is processed
Once the computers in this network of distributed ledgers receive the code, they each come to the same agreement or consensus on the results of the code execution. The network would then update the distributed ledgers to record the execution of the contract, and then monitor for compliance with the terms of the smart contract. In this type of system, single party manipulation is averted because control over the execution of the smart contract is no longer possible since that execution is not in the hands of a single party.

2.2 Smart Contract and Oracles

Some smart contracts systems, including the one built into Bitcoin, are strictly deterministic. In order to interact with the real world, these systems rely on informations (and cryptographic signatures) submitted by outside systems called "oracles".

Oracles are trusted entities which sign claims about the state of the world. Since the verification of signatures can be done deterministically, it allows deterministic smart contracts to react to the (non-deterministic) outside world.

Oracles are required to connect smart contracts to critical data feeds, any web API or various accepted payment methods.

As mentioned previously, Smart Contracts are executed by examining all the conditions of execution which have been defined in advance in the contract code. For example, if a contract includes a condition to run after January 1, 2017, it will be impossible to execute it before that date.
The problem then arises, naturally, from the validation of these conditions of execution. Two scenarios are then possible:

The execution conditions of the contract are linked to other entries in the blockchain or are simple time markers. In this case, checking these execution conditions is very easy: the contract is programmed to verify that these entries exist or that the execution time is passed, and it executes when this is the case.
The conditions of execution of the contract are outside the blockchain (realization of a service, occurrence of an event ...). In this case, the execution of the contract requires the use of a trusted third party, called in the Ethereum jargon an "oracle".

An oracle is instructed to enter the blockchain information reliably so that the contract can run properly and can be constituted in several ways:

Prior designation of a trusted third party known to both parties;
Reference to a database considered "trustworthy" (for example in the case of a sports betting, possibility of referring to the result recorded on the site of a sports newspaper);
Using a decentralized Oracle service. It is an existing service on the blockchain involving many participants. Each participant votes for the result he / she considers to be accurate and it is the consensus among the participants that determines the final result sent to the contract. Decentralized oracle projects already exist, notably the Oraclize project

Long story short, the Oracle stands in between of the External world data or API and the Smart Contract.
As seen on the Oraclize web site :

The challenge with Oracles

An oracle, in the blockchain sense, is a third party which sends to your on-chain smart contract some specific data your smart contract code cannot fetch by itself. As the oracle is a centralized party, one shouldn't take its response for granted.
While hacking the blockchain is proven to be very difficult and unlikely to happen, Oracle form a Single Point of Failure and are vulnerable to attacks.

For example, if one asks an oracle to give last trading price of ETH/USD (forex), then the oracle needs to fetch this data from some exchanges on the Internet and than send this data back.
An attacker could compromise the link between the Oracle and the Forex Exchange company and make the Oracle send back to the blockchain a compromised value.
This is the reason why, by itself, the oracle cannot be trusted.

In the context of Smart Contracts, it is key to be able to trust the data fetched from the outside world and the data provider (in our example this is the exchange trading the ETH/USD pair) and this is difficult.
It the example above, the risk can be mitigated by using different data-sources and using them to determine consensus.

Oraclizes provides its own solution to this trust issue and other initiatives work on other kind of solutions, for instance Codius.

Discussing this issue and its solutions further exceeds the scope of this article.

2.3 DAO

Smart Contracts and blockchain 2.0 technologies have made possible the emergence of special organizations called DAOs.

A Decentralized Autonomous Organization (DAO) is an organization that is run through rules encoded in computer programs called smart contracts. These rules provide a community with unbreakable, secured, universal, public and untamperable governance rules.
A DAO's financial transaction records and program rules are maintained on a blockchain.

A DAO is organized to run without any form of human managerial interactivity, provided the smart contracts are supported by a Turing complete platform. Ethereum is such a platform and thus enables such DAOs.

A DAO is a form of incorruptible organization owned by the people who created it and finance it and whose rules are public.
It brings three new elements in comparison with a traditional organization:

A DAO cannot be stopped or broken
No single person or organization can control the DAO. None can tamper with it, hack it or cheat with it.
Everything in the DAO is public and transparent

It really is a global organization, aimed at being open to everyone. It suffers of no jurisdiction and works with software code and where nobody can fraud.

Corporations and businesses as DAOs

Corporations are, if you strip everything away down to the bare bones, a complex set of contracts and agreements. Most simplistically, employment contracts set the terms for workers pay, duties and responsibilities. Contracts with vendors and customers ensure supply chains are established and maintained. Lease agreements cover office space, vehicles, large machinery and rights to intellectual property.
And so on ... other parts or functions are covered by other contractual elements.

Smart contracts exist without the need for those institutional layers. An organization can be built where all of these agreements are replaced by such smart contracts, and in essence the corporation will exist entirely as an entity on a blockchain. As such it will be a decentralized organization, existing across all the nodes of the network.

A DAO would be in the business of generating economic profits if it were structured as a corporation (Decentralized Autonomous Corporation), and it could raise capital through crowdsales of tokens directly to the blockchain, akin to shares in a public company. Tokenholders would be entitled to their share of profits in the form of dividends, and could vote on the direction of the company. Those tokens could also trade on a secondary market (also on the blockchain) for people to buy and sell them at will.

3. Blockchain 2.0 projects

After the initial blockchain of the Bitcoin, many other projects started to flourish pretty soon. Interstingly, the blockchainb appear to be able to give life to some concepts designed or discussed many years before.
Nick Szabo described Smart Contracts 20 years ago. Interestingly, he has been involved pretty early in the bitcoin project as well.

3.1 New Blockchain technologies

In the world of Blockchain 2.0, the main difference between the different initiatives and technologies is really related to the form of support for Smart Contracts:

	No Smart Contracts	Smart Contracts possible	Turing-Complete Smart Contracts
What?	Distributed transaction or accounting storage	Distributed computing of logic available in pre-designed templates	Distributed computing of any logic
Example technologies	Bitcoin (public) Litecoin (public) Multichain (private)	NXT (public) R3 (private)	Ethereum (public) Eris (private) Clearmatics (private)

Presentation of some of them

Bitcoin's platform is great for processing bitcoin transactions, but otherwise has very limited compute ability. Within the scripts of bitcoin transactions there is only very limited ability to implement rich logic.
An example of what is possible in bitcoin is logic requiring multiple signatories to sign a transaction before a payment is made, like needing two signatories in a cheque. However major changes would need to be made to both the mining functions and the mining incentivisation schemes to enable smart contracts proper on Bitcoin's blockchain.

Sidechains, i.e. blockchains connected to Bitcoin's main blockchain could enable smart contract functionality: by having different blockchains running in parallel to Bitcoin, with an ability to jump value between Bitcoin's main chain and the side chains, side chains could be used to execute logic.

NXT is an public blockchain platform which includes a selection of smart contracts that are currently live. However it is not Turing-complete, meaning that it's not possible to code up anything one wants, one has to use the existing templates.

R3/Corda is the private blockchain technology of the R3 consortium. The R3 consortium is constituted by more than 70 of the world biggest financial institutions in research and development of blockchain usage in the financial system. The consortium's joint efforts have created an open-source blockchain platform called Corda especially geared towards the financial world as it handles more complex transactions and restricts access to transaction data. The aim of Corda is to provide a platform with common services to ensure that any services built on top are compatible between the network participants, whilst still fostering innovation and faster time to market as the underlying infrastructure would be accepted and understood by at least the founding firms.

Ethereum is a public blockchain platform which is currently the most advanced smart contract enabled blockchain. With a "Turing complete" coding system, theoretically one can put any possible logic into an Ethereum smart contract, and it will be run by the whole network. There are mechanisms in place to prevent abuse, and of course one needs to pay for compute power, by passing in "ETH" tokens, which act as payment for the miners who run the code.

3.2 A focus on R3/Corda and Smart Contract Templates

Corda is a distributed ledger platform designed from the ground up to record, manage and synchronize financial agreements between regulated financial institutions. It is heavily inspired by and captures the benefits of blockchain systems, without the design choices that make blockchains inappropriate for many banking scenarios.

Key features

R3/Corda:

has no unnecessary global sharing of data: only those parties with a legitimate need to know can see the data within an agreement
choreographs workflow between firms without a central controller
achieves consensus between firms at the level of individual deals, not the level of the system
benefits from a design directly enabling regulatory and supervisory observer nodes
provides transactions validated by parties to the transaction rather than a broader pool of unrelated validators
supports a variety of consensus mechanisms
records an explicit link between human-language legal prose documents and smart contract code
has no native cryptocurrency

R3/Corda uses Smart Contract Templates which captures a Smart Contract as Ricardian Contract triple of "prose, parameters and code".

This is a very specific model that won't be described further in this article. We will now mostly focus on Turing-Complete Smart Contracts and specifically the Ethereum project.

3.3 A first focus on Ethereum and Turing Complete Smart Contracts

Ethereum is software running on a network of computers that ensures that data and small computer programs called smart contracts are replicated and processed on all the computers on the network, without a central coordinator. The vision is to create an unstoppable censorship-resistant self-sustaining decentralized world computer. The official website is https://www.ethereum.org

It extends the blockchain concepts from Bitcoin which validates, stores, and replicates transaction data on many computers around the world (hence the term 'distributed ledger'). Ethereum takes this one step further, and also runs computer code equivalently on many computers around the world.

What Bitcoin does for distributed data storage, Ethereum does for distributed data storage plus computations. The small computer programs being run are called smart contracts, and the contracts are run by participants on their machines using a sort of operating system called a "Ethereum Virtual Machine".

4. Ethereum in details

The vision of Ethereum is an unstoppable censorship-resistant sefl-sustaining decentralized world computer.

Concept	Description
ETH	Ethereum's inbuilt native cryptocurrency, used for paying for smart contracts to run
Ethereum VM, Swarm and Whisperer	Decentralized Computer, file storage and communication protocols
Solidity, Serpent and LLL	Smart Contract Programming Language
`geth`, `eth`, `pyethapp`	The main Ethereum software, written in different language
meteor-dapp-wallet, Mist	GUI applications running on top of `geth` or `eth`
Frontier, Homestead, Metropolis, Serenity	Friendly names for different releases

We will now see the concepts of Ethereum in a more detailed way.

4.1 Ethereum concepts

Computers need to be able to calculate, store data, and communicate. For Ethereum to realize its vision as an unstoppable censorship-resistant self-sustaining decentralised 'world' computer, it needs to be able to do those three things fairly efficiently and in a robust way.

Ethers

The digital tokens or coins in Ethereum are called ether. Ether are used as crypto fuel or costs of transaction. Developers have to use ether to submit smart contract rules/code to the blockchain and users have to spend or burn ether to invoke transactions for an application. Transactions will roll back if they run out of gas (the amount of ether specified). Ether can be traded against bitcoins and other fiat currencies via cryptocurrency exchanges.

As a matter of fact, there are several different currency names for different scales:

We'll indistinctly use Ether or simply ETH below to design the Ethereum cryptocurrency.

Swarm and Whisper

The Ethereum Virtual Machine is the "virtual world computer' compotent that can runs and executes smart contract's logic.
This is computation without relying on a central server.

Swarm is Peer-to-Peer file sharing, similar to BitTorrent, but incentivized with micropayments of Ethers. Files are split into chunks, distributed and stored with participating volunteers. These nodes that store and serve the chunks are compensated with ETH from those storing and retrieving the data.
This is file storage without relying on a central server.

Whisper is an encrypted messaging protocol that allows nodes to send messages directly to each other in a secure way and that also hides the sender and receiver from third party snoopers.
This is communications without relying on a central server.

Smart Contract languages: Solidity / Serpent, LLL

There are three common languages smart contracts are written in, which can be compiled into smart contracts and run on Ethereum Virtual Machines. They are:

Solidity : similar to the language Javascript. This is currently the most popular and functional smart contract scripting language.
Serpent : similar to the language Python, and was popular in the early history of Ethereum.
LLL (Lisp Like Language) : similar to Lisp and was only really used in the very early days. It is probably the hardest to write in.

Ethereum software: geth, eth, pyethapp

The official Ethereum clients are all open source. The most popular clients are:

geth : written in a language called GO - https://github.com/ethereum/go-ethereum
eth : written in C++ - https://github.com/ethereum/cpp-ethereum
pyethapp : written in Python - https://github.com/ethereum/pyethapp

These are all command-line based programs (think green text on black backgrounds) and so additional software can be used for a nicer graphical interface.
Currently the official and most popular graphical one is Mist - https://github.com/ethereum/mist, which runs on top of geth or eth.

Accounts

In Bitcoin, there is a concept called address where bitcoins are stored - like a bank account number, but for bitcoins. In Ethereum these are commonly called accounts and there are two types:

Accounts that only store ETH : these are similar to Bitcoin addresses and are sometimes known as Externally Owned Accounts (EOAs). One makes payments from these accounts by signing transactions with the appropriate private key.
Accounts that store ETH and have code (smart contracts) that can be run : these smart contracts are activated by a transaction sending ETH into it. Once the smart contract has been uploaded, it sits there waiting to be activated.

Apart from the fact whether an account stores code or not, the EVM treats the two types equally, though. Every account has a persistent key-value store mapping 256-bit words to 256-bit words called storage. Furthermore, every account has a balance in Ether (in "Wei" to be exact) which can be modified by sending transactions that include Ether.

The fact that Smart Contracts on Ethereum have their own account is important. As a matter of fact, Smart Contracts instances can own ETH.

Gas and Gas Price

Gas is the internal pricing for running a transaction or contract in Ethereum. It's purpose is to decouple the unit of Ether (ETH) and its market value from the unit to measure computational use (gas).
A miner will use an amount of gas directly dependent on the amount of operations it needs to execute to run a Smart Contract or support an API all. If need be, the price of gas, i.e. the price of one unit of gas, can be increased or decreased independently in order to avoid a situation in which an increase in the price of ETH would cause the need to change all computing cost prices expressed in gas.

The usage of this more concrete notion of gas and using a gas price in ETH makes the computation system independent from actual ETH market value.

The gas system is not very different from the use of Kw for measuring electricity home use. One difference from actual energy market is that the originator of the transaction sets the price of gas, to which the miner can or not accept.

The gas price is a value set by the creator of the transaction, who has to pay [gas_price * gas] up front from the sending account. If some gas is left after the execution, it is refunded in the same way.
This way, If ETH market value goes up, miners can agree on decreasing the gas price to keep computing cost constant, and the other way around.

In addition, the gas price per transaction or contract is set up to deal with the Turing Complete nature of Ethereum and its EVM (Ethereum Virtual Machine Code) - the idea being to limit infinite loops. So for example 10 Szabo, or 0.00001 Ether or 1 Gas can execute a line of code or some command. If there is not enough Ether in the account to perform the transaction or message then it is considered invalid. The idea is to stop denial of service attacks from infinite loops, encourage efficiency in the code - and to make an attacker pay for the resources they use, from bandwidth to CPU calculations through storage.

The more complex the program one wants to execute, the more gas (and thus Ether) one has to pay. For example if A wants to send B one Ether unit - there would be a total cost of 1.00001 Ether to be paid by A. However if A wanted to form a contract with B depending on the future price of Ether, there would be more lines of code executable and more energy consumption placed on the distributed Ether network - and therefore A would have to pay more than the 1 Gas done in the transaction.

4.2 Ethereum and bitcoin differences

	Bitcoin	Ethereum
Applications	Digital Cash Merchant Payments Currency Trading	Smart Contracts Application Platform
Ownership	No one owns Bitcoin. Developer community and mining pool consensus drives roadmap	Ethereum Foundation develops the platform and roadmap for Ethereum
Blockchain	Blockchain is public and decentralized. New blocks mined every 10 minutes. SHA-256 Proof of Work and consensus verification.	Blockchain is public and decentralized. New blocks mined every 12 seconds. Ethash proof of work and consensus verification. Uncle blocks accepted
Coins	15.3 million of a total possible of 21 millions bitcoins have been mined. Current block reward of 25 bitcoins halving every 210'000 blocks	72 million ethers premined 5 ethers generated as block reward, 4.3 for uncle blocks. No cap; linear rising annual ether limit.
Mining	Full and light nodes are allowed. Increasing barriers to CPU mining. Near centralized mining industry with ASIC and FGPA mining in large scale data centers.	Current Frontier release requires full nodes. Ethash proof of work is ASIC resistant and memory hard. GPU friendly by design.
Trading	Bitcoins have a market cap of about $6 billion and are trading around $400 in Q1 2016.	Ether market cap approaching $1 billion trading at $11 in 2016. Second largest cryptocoin by market cap.

Ethereum's block time is shorter

In Ethereum the time between blocks is around 14 seconds, compared with Bitcoin's ~10 minutes. This means that on average if one made a Bitcoin transaction and an Ethereum transaction, the Ethereum transaction would be recorded into Ethereum's blockchain faster than the Bitcoin transaction getting into Bitcoin's blockchain. One could say Bitcoin writes to its database roughly every 10 minutes, whereas Ethereum writes to its database roughly every 14 seconds.

If one followed carefully the first article int his serie (see introduction above), one knows that this has a consequence. A shorter time between blocks means much more exctincts blocks and branches being created. A solution needed to be found to make it still interesting to miner to try to mine blocks in Ethereum. See notion of uncles below.

Ethereum has smaller blocks

In Bitcoin, the maximum block size is specified in bytes (currently 1 MB) whereas Ethereum's block size is based on complexity of contracts being run - it's known as a Gas limit per block, and the maximum can vary slightly from block to block.
Currently the maximum block size in Ethereum is around 1,500,000 Gas. Basic transactions or payments of ETH from one account to another (ie not a smart contract) have a complexity of 21,000 Gas so one can fit around 70 transactions into a block (1,500,000 / 21,000). In Bitcoin one currently gets around 1,500-2,000 transactions in a block.
Data-wise currently most Ethereum blocks are under 2 KB in size.

ETH (Ether) issuance

Bitcoin is a cryptocurrency and payments network. Bitcoins are designed to be in finite supply and deflationary. 21 million bitcoins will be generated through a halving mining block reward. As on April 2016, 15.3 million bitcoins have been mined and the block reward is 25 bitcoins. All bitcoins have been generated through mining.

Ether is the digital token used in Ethereum. Around 72 million ether were pre-mined and distributed through a crowdfunding sale in exchange for bitcoins to launch Ethereum platform development in 2014. After the Frontier platform went live, Ether are generated as mining block rewards. As on April 2016, there are 78.7 million ether in supply.

Five ether are generated in the form mining reward for new blocks, with five ether per block and uncle blocks are compensated at 7/8th of the block reward or 4.375 ether with a maximum 2 uncles per block which implies a new block confirmation can produce a maximum of 13.75 ether.

Let's just say that this is a lot more complicated than Bitcoin.

Block reward

Currently each block mined creates 5 fresh ETH. Doing the maths, if a block is mined every 14 seconds, and there are 31.5m seconds in a year (365x24x60x60), this means 2.25m blocks are mined per year.
2.25m blocks at 5 ETH per block = 11.3m ETH generated per year. This meets the commitment of less than 18m ETH generated per year.

Uncle reward

Some blocks are mined a little late and don't form part of the main blockchain. In Bitcoin these are called 'orphans' and are entirely discarded, but in Ethereum they are called 'uncles' and can be referenced by later blocks. If uncles are referenced as uncles by a later block, they create about 4.375 ETH for the miner of the uncle (7/8th of the full 5 ETH reward). This is called the uncle reward. Currently around 500 uncles are created per day, adding an additional 2,000 ETH into circulation per day (~0.7m ETH per year at this rate).

This achieves two important things:

It incentivises miners to mine even though there is a high chance of creating a non-mainchain block (the high speed of block creation results in more orphans or uncles. Ethereum's 12 second block rate significantly increases the rate of orphan blocks and forks )
It increases the security of the blockchain by acknowledging the energy spent creating the uncle blocks

Uncle referencing reward

And there's a bit more too: A miner who references an uncle also gets about 0.15 ETH per uncle (maximum 2 uncles).
This is called the GHOST protocol (Greedy Heaviest-Observed Sub-Tree).

4.3 Etherscript

Ethereum's main difference is a turing-complete programming language, sometimes called EtherScript. Contracts live on the blockchain in an Ethereum-specific binary format (Ethereum Virtual Machine [=EVM] bytecode). However, contracts are typically written in some high level language such as solidity and then compiled into byte code to be uploaded on the blockchain.

We will later see the example of a SmartContract written in Solidity but before I would like to introduce Etherscripter available at http://etherscripter.com/. Etherscripter is a Visual Smart Contrat Builder for Ethereum.
It works by providing the user with a Graphical User Interface (GUI) enabling him to drag-and-drop logic elements on a board representing the Smart Contract Code

Let's look at an example. Imagine the following scenario :

One has built a website and someone wants to buy it for $5000 but they can only pay in March.
In the traditional approach, one transfers control of the website and write down what's been agreed on a piece of paper.
March arrives and it seems there has been some confusion.
You assumed the contract meant this March but they insist they meant next March.
Get ready to argue in court about the meaning of "March".

Using Ethereum, you might define the agreement in a form of EtherScript that's readable to both humans and the computer network.
Using Etherscripter, the resulting script would look as follows:

Reading agreements in this form could take some getting used to, but no more than the legalese produced by today's contract lawyers. Fill-in-the-blank scripts would likely become available for common uses. Specialists could craft very custom agreements, as done by lawyers today.
The big advantage here again is that Smart Contract eliminate confusion and remove all uncertainty over whether the other person will follow through. The script both defines and enforces the agreement.

4.4 Hello World in Ethereum

We have seen above a first example of a Smart Contract implemented using Etherscripter. This is interesting for the sake of introducing Smart Contract programming logic. In real life Smart Contract are rather written in one of the Ethereum scripting language, such as Solidity, Serpent or LLL.

We will see here a Hello World program developed using Solidity. Solidity is the prefered language by many Smart Contract developers and IMHO a de-facto standard.
I will present here the greeter program as presented in Ethereum Greeter.

The Greeter is an intelligent digital entity that lives on the blockchain and is able to have conversations with anyone who interacts with it, based on its input.

Here is its code:

The greeter Smart Contract

/* A first abstraction representing a "mortal" entity */
contract mortal {

    /* Define variable owner of the type address*/
    address owner;

    /* this constructor is executed at initialization and sets the owner of the contract
       It is run only when the contract is created. */
    function mortal() { 
        owner = msg.sender; /* msg is an implicit parameter */
    }

    /* Function to recover the funds on the contract */
    function kill() { 

        /* Any "mortal" can be destroyed only by its owner */
        if (msg.sender == owner) {
            selfdestruct(owner); 
        }
    }
}

/* Our greeter "Smart Contract" */
contract greeter is mortal {

    /* define variable greeting of the type string */
    string greeting;

    /* this runs when the contract is executed */
    function greeter(string _greeting) public {
        greeting = _greeting;
    }

    /* main function */
    function greet() constant returns (string) {
        return greeting;
    }
}

One should notice that there are two different contracts in this code: "mortal" and "greeter".
This is because Solidity has inheritance, meaning that one contract can inherit characteristics of another.

The inherited characteristic "mortal" simply means that the greeter contract can be killed by its owner, to clean up the blockchain and recover funds locked into it when the contract is no longer needed. Contracts in ethereum are, by default, immortal and have no owner, meaning that once deployed the author has no special privileges anymore. One should consider this carefully when deploying SmartContracts on the blockchain.

The reader might want to consult the Ethereum Greeter page to discover about how to compile the greeter program using the SolC compiler.

Deploying on the Ethereum blockchain

The deployment and the initialization of a greeter Smart Contract (instance) is performed using the following commands in the geth console:

/* compile greeter source */
var greeterCompiled = web3.eth.compile.solidity(...) 

/* The greeting we will use in our greeter "instance" */
var _greeting = "Hello World!"

/* Define greeter Smart Contract (no instance, just definition) */
var greeterContract = web3.eth.contract (greeterCompiled.greeter.info.abiDefinition);

/* Deploy and instantiate greeter smart contract */
var greeter = greeterContract.new (_greeting, 
        {from : web3.eth.accounts[0], 
         data : greeterCompiled.greeter.code, 
         gas  : 300000
        }, 
        function(e, contract){  /* event listener callback */

    /* If no error occured ... */
    if (!e) {

      if (!contract.address) {
        console.log("Contract transaction send: TransactionHash: " + contract.transactionHash + " waiting to be mined...");

      } else {
        console.log("Contract mined! Address: " + contract.address);
        console.log(contract);
      }

    } else {

        /* If an error occured, log the error */
        console.log(contract);
    }
});

After typing these commands on the geth console, one should wait up to thirty seconds before seeing a message like this:

Contract mined! address: 0xdaa24d02bad7e9d6a80106db164bad9399a0423e

This contract is estimated to need ~180 thousand gas to deploy, at the time of writing, gas on the test net is priced at 20 gwei (equal to 0.00000002 ether) per unit of gas.
Notice that the cost is not paid to the ethereum developers, instead it goes to the Miners, those peers whose computers are working to find new blocks and keep the network secure. Gas price is set by the market of the current supply and demand of computation. If the gas prices are too high, you can become a miner and lower your asking price.

Interacting with the greeter

In order to call the greeter bot, just type the following command in your terminal:

greeter.greet();

Since this call changes nothing on the blockchain, it returns instantly and without any gas cost. You should see it return your greeting:

'Hello World!'

In order for other people to interact with this greeter contract they need two things:

the address where the contract is located and
the ABI (Application Binary Interface) which is a sort of user manual, describing the name of its functions and how to call them to your JavaScript console.

In order to get each of them run these commands:

var ABI = greeterCompiled.greeter.info.abiDefinition;
var Address = greeter.address;

Recover these two variables ABI and Address and send them to whoever wants to interact with the greeter Smart Contract.
Then, on his remote computer, the other user can get access to the greeter using the following commands:

var greeter = eth.contract(ABI).at(Address);

That's it !

Clean-up

Whenever one has fun enough playing with the greeter, one should get rid of it by making it unusable and thus cleaning the blockchain from abandoned live contracts

A transaction will need to be sent to the network and a fee to be paid for the changes made to the blockchain after the code below is run. The self-destruct is subsidized by the network so it will cost much less than a usual transaction.

greeter.kill.sendTransaction({from:eth.accounts[0]})

This can only be triggered by a transaction sent from the contracts owner. You can verify that the deed is done simply seeing if this returns 0:

eth.getCode(greeter.address)

4.5 Further Ethereum Examples

The example above is actually not very relevant since it doesn't make any usage of what Ethereum is finally much more about : exchanging goods and money.
Describing more advanced example exceeds the scope of this article and I will write another article when I come up myself with something relevant in the coming weeks. In the meantime hereunder are 2 examples I think are worth looking at and that make a great job in describing what Ethereum is able to do

Sub-currency example

The following contract will implement the simplest form of a cryptocurrency. It is possible to generate coins out of thin air, but only the person that created the contract will be able to do that (it is trivial to implement a different issuance scheme). Furthermore, anyone can send coins to each other without any need for registering with username and password - all you need is an Ethereum keypair.

See Sub-currency example on solidity

Democracy DAO

The example below creates a first decentralized autonomous organization, or DAO.

Think of the DAO as the constitution of a country, the executive branch of a government or maybe like a robotic manager for an organization. The DAO receives the money that your organization raises, keeps it safe and uses it to fund whatever its members want by voting about it. The robot is incorruptible, will never defraud the bank, never create secret plans, never use the money for anything other than what its constituents voted on. The DAO will never disappear, never run away and cannot be controlled by anyone other than its own citizens.

The token we distributed using the crowdsale is the only citizen document needed. Anyone who holds any token is able to create and vote on proposals. Similar to being a shareholder in a company, the token can be traded on the open market and the vote is proportional to amounts of tokens the voter holds.

See The democracy DAO example

4.6 Private chains in Ethereum

Ethereum software enables a user to set up a "private" or "testnet" Ethereum chain that is separate from the main Ethereum chain. This is useful for testing distributed apps built on Ethereum without having to expose your apps or trials to the real Ethereum network using real Ether. You either pre-generate or mine your own Ether on your private Ethereum chain, so it is a much more cost effective way of trying out Ethereum.

What are the components that tell geth that we want to use/create a private Ethereum chain? The things that dictate a private Ethereum chain are:

Custom Genesis File
Custom Data Directory
Custom NetworkID
(Recommended) Disable Node Discovery

This is actually pretty straightforward and one should simply follow this tutorial

4.7 Ethereum GUI - Graphical User Interface applications

Mist

Mist is the browser for decentralized apps. What Mozilla Firefox or Google Chrome are for the Web 2.0, the Mist Browser will be for the Web 3.0 (which will be decentralized).
Mist is more of a platform running Dapps - for Distributed Applications - where the default applications are the Smart Contracts catalog, the wallet app, etc.

Mist intents to provide the user with an App Store-like User Interface to Smart Contracts:

Mist is available here : https://github.com/ethereum/mist.

meteor-dapp-wallet

The meteor-dapp-wallet GUI is more oriented (for now) towards developers. It provides Ethereum users with a graphical way to deploy Smart Contracts and interact with Smart Contracts or provide all the possible ways to interact with deployed Smart Contracts.
In comparison with Mist above, meteor-dapp-wallet contains kind of like one single dapp which is the wallet application. It is not intended to be a more general use platform such as Mist.

meteor-dapp-wallet is available here : https://github.com/ethereum/meteor-dapp-wallet.

4.8 The DAO and The DAO Attack

The DAO is Code

The DAO was a digital decentralized autonomous organization and a form of something in between an investor-directed venture capital fund and a crowfounding platform.
The DAO had an objective to provide a new decentralized business model for organizing both commercial and non-profit enterprises. It had no conventional management structure or board of directors. The code of the DAO is open-source.

The DAO was stateless, and not tied to any particular nation state. As a result, many questions of how government regulators would deal with a stateless fund were yet to be dealt with.
The DAO itself was crowdfunded via a token sale in May 2016. It set the record for the largest crowdfunding campaign in history.

The DAO was intended to operate as "a hub that disperses funds (currently in Ether, the Ethereum value token) to projects." Investors received voting rights by means of a digital share token; they voted on proposals that are submitted by "contractors" and a group of volunteers called "curators" checked the identity of people submitting proposals and made sure the projects were legal before "whitelisting" them. The profits from the investments will then flow back to its stakeholders.
The DAO did not hold the money of investors; instead, the investors owned DAO tokens that give them rights to vote on potential projects. Anyone could pull out their funds until the time they first vote.
Its reliance on Ether has allowed people to send their money to it from anywhere in the world without providing any identifying information

Since 28 May 2016 the DAO tokens were tradable on various cryptocurrency exchanges.

The DAO Attack

A paper published in May 2016 noted a number of security vulnerabilities associated with The DAO, and recommended that investors in The DAO hold off from directing The DAO to invest in projects until the problems had been resolved.
An Ethereum developer on Github pointed out a flaw relating to "recursive calls" in early June that was picked up and blogged by Peter Vessenes, founder of the Blockchain Foundation on June 9.
By June 14, fixes had been proposed and were awaiting approval by members of The DAO.
On June 16 further attention was called to recursive call vulnerabilities by bloggers affiliated with the IC3.
It's important to note that the vulnerabilities discussed here were not related to the blochchain technology itself, but rather to the specific implementation of The DAO Smart Contract.

On June 17, 2016, The DAO was subjected to a hack that deployed a combination of vulnerabilities, including the one concerning recursive calls, and the hacker gained control of 3.6 million Ether, around a third of the 11.5 million Ether that had been committed to The DAO; the stolen Ether had a value of about $50M at the time of the hack.

The hacked funds were put into an account likely subject to a 28 day holding period under the terms of the Ethereum contract so were probably not actually gone; members of The DAO and the Ethereum community debated what to do next, with some calling the hack a valid but unethical maneuver and others calling for the Ether to be re-appropriated and some calling for The DAO to be shut down

On the 20th July 2016, the Ethereum community decided to hard-fork the Ethereum blockchain to restore virtually all funds to the original contract. This was controversial, and led to a fork in Ethereum, where the original unforked blockchain was maintained as Ethereum Classic, thus breaking Ethereum into two separate active cryptocurrencies.

This fork of the blockchain is a tsunami. It really consisted in "rewriting history" which is precisely what the blockchain should prevent and protect its users from. This causes a lot of interesting questions :

What is better ? A really unbreakable blockchain, making the above fork really impossible but making it also impossible to recover from thief or badly intentioned people exploiting vulnerabilities in a Smart Contract ?
It raises the fact that one of the big challenges of the blockchain technology is governance. I'll get back to this in a next article on this topic

In the fallout of the incident, much was made about how The DAO was "hacked". Upon closer examination though, The DAO was not hacked at all. The attacker(s) used two features of The DAO's specialised code to siphon out ether in amounts small enough to not result in the destruction of their DAO tokens.

Moreover, it is perfectly legitimate to do whatever a smart contract's code permits, even if this is beyond the original intention of those who wrote the code. Like all technologies, "smart contracts" are dual use and might be used in ways that their creators did not intend. The complexity of the technology only compounds this issue.

5. Smart Contracts use cases

I have identified a wide range of applications - ranging from smart health records to pay-as-you-go insurance - that companies are either piloting right now or that are being considered by discussions around the blockchain:

Industry	Use Case	What Smart Contracts can do

Financial Services	Trade Clearing and Settlement	Manage Approval workflows between counterparties, calculate trade settlement amounts, and transfer funds automatically.
	Coupon Payments	Automatically calculate and pay periodic coupon payments and returns principal upon bond expiration.
	Commercial and Retail banking	support mortgage lending, loans and crowdfunding, etc.
	Insurance Claim Processing	Perform error checking, routing, and approval workflows, and calculate payout based on the type of claim and underlying policy
	Micro-insurance	Calculate and transfer micropayments based on usage data from an Internet-of-Things enabled device (example : pay-as-you-go automotive insurance)
	Cyber-insurance	Support insurance for the sharing economy, autonomous object insurances, peer-to-peer insurances, improve fraud prevention, etc.
	Corporate Finance and Funding	Support decentralized venture capital fund that relies on a wisdom-of-the-crowd voting system to make investment decisions.

Life sciences and Health Care	Electronic Medical Records	Provide transfer and/or access to metrical health records upon multi-signature approvals between patients and providers.
	Population Health Data Access	Grant health researchers access to personal health information; micropayments are automatically transferred to the patient for participation.
	Personal health tracking	Track patients' health-related actions through IoT devices and automatically generates reward baseds on specific milestones.

Technology, Media and Telecom	Royalty distribution	Calculate and distribute royalty payments to artists and other associated parties according to contracts.
	Social networks	Decentralizing online communities with a clever rating system, censorship and moderation elimination
	IT Services and Web hosting	Eliminate risk of Denial Of Service attacks by having the site stored everywhere

Energy and resources	Autonomous electric vehicles charging stations	Process a deposit, enable the charging station and return remaining fund when complete .

Gaming	Casinos, online gambling and lotteries	Support provably fair casino style gambling, eliminating cheating and fees.
Gaming	Prediction platforms	combine prediction market and algorithms with power of decentralization to create forcasting tools

Public Sector	Record-keeping / company registry	Update private company share registries and capitalization table records, and distribute shareholder communication.
	Real-Estate / Land registry	Maintain land registry, track changes of ownership, update transactions register
	Person registry	Track civil status of persons, but also marriage contracts and wills, death settlements, etc.

Cross-industry	Supply chain and trade finance documentation	Transfers payments upon (digital) multi-signature approval for letters of credit and issues port payments upon custody changes for bills of lading
	Product Provenance / Ownership and History	Facilitates chain-of-custody processes for products in the supply chain where the party in custody is able to log evidence about the custody. (This is a key use case in so many fields : luxury, gold and diamonds, medical goods, wines, applications, etc.)
	Peer to peer transacting	Match parties and transfer payments automatically for various peer-to-peer applications: lending, insurance, energy, credits, etc.
	Voting	Validate voter criteria, log vote in the blockchain, and initiate specific action as a result of the majority vote. Also applies to elections, in both public or private sectors.
	Person identification	Support trustworthy identification and proof of identity, proving authenticity of actions, reputation management, access management.
	Loyalty programs	support tracking of product or service usage (e.g Airline miles)

6. Issues and challenges

Smart contract technology is still in its early stages. One should track both technology and business developments surrounding smart contracts. On the technology side, certain advances will help broaden the applications and adoption of smart contracts.

Challenges with current blockchain are as follows :

Scalability

Smart contract platforms are still considered unproven in terms of scalability. Think of high frequency trading and the million of transaction on stock exchanges every second, or the hundreds of thousands of facebook updates. If Big Data technologies is at one side of the scale, then blockchain platforms at at the other side, for now.

The community is aware of this problem and is thinking of (more than working of) several approaches such as sharding of computations or off-chain computations.
It remains to be seen whether or not any of these solutions can preserve the key selling points of a public blockchain i.e. its trustful, permissionless and decentralized nature.

Access to real world information

As discussed above, because smart contracts can reference only information on the blockchain, trustworthy data services-known as "oracles" - that can push information to the blockchain will be needed.
Approaches for creating oracles are still emerging. While some initiatives are promising, this is really a new field and where nothing clear and straightforward has emerged now.
In addition, a lot of issues are not clearly addressed. For instance, what happens when things change: what happens if information sources go away, if previously independent sources merge, if new and better sources emerge?

Privacy

The code within smart contracts is visible to all parties within the network, which may not be acceptable for some applications.
For instance, some retailers may not want their deals with their suppliers to be public.

Latency and performance.

Blockchains suffer from high latency, given that time passes for each verified block of transactions to be added to the ledger. For Ethereum this occurs approximately every 17 seconds - a far cry from the milliseconds to which we are accustomed while using non-blockchain databases.
Smart Contracts make things even slower and Ethereum's target of a new block arriving every 12 seconds is quite ambitious and raises the risk of a node drowning under a backlog of work

Permissioning.

While excitement for smart contracts is growing in the realm of both permission-less and permissioned blockchains, the latter is likely to see faster adoption in industry, given that complexities around trust, privacy, and scalability are more easily resolved within a consortium of known parties.

Limits of application

There are often good reasons for optionality. In many contracts, clauses are written into things on purpose to create a channel for arbitration. For example in a flat rental agreement, wear-and-tear from tenants is acceptable, but major damage needs to be repaired. How does code define these things? Force majeure is present in many contracts to allow for wiggle-room for the parties involved. In a smart contract environment, how does one party call that without abusing it or referring to a human arbitrator?
In addition some business may simply not be modeled in a way that would enable it to benefit from Smart Contracts or other blockchains.

Governance

If blockchains are to be sustainable in the long run, serious consideration of appropriate governance mechanisms is needed.

A skewed distribution of mining power and crypto-currency holdings is combined with pseudonymity of account holders and a strong incentive to game the system. This has all the makings for deceptive, unaccountable, fraudulent, and self interested decision making.
Until hard questions around governance of blockchains are asked, and solutions implemented, we should brace ourselves for more incidents like that which has befallen The DAO.

7. Conclusion

This (yet pretty long) article is really just an introduction to Smart Contracts and blockchain 2.0 technologies. There is so much more to say on both Blockchain 2.0 initiatives in general and Ethereum specifically. I guess I'll cover some more aspects following my discoveries when playing with Ethereum or discoveries I make on the technology at large.

What I would like to add for now is that the blockchain technology, despite all the hypes and all the investment in fancy startups around it, still need to mature and the issues I described above are real challenges that need yet to be overcome.

Even if Ethereum is widely discussed nowadays, its only a year and a half old and still in an initial stage. Smart Contracts application are being studied and almost every week a new startup is announcing working on a new use case. But still, proven businesses and wide adoption is still far ahead of us.

Having said that, this technology is a definitely a breakthrough and has an amazing potential. Many technology experts said that its the most disruptive technology they have seen since the apparition of the World Wide Web in the early 90's. And I believe them.

(Again, see first article in this serie : Blockchain explained that provides a pretty complete introduction to the initial bitcoin blockchain technology)

Or see part of this article as a slideshare presentation available here : http://www.slideshare.net/JrmeKehrli/blockchain-20-69472625.

Also, this article is available in PDF format here: https://www.niceideas.ch/blockchain_2.0.pdf.

Ethical hacking : a glimpse on local program vulnerabilities exploitation techniques

Jerome Kehrli — Fri, 7 Oct 2016 18:19:37 -0400

Ethical hacking is a very interesting field, and a pretty funny hobby. Well, ya all penetration tester out there, don't get me wrong: I am well aware that Penetration testing and Ethical Hacking is a full and challenging Software Engineering Field and an actual profession, don't get upset.

I am rather saying that studying vulnerabilities exploitation techniques in one's free time is pretty fun and intellectually rewarding. With the all time and everywhere connection of everything for all kind of usages (understand Internet of Things), current focus in the field of vulnerabilities exploitation is really on Web application, networks, distributed systems, etc.
In addition, most recent progresses in CPU-level protections and compiler-level protections have made local programs exploitation techniques somewhat outdated and such techniques are not very much presented or discussed anymore.

During my master studies, I followed an extended set of lectures on Ethical Hacking and Software Security in general and got quite interested in the field. I wrote a paper for a study in the context of the university at that time which I am reporting today in this blog.
The following article presents various classical vulnerabilities exploitation techniques on local programs.

Summary

1. Ethical hacking methodology

2. A focus on Exploitation

1. Ethical hacking methodology

In regards to ethical hacking, there is some sort of a methodology on which pen testers and ethical hackers commonly agree.

This methodology is as follows:

Information Gathering

This is Fully passive phase.

The goal is to find all possible useful information about the target.
- Company / persons
- DNS / WHOIS / ...
- Search engines, newsgroups, mailing lists
Information mainly collected from public sources
Allows to identify the points that will be most likely vulnerable

Network Mapping

First, as a prerequisites, one might need with the results from the previous step to gather the IP address ranges allocated to the target.

The network mapping consists of building a Foot-Print of the network (i.e. foot-printing :

Finding of live hosts
Port and service scanning
Perimeter network mapping (router, firewalls)
Identification of critical services
OS fingerprinting
Service fingerprinting

=> Simply anything the nmap command can do

Vulnerability Identification

At this stage on tries to answer to

What type of server ?
What OS ?
Wich version of OS ? services ? Patched or vulnerable ?

The goals are :

Identification of vulnerable services (banners)
Vulnerability scan (SecurityFocus, CVE, CERT)
Verification
Enumerate discovered vulns
Estimate probable impact
Identify attack paths and scenarios for exploitation

Penetration / Exploitation

Now it's about attempting to exploit the previously discovered vulnerabilities. The exploit can be searched by whatever means (internet, database, tools such as metasploit, etc.)

Find proof of concept, tool
Development of tools/scripts
Testing of proof of concept
Verify or disprove vulnerabilities
Documentation of findings

Gaining access and Privilege Escalation

Gaining access :

Discovery of username/password combinations
Blank/default passwords
Exploitation of vendor default settings
Discovery of public services that allow for certain operations within the system

Privilege Escalation :

Get administrative rights, if not yet done
Exploitation of a local vulnerability

Further enumeration

This consisis in repeating the previous phases iteratively in order to reach further targets. (for instance from a DMZ to penetrate an internal network)

Obtain encrypted passwords (offline cracking)
Obtain passwords using sniffing or other techniques
Traffic sniffing
Cookies gathering
Internal network mapping

Compromise of remote users/servers

Break other (internal) services and if possible and iterate the process.

Maintaining access

Use of covert channels (protocol tunnels, VPNs, etc.)
Backdoors
Rootkits

Covering tracks

The problem is that the previous steps usually leave lots of traces in the various system logs. One should attempt to get rid of these traces.

Hide files
Clear logs : Check history, Edit log files, Identify remote logging, etc.
Defeat protection mechanisms : Integrity checking, Anti-virus

2. A focus on Exploitation

This article focuses on exploitation of vulnerabilities related to local programs. We will look at various way to exploit local programs vulnerabilities, especially in the C language.

Most of the techniques presented here, thanks to latest progresses in both hardware (processors) and software (compilers), are not so easily exploitable in practice.
The purpose of the following elements is really to present the basic techniques and the key concepts behind them.

3. Introduction to memory manipulation

Memory manipulation attacks consist in sending malformed data to the target application in such a way that the logical program flow is affected.

Goals :

Be able to execute arbitrary code
Crash the application (DoS)

3.1 Runtime Memory Organization

The Memory layout of a running process on x86 is as follows :

Stack
Heap
BSS segment
Data segment
Text segment

**Figure 5.1:** Memory layout

3.1.1 Text Segment

This segment contains all the compiled executable code for the program. It is (Usually) non-writable :

Code does not contain any sort of variables
Read-only segments can be shared between different copies of the program executing simultaneously

3.1.2 Data and BSS Segments

Those segments contain all the global variables.

Read/write/execute rights (at least on Intel)
Data segment contains initialized variables
BSS segment contains un-initialized variables

3.1.3 Stack

The stack is the region of memory used to dynamically store and manipulate most program functions variables (i.e., local variables)

Can (usually) be written, red and executed.
When a program enters a function, space on the stack is provided for variables and data (this space is called a stack frame).

The Stack frame contains :

Function's argument(s)
Stack variables (saved instruction and frame pointers)
Space for local variables

3.1.4 Heap

Programs use the heap to store data that must exist after a function returns (and its stack frame is erased). The heap is often the largest segment of memory.

Allocator and de-allocator algorithms manage the heap :

In C: malloc() / free ()
In C++: new / delete

3.2 Processor Registers (IA32)

eip : instruction pointer
ebp : frame pointer
esp : stack pointer

Blockchain explained

Jerome Kehrli — Thu, 6 Oct 2016 18:01:56 -0400

The blockchain and blockchain related topics are becoming increasingly discussed and studied nowadays. There is not one single day where I don't hear about it, that being on linkedin or elsewhere.
I interested myself deeply in the blockchain topic recently and this is the first article of a coming whole serie around the blockchain.

This article presents an introduction on the blockchain, presents what it is in the light of its initial deployment in the Bitcoin project as well as all technical details and architecture concerns behind it.
We won't focus here on business applications aside from what is required to present the blockchain purpose, more concrete business applications and evolutions will be the topic of another post in the coming days / weeks.

This article presents and explains all the key techniques and mechanisms behind the blockchain technology and is divided in the following sections presented below..

One might want to see part of this article as a slideshare presentation available here: http://www.slideshare.net/JrmeKehrli/the-blockchain-the-technology-behind-bitcoin.

Also, this article is available in PDF format here: https://www.niceideas.ch/blockchain_explained.pdf.

Summary

1. What is the blockchain ?
2. Key problem solved by the blockchain
3. Operation of the blockchain
4. Technical aspects of the blockchain
5. Blockchain 2.0
6. Sum-Up

The blockchain principles and fundamentals are really coming initially from the design work on the Bitcoin. Most of this article focuses on the design and the principle of the blockchain put in place in the Bitcoin system.
Some more recent (Blockchain 2.0) implementations differ slightly while still sharing most genes with the original blockchain, making all that is presented below valid from a conceptual perspective in these other implementations as well.

1. What is the blockchain ?

1.1 Some definitions

Answering this question is somewhat tricky. I will give three definitions that do a pretty good job in answering to this question.

Initial Definition :

The blockchain is the technology running the bitcoin.

The blockchain is a technology that underlies bitcoin - conceived in 2008 and first implemented in 2009 - where it serves as the public ledger for all transactions. The blockchain technology has been conceived by Satoshi Nakamoto a virtual identity which is believed nowadays to belong to a group rather than a single individual.

Wikipedia's definition :

A blockchain is a distributed database that maintains a continuously-growing list of records called blocks secured from tampering and revision.

A blockchain consists of blocks that hold batches of valid transactions. Each block includes the hash of the prior block in the blockchain, linking the two. The linked blocks form a chain.
In addition to a secure hash based history, any blockchain database has a specified algorithm for scoring different versions of the history so that one with a higher value can be selected over others. Peers supporting the database don't have the exact same version of the history at all times, but fall to eventual consistency.

My definition, slightly different from wikipedia's, which underlines what are, from my perspective, the key aspects of the blockchain technology, as opposed to the blockchain data structure on which wikipedia's definition focuses:

The blockchain is a secured protocol enabling peer-to-peer exchanges on a distributed network in a secured, public and non-repudiable way.

I guess these three definitions are very valid and the three of them give some important information. I do however prefer mine (well that's a surprise ...) since it underlines what I believe are the very key aspects of the blockchain.
The blockchain is first and foremost a certification infrastructure which would benefit all applications relying on it.
First the blockchain is more an application protocol than anything else since it consists if individual behaviour specification that eventually lead to a distributed, peer-to-peer, message broadcast-based and secured information database.

1.2 A tiny little bit of history

The blockchain architecture and principles was first designed for bitcoin, as a solution to the problem of making a database both secured and widely distributed.
The block chain is the main innovation of Bitcoin.

As of 2014, "Blockchain 2.0" was a term used in the distributed blockchain database field. Blochchain 2.0 is an evolution of the initial blockchain intent where pretty much only transaction from a sender to a receiver could be stored. In this new paradigm, instead of simple transactions, the exchanges happen around so called "Smart Contracts", actually pretty complete applications implemented in specific scripting languages.

The Economist described one implementation of this second-generation programmable blockchain as coming with "a programming language that allows users to write more sophisticated smart contracts, thus creating invoices that pay themselves when a shipment arrives or share certificates which automatically send their owners dividends if profits reach a certain level."

1.3 Introduction example

Let's imagine the following example which we will be using throughout this article to illustrate the blockchain principles :

Bob is an online buyer who just discovered Sally's online clothes shop. He found a nice suite there and wants to buy it.
Sally is running a little online shop and sells various kinds of clothes. Sally's little shop only accepts paypal transactions.
Bob needs to pay Sally, using paypal, before she sends him the suite .

2. Key problem solved by the blockchain

Banking is a system of intermediaries across the spectrum - ranging from payment networks (e.g Mastercard, Visa etc) to Clearinghouses in Capital Markets to Banks, etc. And the reason these intermediaries exist is to establish trust between two parties who do not know each other.

The Blockchain stands behind every bitcoin ever created by maintaining the proof of ownership.
The innovation is it's openness yet it's security which ensures that the currency is tamper proof.

2.1 Back on the Introduction example.

Recall Bob and Sally's transaction above ?

This is how it happens in practice, with all the intermediates

This usual model suffers from several problems / drawbacks:

The financial system is opaque and lacks transparency and fairness.
All these intermediates are no volunteers. They work for money and get paid for their services. The transaction costs money to both the buyer and the seller. There are interest rates, fees, surcharges, etc. EFTs in Europe can cost 25 euros. Credit transactions can cost several percent of the transaction.
All these exchanges are error prone. Credit card informations are stolen. Banks make mistakes.
An account holder is eventually not even the actual owner of his account. The bank really owns the account. Funds can be garnished, even frozen completely.
Banks and other payment processors like PayPal, Visa, and Mastercard may refuse to process payments for certain legal entities.
Financial exchanges are slow. Checking and low cost wire services take days to complete.

2.2 Centralization and Clearing Houses

A clearing house is a financial institution that provides clearing and settlement services for financial and commodities derivatives and securities transactions. These transactions may be executed on a futures exchange or securities exchange, as well as off-exchange in the over-the-counter (OTC) market.
A clearing house stands between two clearing firms (also known as member firms or clearing participants) and its purpose is to reduce the risk of one (or more) clearing firm failing to honor its trade settlement obligations. A clearing house reduces the settlement risks by netting offsetting transactions between multiple counterparties.

Buyers and sellers use intermediaries because they may not trust the other party, but they trust that the intermediary will assure the transaction is completed faithfully. This is the fundamental role of a clearing house as illustrated below:

The clearing house provides protection to the problems:

How do you ensure some fund will not be spent twice ?
How do you ensure some the transaction sender actually has the funds ?

In addition, the clearing house holds the central transaction ledger.

The problem with these central ledgers, or clearing houses

When one bank sends money to another, no physical currency changes hands. Banks and settlement systems use central electronic ledgers to track assets. But such central ledgers - or clearing houses - can be slow and inefficient, often relying on faxes or manual input.

That not only wastes time but racks up fees. The system is also open to hacking and fraud. These central institutions gets fees to cover such risks of course as well as many other services, bue the price is high and prevents, for instance, micro-paiements who are not able to support the charge asked by these central structures.

2.3 Here comes the blockchain

In contrast to today's networks, distributed ledgers eliminate the need for central authorities to certify ownership and clear transactions. They can be open, verifying anonymous actors in the network, or they can be closed and require actors in the network to be already identified.
The best known existing use for the distributed ledgers is the cryptocurrency bitcoin.

Eliminating the need of the central ledger is precisely the core intent of the blockchain and all protocols put in place there adresse the need of making it public, permanent, distributed and secure.

A distributed ledger (also called shared ledger) is a consensus of replicated, shared, and synchronized digital data geographically spread across multiple sites, countries, and/or institutions.
Every node in the decentralized system has a copy of the blockchain. No centralized "official" copy exists and no user is "trusted" more than any other.

Users of Distributed Ledger Technology (DLT) significantly benefit from the efficiencies and economics by creating a more robust environment for real-time and secure data sharing. Contrary to common belief, the Bitcoin blockchain is not the only distributed ledger, in fact, many other users of Distributed Ledger Technology use different methodologies to achieve the same consensus (e.g. Ripple, MultiChain, HyperLedger Project).
A blockchain is mostly a distributed ledger but not all distributed ledgers are blockchains. Although the term "blockchain" is used more frequently than "distributed ledger" in discussions, a blockchain is only one of the many types of data structures that provide secure and valid achievement of distributed consensus.
The bitcoin blockchain, and similar bockchains, which uses "Proof-of-Work" mining, is the most publicly proven method used to achieve distributed consensus

This leads us to another definition of the blockchain :

A blockchain is a type of distributed ledger, comprised of unchangeable, digitally recorded data in packages called blocks.

3. Operation of the blockchain

3.1 A simplified view of the blockchain

When discussing the Blockchain technology, one is really mentioning the blockchain itself and the network built around it as well as all protocols involved.

All of this can be represented this way, under a simplified form:

Key aspects here are :

The blockchain network is a peer-to-peer network of independent nodes communicating together by message broadcasting.
The key component of the network is the blockchain. Every node has its own copy of the blockchain
A node is not necessarily connected to every other node, but at least some of them.

The blockchain itself is a list of blocks. These digitally recorded "blocks" of data are stored in a linear chain. Each block in the chain contains data (e.g. bitcoin transaction) and is cryptographically hashed.
Each block includes the hash of the prior block in the blockchain, linking the two, ensuring all data in the overall "blockchain" has not been tampered with and remains unchanged.

This has the effect of creating a chain of blocks from the genesis block to the current block. Each block is guaranteed to come after the previous block chronologically because the previous block's hash would otherwise not be known.
Each block is also computationally impractical to modify once it has been in the chain for a while because every block after it would also have to be regenerated.

The linked blocks form a chain.

3.2 The bitcoin blockchain

A block chain is a transaction database shared by all nodes participating in a system based on the Bitcoin protocol. A full copy of a currency's block chain contains every transaction ever executed in the currency. With this information, one can find out how much value belonged to each address at any point in history.

For any block on the chain, there is only one path to the genesis block. Coming from the genesis block, however, there can be forks.
One-block forks are created from time to time when two blocks are created just a few seconds apart. When that happens, generating nodes build onto whichever one of the blocks they received first. Whichever block ends up being included in the next block becomes part of the main chain because that chain is longer.

The block chain is broadcasted to all nodes on the networking using a flood protocol.

3.3 Operation Principle Overview

The intial blockchain, running the bitcoin system, provides distributed, public and secured storage of bitcoin transactions.

The operation principle of is pretty straightforward to understand:

A user wants to pay another user some bitcoins, he broadcasts a transaction to the network.
Miners add the transaction as they receive it to their current block, the one they are currently working on
Randomly, one of the miner may win the lottery and "mine" the block (we'll get back to that)
At that moment, this new "definitive" block is broadcasted to the network and added to everyone's copy of the blockchain

This is illustrated in the following visualization:

3.4 Miners and the "Proof of Work"

In order for a block to be accepted by network participants, miners must complete a proof of work which covers all of the data in the block.
The difficulty of this work is adjusted so as to limit the rate at which new blocks can be generated by the network to one every 10 minutes. Due to the very low probability of successful generation, this makes it unpredictable which worker computer in the network will be able to generate the next block.

The proof of work is a piece of data which is difficult (costly, time-consuming) to produce but easy for others to verify and which satisfies certain requirements. Producing a proof of work can be a random process with low probability so that a lot of trial and error is required on average before a valid proof of work is generated.

Bitcoin uses the Hashcash proof of work system.

For a block to be valid it must hash to a value less than the current target; this means that each block indicates that work has been done generating it. Each block contains the hash of the preceding block, thus each block has a chain of blocks that together contain a large amount of work.
Changing a block (which can only be done by making a new block containing the same predecessor) requires regenerating all successors and redoing the work they contain. This protects the block chain from tampering.

The most widely used proof-of-work scheme is based on SHA-256 and was introduced as a part of Bitcoin.

The mining process works this way:

4. Technical aspects of the blockchain

Initially in the bitcoin system, a block chain is a transaction database shared by all nodes participating in a system based on the Bitcoin protocol.
A full copy of a currency's b(bitcoin) lock chain contains every transaction ever executed in the currency. With this information, one can find out how much value belonged to each address at any point in history.

4.1 The Blockchain Data Structure

The blockchain data structure is an ordered, back-linked list of blocks of transactions. Every block contains a hash of the previous block. This has the effect of creating a chain of blocks from the genesis block to the current block.
Each block is guaranteed to come after the previous block chronologically because the previous block's hash would otherwise not be known.

Each block is also computationally impractical to modify once it has been in the chain for a while because every block after it would also have to be regenerated.

Transaction data is permanently recorded in files called blocks.
They can be thought of as the individual pages of a city recorder's recordbook (where changes to title to real estate are recorded) or a stock transaction ledger. Blocks are organized into a linear sequence over time (also known as the block chain).
New transactions are constantly being processes by miners into new blocks which are added to the end of the chain and can never be changed or removed once accepted by the network.

4.2 A first view on a block structure

Each block contains, among other things, a record of some or all recent transactions, and a reference to the block that came immediately before it. It also contains an answer to a difficult-to-solve mathematical puzzle , the hash or "Proof of Work".

4.3 A miner's life

In the Bitcoin world, transactions are broadcast to the network by the sender, and all peers trying to solve blocks collect the transaction records and add them to the block they are working to solve. This is called Mining.

Mining is the process of adding transaction records to Bitcoin's public ledger of past transactions. This ledger of past transactions is called the block chain as it is a chain of blocks.
The block chain serves to confirm transactions to the rest of the network as having taken place. Bitcoin nodes use the block chain to distinguish legitimate Bitcoin transactions from attempts to re-spend coins that have already been spent elsewhere.

Mining is intentionally designed to be resource-intensive and difficult so that the number of blocks found each day by miners remains steady. Individual blocks must contain a proof of work to be considered valid.
This proof of work is verified by other Bitcoin nodes each time they receive a block. Bitcoin uses the hashcash proof-of-work function.

The primary purpose of mining is to allow Bitcoin nodes to reach a secure, tamper-resistant consensus.

The algorithm

Mining a block is difficult because the SHA-256 hash of a block's header must be lower than or equal to the target in order for the block to be accepted by the network.
This problem can be simplified for explanation purposes: The hash of a block must start with a certain number of zeros. The probability of calculating a hash that starts with many zeros is very low, therefore many attempts must be made.
In order to generate a new hash each round, a nonce is incremented.

Miners implement following (simplified) algorithm :

Note 2016.11.21: I should enhance the above schema to illustrate the fact that when a round trip fails, the hash could not be computed, after incrementing the nounce but before retrying, miners add to the current block they are working on the new transactions that they might have received in the meantime. Thus every round occurs potentially on a slightly different block. This is important because it gives its rationality to using Merkle Trees to compute the hash.
I'll update the schema in the coming days

4.4 Difficulty Adjustment

The difficulty is the measure of how difficult it is to find a new block compared to the easiest it can ever be. It is recalculated every 2016 blocks to a value such that the previous 2016 blocks would have been generated in exactly two weeks had everyone been mining at this difficulty. This will yield, on average, one block every ten minutes.

As more miners join, the rate of block creation will go up. As the rate of block generation goes up, the difficulty rises to compensate which will push the rate of block creation back down.
Any blocks released by malicious miners that do not meet the required difficulty target will simply be rejected by everyone on the network and thus will be worthless.

Again, the difficulty of the mathematical problem is automatically adjusted by the network, such that it targets a goal of solving an average of 6 blocks per hour.
Every 2016 blocks (solved in about two weeks), all Bitcoin clients compare the actual number created with this goal and modify the target by the percentage that it varied.

The network comes to a consensus and automatically increases (or decreases) the difficulty of generating blocks.

4.5 Miner retribution (and bitcoin creation)

Mining is also the mechanism used to introduce Bitcoins into the system: Miners are paid any transaction fees as well as a "subsidy" of newly created coins. This both serves the purpose of disseminating new coins in a decentralized manner as well as motivating people to provide security for the system.
It gives miners incentive to put their computation power at the disposal of the blockchain network.

Because there is a reward of brand new bitcoins for solving each block, every block also contains a record of which Bitcoin addresses or scripts are entitled to receive the reward. This record is known as a generation transaction (or a coinbase transaction) and is always the first transaction appearing in every block.

The number of Bitcoins generated per block starts at 50 and is halved every 210,000 blocks (about four years).

In addition to the generation transaction, Miners get incentive to include transactions in their blocks because of attached transaction fees. A fee (pretty little) is perceived form every transaction in the newly mined block.

4.6 Bitcoin limited supply

In the specific case of the bitcoin, Satoshi had very soon the idea of limiting the bitcoin supply. There is an important reason of course behind this.

In a centralized economy, currency is issued by a central bank at a rate that is supposed to match the growth of the amount of goods that are exchanged so that these goods can be traded with stable prices. The monetary base is controlled by a central bank. In the United States, the Fed increases the monetary base by issuing currency, increasing the amount banks have on reserve, and more recently, printing money electronically in a process called Quantitative Easing.

In a fully decentralized monetary system, there is no central authority that regulates the monetary base. Instead, currency is created by the nodes of a peer-to-peer network. The Bitcoin generation algorithm defines, in advance, how currency will be created and at what rate. Any currency that is generated by a malicious user that does not follow the rules will be rejected by the network and thus is worthless.

Bitcoins are created each time a user discovers a new block. The rate of block creation is adjusted every 2016 blocks to aim for a constant two week adjustment period (equivalent to 6 per hour.) The number of bitcoins generated per block is set to decrease geometrically, with a 50% reduction every 210,000 blocks, or approximately four years.
The result is that the number of bitcoins in existence is not expected to exceed 21 million.

Speculated justifications for the unintuitive value "21 million" are that it matches a 4-year reward halving schedule; or the ultimate total number of Satoshis that will be mined is close to the maximum capacity of a 64-bit floating point number. Satoshi has never really justified or explained many of these constants.

The formula is the following :

This decreasing-supply algorithm was chosen because it approximates the rate at which commodities like gold are mined. Users who use their computers to perform calculations to try and discover a block are thus called Miners.

4.7 Wallet cryptography

A wallet is basically the Bitcoin equivalent of a bank account. It allows you to receive bitcoins, store them, and then send them to others.

The name "Bitcoin wallet" is a bit of a misnomer. Bitcoin wallets don't hold actual Bitcoins, those are essentially stored on the blockchain.
Instead, Bitcoin wallets hold the private keys that give users the right to use those coins. Each Bitcoin wallet comes with at least two keys (multisig wallets can have more) one public, and one private.

The public key lets any Bitcoin user send a sum of Bitcoins directly to any other Bitcoin user, without a middle man. The private key must be kept as secure as possible, since anyone who gets a hold of it has access to every Bitcoin associated with it.

There are several types of wallets out there: Software wallets, web wallets, and paper/cold wallets.

There is a relationship between Wallet and Bitcoin adresses.

Bitcoin address

A Bitcoin address, or simply address, is an identifier of 26-35 alphanumeric characters, beginning with the number 1 or 3, that represents a possible destination for a bitcoin payment. Addresses can be generated at no cost by any user of Bitcoin.

There are currently two address formats in common use:

Common P2PKH which begin with the number 1, eg: 1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2.
Newer P2SH type starting with the number 3, eg: 3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy.

A Bitcoin address is a single-use token. Like e-mail addresses, you can send bitcoins to a person by sending bitcoins to one of their addresses. However, unlike e-mail addresses, people have many different Bitcoin addresses and a unique address should be used for each transaction.

A Bitcoin address is a 160-bit hash of the public portion of a public/private ECDSA keypair. Using public-key cryptography, one can "sign" data with your private key and anyone who knows your public key can verify that the signature is valid.

The private key aims at enabling solely and only the owner of an address to create a transaction where the sender of bitcoin is that owner. Keeping this private key secrete is of utmost importance. If someone steals that private key from a wallet owner, he can drag all its money out by creating transaction from that wallet to his own wallet in a perfectly legitimate way.
It's impossible for an attacker to forge a fraudulent transaction from someone else's wallet without having that very private key.
On the other hand, every miner, every network member can safely and fast ensure the validity of the transactions in a block by using the public key of the corresponding wallet owners.

4.8 Merkle Trees

A tree constructed by hashing paired data (the leaves), then pairing and hashing the results until a single hash remains, the merkle root.
The construction of the Merke tree is such that if any single leaf transaction is changed, all hashes along the branch would be changed and ultimately the merkle root as well.
This is a key property ensuring security of the blockchain.

Merkle trees in bitcoin use a double SHA-256, the SHA-256 hash of the SHA-256 hash of something.

If, when forming a row in the tree (other than the root of the tree), it would have an odd number of elements, the final double-hash is duplicated to ensure that the row has an even number of hashes.

First form the bottom row of the tree with the ordered double-SHA-256 hashes of the byte streams of the transactions in the block.
Then the row above it consists of half that number of hashes. Each entry is the double-SHA-256 of the 64-byte concatenation of the corresponding two hashes below it in the tree.

This procedure repeats recursively until we reach a row consisting of just a single double-hash. This is the Merkle root of the tree.

In the blockchain, Merke trees enables to verify a transaction in a much faster way than if a validating a transaction meant recomputing the hash from the whole block data.
In addition, as new transactions are broadcasted to the network, updating the merkle root takes only log(n) hash operations on small data instead of re-hashing everything.

Why is the usage of Merkle Tree of so important ?

Think of one thing : the system makes it so that a new block is created every 10 minutes or so. During these 10 minutes, new transactions are taken into consideration immediately by miners. At each and every round, not only the nounce is incremented but the very latest transactions received are added to the block currently being mined.
Without Merkle trees, that would require miners to recompute completely the hash of the entire block, which can be quite a significant amount of work.
Again, with Merkle trees, the number of operations to be computed is log (n) where n is the amount of transactions in the block, i.e. only a few operations to recompute all the hashes along the branches of the new transactions.

This is pretty important in addition because of the increasing adoption of bitcoin. Since block creation rates is somewhat fixed, the average amount of transactions per block increases making it even more important to avoid recomputing the hash of the full block as transactions are added to it.

4.9 Peer to peer network

A blockchain is a ledger of facts, replicated across several computers assembled in a peer-to-peer network that operates on a cryptographic protocol. In the case of the bitcoin, users send units of currency, by broadcasting digitally signed messages to the network using bitcoin wallet software.
In the case of more advanced and recent blockchain technologies - called blockchain 2.0 - (such as Ethereum), users broadcasts Smart Contracts, events or API calls on these Smart Contracts.

Members of the network are anonymous individuals called nodes, or "miners" since initially most-if-not-all of them where running the mining algorithm presented above.

Both new transactions and newly mined blocked are broadcasted to the peer-to-peer network.

4.10 Orphaned, Extinct and Staled Blocks

Because each block contains a reference to the prior block, the collection of all blocks in existence can be said to form a chain. However, it's possible for the chain to have temporary splits - for example, if two miners arrive at two different valid solutions for the same block at the same time, unbeknownst to one another.
The peer-to-peer network is designed to resolve these splits within a short period of time, so that only one branch of the chain survives.

The client accepts the longest chain of blocks as valid. The "length" of the entire block chain refers to the chain with the most combined difficulty, not the one with the most blocks. This prevents someone from forking the chain and creating a large number of low-difficulty blocks, and having it accepted by the network as "longest".

5. Blockchain 2.0

The Blockchain 2.0 is an evolution of the blockchain protocol enabling not only to exchange transaction but rather code and programs in the form of Smart Contracts
Now developers are allowed to build programs and API's on the Blockchain Protocol.

This relatively new concept involves the development of programs that can be entrusted with money.
Smart contracts are programs that encode certain conditions and outcomes.
For instance, When a transaction between 2 parties occurs, the program can verify if the product/service has been sent by the supplier. Only after verification is the sum transmitted to the suppliers account.

Apart from Financial transactions, smart contracts are now entering a whole lot of different industry.
For instance in the Legal System, companies like Empowered Law use the public distributed ledger of transactions that makes up the Block Chain to provide Multi-Signature account services for asset protection, estate planning, dispute resolution, leasing and corporate governance.

Ethereum

Ethereum intends to bring together both a crypto ledger and a Turing-complete programming language, which is a language can be used to write actual computer programs. They intend to make a browser that is a Swiss-army knife of Block Chain and encryption tools that allow non-technical users to truly leverage the web.

Ethereum aims to implement a globally decentralized, un-ownable, digital computer for executing peer-to-peer contracts.
Put more simply, Ethereum is a world computer you can't shut down.

The Blockchain 2.0 and its opportunities will be the topic of a dedicated article expected in the coming weeks on this very blog

6. Sum-Up

Summing it up, these are the key aspects of the Blockchain technology:

The Blockchain is an amazing technology. I strongly believe it has the potential to revolution a whole lot of different industries. That as well will be the topic of a third article on the Blockchain on this blog that should appear in the coming days / weeks.

One might want to see part of this article as a slideshare presentation available here : http://www.slideshare.net/JrmeKehrli/the-blockchain-the-technology-behind-bitcoin.

Also, have a look at the next article in this serie on this blog : Blockchain 2.0 - From bitcoin transaction to Smart Contract applications

Finally, this article is available in PDF format here: https://www.niceideas.ch/blockchain_explained.pdf.

The Blockchain ...

Jerome Kehrli — Wed, 5 Oct 2016 11:17:35 -0400

The blockchain and blockchain related topics are becoming increasingly discussed and studied. There is not one single day where I don't hear about it, that being on linkedin or elsewhere.

I kept myself busy on other topics these last years, mostly large scale information systems and analytic systems architecture in the finance business so I really missed the Bitcoin and blockchain hype.
I've been to an OCTO Technology event recently on the Blockchain. To be honest I went there more for the pleasure of seeing my former colleagues than for any specific interest on the topic. Yet I listen carefully to OCTO's presentation ... and I didn't imagine I would be so much intrigued and soon passionated by the subject.

I strongly believe the blockchain technology has the potential to be one of the most disruptive progress in computer sciences of these 10 last years. I studied and keep studying all the technical details, evolutions and business implications of this technology and will post various blog articles in the coming days / weeks about this topic:

First article is : Blockchain explained. I am giving a clear explanation of all the technical nuts and bolts behind the blockchain technologies.
Second is : Blockchain 2.0 - from bitcoin transactions to blockchain applications
Third one will be : Blockchain - various business opportunities where I will discuss how the blockchain can (and will) disrupt several fields.

Sudoku Laboratoy

Jerome Kehrli — Tue, 30 Aug 2016 03:02:26 -0400

I have written a little Sudoku program for which I provide here the source code and Windows pre-built executables. Current version is Sudoku 0.2-beta.

It supports the following features:

A GUI to display and manipulate a Sudoku board
A Sudoku generator
A Sudoku solver
A Sudoku solving tutorial (quite limited at the moment)

At the moment there are two resolution methods supported, one using human-like resolution techniques and a second using backtracking. The resolution of a solvable Sudoku board takes a few milliseconds only.
A solvable Sudoku board is a Sudoku board than has one and only one solution.

The Sudoku board generator generates solvable Sudoku boards. It usually generates boards between 18 and 22 pre-filled cells. (which is quite better than most generators I could find online).
Currently it generates the best (i.e. most difficult) board it possibly can provided the random initial situation (with all cells filled) of the board.
The problem I'm facing in this current version is that it can take from a few seconds only up to several minutes to generate the board (this is discussed in the algorithms section below).
In addition, the difficulty of the resulting board is not tweakable at the moment. In some cases it generates an extremely difficult board (only solvable with nishio) in a few seconds while some other times it needs two minutes to generate an easy board.

The software is written in C++ on Linux with the help of the wxWidgets GUI library.
It is cross-platform to the extent of the wxWidgets library, i.e. it can be compiled on Windows, OS X, BSD, etc.

A makefile is provided to build it, no configure scripts, i.e. you need to adapt the makefile to your own Linux distribution (or on Windows Mingw, TDM, etc.).
Happily only few adaptations should be required.

I provide pre-built Windows binaries here Sudoku_0.4_Windows_binary.zip.

For all other platforms, the source code is available here sudoku-src-v0.4.tar.gz.

1. User Manual

The software presents a sudoku grid centered in its window.
The buttons on the bottom of the GUI have the following functions:

Generate : generate a new random Sudoku board.
Launch ... : launch the Sudoku solving tutorial.
Solve : solve the Sudoku board using human-like heuristics.
Solve BT : solve the Sudoku board using backtracking.
Load Grid : load a previously saved grid.
Save Grid : save the current grid.
Reset : reset grid as initially created / generated.
Clean : clean the grid completely (empty grid).

The user can click on a cell to give its value or set the possibilities for the cell:

A number given alone will set the value for the cell.
Several numbers separated by a space will set the possibilities for the cell.

When launching the Sudoku solving tutorial, the Sudoku is solved cell after cell following the human-like solving algorithm presented below.
The values in the cell are displayed in different colors depending on the way the value has been computed:

Dark blue : the value was the single possibility for the cell.
Cyan : the value needed to be guessed (Nishio approach) during the resolution process.
Green : the value of the cell was obtained with advanced possibilities reduction approaches.
Red : the value needed to be guessed by trying one of the possibilities and solving the board further.
This happens solely when the board is not solvable as it has been given and several solutions exist for it.
The color of a guessed cell is initially red and it turns cyan once the solution is confirmed.

2. Building the software from sources

2.1 On Linux

First install wxWidgets 3.0.x and wxWidgets 3.0.x development files using your system package manager

Then you need to adapt the Sudoku makefile system to your setup.

Adapt file sudoku/[Debug/Release]/objects.mk : give correct libraries names matching your wxWidgets build
Adapt file sudoku/[Debug/Release]/makefile : give correct path of your wxWidgets libraries
Adapt file sudoku/[Debug/Release]/subdir.mk : give correct path of your wxWidgets headers

(Note : [Debug/Release] means either "Release" or "Debug")

You can then make the software using

$ cd sudoku/[Debug/Release]
$ make clean && make

2.1 On Windows

Building on windows is slightly more complicated since one needs both mingw and wxWidgets.

A dedicated how-to is available in file sudoku/Win32/HOWTO.txt

3. Algorithms

Sudoku solving and generation form an interesting set of problems in the field of algorithmic. I am presenting here the big picture of the algorithms as they are implemented in my Sudoku program as pseudo-code.

3 different algorithms are implemented for now :

3.1 Human-like methods solver : more a tutorial that attempts to mimic the human approach when solving a sudoku
3.3 Backtracking solver : a purely algorithmical approach using simple backtracking (nothing smart here)
3.3 Board generator : the algorithm used to generate a feasible board,

The board generation algorithm is where I have most issues for now. I am able to generate hard to very hard boards ... but it takes SOOOOO much time (up to several minutes for hardest grids).
My algorithm is pretty naive for now and I assume there are some more robust approaches to generate Sudoku grids ... Any suggestion would be welcome :-)

3.1 Human-like methods solver

The Human-like methods solver implements a subset of the usual Sudoku solving techniques that are usable by a human being.

The pseudo-code is as follows:

procedure solveSinglePossibilities
    for each cell of the board do
        if cell has no value set then
            for each possible value (1..9) do
                if value is single possibility according to row, column or square then
                    set value on cell
                end if
                check whether any other value is possible 
                        by checking each with row, column and square
                if no other value is possible then
                    set value on cell
                end if
            end for
        end if
    end for
end procedure  

procedure solvePossiblities
    for each row, column and square of the board do
        for each cell of the row, column or square do
            if there are n other cells that have the same n possibilities (or fewer) then
                discard these possibilities from all other cells
            end if
        end for
    end for
end procedure  

procedure solveSquarePossiblities
    for each row, column and square of the board do
        for each cell of the row, column or square do
            if there are n other cells that have the same n possibilities (or fewer) then
                for each number of these possibilities do
                    if all cells containing number are in same square
                        discard number from all other cells of square 
                    end if
                end for    
            end if
        end for
    end for
end procedure 

procedure solvePossibleCells
    for each cell of the board do
        reset all possibilities
    end for
    
    while changes are made on cells by the calls below do
    
        -- this sets the cells for which a single value
        -- is the only possibility
        call solveSinglePossibilities                
                                                     
        -- Compute cell possibilities 
        for each cell of the board do
            for each possible value (1..9) do
                if value is possible according to row, column or square then
                    add value to cell possibilities
                end if
            end for    
        end for           
        
        while changes are made on cell possibilities by the calls below do            
        
            -- in each element (row, column, square) identify group   
            -- of possibilities and discard them from the other cells
            call solvePossiblities                   
            
            -- if all possibilities of a value in a row or in a column   
            -- are in same square, value can be discarded from other
            -- cells in square.
            call solveSquarePossiblities
        end while
        
        for each cell of the board do
            if cell has only one possibility left then
                set value as that single possibility
            end if
        end for           
        
    end while    
end procedure  

procedure solveUsingGuess  
    set = any one of the remaining cells with fewest possibilities
    while such a cell is found do
    
        -- Make a guess for this cell   
        set cell value = any one if its possibilities       
        
        -- Try to solve using that guess 
        call solvePossibleCells                        

        -- If the call above made sure the board cannot be           
        -- solved using that guess   
        if board is unsolvable then                    
            reset cell value                        
        else if board is solved then 
            -- Fix guess   
            fix cell value -- set cell value definitely
        else
            call solveUsingGuess recursively
        end if
    end while
end procedure  

procedure solve
    -- solve using human-like techniques
    call solvePossibleCells   
    -- if grid is not completed, make guesses (nishio)
    call solveUsingGuess                 
    -- with these guesses, solve the remaining cells
    call solvePossibleCells              
end procedure

3.2 Backtracking solver

Unlike the previous one, which finds one solution, the backtracking solver find all solutions of the Sudoku board.
It is an essential piece of the board generation algorithm since it is used to ensure the generated board has one and only one solution.

The backtracking solver uses the method solvePossibleCells from the previous algorithm to speed up the resolution of each branch of solutions.

The pseudo-code is as follows:

procedure findSolutionsInternal
    if current board is solved then
        add a copy of current board to solutions
    end if
    
    set cell = any remaining cell without a value
    
    for each possibility for that cell do
        set cell value = that possibility 
        call findSolutionsInternal recursively
        reset cell value
    end for
end procedure  

procedure findSolutions
    set solutions = instantiate set of solution to be returned
    
    -- set cell values that can be set with human-like approach
    call solvePossibleCells                                        
    
    -- solve remaining cells with backtracking
    call findSolutionsInternal with solutions and current board    
    return solutions
end procedure

3.3 Board generator

The board generation algorithm is the trickiest part. I tried several things (most methods supporting them are still available in the codebase) ... and got rid of most of them.
The thing is that either I generate only easy boards with down to 22 pre-filled cells in a few milliseconds, or I try to generate difficult boards having only between 18 to 22 pre-filled cells. (I have never successfully generated a board with only 17 pre-filled values even though such boards exist).

In the later case, the duration of the algorithm runs from a few seconds up to several minutes with the following results, in average out of 10 runs:

Only 1 really difficult board requiring very advanced resolution techniques or even nishio.
Between 1 and 2 medium to tricky grids requiring a thorough work on possibilities to solve them.
Between 7 and 8 easy to medium grids requiring only a careful analysis of possibilities for each cell.

I haven't found a way yet to come up with a smarter approach enabling the software to generate more difficult boards and, more importantly, in a quicker time.

Anyway, this is what I have implemented currently, in pseudo-code:

procedure newRandomGrid
    set grid = DEFAULT_GRID -- always starting with the same
    
    perform random permutations between rows in same square groups
    perform random permutations between columns in same square groups
    
    perform random permutations between groups of rows matching squares
    perform random permutations between groups of columns matching squares
    
    -- Map every value to a new random value and swap these values
    -- for every cell
    remap values
    
    return grid    
end procedure

procedure performPossibleRemoves
    for each cell of the grid board having a value do
        set savedValue = value in that cell
        reset cell value
        if grid board is not solvable then-- Using backtracking solver
            set cell value = savedValue
        end if
    end for
    return number of additional cells than could be removed
end procedure

procedure removeValues
    set grid = copy of original given as argument
    
    for each cell of the grid board do
        reset all values
    end for
    
    -- Add a value back for each number
    for each possible value (1..9) then
        pick up randomly one cell of original board containing value
        assign value to corresponding cell in grid board
    end for
    
    -- Add more values until board is solvable
    while grid board is not solvable do -- Using backtracking solver
    
        -- This is key in the process. We add values back to the empty grid by choosing
        -- first the cells of grid board with highest number of possibilities
        set cell = pick up randomly one of most undefined cells
        assign value from corresponding cell in original board
    end while
    
    -- See if there is any more values than can be removed
    call performPossibleRemoves
    
end procedure

-- This is the one that takes a huge amount of time
procedure tryReaddingValues
    set betterFound = true
    while betterFound do
        set betterFound = false
        for each cell of the grid board without a value do
            set cell value = back to former value -- former value is cell from original grid
            
            call performPossibleRemoves
            
            if more than two values could be removed then
                set betterFound = true
                break
            else
                reset cell value
            end if
            
        end for        
    end while
end procedure

procedure generateGrid
    -- Create new random solved grid
    set original = call newRandomGrid   
    
    -- Remove cell values as long as board remains solvable
    set grid = call removeValues with original
    
    -- see if adding back a value enables to remove more
    -- Note: this is the very slow step. One can simply get rid of it
    -- to get a quick but less efficient (i.e. easier boards) generator 
    call tryReaddingValues with grid
    
    return grid
end procedure

Regarding this algorithm, I'm slowly getting out of ideas for new techniques to experiment that would enable the software to generate a difficult grid in far less time.
Again, Any idea / suggestion would be really welcome :-)

Data Management

Jerome Kehrli — Thu, 7 Aug 2014 10:22:11 -0400

Data management comprises all the disciplines related to managing data as a valuable resource.
Data Management is the development and execution of architectures, policies, practices and procedures that properly manage the full data lifecycle needs of an enterprise.

During my MS studies, I followed two interesting lectures related to Data Management.

Introduction to Data Mining (Summary)
Introduction to Information Retrieval (Summary)

Data Mining is the computational process of discovering patterns in large data sets involving methods at the intersection of artificial intelligence, machine learning, statistics, and database systems. In the context of Data Mining, Data Warehouses (DW) form an important aspect. Data Warehouses generalize and consolidate data in multidimensional space. The construction of DW is an important pre-processing step for data mining involving data cleaning, data integration, data transformation.
I have summarized all the notes I have taken during the Introduction to Data Mining lecture as well as some of my solutions to the exercises within the following document : Summary of the Data Mining Lecture.

Information retrieval (IR) is finding material (usually documents) of an unstructured nature (usually text) that satisfies an information need from within a large collections (usually stored on computers). Information Retrieval is a field concerned with the structure, analysis, organisation, storage, searching and retrieval of information.
Here as well I have summarized the notes taken during the lecture within the following document : Summary of the Information Retrieval Lecture.

100 hard software engineering interview questions

Jerome Kehrli — Fri, 6 Dec 2013 10:11:41 -0500

For some reasons that I'd rather keep private, I got interested in the kind of questions google, microsoft, amazon and other tech companies are asking to candidate during the recruitment process. Most of these questions are oriented towards algorithmics or mathematics. Some other are logic questions or puzzles the candidate is expected to be able to solve in a dozen of minutes in front of the interviewer.

If found various sites online providing lists of typical interview questions. Other sites are discussing topics like "the ten toughest questions asked by google" or by microsoft, etc.
Then I wondered how many of them I could answer on my own without help. The truth is that while I can answer most of these questions by myself, I still needed help for almost as much as half of them.

Anyway, I have collected my answers to a hundred of these questions below.
For the questions for which I needed some help to build an answer, I clearly indicate the source where I found it.

1. You are given a the source to a application which is crashing when run. After running it 10 times in a debugger, you find it never crashes in the same place. The application is single threaded, and uses only the C standard library. What programming errors could be causing this crash? How would you test each one?

2. You have a stream of infinite queries (ie: real time Google search queries that people are entering). Describe how you would go about finding a good estimate of 1000 samples from this never ending set of data and then write code for it.

Reservoir sampling is a family of randomized algorithms for randomly choosing k samples from a list S containing n items, where n is either a very large or unknown number. Typically n is large enough that the list doesn't fit into main memory.

This simple O(n) algorithm as described in the Dictionary of Algorithms and Data Structures consists of the following steps (assuming that the arrays are one-based, and that the number of items to select, k, is smaller than the size of the source array, S):

array R[k];     // result
integer i, j;

// fill the reservoir array
for each i in 1 to k do
     R[i] := S[i]
done;

// replace elements with gradually decreasing probability
for each i in k+1 to length(S) do
     j := random(1, i);    // important: inclusive range
     if j <= k then
          R[j] := S[i]
     fi
done

Reservoir sampling is and often disguised problem in Google interviews:

There is a linked list of numbers of length N. N is very large and you don't know N. You have to write a function that will return k random numbers from the list. Numbers should be completely random. Hint: 1. Use random function rand() (returns a number between 0 and 1) and irand() (return either 0 or 1) 2. It should be done in O(n).

And here's some C/C++ code:

typedef struct list {int val; list* next;} list;

void select(list* l, int* v, int n) {
  int k = 0;
  while (l != NULL) {
     if (k < n) {
        v[k] = l->val;
     } else {
        int c = rand() * (k + 1);
        if (c < n) v[c] = l->val;
     }
     l = l->next;
     k++;
  }
}

In the case of both questions above, since N is not known, we need to use a streaming principle instead of a loop.

Hence the following pseudo-code:

// constant k is given
integer k = ...;

array R[k];     // result
integer i = 0;
integer N = 0;

procedure processNewListElement (element)
    N := N + 1 // N is unknown in advance, counting it myself
    i := i + 1
    
    if i <= k then
        R[i] := element // initialization
    else
        j := random(1, i);    // important: inclusive range
        if j <= k then
            R[j] := element
        fi
    fi
end proc

3. Given a large network of computers, each keeping log files of visited urls, find the top ten of the most visited urls.
(i.e. have many large <string (url) -> int (visits)> maps, calculate implicitly <string (url) -> int (sum of visits among all distributed maps)>, and get the top ten in the combined map)
The result list must be exact, and the maps are too large to transmit over the network (especially sending all of them to a central server or using MapReduce directly, is not allowed)

Intiuitive idea :

Let's use a distributed algorithm running this way

Hypothesis:

- Arrange every server logically by givien them numbers unique numbers from 1 to n with no holes

we can imagine a distributed algorithm running this way:

- Each node initializes a new consolidated <string (url) -> int (sum of visits among all distributed maps)> map
- Each node computes its ten most visited URLs and put them in its consolidated map
- For i in 2 to n (= number of server) times
     - Node [i - 1]  communicates its ten most visited URLs from its consolidated map along with their visit 
	   counter to node n
     - At the same time, Node [i] receives from its right neihbour its set of ten most visited URL
     - Node [i] computes from this new set of ten URLS it has just received and its own set, the new set of ten 
	   most visited URLs and merges the resultin its consolidated map
- Node [n] now holds the answer

We end up in a O(mn) algorithm

One should not that the algorithm can be significantly optimized by having several nodes working at the same time instead of just one at a time as above.
For instance, we can imagine parallelizing the work following a rule of 2. And end up with the following example for n=20

Step 1 using t=2 : 1 -> 2  3 -> 4  5 -> 6  7 -> 8  9 ->10 11->12 13->14 15->16 17->18 19->20
Step 2 using t=4 : 2 -> 4  6 -> 8  10->12  14->16  18->20 
Step 3 using t=8 : 4 -> 8  12->16  
Step 3 using t=16: 8 ->16
Step 4 (last)     : 16->20

This concerptually the same as putting all co mputers in a B-Tree and have at iteratrion 1 the lowest leaf communicates theur results to the higher node, then up and up again at each iteration until the root node has the result.

Ending up this time in O(m log n)

This works if the servers are not clusters load balancing the same application. If every server has a different set of URLs, the the global top ten is amongst the top ten of each invidual servers.
If, on the other hand, several servers serve the same URLS, the global top ten may be consolidated froms URLs not listed in the individual top ten of each server.

Distributed sorting

Another possibility, likely to perform better, is first sporting the data and then taking the top 10 results.

See http://dehn.slu.edu/courses/spring09/493/handouts/sorting.pdf

4. Merge two sorted linked lists
When you merge two "linked" lists, there tend to be problems with "conflicts" between the lists (because they have a specific order to them and you are messing with the order).

5. Given a set of intervals (time in seconds) find the set of intervals that overlap

Given a list of intervals, ([x1,y1],[x2,y2],...), what is the most efficient way to find all such intervals that overlap with [x,y]?

It depends:

1. If the question is to be answered only once for one single interval, then we're better of with a one time (O(n)) run through all intervals and return the set of intervals that respect

xStart < yEnd and xEnd > yStart

2. On the other hand, if the question should be answered again and again, we're better of with a complexe data structure :

2.a Using an "interval tree"

In computer science, an interval tree is an ordered tree data structure to hold intervals.
Specifically, it allows one to efficiently find all intervals that overlap with any given interval or point. It is often used for windowing queries, for instance, to find all roads on a computerized map inside a rectangular viewport, or to find all visible elements inside a three-dimensional scene.

Construction

Given a set of n intervals on the number line, we want to construct a data structure so that we can efficiently retrieve all intervals overlapping another interval or point.

We start by taking the entire range of all the intervals and dividing it in half at x_center (in practice, x_center should be picked to keep the tree relatively balanced).
This gives three sets of intervals, those completely to the left of x_center which we'll call S_left, those completely to the right of x_center which we'll call S_right, and those overlapping x_center which we'll call S_center.

The intervals in S_left and S_right are recursively divided in the same manner until there are no intervals left.

The intervals in S_center that overlap the center point are stored in a separate data structure linked to the node in the interval tree. This data structure consists of two lists, one containing all the intervals sorted by their beginning points, and another containing all the intervals sorted by their ending points.

The result is a binary tree with each node storing:

A center point
A pointer to another node containing all intervals completely to the left of the center point
A pointer to another node containing all intervals completely to the right of the center point
All intervals overlapping the center point sorted by their beginning point
All intervals overlapping the center point sorted by their ending point

Construction requires O(n log n) time, and storage requires O(n + log n) = O(n) space.

Example for following intervals:

                     c=     
a=[1..............6][78][9..10]=g
b=[1...2][3...4][5....8][9....11]=h                    
          d=     e=  [8..9][1011]=i
                     f=

Gives us this tree:

 
                                 Nr (6)
                                 <[a,e]
                                 >[e,a]
                             /             \
                          /                  \
                      Nl1 (3)             Nl2 (9)
                      <[d]                <[f,g,h]
                      >[d]                >[g,h,f]
                 /                     /             \
              /                     /                    \
         Nl3 (2)                Nl4 (8)                Nl4 (11)
         <[b]                   <[c]                   <[i] 
         >[b]                   >[c]                   >[i]

Given the data structure constructed above, we receive queries consisting of ranges or points, and return all the ranges in the original set overlapping this input.

a) Intersecting with an interval

We have now a simpe and recursive method. We start at each node (root initially) :

If the value is contained in the interval, add all stored intervals to result list
- recursively call left
- recursively call right
ELSE if the value is not contained in the interval but before the interval start
- search end point list for intervals ending after searched interval starts and add them to result list
- recursively call right
ELSE if the value is not contained in the interval but after the interval ends
- search start point list for intervals starting before searched interval ends and add them to result list
- recursively call left

We end up with the set of overlaping intervals.

In average O(log n), O(n) in the worst case.

b) interseting with a point

Almost the same algorithm applies for a search with a point:

if the value is before the searched value
- search end point list for intervals ending after searched value and add them to result list
- recursively call right
ELSE if the value is after the searched value
- search start point list for intervals starting before searched value and add them to result list
- recursively call left

Source on wikipedia : http://en.wikipedia.org/wiki/Interval_tree
and http://en.wikipedia.org/wiki/Segment_tree

6. If we had a list of n nodes, what are the maximum number of edges there can be for a directed acyclic graph?
You have to draw lines between nodes, but never have a clear path of returning to the original node regardless of where you're starting.

If you look at a graph of size 1, it's 0.
2, it's 1.
3, it's 3 (a -> b, a ->c, b ->c)
4, it's 6 (a -> b, a -> c, a ->d, b->c, b->d, c->d)

If you notice, the first node points to all of the other nodes except itself, the next node points to all the other nodes except the first node and itself, and this keeps decreasing by one, so you get (n-1) + (n-2) + ... + 2 + 1

Knowing that the sum of all number from 0 to n = (n x (n+1))/2, this is the sum of 1 to n-1, which is (n x (n-1))/2.

7. What's the difference between finally, final and finalize in Java?

8. Remove duplicate lines from a large text

9. Given a string, find the minimum window containing a given set of characters

Let's use S = 'acbbaca' and T = 'aba'. The idea is mainly based on the help of two pointers (begin and end position of the window) and two tables (needToFind and hasFound) while traversing S. needToFind stores the total count of a character in T and hasFound stores the total count of a character met so far. We also use a count variable to store the total characters in T that's met so far (not counting characters where hasFound[x] exceeds needToFind[x]). When count equals T's length, we know a valid window is found.

Each time we advance the end pointer (pointing to an element x), we increment hasFound[x] by one. We also increment count by one if hasFound[x] is less than or equal to needToFind[x]. Why? When the constraint is met (that is, count equals to T's size), we immediately advance begin pointer as far right as possible while maintaining the constraint.

How do we check if it is maintaining the constraint? Assume that begin points to an element x, we check if hasFound[x] is greater than needToFind[x]. If it is, we can decrement hasFound[x] by one and advancing begin pointer without breaking the constraint. On the other hand, if it is not, we stop immediately as advancing begin pointer breaks the window constraint.

Finally, we check if the minimum window length is less than the current minimum. Update the current minimum if a new minimum is found.

Essentially, the algorithm finds the first window that satisfies the constraint, then continue maintaining the constraint throughout.

i) S = 'acbbaca' and T = 'aba'.

ii) The first minimum window is found. Notice that we cannot advance begin pointer as hasFound['a'] == needToFind['a'] == 2. Advancing would mean breaking the constraint.

iii) The second window is found. begin pointer still points to the first element 'a'. hasFound['a'] (3) is greater than needToFind['a'] (2). We decrement hasFound['a'] by one and advance begin pointer to the right.

iv) We skip 'c' since it is not found in T. Begin pointer now points to 'b'. hasFound['b'] (2) is greater than needToFind['b'] (1). We decrement hasFound['b'] by one and advance begin pointer to the right.

v) Begin pointer now points to the next 'b'. hasFound['b'] (1) is equal to needToFind['b'] (1). We stop immediately and this is our newly found minimum window.

Both the begin and end pointers can advance at most N steps (where N is S's size) in the worst case, adding to a total of 2N times. Therefore, the run time complexity must be in O(N).


// Returns false if no valid window is found. Else returns
// true and updates minWindowBegin and minWindowEnd with the
// starting and ending position of the minimum window.
bool minWindow(const char* S, const char *T,
                    int &minWindowBegin, int &minWindowEnd) {
  int sLen = strlen(S);
  int tLen = strlen(T);
  int needToFind[256] = {0};
 
  for (int i = 0; i < tLen; i++)
     needToFind[T[i]]++;
 
  int hasFound[256] = {0};
  int minWindowLen = INT_MAX;
  int count = 0;
  for (int begin = 0, end = 0; end < sLen; end++) {
     // skip characters not in T
     if (needToFind[S[end]] == 0) continue;
     hasFound[S[end]]++;
     if (hasFound[S[end]] <= needToFind[S[end]])
        count++;
 
     // if window constraint is satisfied
     if (count == tLen) {
        // advance begin index as far right as possible,
        // stop when advancing breaks window constraint.
        while (needToFind[S[begin]] == 0 ||
                hasFound[S[begin]] > needToFind[S[begin]]) {
          if (hasFound[S[begin]] > needToFind[S[begin]])
             hasFound[S[begin]]--;
          begin++;
        }
 
        // update minWindow if a minimum length is met
        int windowLen = end - begin + 1;
        if (windowLen < minWindowLen) {
          minWindowBegin = begin;
          minWindowEnd = end;
          minWindowLen = windowLen;
        } // end if
     } // end if
  } // end for
 
  return (count == tLen) ? true : false;

This actually works:

a c b d a b a c d a c b d a
[       ]
[           ]
    [       ]
        [---]
        [         ]
          [       ]
          [           ]
            [         ]
            [             ]
                  [       ]

Source : http://discuss.leetcode.com/questions/97/minimum-window-substring

10. Write a program to compute if one string is a rotation of another
For example, "strings" usually refer to lines of letters, words or something that is meant to be printed and seen. But they can also refer to matrices (a two-dimensional object) and other kinds of objects.
You have to check if you can rotate them and check them against existing strings

Rotating a string means rotating two parts of a string around a pivot

Example:

If s1 = "stackoverflow" then the following are some of its rotated versions:

"tackoverflows"
"ackoverflowst"
"overflowstack"

Solution:

First make sure s1 and s2 are of the same length. Then check to see if s2 is a substring of s1 concatenated with s1:

algorithm checkRotation(string s1, string s2) 
  if (len(s1) != len(s2))
     return false
  if (substring(s2,concat(s1,s1))
     return true
  return false
end

In Java:

boolean isRotation(String s1,String s2) {
     return (s1.length() == s2.length()) && ((s1+s1).indexOf(s2) != -1);
}

11. What is the sticky bit and why is it used?

12. Describe quicksort algorithm and explain in time and memory complexity
[Quick Sort and Partition algorithms]

Quicksort is a divide and conquer algorithm. Quicksort first divides a large list into two smaller sub-lists: the low elements and the high elements. Quicksort can then recursively sort the sub-lists.

The steps are:

Pick an element, called a pivot, from the list.
Reorder the list so that all elements with values less than the pivot come before the pivot, while all elements with values greater than the pivot come after it (equal values can go either way). After this partitioning, the pivot is in its final position. This is called the partition operation.
Recursively sort the sub-list of lesser elements and the sub-list of greater elements.

The base case of the recursion are lists of size zero or one, which never need to be sorted.

Naive implementation

In simple pseudocode, the algorithm might be expressed as this:

 function quicksort('array')
        if length('array') = 1
             return 'array'  // an array of zero or one elements is already sorted
        select and remove a pivot value 'pivot' from 'array'
        create empty lists 'less' and 'greater'
        for each 'x' in 'array'
             if 'x' = 'pivot' then append 'x' to 'less'
             else append 'x' to 'greater'
        return concatenate(quicksort('less'), 'pivot', quicksort('greater')) // two recursive calls

Notice that we only examine elements by comparing them to other elements. This makes quicksort a comparison sort.

The correctness of the partition algorithm is based on the following two arguments:

At each iteration, all the elements processed so far are in the desired position: before the pivot if less than the pivot's value, after the pivot if greater than the pivot's value (loop invariant).
Each iteration leaves one fewer element to be processed (loop variant).

The correctness of the overall algorithm can be proven via induction: for zero or one element, the algorithm leaves the data unchanged; for a larger data set it produces the concatenation of two parts, elements less than the pivot and elements greater than it, themselves sorted by the recursive hypothesis.

In-place version

The disadvantage of the simple version above is that it requires O(n) extra storage space, which is as bad as merge sort. The additional memory allocations required can also drastically impact speed and cache performance in practical implementations. There is a more complex version which uses an in-place partition algorithm and can achieve the complete sort using O(log n) space (not counting the input) on average (for the call stack). We start with a partition function:

    // left is the index of the leftmost element of the array
    // right is the index of the rightmost element of the array (inclusive)
    //    number of elements in subarray = right-left+1
    function partition(array, left, right, pivotIndex)
        pivotValue := array[pivotIndex]
        swap array[pivotIndex] and array[right]  // Move pivot to end
        storeIndex := left
        for i from left to right - 1  // left = i < right
             if array[i] < pivotValue
                  swap array[i] and array[storeIndex]
                  storeIndex := storeIndex + 1
        swap array[storeIndex] and array[right]  // Move pivot to its final place
        return storeIndex

Tesing it:

     a =   [1, 9, 5, 4, 8, 6, 2, 3, 4, 7, 5]
 ( idx =    0  1  2  3  4  5  6  7  8  9  10 )

Call : partition (a, 0, 10, 5)
       pivotValue := 6
             swap : [1, 9, 5, 4, 8, '6', 2, 3, 4, 5, '7'] -> [1, 9, 5, 4, 8, '7', 2, 3, 4, 5, '6']
       storeIndex := 0

i=0    array[i] = 1   <6 true
            swap without effet
     storeIndex = 1   

i=1    array[i] = 9
     
i=2    array[i] = 5   <6 true
           swap : [1, '9', '5', 4, 8, 7, 2, 3, 4, 5, 6] -> [1, '5', '9', 4, 8, 7, 2, 3, 4, 5, 6]
     storeIndex = 2

i=3    array[i] = 4   <6 true
           swap : [1, 5, '9', '4', 8, 7, 2, 3, 4, 5, 6] -> [1, 5, '4', '9', 8, 7, 2, 3, 4, 5, 6]
     storeIndex = 3
    
i=4    array[i] = 8

i=5    array[i] = 7

i=6    array[i] = 2
           swap : [1, 5, 4, '9', 8, 7, '2', 3, 4, 5, 6] -> [1, 5, 4, '2', 8, 7, '9', 3, 4, 5, 6]
     storeIndex = 4

i=7    array[i] = 3
           swap : [1, 5, 4, 2, '8', 7, 9, '3', 4, 5, 6] -> [1, 5, 4, 2, '3', 7, 9, '8', 4, 5, 6]
     storeIndex = 5

i=8    array[i] = 4
           swap : [1, 5, 4, 2, 3, '7', 9, 8, '4', 5, 6] -> [1, 5, 4, 2, 3, '4', 9, 8, '7', 5, 6]
     storeIndex = 6

i=9    array[i] = 5
           swap : [1, 5, 4, 2, 3, 4, '9', 8, 7, '5', 6] -> [1, 5, 4, 2, 3, 4, '5', 8, 7, '9', 6]
     storeIndex = 7     

LastSwap:
           swap : [1, 5, 4, 2, 3, 4, 5, '8', 7, 9, '6'] -> [1, 5, 4, 2, 3, 4, 5, '6', 7, 9, '8']
     return storeIndex = 7 which is the last place of the pivot

This is the in-place partition algorithm. It partitions the portion of the array between indexes left and right, inclusively, by moving all elements less than array[pivotIndex] before the pivot, and the equal or greater elements after it. In the process it also finds the final position for the pivot element, which it returns. It temporarily moves the pivot element to the end of the subarray, so that it doesn't get in the way. Because it only uses exchanges, the final list has the same elements as the original list. Notice that an element may be exchanged multiple times before reaching its final place. Also, in case of pivot duplicates in the input array, they can be spread across the right subarray, in any order. This doesn't represent a partitioning failure, as further sorting will reposition and finally "glue" them together.

This form of the partition algorithm is not the original form; multiple variations can be found in various textbooks, such as versions not having the storeIndex. However, this form is probably the easiest to understand.

Once we have this, writing quicksort itself is easy:

function quicksort(array, left, right)
 
        // If the list has 2 or more items
        if left < right
 
             // See "Choice of pivot" section below for possible choices
             choose any pivotIndex such that left = pivotIndex = right
 
             // Get lists of bigger and smaller items and final position of pivot
             pivotNewIndex := partition(array, left, right, pivotIndex)
 
             // Recursively sort elements smaller than the pivot
             quicksort(array, left, pivotNewIndex - 1)
 
             // Recursively sort elements at least as big as the pivot
             quicksort(array, pivotNewIndex + 1, right)

Each recursive call to this quicksort function reduces the size of the array being sorted by at least one element, since in each invocation the element at pivotNewIndex is placed in its final position. Therefore, this algorithm is guaranteed to terminate after at most n recursive calls. However, since partition reorders elements within a partition, this version of quicksort is not a stable sort.

In average, quick sort runs on O(n log n).
In the worst case, i.e. the most unbalanced case, each time we perform a partition we divide the list into two sublists of size 0 and n-1. This means each recursive call processes a list of size one less than the previous list. Consequently, we can make n-1 nested calls before we reach a list of size 1. This means that the call tree is a linear chain of n-1 nested calls. So in that case Quicksort take O(n^2) time

Source : http://en.wikipedia.org/wiki/Quicksort

13. Describe a partition-based selection algorithm

Selection by sorting

Selection can be reduced to sorting by sorting the list and then extracting the desired element. This method is efficient when many selections need to be made from a list, in which case only one initial, expensive sort is needed, followed by many cheap extraction operations. In general, this method requires O(n log n) time, where n is the length of the list.

Linear minimum/maximum algorithms

Linear time algorithms to find minima or maxima work by iterating over the list and keeping track of the minimum or maximum element so far.

Nonlinear general selection algorithm

Using the same ideas used in minimum/maximum algorithms, we can construct a simple, but inefficient general algorithm for finding the kth smallest or kth largest item in a list, requiring O(kn) time, which is effective when k is small. To accomplish this, we simply find the most extreme value and move it to the beginning until we reach our desired index. This can be seen as an incomplete selection sort.
Here is the minimum-based algorithm:

 function select(list[1..n], k)
      for i from 1 to k
            minIndex = i
            minValue = list[i]
            for j from i+1 to n
                 if list[j] < minValue
                      minIndex = j
                      minValue = list[j]
            swap list[i] and list[minIndex]
      return list[k]

Other advantages of this method are:

After locating the jth smallest element, it requires only O(j + (k-j)^2) time to find the kth smallest element, or only O(1) for k = j.
It can be done with linked list data structures, whereas the one based on partition requires random access.

Partition-based general selection algorithm

A general selection algorithm that is efficient in practice, but has poor worst-case performance, was conceived by the inventor of quicksort, C.A.R. Hoare, and is known as Hoare's selection algorithm or quickselect.

In quicksort, there is a subprocedure called partition that can, in linear time, group a list (ranging from indices left to right) into two parts, those less than a certain element, and those greater than or equal to the element. (See previous question above)

In quicksort, we recursively sort both branches, leading to best-case O(n log n) time. However, when doing selection, we already know which partition our desired element lies in, since the pivot is in its final sorted position, with all those preceding it in sorted order and all those following it in sorted order. Thus a single recursive call locates the desired element in the correct partition:

function select(list, left, right, k)
      if left = right // If the list contains only one element
            return list[left]  // Return that element
      // select pivotIndex between left and right
      pivotNewIndex := partition(list, left, right, pivotIndex)
      pivotDist := pivotNewIndex - left + 1 
      // The pivot is in its final sorted position, 
      // so pivotDist reflects its 1-based position if list were sorted
      if pivotDist = k 
            return list[pivotNewIndex]
      else if k < pivotDist 
            return select(list, left, pivotNewIndex - 1, k)
      else
            return select(list, pivotNewIndex + 1, right, k - pivotDist)

Note the resemblance to quicksort: just as the minimum-based selection algorithm is a partial selection sort, this is a partial quicksort, generating and partitioning only O(log n) of its O(n) partitions. This simple procedure has expected linear performance, and, like quicksort, has quite good performance in practice.

It is also an in-place algorithm, requiring only constant memory overhead, since the tail recursion can be eliminated with a loop like this:

function select(list, left, right, k)
      loop
            // select pivotIndex between left and right
            pivotNewIndex := partition(list, left, right, pivotIndex)
            pivotDist := pivotNewIndex - left + 1
            if pivotDist = k
                 return list[pivotNewIndex]
            else if k < pivotDist
                 right := pivotNewIndex - 1
            else
                 k := k - pivotDist
                 left := pivotNewIndex + 1

Like quicksort, the performance of the algorithm is sensitive to the pivot that is chosen. If bad pivots are consistently chosen, this degrades to the minimum-based selection described previously, and so can require as much as O(n^2) time.

Source on wikipedia : http://en.wikipedia.org/wiki/Selection_algorithm#Partition-based_general_selection_algorithm.

14. Given a list of integers that fall within a known short but unknown range of values, how to find the median value?

15. Given a set of intervals, find the interval which has the maximum number of intersections.

Key idea : if one first sorts all points of all intervals O(n log n), then one simply needs to browse the point once O(n) and analyze the situation at each encounterd point.

Trying the following algorithm. The algorithm returns a map of intersections count for each interval.

Initialization :
 - sorted_points = sort all points (interval starts and ends, start points precedes equivalent end points) 
 - result = new Map <Interval -> Number>
 - current = new List<Interval> // Use to store current intervals
 - nb_current = 0
Algorithm:
 For each point p in sorted_points do
      i = interval matching p
      if p is an interval start then
            result[i] = nb_current
            increment nb_current 
            for each other in current do
                 increment result[other]
            end for
            add i in current            
      else
            remove i from current
            decrement nb_current 
      end if
 end for

Testing it with:

                     c=     
a=[1..............6][78][9....10]=g
b=[1...2][3...4][5....8][9....11]=h                    
          d=     e=  [8..9]
                     f=
                                
Initialisations:
- sorted_points = {1, 1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 9, 9, 9, 10, 11}
                         a  b  b  d  d  e  a  c  f  c  e  g  h  f  g    h
- nb_current = 0

Point p=1 / i=a             Point p=1 / i=b                Point p=2 / i=b    
  result[a] = 0                result[b] = 1                  current = {a}
  nb_current = 1               nb_current = 2                 nb_current = 1
  current = {a}                  result[a] = 1
                                 current = {a, b}
                                    
Point p=3 / i=d             Point p=4 / i=d                Point p=5 / i=e
  result[d] = 1                current = {a}                  result[e] = 1
  nb_current = 2               nb_current = 1                 nb_current = 2
     result[a] = 2                                               result[a] = 3
  current = {a, d}                                               current = {a, e}
  
Point p=6 / i=a             Point p=7 / i=c                Point p=8 / i=f
  current = {e}                result[c] = 1                  result[f] = 2
  nb_current = 1               nb_current = 2                 nb_current = 3
                                result[e] = 2                   result[e] = 3
                                current = {e, c}                result[c] = 2
                                                                current = {e, c, f}
                                                                        
Point p=8 / i=c             Point p=8 / i=e                Point p=9 / i=g
  current = {e, f}             current = {f}                  result[g] = 1
  nb_current = 2               nb_current = 1                 nb_current = 2
                                                                result[f] = 3
                                                                current = {f, g}
                                                                         
Point p=9 / i=h             Point p=9 / i=f                 Point p=10 / i=g
  result[h] = 2                current = {g, h}                current = {h}
  nb_current = 3               nb_current = 2                  nb_current = 1
    result[f] = 4
    result[g] = 2
  current = {f, g, h}
  
Point p=11 / i=h
  current = {}
  nb_current = 1
  
Results :
  reault = {f=4, g=2, e=3, c=2, a=3, h=2, b=1, d=1}

16.a. Let's defined an array of 100 integers from 1 to 100, shuffled. One integer is taken out, find that integer.

We know that sum(i=1..n) = n x (n + 1) / 2.

Hence the sum of these numbers = 100 * 101 / 2 = x

hence the value of the missing card is equals to x minus the actual sum of the cards which can easily be computed.

sum = 0;
n = 100;
for( i =1; i <= n; i++) {
     sum += array[i];
}
print( (n*(n+1)/2 ) - sum )

If nore than one number is missing, see http://stackoverflow.com/questions/3492302/easy-interview-question-got-harder-given-numbers-1-100-find-the-missing-numbe
This idea is as follows: since we have now two or more missing variables, one needs to find a system of two or more equations.
For 2 missing values, one can use for instance x + = theoretical_sum - real_sum and x^2 + y^2 = theoretical_sum_of_square - real_sum_of_square. For more value, need use higher power functions.

16.b. Given an array of size N in which every number is between 1 and N, determine if there are any duplicates in it. You are allowed to destroy the array if you like.

Very similar to the problem above.
We know that sum(i=1..n) = n x (n + 1) / 2.

If there are no duplicates, and yet N nubers between 1 to N, it means we have all the nubers between 1 to N.
Hence the sum of these numbers = 100 * 101 / 2 = x

We're left with computing the actual sum of the array (O(n))

sum = 0;
n = 100;
for( i =1; i <= n; i++) {
     sum += array[i];
}
print(sum)

Let's store that sum in y.

If x is not equals to y then

knowing that the N numbers are between 1 and N (not greater than N, nor smaller that 1)
One of the i=1..N is missing (otherwise x would have been equals to y)
Still there are N numbers
Hence at least one of the i=1..N is duplicated

16.c. You have given an array from 1 to N and numbers also from 1 to N. But more than one number is missing and some numbers have repeated more than once. Find the algo with running time O(n).

All the numbers are positive to start with.
Now, For each A[i], Check the sign of A[A[i]]. Make A[A[i]] negative if it's positive.
Report a repetition if it's negative.

Finally all those entries i,for which A[i] is negative are present and those i for which A[i] is positive are absent.
In addition, finding a number already negative when wanting to set a number negative indicates a duplicate.

Runs in O(n) setting negatives and detecting duplicates + O(n) again looking for missing elements => O(n) total time complexity.

Detecting duplicates:

Pseudo-code:

for every index i in list
  check for sign of A[abs(A[i])] ;
  if positive then
     make it negative by A[abs(A[i])]=-A[abs(A[i])];
  else  // i.e., A[abs(A[i])] is negative
     this element (ith element of list) is a repetition

Implementation in C++:

#include <stdio.h>
#include <stdlib.h>
 
void printRepeating(int arr[], int size)
{
  int i;
  printf("The repeating elements are: \n");
  for (i = 0; i < size; i++)
  {
    if (arr[abs(arr[i])] >= 0)
      arr[abs(arr[i])] = -arr[abs(arr[i])];
    else
      printf(" %d ", abs(arr[i]));
  }
}
 
int main()
{
  int arr[] = {1, 2, 3, 1, 3, 6, 6};
  int arr_size = sizeof(arr)/sizeof(arr[0]);
  printRepeating(arr, arr_size);
  getchar();
  return 0;
}

Note: The above program doesn't handle 0 case (If 0 is present in array). The program can be easily modified to handle that also. It is not handled to keep the code simple.

Output:

The repeating elements are:
1 3 6

Detecting missing elements

This simply consists in one additional O(n) loop through the array looking for indices containing positive values. Each of this index represents a missing value, the value given by the index

Source : http://www.geeksforgeeks.org/find-duplicates-in-on-time-and-constant-extra-space/.

17. You are given a number of identical balls and a building with N floors. You know that there is an integer X < N such that the ball will break if it is dropped from any floor X or higher but will remain intact if dropped from a floor below X.
Given K balls and N how would you compute the minimum number of ball drops that are required to determine X in the worst-case?

18. Why are manhole covers round?

19.a. Given the time, devise an algorithm to calculate the angle between the hour and minute hands of an analog clock.

First approximative approach:

    public static int getAngleInDegreesBetweenHandsOnClock (int hour /*0-59*/, int minute /*0-59*/) {
        
        int angleFromNoonBig = (hour * 360 / 12) + (minute * 360 / 12 / 60);
        int angleFromNoonSmall = minute * 360 / 60;
        
        return Math.abs (angleFromNoonBig - angleFromNoonSmall);        
    }

A little more precise approach

    public static double getAngleInDegreesBetweenHandsOnClock (int hour /*0-59*/, int minute /*0-59*/, 
                int second /*0-59*/) {
        
        double angleFromNoonBig = ((double)hour * 360 / 12) + ((double)minute * 360 / 12 / 60) 
		        + ((double)second * 360 / 12 / 60 / 60);
        double angleFromNoonSmall = ((double)minute * 360 / 60) + ((double)second * 360 / 60 / 60);
        
        return Math.abs (angleFromNoonBig - angleFromNoonSmall);        
    }

19.b. How many times a day does a clock's hands overlap?

22 times a day if you only count the minute and hour hands overlapping. (12:00, 1:05, 2:11, 3:16, etc.)

2 times a day if you only count when all three hands overlap. This occurs at midnight and noon.

One can use the algorithm above to ensure this:

    List<String> result = new ArrayList<String>();
        for (int i = 0; i < 60; i++) {
            for (int j = 0; j < 60; j++) {
                for (int k = 0; k < 60; k++) {
                    double angle = DateUtils.getAngleInDegreesBetweenHandsOnClock(i, j, k);
                    if (angle < 0.045 && angle > -0.045) {
                        result.add (i + ":" + j + ":" + k);
                    }
                }                
            }
        }
        System.err.println (result);

Which gives:

[0:0:0, 1:5:27, 2:10:55, 3:16:22, 4:21:49, 5:27:16, 6:32:44, 7:38:11, 8:43:38, 9:49:5, 10:54:33]

20. What is a priority queue ? And what are the cost of the usual operations ?
[priority queue]

21. Tree traversal
Describe and discuss common tree traversal algorithms
[Tree traversal algos]

22. Graph traversal
Describe and discuss common graph traversal algorithms
[Graph Search algo]

Depth-first search (DFS)

Depth-first search (DFS) is an algorithm for traversing or searching a tree, tree structure, or graph. One starts at the root (selecting some node as the root in the graph case) and explores as far as possible along each branch before backtracking.

DFS is an uninformed search that progresses by expanding the first child node of the search tree that appears and thus going deeper and deeper until a goal node is found, or until it hits a node that has no children. Then the search backtracks, returning to the most recent node it hasn't finished exploring. In a non-recursive implementation, all freshly expanded nodes are added to a stack for exploration.

Algorithm :

Input: A graph G and a vertex v of G
Output: A labeling of the edges in the connected component of v as discovery edges and back edges

1  procedure DFS(G,v):
2        label v as explored
3        for all edges e in G.adjacentEdges(v) do
4             if edge e is unexplored then
5                  w <- G.adjacentVertex(v,e)
6                  if vertex w is unexplored then
7                        label e as a discovery edge
8                        recursively call DFS(G,w)
9                  else
10                      label e as a back edge

Complexity : O(|V|)

breadth-first search (BFS)

breadth-first search (BFS) is a strategy for searching in a graph when search is limited to essentially two operations: (a) visit and inspect a node of a graph; (b) gain access to visit the nodes that neighbor the currently visited node. The BFS begins at a root node and inspects all the neighboring nodes. Then for each of those neighbor nodes in turn, it inspects their neighbor nodes which were unvisited, and so on. Compare it with the depth-first search.

The algorithm uses a queue data structure to store intermediate results as it traverses the graph, as follows:

Enqueue the root node
Dequeue a node and examine it
- If the element sought is found in this node, quit the search and return a result.
- Otherwise enqueue any successors (the direct child nodes) that have not yet been discovered.
If the queue is empty, every node on the graph has been examined so quit the search and return "not found".
If the queue is not empty, repeat from Step 2.

Note: Using a stack instead of a queue would turn this algorithm into a depth-first search.

Algorithm :

Input: A graph G and a root v of G

1  procedure BFS(G,v):
2        create a queue Q
3        enqueue v onto Q
4        mark v
5        while Q is not empty:
6             t <- Q.dequeue()
7             if t is what we are looking for:
8                  return t
9             for all edges e in G.adjacentEdges(t) do
12                 u <- G.adjacentVertex(t,e)
13                 if u is not marked:
14                        mark u
15                        enqueue u onto Q

The time complexity can be expressed as O(|V|+|E|) since every vertex and every edge will be explored in the worst case.

Source on wikipedia : http://en.wikipedia.org/wiki/Graph_traversal

23. How to find Inorder Successor in Binary Search Tree

In Binary Tree, Inorder successor of a node is the next node in Inorder traversal of the Binary Tree. Inorder Successor is NULL for the last node in Inorder traversal.
In Binary Search Tree, Inorder Successor of an input node can also be defined as the node with the smallest key greater than the key of input node. So, it is sometimes important to find next node in sorted order.

In the above diagram, inorder successor of 8 is 10, inorder successor of 10 is 12 and inorder successor of 14 is 20.

Method 1 (Uses Parent Pointer)

In this method, we assume that every node has a parent pointer.

The Algorithm is divided into two cases on the basis of right subtree of the input node being empty or not.

/> Input: node, root // where node is the node whose Inorder successor is needed.
output: succ // where succ is Inorder successor of node.

If right subtree of node is not NULL, then succ lies in right subtree. Do following.
Go to right subtree and return the node with minimum key value in right subtree.
If right sbtree of node is NULL, then succ is one of the ancestors. Do following.
Travel up using the parent pointer until you see a node which is left child of it's parent. The parent of such a node is the succ.

Method 2 (Search from root)

Simnply use iterative inorder. When value is found, return next visited node if any

findSucessor(node, value)
  parentStack = empty stack
  found = false;
  while not parentStack.isEmpty() or node != null
     if node != null then
        parentStack.push(node)
        node = node.left
     else
        node = parentStack.pop()
        
        // here comes the trick
        if (node.value == value) then
             found = true
        if (found) then
             return node.value        
        
        node = node.right

24. Write a method to pretty print a binary tree

Key Idea : Use a recursive method that generates the left and right subtrees as an array of string (lines of strings).
Then, when the subtrees arrays of strings are generated, merge them together horizontally and add the root node on top with the value located at the location of junction of both sub matrices.

 ___________________                
 |      __A__      |
 |_____/_   _\_____|
 |   B   | |  C    |
 | ....  | |  .... |    
 |_______| |_______|

Using A BFS traversal of the tree enables us then to print the nodes right at the order in which they need to be printed. One only needs to store the level with each node when the node is put in the traversal queue

Time complexity = O(n), space complexity = O(n)

Some pseudo code could be:

procedure printTree (node)

    leftTreePrint = printTree (node.left)    
    rightTreePrint = printTree (node.right)

    underPart = appendSide  (leftTreePrint, rightTreePrint);

    value = node.information
    fullLength = max (length (leftPrintTree) + length (rightPrintTree), length (value) + 2)

    firstLine = node.information;
    firstLine = padLeft (value, max (length (leftPrintTree), 1))
    firstLine = padRight (value, max (length (rightPrintTree), 1))

    secondLine = ... # Put "   /--------    ------ \" above values of left and right subtree
    
    underPart = appendTop (secondLine, underPart)
    return appendTop (firstLine, underPart)

Implementation in Java is as follows, assuming a node is defined this way:

node.left
node.information
node.right

public class TreePrinter {

    public static String printTree(Node<?> root) {
        MutableInt rootPos = new MutableInt(0);
        char[][] printLines = printTree (root, rootPos);
        
        StringBuilder builder = new StringBuilder();
        for (char[] line : printLines) {
            if (line != null) {
                builder.append (String.valueOf(line));
                builder.append("\n");
            }
        }
        return builder.toString();
    }

    private static char[][] printTree(Node root, MutableInt retPos) {
        
        if (root == null) {
            return null;
        }
        
        MutableInt retPosLeft = new MutableInt(0);
        MutableInt retPosRight = new MutableInt(0);
        
        char[][] leftTreePrint = printTree (root.left, retPosLeft);
        char[][] rightTreePrint = printTree (root.right, retPosRight);
        
        String value = root.information.toString();
        
        int lengthLeft = getLength(leftTreePrint, value);
        int lengthRight = getLength(rightTreePrint, value);
        
        char[][] under = appendSide  (leftTreePrint, lengthLeft, rightTreePrint, lengthRight); 
		// if one is null, use one space instead
		
        int fullLength = lengthLeft + lengthRight;// printLength (under);  // min 3 !!!
                
        if (value.length() + 2 > fullLength) {
            fullLength = value.length() + 1;
        }
        
        // 1. Fill in first line
        char[] firstLine = new char[fullLength];
        Arrays.fill(firstLine, ' ');
        int pos = lengthLeft - (value.length() / 2);
        if (pos < 0) {
            pos = 0;
        }
        retPos.setValue(pos);
        System.arraycopy(value.toCharArray(), 0, firstLine, pos, value.length());
        
        // 2. Fill in second line
        char[] secondLine = null;
        if (under != null && under.length > 0) {            
            secondLine = new char[fullLength];
            Arrays.fill(secondLine, ' ');        
            if (leftTreePrint != null && leftTreePrint.length > 0) {
                int posLeftTree = retPosLeft.intValue() + root.left.information.toString().length() / 2;
                secondLine[posLeftTree >= 0 ? posLeftTree : 0] = '/';
                // underscores on first line
                if (posLeftTree + 1 < pos) {
                    Arrays.fill(firstLine, posLeftTree + 1, pos, '_');
                }
            }
            if (rightTreePrint != null && rightTreePrint.length > 0) {
                int posRightTree = lengthLeft + retPosRight.intValue() 
				        + root.right.information.toString().length() / 2;
                secondLine[posRightTree >= 1 ? posRightTree : 1] = '\\';   
                // underscores on first line
                if (pos + value.length() < posRightTree) {
                    Arrays.fill(firstLine, pos + value.length(), posRightTree, '_');
                }
            }
        }

        // 3. append underneath tree 
        return appendTop (firstLine, secondLine, under, lengthLeft, lengthRight); // pad under with left and right spaces if required
    }

    private static int getLength(char[][] treePrint, String value) {
        int length = printLength (treePrint);
        if (length < (value.length() + 1) / 2) {
            length = (value.length() + 1) / 2;
        }
        return length;
    }
    
    private static char[][] appendTop(char[] firstLine, char[] secondLine,
            char[][] under, int lengthLeft, int lengthRight) {
        
        int maxWidth = firstLine.length;
        if (secondLine != null && secondLine.length > maxWidth) {
            maxWidth = secondLine.length;
        }
        if (under != null && under.length > 0 && under[0].length > maxWidth) {
            maxWidth = under[0].length;
        }
        
        char[][] result = new char[1 + (secondLine != null ? 1 : 0) + under.length][];
        result[0] =  padLine (firstLine, maxWidth);
        if (secondLine != null) {
            result[1] =  padLine (secondLine, maxWidth);
            if (under != null && under.length > 0) {
                for (int i = 0; i < under.length; i++) {
                    result[2 + i] = padLineDirection (under[i], maxWidth, 
					        lengthLeft > lengthRight ? false : true);
                }
            }
        }
        
        return result;
    }
    
    private static char[] padLineDirection(char[] line, int maxWidth, boolean left) {
        int leftPadCounter = 0;
        int rightPadCounter = 0;
        char[] result = new char[maxWidth];
        for (int i = 0; i < maxWidth - line.length; i++) {
            if (left) {
                result[leftPadCounter] = ' ';                
                leftPadCounter++;
            } else {
                result[maxWidth - 1 - rightPadCounter] = ' ';
                rightPadCounter++;
            }
        }
        System.arraycopy(line, 0, result, leftPadCounter, line.length);
        
        return result;
    }

    private static char[] padLine(char[] line, int maxWidth) {
        int leftPadCounter = 0;
        int rightPadCounter = 0;
        char[] result = new char[maxWidth];
        for (int i = 0; i < maxWidth - line.length; i++) {
            if (i % 2 == 1) {
                result[leftPadCounter] = ' ';                
                leftPadCounter++;
            } else {
                result[maxWidth - 1 - rightPadCounter] = ' ';
                rightPadCounter++;
            }
        }
        System.arraycopy(line, 0, result, leftPadCounter, line.length);
        
        return result;
    }

    private static char[][] appendSide(char[][] leftTreePrint, int lengthLeft, char[][] rightTreePrint, 
	            int lengthRight) {
        int maxHeight = 0;
        if (leftTreePrint != null) {
            maxHeight = leftTreePrint.length; 
        }
        if (rightTreePrint != null && rightTreePrint.length > maxHeight) {
            maxHeight = rightTreePrint.length;
        }
        
        char[][] result = new char[maxHeight][];
        
        // Build assembled row
        for (int i = 0; i < maxHeight; i++) {
            char[] leftRow = null;
            if (leftTreePrint != null && i < leftTreePrint.length) {
                leftRow = leftTreePrint[i];
            }
            char[] rightRow = null;
            if (rightTreePrint != null && i < rightTreePrint.length) {
                rightRow = rightTreePrint[i];
            }
            result[i] = appendRow (leftRow, rightRow, lengthLeft, lengthRight);
        }
        
        return result;
    }

    private static char[] appendRow(char[] leftRow, char[] rightRow, int maxWidthLeft, int maxWidthRight) {
        char[] result = new char[maxWidthLeft + maxWidthRight];
        if (leftRow != null) {
            System.arraycopy(leftRow, 0, result, 0, leftRow.length);
        } else {
            Arrays.fill(result, 0, maxWidthLeft, ' ');
        }

        if (rightRow != null) {
            System.arraycopy(rightRow, 0, result, maxWidthLeft, rightRow.length);
        } else {
            Arrays.fill(result, maxWidthLeft, maxWidthLeft + maxWidthRight, ' ');
        }
        
        return result;
    }

    private static int printLength(char[][] under) {
        if (under != null && under.length > 0) {
            return under[0].length;
        }
        return 0;
    }  
}

25.a. What is dynamic programming ?
[Dynamic Programming]

25.b. Write an algorithm to generate a fibonacci number sequence and discuss its time and space complexity.

In a Fibonacci series each number is the sum of the two previous numbers starting with 1,1.
The rule is Xn = Xn-1 + Xn-2

1. Naive Algorithm

A naive version of the Fibonacci sequence algorithm, which generates the n'th number of the Fibonacci sequence is as follows:
(for instance in Java)

int recursiveFib(int n) {
     if (n <= 1)
          return 1;
     else
          return recursiveFib(n - 1) + recursiveFib(n - 2);
}

Complexity

the complexity of a naive recursive fibonacci is indeed 2^n.

T(n) = T(n-1) + T(n-2) = T(n-2) + T(n-3) + T(n-3) + T(n-4) =
= T(n-3) + T(n-4) + T(n-4) + T(n-5) + T(n-4) + T(n-5) + T(n-5) + T(n-6) = ...

in each step you call T twice, thus will provide eventual asymptotic barrier of: T(n) = 2 * 2 * ... * 2 = 2^n

Space Complexity

Here we are not using any memory except the stack. Only one resursive function call occurs at a time, hence the space complexity is O(n)

2. A first better approach : use a memory

The obvious reason for the recursive algorithm's lack of speed is that it computes the same Fibonacci numbers over and over and over. A single call to recursiveFib(n) results in one recursive call to recursiveFib(n - 1), two recursive calls to recursiveFib(n - 2), three recursive calls to recursiveFib(n - 3), five recursive calls to recursiveFib(n - 4), and in general, F_(k-1) recursive calls to recursiveFib(n - k), for any 0 <= k < n.
For each call, we're recomputing some Fibonacci number from scratch.

We can speed up the algorithm considerably just by writing down the results of our recursive calls and looking them up again if we need them later.
This process is called memoization.
For instancre in Java:

// initialization
int F = new int[n]
for (int i = 0; i < n; i++) F[i] = -1;

int memoryFib (int n) {
    if (n < 2)
        return n;
    else {
        if (F[n] == -1)
            F[n] = memoryFib(n - 1) + memoryFib(n - 2)
        return F[n];
    }
}

We end up here with an algorithm of time complexity O(n) and space complexity O(n), hence an exponential speedup over the previous algorithm.

3. Even better: use dynamic programming

In the example above, if we actually trace through the recursive calls made by memoryFib, we find that the memory F[] is filled from the bottom up: first F[2], then F[3], and so on, up to F[n].

Once we see this pattern, we can replace the recursion with a simple for-loop that fills the array in order, instead of relying on the complicated recursion to do it for us. This gives us our first explicit dynamic programming algorithm.
For instance in Java:

// initialization
int F = new int[n]

int iterativeFib (int n) {
    F[0] = 0;
    F[1] = 1;
    for (int i = 2; i <= n; i++)
        F[i] = F[i - 1]+ F[i -2];
    return F[n];
}

This is still of time complexity O(n) and space complexity O(n) but removes the overhead of all the recursive method calls.

4. Best approach

We can reduce the space to O(1) by noticing that we never need more than the last two elements of the array:

int iterativeFib2 (int n) {
    prev = 1;
    cur = 0;
    for (int i = 1 ; i <= n; i++) {
        next = cur + prev;
        prev = cur;
        cur = next;
    }
    return cur;
}

This algorithm uses the non-standard but perfectly consistent base case F_1 = 1 so that iterativeFib2(0) returns the correct value 0.

25.c. Given an array, find the longest (non necessarily continuous) increasing subsequence.
Not to be confused with problem 66.c which adds a "continuous" constraint.

Let A be our sequence [a_1, a_2, a_3, ..., a_n]
Define q_k as the length of the longest increasing subsequence of A that ends on element a_k.
- For instance q_4 is 2 if there are two elements before "position 4" in the array that are increasing towards the value a_4
- q_1 is alway 1
The longest increasing subsequence of A must end on some element of A, so that we can find its length by searching the q_k that has the maximum value
All that remains is to find out the values q_k

q_k can be found recursively, as follows:

Consider the set S_k of all i < k such that a_i < a_k. Those are all the elements of S before "positon k" that are below a_k.
If this set is null, then all of the elements that come before a_k are greater than it, which forces q_k = 1
Otherwise, if S_k is not null, then q has some distribution over S_k (which is discussed below)

By the general contract of q, if we maximize q over S_k, we get the length of the longest increasing subsequence in S_k.
We can append a_k to this sequence to get q_k = max (q_j | j in S_k) + 1

This means : For each q_k, look in every position j in S before q searching for the values a_j that are below a_k. These values form the set S_k. In this set, search for the maximum q_i. Add 1 to this value to obtain q_k.

If the actual subsequence is desired, it can be found in O(n) further steps by moving backward through the q-array, or else by implementing the q-array as a set of stacks, so that the above "+ 1" is accomplished by "pushing" ak into a copy of the maximum-length stack seen so far.

Naive approach

One can design the recursive aklgorithm posed above:

procedure lis_length(a, 0, end)
    max = 0
    for j from 0 to end do
        if a[end] > a[j] then
            ln = lis_length (a, j)
            if ln > max then
                max = ln
        max = max + 1    
    return max                
    
// call lis_length (a, 0, length(a) - 1) // the first time

This works, for instance on [1, 2, 1, 5, 2, 3, 4, 7, 5, 4] with longest subsequence [1, 2, 3, 4, 7]:

      [1, 2, 1, 5, 2, 3, 4, 7, 5, 4]
       |                          |
       ||
       1
       |  |
          2
       |     |
	         1
	   ...
	   |        |
	            3
	   ...
	   |              |
	                  3
	   ...
	   |                 |
	                     4
	   ...
	   |                    |
	                        5
	   ...

This is a typical problem where dynamic programming comes in help since we end up solving the same sub-problems over and over again.

Using dynamic programming

There is a straight-forward Dynamic Programming solution if and only if only the length is required not the soluton itself (which can later be retrieved though).

Some pseudo-code for finding the length of the longest increasing subsequence:

procedure lis_length( a )
    n = a.length
    q = new Array(n)
    for k from 0 to n do
        max = 0
        for j from 0 to k do 
            if a[k] > a[j] then // Set S_k
                if q[j] > max then 
                    max = q[j]
        q[k] = max + 1;
    max = 0
    for i from 0 to n do
        if q[i] > max then 
            max = q[i]
    return max;

Source on wikipedia http://www.algorithmist.com/index.php/Longest_Increasing_Subsequence.

26. Describe and discuss the MergeSort algorithm

Merge sort (also commonly spelled mergesort) is an O(n log n) comparison-based sorting algorithm. Most implementations produce a stable sort, which means that the implementation preserves the input order of equal elements in the sorted output. Merge sort is a divide and conquer algorithm

Conceptually, a merge sort works as follows

Divide the unsorted list into n sublists, each containing 1 element (a list of 1 element is considered sorted).
Repeatedly merge sublists to produce new sublists until there is only 1 sublist remaining. This will be the sorted list.

Example pseudocode for top down merge sort algorithm which uses recursion to divide the list into sub-lists, then merges sublists during returns back up the call chain.

function merge_sort(list m)
     // if list size is 0 (empty) or 1, consider it sorted and return it
     // (using less than or equal prevents infinite recursion for a zero length m)
     if length(m) <= 1
          return m
     // else list size is > 1, so split the list into two sublists
     var list left, right
     var integer middle = length(m) / 2
     for each x in m before middle
            add x to left
     for each x in m after or equal middle
            add x to right
     // recursively call merge_sort() to further split each sublist
     // until sublist size is 1
     left = merge_sort(left)
     right = merge_sort(right)
     // merge the sublists returned from prior calls to merge_sort()
     // and return the resulting merged sublist
     return merge(left, right)

In this example, the merge function merges the left and right sublists.

function merge(left, right)
     var list result
     while length(left) > 0 or length(right) > 0
          if length(left) > 0 and length(right) > 0
                if first(left) <= first(right)
                     append first(left) to result
                     left = rest(left)
                else
                     append first(right) to result
                     right = rest(right)
          else if length(left) > 0
                append first(left) to result
                left = rest(left)
          else if length(right) > 0
                append first(right) to result
                right = rest(right)
     end while
     return result

In sorting n objects, merge sort has an average and worst-case performance of O(n log n)

27. Given a circularly sorted array, describe the fastest way to locate the largest element.

Rotated circular array

We assume here the cicular array takes the form of a usual sorted array that has been rotated at some random point.

One can use the following algorithm:

T findLargestElement(T[] data, int start, int end) {
    int mid = start + (end - start) / 2
    if (start == mid]) {
        return data[start];
    }
    // we search for the place the rotation took place
    if (data[start] > data[mid]) { 
        return findLargestElement (data, start, mid);
    } else {
        return findLargestElement (data, mid + 1, end);
    }
}

Using it for instance on [3 4 6 7 8 11 0 1 2] -> 11, we get following recusrions

          [3  4  6  7  8 11  0  1  2]
indices :  0  1  2  3  4  5  6  7  8

[3 4 6 7 8 11 0 1 2]
start = 0
end   = 8
mid   = 0 + (8 - 0) / 2 = 4

[11 0 1 2]
start = 5
end   = 8
mid   = 5 + (8 - 5) / 2 = 6

[11 0]
start = 5
end   = 6
mid   = 5 + (6 - 5) / 2 = 5

return 11

A pointer on a circular array, unknown size, unknown start

If we face a simple pointer as input on some position on the circular array of which we know neither the start nor the length, we have no choice but a O(n) solution to browse the pointers from an element to another until we spot the place where the next element is less than the current element.

28.a Reverse a linked list. Write code in C

28.b. How can you print singly linked list in reverse order? (it's a huge list and you cant use recursion)

If I cannot use recursion (which would allow easier approaches), I would use the destructive iterative reverse function above:

reversedList = reverse(list);
ptr = reversedList
while (ptr != null) {
    printf ("%s,", ptr->value);
}

28.c Write a function to reverse a singly linked list, given number of links to reverse.

29. Write a method to generate a random number between 1 and 7, given a method that generates a random number between 1 and 5. The distribution between each of the numbers must be uniform.

1. Wrong solution, doesn't work

With the usual methods found on internet, the solution gets largely biased.

First let's look at these methods:

Implementation in C:

int rand7(){
  int k = rand5() + rand5() + rand5() + rand5() + rand5() + rand5() + rand5();
  return k / 5;
}

Extending it for any other number:

int rand_any_number_using_rand5(int new_base) {
     int k = 0;
     for (int i = 1; i < new_base; i++) {
          k += rand5();
     }
     return k / new_base;
}

Or in Java:

import java.util.Random;
public class Rand {
     Random r = new Random();
     int rand7() {
          int s = r.nextInt(5);
          for (int i = 0; i < 6; i++) {
                s += r.nextInt(5);
          }
          return s % 7;
     }
}

2. Proof that these methods are wrong

let's try the following program:

import java.util.Arrays;

public class RandUtils {
    
    public static void main (String[] args) {
        int[] count = new int[7];
        for (int i = 0; i < 50000; i++) {
            int rand = rand7();
            count[rand] = count[rand] + 1;
        }
        System.err.println (Arrays.toString(count));
    }
    
    static int rand7() {
        double retValue = 0;
        for (int i = 0; i < 7; i++) {
            retValue += rand5();
        }
        return (int) retValue / 5;
    }
    
    static int rand5 () {
        return (int) (Math.random() * 5.0 + 1.0);
    }

}

Which gives :

[0, 9767, 10019, 9962, 10111, 10141, 0]

This is obvious since there are more posibilities to build the middle values than the extreme values.

3. Correct solution

A correct solution should consist in finding a way using rand5() to select with the same probability any of the numbers between 1 and X.

A binary search can be used to do the trick:

public class RandUtils {
    
    public static void main (String[] args) {
        int[] count = new int[7];
        for (int i = 0; i < 50000; i++) {
            int rand = rand7();
            count[rand - 1] = count[rand - 1] + 1;
        }
        System.err.println (Arrays.toString(count));
    }
    
    static int rand7() {
        return randXInt(1, 7);
    }
    
    static int randXInt(int start, int end) {
        
        if (start == end) {
            return start;
        }
        
        // if the number of values in range is odd, make it even
        // (otherwise the distibution would be biased since an element would
        // have twice more chance to appear than others)
        int effEnd = end;
        if ((end - start + 1) % 2 != 0 ) {
            effEnd++;
        }
        
        int pivot = (effEnd - start) / 2 + start;
        
        // two first values of rand 5 makes us go left, two last right
        int retValue = 0;
        int rand = 0;
        do {
            rand = rand5();
            if (rand == 1 || rand == 2) {
                retValue = randXInt (start, pivot);
            } else if (rand == 4 || rand == 5) {
                retValue = randXInt (pivot + 1, effEnd);
            }  
        } while (rand == 3);
        
        if (end != effEnd && retValue == effEnd) {
            // retry
            return randXInt(start, end);
        }
        return retValue;
    }

    static int rand5 () {
        return (int) (Math.random() * 5.0 + 1.0);
    }   
}

Which gives:

[7150, 7228, 7033, 7281, 7049, 7156, 7103]

Hence a pretty uniform distribution.
Time complexity is O(log n) and space complexity O(log n) as well (function calls on the stack).

30.a. The probability of a car passing a certain intersection in a 20 minute windows is 0.9. What is the probability of a car passing the intersection in a 5 minute window? (Assuming a constant probability throughout)

30.b. You are given biased coin. Find unbiased decision out of it?

31. What is the difference between a mutex and a semaphore?
Which one would you use to protect access to an increment operation?

32. Write a C program which measures the the speed of a context switch on a UNIX/Linux system.

33. Design a class library for writing card games.

I would implement the following classes:

Game: a class that represents the card game, which contains decks, cards and sets of players.
Deck: a stack of cards that could be initialized and used as the full cards deck (52 cards) and drawn from it to other decks like player hands or ground stacks.
Card: the actual card object.
Combination: Any arbitrary set of cards
Player: represents a player which may hold a combination

One can imagine the following attributes and/or methods for each class:

|--------------------------|     |--------------------------|     |-------------------------|  
|         Game             |     |      Deck                |     |      Card               |   
|--------------------------|     |--------------------------|     |-------------------------|   
| - String name            |     | - abstract format        |     | - Family family         |     
| - Set<Player> cards      |     | - Set<Card> cards        |     | - number                |     
| - Deck deck              |     |--------------------------|     |-------------------------|     
|--------------------------|     | Combin. pickUp (int nbr) |     | bool beats (Card other) |     
| void draw(Window wnd)    |     | int remainingCnt()       |     |-------------------------|     
|--------------------------|     | void putBack (Comb. cmb) |                                     
                                 |--------------------------|                                     
								 
|-------------------------|     |-------------------------|								 
|      Combination        |     |      Player             |
|-------------------------|     |-------------------------|   
| - Set<Card> cards       |     | - int number            | 
|-------------------------|     | - Combination comb      | 
| int numberCards()       |     |-------------------------|
| bool beats (Comb. other)|
| void add (Card card)    |
| void remove (Card card) |
|-------------------------|

34. Tree search algorithms. Write BFS and DFS code, explain run time and space requirements. Modify the code to handle trees with weighted edges and loops with BFS and DFS, make the code print out path to goal state.

35. Write some code to find all permutations of the letters in a particular string.
[Permutation generation algo]

First a note on permutations:

When considering sequences of a fixed length k of elements taken from a given set of size n. These objects are also known as partial permutations or as sequences without repetition, terms that avoids confusion with the other, more common, meanings of "permutation". The number of such k-permutations of n is denoted.

In this case we are facing simplier permutations in an array of size n, hence n! possibilities.

perm(a)     = [a]
perm(ab)    = [perma(a).perm(b), perma(b).perm(a)]
perm(abc)   = [perma(a).perm(bc), perma(b).perm(a).perm(c), perma(c).perm(a).perm(b), perma(bc).perm(a)]
perm(abcd)  = [perm(a).perm(bcd), perm(b).perm(a).perm(cd), ...]
...

Is there any way to define a resursive notation ?

Let's write an algorithm that does just that:

import java.util.ArrayList;
import java.util.List;

public class TestPermute {

     public static void main(String[] args) {
          for (String in : permute ("abcd")) {
                System.err.println (in);
          }
     }

     private static List<String> permute(String string) {
          List<String> permutations = new ArrayList<String>();          
          if (string.length() > 1) {
                char fixed = string.charAt(0);
                for (String other :  permute (string.substring(1))) {
                     permutations.add (fixed + other);
                     for (int i = 1; i < other.length(); i++) {
                          permutations.add (other.substring(0, i) + fixed + other.substring(i));
                     }
                     permutations.add (other + fixed);
                }
          } else {
                permutations.add (string);
          }
          return permutations;
     }

}

36.a. What is a hash table ahd how is it typically implemented ?
[Hash Table principle]

36.b When would you use a binary tree vs. a hash map (hash table)?

37.a. You have eight balls all of the same size. 7 of them weigh the same, and one of them weighs slightly more. How can you find the ball that is heavier by using a balance and only two weightings?

37.b. You have 5 jars of pills. Each pill weighs 10 gram, except for contaminated pills contained in one jar, where each pill weighs 9 gm. Given a scale, how could you tell which jar had the contaminated pills in just one measurement?

37.c. You have 12 balls. All of them are identical except one, which is either heavier or lighter than the rest - it is either hollow while the rest are solid, or solid while the rest are hollow. You have a simple two-armed scale, and are permitted three weighings. Can you identify the odd ball, and determine whether it is hollow or solid.

38. There is an array A[N] of N numbers. You have to compose an array Output[N] such that Output[i] will be equal to multiplication of all the elements of A[N] except A[i]. For example Output[0] will be multiplication of A[1] to A[N-1] and Output[1] will be multiplication of A[0] and from A[2] to A[N-1]. Solve it without division operator and in O(n).

Note : same question : You are given an array [a1 To an] and we have to construct another array [b1 To bn] where bi = a1*a2*...*an/ai. you are allowed to use only constant space and the time complexity is O(n). No divisions are allowed.

Since the complexity required is O(n), the obvious O(n^2) brute force solution is not good enough here. Since the brute force solution recompute the multiplication each time again and again, we can avoid this by storing the results temporarily in an array.

First we construct an array B where element B[i] = multiplication of numbers from A[n] to A[i]. For example, if A = {4, 3, 2, 1, 2}, then B = {48, 12, 4, 2, 2}. The array B is built by browsing A from right to left, eac B[i] = A[i] * B[i + 1].
Then, we scan the array A from left to right, and have a temporary variable called product which stores the multiplication from left to right so far. Calculating OUTPUT[i] is straight forward, as OUTPUT[i] = B[i + 1] * product.

Hence the following akgorithm, in Java:

import java.util.Arrays;

public class TestMult {

     public static void main(String[] args) {
          int[] mult = multiplyArray (new int[] {4, 3, 2, 1, 2});
          System.out.println (Arrays.toString(mult));
     }

     private static int[] multiplyArray(int[] in) {
          int[] temp = new int[in.length];
          int[] out = new int[in.length];
          temp[in.length - 1] = in[in.length - 1];
          for (int i = in.length - 2; i >= 0; i--) {
                temp[i] = temp[i + 1] * in[i];
          }
          //System.out.println (Arrays.toString(temp));
          int prod = 1;
          for (int i = 0; i < in.length - 1; i++) {
                out[i] = temp[i + 1] * prod;
                prod = prod * in[i];
          }
          out[in.length - 1] = prod;
          return out;
     }

}

The above method requires only O(n) time but uses O(n) space. We have to trade memory for speed.

Is there a better way? (i.e., runs in O(n) time but without extra space?)

Yes, actually the temporary table is not required. We can have two variables called left and right, each keeping track of the product of numbers multiplied from left->right and right->left.
Can you see why this works without extra space?

void array_multiplication(int A[], int OUTPUT[], int n) {
     int left = 1;
     int right = 1;
     for (int i = 0; i < n; i++)
     OUTPUT[i] = 1;
     for (int i = 0; i < n; i++) {
          OUTPUT[i] *= left;
          OUTPUT[n - 1 - i] *= right;
          left *= A[i];
          right *= A[n - 1 - i];
     }
}

Source : http://leetcode.com/2010/04/multiplication-of-numbers.html.

39. Find or determine non existence of a number in a sorted list of N numbers where the numbers range over M, M>> N and N large enough to span multiple disks. Algorithm to beat O(log n) bonus points for constant time algorithm.

I would try binary search which typically works in O(log n)

A binary search is a search algorithm that operates by selecting between two distinct alternatives (dichotomies) at each step. It is a specific type of divide and conquer algorithm.
A binary search or half-interval search algorithm finds the position of a specified value (the input "key") within a sorted array. In each step, the algorithm compares the input key value with the key value of the middle element of the array. If the keys match, then a matching element has been found so its index, or position, is returned. Otherwise, if the sought key is less than the middle element's key, then the algorithm repeats its action on the sub-array to the left of the middle element or, if the input key is greater, on the sub-array to the right. If the remaining array to be searched is reduced to zero, then the key cannot be found in the array and a special "Not found" indication is returned.

An algorithm that works this way:

function find (files, n) 
     target <- NULL
     for each file in files
          if last number in file > n then
                target <- file
                break
     return find (file, n, 0, length(file))
     
function find (file, n, startIdx, endIdx)      
     span <- (endIdx - startIdx) / 2
     if span = 0 then
          return not found;
     index <- span + startIdx
     number_at_idx = file(index)
     if span == 1 then
          if number_at_idx == n then
                return found
          else
                return not found     
     
     if number_at_idx < n then
          return find (file, n, index + 1, endIdx)
     else
          return find (file, n, startIdx, index - 1)

40. How do you put a Binary Search Tree in an array in a efficient manner.
Hint : If the node is stored at the ith position and its children are at 2i and 2i+1(I mean level order wise) Its not the most efficient way.

First let's try the ith * 2 position trick:

            3
          / \
         2    8
        /    / \
      1    5    9
          / \    \
         4    6  10 
        
index : 1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 16 17 18 19 20
value : 3  2  8  1      5  9                    4  6     10

Indeed it's not the most efficient way in terms of space usage wince it leaves a lot of emtpy elements within the array.

Another better idea:

If you want to be able to reconstruct the tree as it stands, you can simply store the BST nodes in the array using a pre-order traversal.
When you want to rebuild the tree just walk through the array in order, adding the nodes normally, and the tree will end up just like it was before.

This example tree would be stored as { 3, 2, 1, 8, 5, 4, 6, 9, 10 } - there is no need for empty elements to be represented in the array.

41. How do you find out the fifth maximum element in an Binary Search Tree in efficient manner.
Note: You should not use use any extra space. i.e sorting Binary Search Tree and storing the results in an array and listing out the fifth element.

The simpliest is to use "reverse inorder" and stop after the fifth element is encounterd. Iterative way seems preferable over recursive way:

findFifthMaximal(node)
  // from iterativeReverseInorder
  parentStack = empty stack
  int counter = 0;
  while not parentStack.isEmpty() or node != null
     if node != null then
        parentStack.push(node)
        node = node.right
     else
        node = parentStack.pop()
        counter++;
        if counter == 5 then
             return node
        node = node.left
  return null

42. Given a Data Structure having first n integers and next n chars. A = i1 i2 i3 -> iN c1 c2 c3 -> cN.
Write an in-place algorithm to rearrange the elements of the array as A = i1 c1 i2 c2 -> in cn

If the data structure is an array

Single way I found is by cheating. I'm using the stack as a memory (hence a O(n) space complexity)

// 1 2 3 4 a b c d 
// 1 a 2 b 3 c 4 d

rearrange (array)
  N = length(array) / 2
  i = 1
  move(array, i, N)

move (array, i, N) 
  num_pos = i 
  num_target_pos = i * 2 - 1
  char_pos = N + i
  char_target_pos = i * 2
  num = array[num_pos]
  char = array[char_pos]
  if (i < N) {
        move (array, i + 1, N)
  } 
  array[num_target_pos] <- num
  array[char_target_pos] <- char

If the data structure is a Linked List, things get a lot easier since we can insert at random location

Use an algorithm working this way:

rearrange (node)
    // locate first character
    cPointer = node
    while pointer.value is number do
        cPointer = cPointer.next
    done
    while node is not null do
        nextNum = node.next
        node.next = cPointer
        cPointer = cPointer.next // have next char here
        node.next.next = nextNum
        node = nextNum;
    done

Proof of work:

 0   : 1  2  3  4  a  b  c  d
       n           c

 1   : 1  a  2  3  4           b  c  d
             n                 c
             
 2   : 1  a  2  b  3  4        c  d
                   n           c             
                   
 3   : 1  a  2  b  3  c  4     d 
                         n     c

 4   : 1  a  2  b  3  c  4  d

Runs in time complexity O(n) and space complexity O(1)

43. Use basic operations to create a square root function.

First approach : use binary search

One can use a binary search like approach between the numbers between 1 and the target number until x * x = N.

Second approach : Babylonian method :

function sqrt(N)
    oldguess = -1
    guess = 1
    while abs(guess-oldguess) > 1 do
        oldguess = guess
        guess = (guess + N/guess) / 2
    return guess

44. Given a file of 4 billion 32-bit integers, how to find one that appears at least twice?

45. Write a program for displaying the ten most frequent words in a file such that your program should be efficient in all complexity measures.

46.a. What is bactracking as an algorithmic technique ?
Give an example algorithm.
[Backtracking principle]

Backtracking is a general algorithm for finding all (or some) solutions to some computational problem, that incrementally builds candidates to the solutions, and abandons each partial candidate c ("backtracks") as soon as it determines that c cannot possibly be completed to a valid solution.

Backtracking can be applied only for problems which admit the concept of a "partial candidate solution" and a relatively quick test of whether it can possibly be completed to a valid solution. It is useless, for example, for locating a given value in an unordered table. When it is applicable, however, backtracking is often much faster than brute force enumeration of all complete candidates, since it can eliminate a large number of candidates with a single test.

Backtracking is an important tool for solving constraint satisfaction problems, such as crosswords, verbal arithmetic, Sudoku, and many other puzzles. It is often the most convenient (if not the most efficient) technique for parsing, for the knapsack problem and other combinatorial optimization problems.

Backtracking depends on user-given "black box procedures" that define the problem to be solved, the nature of the partial candidates, and how they are extended into complete candidates. It is therefore a metaheuristic rather than a specific algorithm - although, unlike many other meta-heuristics, it is guaranteed to find all solutions to a finite problem in a bounded amount of time.

Description of the method

The backtracking algorithm enumerates a set of partial candidates that, in principle, could be completed in various ways to give all the possible solutions to the given problem. The completion is done incrementally, by a sequence of candidate extension steps.

Conceptually, the partial candidates are the nodes of a tree structure, the potential search tree. Each partial candidate is the parent of the candidates that differ from it by a single extension step; the leaves of the tree are the partial candidates that cannot be extended any further.

The backtracking algorithm traverses this search tree recursively, from the root down, in depth-first order. At each node c, the algorithm checks whether c can be completed to a valid solution. If it cannot, the whole sub-tree rooted at c is skipped (pruned). Otherwise, the algorithm (1) checks whether c itself is a valid solution, and if so reports it to the user; and (2) recursively enumerates all sub-trees of c. The two tests and the children of each node are defined by user-given procedures.

Therefore, the actual search tree that is traversed by the algorithm is only a part of the potential tree. The total cost of the algorithm is the number of nodes of the actual tree times the cost of obtaining and processing each node. This fact should be considered when choosing the potential search tree and implementing the pruning test.

Pseudo code

In order to apply backtracking to a specific class of problems, one must provide the data P for the particular instance of the problem that is to be solved, and six procedural parameters, root, reject, accept, first, next, and output. These procedures should take the instance data P as a parameter and should do the following:

root(P): return the partial candidate at the root of the search tree.
reject(P,c): return true only if the partial candidate c is not worth completing.
accept(P,c): return true if c is a solution of P, and false otherwise.
first(P,c): generate the first extension of candidate c.
next(P,s): generate the next alternative extension of a candidate, after the extension s.
output(P,c): use the solution c of P, as appropriate to the application.

The backtracking algorithm reduces then to the call bt(root(P)), where bt is the following recursive procedure:

procedure bt(c)
     if reject(P,c) then return
     if accept(P,c) then output(P,c)
     s <- first(P,c)
     while s is not "the null candidate" do
         bt(s)
         s <- next(P,s)

(Note : the pseudo-code above will call output for all candidates that are a solution to the given instance P)

Usage considerations:

The reject procedure should be a boolean-valued function that returns true only if it is certain that no possible extension of c is a valid solution for P. If the procedure cannot reach a definite conclusion, it should return false. An incorrect true result may cause the bt procedure to miss some valid solutions. The procedure may assume that reject(P,t) returned false for every ancestor t of c in the search tree.

On the other hand, the efficiency of the backtracking algorithm depends on reject returning true for candidates that are as close to the root as possible. If reject always returns false, the algorithm will still find all solutions, but it will be equivalent to a brute-force search.

The accept procedure should return true if c is a complete and valid solution for the problem instance P, and false otherwise. It may assume that the partial candidate c and all its ancestors in the tree have passed the reject test.

Note that the general pseudo-code above does not assume that the valid solutions are always leaves of the potential search tree. In other words, it admits the possibility that a valid solution for P can be further extended to yield other valid solutions.

The first and next procedures are used by the backtracking algorithm to enumerate the children of a node c of the tree, that is, the candidates that differ from c by a single extension step. The call first(P,c) should yield the first child of c, in some order; and the call next(P,s) should return the next sibling of node s, in that order. Both functions should return a distinctive "null" candidate, denoted here by "the null candidate", if the requested child does not exist.

Together, the root, first, and next functions define the set of partial candidates and the potential search tree. They should be chosen so that every solution of P occurs somewhere in the tree, and no partial candidate occurs more than once. Moreover, they should admit an efficient and effective reject predicate.

(Source on wikipedia : http://en.wikipedia.org/wiki/Backtracking)

46.b Given an integer, return all sequences of numbers that sum to it. (Example: 3 -> (1, 2), (2, 1), (1, 1, 1))

I'm using here a backtracking method (rather to illustrate a simple case yet standard case of backtracking).
Implementation is in Java:

public class NumberSumSolver {
    
    final int targetNumber;

    private final Map<String, Boolean> printedSolMap = new HashMap<String, Boolean>();

    NumberSumSolver (int targetNumber) {
        this.targetNumber = targetNumber;
    }

    private void printSolutionIfNotAlready(int[] numberOfNumbers) {
        String key = Arrays.toString(numberOfNumbers);
        if (!printedSolMap.containsKey(key)) {
            printedSolMap.put (key, Boolean.TRUE);
            StringBuilder solBuild = new StringBuilder();
            boolean first = true;
            for (int i = 0; i < numberOfNumbers.length; i++) {
                if (numberOfNumbers[i] != 0) {
                    if (!first) {
                        solBuild.append (" + ");
                    }
                    solBuild.append (i + 1);
                    solBuild.append (" x ");
                    solBuild.append (numberOfNumbers[i]);
                    first = false;
                }
            }
            System.out.println (solBuild);
        }
    }

    public void printSumPossibilities() {
    
        int[] numberOfNumbers = new int[targetNumber - 1];
        for (int index = 0; index < targetNumber - 1; index++) {
            numberOfNumbers[index] = 0;
        }
    
        backtrack (targetNumber, numberOfNumbers);
    }

    private void backtrack(int targetSum, int[] numberOfNumbers) {
        if (reject (targetSum, numberOfNumbers)) {
            return;
        }
        if (accept (targetSum, numberOfNumbers)) {
            printSolutionIfNotAlready (numberOfNumbers);
        }
        for (int i = 0; i < numberOfNumbers.length; i++) {
            numberOfNumbers[i]++;
            backtrack (targetSum, numberOfNumbers);
            numberOfNumbers[i]--;
        }
    }

    private boolean reject(int targetSum, int[] numberOfNumbers) {
        int curSum = 0;
        for (int i = 0; i < numberOfNumbers.length; i++) {
            curSum += (i + 1) * numberOfNumbers[i];
        }
        return curSum > targetSum;
    }

    private boolean accept(int targetSum, int[] numberOfNumbers) {
        int curSum = 0;
        for (int i = 0; i < numberOfNumbers.length; i++) {
            curSum += (i + 1) * numberOfNumbers[i];
        }
        return curSum == targetSum;
    }        
    
    public static void main (String[] args) {
        new NumberSumSolver (9).printSumPossibilities ();
    }
}

The above can be optinmized a lot but I'm keeping it simple for illustrating the simpliest backtrack algorithm.
The problem is mostly that the tree of solution is a graph, several paths lead to the same solutions which are evaluated again and again. Hence the need of a Map to store the solution already reported.

I simple change into building the tree of solution enables us to build a true tree where the possibilities are not repeated:

public class NumberSumSolver {
        
    final int targetNumber;
        
    NumberSumSolver (int targetNumber) {
        this.targetNumber = targetNumber;
    }

    private void printSolutionIfNotAlready(int[] numberOfNumbers) {
        StringBuilder solBuild = new StringBuilder();
        boolean first = true;
        for (int i = 0; i < numberOfNumbers.length; i++) {
            if (numberOfNumbers[i] != 0) {
                if (!first) {
                    solBuild.append (" + ");
                }
                solBuild.append (i + 1);
                solBuild.append (" x ");
                solBuild.append (numberOfNumbers[i]);
                first = false;
            }
        }
        System.out.println (solBuild);
    }
        
    public void printSumPossibilities() {            
        int[] numberOfNumbers = new int[targetNumber - 1];
        for (int index = 0; index < targetNumber - 1; index++) {
            numberOfNumbers[index] = 0;
        }
            
        backtrack (targetNumber, 0, numberOfNumbers);
    }

    private void backtrack(int targetSum, int index, int[] numberOfNumbers) {
        if (reject (targetSum, index, numberOfNumbers)) {
            return;
        }            
        if (accept (targetSum, numberOfNumbers)) {
            printSolutionIfNotAlready (numberOfNumbers);
            return; // I know If I have a solution, any other on the same base cannot work
        }            
        for (int i = 0; i < targetSum; i++) {
            numberOfNumbers[index] = i;
            if (index + 1 < numberOfNumbers.length) {
                backtrack (targetSum, index + 1, numberOfNumbers);
            }
        }
        numberOfNumbers[index] = 0;
    }

    private boolean reject(int targetSum, int index, int[] numberOfNumbers) {
        int curSum = 0;
        for (int i = 0; i < numberOfNumbers.length; i++) {
            curSum += (i + 1) * numberOfNumbers[i];
        }
        return curSum > targetSum;
    }

    private boolean accept(int targetSum, int[] numberOfNumbers) {
        int curSum = 0;
        for (int i = 0; i < numberOfNumbers.length; i++) {
            curSum += (i + 1) * numberOfNumbers[i];
        }
        return curSum == targetSum;
    }
        
    
    public static void main (String[] args) {
        new NumberSumSolver (9).printSumPossibilities ();
    }
}

46.c. Given a set of coin denominators, find the minimum number of coins to give a certain amount of change.

Posing the problem

I would use an optimization method.

For instance let's assume we have coins of 5, 10, 20 and 50.
We're left with a classical optimization problem
min f(x) = x + y + z + a
u.c. 5x + 10y + 20z + 50a = amount

One can then optimize this problem with a branch-and-bound or branch-and-cut algorithm (both simplex based) that are discrete combinatory optimization algorithms.

Why greedy approach wouldn't work

Greedy approach (fill with bigger coins until no additional fits, then try with smaller) won't work.
See simple example:

coins = { 1, 10, 25 }
amount = 30

Greedy approach will choose 25 first and then five coins of value 1, i.e. 6 coins instead of simply 3 coins of 10.

SOLUTION: Using a simplier backtracking algorithm

We can also use recursion (with its run-time stack) to drive a backtracking algorithm. The general recursive backtracking algorithm for optimization problems (e.g., fewest number of coins) looks something like:

procedure Backtrack (recursionTreeNode p)
    treeNode c;
    for each child c of p do                           # each c represents a possible choice
        if promising(c) then                           # c is "promising" if it could lead to a better solution
            if c is a solution that's better than best then   # check if this is the best solution found so far
                best = c                               # remember the best solution
            else
                Backtrack(c)                           # follow a branch down the tree
            end if
        end if
    end for
end procedure

Implementation in Java:

public class CoinsRenderer {
        
    private final int changeAmt;
    private final int[] coinTypes;
    
    // global current state of the backtrack
    private int[] numberOfEachCoinType = null;
    private int numberOfCoinsSoFar = 0;
    private int bestFewestCoins = -1;
    private int[] bestNumberOfEachCoinType = null;
    
    public CoinsRenderer (int changeAmt, int[] coinTypes) {
        this.changeAmt = changeAmt;
        this.coinTypes = coinTypes;        
    }

    private void backtrack(int changeAmt) {        
        for (int index = coinTypes.length - 1; index >= 0; index--) {
            
            int smallerChangeAmt = changeAmt - coinTypes[index];
            if (promising(smallerChangeAmt, numberOfCoinsSoFar + 1)) {
                
                if (smallerChangeAmt == 0) { // a solution is found
                    // check if its best
                    if (bestNumberOfEachCoinType == null || numberOfCoinsSoFar + 1 < bestFewestCoins) {            
                        bestFewestCoins = numberOfCoinsSoFar + 1;                    
                        bestNumberOfEachCoinType = Arrays.copyOfRange(numberOfEachCoinType, 0, 
						        numberOfEachCoinType.length); 
                        bestNumberOfEachCoinType[index]++;
                    }
                } else {
                    // update global "current state" for child before call
                    numberOfCoinsSoFar++;
                    numberOfEachCoinType[index]++;
                    
                    backtrack(smallerChangeAmt);
                    
                    // undo change to global "current state" after backtracking
                    numberOfCoinsSoFar--;
                    numberOfEachCoinType[index]--;
                }
            }
        }
    }
    
    private boolean promising(int changeAmt, int numberOfCoinsReturned) {      
        if (changeAmt < 0) {           // dummy case
            return false;
        } else if (changeAmt == 0) {   // dummy case
            return true;
        } else {                       // changeAmt > 0            
            // This is simple : is the solution better than the one we have now (if we have one)?
            return bestNumberOfEachCoinType == null || numberOfCoinsReturned + 1 < bestFewestCoins;
        }
    }
    
    public int[] solve() {
        numberOfEachCoinType = new int[coinTypes.length];
        for (int index = 0; index < coinTypes.length; index++) {
            numberOfEachCoinType[index] = 0;
        }

        backtrack(changeAmt);
        return bestNumberOfEachCoinType;
    }
    
    public static void main (String[] args) {
        
        /*
        int changeAmt = 399; 
        int[] coinTypes = new int[] {1, 5, 10, 12, 25, 50};
        */        
        int changeAmt = 30; 
        int[] coinTypes = new int[] {1, 10, 25};
        
        int[] bestNumberOfEachCoinType = new CoinsRenderer(changeAmt, coinTypes).solve();
        
        System.err.println (changeAmt);
        System.err.println (Arrays.toString(coinTypes));
        System.err.println (Arrays.toString(bestNumberOfEachCoinType));
    }
}

This works and returns the correct number of coins for each case with minimum exploration (since it starts with the biggest coin, see reverse for loop):

30
[1, 10, 25]
[0, 3, 0]

399
[1, 5, 10, 12, 25, 50]
[0, 0, 0, 2, 1, 7]

47 Given an array of distinct integers, and a target integer t, compute all of the (continuous!) subsets of the array that sum to t, where order matters.

What about a standard backtrack approach ?

However with standard backtrack, the three of solution would be:

             ____________________[0>1]___________________
            /                                           \
      ___[0>2]___             ___[1>2]___           ___[2>2]___    ...
     /     |     \           /     |     \         /     |     \
   [0>3] [1>3] [2>3] ...   [1>3] [2>3] [3>3] ... [3>3] [4>3] [5>3] ...

Hence with a lot of duplicates...
In addition Backtracking here makes no sense since it is never possible to discard a branch of the three since further nodes on a branch can still make it to the target because the problem doesn't say that the list contains only positive integers.

If the list can contain as well negatove integers, then one needs to test all possibilities, a branch of solutions can never be discarded => backtracking is not appropriate.

if the problem is reduced to an array containing only positive integers, then backtracking is a good approach.

Here however, I am hence using a greedy solution:

private static class SubArraySolver {
        
    private final int[] original;
    private final int targetSum;
        
    SubArraySolver (int[] original, int targetSum) {
        this.original = original;
        this.targetSum = targetSum;
    }
        
    public void findAllSubArrays() {
        testAll (0);
    }
        
    private void testAll(int length) { 
        if (length > original.length) {
            return;
        }
        for (int i = 0; i < original.length - length; i++) {;               
            if (accept (i, length)) {
                printSolutionIfNotAlready (i, length);
            }
        }            
        testAll (length + 1);
    }

    private void printSolutionIfNotAlready(int start, int length) {
        System.out.println (Arrays.toString (Arrays.copyOfRange(original, start, start+length)));
    }

    private boolean accept(int start, int length) {
        int curSum = 0;
        for (int i = start; i < start + length; i++) {
            curSum += original[i];
        }
        return curSum == targetSum;
    }
    
    public static void findSubArrayWithSum (int[] array, int target) {
        new SubArraySolver (array, target).findAllSubArrays();
    }
    
    public static void main (String[] args) {
        findSubArrayWithSum(new int[]{1, 5, 3, 4, -1, -6, 4, 8, 2, 5, 4, -2, 8, 9, -3, 4}, 12);
    }
}

Which returns:

[4, 8]
[5, 3, 4]
[-2, 8, 9, -3]
[1, 5, 3, 4, -1]
[3, 4, -1, -6, 4, 8]
[-1, -6, 4, 8, 2, 5]

48. Given two binary trees, write a compare function to check if they are equal or not. Being equal means that they have the same value and same structure.

Simply use and of the Graph traversal algorithm. Run it on both trees at the same time and quit when the first difference is found.

One can use a modified version of inorder that stops when the first difference is found:

compare(node1, node2)
  if node1 == null and node2 == null then 
        return true
  if node1 == null or node2 == null then 
        return false
  subResult = compare(node1.left, node2.left)
  if (!subResult) then 
        return false
  if (node1.value != node2.value) then
        return false
  return compare(node2.right, node2.right)

49. Write a function that flips the bits inside a byte (either in C++ or Java).

Two solutions :

1. Use the XOR operator

byte ReverseByte(byte b) { return b ^ 0xff; }

2. Use byte after byte inversion

Java or C#:

byte ReverseByte(byte b)
{
     byte r = 0;
     for (int i=0; i < 8; i++)
     {
          int mask = 1 << i;
          int bit = (b & mask) >> i;
          int reversedMask = bit << (7 - i);
          r |= (byte)reversedMask;
     }
     return r;
}

50. What's 2 to the power of 64?

51. Given that you have one string of length N and M small strings of length L. How do you efficiently find the occurrence of each small string in the larger one?

First idea, somewhat brute force but not such bad since the source string is ran through only once:

int[M] findMatching (source, searches[M]) 
// returns index of last match of each search in source or -1
     int[M] return 
     int[M] temp 
     for j in 1 to M do
          return[j] <- 1
          temp[j] <- 1
     for i in 1 to nchar(source) do // char by char
          for j in 1 to length(searches) // every searched string
                search = searches[j]
                if search[0] == source[i] then
                     temp[j] = i
                else if temp[j] > -1
                     index = i - return[j];
                     if index > length(search) then
                          return[j] <- temp[j]
                     else
                          if search[index] != source[i] then
                                temp[j] = -1

In Java:

     static public int[] multipleSearch (String source, String[] searches) {
          int[] ret = new int[searches.length]; 
          int[] temp  = new int[searches.length]; 
          for (int j = 0; j < searches.length; j++) {
                ret[j] = - 1;
                temp[j] = - 1;
          }
          for (int i = 0; i < source.length(); i++) { // char by char
                for (int j = 0; j < searches.length; j++) { // every searched string
                     String search = searches[j];
                     if (search.charAt(0) == source.charAt(i)) {
                          temp[j] = i;
                     } else if (temp[j] > -1) {
                          int index = i - temp[j];
                          if (index >= search.length()) {
                                ret[j] = temp[j];
                          } else if (search.charAt(index) != source.charAt(i)) { 
                                temp[j] = -1;
                          }
                     }                
                }
          }
          return ret;
     }

This runs in time complexity O(m x n) and space complexity O(m)

52. Order the functions in order of their asymptotic performance: 1) 2^n 2) n^100 3) n! 4) n^n

53. Given an array whose elements are sorted, return the index of a the first occurrence of a specific integer. Do this in sub-linear time. I.e. do not just go through each element searching for that element.
[Binary Search algo]

Binary search is the way to go. See binary search.

If the list to be searched contains more than a few items (a dozen, say) a binary search will require far fewer comparisons than a linear search, but it imposes the requirement that the list be sorted. Similarly, a hash search can be faster than a binary search but imposes still greater requirements. If the contents of the array are modified between searches, maintaining these requirements may even take more time than the searches. And if it is known that some items will be searched for much more often than others, and it can be arranged that these items are at the start of the list, then a linear search may be the best.

Algorithms:

Recursive:

int binary_search(int A[], int key, int imin, int imax)
{
  // test if array is empty
  if (imax < imin):
     // set is empty, so return value showing not found
     return KEY_NOT_FOUND;
  else
     {
        // calculate midpoint to cut set in half
        int imid = midpoint(imin, imax);
 
        // three-way comparison
        if (A[imid] > key)
          // key is in lower subset
          return binary_search(A, key, imin, imid-1);
        else if (A[imid] < key)
          // key is in upper subset
          return binary_search(A, key, imid+1, imax);
        else
          // key has been found
          return imid;
     }
}

Iterative

int binary_search(int A[], int key, int imin, int imax)
{
  // continue searching while [imin,imax] is not empty
  while (imax >= imin)
     {
        /* calculate the midpoint for roughly equal partition */
        int imid = midpoint(imin, imax);
 
        // determine which subarray to search
        if        (A[imid] <  key)
          // change min index to search upper subarray
          imin = imid + 1;
        else if (A[imid] > key )
          // change max index to search lower subarray
          imax = imid - 1;
        else
          // key found at index imid
          return imid;
     }
  // key not found
  return KEY_NOT_FOUND;
}

54. What sort would you use if you had a large data set on disk and a small amount of ram to work with?

55. What sort would you use if you required tight max time bounds and wanted highly regular performance.

56. Three strings say A,B,C are given to you. Check weather 3rd string is interleaved from string A and B.
Ex: A="abcd" B="xyz" C="axybczd". answer is yes.

Use three pointers. Pointer on string C is advanced at each iteration. Then either the pointer on string a or the pointer on string b is advanced depending on what character is found. Whenever the value in string C doesn't match neither of the expected value, return false.

Here's some code in Java:

    public static boolean isInterleaved (String a, String b, String test) {
        
        int idxA = 0;
        int idxB = 0;
        
        for (int i = 0; i < test.length(); i++) {
            if (idxA < a.length() && test.charAt(i) == a.charAt(idxA)) {                
                idxA++;
            } else if (idxB < b.length() && test.charAt(i) == b.charAt(idxB)) {
                idxB++;
            } else {
                return false;
            }
        }
        if (idxA < a.length() || idxB < b.length()) {
            return false;
        }
        return true;
    }

57. Given a Binary Tree, Programmatically you need to Prove it is a Binary Search Tree

If the given binary tree is a Binary search tree,then the inorder traversal should output the elements in increasing order.We make use of this property of inorder traversal to check whether the given binary tree is a BST or not

One can modifiy iterativeInOrder this way:

isBST(node)
  prev = NULL
  parentStack = empty stack
  while not parentStack.isEmpty() or node != null
     if node != null then
        parentStack.push(node)
        node = node.left
     else
        node = parentStack.pop()
        if prev is not null then
            if prev > node.value then
                return false
        prev = node
        node = node.right
  return true

58. Given an arbitrarily connected graph, explain how to ascertain the reachability of a given node.

Use any traversal algorithm and :

either check whether the given node has been marked or not
or return as soon as the node is encountered

One can modifiy the BFS algorithm this way:

  procedure BFS(G,v,s): // s is the searched vertex
        create a queue Q
        enqueue v onto Q
        while Q is not empty:
             t <- Q.dequeue()
             if t == s then
                 return true
             for all edges e in G.adjacentEdges(t) do
                  u <- G.adjacentVertex(t,e)
                  if u is not marked:
                      mark u
                      enqueue u onto Q
        return false

59. You are given 1001 numbers in an array. There are 1000 unique numbers and 1 duplicate. How do you locate the duplicate as quickly as possible?

60. Given that you can take one step or two steps forward from a given step. So find the total number of ways of reaching Nth step.

61. If you have one billion numbers and one hundred computers, what is the best way to locate the median of the numbers?

62.a Implement multiplication (without using the multiply operator, obviously).

I would use binary multiplication.

One way : Repeated Shift and Add

(There are other ways)

Starting with a result of 0, shift the second multiplicand to correspond with each 1 in the first multiplicand and add to the result. Shifting each position left is equivalent to multiplying by 2, just as in decimal representation a shift left is equivalent to multiplying by 10.

    Set result to 0
    Repeat
        Shift 2nd multiplicand left until rightmost digit is lined up with leftmost 1 in first multiplicand
        Add 2nd multiplicand in that position to result
        Remove that 1 from 1st multiplicand
    Until 1st multiplicand is zero
    Result is correct

See following steps:

Source : http://courses.cs.vt.edu/~cs1104/BuildingBlocks/multiply.040.html

62.b Implement division (without using the divide operator, obviously).

I would use binary division.

Basically the reverse of the mutliply by shift and add.

    Set quotient to 0
    Align leftmost digits in dividend and divisor
    Repeat
        If that portion of the dividend above the divisor is greater than or equal to the divisor then
            subtract divisor from that portion of the dividend and
            Concatentate 1 to the right hand end of the quotient
        Else 
            concatentate 0 to the right hand end of the quotient
        Shift the divisor one place right
    Until dividend is less than the divisor
    quotient is correct, dividend is remainder

Source : http://courses.cs.vt.edu/~cs1104/BuildingBlocks/divide.030.html

63. You are given with three sorted arrays ( in ascending order), you are required to find a triplet (one element from each array) such that distance is minimum. Distance is defined like this : If a[i], b[j] and c[k] are three elements then distance=max(abs(a[i]-b[j]),abs(a[i]-c[k]),abs(b[j]-c[k])).
Please give a solution in O(n) time complexity.

KEJ IDEA : since the arrays are sorted : keep moving the pointers until the solution gets better, stop when no pointer move, neither left nor right, can make the solution any better

Solution from someone else:

I am not sure if this is correct, but it seems to be correct by intuition and intuitive testing, and works alright for a few test cases.
Its also o(n)


     public class NewMain {

          public static void main(String[] args) {
              
                int inp[] = {155, 160, 163, 170};
                int inp2[] = {160, 162, 172};
                int inp3[] = {143, 151, 159, 164, 167, 180};
              
                int i=0, j=0, k=0; //counters
                int min, max, minadd, maxadd;
                int mindist=100000, mini=0, minj=0, mink=0, tempdist=0;
              
                while(i < inp.length && j < inp2.length && k < inp3.length) {
                     min = inp[i];
                     minadd = i;
                    
                     if (inp2[j] < min) {
                          min = inp2[j];
                          minadd = j;
                     }
                     if (inp3[k] < min) {
                          min = inp3[k];
                          minadd = k;
                     }
                     max=inp[i];
                     maxadd = i;
                     if (inp2[j] > max) {
                          max=inp2[j];
                          maxadd = j;
                     }
                     if (inp3[k] > max) {
                          max = inp3[k];
                          maxadd = k;
                     }
                     if ((max - min) < mindist) {
                          mindist = max - min;
                          mini=i;
                          minj=j;
                          mink=k;
                     }
                     System.out.printf("%d %d %d %d %d\n", i,j,k, max-min, mindist);
                     if (inp[i]==min)
                          i++;
                     if (inp2[j]==min)
                          j++;
                     if (inp3[k]==min)
                          k++;                  
                }
                System.out.printf("%d\n%d\n%d\n", inp[mini], inp2[minj], inp3[mink]);              
          }
     }

Test cases:

int inp[] = {155, 160, 163, 170};
int inp2[] = {160, 162, 172};
int inp3[] = {3,9,15,21,25,31,40};
155
160
40
int inp[] = {155, 160, 163, 170};
int inp2[] = {160, 162, 172};
int inp3[] = {143, 151, 159, 164, 167, 180};
160
160
159
int inp[] = {100,200, 300};
int inp2[] = {151, 152, 152};
int inp3[] = {3,9,15,21,25,31,40};
100
151
40

Source : http://www.careercup.com/question?id=3796439

64. Given a binary search tree and an integer k, describe the most efficient way to locate two nodes of the tree that sum to k.

Key idea: use two pointers, one starting at lowest value, other starting at value k, move first to right, second to left (inOrder order) until value is found ... or not.

Example Tree:

                     15
                  /      \
              10          16
            /     \          \  
          5        12         20
         / \      /  \       /  \
        2    8   11   14    17  22

Solution:

     // input  : k
     
     //     note : in order to ease implementation of nextInOrder amd prevInOrder, 
     //            it might be required to build a tree with backlinks as initialization step (O(n))
     //            Othwerwise, une iterativeInOrder and return value following, resp. preceding
     //            search value.

     // init
     min = first node inOrder
     max = locate node in the tree that is either equal to k or the smallest that is greater than k
     
     doLoop = true
     
     // algo
     while doLoop do
     
          l = value(min) + value(max)
     
          if (max == min && l != k) then
                stop "ERROR : none found"
          end if
     
          if (l == k) then
                break // min and max sum to k          
          else if (l < k) then
                min = nextInOrder (min)
          else if (l > k) then
                max = prevInOrder (max)
          end if
     end do

Test values:

  k    :  10
  It   :  0    1    2    3    4    5    6
  min  :  2    2  
  max  :  10   8  
  l    :  12  10    DONE
  
  k    :  20
  It   :  0    1    2    3    4    5    6
  min  :  2    2    5    5    5
  max  :  20  17   17   16   15
  l    :  22  19   22   21   20    DONE
  
  k    :  18
  It   :  0    1    2    3    4    5    6
  min  :  2    2    2
  max  :  18  17   16
  l    :  20  19   18    DONE
         
  k    :  9
  It   :  0    1    2    3    4    5    6
  min  :  2    2    2    5
  max  :  10   8    5    5
  l    :  12   10   7   10    ERROR
         
  k    :  13
  It   :  0    1    2    3    4    5    6
  min  :  2    2    2
  max  :  14  12   11
  l    :  16  14   13    DONE

65. What is the KBL algorithm ?

66.a. You're given an array containing both positive and negative integers and required to find the subarray with the largest sum (O(N) a la KBL).

This is an all-time favorite software interview question. The best way to solve this puzzle is to use Kadane's algorithm which runs in O(n) time.
The idea is to keep scanning through the array and calculating the maximum sub-array that ends at every position. The sub-array will either contain a range of numbers if the array has intermixed positive and negative values, or it will contain the least negative value if the array has only negative values.

Here's some code to illustrate.

void maxSumSubArray( int *array, int len, int *start, int *end, int *maxSum )
{
     int maxSumSoFar = -2147483648;
     int curSum = 0;
     int a = b = s = i = 0;
     
     for( i = 0; i < len; i++ ) {
          curSum += array[i];
          if ( curSum > maxSumSoFar ) {
                maxSumSoFar = curSum;
                a = s;
                b = i;
          }
          if ( curSum < 0 ) {
                curSum = 0;
                s = i + 1;
          }
     }
     *start = a;
     *end = b;
     *maxSum = maxSumSoFar;
}

Testing it on some values:

Input     : array [ 1, 2, -6, 6, 17, 12, -4, 7, -8, -11, 12, -5, 3, 4, 16, -7, -8, 12, -4, 6]  
           (idx)    0  1   2  3   4   5   6  7   8    9  19  11 12 13  14  15  16  17  18 19
Feelings                      [    35  ]
                              [       38     ]
                                                         [      30      ]
                              [                            49           ]
                                                                          
Algo:
      i          : init    0    1    2    3    4    5    6    7    8    9   10  11  12  13  14  15  16  17  18  19
      array[i]   :         1    2   -6    6   17   12   -4    7   -8  -11   12  -5   3   4  16  -7  -8  12  -4   6
      a          :         0    0    0         3    3    3         3                                     3
      b          :         0    0    1         3    4    5         7                                    14
      s          :         0              3
   curSum (bef.) :    0    1    3   -3    6   23   35   31   38   30   19   31  26  29  33  49  42  34  46  42  48
   curSum (aft.) :         0    1    3    0  
  maxSumSoFar    :  -..    1         3    6   23   35        38                             49
       BEST      :                                                                          |

66.b. Given an array, find the longest continuous(!) increasing subsequence.
Not to be confused with problem 25.c which releases the "continuous" constraint.

We can do better than backtracking (O(n^2)) in the worst case.

We can use a variant of Kadane's algorithm which runs in O(n) time.
The idea consists simply in moving the pointer from the beginning to the end of the array, incrementing the size of the longest increasing continuous sequence as long as the number increase and restarting the sequence collection as soon as a decreasing number is encountered.

Algorithm looks this way:

    public static int[] findLongestContinousIncreasingSequence(int[] array) {
        
        int start = 0;
        
        int bestStart = 0;
        int bestEnd = 1;
        int bestSize = 1;
        
        for (int i = 1; i < array.length; i++) {
            if (array[i] > array[i - 1]) {
                if (i - start + 1 > bestSize) {
                    bestSize = i - start + 1;
                    bestStart = start;
                    bestEnd = i + 1;
                }                
            } else {
                start = i;
            }
        }
        
        return Arrays.copyOfRange(array, bestStart, bestEnd);
    }
    
    public static void main (String[] args) {
        System.out.println (Arrays.toString (findLongestContinousIncreasingSequence(
		         new int[]{1, 5, 3, 4, -1, -6, 4, 8, 2, 5, 4, -2, 8, 9, 12, -3, 4})));
    }

Which returns:

[-2, 8, 9, 12]

67. Given an array of characters which form a sentence of words, give an efficient algorithm to reverse the order of the words (not characters) in it.

First idea in O(n) time O(n) space

Loop through space and stack words (O(n)) then unstack until stack is empty (O(n) worst case)

Second idea in O(n) time O(1) space ... well not really O(1) space

browse input string until a space is found.
string so far is a word
recursively call function on end of string and append word to result

Java code:

     public static String reverseString (String source) {
          for (int i = 0; i < source.length(); i++) {
                if (source.charAt(i) == ' ') {
                     if (i < source.length() + 1) {
                          return reverseString (source.substring(i + 1)) + ' ' + source.substring(0, i);
                     }
                     break;
                }
          }
          return source;
     }

Note This is not really O(1) space, but O(n) since it uses function calls on the stack as a memory.

68.a. Fastest algorithm or way to check a X's and 0's game (i.e. TIC TAC TOE) board.

68.b. In a X's and 0's game (i.e. TIC TAC TOE) if you write a program for this give a fast way to generate the moves by the computer. I mean this should be the fastest way possible.

One approach is that you need to store all possible configurations of the board and the move that is associated with that. Then it boils down to just accessing the right element and getting the corresponding move for it. Do some analysis and do some more optimization in storage since otherwise it becomes infeasible to get the required storage in a DOS machine.

A tree storing all possible games with positions played each time would take this much storage: 9! = 362'880 nodes. One could then ask at each level of the tree which of the subtree has the max count of wining games and then choose the next move accordingly.
(count of wining games for a node is the sum of the count of wining games of each of its sub-trees or 1 if the node is a wining game itself)
This seems to be the fastest possible way yet by sacrificing the required storage.

My idea that optimizes storage as much as possible is to store each possible game this way : 01010101, i.e. 9 positions of 0 or 1 for O or X. The problem with this is that it doesn't store the order of each play. An exact approach
An algorithm could then run this way (somewhat probabilistic approach)

- At each move
     - Find all games mathing current start game 

      (all of them at first)
    - In these games, find all games in which I am victorious
      (since all board are always completely filled, i consider victorious games where I have the single line 
	  or games where I have more lines that the opponent)
    - In all these games, find my position that comes most often (find the byte that it is the most often set)
    - Play that move

69. There are 3 ants at 3 corners of a triangle, they randomly start moving towards another corner.. what is the probability that they don't collide.

The probability is 25% because there are 3 ants all with two possible paths and 8 total possible outcomes. But there are two possible outcomes that the ants don't collide. Either they move one way or the other. 2/8 = 25%.

Each ant can move in 2 directions. Lets say direction are Left (L) and Right (R). Solution if all ants move either towards L or R. For L (1/2 * 1/2 * 1/2) = 1/8. Same for R = 1/8. Total for L and R = 1/8 + 1/8 = 1/4.

Provided as example:

                      A
                    0/ \1
                    /   \
                   /     \
                 1/       \0  
                  B0-----1C

Karnaugh table is as follows

ABC  | Collide ?
----------------
000  |  0
001  |  1
010  |  1
011  |  1
100  |  1
101  |  1
110  |  1
111  |  0

Which confirms: there are 2/8 = 1/4 chance they don't collide while they collide 6/8 = 3/4 times.

70. There are 4 men who want to cross a bridge. They all begin on the same side. You have 17 minutes to get all of them across to the other side. It is night. There is one flashlight. A maximum of two people can cross at one time. Any party who crosses, either 1 or 2 people, must have the flashlight with them. The flashlight must be walked back and forth, it cannot be thrown, etc. Each man walks at a different speed. A pair must walk together at the rate of the slower mans pace.
Man 1: 1 minute to cross
Man 2: 2 minutes to cross
Man 3: 5 minutes to cross
Man 4: 10 minutes to cross

a) 1 and 2 cross together    : 3,4     -> 1,2      - 2 min
b) 1 comes back              : 1,3,4   <- 2        - 1 min
c) 3 and 4 cross together    : 1       -> 2,3,4    - 10 min
d) 2 comes back              : 1,2     <- 3,4      - 2 min
e) 1 and 2 cross together    :         -> 1,2,3,4  - 2 min

71. Give a one-line C expression to test whether a number is a power of 2. (No loops allowed - it's a simple test.)

First idea:

2^x = n => x = log_2 (n)
Then, if n is a power of 2, then x is an integer
if x is integer then x % 1 = 0

One can then use 2^((int)log_2(n)) == n as a condition.

Better: (no need to use a log_2 function in C)

A power of 2 has only one bit set to 1 and all other to 0 (also value intger 1 which need to be checked).
Let's name x that power of 2.

In this case, the value (x - 1) has other bytes set to 1, always. It never has the same byte set to 1.
hence x & (x - 1) == 0, always (& = "bitwise and").

Examples:

          x = 0010 0000 = 32
        x-1 = 0001 1111 = 31
x & (x - 1) = 0000 0000 = 0

          x = 0000 1000 = 8
        x-1 = 0000 0111 = 7
x & (x - 1) = 0000 0000 = 0

Counter examples (for numbers not a power of 2)

          x = 0110 0000 = 96
        x-1 = 0101 1111 = 95
x & (x - 1) = 0100 0000 = 0

          x = 0000 0110 = 6
        x-1 = 0000 0101 = 5
x & (x - 1) = 0100 0000 = 0

We can hence come up with a one-line expression this way: ((n > 1) && !(n & n-1))

Source : http://answers.yahoo.com/question/index?qid=20080711094134AAyQ2vg

72. Give a very good method to count the number of ones in a 32 bit number.

Solution A

Brian Kernighan's method goes through as many iterations as there are set bits. So if we have a 32-bit word with only the high bit set, then it will only go once through the loop.

long count_bits(long n) {      
     unsigned int c;    // c accumulates the total bits set in v
     for (c = 0; n; c++) 
          n &= n - 1;   // clear the least significant bit set
     return c;
}

Note that this is a question used during interviews. The interviewer will add the caveat that you have "infinite memory". In that case, you basically create an array of size 232 and fill in the bit counts for the numbers at each location. Then, this function becomes O(1).

Solution B (easier to understand)

In my opinion, the "best" solution is the one that can be read by another programmer (or the original programmer two years later) without copious comments. You may well want the fastest or cleverest solution which some have already provided but I prefer readability over cleverness any time.

unsigned int bitCount (unsigned int value) {
     unsigned int count = 0;
     while (value > 0) {          // until all bits are zero
          if ((value & 1) == 1)   // check lower bit
                count++;
          value >>= 1;            // shift bits, removing lower bit
     }
     return count;
}

73. Given two strings S1 and S2. Delete from S2 all those characters which occur in S1 also and finally create a clean S2 with the relevant characters deleted.

First naive idea

First naive idea consists in O(m x n) looping through the first string, then through the second string, deleting every character that appears.
Hence the following code in C:

void trimString() {

     char s1[] = "hello world";
     char s2[] = "el";
     int i, j;
     
     for (i = 0; i < (signed)strlen(s1); i++) {
          for (j = 0; j < (signed)strlen(s2); j++) {
                if (s1[i] == s2[j]) {
                     s1[i] = -1;
                     break;
                }
          }
     }
     
     for (i = 0, j = 0; i < (signed)strlen(s1); i++) {
          if (s1[i] != -1) {
                s1[j] = s1[i];
                j++;
          }
     }
     s1[j] = '\0';
     printf("\nString is%s", s1);
}

Better idea using a hastable

Since you are looking for characters only, we can try using a hash table of size 256. One should note that it's not exactly a hash table since we have as many entries as elements in the table and the hash function is rather returning the element itself.

char *DeleteAndClean (char *s1, char *s2) {
     char hash[256];
     int i;
     
     for(i = 0; i < 256; i ++) 
          hash[i] = 0; // Init Hash
    
     char *t = s1;
     while (*t) {
          hash[*t] = 1; // populate hash
          t++;
     }

     size_t count = 0;
     size_t cleanlen = 0
     
     // Iteration 1: compute length of result string
     t = s2;
     while (*t) {         
          if (hash[*t] == 1)
                count++;
          else
                cleanlen++;
          t++;
     }
    
     cleanlen++; // Include space for null Terminator
     if (count == 0) 
          return strdup(s2);

     // dynamically allocate new space for result
     char* clean = (char*) malloc(sizeof(char) * cleanlen);
    
     if (!clean) 
          throw out_of_mem_exception;
     t = s1;

     // Iteration 2: build result
     while (*t) {
          if (hash[*t] == 0)
                *clean++ = *t;
          t++;
     }

     *clean = '\0';
     return clean;
}

Should the additional memory required to return the value be an issue (since it's O(n) space), one can use the same idea than in the former algorithm and use a destructive approach on the string given as argument.

74. Determine the 10 most frequent words given a terabyte of strings.

75.a Given only putchar (no sprintf, itoa, etc.) write a routine putlong that prints out an unsigned long in decimal.

There are two problems to be solved:

the long value must be decomposed in each of its decimal position for them to be printed individualy
A decimal (0-9) must be converted to a char in order to be printed with put char

These two problems are easily solved this way:

Either an iterative (using an array) or a recursive (discarding the need of an array in favor of a usage of the stack) to decompose the long number. Use division by 10 and remainder (modulo) to proceed with the decomposition
Converting a [0-9] number to a char in ASCII or UTF-8 is easy. One only needs to add the ASCI number mathing '0' to the decimal number and one gets the ASCII number of the decimal number (No need to know where the numbers start in the ASCII sequence).

Hence the following code in C:

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

void printInt(unsigned long x){
    if (x > 10){
        printInt(x / 10);
    }
    //putchar(x % 10 + '0'); // Both will work fine
    putchar(x % 10 + 48);
}

int main(){
     long int a;
     printf(" Enter integer value : ");
     scanf("%d",&a);
     printf("\n");
     printInt(a);
     return 0;
}

75.b. Write a function to convert an int to a string.

Very similar to the problem above. The very same approach can be used.

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

void toString(unsigned long x, char* result){
    if (x > 10){
        toString(x / 10, result);
    }
    int len = strlen(result);
    result[len] = (x % 10) + '0';
    result[len + 1] = \0;
}

76. How many points are there on the globe where by walking one mile south, one mile east and one mile north you reach the place where you started.

77. You have a cycle in linked list. Find it. Prove that time complexity is linear. Also find the node at which looping takes place.

Another way the question is asked is "How can you find out if there is a loop in a very long list?"

Browse the list marking each node as visited. Stop whenever a node is encountered that is already marked (there is the loop). If the end of the list is reached then there is no loop.

Add one boolean field in structure of node as visited and initialised it will FALSE. Now start travesing the list and upon next element visit, make this boolean filed as true and before making it as true check if it is already TRUE or not. In case if it is true than there is certainly loop.

while (current ->next != NULL) do
    if (current->visited == TRUE) then
        printf("LOOP in LL found");
        break;
    else
        current->visited = TRUE;
        current = current->next;
    end if
end do

This runs in O(n).

Whenever this list structure cannot be modified, use a hash table or a B-Tree to store the visited flag.
In this case the algorithm becomes O(n log n)

78.a. Reverse each bit in a number.

This is as easy as XORing the number with a mask made only of 1s.

For instance for a 32 bits integer:

unsigned int n = 12345..;
unsigned int mask = 0xFFFFFFFF;
unsigned int result = n ^ mask;

78.b. How would you reverse the bits of a number with log N arithmetic operations, where N is the number of bits in the integer (eg 32,64..)

79. A character set has 1 and 2 byte characters. One byte characters have 0 as the first bit. You just keep accumulating the characters in a buffer.
Suppose at some point the user types a backspace, how can you remove the character efficiently.
(Note: You can't store the last character typed because the user can type in arbitrarily many backspaces)

80. What's the simplest way to check if the sum of two unsigned integers has resulted in an overflow.

1. First idea : actually do the operation and check result

If adding both numbers result in an overflow, then the result is necessarily below both numbers.
(Let's imagine INT_MAX_VALUE = 10, then 9 + 2 = 11 => 1 with 1 < 9 and 1 < 2)

One can hence use the following code:

uint32_t x, y;
uint32_t value = x + y;
bool overflow = value < x; // Alternatively "value < y" should also work

2. Second idea : no need to actually perform the comparison but need to have access to MIN/MAX_VALUE constants

unsigned int si1, si2, sum;
 
/* Initialize si1 and si2 */
 
if (  si1 > (INT_MAX - si2)) {
   /* handle error condition */
} else {
  sum = si1 + si2;
}

For signed integers : the solution is only a little more complicated:

signed int si1, si2, sum;
 
/* Initialize si1 and si2 */
 
if (   ((si2 > 0) && (si1 > (INT_MAX - si2)))
    || ((si2 < 0) && (si1 < (INT_MIN - si2)))) {
   /* handle error condition */
} else {
  sum = si1 + si2;
}

Source : http://www.fefe.de/intof.html
and http://stackoverflow.com/questions/199333/best-way-to-detect-integer-overflow-in-c-c

81. Devise an algorithm for detecting whether a given string is a palindrome (spelled the same way forwards and backwards).
For example, "A man, a plan, a canal, Panama."

This is simple. One only need to browse the string with a pointer from start forward and from end backward.
Whenever a character is encountered, make sure both pointers point to the same character (case insensitive)

Hence the following algorithm in Java:

    static public boolean isPalindrome (String s) {
        
        int len = s.length();
        
        int start = 0;
        int end = len - 1;
        
        while (true) {
            
            // stop condition
            if (start >= end) {
                return true;
            }
            
            char charStart = 0;
            do {
                charStart = Character.toLowerCase(s.charAt(start++));
                if (start >= len) {
                    return true;
                }
            } while (   charStart == ' ' || charStart == ',' || charStart == '.' 
			                || charStart == '\'' || charStart == '\n');
            
            char charEnd = 0;
            do {
                charEnd = Character.toLowerCase(s.charAt(end--));
                if (end < 0) {
                    return true;
                }
            } while (   charEnd == ' ' || charEnd == ',' || charEnd == '.' 
			                || charEnd == '\'' || charEnd == '\n');
            
            if (charStart != charEnd) {
                return false;
            }
        }
    }

Running in time complexity O(n) and space complexity O(1).

82. Write a function to find the depth of a binary tree.

The depth of a tree is the maximum of the depth of its sub-trees plus 1 for the root node. A recursive approach makes more sense.

hence the following pseudo-code:

function depth (tree)
    if tree is NULL then
        return 0
    end if
    depthLeft = depth (tree.left)
    depthRight = depth (tree.right)
    if depthLeft > depthRight then
        return depthLeft
    else 
        return depthRight
    end if

Runs in time complexity O(n) and space complexity O(1).

83. Besides communication cost, what is the other source of inefficiency in RPC?

84.a. An array of integers of size n. Generate a random permutation of the array, given a function rand_n() that returns an integer between 1 and n, both inclusive, with equal probability.

There is an algorithm in O(n) to solve this known as the Fisher - Yates shuffle algorithm. The version of this algorithm used today has been popularized by Donald E. Knuth in volume 2 of his book The Art of Computer Programming as "Algorithm P".

Pseudo-code is as follows:

To shuffle an array a of n elements (indices 0..n-1):
  for i from n - 1 downto 1 do
       j <- random integer with 0 <= j <= i
       exchange a[j] and a[i]

There is an implementation of that algorithm in Java in Collections.shuffle() (simplified):

    public static void shuffle(List<?> list, Random rnd) {
        int size = list.size();

        Object arr[] = list.toArray();

        // Shuffle array
        for (int i=size; i>1; i--)
            swap(arr, i-1, rnd.nextInt(i));

        // Dump array back into list
        ListIterator it = list.listIterator();
        for (int i=0; i < arr.length; i++) {
            it.next();
            it.set(arr[i]);
        }
    }

    public static void swap(List<?> list, int i, int j) {
        list.set(i, list.set(j, list.get(i)));
    }

Runs in time complexity O(n) and space complexity O(1).

Source : http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle

84.b. Write an efficient algorithm and C code to shuffle a pack of cards

85a. Assuming that locks are the only reason due to which deadlocks can occur in a system. What would be a foolproof method of avoiding deadlocks in the system ?

A deadlock occurs when a set of concurrent workers are waiting on each other to make forward progress before any of them can make forward progress. If this sounds like a paradox, it is. There are four general properties that must hold to produce a deadlock:

Mutual Exclusion: When one thread owns some resource, another cannot acquire it. This is the case with most critical sections, but is also the case with GUIs in Windows. Each window is owned by a single thread, which is solely responsible for processing incoming messages; failure to do so leads to lost responsiveness at best, and deadlock in the extreme.
A Thread Holding a Resource is Able to Perform an Unbounded Wait For example, when a thread has entered a critical section, code is ordinarily free to attempt acquisition of additional critical sections while it is held. This typically results in blocking if the target critical section is already held by another thread.
Resources Cannot be Forcibly Taken Away From Their Current Owners In some situations, it is possible to steal resources when contention is noticed, such as in complex database management systems (DBMSs). This is generally not the case for the locking primitives available to managed code on the Windows platform.
A Circular Wait Condition A circular wait occurs if chain of two or more threads is waiting for a resource held by the next member in the chain. Note that for non-reentrant locks, a single thread can cause a deadlock with itself. Most locks are reentrant, eliminating this possibility.

Let's have two ressources A and B and two threads that need a lock on these ressources. The following conditions can be identified:

  T1 lock A then B / T2 lock A then B -> OK (no cycle)
  T1 lock A then B / T2 lock B then A -> potential DEADLOCK !

Two general strategies are useful for dealing with critical-section-based deadlocks.

Avoid Deadlocks Altogether Eliminate one of the aforementioned four conditions. For example, you can enable multiple resources to share the same resource (usually not possible due to thread safety), avoid blocking altogether when you hold locks, or eliminate circular waits, for example. This does require some structured discipline, which can unfortunately add noticeable overhead to authoring concurrent software.
Detect and Mitigate Deadlocks Most database systems employ this technique for user transactions. Detecting a deadlock is straightforward, but responding to them is more difficult. Generally speaking, deadlock detection systems choose a victim and break the deadlock by forcing it to abort and release its locks. Such techiques in arbitrary managed code could lead to instability, so these techniques must be employed with care.
Avoiding Deadlocks with Lock Leveling: A common approach to combating deadlocks in large software systems is a technique called lock leveling (also known as lock hierarchy or lock ordering). This strategy factors all locks into numeric levels, permitting components at specific architectural layers in the system to acquire locks only at lower levels. For example, in the original example, I might assign lock A a level of 10 and lock B a level of 5. It is then legal for a component to acquire A and then B because B's level is lower than A's, but the reverse is strictly illegal. This eliminates the possibility of deadlock.

85.b. What is the difference between a live-lock and a deadlock ?

86. Give a good data structure for having n queues ( n not fixed) in a finite memory segment. You can have some data-structure separate for each queue. Try to use at least 90% of the memory space.

Linked list

I believe the best data structure is a Linked List, linked with pointers.

Dynamic memory allocation comes in help here. Using a simple structure like

struct node {
    Type data;
    struct node next;
};

Here any number of lists or queues can be created in the finite memory segment using dynamic memory allocation. Every queue is simply represented by two pointers, the head of the queue and the current tail of the queue.
Whenever a new element needs to be aded to a queue, a new struct instance is allocated in te hfinit memory segment, the next pointer of the current last element is updated to point to it and finally the tail pointer is updated.

The problem here is that it is inneficient in terms of memory consumption because of the overhead required to store all pointers.

Hybrid solution

This memory consumtion efficiency problem can be solved (at least a little) by using an hybrid approach. Every 10 elements of each queue is stored in an array. Each array is stored in a structure along with a pointers pointing on the next 10 elements array.
Hence a structure this way:

struct node {
    Type data[10];
    struct node next;
};

This way, instead of having potentially only 50% elements and 50% pointers in the finite memory segment, we can achieve 90% elements and only 10% pointers in the finite memory segment.

This is pretty appropriate for a queue where elements are always added to the tail but would be unneffective for a list with random insertion and deletions.

87. Say you are implementing exponentiation for a certain processor. How would you minimize the number of multiplications required for this operation?

88. You have given an array. Find the maximum and minimum numbers in less number of comparisons.

I assume the array is unsorted (if it is sorted, just take first and last element).

There isn't any reliable way to get the minimum/maximum without testing every value. You don't want to try a sort or anything like that, walking through the array is O(n), which is better than any sort algorithm can do in the general case.

Naive algorithm

The naive algorithm is too loop and update min, max.

Recursive solution

A recursive solution will require less comparisons than naive algorithm, if you want to get min, max simultaneously

struct MinMax{
   public int min,max;
}

MinMax FindMinMax(int[] array, int start, int end) {
   if (start == end)
      return new MinMax { min = array[start], max = array[start] };

   if (start == end - 1)
      return new MinMax { min = Math.Min(array[start], array[end]), max = Math.Max(array[start], array[end]) } ;

   MinMax res1 = FindMinMax(array, start, (start + end)/2);
   MinMax res2 = FindMinMax(array, (start+end)/2+1, end);

   return new MinMax { min = Math.Min(res1.Min, res2.Min), max = Math.Max(res1.Max, res2.Max) } ;
}

This isn't necessarily faster due to function call overhead, not to count the memory allocation.

Best solution : iterative solution

Then there is an algorithm that finds the min and max in 3n/2 number of comparisons. What one needs to do is process the elements of the array in pairs. The larger of the pair should be compared with the current max and the smaller of the pair should be compared with the current min. Also, one needs take special care if the array contains odd number of elements.

struct MinMax{
   int min,max;
}

MinMax FindMinMax(int[] array, int start, int end) {
   MinMax  min_max;
   int index;
   int n = end - start + 1;//n: the number of elements to be sorted, assuming n>0
   if ( n%2 != 0 ){// if n is odd

     min_max.min = array[start];
     min_max.max = array[start];

     index = start + 1;
   }
   else{// n is even
     if ( array[start] < array[start+1] ){
       min_max.min = array[start];
       min_max.max = array[start+1];

       index = start + 2;
   }

   int big, small;
   for ( int i = index; i < n-1; i = i+2 ){
      if ( array[i] < array[i+1] ){ //one comparison
        small = array[i];
        big = array[i+1];
      }
      else{
        small = array[i+1];
        big = array[i];
      }
      if ( min_max.Min > small ){ //one comparison
        min_max.min = small;
      }
      if ( min_max.Max < big ){ //one comparison
        min_max.max = big;
      }
   }

   return min_max;
}

It's very easy to see that the number of comparisons it takes is 3n/2. The loop runs n/2 times and in each iteration 3 comparisons are performed. This is probably the optimum one can achieve.

89. You have five pirates, ranked from 5 to 1 in descending order. The top pirate has the right to propose how 100 gold coins should be divided among them. But the others get to vote on his plan, and if fewer than half agree with him, he gets killed.
How should he allocate the gold in order to maximize his share but live to enjoy it? (Hint: One pirate ends up with 98 percent of the gold.)

Intuitive approach

Only half of the pirates should agree to the plan for the leader not to be killed. Here there are 5 pirates, so 3 pirates should agree to the plan.

Hence intuitively, the leader should propose to two other pirates to share the loot. He keeps 34 to himself and offers two other pirates 33 each.

Solution

The given hints states that one pirate ends up with 98% of the gold.
In this case, I assume that the leader keeps 98 gold coins and gives two other pirates 1 gold coind each. Since one gold coin is better than nothing, the two pirates accepts the plan and the leader survives.

Assumptions

A few assumptions are required to explain this solution:

First, assume that if the Pirate 5 (the top pirate) is voted down and gets killed, then the remaining pirates retain their rankings and continue the game, with Pirate 4 now in charge. If Pirate 4 is killed, then Pirate 3 is in charge, and so on.
Second, assume that any vote includes the person who proposed the plan (the top pirate), and a tie vote is enough to carry the plan.
Third, assume that all pirates are acting rationally to maximize the amount of gold they receive, and are not motivated by emotion or vindictiveness.
Fourth, assume that pirates are ruthless and cannot be trusted to collaborate with each other.

Generalized answer is

If there are odd number of pirates then
    the number of coins with top pirate = total number of coins - number of odd numbers below the number.
else
    the number of coins with top pirate = total number of coins - number of even numbers below the number.

90. Every man in a village of 100 married couples has cheated on his wife. Every wife in the village instantly knows when a man other than her husband has cheated, but does not know when her own husband has. The village has a law that does not allow for adultery. Any wife who can prove that her husband is unfaithful must kill him that very day. The women of the village would never disobey this law. One day, the queen of the village visits and announces that at least one husband has been unfaithful. What happens?

91. What is the birthday paradox ?

92.a What method would you use to look up a word in a dictionary?

92.b. How would you store 1 million phone numbers?

At first sight, a trie seems interesting since it offers classification and simple retrieval.

A trie, also called digital tree or prefix tree, is an ordered tree data structure that is used to store a dynamic set or associative array where the keys are usually strings. Unlike a binary search tree, no node in the tree stores the key associated with that node; instead, its position in the tree defines the key with which it is associated. All the descendants of a node have a common prefix of the string associated with that node, and the root is associated with the empty string. Values are normally not associated with every node, only with leaves and some inner nodes that correspond to keys of interest. For the space-optimized presentation of prefix tree, see compact prefix tree.

The problem with a trie comes from the space overhead since it requires O(n log n) space to store the pointers.

However, there are rules for engagement when dealing with phone numbers. They're sparse, for one, meaning not all possible area codes are used. In this case, a simple tree is a-ok. I mean think about it... you only need 269 + 26 for Canada. That's pretty small, and you've cut out a large portion of space PLUS increased search time. Not only that, but it can be augmented for location information.

After that, you've got a 7 digit number. This can be stored in a single 32-bit integer. Sort on insert, and you've got a pretty fast mechanism for retrieval as you can do binary search on the remainder of the number.

In java, an implementation I would look into a BitSet:

private BitSet dir = new BitSet(1000000);

public void addTelephoneNumber(int number) {
     dir.set(number);
}

public void removeTelephoneNumber(int number) {
     if (dir.get(number)) {
          dir.flip(number);
     }
}

public boolean isNumberPresent(int number) {
     return dir.get(number);
}

93. Describe an API for a cache, with all of the associated function signatures. Provide pseudocode for the simple one.

I would suggest a typical Hash Table interface since a cache is nothing more regarding its APIs. The bug difference is that a cache is bounded in terms of size.
It has a maximum size with an eviction method (either LRU or LFU).

In addition, a lot of cache implementation support artificial eviction of elements from the cache using:

Maximum Idle Time: the maximum duration (typically in secs or millisecs) before an element in the cache that hasn't been used any more is removed from the cache.
Maximum Time To Live: the absolute maximum time an element is allowed to be kept in the cache before its is removed (no mather whether it has been used or not)

I would hence suggest as typical API this way (using a Java interface):

public interface Cache<TKey, TObj> {

    void put (Tkey, TObj);

    TObj get (Tkey);

    boolean contains (Tkey);
}

In case of an LRU cache, one could implement get and put this way, usingf pseudo code:
(I asume here we are using both MAX_IDLE_TIME, MAX_TIME_TO_LIVE

    procedure get (tKey)
        if underlyingMap contains tKey then // one should better get object and compare with null
            lastUsedTime = getLastUsedTimestamp (tKey)
            currentTime = getCurrentTime()
            if lastUsedTime + MAX_TIME_TO_IDLE < currentTime then
                cachePutTime = getPutInCacheTimeStamp (tkey)
                if cachePutTime + MAX_TIME_TO_LIVE < currentTime then
                    return underlyingMap.get (tKey)
                end if
            end if
            // I assume cache eviction following time limits is passive
            // If I reach this point I can get rid of the element anyway
            removeFromCache (tKey) // needs to remove tStamps as well
        end if
        return NULL;
   end proc

   procedure put (tkey, tObj)
       underlyingMap.put (tkey, tObj)
       currentTime = getCurrentTime()
       saveLastUsedTimeStamp (tKey, currentTime)
       savePutInCacheTimeStamp (tKey, currentTime)
       if (underlyingMap.size() > MAX_CACHE_SIZE) then
           removeLeastRecentlyUsed()
       end if
   end proc

94.a. Implement a special type of integer iterator. It will be a wrapper over a regular integer iterator, except that this iterator will only iterate over negative numbers.
Show how you'd write the next() and hasNext() functions to work with the next negative integer instead of just the next integer.

One can generalize this to a filtering iterator.
A simplified version of a filtering iterator is as follows:

public abstract class FilteringIterator<Type> implements Iterator<Type> {

    private Iterator<Type> model = null;
    private Type prefetched = null;

    public FilteringIterator(Iterator<Type> model) {
        this.model = model;
    }

    public boolean hasNext() {

        if (this.prefetched != null) {
            return true;
        }
        
        // so, prefetched == null
        while (model.hasNext()) {
            Type o = model.next();
            if (this.shouldShow(o)) {
                this.prefetched = o;
                return true;
            }
        }
        
        return false;        
    }

    public Type next() {
        if (this.prefetched == null && !this.hasNext()) { // has next will set prefetched for the below
            throw new NoSuchElementException();
        }        
        Type ret = this.prefetched;
        this.prefetched = null;
        return ret;
    }

    protected abstract boolean shouldShow(Type o);
}

Then one is left with implementing the filter method shouldShow() this way:

    protected boolean shouldShow(Integer o) {
        return o.intValue() < 0;
    }

94.b. How would you implement an Iterator for Binary tree inOrder traversal

The idea consists in merging the iterative inOrder algorithm with the next() method of the iterator:

The "visit" operation consists in stopping the inOrder iteration and returning the result.
Upon a call to next, resume the inOrder algorithm iterations.

Assuming a tree node is defined with:

node.left
node.information
node.right

One can write it this way in Java

public class InOrderIterator<E extends Comparable<? super E>> implements Iterator<E> {
    
    private LinkedList<Node<E>> parentStack = new LinkedList<Node<E>>();    
    private Node<E> node = null;    
    private E current = null; 
    
    public InOrderIterator (Node root) {
        this.node = root;
        fetchNext();
    }

    public boolean hasNext() {
        return current != null;
    }

    public E next() {
        E retValue = current;
        
        if (parentStack.isEmpty() && node == null) {
            current = null;
        }
                
        fetchNext();

        if (retValue != null) {
            return retValue;
        } else {        
            throw new NoSuchElementException();
        }
    }
    
    private void fetchNext() {
        while (!parentStack.isEmpty() || node != null) {
            if (node != null) {
                parentStack.add(node);
                node = node.left;
            } else {
                node = parentStack.removeLast();
                
                // visit
                current = node.information;
                
                node = node.right;                
                break;
            }
        }
    }
}

95. You need to check that your friend, Bob, has your correct phone number, but you cannot ask him directly. You must write the question on a card which and give it to Eve who will take the card to Bob and return the answer to you. What must you write on the card, besides the question, to ensure Bob can encode the message so that Eve cannot read your phone number?

96. Describe a data structure that accomplishes the functions INSERT and FIND-MEDIAN in the best possible asymptotic time.

Real solution using a balanced-binary search tree

We use a binary search tree that is balanced (AVL/Red-Black/etc), So adding an item is O(log n)
One modification to the tree: for every node we also store the number of nodes in its subtree. This doesn't change the complexity.
(For a leaf this count would be 1, for a node with two leaf children this would be 3, etc)

This implies:

-> When ading an element, the count for each traversed node is incremented by 1
-> The usual rotation algorithms need to be adapted as well in order to adapt the count of the moved nodes

Note : We can now access the Kth smallest element in O(log n) using these counts:

procedure get_kth_item(subtree, k)
  if subtree.left is null then
      left_size = 0
  else
      left_size = 0 subtree.left.size

  if k < left_size then
      return get_kth_item(subtree.left, k)
  else if k == left_size then
      return subtree.value
  else # k > left_size
      return get_kth_item(subtree.right, k-1-left_size)

A median is a special case of Kth smallest element (given that you know the size of the set).
So all in all this is another O(log n) solution.

In conclusion with such a data structure:

Insertion takes still O(log n) since incrementing the count only adds a constant factor
Find median takes O(1) :
- either both sides of the root have same count => root is median (O(1))
- either left side has more nodes => an easy algorithm can return the median from the left sub-tree (O(1))
- eithre right side has more nodes => same thing
Find kth element takes O(log n)

Note : If the low insertion time constraint is released, another solution for FIND-MEDIAN

If only FIND-MEDIAN is important, one can simply maintain two sorted lists kept the same size.

At all time, the median is stored in a variable.
left list stores element below the median while right list stores element above the median
After an insertion, of one list's sizes becomes bigger that the other, then the current median is added to the other list and the new median is poped from the bigger list.
(at end of the left list or beginning of the right list)

97. Write a function (with helper functions if needed) called toExcel that takes an excel column value (A,B,C,D,...,AA,AB,AC,...,AAA,..) and returns a corresponding integer value (A=1,B=2,...,AA=26,...)?

In java:

    public static int fromExcelColumn (String columnLabel) {
        // sanitizing
        if (columnLabel == null || columnLabel.trim().length() == 0) {
            return 0;
        }
        String label = columnLabel.trim().toUpperCase();
        int retValue = 0;
        // algorithm
        for (int i = 0; i < label.length(); i++) {
            retValue = (retValue * 26) + (label.charAt(i) - 'A' + 1)  ;
        }
        return retValue;
    }

98. What would you do if senior management demanded delivery of software in an impossible deadline?

99. How Old Are My Children? Knowing:
A) The product of their ages is 72 and the sum of their ages is the same as your birth date.
B) ... I still don't know .
A) My eldest kid just started taking piano lessons.
B) Now I know :-)

Don't hesitate to leave a comment or contact me should you see any error in here, or any improvement, better solution, etc. and I'll update the post accordingly.

Funny developer tale

Jerome Kehrli — Thu, 6 May 2010 17:03:06 -0400

I've been working a few years ago on an architectural concept for some very specific piece of software my former company had to develop. The technical challenges were huge and the field was pretty complex. In addition, the timeframe was very little and we have had to rush a lot to get it ready and prototyped in time.

In the end we screwed up ... totally. The concept was miles away from what was required and we pretty much had to start it all over. Months of work were just good enough to be thrown away with the trash.

Not used at all to such failures, I decided to take some time to understand what happened, what went wrong.

My investigations led to the following story, a pretty funny though quite common developer tale :

First there was the IT management which wanted to replace old technologies which were soon going to lack a proper support from the editors with brand new cutting edge technologies. They decided to build a team intended to replace the legacy system by a new one, taking that opportunity to refactor a few things the company was suffering with the legacy system.
The IT management designated a project management for the team and told them to go seeking for information on what needs to be done by the new system and how to do it.
The project management put in place a few meetings with various stakeholders.
They first met the business users trying to get the business needs. Business users are busy people. They don't have time to spend days in meetings. So instead of telling about the legacy system and what it's doing, they told about what they wanted differently in the new system and what they wanted in addition (that leap not being obvious of course).
A bit puzzled, the project management then went to the sysadmins of the legacy system. The guys all have long beards and white hairs and were really not enthusiastic at all about replacing the system they were working on for the last ten years and they knew so well. They were definitely not open to provide any help in getting rid of what gives them a job And feeds their family (that reluctance not being obvious of course).
More puzzled, the project management went to the team leaders of the development teams working on the legacy system. The guys all only had a very scarce view of the system functionalities, the big picture being spread amongst all the development teams. Even worst, in their own private field, they had obsolete views on pretty much everything. The system growing in complexity and their respective teams growing in head count, it soon became impossible for them to stay aware of what was being implemented on the system. Yet they are the funder of that system and not willing at all to admit their knowledge is obsolete.
Being nice guys, they spent all the required time with the project management feeding them with wrong information most of the time and obsolete in any case.
Finally, the project management spent time finding all the documentation they could about the legacy system. Yet again, that documentation was either inexistant or obsolete (I mean not just a bit, the latest document they found was 6 years old) and wrong.
And so they figured they did all they could and that it was about time to get the project moving. They took quite a great deal of time writing specifications with what they understood. Then, sure as hell the document is as complete as possible, they went to the architecture team.
This is where my team kicked in. The project management came to us with the specification document and asked us to come up with an architectural concept enabling the future development teams to start the migration of the legacy system to the new technologies. We were all quite experienced and smart engineers cumulating all together a lot of experience.
I do believe experienced architects have one serious drawback (although lots of qualities as well). They tend uncounsciously to fill the voids in specification with what they already know on the kind of the system they are trying to build, assuming they know how it should work and what it should do. This is unfortunately very rarely the case and I know now that one of the most important values an architect should embrace is not to leave any room to uncertainty.
Nevertheless we took good care in reading the specifications and discussing the document with our management. Once we figured we had a pretty clear view of what we've been asked to achieve, we put ourselves at work.
A few months later, we were there staring at our architecture, damn sure everything is well thought out and quite clever. So we went further to the developers and built a little team which we asked to write a few prototypes on top of this architecture. We're smart guys, right ? Why the hell should we need specifications for these prototypes ? Let's be agile.
Finally the development team put itself at work. They wrote the prototypes in a few weeks and got back to us when they were done. We looked at those prototypes and, besides a few things, we figured they were more or less in the scope, at least definitely enough to be presented to the stakeholders.
We went back to the project management and showed them the prototypes. They appeared quite happy and decided to present them to the stakeholders.
The presentation was set up. This time, in addition to the grinchy sysadmins, the development team leaders and the busy business users, a lot of the legacy system developers were here as well. The presentation began and all went ugly, really really bad. The concept was so far from what it was supposed to be and do, it all turned to a giant riot. People were shouting, yelling and very soon no one was happy anymore.

And how could it have been any different ?

There has been what was told to the project management, what the project management understood, what the project management told us, what we understood, what we designed, what we explained of the design to the developers, what the developers understood, what the developers implemented, and finally what was presented to the stakeholders ... How can such a project eventually succeed ?

They say a little picture is worth a thousand words. I found this pictures which I believe summarize pretty good this very issue :


How the customer explained it	How the project leader understood it
How the Architect designed it" src="https://www.niceideas.ch/roller2/badtrash/mediaresource/cff5c667-4291-4ae2-b279-5f736f27e454"/>
How the Architect designed it	How the Programmer wrote it

How the Business Consultant described it	How the project was documented

What operations were actually installed	How the Customer was billed

How it was supported	What the customer really needed

(I haven't been able to find who these pictures belong to so please contact me in case of copyright infringement)

Happily there have been a lot of trends in the last decade aiming at preventing such failures to happen again, let's just thing of XP or Agile to name only those two.

We should definitely have integrated from scratch two key people in the architecture/development team : a business user and an experienced developer from the legacy system. These two persons could have pointed out from the very beginning the mistakes in understanding or interpretation and they would have kept everyone's mind on track.

A good starting point with XP I would recommend is Kent Beck's classical "Extreme Programming Explained: Embrace Change"
http://www.amazon.com/Extreme-Programming-Explained-Embrace-Change/dp/0201616416

Integrating these people was eventually what we did and thanks to them we succeeded in architecturing and designing the new system, too bad it's been 2 months late and after being laughed at by the whole IT. The migration process is now running well.

Functional programming in Haskell

Jerome Kehrli — Sun, 24 Jan 2010 11:28:18 -0500

Functional programming addicts,

I'm following an Haskell programming course. It was a short course, though we ran pretty much completely through the book "Programming in Haskell" by Graham Hutton. My personal view on this is that Haskell is a great language which offers a concision rarely reached by other languages, even other functional ones. The book sucks though. It's follows a way too much theoretical approach which makes it quite cumbersome and not interesting at all.

I've been told though that Hutton's book is the reference for Haskell programming. On my side I really found the various tutorials I could find online much more useful than the thorough lecture of this book I've been pretty much forced to follow.

Anyway, as usual I made a nifty summary on this book, so help yourself :

Haskell summary

The summary stands on three A4 pages and should serve as a reference for those who are initiated to Haskell programming and seek for a quick programming reference.

Happy reading, HTH.

Introduction to the theory of computation

Jerome Kehrli — Sat, 23 Jan 2010 17:05:35 -0500

I have written a quite amazing summary on the book "Introduction to the theory of computation" by Michael Sipser. It's definitely not a replacement for the book itself as it lacks the basic explanation required to understand the presented concepts. But if you have read this book and you're looking for a short summary standing on 7 A4 pages, there you have it.

The summary focuses on the most important concepts presented by the book and holds the mandatory illustrations going along the various concepts. Well there isn't much more to say about it, so if you have read that book, check out this summary. You should be pretty amazed to see that pretty much everything actually is in it ... in less than 7 pages.

It's worth to mention though that it's quite a big file (3.8 Mb).

Summary Theoretical Computer Science

Good reading, HTH

niceideas.ch

My take on Vibe-Coding

The key takeaway

How I personally use AI

So how much faster in the end?

Two Books, One Journey Through Computing

From Transistors to Intelligence

A Project Born Long Before the First Page

Book I - From Matter to Systems

Book II - From Ideas to Intelligence

Why These Books Are in French - And Why That Matters

Emotion, Doubt and the Discipline of Renunciation

Who These Books Are Really For

Two Independent Books. One Coherent Vision.

Final Thought

AI - what do we do differently at NetGuardians ?

Interview on Artificial Intelligence

Blockchain 2.0 - From Bitcoin Transactions to Smart Contract applications

1. Blockchain 2.0 and Smart Contracts

1.1 From Transactions to Smart Contracts

1.2 Smart Contracts Overview

1.3 A little glimpse of Smart Contracts from finance perspective

2. Smart Contracts Operation

2.1 Smart Contracts Design

2.2 Smart Contract and Oracles

2.3 DAO

3. Blockchain 2.0 projects

3.1 New Blockchain technologies

3.2 A focus on R3/Corda and Smart Contract Templates

3.3 A first focus on Ethereum and Turing Complete Smart Contracts

4. Ethereum in details

4.1 Ethereum concepts

4.2 Ethereum and bitcoin differences

4.3 Etherscript

4.4 Hello World in Ethereum

4.5 Further Ethereum Examples

4.6 Private chains in Ethereum

4.7 Ethereum GUI - Graphical User Interface applications

4.8 The DAO and The DAO Attack

5. Smart Contracts use cases

6. Issues and challenges

7. Conclusion

Ethical hacking : a glimpse on local program vulnerabilities exploitation techniques

1. Ethical hacking methodology

2. A focus on Exploitation

3. Introduction to memory manipulation

3.1 Runtime Memory Organization

3.1.1 Text Segment

3.1.2 Data and BSS Segments

3.1.3 Stack

3.1.4 Heap

3.2 Processor Registers (IA32)

4. Stack overflows

4.1 Introductory example

4.2 Shell code

4.2.1 Back to our example program

4.2.2 Principle

5. Stack off-by-one

5.1 Illustration example

5.1.1 Let's play with it

5.1.2 What happened ?

5.2 Exploitation

5.3 Remarks

6. Format String bugs

6.1 Introductory example

6.1.1 Let's play with it

6.1.2 Principle

6.2 Read environment variables

6.3 Overwriting any word in memory

6.4 Practice : overwriting the .dtors section

7. Heap overflow

7.1 Heap organisation

7.2 Free chunks

7.3 Defragmentation

7.4 Heap overflow

7.5 Heap overflow Exploitation

8. Integer Overflows

8.1 Principle

8.2 Example

9. Protections against Overflows

6.4 Practice : overwriting the `.dtors` section