INTK

intk

Google’s MLKit library finds text in images and this works well for simple text but for tabular data such as receipts or tables, it does not. If you’ve ever used an you might have noticed that it works reasonably well when scanning a page with uniform text but when dealing with any kind of tables or text formatting, it just falls flat. OCR app This article discusses an algorithm used in a mobile application I wrote that processes text to keep it in line. We’ll take a common example of a store receipt. In the example below you can see exactly the problem that I’m trying to solve. Lens does not prefer lines for text but will rather put together text that is physically closer together. This works sometimes but definitely does not work for receipts and other tabular data. See specifically how Google Lens put the price as a new line because it was physically far away from the lines on the left. Google 1,49€ is an application developed specifically to scan tabular data and the results of scanning a receipt are in the top right corner.  You can see how it respected the horizontal layout of the receipt and put the price together with the correct article. Line Text Scanner Google OCR library Here is a quick overview of how to use the OCR library: load an image and get text. Recognition of characters happens entirely on Google’s side. InputImage image = InputImage.fromBitmap(mSelectedImage, 0);
        TextRecognizer recognizer = TextRecognition.getClient();
        
        recognizer.process(image)
                .addOnSuccessListener(
                        new OnSuccessListener<Text>() {
                            @Override
                            public void onSuccess(Text texts) {
                                processTextRecognitionResult(texts);
                            }
                        })
                .addOnFailureListener(
                       // 
                        }); Full documentation is here and the diagram below is from this link. https://developers.google.com/ml-kit/vision/text-recognition/v2?embedable=true Once we have the Text object we can begin our own logic. We’ll try to process Text to do better than Google Lens. First, we need to look at the Text object. Text is a hierarchical representation of the scanned text as seen in the following diagram from Google’s documentation. The algorithm looks for characters and words in physical space and puts them into a hierarchical structure. As mentioned, this works well for easy text as in the diagram above but for tabular data like a receipt it does not. Below we have the full text of the receipt scanned by Google Lens. ENTRETIEN/BAZAR......
MPX FILM FRAICH30M
EPICERIE/BOISSONS.......
1,49€
265G POIS CHICHES HARICOTS ROUGES TR
0,95€
PECHE FRAICH FRTS
COOKIES SABLES CHO
1,25€
3,69€
2,39€
HYGIENE/BEAUTE.......
2,99€
20 ELAST COURTS WA
2 X BATISTE SHP SEC 6,59€ 13,18€
2è à -60%
-3,95€
MPX FIL DENTAIR 50 SOIN BLANCHEUR GOU
2,09€
7,29€
SURGELES/PRODUITS FRAIS...........
LAITIERE PV VANILL
1,69€
MALO F.FRAIS FRUIT COMTE AOP 6M 450G
2,35€
5,29€
QUICHE LORRAINE ESCAL.PANEES DE BL
2,79€
OEUFS PLEIN AIRX12
2,85€
MORIN MOUSSE CHOCO
3,25€
2,09€
LONGLEY FARM COT.C
1,99€
TOTAL HORS AVANTAGES
57,62€
18
NOMBRE D'ARTICLES I think that you’ll agree that this is not very useful. The algorithm picked the columns first rather than the rows. It made new lines for text that was far away. This is the difference in text processing that this article explores. Processing Text To demonstrate what MLKit does I’ve modified the application to only output the index of Text Elements (those are boxes with dark green border in the diagram from Google). In the screen below we can see text blocks 0 to 31. We can see how the MLKit library prefers physical distance to group words together into phrases. This is not exactly what Google Lens has outputted. We can see that Google Lens made the price of 1,49€ below the first three lines. It treated the text blocks differently but didn’t manage to output clear lines. As seen from this output, the OCR library makes up block 0 as ‘Entrentien/Bazar. MPX FILM FRAICH30M’. The second block is made up of multiple lines of the left column. The library continues to create text blocks from the left column and then moves to the right column to create the text blocks from prices. The image is correctly converted into characters and words. We’ll use these words but do it using a different algorithm to prefer lines to make our sentences. It’s clear that Google Lens also processes these blocks but obviously in yet another way. Breaking boxes Now to our algorithm. The first thing we’ll do is process all the TextBlocks from Text to extract the individual lines. Each line has one or more object and we extract them all and put them into a single  list. Text.Element List<Text.Element> textElements = new ArrayList<>();

        for (int i = 0; i < blocks.size(); i++) {
            Rect rect = blocks.get(i).getBoundingBox();
  
            List<Text.Line> lines = blocks.get(i).getLines();
  
            for (int j = 0; j < lines.size(); j++) {
                List<Text.Element> elements = lines.get(j).getElements();
                for (int k = 0; k < elements.size(); k++) {
                    Text.Element e = elements.get(k);
                    textElements.add(e);
                 }
            } At this point, we have an array of objects which all contain some text. In our example, the four in block 0 are 'ENTRETIEN/BAZAR......’, ‘MPX’, ‘FILM’, and ‘FRAICH30M’. All of the elements are put into a list. Text.Element Text.Elements Sorting boxes So now that we have all these objects in a list, how do we determine what goes after what? As seen from above, the OCR algorithm just recognized blocks of text but it made no effort to make correct sentences. First, we need to realize that object is bound by Rect object which has coordinates and dimensions. We use this fact to sort the . Text.Element Text.Element Text.Elements We take the top and left coordinates of the rectangles and sort them: public int compare(Text.Element t1, Text.Element t2) {
            int diffOfTops = t1.getBoundingBox().top - t2.getBoundingBox().top;
            int diffOfLefts = t1.getBoundingBox().left - t2.getBoundingBox().left;

            int height = (t1.getBoundingBox().height() + t2.getBoundingBox().height()) / 2;
            int verticalDiff = (int)(height * 0.35);

            int result = diffOfLefts;
            if (Math.abs(diffOfTops) > verticalDiff) {
                result =  diffOfTops;
            }
            return result;
        } The main decision in this algorithm is to decide whether one rectangle should go after another based on whether it is more to the right of it or more below it. The horizontal difference is easy, if one rectangle has coordinates more to the left of another rectangle then it will come before it. But this will be taken into consideration only if the difference in the tops is more than 35% height of the line. Basically, we allow for some skew in the picture-taking where the text might not align perfectly. But if a rectangle is 35% the height of the current rectangle below the next rectangle then we consider it as another line. Overall, in our algorithm, we prefer horizontal lines along which we can find the objects. Text.Element Making lines In this final processing step, we will make lines by processing the list above. Remember that the list just has rectangles and so we need to add a condition based on coordinates to decide whether to start a new line. To do this, we get the difference between the top of the boxes and take the average of their height. We don’t check the difference in location on the horizontal axis as we already did that when sorting boxes. Here we just have one decision to make: whether or not to make a new line. private boolean isSameLine(Text.Element t1, Text.Element t2) {
        int diffOfTops = t1.getBoundingBox().top - t2.getBoundingBox().top;
    
        int height = (t1.getBoundingBox().height() + t2.getBoundingBox().height()) * 0.35;

        if (Math.abs(diffOfTops) > height ) {
            return false;
        }
        return true;
    } This finally gives us the well-formatted tabular text. Here is the full text again. ENTRETIEN/BAZAR.  
MPX FILM FRAICH3OM 1,49€  
EPICERIE/BO1SSONS.  
265G POIS CHICHES 0,95€  
HARICOTS ROUGES TR 1,25e  
PECHE FRAICH FRTS 3,69e  
COOKIES SABLES CHO 2,39e  
HYGIENE/BEAUTE.....  
20 ELAST COURTS WA 2,99€  
2 X BATISTE SHP SEC 6,59€ 13,18€  
2è à -60% -3,95€  
MPX FIL DENTAIR 50 2,09e  
SOIN BLANCHEUR GOU 7,29€  
SURGELES/PRODUITS FRAIS....  
LAITIERE PV VANILL 1,69€  
MALO F.FRAIS FRUIT 2,35€  
COMTE AOP 6M 450G 5,29€  
QUICHE LORRAINE 2,79€  
ESCAL.PANEES DE BL 2,85e 
OEUFS PLEIN AIRX12 3,25€  
MORIN MOUSSE CHOCO 2,09e  
LONGLEY FARM COT.C 1,99e  
TOTAL HORS AVANTAGES 57,62e 
NOMBRE D'ARTICLES 18 Conclusion The solution to process the text in lines in this article is not without faults. The text should be relatively straight and not skewed too much. With some effort, we could calculate the vectors of lines even in the most crumpled receipt but that would be for another article. Here we show how a small tweak in treating the output of a large library can have a big effect for a very specific purpose. If you think that this is useful to you, the app is available in the . Google Play Store

Using Google MLKit Text Recognition to Scan Tabular Data

