Lmao

Me,too.

lol

agree

agree

seriously ;-)

we can consider the string of UNSIGNED LONG LONG INT type giving it a range of 2^64-1 which is equal to 18446744073709551615 and declare it like unsigned long long int str[18446744073709551615]; --> containing values of continuous integers 0,1,2,3,4,5,6,7,8,9,10,11,12........

now string of any of the test cases can have a string as long as 32 characters as stated in ques. This input string can be matched in the above string (str) using search algorithm in stl giving the iterator to the first matched position.

the need to take str of 2^64-1 is that we never know from where will the input string will start like in a test case it was started from 101.

Totally agree!

haha ;-) Yaa!

same here bro.

lol

ROFL me too rip allHopes

Rofl :D

haha

Totally agree :p

same here man.. I don't know from which angle this one is easy..

LOL,still can't find a best solution.

:D :D

I fell so bad about those "easy problems". But i still have faith anyway LOL

true!

same here XD !

same here , getting frustrated for beginners like me.

I totally agree! :/

haha:V:V

here is mine approach

include

include

include

using namespace std;

int main() { int t; cin>>t;

while(t--)
{
    string s;
    cin>>s;

    int len= s.length();
    len= len/2;


    int no_yes=1, countp;
    for(int i=0; i<=len;i++)
    {      countp=0;

        string str=s.substr(0,i+1);

        stringstream geek(str);
      long long int temp=0;
        geek>>temp;

      long long  int rev=temp;




        int inter=0;


        string test_t; int t1=0;
       for(int j=0; j<s.length(); j++)
       {     
          long long int no=temp,a=0;

           while(no>0)
           {
               no=no/10;
               a++;

           }

           string str_s =s.substr(j,a) ;

           stringstream gee(str_s);
          long long int temp1=0;
           gee>>temp1;


           if(temp==temp1 )
           {    



               inter=inter+a;
               countp++;
           }



          temp++; 

           if(a>=2)
              j=j+a-1; 
       }

        if(inter== s.length() &&countp>=2)
        {
            cout<<"YES "<<rev<<endl;
            no_yes=0;
            break;
        }




    }  


    if(no_yes)
        cout<<"NO"<<endl;





}

}

+1 AGREE

Lmao

This is an amazing solution.

Better than trying to iterate over existing string (messy code) and finding out if sequence exists. You can use StringBuilder though for the 'test' for less memory usage. Still brilliant work! :)

Thank you so, so much. But I had a terrible time trying to figure out why this works. I looked at your answer and was nearly pulling my hair out.

1. Check every possible number up to the halfway point in the string (because once you pass that you'll break the first rule).
2. Set the number you're currently on as the first element of your beautiful sequence.
3. Save your first element so you can use it later.
4. Set that same element as a new string.
5. Increment the first element and add it to the string you just created. You'll start building a string like "9", "910", "91011".
6. Stop doing this once your string is of equal length or greater than the initial string.
7. If the string you created is equal to the initial string, it is beautiful. If not, start back at step 2 and try with a new base number that's one digit longer.

The problem I faced was that I tried doing this backwards. I would read the string first and then check that it fit all the rules. You, instead, made a new string that followed the rules; if it wasn't the same as your initial string, your initial string was consequently not beautiful.

Thanks

My example

Thanks for a simple and amazing solution.

wow such an wonderfull idea.. thanks a lot !!

can you please explain your code

Excellent logic (y)

Awesome solution :)

Man that's genious!

Thanks for amazing solution!

One thing I want to mention, according to rule 2, if 's' is started from zero, it can be decided as 'NO' without test iteration.

Really, its very nice approach to reach to the next number by incrementing. I tried in C++.

excellent logic :) :)

This is really awesome. Nice approach.

Brilliant man!!

best solution..hats off!!

Great logic! Thanks.

Nice !

Brilliant! I have been working with the existing string this whole time. Instead build it up, and compare to original string.

thank you @johnpearson.

Although this is in javaScript and javaScript does not work well with large numbers(up to 53 bits) here is my version of your code in javaScript:

function checkBeauty(num) {

var str = num.toString();
var numLen = str.length;
var firstNum = 0;
var incre = 0;
var testStr = '';


if (numLen <= 1) {
    return 'NO';
}

for (var i = 1; i <= numLen/2; i++) {
    firstNum = parseInt(str.substr(0, i));
    testStr = firstNum.toString();
    incre = firstNum;

    while (testStr.length < numLen && str != testStr) {
        // this part needs help in javaScript because it only works up to 53bits
        incre++;
        testStr += incre.toString(); 
    }

    if (testStr == str) {
        break;
    }
}

return testStr == str ? 'YES ' + firstNum : 'NO';

}

Here's a C++ version of johnpearson's algorithm:

#include <iostream>
#include <string>
using namespace std;

int main() {
    
    // Declarations.
    int n;
    string s;
    cin >> n;
    
    // For each query
    while (n--)
    {
        cin >> s;
		bool valid = false;
		long firstx = -1;
        
		// Try each possible starting number
		for (int i = 1; i <= s.length()/2; ++i) {
			long x = stol(s.substr(0,i));
			firstx = x;
		    // Build up sequence starting with this number
			string test = to_string(x);
			while (test.length() < s.length()) {
				test += to_string(++x);
			}
            
			// Compare to original
			if (test == s) {
				valid = true;
				break;
			}
		}
        valid ? cout << "YES " << firstx << endl : cout <<"NO" << endl;
    }
    return 0;
}

