import java.util.*;
class StringTimes {


    /** @return `msg` duplicated `n` times. * /
    static String stringTimes( int n, String msg ) {
        String resultSoFar = "";
        for (int i=0;  i<n;  ++i)
            resultSoFar = resultSoFar + msg;
        return resultSoFar;
        }
        // Want to say: the running-time of this function is Θ(n * msg.length()).
    /***************/
    

/***
# Fwiw, here's a python equivalent:
def stringTimes(n, msg):
    """return `msg` duplicated `n` times"""
    resultSoFar = ""
    for (i in range n):
        resultSoFar = resultSoFar + msg
    return msg
***/
         


    public static void main( String... __ ) {
	String info = "Note: Java strings are immutable.";
        System.out.println( "Original  info: " + info );
        System.out.println( "downcased info: " + info.toLowerCase() );
        System.out.println( "original, now:  " + info );
	System.out.println();
	if (false) return;



        System.out.println( stringTimes(3,"echo!") );
        
        for (List tst : List.of( List.of(      100,"a")
                                ,List.of(    1_000,"a")
                                ,List.of(   10_000,"a")
                                ,List.of(  100_000,"a")
                                ,List.of(      100,"abcde")
                                ,List.of(    1_000,"abcde")
                                ,List.of(   10_000,"abcde")
                                ,List.of(  100_000,"abcde")
                                ,List.of(1_000_000,"abcde")
                                ,List.of(1_000_000,"a")
                                ,List.of(10_000_000,"abcde")
                                ,List.of(100_000_000,"abcde")
                                ) ) {
            int k = (Integer)tst.get(0);
            String msg = (String)tst.get(1);
            long t0 = System.currentTimeMillis();
            stringTimes(k,msg);
            long t1 = System.currentTimeMillis();
            System.out.printf( "%9dx%9d requires %9dms.\n", k, msg.length(), t1-t0 );
            }
        // Using String:
        // 1000:  
        // 10000: 
        // 100000:
        }
    





    /** @return `msg` duplicated `n` times. */
    // This version takes linear time, using StringBuffer (a mutable class)
    static String stringTimes( int n, String msg ) {
        StringBuffer resultSoFar = new StringBuffer();
        for (int i=1;  i<=n;  ++i)
            resultSoFar.append(msg);
        return resultSoFar.toString();
        }
    /***  */

    
/***
#Fwiw, here's a python equivalent: [untested]

from io import StringIO

def stringTimes(n, msg):
    """This version takes linear time, using StringIO (a mutable class)"""
    resultSoFar = StringIO()
    for (i in range n):
        resultSoFar.write(msg)
    return msg.getvalue()

# or (ha ha) just:  `n*msg` -- it's built-in to python!

***/
    
    }


  
/* results:
    100x      1 requires       0ms.
   1000x      1 requires       2ms.
  10000x      1 requires      18ms.
 100000x      1 requires     631ms.
    100x      5 requires       0ms.
   1000x      5 requires       1ms.
  10000x      5 requires      19ms.
 100000x      5 requires    2317ms.

1000000x      1 requires   46317ms. (~45s)
1000000x      5 requires  286867ms. (~5min)
*/