Introduction In the world of algorithms and data structures, there are many efficient methods that allow solving various problems with minimal computational resources. One such powerful tool is the Sliding Window Pattern, or the "sliding window" technique. This method allows you to confidently control the processing of data in sequences using a fixed-length dynamic window approach. The main idea of a sliding window is that instead of directly iterating or processing all data elements, we narrow the focus to a certain subset of elements that can be changed and updated as we move along the sequence. This technique finds application in various problems, from finding the maximum substring to time series analysis. In this article, we will introduce you to the concept of the Sliding Window Pattern by providing a brief description of the theory behind it. We will look at how this method works in the context of data processing, illustrating its application with practical examples. In addition, we will share useful tips on choosing the right situations for using a sliding window and optimizing your code. So, the first thing you want to do is identify a problem that utilizes the sliding window paradigm. How do you identify such a problem? The problem will be related to a data structure that is ordered and repeatable, such as an array or a string. You are looking for a certain subrange within this array/string, for example, the longest, shortest, or a target value. There exists an obvious naive or brute-force solution that works in O(N²), O(2^N), or some other large time complexity. Example 1 - How to Find the Longest Substring without Repeating Characters Task Description: Given a string , find the length of the without repeating characters. s longest substring Constraints: 0 <= s.length <= 5 * 10^4 consists of English letters, digits, symbols, and spaces. s Example 1: Input: s = "abcabcbb"
Output: 3
Explanation: The answer is "abc", with the length of 3. Example 2: Input: s = "bbbbb"
Output: 1
Explanation: The answer is "b", with the length of 1. Example 3: Input: s = "pwwkew"
Output: 3
Explanation: The answer is "wke", with the length of 3.
Notice that the answer must be a substring, "pwke" is a subsequence and not a substring. Brute force approach The idea is simple, we fix one letter and iterate over the rest of the string until we encounter a duplicate. We save all the letters in the set, and as soon as we find a duplicate letter, we shift the left border by 1 and start over. This is a simple but inefficient approach. Complexity: Time complexity: O(n*n) Space complexity: O(n) public int lengthOfLongestSubstring(String s) {
    int max = 0;
    for (int left=0; left<s.length(); stleftart++) {
        Set<Character> set = new HashSet<>();
        for (int right=left; right<s.length(); right++) {
            if (left != right && set.contains(s.charAt(right))) {
                break;
            }
            set.add(s.charAt(right));
         }
         max = Math.max(max, set.size());
    }
    return max;
} Sliding window approach The idea of optimization is that we don't want to do only 1 step as soon as we meet a duplicate and start all over again. We will move the left border as long as there is a duplicate. Complexity: Time complexity: O(n) Space complexity: O(n) public int lengthOfLongestSubstring(String s) {
    Set<Character> set = new HashSet<>();
    int max = 0;
    for (int i=0; i<s.length(); i++) {
         char c = s.charAt(i);
        if (set.contains(c)) {
            while (c != s.charAt(i - set.size())) {
                set.remove(s.charAt(i - set.size()));
            }
        } else {
            set.add(c);
        }
        if (set.size() > max) max = set.size();
    }
    return max;
} I want to note that I do not store the left border in a separate variable (although it is possible). Since the left border is only needed when we encounter a duplicate, so I know exactly how many unique characters there were: . set.size() Therefore, I can find the left border by the formula: . i - set.size() The algorithm listed above gives us the following result. Example 2 - Longest Repeating Character Replacement Task Description: You are given a string and an integer . You can choose any character of the string and change it to any other uppercase English character. You can perform this operation at most times. s k k Return . the length of the longest substring containing the same letter you can get after performing the above operations Constraints: 1 <= s.length <= 105 consists of only uppercase English letters. s 0 <= k <= s.length Example 1: Input: s = "ABAB", k = 2
Output: 4
Explanation: Replace the two 'A's with two 'B's or vice versa. Example 2: Input: s = "AABABBA", k = 1
Output: 4
Explanation: Replace the one 'A' in the middle with 'B' and form "AABBBBA".
The substring "BBBB" has the longest repeating letters, which is 4.
There may exists other ways to achive this answer too. Solution This is a standard problem for applying the technique, we must keep the "window" within certain constraints, in this case the constraint will be the presence of characters different from the most common. sliding window k The idea is to move and check that the area between and can be represented by a single character and we will make less than replacements. If more than replacements need to be made between and , then we will move until the rule is satisfied again. end start end k k start end start public int characterReplacement(String s, int k) {

    // Frequency map to store character frequencies within window
    Map<Character, Integer> charFreqMap = new HashMap<>();

    int start = 0; // Sliding window start
    int maxFreq = 0; // Store frequency of most frequent character within window
    int maxLength = 0; // Store maximum length of substring with same letters

    for (int end = 0; end < s.length(); end++) {
        char endChar = s.charAt(end);
        charFreqMap.put(endChar, charFreqMap.getOrDefault(endChar, 0) + 1);

        // Update maxFreq with current character's frequency
        maxFreq = Math.max(maxFreq, charFreqMap.get(endChar));

        // Calculate the number of characters that need to be replaced
        int replacementsNeeded = (end - start + 1) - maxFreq;

        // Check if replacements needed exceed k
        while (replacementsNeeded > k) {
            char leftChar = s.charAt(start);
            charFreqMap.put(leftChar, charFreqMap.get(leftChar) - 1);
            start++; // Move start to shrink window
        }

        // Update maxLen with current window size
        maxLength = Math.max(maxLength, end - start + 1);
    }
    return maxLength;
} I hope this article helped you understand how to solve this type of problem. I will be glad for your feedback. See you soon! ✌

Understanding the Sliding Window Pattern: Efficient Utilization Through Examples

According to Leetcode: We highly recommend Kth Largest Element in an Array, which has been asked many times in an Amazon phone interview. Task Given an integer array and an integer , return . nums k the kth largest element in the array Note that it is the largest element in the sorted order, not the distinct element. kth kth You must solve it in time complexity. O(n) Heap There are several ways to solve this task. The most straightforward is to iterate through the array and keep the top Kth largest element while iterating. For that purpose, a heap is the best data structure. The algorithm: iterate through the array and put each element to the heap if the heap size is greater than k - remove the smallest one(which will be at the beginning of our queue) return the first element class Solution {
    public int findKthLargest(int[] nums, int k) {
        PriorityQueue<Integer> heap = new PriorityQueue<>();
        for (int n: nums) {
          heap.add(n);
          if (heap.size() > k)
            heap.poll();
        }

        return heap.poll();        
  }
} We iterate through the array and each time we insert the element in the heap of length K, so the time complexity is O(NlogK). Can we do better? :) Quickselect time complexity First, let’s discuss high-level design, and then we can dive deeper. Here is a . link to the problem We need to find K-th largest element in the array. Since for us more comfortable sorting an array in non-decreasing order, let’s rephrase the task and say that we need to find the N-k smallest element in the array. The idea behind the algorithm is to use a partitioning algorithm from quickselect. We partition the whole array( time complexity). O(n) Then through away half of it and continue with another half( time complexity). O(n/2) Again through away half of it and continue with 1/4 of the original array ( time complexity). O(n/4) Continue doing so until we reach a single element. To summarize overall time complexity: n + n/2 + n/4 + n/8 +... ~ 2n = n You may be confused about time complexity thinking “wait, we are doing almost the same with binary search, it is logN time complexity, where is the logN part”. Well, you are right. The key point here is that not all partitions are doing the same amount of work. This more precise analysis, which uses the fact that the work done keeps decreasing on each iteration, gives the O(n) runtime. If you are still confused about time complexity take a look at and . this answer this article Partition algorithm(Lomuto partitioning scheme) One chooses a pivot and defines its position in a sorted array in a linear time using so-called . partition algorithm The toughest thing in this algorithm is understanding how the partition works. Let’s imagine we have an array [2,6,3,4,7,1,8,5]. With the Lomuto partitioning scheme the algorithm will look like this: choose the last element as a pivot create 2 pointers, and , both starting from the beginning of the target interval. i startIndex The first pointer will scan the whole interval and check the condition - if the value at is less than the pivot then swap it with the value at the pointer and increment i i startIndex startIndex swap the pivot(which is placed at the end of the array) with the value at (since this is a place for our pivot value) and return . startIndex startIndex To achieve that we need a single for loop and dedicated variable startIndex which is equal to the index of the first element in the array(in our case it is 0). Now we ended up with storeIndex = 3, which is actually a place for our pivot element. We can swap them and return this pivot index. The array looks like , pivot index is 3. [2,3,4,5,7,6] public void swap(int i, int j) {
  int temp = nums[i];
  nums[i] = nums[j];
  nums[j] = temp;
}

