Jyotirmay Welcomes You!



palindrome-number: PROBLEM STATEMENT


                                    
                                        
Determine whether an integer is a palindrome. An integer is a palindrome when it reads the same backward as forward.

Example 1:

Input: 121
Output: true
Example 2:

Input: -121
Output: false
Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.
Example 3:

Input: 10
Output: false
Explanation: Reads 01 from right to left. Therefore it is not a palindrome.
Follow up:

Coud you solve it without converting the integer to a string?
                                    

                                

MY SOLUTION


                                    
                                        
class Solution:
    def isPalindrome(self, x: int) -> bool:
        x_arr = []
        x_orig = x
        while (x > 0):
            x_arr.append(x % 10)
            x = x // 10

        x_len = len(x_arr)
        p_num = 0
        for idx, x_r in enumerate(x_arr):
            p_num += x_r * 10 ** (x_len - idx - 1)

        return True if x_orig == p_num else False

                                    
                                

BEST RUN-TIME SOLUTION


                                    
                                        
class Solution:
    def isPalindrome(self, x: int) -> bool:
        x_str = str(x)
        return x >= 0 and x_str == x_str[::-1]

                                    
                                

BEST SPACE-TIME SOLUTION


                                    
                                        
class Solution:
    def isPalindrome(self, x: int) -> bool:
        if x < 0:
            return False
        x = str(x)
        n = len(x)
        for i in range(n//2):
            if x[i] != x[-(i+1)]:
                return False
        return True

                                    
                                

RANK ACHIEVED



two-sum: PROBLEM STATEMENT


                                    
                                        
Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

 

Example 1:

Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Output: Because nums[0] + nums[1] == 9, we return [0, 1].
Example 2:

Input: nums = [3,2,4], target = 6
Output: [1,2]
Example 3:

Input: nums = [3,3], target = 6
Output: [0,1]
 

Constraints:

2 <= nums.length <= 105
-109 <= nums[i] <= 109
-109 <= target <= 109
Only one valid answer exists.
                                    

                                

MY SOLUTION


                                    
                                        
class Solution:
    def twoSum(self, nums, target):
        valList = []
        for i, val in enumerate(nums):
            if val in valList:
                return [valList.index(val), i]
            else:
                more = target - val
                valList.append(more)


                                    
                                

BEST RUN-TIME SOLUTION


                                    
                                        
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        a = {}
        for i in range(len(nums)):
            n = target - nums[i]
            if n not in a.keys():
                a[nums[i]] = i
            else:
                return [a[n], i]

                                    
                                

BEST SPACE-TIME SOLUTION


                                    
                                        
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(len(nums)):
                for j in range(i+1, len(nums)):
                    if nums[i] + nums[j] == target:
                        return [i,j]

                                    
                                

RANK ACHIEVED



house-robber: PROBLEM STATEMENT


                                    
                                        
You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security system connected and it will automatically contact the police if two adjacent houses were broken into on the same night.

Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.

 

Example 1:

Input: nums = [1,2,3,1]
Output: 4
Explanation: Rob house 1 (money = 1) and then rob house 3 (money = 3).
             Total amount you can rob = 1 + 3 = 4.
Example 2:

Input: nums = [2,7,9,3,1]
Output: 12
Explanation: Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1).
             Total amount you can rob = 2 + 9 + 1 = 12.
 

Constraints:

0 <= nums.length <= 100
0 <= nums[i] <= 400
                                    

                                

MY SOLUTION


                                    
                                        
# COPIED

class Solution:
    def rob(self, nums):
        dp1, dp2 = 0, 0
        for num in nums:
            dp1, dp2 = dp2, max(dp1 + num, dp2)
        return dp2

                                    
                                

BEST RUN-TIME SOLUTION


                                    
                                        
class Solution:
    def rob(self, nums: List[int]) -> int:
        if not nums:
            return (0)

        dp = [0] * (len(nums))
        dp[0] = nums[0]

        for i in range(1, len(nums)):
            dp[i] = max(dp[i - 1], nums[i] + (dp[i - 2] if i > 1 else 0))
        return (dp[-1])

                                    
                                

BEST SPACE-TIME SOLUTION


                                    
                                        