I have written a similar solution but with Recursion.

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {
    public static boolean find(String s, String first) {
        if(s == null)
            return true;
        if(s.length() == 0)
            return true;
        String next = Long.toString(Long.parseLong(first) + 1); 
        if(s.startsWith(next))
            return find(s.substring(next.length()), next);
        return false;
    }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int q = in.nextInt();
        for(int a0 = 0; a0 < q; a0++){
            String s = in.next();
            boolean flag = false;
            // your code goes here
            for(int i=1;i<=s.length()/2;i++){
                String first = s.substring(0, i);
                if(find(s.substring(i), first)){
                    flag = true;
                    System.out.println("YES " + first);
                    break;
                }
            }
            if(!flag)
                System.out.println("NO");
        }
    }
}

Wow.. brilliant solution.

change the out limit of for loop from (s.length()/2) to (s.length()/2+1) to make it more generic

I admire this code

Bravo!

from itertools import count


def check_rest(start,remains):
    for i in count(start+1):
        if not remains:
            return True
        if not remains.startswith(str(i)):
            return False
        remains = remains[len(str(i)):]


def is_beautiful(s):
    for i in range(1,len(s)//2+1):
        if check_rest(int(s[:i]),s[i:]):
            print "YES %s"%s[:i]
            return
    print "NO"
print is_beautiful("991992")

was my solution

Now thats a beautiful solution :D Anybody got the pun? :P

Thanks.Implementation in python:

#!/bin/python3

import sys


if __name__ == "__main__":
    ans=0
    q = int(input().strip())
    for a0 in range(q):
        s = input().strip()
        ans=0
        a=""
        for i in range (int(len(s)/2)):
                        a=""
                        a=a+s[0:i+1]
                        #print("initial a",a)
                        x=int(a)
                        y=x
                        while(len(a)<len(s)):
                              #x=int(x)          
                              a=a+str(x+1)
                         #     print(a)
                              x=x+1          
                        if(a==s):
                              ans=1
                              break          
        if ans==1:
          print("YES",y)
        else:
           print("NO")

great..

great and simple

This is really an amazing idea. Doing reverse engineering. Rather i tried checking at each step whetehr it follows all rules or not. and it is so messed up. If anyone can guide me on how to improve code. I mean want to keep the logic same but if at some places i am doing redundant work, or unnecesary conditions or anything like that. It will be great help.

static void separateNumbers(String s) {
        if(s.length() < 2) System.out.println("NO");
        else if(s.charAt(0) == '0') System.out.println("NO");
        else{
            int check_len = 1;
            boolean flag = true;//flag is for checking whether they are consecutive numbers or not
            boolean flag2 = false;//flag2 is to check wether we increaed check_len somewhere in middle due to number of all nines
            while(check_len<=s.length()/2){
                flag = true;
                flag2 = false;
                int i = check_len;
                long val1 = Long.parseLong(s.substring(0, check_len));
                for(i = check_len; i<s.length()-check_len+1; i += check_len){
                    if(val1AllNine(val1)){
                        check_len++;
                        flag2 = true;
                    }
                    long val2 = Long.parseLong(s.substring(i, i+check_len));
                    if(val2-val1 != 1 || s.charAt(i) == '0'){
                        flag = false;
                        break;
                    }
											else val1 = val2;//going on next piece of string
                }
                if(i == s.length() && flag) break;
                else{
                    if(!flag2) check_len++;//increase check_len only if it not increased half way in last iteration
                }
            }
            if(flag && !flag2) System.out.println("YES "+s.substring(0, check_len));
            else if(flag && flag2) System.out.println("YES "+s.substring(0, check_len-1));
            else System.out.println("NO");
        }

    }

    static boolean val1AllNine(long v1){

        while(v1 >= 9){
            if(v1%10 < 9)
                return false;
            v1 = v1/10;
        }
        if(v1 < 9 && v1 > 0) return false;
        else return true;
    }

WOULD IT WORK FOR THE STRING WITH LEADING 0

Wow

This is honestly brilliant! I couldn't even figure out how to extract numbers from the string. Good job man

is that the bruteforcing is the only solution to this problem??

Yeah I did the same

Best Solution. Thanks apghr you saved my time.

VS2010,I must comment out this line. cin.ignore(256, '\n'); Otherwise it walk into deadlock.

Finally, this beautiful solution works well.

Well done, but I donno if such test 0891011 exists, but it gives YES 08, which contradicts the condition#2:

No a[i] contains a leading zero...

Probably such challange doesn't have good test coverage.

Yes, this exercise could be categorized as medium without offending anyone, imo.

thanks dude for your code it helps me a lot i didnt understood the problem good enough but after seeing your i came to understand what the question was !!

Can u pls explain what u did here? It'll be of great help to me

Beautiful !!!

nice solution :)

why python <3

I see a very inconsistent classification of problems. Some in Easy are literally 10 minutes to think of the solution and implement it, while on others (like this one) you can spend even 2 hours and not come with an appropiate solution.

I did the same thing, but getting invalid argument for stoll don't know why?

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include<string>
#include<sstream>
using namespace std;
int main() 
{
    int n;
    cin>>n;
    while(n>0)
    {
 string p;
 cin>>p;
 int m=0;
 int l=p.length();
 for(int i=1;i<=(l-2);i++)
 {
     string s=p.substr(0,i);
     stringstream g(s);
     int d=0;
     g>>d;
     int sum=0;
     int count=0;
     string ss;
     for(int j=0;j<l;j++)
     {   int x=d+j;
        
         string s2=to_string(x);
         int l2=s2.length();
         count=count+l2;
         ss=ss+s2;
         if(count==l)
             break;
         
     }
     if(ss==p)
     {
          m=1;
         cout<<"YES"<<" "<<s;
         break;
     }
 }
  if(m==0)
  {
      cout<<"NO";
  }
        cout<<"\n";
        n--;
    }
return 0;
}

test case 4 and last 6 test cases are showing wrong output ,can someone help plz?

Same with Java, use long and Long.parseLong