public int partition(int start, int end) {
  int pivot = nums[end];
  int storeIndex = start;
  for (int i = start; i <= end; i++) {
    if (nums[i] < pivot) {
      swap(i, storeIndex);
      storeIndex++;
    }
  }
  //don't forget to move pivot element from the end of the array to its position
  swap(end, storeIndex);
  return storeIndex;
} Random pivot The worst case of this algorithm will be O(n^2). Why is that so? The algorithm is sensitive to the pivot that is chosen. Imagine you have already sorted the array and each time you select the first element as a pivot. That means each partition will decrease the range of the elements only by 1. To avoid this, we need to select a random pivot each time: Random random = new Random();
//asume that 'start' is an index of the first element in search interval of the array
//and 'end' is an index of the last element in that interval, then:
int pivot = left + random.nextInt(right - left); Quickselect algorithm At last, we need to implement a quickselect algorithm. The steps are: select a random pivot partition array with this pivot and return its new index if the index is equal to N - k, then we find our value, otherwise select one of the two parts of the array, and repeat the algorithm Here is the source code: class Solution {
    int[] nums;
    public void swap(int i, int j) {
      int temp = nums[i];
      nums[i] = nums[j];
      nums[j] = temp;
    }

    public int partition(int start, int end, int pivotIndex) {
      int pivot = nums[pivotIndex];
      //move pivot to the end of the array;
      swap(end, pivotIndex);
      int startIndex = start;
      for (int i = start; i <= end; i++) {
        if (nums[i] < pivot) {
          swap(i, startIndex);
          startIndex++;
        }
      }
      //don't forget to move pivot element from the end of the array to its position
      swap(end, startIndex);
      return startIndex;
    }
    public int findKthLargest(int[] nums, int k) {
        this.nums = nums;
        return quickselect(0, nums.length - 1, nums.length - k);
    }
    public int quickselect(int start, int end, int k) {
        if (start == end) {
            return nums[start];
        }
        Random random = new Random();
        int pivotIndex = start + random.nextInt(end - start);
        pivotIndex = partition(start, end, pivotIndex);
        if (pivotIndex == k) {
            return nums[pivotIndex];
        }
        if (pivotIndex < k) {
            return quickselect(pivotIndex + 1, end, k);
        }
        return quickselect(start, pivotIndex - 1, k);
    }
}

Kth Largest Element in an Array - Quickselect Using Lomuto Partitioning Scheme.

Description of the Situation: We have an arbitrary binary tree, a node of that tree, and also an integer: 'K.' We need to print all such nodes which have a distance K from the given node and return the list of these nodes. You can check out this problem here as well: . Print Nodes at Distance k from Node The distance between the two nodes in a binary tree is defined as the number of connections/edges in the path between the two nodes. Let’s see an example: Let's examine the tree shown in the diagram: = pointer to node with data 8. Inputs: target = pointer to node with data 20. root k = 2. 10 14 22 Output : If the target is 14 and k is 3, then the output  should be “4 20.” In this type of node, two types of nodes are to be considered: 1. The target node is rooted in the subtree. If the value of k is 2 and the target node is 8, for example, such nodes are 10 and 14. 2. Other nodes could be a target's ancestor or a node in a different subtree. This category includes node 22 for target node 8 when k is 2. Finding the first type of node is straightforward. In a recursive call, simply visit subtrees rooted with the target node and decrement k. As soon as k becomes 0, print the node that is currently being traversed. So, we will call a new function printkdistance(). And we must go through all ancestors for the output nodes that are not in the subtree that has the target node as the root. We calculate the distance between each ancestor and the target node, d. We then travel to the ancestor's other subtree (if the target was discovered in the left subtree, we go to the right subtree, and vice versa) and find all nodes at k-d distance from the ancestor. Let’s see how can we implement this approach: int data;
	Node left, right; {
		data = item; }
} Node root; { } {
			System.out.print(node.data); } } { } {
			printkdistance(node, k); } int dl = printkdistanceNode(node.left, target, k); { {
				System.out.print(node.data); } } int dr = printkdistanceNode(node.right, target, k); { {
				System.out.print(node.data); } } } Node target = tree.root.left.right; }
} // This is a java program //to print nodes at a distance k from the given node // A Node of a Binary Tree class Node { Node ( int item ) left = right = null ; class BinaryTree { // Recursive function that will help to print all the nodes at distance k in // tree (or subtree) rooted with a given root. void printkdistance ( Node node, int k ) // Base Case will be, if (node == null || k < 0 ) { return ; // If we find a k distant node, we'll print it if (k == 0 ) System.out.println( "" ); return ; // Recursion for left and right subtrees printkdistance(node.left, k- 1 ); printkdistance(node.right, k- 1 ); // Prints nodes at a distance k from a given target node. // The nodes that are at k distance may be in an up or down direction. // This function will return the distance of the root node from the target node. // And, it will return -1 if the target node is not present in a tree rooted with the root // node. int printkdistanceNode ( Node node, Node target, int k ) // The First Base Case: If the tree is empty, then return (-1). if (node == null ) { return - 1 ; // If the target is the same as the root node. We will use the downward // function that will print all nodes at distance k in the subtree rooted with // target or root if (node == target) return 0 ; // Recursion for left subtree. // Check if the target node was in the left subtree. if (dl != - 1 ) // If the root is at k distance from the target, then print the root node. // Note that the distance of root's left child from the target is dl. if (dl + 1 == k) System.out.println( "" ); // Else go into the right subtree and print all the nodes that are at distance of k-dl-2. // Note that the right child is only 2 edges away from the left child. else printkdistance(node.right, k - dl - 2 ); // Now, add 1 to the distance and return the value for parent calls. return 1 + dl; // Now, we will MIRROR THE ABOVE CODE FOR THE RIGHT SUBTREE as well. // Note that we will reach here only when node was not found in left // subtree if (dr != - 1 ) if (dr + 1 == k) System.out.println( "" ); else printkdistance(node.left, k - dr - 2 ); return 1 + dr; // If target is neither in the left nor in the right subtree return - 1 ; // To test the above functions, a Driver Program public static void main ( String args[] ) { BinaryTree tree = new BinaryTree(); /* Let us make the tree as shown in above diagram */ tree.root = new Node( 20 ); tree.root.left = new Node( 8 ); tree.root.right = new Node( 22 ); tree.root.left.left = new Node( 4 ); tree.root.left.right = new Node( 12 ); tree.root.left.right.left = new Node( 10 ); tree.root.left.right.right = new Node( 14 ); tree.printkdistanceNode(tree.root, target, 2 ); Output: 4 20 In this approach, no node is being traversed more than twice. So, the time complexity is O(n). Time Complexity: Another Approach: First, get the Path from the Root Node and add it to a list. For every 'i' th element from Path, just iterate and print nodes that are at '(K-i)'th distance. public int val;
	public TreeNode left;
	public TreeNode right; } { discoverPath(root, target); findKDistance(
				path.get(i), K - j, answer, } } { } answer.add(node.val);
		} } { path.add(node); } } { TreeNode target = root.left.right; }
} import java.io.*; import java.util.*; class TreeNode { public TreeNode ( ) {} public TreeNode ( int val ) { this .val = val; } class CodingNinjas { List<TreeNode> path = null ; //Finding the nodes that are at a distance of K from the target node. public List<Integer> distanceK ( TreeNode root, TreeNode target, int K ) path = new ArrayList<>(); List<Integer> answer = new ArrayList<>(); for (int j= 0 ; j<path.size(); j++) { j == 0 ? null : path.get(j - 1 )); //Now return the list of all nodes at a distance K. return answer; // Blocker is used for nodes that are ancestors; if the target is at left, then we will // have to go right, or if the target is at right, then we will have to go left. public void findKDistance ( TreeNode node, int dist, List<Integer> answer, TreeNode blocker ) if (dist < 0 || node == null || (blocker != null && node == blocker)) { return ; if (dist == 0 ) { findKDistance(node.left, dist - 1 , answer, blocker); findKDistance(node.right, dist - 1 , answer, blocker); //To find the path of the target node from the root node. public boolean discoverPath ( TreeNode node, TreeNode target ) if (node == null ) return false ; if (node==target || discoverPath(node.left, target) || discoverPath(node.right, target))   { return true ; return false ; public static void main ( String [] args ) CodingNinjas codingninjas = new CodingNinjas(); /* Let us make the tree shown in above diagram */ TreeNode root = new TreeNode( 20 ); root.left = new TreeNode( 8 ); root.right = new TreeNode( 22 ); root.left.left = new TreeNode( 4 ); root.left.right = new TreeNode( 12 ); root.left.right.left = new TreeNode( 10 ); root.left.right.right = new TreeNode( 14 ); System.out.println(codingninjas.distanceK(root, target, 2 )); Output: [4, 20] Conclusion In this article, we have studied how to print Nodes at Distance k from Node. We hope that this article has provided you with the help to enhance your knowledge regarding Binary Tree.

Learning to Code: Print Nodes at Distance K From Node

Today’s Bug When Doing Custom JSON Marshal in Golang So, today’s bug and a lesson to be learned is about non/pointer receiver function, it happens when I’m doing custom marshal JSON for my struct. I’m stuck for a few hours when to fix this. So the scenario is, I have a struct let’s say a ClassRoom struct, and the ClassRoom has many students. Every student ranked ascending by their mark or something whatever it is :D, this is just an example to describe how is our real case struct. It’s similar, but different in name. type ClassRoom struct {
 Name     string Students map[int]Student }
type Students struct {
 Name string Age  int } `json:"name"` `json:"students"` `json:"name"` `json:"age"` With this struct, if we marshall it to JSON, the result will looks like this: { : , : { : { : , : }, : { : , : }, : { : , : }
  }
} "name" "D3TI2-Classmate" "students" "1" "name" "Iman Tumorang" "age" 17 "2" "name" "Christin Tumorang" "age" 18 "3" "name" "Idola Manurung" "age" 18 But for requirement to API, we want the JSON result is without the student’s rank. We just want looks like this: { : , : [
    { : , : },
    { : , : },
    { : , : }
  ]
} "name" "D3TI2-Classmate" "students" "name" "Iman Tumorang" "age" 17 "name" "Christin Tumorang" "age" 18 "name" "Idola Manurung" "age" 18 Well, based on my experience, to do this in Golang is very easy. We just create a function with the ClassRoom as the receiver with the same name as the function name in interface of Marshaler func (s ClassRoom) MarshalJSON() ([]byte, error) { := []Student{}
 arrKey := []int{} k, := range s.Students {
  arrKey = append(arrKey, k)
 }
 sort.Ints(arrKey) _, := range arrKey {
  arrStudent = append(arrStudent, s.Students[pos])
 } json.Marshal(struct {
  Name     string Students []Student }{ :     s.Name, : arrStudent,
 })
} arrStudent for _ for pos return `json:"name"` `json:"students"` Name Students Just simple as that. But then, when I’m trying to test it. The JSON results is not right as we expected. And I’m stucked for a few hours in this issue :D *so fool I am 😅 Issue Before the code fixed, the code is more like this below. If we see here, it’s like nothing wrong here. But the result is wrong. package main ( )

func main() { := map[int]Student{ : Student{ : , : ,
		}, : Student{ : , : ,
		}, : Student{ : , : ,
		},
	}

	sample := ClassRoom{ : , : students,
	}

	jbyt, := json.Marshal(sample) err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(jbyt))

}

type ClassRoom struct {
	Name     string Students map[int]Student }
type Student struct {
	Name string Age  int }

func (s *ClassRoom) MarshalJSON() ([]byte, error) { := []Student{}
	arrKey := []int{} k, := range s.Students {
		arrKey = append(arrKey, k)
	}
	sort.Ints(arrKey) _, := range arrKey {
		arrStudent = append(arrStudent, s.Students[pos])
	} json.Marshal(struct {
		Name     string Students []Student }{ : arrStudent, :     s.Name,
	})
} import "encoding/json" "fmt" "log" "sort" students 1 Name "Iman Tumorang" Age 17 2 Name "Christin Tumorang" Age 18 3 Name "Idola Manurung" Age 18 Name "D3TI2-Classmate" Students err if `json:"name"` `json:"students"` `json:"name"` `json:"age"` arrStudent for _ for pos return `json:"name"` `json:"students"` Students Name Fixing After tired of searching solutions, then I figured it later when I accidentally call the JSON marshall with a pointer object. sample := &ClassRoom{ Name: , : students,
 }
_,_= json.Marshal(sample) // See the ampersand symbol "&" "D3TI2-Classmate" Students That’s the problem. In my custom MarshalJSON I make the receiver is a pointer. So my custom MarshalJSON won’t called if I try to marshal a non-pointer object. But, if I marshal a non-pointer object, it will succeed to marshal. So to summarize: If I made the custom MarshalJSON with a receiver pointer func (s *ClassRoom)MarshalJSON() ([]byte, error){ } // Other codes Then when I want to marshal the Object, I must pass a object to pointer json.Marhsal sample := &ClassRoom{ Name: , : students,
 }
_,_= json.Marshal(sample) // See the ampersand symbol "&" "D3TI2-Classmate" Students And it also vise versa for receiver. non-pointer (value) func (s ClassRoom)MarshalJSON() ([]byte, error){ } // Other codes If I made the custom MarshalJSON with a receiver non-pointer (value) func (s ClassRoom)MarshalJSON() ([]byte, error){ } // Other codes Then when I want to marshal the Object, I must pass a object to non-pointer (value) json.Marhsal sample := ClassRoom{ Name: , : students,
 }
_,_= json.Marshal(sample) // Without the ampersand symbol "&" "D3TI2-Classmate" Students Well, this is a very silly issue for me, because it’s really made me furious for a few hours. And it’s made me more cautious when deciding using a or receiver in function. pointer non pointer

Today I Learned: Beware with pointer in Golang!!!

What’s the Hype About Hyperledger Sawtooth Hyperledger Sawtooth is an open source Blockchain platform founded by the Linux Foundation’s open-source blockchain project, Hyperledger. Proposed by Intel, it is an enterprise-grade distributed ledger and was one of the first projects under the Hyperledger Umbrella. With a pluggable consensus model, Hyperledger Sawtooth is : Modular Scalable Supports Permissionless and Permissioned Infrastructure. Its underlying design is aimed at keeping ledgers distributed and adding business logic to smart contracts. In many standard blockchain based platforms, applications and core are executed and hosted on their platform, that may cause performance issues and security concerns. However, Hyperledger Sawtooth is different from such platforms in a way that it isolates the core ledger system from the application specific environment. As a result, it simplifies the application development yet keeps the system safe and secure. With Sawtooth’s modular architecture, developers can develop applications in the programming language of their choice and can host, run and operate it on system periphery without hindering the core blockchain system. An application on Hyperledger Sawtooth can be based on a core business logic to run business operations, or it can be built and run as a smart contract virtual machine with a self-governing mechanism to create, notify and execute the contracts between various members on the blockchain network. Sawtooth’s core system allows both of these applications to co-exist, allowing different types of applications to stay in the same instance of the blockchain network. Applications on Sawtooth can select transaction rules, define the consensus mechanisms and select the required permissioning to decide the working of the digital ledger in a way that it meets the requirements of an enterprise. Being extremely scalable. Hyperledger Sawtooth can offer high transaction throughput of data and is, therefore, a great option for handling production supply chains. Features of Hyperledger Sawtooth **Private networks with the permissioning features**Sawtooth overcomes the challenges of the permissioned network as the cluster of its nodes can be deployed with isolated permissioning. No centralized service can leak confidential information or transaction patterns. The blockchain manages the settings that specify identities and roles so that participants within the network can access the information on the network. **Ethereum Contract Compatibility with Seth**The Seth, Sawtooth-Ethereum integration project allows the interoperability of the Sawtooth platform to Ethereum. The project makes it possible for Ethereum smart contracts to get deployed to the Sawtooth platform with Seth transaction family. **Parallel Transaction Execution**Many blockchains need serial transaction execution to ensure consistent ordering at every node on the network. However, Sawtooth contains an advanced parallel scheduler that classifies transactions into parallel flows. Based on locations in state accessed by a transaction, Sawtooth separates the transactions’ execution from one another while handling contextual changes. Transactions in Sawtooth are executed parallelly to prevent double spending even with several modifications to the same state. This type of scheduling leads to the potential increase in performance as compared to serial execution. **Isolation between the core system and the application level**Hyperledger Sawtooth eases the development and deployment of an application by separating the application level from the core system level. It offers smart contract abstraction to allow developers to create contract logic in the programming language of their choice. Each application can define the custom transaction processors to meet the unique requirements. It provides transaction families to serve as an approach for low-level functions, like storing on-chain permissions, managing chain-wide settings and for particular applications such as saving block information and performance analysis. **Pluggable Consensus Mechanisms**The consensus mechanism is the process of coming to an agreement among a group of participants on the blockchain network. Algorithms for achieving consensus with arbitrary faults need some kind of voting among a specific set of participants.General consensus approaches comprise Nakamoto-style consensus that selects a leader through the lottery and variants of Byzantine Fault Tolerance mechanisms that run multiple rounds of explicit voting to form a consensus.Sawtooth supports multiple consensus types on the same blockchain which is chosen initially during the network setup and can be changed on a running blockchain with a transaction. It supports the following consensus implementations: **Proof of Elapsed Time (PoET):**It is a Nakamoto-style consensus, designed as a production-grade protocol that can support large network populations. Relying on a secure instruction execution, it can achieve the scalability of Nakamoto-style consensus mechanism without the drawbacks of power consumption of the PoW algorithm. **PoET Simulator:**It enables PoET-style consensus on any hardware and a virtualized cloud environment. **Dev mode:**It is a simplified random-leader mechanism used for development and testing. **Sample Transaction Families**Transaction language and the data model are implemented in a transaction family. Though users can build custom transaction families to represent their unique requirements, Sawtooth also provides various transaction families as models: for testing deployed ledgers.2. for managing on-chain permissioning for validator and transactor keys to simplify identity management for public keys’ lists.3. to provide an implementation for saving on-chain configuration settings.4. for providing an approach to store information about a number of historic blocks.5. for managing performance analysis for performance testing and benchmarking when doing the comparison of blockchain systems’ performance. IntegerKey Identity Settings BlockInfo Smallbank Getting started with Hyperledger Sawtooth Application Development? Image Source: Hyperledger Sawtooth Documentation You will have to set up and execute a local validator to test your application before you start developing an application on Hyperledger Sawtooth platform. Once the network will be running, you can conduct new transactions and fetch the block data and resulting state from the blockchain via Sawtooth REST API and HTTP. Sawtooth validators can run from prebuilt Docker containers which are installed using Ubuntu 16.904 or deployed in AWS from the AWS marketplace. We will walk you through the process of Hyperledger Sawtooth Application Development using Docker Compose. Installing Docker Engine and Docker Compose **Windows:**Docker Compose can be installed automatically when you install . Docker Engine on Windows **Linux:**On the Linux operating system, you will need to install both and . Docker Engine Docker Compose **macOS:**On macOS, you will have to install the latest version of the . Similar to Windows, Docker Compose is also installed automatically with Docker Engine on macOS. Docker Engine Setting up Environment A Docker Compose file is provided to state the process for building a Sawtooth environment. The Sawtooth environment comprises of the following containers: REST API connected to the validator A client container to run Sawtooth commands A single validator that uses dev-mode consensus The Settings, XO transaction processors and IntegerKey Docker Compose file also represents the container images to obtain from Docker Hub and the network settings required for containers to interact correctly. The Docker Compose File serves as the basis for the multi-container Sawtooth application development environment. Download the Docker Compose File and set up the environment for the development of Sawtooth application. Starting up the Sawtooth environment involves the following tasks: Open a terminal window. Switch the working directory to the same directory where you stored the Docker Compose file. Run the command: % docker-compose -f sawtooth-default.yaml up Downloading of the docker images may take a few minutes. After you find the containers registering and building initial blocks, move to the next step. In case the environment needs to be stopped or reset, you need to log out of the client container to return to the default state and then press CTRL- C from the Windows system where you initially executed docker-compose. How to Create and Submit transactions to the Sawtooth network Sawtooth provides the intkey command to make sample transactions of the IntegerKey (intkey) transaction type for testing. This method uses intkey for preparing batches of intkey transactions that assign a few keys to random values, then increase and decrease those values randomly. These batches are stored locally and distributed to the validator within the network. Run the mentioned-below commands from the client container: $ intkey create_batch — count 10 — key-count 5 $ intkey load -f batches.intkey -U The terminal window where you ran the docker-compose command will start logging output as a validator and intkey transaction processor manages the transactions submitted recently. http://rest-api:8008 Rather than using intkey load, you can also use “sawtooth batch submit” command to submit transactions. For instance, submit the transactions in batches.intkey file with the command: $ sawtooth batch submit -f batches.intkey — url http://rest-api:8008 Viewing the Blockchain Following are the different commands for viewing the block, list of blocks, a specific block and global state: sawtoothblockThis subcommand is used to see the blocks saved in the blockchain. sawtoothblocklistThis command is used to view the blocks stored by the state. sawtooth block show — url {BLOCK_ID}This command is used to view a specific blockchain using a block ID. http://rest-api:8008 sawtoothstatelistThis command is used for listing the nodes in the Merkle tree. sawtooth state show — url {STATE_ADDRESS}This command is used to view the data at a specific address. http://rest-api:8008 Connecting to the REST API Use the command “$ curl http://rest-api:8008/blocks" to ensure that you can connect to the REST API via the host. To connect the REST API from the host, use the command: “$ curl http://localhost:8008/blocks". Due to the potential of Hyperledger Sawtooth to build modular and scalable blockchain apps, it is being used widely by blockchain companies to provide blockchain business solutions to enterprises and startups. Shameless Plug a.k.a Our Work on Hyperledger Sawtooth We have built a distributed ledger platform called on the Hyperledger Sawtooth that enables end-to-end traceability across the pharma supply chain on the blockchain. The platform allows UNO to track the distribution of free aid and perform recalls quickly. TraceRx Image Source: LeewayHertz At LeewayHertz, we have a team of Blockchain Consultants who can assist companies and individuals interested in advancing their business operations with distributed ledger technology. <a href="https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href">https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href</a>

An Introduction to Hyperledger Sawtooth and a Guide to Setting It Up

What is the 500 Internal Server Error Mean and How Do I Fix It?

While GitHub is primarily known for version control and hosting code, it also hides some of the best resources for tech jobs and internships. I manually curated 9 of my favorite repositories with amazing career opportunities, divided across categories and with application links for each. From software engineering roles to AI-focused internships, remote jobs, and open-source opportunities, both beginners and seasoned devs are welcome! I hope that this article will be useful for you to land your dream job or secure an internship role! Wishing you the best of luck in your tech career journey! 1. Summer Internships 2025 ⭐ GitHub stars: 35.2K+ A curated list of computer science, software, tech, and quant internships for Summer 2025, updated collaboratively by the community. 👉 https://github.com/SimplifyJobs/Summer2025-Internships Who is it for: College students and recent graduates in technical fields seeking internship opportunities across various companies. How to apply: Browse the list, identify roles of interest, and follow the application links provided for each opportunity. 2. Open Source Internships Programs ⭐ GitHub stars: 3.8K+ A comprehensive directory of open-source internship programs, with timeline, eligibility, stipend, and tech stack focus details. 👉 https://github.com/deepanshu1422/List-Of-Open-Source-Internships-Programs Who is it for: Beginners and seasoned developers interested in contributing to open-source projects and gaining industry experience. How to apply: Check the deadlines and program details listed, and follow the official application instructions provided for each program. 3. SWE College Jobs 2025 ⭐ GitHub stars: 1.8K+ A collection of software engineering internships and new graduate positions. Daily updated roles for both the US and international scope. 👉 https://github.com/speedyapply/2025-SWE-College-Jobs Who is it for: Perfect for students pursuing computer science or related degrees looking for hands-on software engineering roles. How to apply: Use the provided apply links and follow the instructions to submit your application for the role. 4. AI College Jobs 2025 ⭐ GitHub stars: 400+ A dedicated list of artificial intelligence, machine learning, and data science jobs. Available roles for both the US and internationally, and updated daily. 👉 https://github.com/speedyapply/2025-AI-College-Jobs Who is it for: Well suited for college students interested in AI technologies and looking for internships in this growing field. How to apply: Find the company and niche of your interest and follow the direct application links for AI internship positions. 5. Remote Jobs ⭐ GitHub stars: 30K+ A comprehensive list of remote-friendly companies that offer tech roles globally. 👉 https://github.com/remoteintech/remote-jobs Who is it for: Developers, designers, and other tech professionals of various experience levels looking for fully remote job opportunities. How to apply: Explore the companies to read more about their tech stacks, size, and mission, and apply via the links provided. 6. Tech Jobs with Relocation ⭐ GitHub stars: 3.2K+ A collection of tech jobs and internships that offer relocation support, helping you find roles in cities or countries of your choice. 👉 https://github.com/AndrewStetsenko/tech-jobs-with-relocation Who is it for: Professionals open to moving internationally for tech roles, looking to expand their horizons, and seeking new adventures. How to apply: Follow the links to company career pages, and apply directly for relevant roles. Also, lots of valuable info about work permits, visas, etc. 7. Easy Application ⭐ GitHub stars: 7.8K+ A collection of job applications that require minimal to apply. This lets candidates focus on their application, rather than meticulously fill out lengthy forms. 👉 https://github.com/j-delaney/easy-application Who is it for: Job seekers who prefer simple application processes by uploading their resume and experience straight-forward UX. How to apply: Leverage the provided links to the company career pages. 8. Hiring Without Whiteboards ⭐ GitHub stars: 46.4K+ A directory of companies that evaluate technical candidates through non-traditional methods, often avoiding whiteboard interviews. 👉 https://github.com/poteto/hiring-without-whiteboards Who is it for: Developers who value practical coding challenges and real-world problem-solving over theoretical interviews. How to apply: Use the list to find companies, read more about their interview process, and follow their specific application guidelines. 9. Community Writer Programs ⭐ GitHub stars: 3.9K+ A list of programs that reward technical writers for creating content, including blog posts in the IT field, tech reviews, and tutorials. 👉 https://github.com/malgamves/CommunityWriterPrograms Who is it for: Developers and writers looking to earn money and recognition through technical writing by sharing their expertise and insights. How to apply: Select a program, read the guidelines, and submit content proposals directly. You might be required to provide a blog link or sample work. Did You Like The Resources? Here Is More 👇 Join 6000+ others to receive the best DEV resources, tools, productivity tips, and career growth advice I discover by subscribing to my newsletter! Also, connect with me on Twitter, LinkedIn, and GitHub! Writing has always been my passion and it gives me pleasure to help and inspire people. If you want to get featured or partner up, feel free to get in touch! Also published here. While GitHub is primarily known for version control and hosting code, it also hides some of the best resources for tech jobs and internships. I manually curated 9 of my favorite repositories with amazing career opportunities, divided across categories and with application links for each. From software engineering roles to AI-focused internships, remote jobs, and open-source opportunities, both beginners and seasoned devs are welcome! I hope that this article will be useful for you to land your dream job or secure an internship role! Wishing you the best of luck in your tech career journey! 1. Summer Internships 2025 Summer Internships 2025 ⭐ GitHub stars: 35.2K+ ⭐ GitHub stars: 35.2K+ A curated list of computer science, software, tech, and quant internships for Summer 2025, updated collaboratively by the community. 👉 https://github.com/SimplifyJobs/Summer2025-Internships https://github.com/SimplifyJobs/Summer2025-Internships Who is it for: College students and recent graduates in technical fields seeking internship opportunities across various companies. Who is it for: How to apply: Browse the list, identify roles of interest, and follow the application links provided for each opportunity. How to apply: 2. Open Source Internships Programs Open Source Internships Programs ⭐ GitHub stars: 3.8K+ ⭐ GitHub stars: 3.8K+ A comprehensive directory of open-source internship programs, with timeline, eligibility, stipend, and tech stack focus details. 👉 https://github.com/deepanshu1422/List-Of-Open-Source-Internships-Programs https://github.com/deepanshu1422/List-Of-Open-Source-Internships-Programs Who is it for: Beginners and seasoned developers interested in contributing to open-source projects and gaining industry experience. Who is it for: How to apply: Check the deadlines and program details listed, and follow the official application instructions provided for each program. How to apply: 3. SWE College Jobs 2025 SWE College Jobs 2025 ⭐ GitHub stars: 1.8K+ ⭐ GitHub stars: 1.8K+ A collection of software engineering internships and new graduate positions. Daily updated roles for both the US and international scope. 👉 https://github.com/speedyapply/2025-SWE-College-Jobs https://github.com/speedyapply/2025-SWE-College-Jobs Who is it for: Perfect for students pursuing computer science or related degrees looking for hands-on software engineering roles. Who is it for: How to apply: Use the provided apply links and follow the instructions to submit your application for the role. How to apply: 4. AI College Jobs 2025 AI College Jobs 2025 ⭐ GitHub stars: 400+ ⭐ GitHub stars: 400+ A dedicated list of artificial intelligence, machine learning, and data science jobs. Available roles for both the US and internationally, and updated daily. 👉 https://github.com/speedyapply/2025-AI-College-Jobs https://github.com/speedyapply/2025-AI-College-Jobs Who is it for: Well suited for college students interested in AI technologies and looking for internships in this growing field. Who is it for: How to apply: Find the company and niche of your interest and follow the direct application links for AI internship positions. How to apply: 5. Remote Jobs Remote Jobs ⭐ GitHub stars: 30K+ ⭐ GitHub stars: 30K+ A comprehensive list of remote-friendly companies that offer tech roles globally. 👉 https://github.com/remoteintech/remote-jobs https://github.com/remoteintech/remote-jobs Who is it for: Developers, designers, and other tech professionals of various experience levels looking for fully remote job opportunities. Who is it for: How to apply: Explore the companies to read more about their tech stacks, size, and mission, and apply via the links provided. How to apply: 6. Tech Jobs with Relocation Tech Jobs with Relocation ⭐ GitHub stars: 3.2K+ ⭐ GitHub stars: 3.2K+ A collection of tech jobs and internships that offer relocation support, helping you find roles in cities or countries of your choice. 👉 https://github.com/AndrewStetsenko/tech-jobs-with-relocation https://github.com/AndrewStetsenko/tech-jobs-with-relocation Who is it for: Professionals open to moving internationally for tech roles, looking to expand their horizons, and seeking new adventures. Who is it for: How to apply: Follow the links to company career pages, and apply directly for relevant roles. Also, lots of valuable info about work permits, visas, etc. How to apply: 7. Easy Application Easy Application ⭐ GitHub stars: 7.8K+ ⭐ GitHub stars: 7.8K+ A collection of job applications that require minimal to apply. This lets candidates focus on their application, rather than meticulously fill out lengthy forms. 👉 https://github.com/j-delaney/easy-application https://github.com/j-delaney/easy-application Who is it for: Job seekers who prefer simple application processes by uploading their resume and experience straight-forward UX. Who is it for: How to apply: Leverage the provided links to the company career pages. How to apply: 8. Hiring Without Whiteboards Hiring Without Whiteboards ⭐ GitHub stars: 46.4K+ ⭐ GitHub stars: 46.4K+ A directory of companies that evaluate technical candidates through non-traditional methods, often avoiding whiteboard interviews. 👉 https://github.com/poteto/hiring-without-whiteboards https://github.com/poteto/hiring-without-whiteboards Who is it for: Developers who value practical coding challenges and real-world problem-solving over theoretical interviews. Who is it for: How to apply: Use the list to find companies, read more about their interview process, and follow their specific application guidelines. How to apply: 9. Community Writer Programs Community Writer Programs ⭐ GitHub stars: 3.9K+ ⭐ GitHub stars: 3.9K+ A list of programs that reward technical writers for creating content, including blog posts in the IT field, tech reviews, and tutorials. 👉 https://github.com/malgamves/CommunityWriterPrograms https://github.com/malgamves/CommunityWriterPrograms Who is it for: Developers and writers looking to earn money and recognition through technical writing by sharing their expertise and insights. Who is it for: How to apply: Select a program, read the guidelines, and submit content proposals directly. You might be required to provide a blog link or sample work. How to apply: Did You Like The Resources? Here Is More 👇 Join 6000+ others to receive the best DEV resources, tools, productivity tips, and career growth advice I discover by subscribing to my newsletter! my newsletter ! my newsletter Also, connect with me on Twitter , LinkedIn , and GitHub ! Twitter Twitter LinkedIn LinkedIn GitHub GitHub Writing has always been my passion and it gives me pleasure to help and inspire people. If you want to get featured or partner up, feel free to get in touch ! get in touch get in touch Also published here . here