class Solution:
    def rob(self, nums: List[int]) -> int:
        if not nums:
            return 0
        if len(nums) == 1:
            return nums[0]
        dp = [0] * len(nums)
        dp[0] = nums[0]
        dp[1] = max(nums[0], nums[1])

        for i in range(2, len(nums)):
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])
        return dp[-1]

                                    
                                

RANK ACHIEVED



valid-parentheses: PROBLEM STATEMENT


                                    
                                        
Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

An input string is valid if:

Open brackets must be closed by the same type of brackets.
Open brackets must be closed in the correct order.


Example 1:

Input: s = "()"
Output: true
Example 2:

Input: s = "()[]{}"
Output: true
Example 3:

Input: s = "(]"
Output: false
Example 4:

Input: s = "([)]"
Output: false
Example 5:

Input: s = "{[]}"
Output: true


Constraints:

1 <= s.length <= 104
s consists of parentheses only '()[]{}'.
                                    

                                

MY SOLUTION


                                    
                                        
# In Progress
class Solution:
    def isValid(self, s: str) -> bool:
        b1 = 0
        b2 = 0
        b3 = 0
        for i, si in enumerate(s):

            # b1 = si
            # last = isValid(s[i:])
            if si == '(':
                b1 += 1
            elif si == '{':
                b2 += 1
            elif si == '[':
                b3 += 1
            elif si == ')':
                b1 -= 1
            elif si == '}':
                b2 -= 1
            elif si == ']':
                b3 -= 1
            else:
                pass

        print(b1, b2, b3)
        if (b1 != 0) or (b2 != 0) or (b3 != 0):
            return False
        else:
            return True

                                    
                                

BEST RUN-TIME SOLUTION


                                    
                                        

                                    
                                

BEST SPACE-TIME SOLUTION


                                    
                                        

                                    
                                

RANK ACHIEVED



reverse-integer: PROBLEM STATEMENT


                                    
                                        
Given a 32-bit signed integer, reverse digits of an integer.

Example 1:

Input: 123
Output: 321
Example 2:

Input: -123
Output: -321
Example 3:

Input: 120
Output: 21
Note:
Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−231,  231 − 1]. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.
                                    

                                

MY SOLUTION


                                    
                                        
class Solution:
    def reverse(self, x: int) -> int:
        if x > (2 ** 31) - 1 or x < -(2 ** 31):
            return 0

        x_s = str(x)
        if x_s[0] == '-' or x_s[0] == '+':
            x_tr = x_s[1:]
            signed = x_s[0]
        else:
            x_tr = x_s
            signed = ''

        def print_reverse(xt):
            if len(xt) == 0:
                return xt

            return print_reverse(xt[1:]) + xt[0]

        out = print_reverse(x_tr)

        if len(out) > 1:
            for idx, o in enumerate(out):
                if o is '0':
                    continue
                elif o is not '0':
                    out = out[idx:]
                    break
        final_out = int(signed + out)
        if final_out > (2 ** 31) - 1 or final_out < -(2 ** 31):
            return 0

        return final_out

                                    
                                

BEST RUN-TIME SOLUTION


                                    
                                        
class Solution:
    def reverse(self, x: int) -> int:
        x = str(x)
        a =  int('-' + x[-1:0:-1]) if x[0] == '-' else int(x[::-1])
        if a >= -2147483648 and a<= 2147483647: return a
        else: return 0

                                    
                                

BEST SPACE-TIME SOLUTION


                                    
                                        
class Solution:
    def reverse(self, x: int) -> int:

        reversed = 0
        if x == 0:
            return 0

        num = x
        x = abs(x)
        while x != 0:
            reversed = (reversed * 10) + (x % 10)
            x //= 10
        if (reversed > ((2 ** 31) - 1) or reversed < -1 * (2 ** 31)):
            return 0

        if num < 0:
            return -reversed
        else:
            return reversed

                                    
                                

RANK ACHIEVED



roman-to-integer: PROBLEM STATEMENT


                                    
                                        
Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.

Symbol       Value
I             1
V             5
X             10
L             50
C             100
D             500
M             1000
For example, two is written as II in Roman numeral, just two one's added together. Twelve is written as, XII, which is simply X + II. The number twenty seven is written as XXVII, which is XX + V + II.

Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:

