求一算法，欢迎大家积极讨论

Question

一个List，数据是这样的，List(3个，7个，4个，17个....)   n个代表有多少个元素要求，写一个函数，传入两个参数，即开始值和结束值，返回此List中第几个元素的第几个开始和第几个元素的第几个结束。例如 
 输入参数（5，15），返回第2个元素的第2开始，第4个元素的第1个结束 即 2，2，4，1
输入参数（10，20），返回第2个元素的第7开始，第4个元素的第6个结束 即 2，7，4，6java这里冷清许多了感觉

Answer 1

看了好久终于明白了，可以写成这样便于理解。算法在思考中。
List(3个，7个，4个，17个....)  
List(1,2,3(3个);4,5,6,7,8,9,10(7个);11,12,13,14(4个);......)

Answer 2

List中的元素是什么？
难道是一个List数组？

Answer 3

4楼理解的也许很对,但楼主就很不对:你考验我的理解能力?
先说List,你这和java.util.List重名,不是不可以,是你没说清楚
再说(3个，7个，4个，17个....) 这是啥语法,构造函数?
还有List,既然是你自定义的类,那是什么结构
最后,这个"3个,7个"的"个"是什么东东
总之,你说的很模糊

Answer 4

明白了，应该就是4楼的想法。
正常思路：
1、比较传入参数，返回从小到大的排序。
2、定义返回listRtn，
3、定义临时变量：curPos = 0，记录当前循环的序列的自序列的总长度。定义临时变量curParm = 第一个参数，用于代替两个参数的值。
4、循环List，curPos ＝ curPos ＋list当前元素（子list的长度），判断curPos是否大于等于 
curParm ，真则取当前元素（子list的长度）的第（curPos － curParm ＋ 1）个元素，并curParm ＝ 第二个参数，并listRtn.add(取到的元素)。判断listRtn的长度＝2 return listRtn，否则继续循环。
初步想法，没写出具体函数。供讨论。

Answer 5

List(3个，7个，4个，17个....)  
List(1,2,3(3个);4,5,6,7,8,9,10(7个);11,12,13,14(4个);......)
明白了  谢谢四楼  也就是  第一个参数 不如5是 数组的第二个元素所包括的数  又是第二个  所以返回 2 2
15同理 返回 4 1但写出有点难度
也就是我现在写不出

Answer 6

在数组上累加就可以算出来了朴素算法如下，没啥高深技术：import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/**
 * 不规则列表的数据起止判定
 * @author jinxfei
 *
 */
public class BGZList { private static Random r=new Random(System.currentTimeMillis());

public static void main(String[] args) throws Exception{
List<Integer> targetList=createBGZList();
System.out.println("随机数组：\n"+targetList);
System.out.println("请输入起始值：\n");
BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
int start=Integer.parseInt(r.readLine());
System.out.println("请输入终止值：\n");
int end=Integer.parseInt(r.readLine());
end-=start;
int startIndex=0,startPos=0;
int endIndex=0,endPos=0;
for(int i=0; i<targetList.size();i++){
Integer cur=targetList.get(i);
if (start>=0){
if (start>cur){
start-=cur;
continue;
}
startIndex=i+1;
startPos=start;
start=-1;
}else{
if (end>cur){
end-=cur;
continue;
}
endIndex=i+1;
endPos=end;
break;
}

}
System.out.println("开始于 "+startIndex+" 的 "+startPos+", 结束于 "+endIndex+" 的 "+endPos);
}

/**
 * 创建一个随机长度(10-110)的list，list中的每一个数字也都是随机的（5-55)，
 * 
 * @return
 */
private static List<Integer> createBGZList(){
List<Integer> result=new ArrayList<Integer>();
int listLength=r.nextInt(100)+10;
for(int i=0; i<listLength;i++){
result.add(r.nextInt(50)+5);
}
return result;
}
}

Answer 7