How to Find a Job or Internship in Tech With These 9 GitHub Repositories (2025 Guide)📚🔥

GRAND CAYMAN, Cayman Islands, November 22nd, 2024/Chainwire/--Sui drives blockchain innovation with support from global leader in asset management. The Sui Foundation, the independent organization dedicated to the advancement and adoption of Sui, the innovative Layer 1 and smart contract platform, today announced a strategic partnership with Franklin Templeton Digital Assets. Franklin Templeton Digital Assets has been investing in the Sui ecosystem, and believes this strategic partnership will provide further benefit toward that effort by seeking value creation opportunities to allow builders of Sui blockchain-based solutions to deploy novel technologies leveraging the Sui blockchain protocol. “Sui was originally inspired by some of the challenges Franklin Templeton Digital Assets is helping to solve, particularly those that exist within decentralized finance today,” said Jameel Khalfan, Head of Ecosystem Development. “Their interest in Sui’s groundbreaking technology feels not only validating, but as though Sui has come full circle.” Franklin Templeton Digital Assets has been engaged for the past few years in building blockchain-based technology solutions, running node validators, and developing a wide range of investment strategies. The firm’s dedicated digital assets research team leverages fundamental “tokenomic” analysis, insights from an embedded data science team and deep industry connections to help inform product development and investment decisions. “For the past decade, blockchain technology has captured public attention from technologists and economists alike, but often runs up against technical limitations. We are excited for what the Sui team is building,” said Tony Pecore, SVP / Director of Digital Asset Management at Franklin Templeton. Examples of impressive projects being built in the Sui ecosystem include DeepBook on Sui, called DeFi’s answer to a central limit order book, or what exchanges use to facilitate buying and selling between traders by recording bids and offers, as well as Karrier One, the decentralized mobile carrier behind the Karrier One DePin network, and Ika, a parallel MPC network that enables seamless and secure cross-chain interactions. As a secure and scalable platform for building the future of intelligent assets, Sui has already become a premier destination for application builders in gaming, DeFi, memecoins, as well as real-world applications such as 3D printing and tokenized securities. Most recently, native USDC launched on Sui, enabling users to have direct access to one of the most widely used stablecoins globally while removing the added complexities and risks caused by bridged assets. Contact Sui Foundation media@sui.io This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program here GRAND CAYMAN, Cayman Islands, November 22nd, 2024/Chainwire/--Sui drives blockchain innovation with support from global leader in asset management. The Sui Foundation, the independent organization dedicated to the advancement and adoption of Sui , the innovative Layer 1 and smart contract platform, today announced a strategic partnership with Franklin Templeton Digital Assets. Sui Sui Franklin Templeton Digital Assets has been investing in the Sui ecosystem, and believes this strategic partnership will provide further benefit toward that effort by seeking value creation opportunities to allow builders of Sui blockchain-based solutions to deploy novel technologies leveraging the Sui blockchain protocol. “Sui was originally inspired by some of the challenges Franklin Templeton Digital Assets is helping to solve, particularly those that exist within decentralized finance today,” said Jameel Khalfan, Head of Ecosystem Development. “Sui was originally inspired by some of the challenges Franklin Templeton Digital Assets is helping to solve, particularly those that exist within decentralized finance today,” said Jameel Khalfan, Head of Ecosystem Development. “Their interest in Sui’s groundbreaking technology feels not only validating, but as though Sui has come full circle.” “Their interest in Sui’s groundbreaking technology feels not only validating, but as though Sui has come full circle.” Franklin Templeton Digital Assets has been engaged for the past few years in building blockchain-based technology solutions, running node validators, and developing a wide range of investment strategies. The firm’s dedicated digital assets research team leverages fundamental “tokenomic” analysis, insights from an embedded data science team and deep industry connections to help inform product development and investment decisions. “For the past decade, blockchain technology has captured public attention from technologists and economists alike, but often runs up against technical limitations. We are excited for what the Sui team is building,” said Tony Pecore, SVP / Director of Digital Asset Management at Franklin Templeton. “For the past decade, blockchain technology has captured public attention from technologists and economists alike, but often runs up against technical limitations. We are excited for what the Sui team is building,” said Tony Pecore, SVP / Director of Digital Asset Management at Franklin Templeton. Examples of impressive projects being built in the Sui ecosystem include DeepBook on Sui , called DeFi’s answer to a central limit order book , or what exchanges use to facilitate buying and selling between traders by recording bids and offers, as well as Karrier One, the decentralized mobile carrier behind the Karrier One DePin network, and Ika, a parallel MPC network that enables seamless and secure cross-chain interactions. DeepBook on Sui DeepBook on Sui DeFi’s answer to a central limit order book DeFi’s answer to a central limit order book As a secure and scalable platform for building the future of intelligent assets, Sui has already become a premier destination for application builders in gaming, DeFi, memecoins, as well as real-world applications such as 3D printing and tokenized securities. Most recently, native USDC launched on Sui, enabling users to have direct access to one of the most widely used stablecoins globally while removing the added complexities and risks caused by bridged assets. Contact Sui Foundation media@sui.io This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program here This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program here here here

