Skip to content

Instantly share code, notes, and snippets.

@Ivanca

Ivanca/Q-adverts.py

Last active Feb 23, 2018
Embed
What would you like to do?
Q adverts translated to python
# Each-prior
#####################################################################
# in Q >>>
types: type'[(1;2h;3.2)]
# returns the type of each element (-7 -5 -9h)
# in PYTHON >>>
numbers = [1, 2, 3.2]
types = list(map(type, numbers))
# Notes:
# 1) executing type'[(1;2h;3.2)] is the same as type each [(1;2h;3.2)]
# 2) 2h (unlike just 2) is a 'short', a number between 0 to 255 (there is no python equivalent for that)
# Over
#####################################################################
# In Q >>>
result: {x*2}/[4;3]
#
# In Q Destructured >>>
repeat: 4;
initialValue: 3;
result: {x*2}/[repeat;initialValue]
#
# Which is the same as executing 3*2*2*2*2
#
# in PYTHON >>>
def timesTwo(x):
return x * 2
repeat = 4
initialValue = 2
result = initialValue
for x in range(repeat):
result += timesTwo(result)
print(result) # result is now 58
# Notes:
# There is also a monadic way of doing this in python use 'reduce', more
# similar to the way Q does it
# you may read about it at https://www.geeksforgeeks.org/reduce-in-python/
# In Q when the second one being a list, the function is called with the left argument as its
# first parameter and the first element of the right argument as the second parameter; meaning:
ssr["today I will";"today";"tomorrow"]
# returns "tomorrow I will" but...
ssr/["today I will";("today";"I");("tomorrow";"you")]
# returns "tomorrow you will"
# Scan
#####################################################################
# The same as "over" but returns an array filled with the result of each iteration
# There is also a monadic way of doing this in python use 'reduce'
def timesTwo(x):
return x * 2
repeat = 4
initialValue = 2
result = [initialValue]
for x in range(repeat):
result += [timesTwo(result[-1])]
# Dyadic
#####################################################################
# In Q >>>
1 +' 1 2 3
# this returns 2 3 4
# In PYTHON >>>
list(map(lambda x : 1 + x, [1, 2, 3]))
# In Q >>>
5 -' 1 2 3
# this returns 4 3 2
# In PYTHON >>>
list(map(lambda x : 5 - x, [1, 2, 3]))
# Notes:
# In Q this operator doesn't care for the order so 1 +' 1 2 3 is the same as 1 2 3 +' 1
# If both parameters are lists then they must be of the same length.
# Each prior
#####################################################################
# Takes pairs of elements and executes an operator
# example using sum "+" operator
# In Q >>>
result: +':[4 8 3 1 2]
# returns 4 12 11 5 4 (cause 0+4 is 4, 4+8 is 12, and so on)
# In PYTHON >>>
lista = [4,8,3,1,2]
result = []
# First element gets no changes, its just copied
result.append(lista[0])
for index in range(1,len()):
result.append(lista[index] + lista[index - 1])
# Each-Right
#####################################################################
# In Q >>>
"abc",/:("cde";"fgh";"ijk")
# In PYTHON >>>
result = list(map(lambda x: "abc" + x, ["cde","fgh","ijk"]))
print(result)
# Each-Left
#####################################################################
# The each-left adverb behaves the same way as the each-right adverb, except it applies the right
# argument to each element of the left argument.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment