Wipro coding

import java.util.Scanner;
public class ReverseWords {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String sentence = sc.nextLine();
        String[] words = sentence.trim().split("\\s+");
        StringBuilder result = new StringBuilder();
        for (int i = words.length - 1; i >= 0; i--) {
            result.append(words[i]);
            if (i != 0) result.append(" ");
        }
        System.out.println(result.toString());
    }
}

sentence = input().strip()
words = sentence.split()
print(" ".join(reversed(words)))

public class SpiralMatrix {
    public static void printSpiral(int[][] matrix) {
        int top = 0, bottom = matrix.length - 1;
        int left = 0, right = matrix[0].length - 1;
        StringBuilder result = new StringBuilder();

        while (top <= bottom && left <= right) {
            for (int i = left; i <= right; i++) result.append(matrix[top][i]).append(" ");
            top++;
            for (int i = top; i <= bottom; i++) result.append(matrix[i][right]).append(" ");
            right--;
            if (top <= bottom) {
                for (int i = right; i >= left; i--) result.append(matrix[bottom][i]).append(" ");
                bottom--;
            }
            if (left <= right) {
                for (int i = bottom; i >= top; i--) result.append(matrix[i][left]).append(" ");
                left++;
            }
        }
        System.out.println(result.toString().trim());
    }
}

def spiral_order(matrix):
    result = []
    top, bottom = 0, len(matrix) - 1
    left, right = 0, len(matrix[0]) - 1

    while top <= bottom and left <= right:
        for i in range(left, right + 1):
            result.append(matrix[top][i])
        top += 1
        for i in range(top, bottom + 1):
            result.append(matrix[i][right])
        right -= 1
        if top <= bottom:
            for i in range(right, left - 1, -1):
                result.append(matrix[bottom][i])
            bottom -= 1
        if left <= right:
            for i in range(bottom, top - 1, -1):
                result.append(matrix[i][left])
            left += 1
    return result

public class LIS {
    public static int lengthOfLIS(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n];
        java.util.Arrays.fill(dp, 1);
        int maxLen = 1;
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            maxLen = Math.max(maxLen, dp[i]);
        }
        return maxLen;
    }
}

def length_of_lis(nums):
    n = len(nums)
    dp = [1] * n
    for i in range(1, n):
        for j in range(i):
            if nums[i] > nums[j]:
                dp[i] = max(dp[i], dp[j] + 1)
    return max(dp)

import java.util.Arrays;
public class AnagramCheck {
    public static boolean isAnagram(String s1, String s2) {
        if (s1.length() != s2.length()) return false;
        char[] a1 = s1.toCharArray();
        char[] a2 = s2.toCharArray();
        Arrays.sort(a1);
        Arrays.sort(a2);
        return Arrays.equals(a1, a2);
    }
}

def is_anagram(s1, s2):
    return sorted(s1) == sorted(s2)

import java.util.*;
public class PairSum {
    public static void findPairs(int[] arr, int target) {
        Set<Integer> seen = new HashSet<>();
        Set<String> printed = new HashSet<>();
        for (int num : arr) {
            int complement = target - num;
            if (seen.contains(complement)) {
                int a = Math.min(num, complement), b = Math.max(num, complement);
                String key = a + "," + b;
                if (!printed.contains(key)) {
                    System.out.println("(" + a + ", " + b + ")");
                    printed.add(key);
                }
            }
            seen.add(num);
        }
    }
}

def find_pairs(arr, target):
    seen = set()
    printed = set()
    for num in arr:
        complement = target - num
        if complement in seen:
            pair = tuple(sorted((num, complement)))
            if pair not in printed:
                print(pair)
                printed.add(pair)
        seen.add(num)