NoOne
Look at that link there? That is the language we have created.
 0of 0 votes
AnswersWhat is the smallest number *n* by which the given number *x* must be divided to make it into a perfect square?
 NoOne in Indian = find_number( x )
 Report Duplicate  Flag
Microsoft Software Engineer / Developer Algorithm  0of 0 votes
AnswersThe original question can be found from here :
 NoOne in India
franklinchen.com/blog/2011/12/08/revisitingknuthandmcilroyswordcountprograms/
Read a file of text, determine the *n* most frequently used words, and print out a sorted list of those words along with their frequencies.
In the same spirit of the history:
1. Do it using pure shell scripting
2. Do it in the favourite language of your choice
Try to minimise code and complexity. Report Duplicate  Flag
Deshaw Inc Software Developer Algorithm  0of 0 votes
Answer1. If I say quick sort takes O(e^n ) on the average, would I be wrong?
 NoOne in India
2. Do you think O( f ) is a good idea for real engineering?
3.Given a choice, what other 'order of' measure would you propose to use ?
4. Do you see a real problem with the modified *order of* ?
5. If you were to sort 10 elements, what sorting method would you have used?
6. If you were to sort 1 trillion unicode characters, what sorting method you would have used? Report Duplicate  Flag
Microsoft SDET Algorithm Math & Computation  0of 0 votes
AnswersThe actual problem from question?id=6289136497459200
Implement pow, with :// Assume C/C++, as of now double pow ( double x, double power )
No library functions allowed.
Should return : x^power
=== Edit ===
People took it a bit trivially, thus examples should help :
 NoOne in United Statesx = pow ( 4, 0.5 ) // x = 2.0 x = pow ( 8, 0.333333333 ) // 1.99999999986137069 x = pow ( 10.1 , 2.13 ) // 137.78582031242644
 Report Duplicate  Flag
Microsoft SDET Algorithm  0of 0 votes
AnswersFrom here : question?id=5660692209205248
 NoOne in United States
Inorder traversal:
A>B>C>D>E>F>H>L>MP>R>S>T
Write a function (pseudocode is fine) that given a starting node, advances to the next inorder node in a binary tree.
Please also provide a datastructure definition of a node. Report Duplicate  Flag
Arista Networks Software Developer Algorithm Trees and Graphs  0of 0 votes
AnswersApparently DESCO asked it. It was faulty, and I am fixing it. The physics was wrong. A mono pole is an abstract magnet with either the north or the south pole of the magnet.
[ en.wikipedia.org/wiki/Magnetic_monopole ]
Imagine you are given such *n* monopoles, all of the same type, say North type. Thus, all of these repel one another. The force of repulsion follows inverse square law :
[ en.wikipedia.org/wiki/Inversesquare_law ]
That is, given two such monopoles with a distance *r* between them, the force of repulsion between them is given by :F = ( 1.0 ) / ( r ** 2 )
Now, suppose you are also given an array of *n* number of positions over X axis, like : [ 0, 1, 4, 10 , 21 , .. ] where you need to place the monopoles ( imagine they are hold tight there, and do not move away ).
 NoOne in United States
After placement, you are given another monopole, of different type S, say. Find positions to place the monopole so that it is stable.
Fixes from the original question :
[geeksforgeeks.org/deshawinterviewexperienceset19oncampus/ ]
1. Monopoles exhibit inverse square law, not inverse law.
2. It is impossible to have stable configuration using same type monopole, so one must use another type, repulsion is not stable, attraction is.
( Terrible physics mistakes )
PS. Do not try to do binary search here. Binary search assumption is underlying linearity of the structure, thus, effectively there are proportionate elements in left and right. In the classic cases of sorted array, the expectation is 50/50. But here due to non linearity (inverse square) , it won't work. Report Duplicate  Flag
Deshaw Inc Software Developer Algorithm  0of 0 votes
AnswersGiven a set of numbers, find out all subsets of the set such that
the sum of all the numbers in the subset is equal to a target number.s = [ 1, 2, 3, 4, 5 ] target = 5 op = [ [ 1,4 ] , [2,3] , [5] ]
Application: Given a fixed budget, and work items we are doing back filling to check what all we can attain with the budget.
Continuation. Imagine the set is actually a set of work items, with cost and utility involved :def work_item : { name : 'foo bar' , cost : 10 , utility : 14 }
Now, solve this to maximise utility.
Continuation. Imagine that the work items are related, so that, if work item w1 is already in the
subset of the work items selected, w2 's utility increases further!.
( Can you imagine how it can happen? Effectiveness of Mesi increases when he plays for Barca)
So, you are given a list like this :w1 > normal utility 14, with w2 20, ....
Now maximize payoff.
NOTE: Payoff is a matrix. This comes from game theory.
Hence, a payoff matrix looks like :w1 w2 w3 w4 .... w1 w1 w2 w2 w3 w3 w4 w4
A cell ( i,j) is filled up with if a list contains both wi and wj, then how much the payoff would be. It is a symmetric matrix.
 NoOne in United States Report Duplicate  Flag
Amazon SDE3 Algorithm  0of 0 votes
AnswersWe tend to use computer to solve practical problems that actually earns or save dollars. Here is something that happens across the stock exchanges : people buy and sell stocks.
 NoOne in India