Sui Foundation Enters Into Strategic Partnership With Franklin Templeton Digital Assets

Sui Fondu Franklin Templeton Digital Assets ilə Strateji Tərəfdaşlığa Daxildir

La Fundación Sui firma una alianza estratégica con Franklin Templeton Digital Assets

بنیاد Sui با دارایی های دیجیتال فرانکلین تمپلتون وارد مشارکت استراتژیک شد

Sui Foundation aloittaa strategisen kumppanuuden Franklin Templeton Digital Assetsin kanssa

Sui հիմնադրամը ռազմավարական համագործակցության մեջ է մտնում Franklin Templeton Digital Assets-ի հետ

La Fondazione Sui stipula una partnership strategica con Franklin Templeton Digital Assets

קרן Sui נכנסת לשותפות אסטרטגית עם נכסים דיגיטליים של פרנקלין טמפלטון

Sui Foundation、フランクリン・テンプルトン・デジタル・アセットと戦略的提携を締結

Sui Foundation Franklin Templeton Digital Assets менен стратегиялык өнөктөштүккө кирет

Sui Foundation dia miditra amin'ny fiaraha-miasa stratejika miaraka amin'ny Franklin Templeton Digital Assets

ሱይ ፋውንዴሽን ምስ ፍራንክሊን ቴምፕልተን ዲጂታላዊ ንብረት ናብ ስትራተጂካዊ ምሕዝነት ኣትዩ።

Sui Foundation Yi Nghena Eka Ntirhisano Wa Maqhinga Na Franklin Templeton Digital Assets

Recently, my friend with a strong desire to make a difference in the world and deeply interested in the political future of society—asked me a question that sounded both paradoxical and provocative: “How can corruption be put to work for the state?” At first glance, the idea of using corruption as a tool for the state’s benefit seems controversial, but it raises an important question about the nature of governance and approaches to achieving public good in modern societies. These reflections, however, led me to another, more interesting idea: that the best path to building a prosperous society for everyone is through integrating economic growth and environmental protection as equal goals, handing these tasks over to technologies that will emerge very soon. I am convinced that only artificial general intelligence (AGI) can reliably and effectively manage the achievement of these two essential objectives in the future. But let’s start with corruption, one of the most deeply rooted problems in various countries. Corruption can be found in both democratic and authoritarian systems, in nations with high and low levels of development. It functions as a parallel power structure, where personal interests replace public ones and distort democratic principles. In research Corruption and Government: Causes, Consequences, and Reform, Susan Rose-Ackerman and Bonnie J. Palifka emphasize that corruption infiltrates even those structures meant to uphold justice and transparency, undermining public trust in institutions—a phenomenon we can observe in many countries, such as Russia, China, and North Korea. Transparency International, which publishes the Corruption Perceptions Index annually, confirms that fighting corruption remains a pressing issue on a global scale. Despite the efforts of anti-corruption organizations and reformers, corruption often remains a persistent and seemingly unavoidable part of political systems. It is worth noting that history has seen attempts at “managed” corruption, where instead of eradicating it completely, authorities aimed to minimize its harmful effects. For example, in some authoritarian regimes, corruption is tolerated as a way to maintain elite loyalty and system stability. Michael Johnston, in his book Syndromes of Corruption: Wealth, Power, and Democracy, explores the phenomenon of corruption and argues that such “managed” corruption may temporarily help sustain stability but ultimately deepens social inequality and increases public dissatisfaction in the long run. In short, corruption cannot be turned into something beneficial, as the idea of "useful" corruption encounters several fundamental issues: Ethical contradictions. Legalizing corruption or using it for state purposes undermines principles of justice and equality. Such a system becomes vulnerable and loses legitimacy.


Economic inefficiency. Corruption leads to resource waste and reduces the effectiveness of government management.


