Format
K-Group & Omit Lyrics
Jump to: Overall Meaning ↴ Line by Line Meaning ↴
Yeah!!
Yeah!!!
We fight we lie we strong
We sly we fall we run
And when we get up again We ball
We on the side way up.. We on the
Season filled up with many blessings on the
I gat no time I keep on rolling on the
Balling to dawn wake in the morning on the
Dreaming rockstar feeling like a king on the
Straight out up onto the sky ya
Know the love is never gonna die ya
Straight up never going down ya
Shaky to the ground e going loud others fussy format
Yea yea on the fussy format
(We playing) men we rolling on the fussy format
Yea yea on the fussy format
On the fussy format yeah
We live we die we gone
We here we there we none
But we go forming and we real one
We on the side way up We on the
Fussy format
Season filled up with many blessings on the
I gat no time I keep on rolling on the
Balling to dawn wake in the morning on the
Dreaming rockstar feeling like a king on the
Straight out up onto the sky ya
Know the love is never gonna die ya
Straight up never going down ya
Shaky to the ground e going loud on the fussy format
Yea yea on the fussy format
(We playing) men we rolling on the fussy format
Yea yea on the fussy format...
On the fussy format yeah
The lyrics of "Format" by K-Group & Omit convey a message of resilience, perseverance, and living life to the fullest despite challenges and setbacks. The repetitive "Yeah!" at the beginning emphasizes a sense of determination and readiness to face whatever comes their way. The mention of fighting, lying, being strong, sly, falling, and running paints a picture of the ups and downs of life. Despite the difficulties, they never stay down for long and come back stronger, symbolized by "We ball."
The phrase "We on the side way up" suggests that they are on an upward trajectory, regardless of the obstacles they encounter. The "Fussy format" could signify the unpredictable and chaotic nature of life, filled with both blessings and challenges. The continuous pursuit of their goals is highlighted by the repetition of "I keep on rolling on."
There is a sense of ambition and determination in the lyrics, with references to feeling like a rockstar and a king, indicating a desire to achieve greatness and live life to the fullest. The lines "Know the love is never gonna die ya" and "Balling to dawn wake in the morning on the" exude confidence and a belief in enduring love and success. Despite facing uncertainties and instability, they remain steadfast and resolute, never wavering and always staying true to themselves.
The chorus, with its repetition of "On the fussy format," reinforces the idea of adapting to life's twists and turns, embracing the challenges and blessings that come their way. It serves as a reminder to keep pushing forward, no matter what obstacles may arise. Overall, the lyrics of "Format" encourage resilience, perseverance, and a positive mindset in navigating life's unpredictable journey.
Line by Line Meaning
We fight we lie we strong
We face obstacles, deceive, but remain resilient
We sly we fall we run
We are cunning, stumble, but keep moving forward
And when we get up again We ball
After falling, we rise and excel
We on the side way up.. We on the
We are on the path to success
Season filled up with many blessings on the
Life is full of opportunities and blessings
I gat no time I keep on rolling on the
I have no time to waste, I keep moving forward
Balling to dawn wake in the morning on the
Continuously working towards success
Dreaming rockstar feeling like a king on the
Aspiring for greatness and confidence
Straight out up onto the sky ya
Aiming high towards the sky
Know the love is never gonna die ya
Believing in everlasting love
Straight up never going down ya
Consistently moving forward, never giving up
Shaky to the ground e going loud others fussy format
Despite challenges, we remain strong and determined on the path to success
We live we die we gone
Experiencing life, death, and departure
We here we there we none
Existing in different situations, yet together as one
But we go forming and we real one
We continue to evolve and remain authentic
We on the side way up We on the
We are on the journey to success
Yea yea on the fussy format
Embracing the meticulous process towards success
(We playing) men we rolling on the fussy format
Actively engaging in the detailed process towards success
Lyrics © O/B/O DistroKid
Written by: Ifeanyi Rex
Lyrics Licensed & Provided by LyricFind
Back To Back SWE
Table of Contents:
The Problem Introduction 0:00 - 2:11
The Code 2:11 - 8:08
Time Complexity 8:08 - 9:06
Space Complexity 9:06 - 10:22
Feed My Ego 10:22 - 10:44
Mistakes:
3:10 -> I misspoke and said: "divided by k does not equal 0". I meant "modded by k does not equal 0" (meaning that sumOfArrayItems is not divisible by k).
The code for this problem is in the description.
I spent 2 -3 hours thinking over the time complexity and searching online. In the rare event that I found someone who knew the time complexity, their explanation would fall short.
I will not tell you I know something unless I am 90%+ sure I am right so I did not cover the time complexity since it is NOT TRIVIAL to calculate for this problem for reasons stated in the video.
Space complexity is straightforward though depending on how you implement this problem.
This is a weak video because today I'm planning videos for the next 2-3 months. Didn't put many animations in it.
Jacob Your
Is there an algorithm for non-negative values (values greater than 0) that takes an int array and an int k as parameters, to count how many subarrays whose sum equals K and return the count?
The input array can have duplicates but as individual objects, they cannot be used twice or counted twice. The conditions are that the same element cannot be used twice, so every subarray should have a unique element or unique elements, so every object can end in one sub-array.
For instance, suppose that k, the target value is 13 and the input array is: {14, 13, 7, 6, 5, 8, 4, 9, 8, 5, 3}
Then the method should return the number of sub-arrays whose sum is equal to k, the target value which in this case is 13. The method should return 5. Since the sub-arrays whose sum is 13 are: {13}, {7,6}, {5,8}, {4,9}, {8,5}. We have two sub-arrays({5,8}) that have the same values but they are not the same objects, so we are good here and have used every unique element once to form a sub-array whose sum is equal to k.
14 is larger than the target so it will be discarded and 3 cannot be grouped with other elements to sum 13 because they all have been used in other subarrays, so 3 will be discarded as well.
Another condition that algorithm should return the highest possible count of sub-arrays whose sum is equal to k. If we have an input array like = {1,2,3,4,5,6} and the k is 10.
It would be wrong if we grouped it like this = {6,3,1} and {5,2,4} because we get just one subarray whose sum is equal to 10. It is wrong because we can group it like this = {6,4} and {5,2,3} and we get 2 subarrays whose sum is 10 and also the highest possible count of sub-arrays.
Xabier Moreno Pastor
Thank you very much for your amazing video. Keep doing more please, the code is missing in the video so I will add below. Thanks
class Solution {
public boolean canPartitionKSubsets(int[] nums, int k) {
int sumOfArrayItems = IntStream.of(nums).sum();
if(k == 0 || sumOfArrayItems % k != 0){
return false;
}
return canPartition(0, nums, new boolean[nums.length], k, 0, sumOfArrayItems/k);
}
public boolean canPartition(int iterationStart, int[] nums, boolean[] used, int k, int inProgressBucketSum, int targetBucketSum){
if(k == 1){
return true;
}
if(inProgressBucketSum == targetBucketSum){
return canPartition(0, nums, used, k-1, 0, targetBucketSum);
}
for(int i=iterationStart; i<nums.length;i++){
if(!used[i]){
used[i] = true;
if(canPartition(i+1, nums, used, k, inProgressBucketSum + nums[i], targetBucketSum)){
return true;
}
used[i] = false;
}
}
return false;
}
}
Karan A
nice solution , one addition
if we add this to base case : if(localSum > targetSum) return false
the speed of algo becomes 4X (leet code https://leetcode.com/submissions/detail/470932100/ vs https://leetcode.com/submissions/detail/470932075/ )
this is because , we don't let the algo overflow to numbers bigger than targetSum / no point finding more subsets with sum greater than targetSum
thank you for all your hard work and videos :)
Raafiul Hossain
I'm new but would this work?
# Partition To K Equal Sum Subsets From An Array of Integers - The Backtracking Approach
def function(A,N):
n=[[] for i in range(N)]
if len(A)==0:
return 0
if sum(A)%N !=0:
return 0
else:
goal_sum=sum(A)/N
return backtracking(A,n,goal_sum)
solution=[]
def backtracking(A,P,goal_sum):
if len(A)==0: # Our goal
solution.append(P)
else:
for box in P: # If first box doens't match, try second box, then third and etc.
if sum(box)+A[0]<=goal_sum:
box.append(A[0])
backtracking(A.pop(0),P,goal_sum) # Goes through all them in a Depth First manner.
function(A,N)
print(solution)
Back To Back SWE
Table of Contents:
The Problem Introduction 0:00 - 2:11
The Code 2:11 - 8:08
Time Complexity 8:08 - 9:06
Space Complexity 9:06 - 10:22
Feed My Ego 10:22 - 10:44
Mistakes:
3:10 -> I misspoke and said: "divided by k does not equal 0". I meant "modded by k does not equal 0" (meaning that sumOfArrayItems is not divisible by k).
The code for this problem is in the description.
I spent 2 -3 hours thinking over the time complexity and searching online. In the rare event that I found someone who knew the time complexity, their explanation would fall short.
I will not tell you I know something unless I am 90%+ sure I am right so I did not cover the time complexity since it is NOT TRIVIAL to calculate for this problem for reasons stated in the video.
Space complexity is straightforward though depending on how you implement this problem.
This is a weak video because today I'm planning videos for the next 2-3 months. Didn't put many animations in it.
Back To Back SWE
whaddup
Ashish Ranjan
Bro when u r going to post new videos in the list.... keep on doing gud works
NICK
Really appreciate these videos. I love watching Kevin Naughton Jr. for the high-level solutions and your videos for the conceptual deep dive into these challenges. Thank you!
Back To Back SWE
ye - thanks for watching!
Anand Ganesh
God-level explanation!! never thought this could turn out this easy! This also cleared out my thought in general while doing backtracking. Love you bro!
Artem Strashko
Thank you for turning a hard problem into a simple one!:)
Martin F
Really solid explanation, I was sort of stumped with the explanation on LC and this cleared it up. I believe the time complexity though is O(2^n) you are either picking or not picking the element so for n elements with two possibilities you could have two decision trees potentially of depth n.
Back To Back SWE
@Martin F It'd be fascinating though. I wish I could stay on these problems but too many to cover so I had to move along.
Martin F
@Back To Back SWE True you'd have to think about the worse case. I guess you'd have to think if its possible to have most at most N elements per N / K buckets then you have a tree of depth N / K and if it's possible to have a tree of N = K then you'd have 2 ^ (N / K * N) which might just be 2 ^ K, but haha no time to actually try and prove this.