I completely agree, the wording of the question is terrible. I thought 'lastans' would be assigned the value of 'size'.... Your comment put me back on the right track. Thanks.

import java.io.; import java.util.;

public class Solution {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

    int n = sc.nextInt();
    int q = sc.nextInt();
    int inc=0,inb=0;
    int last = 0,x;
    int  a[][] = new int[q][3];
    int  b[] = new int[100000];
   int  c[] = new int[100000];

    for(int i = 0; i<q ; i++)
    {
        for(int j=0;j<3;j++)
        a[i][j] = sc.nextInt();

        x = ((a[i][1]^last)%n);              //sequence s1 or s0
        if(a[i][0] == 1)                    // query 1 or 0
        {
            if(x == 0)                         
            b[inb++] = a[i][2];
            else
            c[inc++] = a[i][2];
        }
        else{

                if(x == 0)
                last = b[a[i][2]%(inb)];
                else
                last = c[a[i][2]%(inc)];

                System.out.println(last);


        }


    }


}

}

WOULD ANYONE MIND HELPING ME TO FIND WHATS WRONG WITH THIS PROGRAM?

Funny thing is it's a simple piece of code, just 11 lines in python, shame the question is so poorly framed.

After reading the description several times, trying to map the output to the input, then reading the comments, reading the description again, taking a ten minute break, reading the description again and only after that realizing what the types of query actually means, I have to agree that it was fun too solve. Seriously is there any way to obscure the intention any more? The description is way to hard for the work that has to be done.

Agreed - I read the question start to finish twice and still don't completely understand what the question is asking.

Boy, I had no clue what he was asking about. I did not understand what the problem is.

So true. The question was really abstruse. Kind of infuriated me.

can u pls explain me this question

Agreed! Problem discription is way too confusing.

can u please explain the question?

Hard to read, it made me want to avoid that challenge.

I completely agree, the wording of the question is terrible.

The style of writing used was very much the kind we find in technical books or some textbooks. It is closer to "mathematical language".

3 years later, and it's still worded in a confusing way. Also, the mathematics appear to use non-standard symbols.

The example gives (1 XOR 7) % 2 = 3. So 1 XOR 7 is 6, but 6 mod 2 gives 0. So apparently they mean integer division when using the % sign??? Who does that??

Edit: Oops, never mind. Re-read it once again, and they do go with 6 mod 2 = 0. But the zero is then used as an index into array1 (3,5), and LastAnswer is set to that. That's where the 3 comes from. Okay, I think I understand it well enough to start programming finally.

I am still wondering if the difficulty I found to understand the challenge was because I need to study more or was because the question was made in a confusing way?

You just need to break it down into each part.

There is a dynamic array of sequences.

There are two types of queries:

1. one adds an element to a sequence at a calculated index

2. two finds the sequence at a calculated index and prints the value at the calculated subindex.

Dynamicly increasing the size of the array in for query (1) might be why its marked as difficult.

[edit] Although if you in Java if you use an ArrayList then it does seem like a very straight forward problem. If you understood the question and could walk through the example on paper you can implement a solution.

u r correct

I have a question about whether we should use Array of ArrayList, or just 2D array.

I have my own code below

public class Solution {

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int lastans =0;
    int N = sc.nextInt();
    int Q = sc.nextInt();
    int tag, x, y, index;

    ArrayList<Integer>[] list = new ArrayList[N];

    while(Q-->0){
        tag = sc.nextInt();
        x = sc.nextInt();
        y = sc.nextInt();
        index = (x^lastans)%N;

        switch (tag) {

            case 1:
                if (list[index] == null) {
                    ArrayList<Integer> myList = new ArrayList<>();
                    myList.add(y);
                    list[index] = myList;
                } else
                    list[index].add(y);
                break;
            case 2:
                System.out.println(lastans = list[index].get(y % list[index].size()));
                break;
        }
    }
}

}

And code from @__spartax:

public class Solution {

static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
static StringTokenizer tok = null;

public static void main(String[] args) {
    int last = 0, x, y;
    int n = getInt(), q = getInt(), cmd, c, len;
    int[][] A = new int[n][];
    int[] tmp;
    for(int k = 0; k < q; ++k) {
        cmd = getInt();
        x = getInt();
        y = getInt();
        c = (x^last) % n;
        switch(cmd) {
            case 1:
                if(A[c] == null)
                    len = 1;
                else
                    len = A[c].length + 1;
                tmp = new int[len];
                if(A[c] != null)
                    System.arraycopy(A[c], 0, tmp, 0, A[c].length);
                tmp[tmp.length-1] = y;
                A[c] = tmp;
                break;
            case 2:
                System.out.println(last = A[c][y % A[c].length]);
        }
    }
}

static String gets() throws IOException{
    if(tok == null || !tok.hasMoreTokens())
        tok = new StringTokenizer(br.readLine());
    return tok.nextToken();
}

static int getInt() {
    try {
        return Integer.parseInt(gets());
    } catch(IOException | NumberFormatException e) {
        return -1;
    }
}

}

When I used array of ArrayList, I spent twice more time as using 2D array. Yes, I use ArrayList, but ArrayList.get(index) only needs constant time like array. And @__spartax used System.arraycopy, which requires O(n), which is exactly how ArrayList works when it has to expand its size. But he expanded the size everytime. Yes, I have a higher space complexity because of ArrayList, but I don't get it why my algo spends twice time as his. Thanks in advance.

can u explain still more clearly please, specially seqlist(array of arrays concept)

The code below is on the same lines as your code, but please tell me the mistake. I am getting a lot of segmentation faults.

include

include

include

include

int bitxor(int a,int b) { return (a^b); }

int main() { int ** sl; int la=0,n,i,q; int *size;

scanf("%d %d\n",&n,&q);
sl=(int **)malloc(n*sizeof(int *));

size=(int *)malloc(n*sizeof(int));

for(i=0;i<n;i++)
{
    sl[i]=(int *)malloc(n*sizeof(int));
    size[i]=0;
}

// printf("%d %d\n",n,q);

while(q--)
{
    int a,x,y;
    scanf("%d %d %d\n",&a,&x,&y);

 //  printf("%d %d %d\n",a,x,y);

    if(a==1)
    {
        int j;
        j=(bitxor(x,la)%n);
        sl[j][size[j]] = y;
        ++(size[j]);
    }


    else if(a==2)
    {
       int j;
        j=(bitxor(x,la)%n);
        int k=size[j];
        int l = y%k;
        la = sl[j][l];
        printf("%d\n",la);
    }


}



















/* Enter your code here. Read input from STDIN. Print output to STDOUT */    
return 0;

}

Nice Explanation.

Thanks

can u please explain the solution

Brilliant solution bro! Cheers.

Thanks! Your code provided me a vital hint. For last 30 mintes I was doing lastElemOfArray()%size() instead of appendedElement%size()

Best Explaination and cleanest code ever. thanks

Awesome

fantastic bro i am thinking just the same like u and come up with a similar solution after getting your logic ...:)

@rshaghoulian Using java8, do we have a option to make a 2-D array in which outer structure is array and inner structure(each element of array) is ArrayList? As here we have fixed value for n (outer dimension) but changing length for each element of array[n] i.e. ArrayList inside Array.

I got close to the same solution of yours after some hours of work. However, the problem was formulated a bit confusing. It was more to understand what one wants. Problem is not so hard once you get it.