We generally use automated intelligent systems to buy and sell stocks. That part is too much mathematics, and beyond scope of this interview. There is another part. Suppose the system issues a buy order : buy 1000 Microsoft stock. Now, there are more than 1 ( in fact 10 ) active exchanges from where we can buy MSFT. There is a slight price delta, which keeps changing over time. There is another problem. In each stock exchange, prices are stacked, that is :
1. For first 100 stocks prices are 55$.
2. Next 200 stocks, prices are 55.2$.
... etc, and you got the idea. Even this stacks are changing over time.
Thus, here is the problem to solve. Design and implement a system such that one can buy n stocks with minimal price.
Also, in the same spirit, the same system should be able to sell n stocks with maximum payoff possible.
This is a non trivial problem, for Quant systems.
There are always k no of exchanges to hit. Report Duplicate  Flag
Goldman Sachs Software Engineer / Developer Algorithm Cache Computer Architecture & Low Level Computer Science Distributed Computing Large Scale Computing Math & Computation Software Design  0of 0 votes
AnswersAs you know, Computers were invented to solve practical business problems, we tend to ask practical applied questions. One of the key areas where we want to apply computers is simulation. As most of the people working in software are Engineers, here is the problem. It is called 3 body problem.
 NoOne in India
3 Bodies with masses [ m1, m2, m3 ] are initially positioned in the 3 points in the space, thus, having positions [ P1, P2, P3 ].
Observe that each Pi is nothing but [ xi, yi, zi ].
Once the initial condition is set, definitely gravity would work and they would start falling against each other. Write code to simulate this problem. Imagine G, the constant of gravity as 1.
How do you go about simulating it?
Hint : feynmanlectures.caltech.edu/I_09.html see 9.5
Face to face. Pen and Paper. Panel Interview, 2 person Panel. 60 Minutes. For Engineers only, was specifically told about it. Report Duplicate  Flag
Software Developer Algorithm Computer Science Graphics Math & Computation Programming Skills  0of 0 votes
AnswersGiven a convex polygon ( is planer as opposed to a polytope) and a point one had to tell if the point lies inside the polygon or outside the polygon.
 NoOne in India
To understand convexity : mathopenref.com/polygonconvex.html
Thus the question comprise of 3 sub problems :
1. How to store a polygon.
2. How to define inside and outside of a polygon.
3. How to solve the actual one, given 1,2 ? Report Duplicate  Flag
Deshaw Inc Software Developer Algorithm  0of 0 votes
AnswersAs you guys know, C did not have,and does not have anything called class. C++ has them. Now, C++ was written using C. In fact, C++ initially was called C with classes.
 NoOne in India
Thus, here is the problem for you.
Given you have C, and you need to implement class like behaviour, how you would do it? Specifically, implement the following in C :
1. A Simple Hello class with hello() function printing "Hello, World" .
2. A new operator which enables creating this constructor less class.
3. A delete operator that deletes the pointer.
How would you do it? Report Duplicate  Flag
Deshaw Inc SDET C  0of 0 votes
AnswersLinux has this nice command called *tree*.
 NoOne in India
If you did not use it, please take a look around.
You do not have to write one. BUT, you have to do something similar. Given a file name ( not a path ), and an initial directory, you have to list all the file paths, which matches the file name, case should not be considered.
Also allow regex match.
Again, the problem is non trivial.
It was expected to ask the right questions. Report Duplicate  Flag
SDET Algorithm Operating System  0of 0 votes
AnswersThere is this nice tiny *nix utility called *wc*.
The idea here is :wc file_name
prints :
 NoOne in India
character count of the file.
Word count of the file.
Line count of the file.
You have to implement your own *wc* program.
NOTE: The problem is non trivial for 3 reasons.
It was expected to ask about the non triviality. Report Duplicate  Flag
SDET Algorithm Operating System  0of 0 votes
AnswersNone actually understands how garbage collection works, albeit people ask this in the interviews. Nonetheless, we are going to ask you something very similar. Here is the problem.
Take an array of bytes, perhaps 1MB in size.
Implement these two operations:ptr_structure = alloc ( amount_of_storage ) freeed = free ( ptr_structure )
Now, here is your problem. alloc must allocate contiguous storage. If it is not possible, you need to compact ( defragment ) memory. So, you need to implicitly write a :
defragment() // defragments memory
Worse is coming. Even imagining you have written a stop the world defragmenter, after you reallocate, how the ptr_structures would actually work?
 NoOne in India
Solve this whole problem.
Time allocated was 1 hour. Face to face, panel with 2 interviewers. Report Duplicate  Flag
SDET Algorithm Assembly Computer Architecture & Low Level Computer Science Data Structures  0of 0 votes
AnswersImagine there are brick boulders, all of integer size.
Their sizes are stored in an array.
The figure looks something like this :
peltiertech.com/Excel/pix2/Histogram2.gif
Now, suppose someone is pouring water into it till water starts spilling.
You have to answer how much water the boulders are holding up.
 NoOne in Indiadef water_holding( arr ) { /* answer this */ }
 Report Duplicate  Flag
Deshaw Inc SDET Algorithm  0of 0 votes
AnswersXPATH implementation problem.
 NoOne in India
