# Separate the Numbers

### Problem Statement :

```A numeric string, , is beautiful if it can be split into a sequence of two or more positive integers, , satisfying the following conditions:

for any  (i.e., each element in the sequence is  more than the previous element).
No  contains a leading zero. For example, we can split  into the sequence , but it is not beautiful because  and  have leading zeroes.
The contents of the sequence cannot be rearranged. For example, we can split  into the sequence , but it is not beautiful because it breaks our first constraint (i.e., ).
The diagram below depicts some beautiful strings:

Perform  queries where each query consists of some integer string . For each query, print whether or not the string is beautiful on a new line. If it is beautiful, print YES x, where  is the first number of the increasing sequence. If there are multiple such values of , choose the smallest. Otherwise, print NO.

Function Description

Complete the separateNumbers function in the editor below.

separateNumbers has the following parameter:

s: an integer value represented as a string
Prints
- string: Print a string as described above. Return nothing.

Input Format

The first line contains an integer q, the number of strings to evaluate.
Each of the next q lines contains an integer string s to query.

Constraints

1  <=   q  <=  10
1  <=  | s |  <=  32```

### Solution :

```                            ```Solution in C :

In  C++  :

#include <cstdio>
#include <iostream>
#include <ctime>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <set>
#include <cstdlib>
#include <ctime>
#include <cassert>
#include <bitset>
#include <fstream>
#include <deque>
#include <stack>
#include <climits>
#include <string>
#include <queue>
#include <memory.h>
#include <map>
#include <unordered_map>

#define ll long long
#define ld double
#define pii pair <ll, ll>
#define mp make_pair

using namespace std;

int main() {
int q;

cin >> q;

while (q--) {
string s;

cin >> s;

if (s == '0') {
cout << "NO\n";
continue;
}

ll now = 0;

bool st = false;

for (int i = 0; i < (int)s.size(); i++) {
now *= 10;
now += s[i] - '0';

ll res = 0;

if (s[i + 1] == '0') {
continue;
}

int cnt = 1;

for (int j = i + 1; j < (int)s.size(); j++) {
res *= 10;
res += s[j] - '0';

if (res == now + cnt) {
if (j + 1 == (int)s.size()) {
st = true;
break;
}

if (s[j + 1] == '0') {
break;
}

res = 0;
cnt++;
}
}

if (st) {
break;
}
}

if (st) {
cout << "YES " << now << endl;
} else {
cout << "NO\n";
}
}

return 0;
}

In  Java  :

import java.io.*;
import java.util.StringTokenizer;

public class Main {
private void solve() {
int n = rw.nextInt();
main:
for (int i = 0; i < n; ++i) {
String s = rw.next();
if (s.startsWith("0") || s.length() == 1) {
rw.println("NO");
continue;
}
long x, cur;
cy:
for (int j = 1; j <= s.length() / 2; ++j) {
x = Long.parseLong(s.substring(0, j));
cur = x + 1;
int c = j;
while (c < s.length()) {
String p = String.valueOf(cur);
cur += 1;
if (s.startsWith(p, c)) {
c += p.length();
} else {
continue cy;
}
}
rw.println("YES" + " " + x);
continue main;
}
rw.println("NO");
}

}

private RW rw;
private String FILE_NAME = "file";

public static void main(String[] args) {
new Main().run();
}

private void run() {
rw = new RW(FILE_NAME + ".in", FILE_NAME + ".out");
solve();
rw.close();
}

private class RW {
private StringTokenizer st;
private PrintWriter out;
private boolean eof;

RW(String inputFile, String outputFile) {
out = new PrintWriter(new OutputStreamWriter(System.out));

File f = new File(inputFile);
try {
out = new PrintWriter(new FileWriter(outputFile));
} catch (IOException e) {
e.printStackTrace();
}
}
}

private String nextLine() {
String s = "";
try {
} catch (IOException e) {
e.printStackTrace();
}
return s;
}

private String next() {
while (st == null || !st.hasMoreTokens()) {
try {
} catch (IOException e) {
eof = true;
return "-1";
}
}
return st.nextToken();
}

private long nextLong() {
return Long.parseLong(next());
}

private int nextInt() {
return Integer.parseInt(next());
}

private void println() {
out.println();
}

private void println(Object o) {
out.println(o);
}

private void print(Object o) {
out.print(o);
}

private void close() {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
out.close();
}
}
}

In    C  :

#include <stdio.h>
#include <string.h>

typedef unsigned long long int Long;
char s;
int q;
Long x;

int isZeroLead(int i) { return s[i] == '0'; }
Long read(int i, int sz) {
char *pt = s + i;
Long ans = 0;
while(sz-- && *pt) {
ans = ans*10 + (*pt - '0');
pt++;
}
return ans;
}

int digs(Long x) {
int ll = 0;
while(x) {
ll++;
x /= 10;
}
return ll;
}

int check(Long fst, int len) {
Long last = fst, curr;
int lsz = digs(fst);
for(int i = lsz; i < len; i += lsz) {
if(digs(last + 1) != digs(last)) { lsz++; }

if(curr - last != 1) return 0;
last = curr;
}

return 1;
}

int main() {
scanf("%d",&q);
while(q--) {
scanf("%s", s);
Long x = -1, fst;
for(int i = 1, len = strlen(s); i <= (len>>1); i++) {
if(check(fst, len)) {
x = fst;
break;
}
}

if(x == -1) puts("NO");
else printf("YES %lld\n", x);
}

return 0;
}

In   Python3 :

for _ in range(int(input())):
s = input().strip()
n = len(s)
x = ''
for i in s[:-1]:
x += i
y = int(x)
z = ''
while len(z) < n:
z += str(y)
y += 1
if n == len(z) and z == s:
print("YES", x)
break
else:
print("NO")```
```

## Tree: Inorder Traversal

In this challenge, you are required to implement inorder traversal of a tree. Complete the inorder function in your editor below, which has 1 parameter: a pointer to the root of a binary tree. It must print the values in the tree's inorder traversal as a single line of space-separated values. Input Format Our hidden tester code passes the root node of a binary tree to your \$inOrder* func

## Tree: Height of a Binary Tree

The height of a binary tree is the number of edges between the tree's root and its furthest leaf. For example, the following binary tree is of height : image Function Description Complete the getHeight or height function in the editor. It must return the height of a binary tree as an integer. getHeight or height has the following parameter(s): root: a reference to the root of a binary

## Tree : Top View

Given a pointer to the root of a binary tree, print the top view of the binary tree. The tree as seen from the top the nodes, is called the top view of the tree. For example : 1 \ 2 \ 5 / \ 3 6 \ 4 Top View : 1 -> 2 -> 5 -> 6 Complete the function topView and print the resulting values on a single line separated by space.

## Tree: Level Order Traversal

Given a pointer to the root of a binary tree, you need to print the level order traversal of this tree. In level-order traversal, nodes are visited level by level from left to right. Complete the function levelOrder and print the values in a single line separated by a space. For example: 1 \ 2 \ 5 / \ 3 6 \ 4 F

## Binary Search Tree : Insertion

You are given a pointer to the root of a binary search tree and values to be inserted into the tree. Insert the values into their appropriate position in the binary search tree and return the root of the updated binary tree. You just have to complete the function. Input Format You are given a function, Node * insert (Node * root ,int data) { } Constraints No. of nodes in the tree <

## Tree: Huffman Decoding

Huffman coding assigns variable length codewords to fixed length input characters based on their frequencies. More frequent characters are assigned shorter codewords and less frequent characters are assigned longer codewords. All edges along the path to a character contain a code digit. If they are on the left side of the tree, they will be a 0 (zero). If on the right, they'll be a 1 (one). Only t