写好了，可能不是很规范 ，但可以得到结果。考到java里面直接可以运行package a;import java.util.ArrayList;
import java.util.List;public class Test { public static List<int[]> list = new ArrayList<int[]>(); public Test() {
int[] a = { 1, 2, 3 };
int[] b = { 4, 5, 6, 7, 8, 9, 10 };
int[] c = { 11, 12, 13, 14 };
list.add(a);
list.add(b);
list.add(c);
} public int[] function(int x, int y) {
int[] returnBack = new int[4];
int[] a = get(x);
int[] b = get(y);
returnBack[0] = a[0];
returnBack[1] = a[1];
returnBack[2] = b[0];
returnBack[3] = b[1];
return returnBack;
} public static int[] get(int x) {
int[] returnBack = new int[2];
int sum = 0;
int cout = 0;
for (int n = 0; n < list.size(); n++) {
sum = sum + (list.get(n)).length;
if (x <= sum && cout == 0) {
cout++;
returnBack[0] = n + 1;
for (int i = 0; i < (list.get(n)).length; i++) {
if (x == list.get(n)[i]) {
returnBack[1] = i + 1;
}
}
}
} return returnBack;
} public static void main(String[] args) {
Test test = new Test();
int[] aa = test.function(3, 14); for (int i = 0; i < aa.length; i++) {
System.out.println(aa[i]); }
}}

Answer 8