I can be placed before V (5) and X (10) to make 4 and 9. 
X can be placed before L (50) and C (100) to make 40 and 90. 
C can be placed before D (500) and M (1000) to make 400 and 900.
Given a roman numeral, convert it to an integer. Input is guaranteed to be within the range from 1 to 3999.

Example 1:

Input: "III"
Output: 3
Example 2:

Input: "IV"
Output: 4
Example 3:

Input: "IX"
Output: 9
Example 4:

Input: "LVIII"
Output: 58
Explanation: L = 50, V= 5, III = 3.
Example 5:

Input: "MCMXCIV"
Output: 1994
Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.
                                    

                                

MY SOLUTION


                                    
                                        
class Solution:
    def romanToInt(self, s: str) -> int:
        priority = {
            'I': 1,
            'V': 5,
            'X': 10,
            'L': 50,
            'C': 100,
            'D': 500,
            'M': 1000
        }
        num = 0
        for idx, si in enumerate(s):
            if idx == 0:
                num += priority[si]
                continue

            temp_num = priority[si]
            prev_num = priority[s[idx - 1]]
            if temp_num <= prev_num:
                num += priority[si]
            else:
                num += priority[si] - (2 * prev_num)

        return num



                                    
                                

BEST RUN-TIME SOLUTION


                                    
                                        
class Solution:
    def romanToInt(self, s: str) -> int:
        table = {
            'I': 1,
            'V': 5,
            'X': 10,
            'L': 50,
            'C': 100,
            'D': 500,
            'M': 1000
        }

        prev = 0
        current = 0
        total = 0
        for i in range(len(s)):
            current = table[s[i]]
            if current > prev:
                total = total + current - 2 * prev
            else:
                total = total + current
            prev = current
        return total

                                    
                                

BEST SPACE-TIME SOLUTION


                                    
                                        
