Related
developers, i am new in Kotlin I am trying to take input in Array by using loop and after that, i print the all values of array by using loop but t get only input and not show the other chunk and through the error which is shiwn on attach image
fun main(args: Array<String>) {
var arrayint = Array<Int>(5){0}
var x = 1
val abc:Int = arrayint.size
while( x <= abc)
{
arrayint[x] = readLine()!!.toInt()
x++
}
for(index in 0..4)
{
println(arrayint[index])
}
}
The following is a little more succinct
var arrayint = Array<Int>(5) { readLine()!!.toInt() }
for(x in arrayint)
println(x)
On the first line, instead of using the initializer lambda { 0 }, I use a lambda that call readLine.
On line 2, instead of having to know my range (0..4), I let the language do it for me (an Array is iterable).
Try this:
fun main (args:Array<String>){
var arrayint = Array<Int>(5){0}
var x:Int = 0
val abc:Int = arrayint.size
while( x < abc)
{
arrayint[x] = readLine()!!.toInt()
x++
}
for(index in 0..4)
{
println(arrayint[index])
}
}
You should change x <= abc to x < abc and x = 1 to x = 0. It doesn't work now because if abc = 5 and you loop 4 times then x = 5 but arrays in Kotlin (and Java) start at index 0 which means that array of size 5 has the following indexes: 0, 1, 2, 3, 4 which means that arrayint[5] doesn't exist as 5 is out of bounds (> 4)
One of the shorthand for taking n data elements of data input in an array of predefined size is as follow.
Here the user is going to input a integer
n = number of elements then then the array elements
import java.util.*
fun main(){
val read = Scanner(System.`in`)
val n = read.nextInt()
var arr = Array(n) {i-> read.nextInt()} // taking input
arr.forEach{
println(it) // this loop prints the array
}
}
Following code is taking input in array using loop
import java.util.*
fun main(args: Array<String>) {
var num = arrayOfNulls<Int>(5)
var read= Scanner(System.`in`)
println("Enter array values")
for(i in 0..4)
{
num[i] = read.nextInt()
}
println("The array is")
for(x in num){
println(x)}
}
Following code is taking input of array size and then it's elements
fun main() {
print("Enter Array size: ")
val arraySize = readLine()!!.toInt()
println("Enter Array Elements")
val arr = Array<Int>(arraySize) { readLine()!!.toInt() }
for (x in arr)
println(x)
}
With experience of java programming, I started learning Kotlin today. I am playing with the language and found me stuck to find a factorial using for loop in kotlin. I managed to do this using while loop.
import java.util.Scanner
fun main(args: Array<String>){
val reader=Scanner(System.`in`)
val x: Int = reader.nextInt()
println(factorial(x))
}
fun factorial(a: Int): Int{
var ans=1
var i: Int = a
while(i>1){
ans*=i
i--
}
return ans
}
Please help me to do this using a for loop.
Thanks
Well, the simplest one that comes to mind:
fun factorial(num: Int): Long {
var result = 1L
for (i in 2..num) result *= i
return result
}
This doesn't use a for loop, but just as an addition you can also make this shorter, more functional and Kotlin-like using reduce:
fun factorial(num: Int) = (1..num).reduce(Int::times)
Or:
fun factorial(num: Int) = (1..num).reduce { a, b -> a * b }
This is the simplest I can think of.
Edit: This is equivalent to
fun factorial(num: Int) = (2..num).fold(1, Int::times)
as reduce is practically a fold starting from the value at index 0.
We start with 2 instead, however 1 would be equivalent as multiplying by one doesn't change the result.
Edit 2: this edit is exactly what holi-java just posted.
there is another expressive one by using Range#fold and function reference expression, for example:
fun factorial(n: Int) = (2..n).fold(1L, Long::times)
If I am so bold to not do it in a for loop,
Here is a handy one liner recursive function to determine the factorial:
fun factorial(a: Int): Long = if (a == 1) a.toLong() else factorial(a - 1) * a
Factorial:
fun factorial(num : Long) : Long {
var factorial : Long = 1
for (i in 2..num) {
factorial *= i
}
println("Factorial of $num = $factorial")
}
Factorial using BigInteger variable:
fun factorial(num : Long) : Long {
var factorial = BigInteger.ONE
for (i in 2..num) {
factorial = factorial.multiply(BigInteger.valueOf(num))
}
println("Factorial of $num = $factorial")
}
Alternative using recursion:
fun factorial(number: Int): Int {
when (number) {
0 -> return 1
else -> return number * factorial(number - 1)
}
}
Other way :
fun factorial (data : Int) : Long {
var result : Long = 1
(1..data).map {
result *= it;
}
return result;
}
if you want use BigInteger :
fun factorial (data : Int) : BigInteger {
var result : BigInteger = 1.toBigInteger()
(1..data).map {
result *= it.toBigInteger();
}
return result;
}
How do you make a 2D Int array in Kotlin? I'm trying to convert this code to Kotlin:
int[][] states = new int[][] {
new int[]{-android.R.attr.state_pressed}, // not pressed
new int[] { android.R.attr.state_pressed} // pressed
};
int[] colors = new int[] {
foregroundColor,
accentColor,
accentColor
};
ColorStateList myList = new ColorStateList(states, colors);
Here is one attempt I tried, where the first 2D array didn't work, but I got the 1D array to work:
//This doesn't work:
var states: IntArray = intArrayOf(
intArrayOf(-android.R.attr.state_pressed), // not pressed
intArrayOf(android.R.attr.state_pressed) // pressed
);
//This array works:
var colors: IntArray = intArrayOf(
foregroundColor,
accentColor,
accentColor
);
val myList: ColorStateList = ColorStateList(states, colors);
You may use this line of code for an Integer array.
val array = Array(row) { IntArray(column) }
This line of code is pretty simple and works like 1D array and also can be accessible like java 2D array.
You are trying to put your IntArrays inside another array to make it 2-dimensional.
The type of that array cannot be intArray, which is why this fails.
Wrap your initial arrays with arrayOf instead of intArrayOf.
val even: IntArray = intArrayOf(2, 4, 6)
val odd: IntArray = intArrayOf(1, 3, 5)
val lala: Array<IntArray> = arrayOf(even, odd)
Short Answer:
// A 6x5 array of Int, all set to 0.
var m = Array(6) {Array(5) {0} }
Here is another example with more details on what is going on:
// a 6x5 Int array initialise all to 0
var m = Array(6, {i -> Array(5, {j -> 0})})
The first parameter is the size, the second lambda method is for initialisation.
I have been using this one-liner when creating matrix
var matrix: Array<IntArray> = Array(height) { IntArray(width) }
1. Nested arrayOf calls
You can nest calls of arrayOf, e.g., to create an Array of IntArray, do the following:
val first: Array<IntArray> = arrayOf(
intArrayOf(2, 4, 6),
intArrayOf(1, 3, 5)
)
Note that the IntArray itself only takes arguments of type Int as arguments, so you cannot have an IntArray<IntArray> which obviously does not make much sense anyway.
2. Use Array::constructor(size: Int, init: (Int) -> T) for repeated logic
If you want to create your inner arrays with some logical behaviour based on the index, you can make use of the Array constructor taking a size and an init block:
val second: Array<IntArray> = Array(3) {
intArrayOf(it * 1, it * 2, it * 3, it * 4)
}
//[[0, 0, 0, 0], [1, 2, 3, 4], [2, 4, 6, 8]]
It seems that you are trying to create a ColorStateList in Kotlin. The code for that is a bit messy, i'll try to keep it readable:
val resolvedColor = Color.rgb(214, 0, 0)
val states = arrayOf(
intArrayOf(-android.R.attr.state_pressed),
intArrayOf(android.R.attr.state_pressed)
)
val csl = ColorStateList(
states,
intArrayOf(resolvedColor, Color.WHITE)
)
You can use a simple 1D (linear) array for this purpose. For example, this is my class for a rectangle array of Double values:
/**
* Rect array of Double values
*/
class DoubleRectArray(private val rows: Int, private val cols: Int) {
private val innerArray: DoubleArray
init {
if(rows < 1) {
throw IllegalArgumentException("Rows value is invalid. It must be greater than 0")
}
if(cols < 1) {
throw IllegalArgumentException("Cols value is invalid. It must be greater than 0")
}
innerArray = DoubleArray(rows*cols)
}
/**
*
*/
fun get(row: Int, col: Int): Double {
checkRowAndCol(row, col)
return innerArray[row*cols + col]
}
/**
*
*/
fun set(row: Int, col: Int, value: Double) {
checkRowAndCol(row, col)
innerArray[row*cols + col] = value
}
/**
*
*/
private fun checkRowAndCol(row: Int, col: Int) {
if(row !in 0 until rows) {
throw ArrayIndexOutOfBoundsException("Row value is invalid. It must be in a 0..${rows-1} interval (inclusive)")
}
if(col !in 0 until cols) {
throw ArrayIndexOutOfBoundsException("Col value is invalid. It must be in a 0..${cols-1} interval (inclusive)")
}
}
}
package helloWorld
import java.util.Scanner
fun main(){
val sc = Scanner(System.`in`)
print("ENTER THE SIZE OF THE ROW: ")
var row = sc.nextInt()
println()
print("ENTER THE SIZE OF COLUMN: ")
val column = sc.nextInt()
println()
var a = Array(row){IntArray(column)}
for(i in 0 until row){
when (i) {
0 -> {
println("----------${i+1} st ROW'S DATA----------")
}
1 -> {
println("----------${i+1} nd ROW'S DATA----------")
}
2 -> {
println("----------${i+1} rd ROW'S DATA----------")
}
else -> {
println("----------${i+1} th ROW'S DATA----------")
}
}
for(j in 0 until column)
{
print("ENTER ${j+1} COLUMN'S DATA: ")
var data:Int = sc.nextInt()
a[i][j]=data;
}
println()
}
println("COLLECTION OF DATA IS COMPLETED")
for(i in 0 until row){
for(j in 0 until column){
print(a[i][j])
print(" ")
}
println()
}
}
It works like this:
You can create 2D array in kotlin.
var twoDarray = Array(8) { IntArray(8) }
this is a example of int 2D array
Using an inline function and a Pair:
inline fun<reified T> Pair<Int,Int>.createArray(initialValue:T) = Array(this.first){ Array(this.second){initialValue}}
// Create m*n Array of Ints filled with 0
val twoDimArray = Pair(10,20).createArray(0)
// Create m*n Array of Doubles filled with 0.0
val twoDimArray = Pair(10,20).createArray(0.0)
// Create m*n Array of Strings filled with "Value"
val twoDimArray = Pair(10,20).createArray("Value")
...
You can create two one dimensional array and add them in new array.
val unChecked = intArrayOf(-android.R.attr.state_checked)
val checked = intArrayOf(android.R.attr.state_checked)
val states = arrayOf(unChecked, checked)
val thumbColors = intArrayOf(Color.WHITE, Color.parseColor("#55FFD4"))
val stateList = ColorStateList(states, thumbColors)
I have a string that a user inputs through Console.ReadLine() e.g. "140 150 64 49" (separated only with spaces) and I want to add those numbers to an array. What is the best way to do it. I'm kinda new to programming so I'm a bit lost. Google didn't help either.
When saying you're using Console.ReadLine(), I assume you use C#.
you can use this:
int counter = 0;
int[] array = new int[200]; // choose some size
string s = Console.ReadLine();
int indexOfNextSpace;
while ((indexOfNextSpace = s.IndexOf(' ')) > -1)
{
int num = int.Parse(s.Substring(0, indexOfNextSpace));
array[counter] = num;
counter++;
s = s.Substring(indexOfNextSpace + 1);
}
if you're not sure about valid input, try surrounding with try\catch, or use int.TryParse instead of int.Parse.
You can use this:
List<int> ints = new List<int>();
int num;
int[] result = new int[] { };
string input = Console.ReadLine();
foreach (string str in input.Split(' '))
{
if (int.TryParse(str, out num))
{
ints.Add(num);
}
}
result = ints.ToArray();
foreach (int i in result)
{
Console.WriteLine(i);
}
It uses a List then convert it to array. Note that items are validated, so only ints are added.
This will produce the following output:
123 456 dsf def 1
123
456
1
I'm not sure how to ask my question in a succinct way, so I'll start with examples and expand from there. I am working with VBA, but I think this problem is non language specific and would only require a bright mind that can provide a pseudo code framework. Thanks in advance for the help!
Example:
I have 3 Character Arrays Like So:
Arr_1 = [X,Y,Z]
Arr_2 = [A,B]
Arr_3 = [1,2,3,4]
I would like to generate ALL possible permutations of the character arrays like so:
XA1
XA2
XA3
XA4
XB1
XB2
XB3
XB4
YA1
YA2
.
.
.
ZB3
ZB4
This can be easily solved using 3 while loops or for loops. My question is how do I solve for this if the # of arrays is unknown and the length of each array is unknown?
So as an example with 4 character arrays:
Arr_1 = [X,Y,Z]
Arr_2 = [A,B]
Arr_3 = [1,2,3,4]
Arr_4 = [a,b]
I would need to generate:
XA1a
XA1b
XA2a
XA2b
XA3a
XA3b
XA4a
XA4b
.
.
.
ZB4a
ZB4b
So the Generalized Example would be:
Arr_1 = [...]
Arr_2 = [...]
Arr_3 = [...]
.
.
.
Arr_x = [...]
Is there a way to structure a function that will generate an unknown number of loops and loop through the length of each array to generate the permutations? Or maybe there's a better way to think about the problem?
Thanks Everyone!
Recursive solution
This is actually the easiest, most straightforward solution. The following is in Java, but it should be instructive:
public class Main {
public static void main(String[] args) {
Object[][] arrs = {
{ "X", "Y", "Z" },
{ "A", "B" },
{ "1", "2" },
};
recurse("", arrs, 0);
}
static void recurse (String s, Object[][] arrs, int k) {
if (k == arrs.length) {
System.out.println(s);
} else {
for (Object o : arrs[k]) {
recurse(s + o, arrs, k + 1);
}
}
}
}
(see full output)
Note: Java arrays are 0-based, so k goes from 0..arrs.length-1 during the recursion, until k == arrs.length when it's the end of recursion.
Non-recursive solution
It's also possible to write a non-recursive solution, but frankly this is less intuitive. This is actually very similar to base conversion, e.g. from decimal to hexadecimal; it's a generalized form where each position have their own set of values.
public class Main {
public static void main(String[] args) {
Object[][] arrs = {
{ "X", "Y", "Z" },
{ "A", "B" },
{ "1", "2" },
};
int N = 1;
for (Object[] arr : arrs) {
N = N * arr.length;
}
for (int v = 0; v < N; v++) {
System.out.println(decode(arrs, v));
}
}
static String decode(Object[][] arrs, int v) {
String s = "";
for (Object[] arr : arrs) {
int M = arr.length;
s = s + arr[v % M];
v = v / M;
}
return s;
}
}
(see full output)
This produces the tuplets in a different order. If you want to generate them in the same order as the recursive solution, then you iterate through arrs "backward" during decode as follows:
static String decode(Object[][] arrs, int v) {
String s = "";
for (int i = arrs.length - 1; i >= 0; i--) {
int Ni = arrs[i].length;
s = arrs[i][v % Ni] + s;
v = v / Ni;
}
return s;
}
(see full output)
Thanks to #polygenelubricants for the excellent solution.
Here is the Javascript equivalent:
var a=['0'];
var b=['Auto', 'Home'];
var c=['Good'];
var d=['Tommy', 'Hilfiger', '*'];
var attrs = [a, b, c, d];
function recurse (s, attrs, k) {
if(k==attrs.length) {
console.log(s);
} else {
for(var i=0; i<attrs[k].length;i++) {
recurse(s+attrs[k][i], attrs, k+1);
}
}
}
recurse('', attrs, 0);
EDIT: Here's a ruby solution. Its pretty much the same as my other solution below, but assumes your input character arrays are words: So you can type:
% perm.rb ruby is cool
~/bin/perm.rb
#!/usr/bin/env ruby
def perm(args)
peg = Hash[args.collect {|v| [v,0]}]
nperms= 1
args.each { |a| nperms *= a.length }
perms = Array.new(nperms, "")
nperms.times do |p|
args.each { |a| perms[p] += a[peg[a]] }
args.each do |a|
peg[a] += 1
break if peg[a] < a.length
peg[a] = 0
end
end
perms
end
puts perm ARGV
OLD - I have a script to do this in MEL, (Maya's Embedded Language) - I'll try to translate to something C like, but don't expect it to run without a bit of fixing;) It works in Maya though.
First - throw all the arrays together in one long array with delimiters. (I'll leave that to you - because in my system it rips the values out of a UI). So, this means the delimiters will be taking up extra slots: To use your sample data above:
string delimitedArray[] = {"X","Y","Z","|","A","B","|","1","2","3","4","|"};
Of course you can concatenate as many arrays as you like.
string[] getPerms( string delimitedArray[]) {
string result[];
string delimiter("|");
string compactArray[]; // will be the same as delimitedArray, but without the "|" delimiters
int arraySizes[]; // will hold number of vals for each array
int offsets[]; // offsets will holds the indices where each new array starts.
int counters[]; // the values that will increment in the following loops, like pegs in each array
int nPemutations = 1;
int arrSize, offset, nArrays;
// do a prepass to find some information about the structure, and to build the compact array
for (s in delimitedArray) {
if (s == delimiter) {
nPemutations *= arrSize; // arrSize will have been counting elements
arraySizes[nArrays] = arrSize;
counters[nArrays] = 0; // reset the counter
nArrays ++; // nArrays goes up every time we find a new array
offsets.append(offset - arrSize) ; //its here, at the end of an array that we store the offset of this array
arrSize=0;
} else { // its one of the elements, not a delimiter
compactArray.append(s);
arrSize++;
offset++;
}
}
// put a bail out here if you like
if( nPemutations > 256) error("too many permutations " + nPemutations+". max is 256");
// now figure out the permutations
for (p=0;p<nPemutations;p++) {
string perm ="";
// In each array at the position of that array's counter
for (i=0;i<nArrays ;i++) {
int delimitedArrayIndex = counters[i] + offsets[i] ;
// build the string
perm += (compactArray[delimitedArrayIndex]);
}
result.append(perm);
// the interesting bit
// increment the array counters, but in fact the program
// will only get to increment a counter if the previous counter
// reached the end of its array, otherwise we break
for (i = 0; i < nArrays; ++i) {
counters[i] += 1;
if (counters[i] < arraySizes[i])
break;
counters[i] = 0;
}
}
return result;
}
If I understand the question correctly, I think you could put all your arrays into another array, thereby creating a jagged array.
Then, loop through all the arrays in your jagged array creating all the permutations you need.
Does that make sense?
it sounds like you've almost got it figured out already.
What if you put in there one more array, call it, say ArrayHolder , that holds all of your unknown number of arrays of unknown length. Then, you just need another loop, no?