Social inequality. Corruption deepens social divides, as resources meant to improve life for all citizens are redirected to benefit a narrow group of individuals. An interesting aspect of our discussion is that the ideal economic model for humanity should combine sustainable economic development with environmental protection. The United Nations, through its Sustainable Development Goals (SDGs), emphasizes that only balanced and sustainable economic growth can improve quality of life on the planet while minimizing environmental impact. Thus, a crucial aspect here is the integration of economic growth with environmental goals, which modern scientists and researchers already consider the only path to long-term well-being. Economist Jeffrey D. Sachs, in his book The Age of Sustainable Development, argues that a society’s happiness can be measured not only by GDP growth but also by its level of environmental sustainability, air and water quality, access to green spaces, and social equality. The combination of these factors helps create a society in which each individual feels part of a shared prosperity, while the environment remains viable for future generations. But what does AGI, technocracy, and the coming technological revolution have to do with this? In light of the above conclusions about corruption and the challenges of sustainable development, it’s clear that traditional management models, based on human decisions, are often unable to effectively address issues of sustainable growth. Sadly, people alone cannot fully help people. Modern technologies, especially artificial intelligence, have the potential to offer more flexible and precise solutions. I argue that AGI will be capable of managing the economy by striking a balance between economic growth and environmental sustainability. In book Life 3.0: Being Human in the Age of Artificial Intelligence, Max Tegmark notes that AGI will be able to process massive amounts of statistical data, which is essentially what the economy is built on—data analysis and interpretation. Works like The Second Machine Age by Erik Brynjolfsson and Andrew McAfee emphasize that AI has the potential to transform the management of social and economic processes, helping to reduce the impact of human weaknesses and biases. To me, this means that AGI could effectively allocate resources in the future to serve the public good, taking into account both current and long-term needs of society and our planet’s environment. I believe that the development of AGI will pave the way for a technocratic model of governance, where the economy becomes not just a tool for growth, but a system focused on creating conditions for societal happiness and well-being. In conclusion, I believe that humanity's best path forward lies not in attempts to adapt corruption for state needs, but in the pursuit of sustainable development grounded in advanced technologies. Corruption, even when "under control," undermines trust in institutions, slows progress, and deepens inequality. Instead of seeking "useful" corruption, humanity should focus on technologies that can provide long-term economic growth while also promoting environmental protection—key aspects upon which the well-being of future generations depends. The development of artificial general intelligence (AGI) could be the starting point for this progress. AGI has the potential to bring a new level of efficiency and transparency to governance, where traditional problems like corruption would cease to exist, as all processes would be focused on the public good. Furthermore, AGI could become a tool for balancing economic development with the preservation of natural resources. In a world where sustainable management is essential for the very possibility of life on the planet, such a model could be a solution and lifeline for future generations. In the face of global challenges such as climate change and the depletion of natural resources, it is clear that only the alignment of economic and environmental goals will create a harmonious future. Sustainable development, managed by AGI, has the potential to ensure long-term stability in which both public welfare and the environment are preserved for the benefit of future generations. Thus, AGI could offer humanity a completely new paradigm of governance, where corruption becomes obsolete, and steady economic growth along with environmental stewardship form the solid foundation for the happiness and prosperity of society as a whole. Recently, my friend with a strong desire to make a difference in the world and deeply interested in the political future of society—asked me a question that sounded both paradoxical and provocative: “How can corruption be put to work for the state?” At first glance, the idea of using corruption as a tool for the state’s benefit seems controversial, but it raises an important question about the nature of governance and approaches to achieving public good in modern societies. These reflections, however, led me to another, more interesting idea: that the best path to building a prosperous society for everyone is through integrating economic growth and environmental protection as equal goals , handing these tasks over to technologies that will emerge very soon. I am convinced that only artificial general intelligence (AGI) can reliably and effectively manage the achievement of these two essential objectives in the future. as equal goals But let’s start with corruption, one of the most deeply rooted problems in various countries. Corruption can be found in both democratic and authoritarian systems, in nations with high and low levels of development. It functions as a parallel power structure, where personal interests replace public ones and distort democratic principles. In research Corruption and Government: Causes, Consequences, and Reform, Susan Rose-Ackerman and Bonnie J. Palifka emphasize that corruption infiltrates even those structures meant to uphold justice and transparency, undermining public trust in institutions—a phenomenon we can observe in many countries, such as Russia, China, and North Korea. Corruption and Government: Causes, Consequences, and Reform , Corruption and Government: Causes, Consequences, and Reform Corruption and Government: Causes, Consequences, and Reform Transparency International, which publishes the Corruption Perceptions Index annually , confirms that fighting corruption remains a pressing issue on a global scale. Despite the efforts of anti-corruption organizations and reformers, corruption often remains a persistent and seemingly unavoidable part of political systems. Corruption Perceptions Index Corruption Perceptions Index Corruption Perceptions Index annually annually It is worth noting that history has seen attempts at “managed” corruption, where instead of eradicating it completely, authorities aimed to minimize its harmful effects. For example, in some authoritarian regimes, corruption is tolerated as a way to maintain elite loyalty and system stability. Michael Johnston, in his book Syndromes of Corruption: Wealth, Power, and Democracy, explores the phenomenon of corruption and argues that such “managed” corruption may temporarily help sustain stability but ultimately deepens social inequality and increases public dissatisfaction in the long run. Syndromes of Corruption: Wealth, Power, and Democracy , Syndromes of Corruption: Wealth, Power, and Democracy Syndromes of Corruption: Wealth, Power, and Democracy In short, corruption cannot be turned into something beneficial, as the idea of "useful" corruption encounters several fundamental issues: Ethical contradictions. Legalizing corruption or using it for state purposes undermines principles of justice and equality. Such a system becomes vulnerable and loses legitimacy. Economic inefficiency. Corruption leads to resource waste and reduces the effectiveness of government management. Social inequality. Corruption deepens social divides, as resources meant to improve life for all citizens are redirected to benefit a narrow group of individuals. Ethical contradictions. Legalizing corruption or using it for state purposes undermines principles of justice and equality. Such a system becomes vulnerable and loses legitimacy. Ethical contradictions. Legalizing corruption or using it for state purposes undermines principles of justice and equality. Such a system becomes vulnerable and loses legitimacy. Ethical contradictions. Economic inefficiency. Corruption leads to resource waste and reduces the effectiveness of government management. Economic inefficiency. Corruption leads to resource waste and reduces the effectiveness of government management. Economic inefficiency. Social inequality. Corruption deepens social divides, as resources meant to improve life for all citizens are redirected to benefit a narrow group of individuals. Social inequality . Corruption deepens social divides, as resources meant to improve life for all citizens are redirected to benefit a narrow group of individuals. Social inequality An interesting aspect of our discussion is that the ideal economic model for humanity should combine sustainable economic development with environmental protection. The United Nations, through its Sustainable Development Goals ( SDGs ), emphasizes that only balanced and sustainable economic growth can improve quality of life on the planet while minimizing environmental impact. SDGs SDGs SDGs Thus, a crucial aspect here is the integration of economic growth with environmental goals, which modern scientists and researchers already consider the only path to long-term well-being. Economist Jeffrey D. Sachs, in his book The Age of Sustainable Development, argues that a society’s happiness can be measured not only by GDP growth but also by its level of environmental sustainability, air and water quality, access to green spaces, and social equality. The combination of these factors helps create a society in which each individual feels part of a shared prosperity, while the environment remains viable for future generations. The Age of Sustainable Development , The Age of Sustainable Development The Age of Sustainable Development But what does AGI, technocracy, and the coming technological revolution have to do with this? In light of the above conclusions about corruption and the challenges of sustainable development, it’s clear that traditional management models, based on human decisions, are often unable to effectively address issues of sustainable growth. Sadly, people alone cannot fully help people. Modern technologies, especially artificial intelligence, have the potential to offer more flexible and precise solutions. I argue that AGI will be capable of managing the economy by striking a balance between economic growth and environmental sustainability. In book Life 3.0: Being Human in the Age of Artificial Intelligence, Max Tegmark notes that AGI will be able to process massive amounts of statistical data, which is essentially what the economy is built on—data analysis and interpretation. Works like The Second Machine Age by Erik Brynjolfsson and Andrew McAfee emphasize that AI has the potential to transform the management of social and economic processes, helping to reduce the impact of human weaknesses and biases. Life 3.0: Being Human in the Age of Artificial Intelligence , Life 3.0: Being Human in the Age of Artificial Intelligence Life 3.0: Being Human in the Age of Artificial Intelligence The Second Machine Age The Second Machine Age The Second Machine Age To me, this means that AGI could effectively allocate resources in the future to serve the public good, taking into account both current and long-term needs of society and our planet’s environment. I believe that the development of AGI will pave the way for a technocratic model of governance, where the economy becomes not just a tool for growth, but a system focused on creating conditions for societal happiness and well-being. In conclusion, I believe that humanity's best path forward lies not in attempts to adapt corruption for state needs, but in the pursuit of sustainable development grounded in advanced technologies. Corruption, even when "under control," undermines trust in institutions, slows progress, and deepens inequality. Instead of seeking "useful" corruption, humanity should focus on technologies that can provide long-term economic growth while also promoting environmental protection—key aspects upon which the well-being of future generations depends. The development of artificial general intelligence (AGI) could be the starting point for this progress. AGI has the potential to bring a new level of efficiency and transparency to governance, where traditional problems like corruption would cease to exist, as all processes would be focused on the public good. Furthermore, AGI could become a tool for balancing economic development with the preservation of natural resources. In a world where sustainable management is essential for the very possibility of life on the planet, such a model could be a solution and lifeline for future generations. In the face of global challenges such as climate change and the depletion of natural resources, it is clear that only the alignment of economic and environmental goals will create a harmonious future. Sustainable development, managed by AGI, has the potential to ensure long-term stability in which both public welfare and the environment are preserved for the benefit of future generations. Thus, AGI could offer humanity a completely new paradigm of governance, where corruption becomes obsolete, and steady economic growth along with environmental stewardship form the solid foundation for the happiness and prosperity of society as a whole.

Could Artificial General Intelligence Make Government Corruption Obsolete? 

Može li vještačka opća inteligencija učiniti korupciju vlade zastarjelom? 

¿Podría la Inteligencia Artificial General hacer obsoleta la corrupción gubernamental?

Inteligentzia Orokor Artifizialak Gobernuaren ustelkeria zaharkitu al dezake? 

Podería a intelixencia xeral artificial facer obsoleta a corrupción do goberno? 

क्या कृत्रिम सामान्य बुद्धिमत्ता सरकारी भ्रष्टाचार को ख़त्म कर सकती है?

A mesterséges általános intelligencia elavulttá teheti a kormányzati korrupciót? 

האם בינה כללית מלאכותית יכולה להפוך את השחיתות השלטונית למיושנת? 

汎用人工知能は政府の腐敗をなくすことができるか？

ປັນຍາທຽມທົ່ວໄປສາມາດເຮັດໃຫ້ການສໍ້ລາດບັງຫຼວງຂອງລັດຖະບານລ້າສະໄຫມໄດ້ບໍ? 

Может ли искусственный интеллект сделать коррупцию в правительстве ненужной?

Sirdoonka Guud ee macmalka ahi ma ka dhigi karaa musuqmaasuqa dawladda mid duugoobay? 

Kan artificiell allmän intelligens göra statlig korruption föråldrad? 

Stories, News & Mentions about INTK

Intk’s Stories on HackerNoon