class Solution:
    def romanToInt(self, s: str) -> int:
        dictt={'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
        prev=0
        ans=0
        for i in range(len(s)-1,-1,-1):
            if prev<=dictt[s[i]]:
                prev=dictt[s[i]]
                ans+=prev
            else:
                prev-=dictt[s[i]]
                ans-=dictt[s[i]]
        #print(ans)
        return ans

                                    
                                

RANK ACHIEVED



longest-common-prefix: PROBLEM STATEMENT


                                    
                                        
Write a function to find the longest common prefix string amongst an array of strings.

If there is no common prefix, return an empty string "".

Example 1:

Input: ["flower","flow","flight"]
Output: "fl"
Example 2:

Input: ["dog","racecar","car"]
Output: ""
Explanation: There is no common prefix among the input strings.
Note:

All given inputs are in lowercase letters a-z.
                                    

                                

MY SOLUTION


                                    
                                        
class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if len(strs) == 0:
            return ""

        base = strs[0]
        for toMatch in strs[1:]:
            base = self.lcp(base, toMatch)

        return base

    def lcp(self, w1, w2):
        lcp = ''
        for l1, l2 in zip(w1, w2):
            if l1 == l2:
                lcp += l1
            else:
                break
        return lcp

                                    
                                

BEST RUN-TIME SOLUTION


                                    
                                        
class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if len(strs) == 0:
            return ""
        l = min(len(x) for x in strs)
        lcp = strs[0][:l]

        for i in range(1, len(strs)):
            while l >= 0 and lcp != strs[i][:l]:
                l = l - 1
                lcp = strs[0][:l]

        return lcp

                                    
                                

BEST SPACE-TIME SOLUTION


                                    
                                        
class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        prefix = ""
        arranged = list(zip(*strs))
        for chars in arranged:
            print(chars)
            if chars.count(chars[0]) == len(chars):
                prefix = "".join([prefix, chars[0]])
            else:
                break

        return prefix

                                    
                                

RANK ACHIEVED


Chapter 1

THE

July 4th, 2020


Chapter 1

FOOD 1

July 19th, 2020


Chapter 1

INTRO

July 16th, 2020


Chapter 2

ADJECTIVES

August 4th, 2020


Chapter 3

STUFF

September 02nd, 2020


Chapter 1

ACCUSATIVE CASES

July 13th, 2020


Chapter 2

FAMILY 1

September 19th, 2020


Chapter 3

ACCUSATIVE PRONOUN

September 04th, 2020


Chapter 2

CLOTHING

August 13th, 2020


Chapter 3

NOMINATIVE PRONOUN

August 21th, 2020


Chapter 1

ANIMALS 1

July 22nd, 2020


Chapter 1

BASIC 1

July 1st, 2020


Chapter 4

DATIVE CASE

October 16th, 2020


Chapter 1

PHRASES

July 10th, 2020


Chapter 2

PLURALS

August 1st, 2020


Chapter 3

POSSESSIVE PRONOUN

August 18th, 2020


Chapter 3

HOUSE 1

September 07th, 2020


Chapter 4

NUMBERS 1

September 26th, 2020


Chapter 2

QUESTIONS 2

September 16th, 2020


Chapter 3

NEGATIVES

August 24th, 2020


Chapter 2

PRESENT 1

August 10th, 2020


Chapter 4

Money

October 05th, 2020


Chapter 3

ADVERBS 1

August 27th, 2020


Chapter 3

PEOPLE 1

September 13th, 2020


Chapter 4

FAMILY 2

October 24th, 2020


Chapter 4

FOOD 2

October 09th, 2020


Chapter 3

CONJUNCTIONS

September 10th, 2020


Chapter 3

PLACES 1

August 30th, 2020


Chapter 2

NOT

August 04th, 2020


Chapter 1

BASIC 2

July 7th, 2020


Chapter 4

ACCUSATIVE PREPOSITIONS

September 22nd, 2020


Chapter 2

NATURE 1

August 15th, 2020


Chapter 2

QUESTIONS 1

August 07th, 2020


070920


Ab Crunch


Ab Crunch Machine


Ab Rollout


Air Squats


Alternating Medicine Ball Push Up


Arnold Dumbbell Press


Assisted Chin Up


Assisted Dips


Assisted Neutral Grip Pull Up


Assisted Pull Ups


Assult Bike


Back Extension


Back Flies


Back Squat


Bar Muscle Up


Barbell Ab Rollout


Barbell Bench Press


Barbell Curl


Barbell Decline Bench Press


Barbell Floor Press


Barbell Glute Bridge


Barbell High Pull


Barbell Hip Thrust


Barbell Incline Bench Press


Barbell Lunge


Barbell Reverse Curl


Barbell Row


Barbell Shoulder Press


Barbell Shrug


Barbell Step Ups


Battle Ropes


Bear Crawl


Bench Dips


Bent Over Row


Biceps Curl to Shoulder Press


Bicycle Crunch


Bird Dog


Bosu Ball Cable Crunch with Side Bends


Bosu Ball Crunch


Bosu Ball Mountain Climbers


Bosu Ball Push Up


Bosu Ball Squat


Box Jump


Box Squat


Bulgarian Split Squat


Burpee


Butterfly Pull Up


Cable Chest Press


Cable Crossover Fly


Cable Crunch


Cable Lateral Raise


Cable Preacher Curl


Cable Rear Delt Fly


Cable Rope Overhead Triceps Extension


Cable Row


Cable Russian Twists


Cable Shotgun Row


Cable Shoulder Press


Cable Shrugs


Cable Tricep Extension


Cable Tricep Extension with Rope


Cable Woodchop


Calf Press


Calf Raises


Child's Pose


Chin Up


Clams


Clean


Clean and Jerk


Clean Deadlift


Clean From Box


Clean High Pull


Clean Pull


Close Grip Bench Press


Concentration Curl


Crunches


Dead Bug


Deadlift


Decline Crunch


Decline Leg Raise


Decline Pushup


Decline Reverse Crunch


Demo Video


Diamond Push Up


Dips


Double Under


Dumbbell Bench Press


Dumbbell Bent Over Row


Dumbbell Bicep Curl


Dumbbell Bicep Curl 2


Dumbbell Clean


Dumbbell Decline Bench Press


Dumbbell Decline Fly


Dumbbell Floor Press


Dumbbell Fly


Dumbbell Front Raise


Dumbbell Incline Bench Press


Dumbbell Incline Fly


Dumbbell Kickbacks


Dumbbell Lateral Raise


Dumbbell Lunge


Dumbbell Pullover


Dumbbell Rear Delt Raise


Dumbbell Reverse Fly


Dumbbell Romanian Deadlift


Dumbbell Row


Dumbbell Shoulder Press


Dumbbell Shoulder Raise


Dumbbell Shrug


Dumbbell Side Bend


Dumbbell Skull Crusher


Dumbbell Squat to Shoulder Press


Dumbbell Squeeze Press


Dumbbell Step Ups


Dumbbell Stiff Legged Deadlift


Dumbbell Tricep Extension


Dumbbell Tricep Press


Dumbbell Upright Row


Dumbbell Walking Lunge


Elevated Hip Bridge


Exercise Ball Crunch


Exercise Ball Pull In


Exercise Ball Push Up


EZ Bar Curl


EZ Bar Skullcrusher


Face Pull


Farmer's Walk


Floor Bridge


Floor Glute Ham Raise


Floor Press


Flutter Kicks


Foam Roll Quadriceps


Freemotion Chest Press


Freemotion Shoulder Press


Front and Back Neck Exercise


Front Plate Raise


Front Squat


Front Squat To A Bench


Glute Ham Raise


Glute Ham Raise Situp


Glute Kickback


Goblet Squat


Good Morning


Hack Squat


Hammer Curls


Hammerstrength Bench Press


Hammerstrength Decline Chest Press


Hammerstrength High Row


Hammerstrength Incline Chest Press


Hammerstrength Iso Row


Hammerstrength Shoulder Press


Hammerstrength Shrug


Handstand Push Up


Handstand Walk


Hang Clean


Hang Power Clean


Hang Power Snatch


Hang Snatch


Hanging Knee Raise


Hanging Leg Raise


Hip Extension


Hip Thrust


Dumbbell Squat


Power Clean


Incline Barbell Skull Crusher


Incline Cable Chest Press


Incline Dumbbell Curls


Incline Hammer Curls


Incline Push Up


Inverted Row


Iron Cross


Jackknife Sit Up


Jog In Place


Jump Rope


Jump Squat


Jumping Jacks


Kettlebell Clean


Kettlebell Clean and Jerk


Kettlebell Front Squat


Kettlebell Hang Clean


Kettlebell Jerk


Kettlebell One Legged Deadlift


Kettlebell Overhead Press


Kettlebell Pistol Squat


Kettlebell Snatch


Kettlebell Sumo High Pull


Kettlebell Swing


Kettlebell Thruster


Kettlebell Turkish Get Up


Kipping Pull Up


Knee Raise


Knee Raise on Parallel Bars


L Sit


Landmine


Landmine Press


Landmine Row


Lat Pulldown


Lateral Bound


Lateral Box Jump


Lateral Cone Hop


Launch Video 4


Leg Curl


Leg Extension


Leg Lift


Leg Press


Leg Raise


Lunge


Lunge Jump


Lying Hamstrings Curl


Machine Bench Press


Machine Bicep Curl


Machine Calf Press


Machine Fly


Machine Lat Pulldown


Machine Lateral Raise


Machine Leg Press


Machine Preacher Curls


Machine Row


Machine Shoulder Press


Machine Squat


Machine Tricep Dip


Machine Triceps Extension


Medicine Ball Chest Pass


Medicine Ball Full Twist


Medicine Ball Push Up


Medicine Ball Slam


Mixed Grip Pull Up


Mountain Climbers


Muscle Clean


Muscle Snatch


Muscle Up


Neutral Grip Pull Up


Oblique Crunch


Olympic Squat


Overhead Squat


Pallof Press


Palm's Down Barbell Wrist Curl


Palm's Down Dumbbell Wrist Curl


Palm's Up Barbell Wrist Curl


Palm's Up Dumbbell Wrist Curl


Parallel Bar Dip


Pike Push Up


Pistol Squat


Plank


Plank Jacks


Plate Twist


Power Clean From Box


Power Snatch


Power Snatch From Blocks


Preacher Curl


Prowler Sprint


Pull Through


Pull Up


Push Jerk


Push Press


Push Up


Rack Pulls


Rear Delt Fly


Rear Delt Machine Fly


Renegade Row


Resistance Band Bicep Curl


Reverse Barbell Curl


Reverse Crunch


Reverse Flutter Kicks


Reverse Hyperextension


Ring Dips


Ring Row


Romanian Deadlift


Rope Climb


Rope Triceps Extension


Rotation Push Up


Russian Twists


Scapular Pull Up


Scissor Crossover Kick


Scissor Kick


Seated Back Extension


Seated Cable Row


Seated Calf Raise


Seated Dumbbell Curl


Seated Dumbbell Rear Delt Raise


Seated Leg Curl


Seated Triceps Press


Shadowboxing


Shotgun Row


Shoulder Press


Side Bend Stretch


Side Bridge


Side Lateral Raise


Side Laterals to Front Raise


Side Leg Raises


Side Lunge


Side Neck Exercise


Side Plank


Single Arm Dumbbell Bench Press


Single Arm Floor Press


Single Arm Landmine Press


Single Arm Landmine Row


Single Arm Lat Pulldown


Single Arm Overhead Kettlebell Squat


Single Arm Overhead Press


Single Arm Preacher Curl


Single Arm Push Up


Single Leg Box Jump


Single Leg Butt Kick


Single Leg Cable Kick Back


Single Leg Curl


Single Leg Glute Bridge


Single Leg Hip Thrust


Single Leg Leg Extension


Single Leg Machine Leg Curl


Single Leg Romanian Deadlift


Sit Up


Skullcrusher


Sled Push


Sledge Hammer


Smith Machine Behind the Back Shrug


Smith Machine Bench Press


Smith Machine Bent Over Row


Smith Machine Calf Raise


Smith Machine Close Grip Bench Press


Smith Machine Decline Press


Smith Machine Hang Power Clean


Smith Machine Incline Bench Press


Smith Machine One Arm Upright Row


Smith Machine Overhead Shoulder Press


Smith Machine Pistol Squat


Smith Machine Shrug


Smith Machine Squat


Smith Machine Stiff Legged Deadlift


Smith Machine Upright Row


Smith Single Leg Split Squat


Snatch


Snatch Balance


Snatch Deadlift


Snatch From a Block


Snatch from Blocks


Snatch High Pull


Snatch Pull


Split Clean


Split Jerk


Split Snatch


Split Squats


Stability Ball Abdominal Twist


Stability Ball Hip Bridge


Standing Barbell Calf Raise


Standing Calf Raise


Standing Leg Curl


Step Up


Stiff Legged Barbell Good Morning


Stiff Legged Deadlift


Straight Arm Pulldown


Straight Leg Kickback


Sumo Deadlift


Sumo Deadlift High Pull


Sumo Dumbbell Squat


Superman


Svend Press


T Bar Row


Tate Press


Team USA Weightlifting Champion Ian Wilson demonstrates the Clean and Jerk


Thigh Abductor


Thigh Adductor


Thruster


Tire Flip


Toe Touchers


Toes to Bar


Trap Bar Deadlift


Tricep Dip


Tricep Push Up


Tricep Pushdown


TRX Atomic Push Up


TRX Bicep Curl


TRX Chest Fly


TRX Chest Press


TRX Curtsy Lunge


TRX Deltoid Fly


TRX Fallout


TRX Glute Bridge


TRX Lateral Lunge


TRX Leg Lunge


TRX Mountain Climber


TRX Push Up


TRX Row


TRX Side Plank


TRX Single Leg Squat


TRX Squat


TRX Squat and Row


TRX Suspended Plank


TRX Tricep Extension


Tuck Crutch


Tuck Jump


Turkish Get Up


Upright Row


V Bar Pulldown


Vertical Knee Raise


Vertical Leg Raise


Walking Dumbbell Lunge


Walking Lunge


Wall Ball


Weighted Ball Hyperextension


Wide Grip Lat Pulldown


Wide Grip Pull Up


Windshield Wipers


Zercher Squats


Zottman Curl


Zottman Preacher Curl




Get connect with me from anywhere

World is small and round, even if we don't wanna meet, we will!