Here is the problem.
Implement XPATH expressions, given there is a DOM tree :
1. $x('//*[text() = "abc"])
How do you think it is implemented? Write code, imagine you have a general purpose tree.
2. $x('//span[text() = "abc"])
How do you think it is implemented? Write code, imagine you have a general purpose tree.
Now, explain which one would be faster, and why?
Explain from the design and the code you have written. Report Duplicate  Flag
SDET Algorithm Application / UI Design  0of 0 votes
AnswerAs you know, every OS comes up with this tiny application called the calculator. It is good. Now, here is our problem. If we try to implement the function
def calculate( operand, operator, operand ) { /* Do Interviewers bidding here */ }
I have to write if upon if upon if upon if to do for all operators. Moreover, some operators are not even binary! Take example the abs() or say the negate()!
 NoOne in India
Bigger problem persists. With the if mode, we can not even add operators as we wish to without changing code!
But that is a sin. So, what do we do? That is question 1.
In question 2, as a software tester, how do you propose to test and automate the above? Writing more if than the developer is not allowed. Report Duplicate  Flag
SDET Algorithm Data Structures Object Oriented Design Programming Skills Software Design  0of 0 votes
AnswersWe all know databases are very very slow. In fact they are so slow that very serious people who wants to do volumes of read operation and search operations write their own implementation. In this question, you would be asked to do the same, for a very limited operation  select.
Every item stored has this field called timestamp.
Now, here is the problem you need to solve :select items where time < some_time select items where time < some_time and time < another_time select items where time > some_time
Imagine you have millions of data rows. How to store it in HDD, and how to load, entirely your problem. None is going to insert anything on existing data  only read.
 NoOne in India
Write an algorithm that solves this problem, and a data structure that works as storage for the data. Report Duplicate  Flag
SDET Algorithm Database  0of 0 votes
AnswersImagine you are given the instructions :
GOTO <LABEL> WHEN <CONDITION> NOP ; no operation
Implement the following using it:
 NoOne in India
1. If condition.
2. If else condition.
3. If else if else condition.
4. While loop
5. for loop. Report Duplicate  Flag
SDET Assembly  0of 0 votes
AnswersGiven brackets, e.g. '(' and ')' as the only symbols, write a function that would generate : true, if the brackets are matching, false if the brackets are not matching.
 NoOne in India
Almost everyone can do the above.
Now, prove that it works.
Also tell which class of grammar the string belongs to.
Showcase why your algorithm is a language recogniser for the same. Report Duplicate  Flag
SDET Automata  0of 0 votes
AnswersYou are given 20 questions to solve in 20 minutes.
 NoOne in India
If you successfully solve the question, you would receive 2 marks.
If you failed to solve the question, and you do not try it ( let it untouched ) , you would receive 0 marks. If you solve it wrong ( i.e. not the correct answer )  you would receive 1 ( negative) .
With the story, here are the problems:
1. Write an algorithm, which, given an input array ( set ) of questions, and varying probability ( 0 <= p <= 1 ) of can do and can not do per question, generates a strategy for solving the paper to generate maximum expected pay off.
2. Given the question paper is multiple choice, between 4 choices ( a,b,c,d ) do a bias analysis ( e.g. if more a's are coming than 'c's ), and decide if you would like to probabilistically take risk and mark some to increase pay off.
Obviously, you can get a maximum 40, and a minimum 20.
3. Now, put yourself in the position of the examiner, and try to ensure it is almost impossible to increase payoff by random selection over the questions. Try to negate the bias. That is question 3.
In all 3 cases write an algorithm. Face to face interview, time allocated was 60 minutes. Panel Interview. Report Duplicate  Flag
unknown SDET Algorithm  0of 0 votes
AnswersFind the n'th Ugly no. An ugly no. is defined as a no. which are of the form :
n = ( 2 ** p ) * ( 3 ** q ) * ( 5 ** r )
with p,q,r >= 0 and are integers not all equal to zero.
 NoOne in United States
You must not memorise the whole sequence, as n can be really large.
Hint : use number theory to figure out the pattern of the increasing sequence. Report Duplicate  Flag
Algorithm  0of 0 votes
AnswersGiven an array, move the smaller no to the left and the larger nos to the right. The relative positioning between the small no's and the relative positions between the large nos should not change.
The original ( ill formulated ) question can be found here :
question?id=5756583549075456.
Example :a = [ 6 4 5 0 2 1 11 1 ] after_a = [ 0 , 2, 1, 1, 6, 4, 5, 11 ]
Note, for lack of good explanation, please do not laugh at the poster in the solutions. After all, they are trying to help or get help.
 NoOne in United States Report Duplicate  Flag
Arrays
def find_max_repeated_elem(a){
m = mset(a)
#(min,max) = minmax(m){ $.l.value < $.r.value }
max.value
}
def find_max_repeated_elem_sorted(a){
p = { 'item': a[0] , 'count' : 0, 'max' : 0 }
p = fold ( a , p ) > {
if( $.o == $.p.item ){
$.p.count += 1
} else {
if ( $.p.count > $.p.max ){
$.p.max = $.p.count
}
$.p.count = 1
$.p.item = $.o
}
$.p // return
}
p.item
}

NoOne
May 29, 2017 Could not resist a much cleaner  always controlled expansion on the area.
/* Starting point is (0,0).
Given the new point (x,y) is not already visited,
add 1 to the area. Else fallback.
Bonus should be, print the Area properly */
def Robot : {
$$ : def(max=100){
$.max_area = max
$.cur_area = 1
},
move : def ( dir ){
/*
spread of the area can be controlled by a global variable */
$.cur_area += 1
$.cur_area < $.max_area && random(true)
}
}
robot = new ( Robot )
// The function, with recursion removal
def find_area(){
// positions: x#y > visited
positions = dict()
positions['0#0'] = false
while ( true ){
not_traversed = find ( positions ) :: { !$.value }
break ( not_traversed.nil ) // not found such position
#(sx,sy) = not_traversed.value.key.split('#')
positions[not_traversed.value.key] = true // traversed it
x = int(sx) ; y = int(sy)
printf('%d,%d\n',x,y)
if ( robot.move( 0 ) ){ positions[str('%d#%d', x,y+1)] = false }
if ( robot.move( 1 ) ){ positions[str('%d#%d', x,y1)] = false }
if ( robot.move( 2 ) ){ positions[str('%d#%d', x+1,y)] = false }
if ( robot.move( 3 ) ){ positions[str('%d#%d', x1,y)] = false }
}
println( positions.keys )
size(positions)
}
// every time, different results
a = find_area()
println( 'Area is :' + a)

NoOne
May 27, 2017 @aonecoding  I guess you overcomplicated the thing.
/* Starting point is (0,0).
Given the new point (x,y) is not already visited,
add 1 to the area. Else fallback.
Bonus should be, print the Area properly */
// the magical move function
def move( dir ){
/* making it interesting
 so we bias it against expanding out.
 this is how Einstein figured out brownian motion.
 spread of the area can be calculated
 you can easily remove recursion. */
random(100) > 70
}
// The function, fully declarative
def recursion_is_divine( x, y, visited ){
pos_key = str('%d#%d', x,y)
/* I have already visited this  no point visiting again */
if ( pos_key @ visited ){ return; }
visited += pos_key // set it up
// move up
if ( move( 0 ) ){ recursion_is_divine( x, y+1, visited ) }
// move down
if ( move( 1 ) ){ recursion_is_divine( x, y1, visited ) }
// move left
if ( move( 2 ) ){ recursion_is_divine( x1, y, visited ) }
// move right
if ( move( 3 ) ){ recursion_is_divine( x+1, y, visited ) }
}
def find_area( ){
visited = set()
recursion_is_divine(0,0,visited)
// this would have the whole floor plan
println('The floor plan:')
println( visited )
// this would be the area
size(visited)
}
// every time, different results
a = find_area()
println( 'Area is :' + a)

NoOne
May 27, 2017 A naive recursionless code is possible:
/*
A nice trick to find permutations is use integers with base b.
Suppose there is a string of length b, with all unique characters.
Now, that means, the string can be represented as a base b integer.
Permutaions, of the string can be now found by incrementing the number,
such that all digits are unique.
Now a demonstration:
abc : 3 chars.
3 digit number, and base 3.
The digits are: a:0, b:1, c:2
012 021 102 120 201 210
> map_back to >
abc acb bac bca cab cba
and we are done.
This can be easily implemented:
*/
def map_back(encoded, string){
str( encoded.value ,'' ) > { string[int($.o)] }
}
def permutations( string ) {
// imagine all chars are unique, else there will be repeatation
b = size(string)
// start with min.
min_str = '0' + str( [1:b] , '' ) > { str($.o,b) }
max_str = min_str ** 1
min = int(min_str,b,0)
max = int(max_str,b,0)
perms = list()
perms += map_back(min_str,string)
for ( x : [ min + 1 : max ] ){
str_x = str(x,b)
if ( size(str_x) < b ){ str_x = '0' + str_x }
if ( size( set(str_x.value) ) == b ){
// all different  map it
perms += map_back(str_x,string)
}
}
perms += map_back(max_str,string)
}
p = permutations( "abc" )
println(p)

NoOne
May 26, 2017 /*
Essentially  generate a datetime range,
with spacing of 1 sec, each,
and then check if the string rep has 2 or less unique chars.
That is how one does a fully declarative coding.
Observe : en.wikipedia.org/wiki/ISO_8601
*/
def compute_interesting_times( s1, s2 ){
input_time_format = 'HH:mm:ss'
time_range = [ time(s1,input_time_format) : time(s2,input_time_format) + 'PT1S' : 'PT1S' ]
output_time_format = 'HHmmss'
x = select( time_range ) where {
s = str($.o, output_time_format)
size(set(s.value)) <= 2
}
size(x)
}
println( compute_interesting_times("15:15:00", "15:15:12") )
println( compute_interesting_times("22:22:21", "22:22:23") )

NoOne
May 24, 2017 There are many ways to do it, here is one.
/*
The regex is :
n2 = (\d)?x(\d)?y...(\d)?
under string_n1 = string_n2 + 1
*/
def get_number( sum_value ){
list ( [ 1: sum_value /2 + 1 ] ) > {
n2 = $.o
n1 = sum_value  n2
// when the digits are not one up
s_n1 = str(n1)
s_n2 = str(n2)
continue ( size(s_n2) + 1 != size(s_n1) )
decorated_n2 = fold( s_n2.value , '(\d)?' ) > { $.p + $.o + '(\d)?' }
continue( s_n1 !~ str(decorated_n2) )
[ n1, n2 ]
}
}
ns = get_number ( int(@ARGS[0]) )
println(ns)

NoOne
May 22, 2017 /*
Showing Idiomatic ZoomBA
*/
input = [4,2,8,5,20,1,40,13,23]
#(m,M) = minmax(input)
fib = seq ( 0, 1 ) > { $.item[1] + $.item[2 ] }
while ( fib.next <= M );
result = input & fib.history
println(result)
Now the result:
➜ wiki git:(master) ✗ zmb tmp.zm
[ 1,2,5,8,13 ]
➜ wiki git:(master) ✗

NoOne
May 20, 2017 mapping = { "p" : [ "$", "P" ],
"a" : [ "A" ],
"s" : [ "/" ,"S" , "&" ] }
def solutions(word, mapping){
arg = list( word.value ) > { mapping[str($.o)] }
join(@ARGS=arg) > { str($.o,'') }
}
println( solutions('pass', mapping) )
and the result:
careercup git:(master) ✗ zmb tmp.zm
[ $A//,$A/S,$A/&,$AS/,$ASS,$AS&,$A&/,$A&S,$A&&,PA//,PA/S,PA/&,PAS/,PASS,PAS&,PA&/,PA&S,PA&& ]
➜ careercup git:(master) ✗

NoOne
May 18, 2017 /*
What you want is cardinal product
Given a string is c_0,c_1,c_2, ....
We need a cardinal product of
[lower(c_0),upper(c_0)] X [lower(c_1),upper(c_1)] X ...
*/
word = 'ab'
// generate the options
args = list( word.value ) as { [ str($.o).toLowerCase(), str($.o).toUpperCase() ] }
// use the options for join  and map the tuple into a word by using str with seperator ''
result = join( @ARGS = args ) as { str($.o,'') }
println(result)

NoOne
May 15, 2017 @Flash < Try finding anagrams of "speedstar". You would find that there will be too many repetitions. Consider adding them to a set. In ZoomBA, this is what we do.
def anagrams( word ){
indices = [0:size(word)].asList()
// permutate the indices
// use the index to map to a word ( a tuple is index tuple )
// collect into a set
from ( perm( indices ) , set() ) as { str($.o,'') as { word[$.o] } }
}
println( anagrams('test') )
Also note that, for a practical point of view, you can not use recursion. The depth would become too high, better to use next_higher_permutation, which is implicit in ZoomBA.
 NoOne May 15, 2017Guys, use heap.
[ en.wikipedia.org/wiki/Heap_(data_structure) ]
You should be good to go. Get a kheap, distance metric is Euclidean, I guess everyone knows that  and you should be good.
The code is so so trivial.
In Java, use a [ docs.oracle.com/javase/8/docs/api/java/util/PriorityQueue.html ]
Here we go. By the way, the result posted in the problem is wrong.
However, I left it for the people.
/*
Business logic, I love it.
Shows why nothing in the world can beat ZoomBA.
let's write one liners for each requirements  steps.
The crux is, of course, find the *reusable* components, and use them back in Java.
*/
// step 1, read the data into a dict where key is location :: {:row_num, :name, :loc, :time }
data = list( file('foo.txt') ) as {
row = $.o.split(",")
// return this tuple
[ $.i, row[0].trim(), row[1].trim(), time(row[2].trim(),'yyyyMMdd HH:mm:ss') ]
}
// step 2 : create a multiset from this, grouped by location which is 2nd index of the tuple.
ms = mset(data) as { $.2 }
// step 3 : process each group by generating the file name and sort by time stamp
final = list()
for ( e : ms.entries ){
// sort the values by time stamp [3] index
sorta( e.value ) where { $.l.3 < $.r.3 }
// number of digits in base 10. If you can beat that, let me know
sz = size(size(e.value), 10)
// to create name, we need those many padding, so
fs = str('%%0%dd',sz)
// now iterate over all, again
fold ( e.value ) as {
// assign back the new name in data
data[$.0][1] = e.key + str(fs,$.i+1) + file($.1).extension
}
}
// print the final by projecting what component is required
println( str( data , '\n') as { $.1 } )
// amen. and yet we are to cross 42 lines. Sorry, can not add more code.
// I am truly sorry. I truly feel for people coding in Java.

NoOne
May 10, 2017 This is how you do it  in a fully declarative paradigm.
__mapping__ = {
1 : [ 'A', 'B', 'C' ], 2 : [ 'D', 'E', 'F' ],
3 : [ 'G', 'H', 'I' ], 4 : [ 'J', 'K', 'L' ],
5 : [ 'M', 'N', 'O' ], 6 : [ 'P', 'Q', 'R' ],
7 : [ 'S', 'T', 'U' ], 8 : [ 'V', 'W', 'X' ],
9 : ['Y', 'Z'] }
def map_back(n){
args = list( str(n).value ) as { __mapping__[int($.o)] }
join(@ARGS = args ) where { true } as { str($.o,'') }
}
println(map_back(12))
The result:
zmb tmp.zm
[ AD,AE,AF,BD,BE,BF,CD,CE,CF ]

NoOne
May 10, 2017 /*
Imagine the problem as finding all integers with
n 1s and m 0 s such that in the binary representation
There is no '*11*'. And we are good. So....
*/
def do_garbled(m,n){
range = [0 : 2 ** ( m + n )]
count = 0
for ( x : range ){
s = str(x,2)
s = '0' ** (size(s)  m  n) + s
continue ( n != sum(s.value) > { _'1' == $.o ? 1 : 0 } )
continue ( s =~ '.*11.*')
count += 1
}
}
// now in full ZoomBA mode, we can write this:
m = 2
n = 2
res = from ( [0 : 2 ** ( m + n )] , set() ) as {
s = str($.o,2)
s = '0' ** (size(s)  m  n) + s
} where {
n == sum($.o.value ) as { _'1' == $.o ? 1 : 0 } } where {
$.o !~ '.*11.*'
}
println ( res )
println ( size(res) )

NoOne
April 29, 2017 I abhor code so.. what these guys said, they are going to get exactly that:
/*
4 digit Even.
That gives :
A  B  C  D = [0 2 4 6 8]
Such that D != C etc etc.
*/
__digits__ = list ( [0:10] )
__l_digits__ = list ( [1:10] )
def four_digit_even_unopt(){
D = random( [0,2,4,6,8] )
C = random( __digits__  D )
B = random( __digits__  C )
A = random( __l_digits__  B )
1000 * A + 100 * B + 10 * C + D
}
println( four_digit_even_unopt() )

NoOne
April 28, 2017 Cool to see @ChrisK back. Welcome back dude. However, as a welcome gesture,
I will love to rub something in... and here we go:
/* This is how to ZoomBA */
a = [1, 1, 3, 4, 1, 1, 2, 3]
target = 4
range_a = [0:size(a)].asList
// sequences generates all possible subset of a set
options = from ( sequences( range_a ), set() ) as {
// map back the opt to actual
list( $.o ) > { a[$.o] }
// the where clause filter around it
} where { sum($.o) == target }
// prints it
println(options)

NoOne
April 27, 2017 You want to find set intersection. Here is how we do it in ZoomBA.
(zoomba)userA = [ 2, 3, 1 ]
@[ 2,3,1 ] // ZArray
(zoomba)userB = [ 2, 5, 3 ]
@[ 2,5,3 ] // ZArray
(zoomba)userC = [ 7, 3, 1 ]
@[ 7,3,1 ] // ZArray
(zoomba)s = set()
{ } // ZSet
(zoomba)s += userA
{ 1,2,3 } // ZSet
(zoomba)s &= userB
{ 2,3 } // ZSet
(zoomba)s &= userC // &= mutable intersection
{ 3 } // ZSet
(zoomba)

NoOne
April 26, 2017 Too much code. I don't like to code at all. Be lazy.
/*
For a given Sum and N print all the combinations .
This is integer partition problem.
Constrained to number of partitions := N
Given an integer is n, imagine
1 1 1 1 ... 1 ( n 1's)
Now, there can be n1 cut positions.
Choosing or not choosing a cut position
will create a partition.
Thus, create a binary string with n1 digits.
When 1, we choose the cut, when 0, we do not.
This will produce all the cuts and thus, all partitions.
The problem is constrained by number of cuts := N1
*/
def partition_int( n , N ){
n_splits = n  1
max = 2 ** n_splits
partitions = set()
for ( x : [1:max] ) {
bs = str(x,2)
// do 0 padding on left
bs = '0' ** ( n_splits  size(bs) ) + bs
nums = list()
c = 1
for ( b : bs.value ){
if ( b == _'1' ){
nums += c
c = 1
} else {
c += 1
}
}
nums += c
continue ( size(nums) != N )
// to make the partitions unique
sorta(nums)
ps = str(nums,',')
continue ( ps @ partitions )
// only when does not exist
partitions += ps
// now print
printf('%s > %s \n', bs, ps )
}
}
partition_int( @ARGS = list( @ARGS ) > { int($.o) } )
The result if you run it :
zmb tmp.zm 16 2
000000000000001 > 1,15
000000000000010 > 2,14
000000000000100 > 3,13
000000000001000 > 4,12
000000000010000 > 5,11
000000000100000 > 6,10
000000001000000 > 7,9
000000010000000 > 8,8
Let's try another one:
zmb tmp.zm 10 4
000000111 > 1,1,1,7
000001011 > 1,1,2,6
000010011 > 1,1,3,5
000010101 > 1,2,2,5
000100011 > 1,1,4,4
000100101 > 1,2,3,4
000101010 > 2,2,2,4
001001001 > 1,3,3,3
001001010 > 2,2,3,3
Hope this should do fine.
 NoOne April 25, 2017// ZoomBA
def is_isomorphic( s1, s2 ){
if ( (l = size(s1))!= size(s2) ) return false
m = dict()
for ( i : [0:l] ){
if ( s1[i] @ m ){
y = m[ s1[i] ]
} else {
y = m[ s1[i] ] = s2[i]
}
if ( y != s2[i] ) return false
}
true
}
println( is_isomorphic('','' )) // true
println( is_isomorphic('aabaac','xxtxxw' )) // true
println( is_isomorphic('ac','xxt' )) // false
println( is_isomorphic('acaa','xxtw' )) // false

NoOne
April 22, 2017 I am hungry, SRH lost so frustrated, but this should do the trick :
/*
The find next lower tidy number is
not a classically trivial one.
Obvious trivial solution is :
def find_unoptimal( n ){ while( !is_tidy(n) ){ n = 1 } }
But that is a mess.
A better solution will be:
1. Search for inversion of order ( d[i] > d[i+1] ) from left.
2. If on the inversion, we can down the digit:
Down(x) = x  1
and d[i1] < d[i]  1 then we can down the digit, replace rest by 9.
3. If we can not do that ( 12222334445555123 ),
we search for a digit change from right: ( d[i]<d[i+1] )
where we can change d[i+1] to d[i] and replace all right digits by 9
*/
def find_last_tidy( n ){
sn = str(n)
l = size(sn)
i = index( [0:l1] ) :: { sn[$.o] > sn[$.o+1] }
if ( i < 0 ) return n // this is first step
// is there a left digit? if not...
if ( i == 0 ) return int( '' + ( int(sn[0])  1 ) + ( '9' ** (l  1) ) )
// there is
// if it is like 12222334445555123 ?
// then we need to check j is the repeat size
j = index( [i:1] ) :: { sn[$.o] != sn[i] }
ns = sn[0:ij] + ( int(sn[i])  1 ) + ( '9' ** (l  i + j  2 ) )
int ( ns )
}
println( find_last_tidy(@ARGS[0]) )

NoOne
April 22, 2017 @rajendra : I actually gave you an up vote. Later, I found, almost there but not there.
Observe this :
Input : 332 Expected : 299
Actual : 229
I was looking for branch conditions. Gotha.
I guess the dumb approach wins here :)
def find_unoptimal( n ){
while( !is_tidy(n) ){ n = 1 }
n // return
}
Obviously I will try to improve, but there are some very interesting edge scenarios.
 NoOne April 22, 2017/*
This is the one which should do it
*/
def has_3_consecutive( dates ){
if ( size(dates) < 3 ) return false
ld = list(dates)
// in long form 3 consecutive date are (D  d), D, (D + d)
exists([2: size(dates)]) where { 2 * ld[$.o 1 ] == ( ld[$.o2] + ld[$.o] ) }
}
ms = mset( file( 'logfile.txt' ) ) as { #(date,key) = $.o.split('\t') ; key }
users_cons = select( ms ) where {
dates = sset ( $.o.value ) as { #(date,key) = $.o.split('\t') ; int( time(date,'MM/dd/yyyy') ) }
has_3_consecutive( dates )
} as { $.o.key }

NoOne
April 19, 2017 (zoomba)input=[2,3,5,3,7,9,5,3,7]
@[ 2,3,5,3,7,9,5,3,7 ] // ZArray
(zoomba)ms = mset(input)
{2=1, 3=3, 5=2, 7=2, 9=1} // HashMap
(zoomba)l = list(ms.entries)
[ 2=1,3=3,5=2,7=2,9=1 ] // ZList
(zoomba)sortd(l) :: { $.l.value < $.r.value }
true // Boolean
(zoomba)l
[ 3=3,5=2,7=2,2=1,9=1 ] // ZList
(zoomba)x = fold(l,list()) > { for(i:[0:$.o.value] ){ $.p += $.o.key } }
[ 3,3,3,5,5,7,7,2,9 ] // ZList

NoOne
April 18, 2017 // ZoomBA
def get_pos( string ){
pos = { 'x' : 0 , 'y' : 0 }
tokens( string , '([NEWS](\\d*))' ) > {
directive = $.o // the directive
direction = directive[0]
amount = int( directive[1:1] , 1 )
printf( '%s %s\n', direction, amount )
switch( direction ){
case _'N' : pos.y += amount
case _'S' : pos.y = amount
case _'E' : pos.x += amount
case _'W' : pos.x = amount
}
}
pos // return it
}
// use it
s = 'E4N4S4W'
println ( get_pos(s) )

NoOne
April 12, 2017 // ZoomBA.
// Basic trick, iterate over permutations, and collect elements
s = 'abcdc'
len = size(s)
sa = s.toCharArray
sorta(sa) // the base template
// iterate and select over all permutation indices
// specify the collector  classic example of from syntax
deranged = from ( perm( [0:len].asList ) , set() ) :: {
// when no element exists such that there is same char in place
!exists( $.o ) :: { sa[ $.o ] == s[ $.i ] }
// finally map permutation index back to the string
} > { str( $.o ,'' ) > { sa[ $.o ] } }
println( deranged )

NoOne
April 11, 2017 Interesting problem. There can be at least 2 ways to get it done.
The trivial one:
def getRandomOdd( min, max){
r = random()
while ( (n = r.num(min,max)) % 2 == 0 );
n // return n
}
The problem is  not really uniform, in some sense. To generate uniform, we use a reverse map:
y_min, y_max : such that
2 * y_min + 1 > min
2 * y_max + 1 > max
If min, max are not that way, we change them by something. Now we have a cleaner solution:
def getRandomOdd( min, max){
r = random()
y_min = min/2
if ( 2 /? max ){ max  1 }
y_max = max/2
2 * r.num( y_min, y_max ) + 1
}

NoOne
April 11, 2017 Sorting and everything is irrelevant here.
Read very carefully about the formulation : [ wikipedia.org/wiki/Partition_problem ]
========
The algorithm can be extended to the kway multipartitioning problem, but then takes O(n(k − 1)mk − 1) memory where m is the largest number in the input, making it impractical even for k = 3 unless the inputs are very small numbers.
=========
k = 2
M = [ 1,1,1,1,8,10 ]
N = size(M)
last = k ** N // the largest one k to the power N
min = num('inf') // well, infinity
min_p = null // nothing
// now we iterate  recursion only cool for divine
for ( n : [0:last] ){
s = str(n,k) // representing number n in base k
// reject when all the k digits do not exist in base k rep
continue( size(set(s.value) ) != k )
// left pad with zeros thus making the string N size
s = '0' ** ( N  size(s)) + s
// collect into k partitions ( change the char into int as key )
p = mset( M ) as def(inx){ int(s[inx]) }
// now generate total  calculating all pairs between 0,k1
tot = sum ( comb( [0:k] , 2 ) ) as def(inx, pair){
// size(x) is abs(x)
size( sum(p[pair[0]])  sum(p[pair[1]]))
}
// search for min m
if ( tot < min ){
min = tot
min_p = p
}
}
// well...
println(min)
println(min_p)
// and Finally, Galaxy has peace!

NoOne
April 03, 2017 This problem is imprecise. Observe this:
a = [ 0 , 1000, 10000] // k = 1
a = [ 0 , 1000, 10000] // k = 3
Thus, the problem needs to be precisely stated.
The proper formulation will entail :
Given there is an array of sorted values, and a parameter k, group the values into k buckets (bucket_i s) such that :
M = sum ( abs( sum(bucket_i)  sum(bucket_j) ) )
gets minimized.
 NoOne April 03, 2017Given people already are massively overthought this  and they did not think what should be thought about : en.wikipedia.org/wiki/Similarity_measure.
Take a pause and think this.
Is it transitive? That is :
A similar_to B and B similar_to C ==>(implies) A similar_to C
does it hold true? 99.999% of the real practical cases, it won't be.
Take name for example.
ram : ok, male
rama : ok, male again perhaps
ramaa : ambiguous  perhaps it is a female name ? Now thinking backward,
ramaa > rama :: hmm. See the problem there?
what about roma? ramaa and roma are close but is ram and roma close? Well.
That... pose a problem.
How did we get it? By working in system  where close name matching may point to same individual  facebook is another classic example. Same problem persists in the Indian addresses.
Thus, we need to ask, is the similarity function transitive? That would have clear impact on any algorithm we try to apply.
// ZoomBA : the data
data = [ [1,3,5,9],
[1,2,1,2],
[1,4,7,9],
[20,25,20,35] ]
// operation 1 :
repeat_in_rows = sum ( data ) > { (size( set($.o) ) != size($.o) )? 1:0 }
println( repeat_in_rows )
// operation 2 :
num_dup = 2
num_dup_in_rows = sum ( data ) > {
// get mset, key, num_of_occurences
ms = mset($.o)
// when there are at least 2 keys with num_of_occurences >= num_dup :: dup
dups = select( ms.values ) :: { break( size($.p) >= num_dup ) ; $.o > 1 }
// simple
size(dups) == num_dup ? 1 : 0
}
println( num_dup_in_rows )

NoOne
March 28, 2017 /*
1. bucketize on thread pool.
2. Shoot.
*/
// per thread num of file
bucket_size = 100
// assume list of files are here
files // yep, files as in like list of strings
num_files = size(files)
def process_files ( start_inx ){
end_inx = start_inx + bucket_size
end_inx = end_inx > num_files ? num_files : end_inx
sum ( [start_inx : end_inx ] ) > { sumOfFile( files[$.o] ) }
}
num_buckets = ceil ( num_files / bucket_size )
start_inx = 0
threads = list ( [0:num_buckets] ) > {
start_inx += bucket_size
thread( ) > { process_files( start_inx ) }
}
// do not get into a loop, ever
succeeded = poll( 42, 300 ) :: { !exists( threads ) :: { $.o.alive } }
// zoomba threads return value, proper they are option monad
assert ( succeeded , "Why you fail in timeout???" )
total_sum = sum ( threads ) > { $.o.value }
println( total_sum ) // should be cool

NoOne
March 26, 2017 // ZoomBA
/*
We are assuming only alpha.
Thus, the general regex for the string is :
word > [azAZ][\d]+
s = ( word )+
Thus, the problem can be solved by tokenization of word
and then expanding the word
*/
word = '[azAZ][\\d+]'
string = "a4b2c2a3f1g2"
println(string)
// tokenize on string
l = tokens( string , word ) > {
// extract letter
letter = (tokens($.o, '[azAZ]' ))[0]
// extract frequency
frequency = (tokens($.o, '\\d+' ))[0]
// expand the letter with frequency : a ** 2 > aa
letter ** int(frequency)
}
// finally catenate over the list
println( str(l,'') )

NoOne
March 26, 2017 // ZoomBA
/*
Should be solvable by 2 iterations and exactly n space.
You can optimize it later.
Pass 1: At every index position left_bracket_count
1 : 0 ....
Pass 2: At every index position right_bracket_count
from right, so size : 0 check where left and right count matches.
You are cool.
*/
def find_match_count( string ){
#(mem,count) = fold ( string.value, [list(), 0] ) > {
$.p.1 += ($.o == _'(' ? 1 : 0)
$.p.0 += $.p.1 ; $.p
}
// this is DUMB.. but well..
if ( mem[1] == 0 ) return #'Index #{size(string)} Count 0'
right_count = 0
i = rindex ( string.value ) :: {
right_count += ($.o == _')' ? 1 : 0)
mem[$.i] == right_count
}
i<0 ? 'Nothing Found' : #'Index #{i} Count : #{mem[i]}'
}
println( find_match_count( "(())" ) )
println( find_match_count( "(())))(" ) )
println( find_match_count( "))" ) )

NoOne
March 18, 2017 /*
A better way to look it using sequences
Define a Sequence S, such that it is strictly increasing
and generated by the rule of sum of nonnegative multiples of the numbers in the array.
Thus, S(0) = 0 and we go in a = [6,9,20]
S(1) = 6
S(2) = 9
S(3) = 12 = 6 * 2
S(4) = 15 = 6 + 9
S(5) = 18 = ( 3 * 6 , 9*2 )
We use ZoomBA to solve it and show a nice pattern.
This is solvable by adding 6,9,20 to each item encountered before in the sequence,
and check if the current item is minimum of the larger item than the current max
Then the next item is generated. Thus, the problem is solved when we have
Target n is such that
S(k) < n <= S(k+1)
To generate the this array a from bases is easy, and can be left as an exercise to the reader.
Hint: use the same algorithm and start with 0,min_of_base
*/
bases = [6,9,20]
// first few items of the sequence from the bases till 20
a = [ 0, 6, 9, 12 , 15 , 18, 20 ]
s = seq( a ) > {
cached = $.p // previous items
last_no = cached[1] // last item
maxes = list ( bases ) > {
item = $.o // store the individual base items
ix = index ( cached ) :: { $.o + item > last_no }
cached[ix] + item // we find where we max  so store it
}
#(min,Max) = minmax( maxes ) // find min of the maxes
min // return min as the next item in the sequence
}
// now call
def find_some( n ){
if ( n <= s.history[1] ) return n @ s.history // obvious
while ( s.history[1] <= n ){ s.next } // iterate over
return n @ s.history // and then is trivial
}
println( find_some(47) )
println( find_some(23) )

NoOne
March 18, 2017 Open Chat in New Window
@ChrisK,
 NoOne May 29, 2017Suppose there is only one element that is repeated. Only one. The number of repetitions unknown. Then, what we can do is  simple go to middle and search for left/right is same or not. That would work.