package com.csdn;import java.util.ArrayList;
import java.util.List;import com.sun.java_cup.internal.internal_error;public class TestList {
//size>1
public static List getInt(int size){
List childList = new ArrayList();
for(int i = 0;i<size;i++){
childList.add(i+1);
}
return childList;
} //随机从LIST中获得n个数字(不重复)用于---截断---（eg:123，456，6，789，10）
public static List getFatherList(int m,List childList ,int max) {
int n = childList.size();

 List listnew = new ArrayList();
n--;
for(int i = 0;i<childList.size()&&m>0;i++,m--) {
//随机获得一个
int charIndex = (int) Math.floor(Math.random() * n);
//加入
listnew.add(childList.get(charIndex));
//加了后去掉
childList.remove(charIndex);

}
listnew.add(max);
return listnew;

}
//将随机获得LIST转换为数组

public static int[] getFatherListInt(List faList){
int[] getIs = new int[faList.size()];
for(int i = 0;i<faList.size();i++){
getIs[i]=(Integer)faList.get(i);

}

return getIs;
}

//对随机获得的进行排序
    public static int[] Sort(int[] a){
        int len = a.length;
        for(int i = len-1;i>=1;i--){
            for(int j = 0;j<=i-1;j++){
                if(a[j]>a[j+1]){
                    int temp = a[j]; 
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        return a;
    }
    
    //获得eg String[0]="123,",string[2]="56789"
    public static String[] getSortString(int[] a,int max){
     boolean flag = false;
     String [] strings = new String[a.length];
     int m = 0;
   
     for(int i = 0;i<a.length;i++){
     if(flag){
     break;
     }
     StringBuffer s = new StringBuffer();
     if(i-1<0){
     for(int j =0;j<a[i];j++){
         m++;
         s.append(String.valueOf((m)));
         s.append(",");
         }
    
     }else{
     for(int j = a[i-1];j<a[i];j++){
         m++;
         s.append(String.valueOf((m)));
         s.append(",");
         if(m==max){
         flag=true;
         break;
         }
         }
    
     }
    
     strings[i]=s.toString();
     }
    
     return strings;
    }
    //输入参数（5，15），返回第2个元素的第2开始，第4个元素的第1个结束 
    
    public static void getResult(int i,int j,String[] aStrings){
String a = String.valueOf(i);
String b = String.valueOf(j);

for(int n= 0;n<aStrings.length;n++){
String[] childStrings = aStrings[n].split(",");
for(int m = 0;m<childStrings.length;m++){
if(childStrings[m].equals(a)){
System.out.println(a+"--is第--"+(n+1)+"--个元素的第--"+(m+1)+"--个");
}
if(childStrings[m].equals(b)){
System.out.println(b+"--is第--"+(n+1)+"--个元素的第--"+(m+1)+"--个");
}
}

}
    
    }
    
public static void main(String[] args) {
//n个元素
int n=5;
//经过测试发现5个点变成了6段因此数量（最大值手动加上）
List list =getFatherList(5,getInt(70),70);
for(int i = 0;i<list.size();i++){
System.out.println("随机取得的6个不重复数字："+list.get(i).toString());
}
System.out.println("---------------------------------------");
int[] a = getFatherListInt(list);
Sort(a);
for(int i = 0;i<a.length;i++){
System.out.println(a[i]+"---a[i]");
}

String[] aStrings = getSortString(a,70);
for(int i = 0;i<aStrings.length;i++){
System.out.println(aStrings[i]);
}


getResult(5,15,aStrings);
/*int[] aI = getFatherListInt(getFatherList(5,getInt(70)));
String[] aStrings = getSortString(aI,70);
for(int i = 0;i<aStrings.length;i++){
System.out.println(aStrings[i]);
}
getResult(5,15,aStrings);*/
}
}
结果：

Answer 9

随机取得的6个不重复数字：12
随机取得的6个不重复数字：47
随机取得的6个不重复数字：11
随机取得的6个不重复数字：52
随机取得的6个不重复数字：5
随机取得的6个不重复数字：70
---------------------------------------
5---a[i]
11---a[i]
12---a[i]
47---a[i]
52---a[i]
70---a[i]
1,2,3,4,5,
6,7,8,9,10,11,
12,
13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,
48,49,50,51,52,
53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,
5--is第--1--个元素的第--5--个
15--is第--4--个元素的第--3--个

Answer 10

随机取得的6个不重复数字：66
随机取得的6个不重复数字：2
随机取得的6个不重复数字：48
随机取得的6个不重复数字：59
随机取得的6个不重复数字：11
随机取得的6个不重复数字：70
---------------------------------------
2---a[i]
11---a[i]
48---a[i]
59---a[i]
66---a[i]
70---a[i]
1,2,
3,4,5,6,7,8,9,10,11,
12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,
49,50,51,52,53,54,55,56,57,58,59,
60,61,62,63,64,65,66,
67,68,69,70,
5--is第--2--个元素的第--3--个
15--is第--3--个元素的第--4--个

Answer 11

题目得意思理解了
暂时用 java list<Integer> 代表列表，用int型代表是几个元素
不管开始位置还是结束位置都是在数组中找到对应的几个元素，的第几个位置，所以可以用一个方法解决
通过累加的方式判断输入的index在哪个元素中，减去前边累加的数据得到位置序号
import java.util.ArrayList;
import java.util.List;
public class ArraysTest { private List<Integer> list = new ArrayList<Integer>();
public ArraysTest(List<Integer> _list) 
{
list = _list;
} public String getResultValues(int begin,int end)
{
return getValues(begin)+","+getValues(end);
}

public String getValues(int index)
{
int sum =0;
int postion= 0;
int postionIndex= 0;
String result = "";

for (int i = 0; i < list.size(); i++) 
{
if (sum < index)
{
sum = sum+list.get(i);
}
else
{
postion= i;
postionIndex= index - (sum -list.get(i-1));
return String.valueOf(postion)+","+String.valueOf(postionIndex);
}
}
if (sum >= index)
{
postion= list.size();
postionIndex= index - (sum -list.get(list.size()-1));
return String.valueOf(postion)+","+String.valueOf(postionIndex);
}
return result;
}
/**
 * @param args
 */
public static void main(String[] args) 
{
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(3);
list.add(7);
list.add(4);
list.add(17);
ArraysTest test = new ArraysTest(list);
System.out.println(test.getResultValues(31, 31));
}
}

Answer 12

不冷清，我还在啊，哈哈。贴我的代码吧，不过其实可以用HashMap实现，把List里的数组作为map的value，key就是list里每个数组的长度，然后再来比较输出。不过我的代码就是最直接的 复制到数组中 然后遍历输出：
import java.util.*;public class FindElements {
static List<int[]> list = new ArrayList<int[]>();
static int arrayLength;

public static void findElements(int start, int end){
arrayLength = 0;

if(start > end){
System.err.println("Error! Start > End!");
return;
}
Iterator<int[]> iterator = list.iterator();

while(iterator.hasNext())
arrayLength += iterator.next().length;

if (end > arrayLength){
System.err.println("Error! End is over the maximum!");
return;
}

int[] tempArray = new int[arrayLength];
int count = 0;

Iterator<int[]> iterator1 = list.iterator();

while(iterator1.hasNext()){
int[] intArray = iterator1.next();

for(int i=0; i<intArray.length; i++){
tempArray[count] = intArray[i];
count++;
}
}

for(int i=start-1; i<end; i++)
System.out.print(tempArray[i] +" ");

System.out.println();
}

public static void main(String args[]){
int[] intArray1 = {1, 4, 6, 8};
int[] intArray2 = {1, 14, 6, 5, 18, 22};
int[] intArray3 = {1, 22, 36};
int[] intArray4 = {91, 4, 6, 866, 55, 21, 72};

list.add(intArray1);
list.add(intArray2);
list.add(intArray3);
list.add(intArray4);

findElements(3, 7);
findElements(6, 14);
}
}

Answer 13

一个List，数据是这样的，List(3个，7个，4个，17个....)  n个代表有多少个元素 这种结构 如果得来的呢？

Answer 14

4楼理解力很强，我有一点不明白list的规律是什么？List(3个，7个，4个，17个....)  后面是什么呢？

Answer 15

private short GetElememntPos(short start, short end, 
            ref short se, ref short sp, ref short ee, ref short ep)
        {
            short ret = 0;
            if (start > end) { return -1; }            Dictionary<short, short> container = new Dictionary<short, short>();
            container.Add(1, 3);
            container.Add(2, 7);
            container.Add(3, 4);
            container.Add(4, 17);            short total = 0;
            bool SettedStart = false;
            sp = start;
            ep = end;
            foreach (KeyValuePair<short, short> kvp in container)
            {
                total += kvp.Value;
                if (!SettedStart)
                {
                    if (total >= start)
                    {
                        se = kvp.Key;
                        SettedStart = true;
                    }
                    else { sp -= kvp.Value; }
                }                if (total >= end)
                {
                    ee = kvp.Key;
                    break;
                }
                else { ep -= kvp.Value; }
            }
            return ret;
        }
        private void button2_Click(object sender, EventArgs e)
        {
            short[] data = new short[4];
            GetElememntPos(5, 15, ref data[0], ref data[1], ref data[2], ref data[3]);
        }

Answer 16

我太有才了,呵呵看明白了不容易啊!List(3个，7个，4个，17个....)可以这样写更容易理解一点:List((1,2,3)，(4,5,6,7,8,9,10)，(11,12,13,14)，(15,16,17,...31)....)  

Answer 17

import java.util.ArrayList;
import java.util.List;
public class ArraysTest {    private List<Integer> list = new ArrayList<Integer>();
    public ArraysTest(List<Integer> _list) 
    {
        list = _list;
    }    public String getResultValues(int begin,int end)
    {
        return getValues(begin)+","+getValues(end);
    }
    
    public String getValues(int index)
    {
        int sum =0;
        int postion= 0;
        int postionIndex= 0;
        String result = "";
        
        for (int i = 0; i < list.size(); i++) 
        {
            if (sum < index)
            {
                sum = sum+list.get(i);
            }
            else
            {
                postion= i;
                postionIndex= index - (sum -list.get(i-1));
                return String.valueOf(postion)+","+String.valueOf(postionIndex);
            }
        }
        if (sum >= index)
        {
            postion= list.size();
            postionIndex= index - (sum -list.get(list.size()-1));
            return String.valueOf(postion)+","+String.valueOf(postionIndex);
        }
        return result;
    }
    /**
     * @param args
     */
    public static void main(String[] args) 
    {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(3);
        list.add(7);
        list.add(4);
        list.add(17);
        ArraysTest test = new ArraysTest(list);
        System.out.println(test.getResultValues(31, 31));
    }
}