有趣的编程题

Question

给一个无限长的自然数构成的字符串
S:12345678910111213141516…，它是由所有
自然数从小到大依次排列起来的，任意给一个数
字串S1，编程求出它第一次出现的位置。

Answer 1

String s="12345678910111213141516";
s.indexOf("456");

Answer 2

一个思路！     StringBuffer sb = new StringBuffer();
    String s1 = "457";
    boolean temp = true;
    if ("0".equals(s1))
    {
     System.out.println(10);
    }
    for (int i = 0; i < s1.length() - 1; i++)
    {
     if (s1.charAt(i) + 1  !=  s1.charAt(i + 1))
     {
     temp = false;
     break;
     }
    }
    if (temp)
    {
     System.out.println(s1.charAt(0)); 
    }
    else
    {
    int is = Integer.parseInt(s1);
    for (int i = 1; i <= is; i++)
    {
     sb.append(i);     
    }
    System.out.println(sb.toString());
    System.out.println(sb.toString().indexOf(s1));
    }

Answer 3

public class Test{
public static void main(String[] args) { 
String str="101";
long position=pos(str);
System.out.println(str+"的位置是: 从"+position+"到"+(position+str.length()));
}

static long  pos(String str){
long x=Long.parseLong(str),y=1;
long position=0;

for(int i=1;i<=str.length()-1;i++){
position+=y*9*i;
y*=10;
}
position+=(x-y)*str.length();
return position+1;
}
        
}F:\java>java Test
101的位置是: 从193到196

Answer 4

indexOf（）估计采用的就是kmp吧。这题好象不是求子串。

Answer 5

搞不明白楼主的具体目的...难道就是indexof()？

Answer 6

andycpp说的对，这道题是算法题。要找出它的规律还真不容易！

Answer 7

public class Test{
public static void main(String[] args) { 
String[] strs={"101","4","34","1253"};
for(int i=0;i<strs.length;i++){
long position=pos(strs[i]);
System.out.println(strs[i]+"的位置是: 从"+position+"到"+(position+strs[i].length()));
System.out.println("验证："+pos2(strs[i])+"\n");
} }

static long  pos(String str){
long x=Long.parseLong(str),y=1;
long position=0;

for(int i=1;i<=str.length()-1;i++){
position+=y*9*i;
y*=10;
}
position+=(x-y)*str.length();
return position+1;
}
/**这个算法是把一个1~Long.parseLong(str)之间的数都转为字符串连起来再看结果。
*/
static long pos2(String str){
long x=Long.parseLong(str);
StringBuilder resualt=new StringBuilder();
for(int i=1;i<x;i++){
resualt.append(String.valueOf(i));
}
return resualt.length()+1;
}
        
}
F:\java>java Test
101的位置是: 从193到196
验证：1934的位置是: 从4到5
验证：434的位置是: 从58到60
验证：581253的位置是: 从3902到3906
验证：3902

Answer 8

最简单的办法就是:对给定的s1，把这个s1转为整数x，再把1~x之间的数转为字符串并连接起来，再用indexOf（）求出。问题是如果给定的s1非常的长，比如有50个数字字符组成，一个long最多能表示19位数字，只好用java.math.BigInteger来做，而连接成的字符串非常的长，大约是s1.length()+90*2+900*3+....+9000..000*49+s1.length()*(x-9000...00),也是一个非常庞大的数。不好办啊。

Answer 9

解决思路
a 一个数是如：45795（长度问N）
b 找到包含这个数的最小的连续的两个数：5794 5795
此算法复杂度为o（（N+1）！）
c 然后求出45795 在5794 5795的索引：3和两连续数的前一个数5794
d 最后求出45795的位置：

Answer 10

问题就是无限长的字串
所以需要字串的分割，但是分割的同时要保证字串的完整性。
每100个字符切开，但是你要保证第99，100，101，102正好组合成要求的标准时。KMP算法是可行的。但需要很好的文件操作支持。
只有这么多思路了

Answer 11

弄了一晚上，暂时没有实现输入串前面带0的情况，有兴趣的同学可以完善一下，思路应该是一样的package quiz;public class Headache {
private String analysis;
private int digits;
private int rstOffset, rstDiv;
private long rstIndex = Long.MAX_VALUE;
private String outPut; Headache(String src) {
analysis = src;
digits = src.length();
if (hasLeadingZero(analysis)) {
// 对含前导零的输入串尚需处理
} else {
rstOffset = 0;
rstDiv = digits;
}
} public void analyse() {
boolean find = false;
for (int n = 1; n <= digits; n++) {
// 对同一个n的不同offset匹配结果须比较大小
if (find) {
return;
}
inner1: for (int offset = 0; offset < n; offset++) {
int i = n; // 当前最高位数
int index = 0; // 当前索引
boolean carry = false; // 是否产生进位
String pre;
String suc;
if (offset != 0) {
pre = analysis.substring(0, offset);
index += offset;
} else {
pre = analysis.substring(0, i);
index += i;
}
if (hasLeadingZero(pre)) {
if (pre.length() != 1 && Long.parseLong(pre) == 0) {
continue inner1;
}
} if (isMax(pre)) {
i++;
carry = true;
}
while (true) {
if (index + i >= digits) {
if (offset == 0 && n == digits) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
continue inner1;
}
if (index == digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
continue inner1;
}
suc = analysis.substring(index, digits);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
} else {
if (offset != 0 && index == offset) {
if (suc.length() - (2 * n - digits) < 0
|| 2 * n <= digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
} else if (String.format(
String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(0,
2 * n - digits).equals(
suc.substring(suc.length()
- (2 * n - digits), suc
.length()))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
} }
continue inner1;
}
if (String.valueOf(Long.parseLong(pre) + 1)
.substring(0, suc.length()).equals(suc)) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
}
continue inner1;
} suc = analysis.substring(index, index + i);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (!suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
continue inner1;
} else {
carry = false;
}
} else {
if (offset != 0 && index == offset) {
if (!String.format(String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(
n - offset, n).equals(
suc.substring(n - offset, n))) {
continue inner1;
}
} else {
if (!String.valueOf(Long.parseLong(pre) + 1)
.equals(suc)) {
continue inner1;
}
}
}
index += i;
if (isMax(suc)) {
i++;
carry = true;
}
pre = suc;
}
}
}
} public boolean hasLeadingZero(String test) {
return test.charAt(0) == '0';
} public boolean isMax(String test) {
return test.equals(test.replaceAll("\\d", "9"));
} public String getFstNum(int argOffset, int argDiv) {
String tmpOne;
if (argOffset + argDiv > digits) {
int len = argDiv - (digits - argOffset);
String tmp = String.format(String.format("%%0%dd", len),
Long.parseLong(analysis.substring(argOffset - len,
argOffset)) + 1);
tmpOne = analysis.substring(argOffset, digits)
+ tmp.substring(tmp.length() - len, tmp.length());
} else {
tmpOne = analysis.substring(argOffset, argOffset + argDiv);
}
return tmpOne;
} public long calIndex(int argOffset, int argDiv) {
String tmpTwo = getFstNum(argOffset, argDiv);
long total = 0;
long base = 0;
for (int i = 1; i < tmpTwo.length(); i++) {
base += Math.pow(10, i - 1);
total += 9 * i * base;
}
total += tmpTwo.length()
* (Long.parseLong(tmpTwo) - Math.pow(10, tmpTwo.length() - 1) + 1);
total -= (argOffset + 1);
return total;
} public void Print() {
analyse();
System.out.println("the position of first appearance is "
+ (rstIndex + 1) + "  rstOffset:" + rstOffset + "   rstDiv"
+ rstDiv);
System.out.println("the first extracted number is "
+ getFstNum(rstOffset, rstDiv));
System.out.println(calIndex(3, 4));
} public static void main(String[] args) {
//在构造函数中输入要求位置的字符串
Headache tm = new Headache("3412");
tm.Print(); }
}

Answer 12

不能编辑代码？删去了一些测试的代码
package quiz;public class Headache {
private String analysis;
private int digits;
private int rstOffset, rstDiv;
private long rstIndex = Long.MAX_VALUE;
private String outPut; Headache(String src) {
analysis = src;
digits = src.length();
if (hasLeadingZero(analysis)) {
// 对含前导零的输入串尚需处理
} else {
rstOffset = 0;
rstDiv = digits;
}
} public void analyse() {
boolean find = false;
for (int n = 1; n <= digits; n++) {
// 对同一个n的不同offset匹配结果须比较大小
if (find) {
return;
}
inner1: for (int offset = 0; offset < n; offset++) {
int i = n; // 当前最高位数
int index = 0; // 当前索引
boolean carry = false; // 是否产生进位
String pre;
String suc;
if (offset != 0) {
pre = analysis.substring(0, offset);
index += offset;
} else {
pre = analysis.substring(0, i);
index += i;
}
if (hasLeadingZero(pre)) {
if (pre.length() != 1 && Long.parseLong(pre) == 0) {
continue inner1;
}
} if (isMax(pre)) {
i++;
carry = true;
}
while (true) {
if (index + i >= digits) {
if (offset == 0 && n == digits) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
continue inner1;
}
if (index == digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
continue inner1;
}
suc = analysis.substring(index, digits);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
} else {
if (offset != 0 && index == offset) {
if (suc.length() - (2 * n - digits) < 0
|| 2 * n <= digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
} else if (String.format(
String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(0,
2 * n - digits).equals(
suc.substring(suc.length()
- (2 * n - digits), suc
.length()))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
} }
continue inner1;
}
if (String.valueOf(Long.parseLong(pre) + 1)
.substring(0, suc.length()).equals(suc)) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
}
continue inner1;
} suc = analysis.substring(index, index + i);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (!suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
continue inner1;
} else {
carry = false;
}
} else {
if (offset != 0 && index == offset) {
if (!String.format(String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(
n - offset, n).equals(
suc.substring(n - offset, n))) {
continue inner1;
}
} else {
if (!String.valueOf(Long.parseLong(pre) + 1)
.equals(suc)) {
continue inner1;
}
}
}
index += i;
if (isMax(suc)) {
i++;
carry = true;
}
pre = suc;
}
}
}
} public boolean hasLeadingZero(String test) {
return test.charAt(0) == '0';
} public boolean isMax(String test) {
return test.equals(test.replaceAll("\\d", "9"));
} public String getFstNum(int argOffset, int argDiv) {
String tmpOne;
if (argOffset + argDiv > digits) {
int len = argDiv - (digits - argOffset);
String tmp = String.format(String.format("%%0%dd", len),
Long.parseLong(analysis.substring(argOffset - len,
argOffset)) + 1);
tmpOne = analysis.substring(argOffset, digits)
+ tmp.substring(tmp.length() - len, tmp.length());
} else {
tmpOne = analysis.substring(argOffset, argOffset + argDiv);
}
return tmpOne;
} public long calIndex(int argOffset, int argDiv) {
String tmpTwo = getFstNum(argOffset, argDiv);
long total = 0;
long base = 0;
for (int i = 1; i < tmpTwo.length(); i++) {
base += Math.pow(10, i - 1);
total += 9 * i * base;
}
total += tmpTwo.length()
* (Long.parseLong(tmpTwo) - Math.pow(10, tmpTwo.length() - 1) + 1);
total -= (argOffset + 1);
return total;
} public void Print() {
analyse();
System.out.println("the position of first appearance is "
+ (rstIndex + 1) + "  rstOffset: " + rstOffset + "   rstDiv："
+ rstDiv);
System.out.println("the first extracted number is "
+ getFstNum(rstOffset, rstDiv));
} public static void main(String[] args) {
//在构造函数中输入要求位置的字符串
Headache tm = new Headache("989910");
tm.Print(); }
}

Answer 13

完全版本，可求任意字符串
package quiz;public class Headache {
private String analysis;
private int digits;
private int rstOffset, rstDiv;
private long rstIndex = Long.MAX_VALUE;
private String outPut; Headache(String src) {
analysis = src;
digits = src.length();
} public void analyse() {
boolean find = false;
if (analysis.length() != 1 && Long.parseLong(analysis) == 0) {
rstOffset = digits;
rstDiv = digits + 1;
rstIndex = calIndex(digits, digits + 1);
}
for (int n = 1; n <= digits; n++) {
// 对同一个n的不同offset匹配结果须比较大小
if (find) {
return;
}
inner1: for (int offset = 0; offset < n; offset++) {
int i = n; // 当前最高位数
int index = 0; // 当前索引
boolean carry = false; // 是否产生进位
String pre;
String suc;
if (offset != 0) {
pre = analysis.substring(0, offset);
index += offset;
} else {
pre = analysis.substring(0, i);
index += i;
}
if (hasLeadingZero(pre) && offset == 0) {
continue inner1;
}
if (isMax(pre)) {
i++;
carry = true;
}
while (true) {
if (index + i >= digits) {
if (offset == 0 && n == digits) {
if (hasLeadingZero(analysis)) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
continue inner1;
}
if (index == digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
continue inner1;
}
suc = analysis.substring(index, digits);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
} else {
if (offset != 0 && index == offset) {
if (suc.length() - (digits - n) < 0
|| n == digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
} else if (String.format(
String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(0,
(digits - n)).equals(
suc.substring(suc.length()
- (digits - n), suc.length()))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
} }
continue inner1;
}
if (String.valueOf(Long.parseLong(pre) + 1)
.substring(0, suc.length()).equals(suc)) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
}
continue inner1;
} suc = analysis.substring(index, index + i);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (!suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
continue inner1;
} else {
carry = false;
}
} else {
if (offset != 0 && index == offset) {
if (!String.format(String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(
n - offset, n).equals(
suc.substring(n - offset, n))) {
continue inner1;
}
} else {
if (!String.valueOf(Long.parseLong(pre) + 1)
.equals(suc)) {
continue inner1;
}
}
}
index += i;
if (isMax(suc)) {
i++;
carry = true;
}
pre = suc;
}
}
}
} public boolean hasLeadingZero(String test) {
return test.charAt(0) == '0';
} public boolean isMax(String test) {
return test.equals(test.replaceAll("\\d", "9"));
} public String getFstNum(int argOffset, int argDiv) {
if (argDiv == digits + 1) {
return "1" + analysis;
}
String tmpOne;
if (argOffset + argDiv > digits) {
int len = argDiv - (digits - argOffset);
String tmp = String.format(String.format("%%0%dd", len),
Long.parseLong(analysis.substring(argOffset - len,
argOffset)) + 1);
tmpOne = analysis.substring(argOffset, digits)
+ tmp.substring(tmp.length() - len, tmp.length());
} else {
tmpOne = analysis.substring(argOffset, argOffset + argDiv);
}
return tmpOne;
} public long calIndex(int argOffset, int argDiv) {
String tmpTwo = getFstNum(argOffset, argDiv);
long total = 0;
long base = 0;
for (int i = 1; i < tmpTwo.length(); i++) {
base += Math.pow(10, i - 1);
total += 9 * i * base;
}
total += tmpTwo.length()
* (Long.parseLong(tmpTwo) - Math.pow(10, tmpTwo.length() - 1) + 1);
total -= (argOffset + 1);
return total;
} public void Print() {
analyse();
System.out.println("the input String: " + analysis);
System.out.println("the first extracted number is "
+ getFstNum(rstOffset, rstDiv) + "  rstOffset(在原串中出现的位置）: "
+ rstOffset + "   rstDiv（位数）：" + rstDiv);
System.out.println("the position of first appearance is "
+ (rstIndex + 1));
} public static void main(String[] args) {
// 在构造函数中输入要求位置的字符串
Headache tm = new Headache("12354");
tm.Print(); }
}

Answer 14

受长整型范围约束，最大可以输入长度为18位的字符串，修正一个小bugpackage quiz;public class Headache {
private String analysis;
private int digits;
private int rstOffset, rstDiv;
private long rstIndex = Long.MAX_VALUE;
private String outPut; Headache(String src) {
analysis = src;
digits = src.length();
} public void analyse() {
boolean find = false;
if (Long.parseLong(analysis) == 0) {
rstOffset = digits;
rstDiv = digits + 1;
rstIndex = calIndex(digits, digits + 1);
}
for (int n = 1; n <= digits; n++) {
// 对同一个n的不同offset匹配结果须比较大小
if (find) {
return;
}
inner1: for (int offset = 0; offset < n; offset++) {
int i = n; // 当前最高位数
int index = 0; // 当前索引
boolean carry = false; // 是否产生进位
String pre;
String suc;
if (offset != 0) {
pre = analysis.substring(0, offset);
index += offset;
} else {
pre = analysis.substring(0, i);
index += i;
}
if (hasLeadingZero(pre) && offset == 0) {
continue inner1;
}
if (isMax(pre)) {
i++;
carry = true;
}
while (true) {
if (index + i >= digits) {
if (offset == 0 && n == digits) {
if (hasLeadingZero(analysis)) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
continue inner1;
}
if (index == digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
continue inner1;
}
suc = analysis.substring(index, digits);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
} else {
if (offset != 0 && index == offset) {
if (suc.length() - (digits - n) < 0
|| n == digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
} else if (String.format(
String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(0,
(digits - n)).equals(
suc.substring(suc.length()
- (digits - n), suc.length()))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
} }
continue inner1;
}
if (String.valueOf(Long.parseLong(pre) + 1)
.substring(0, suc.length()).equals(suc)) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
}
continue inner1;
} suc = analysis.substring(index, index + i);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (!suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
continue inner1;
} else {
carry = false;
}
} else {
if (offset != 0 && index == offset) {
if (!String.format(String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(
n - offset, n).equals(
suc.substring(n - offset, n))) {
continue inner1;
}
} else {
if (!String.valueOf(Long.parseLong(pre) + 1)
.equals(suc)) {
continue inner1;
}
}
}
index += i;
if (isMax(suc)) {
i++;
carry = true;
}
pre = suc;
}
}
}
} public boolean hasLeadingZero(String test) {
return test.charAt(0) == '0';
} public boolean isMax(String test) {
return test.equals(test.replaceAll("\\d", "9"));
} public String getFstNum(int argOffset, int argDiv) {
if (argDiv == digits + 1) {
return "1" + analysis;
}
String tmpOne;
if (argOffset + argDiv > digits) {
int len = argDiv - (digits - argOffset);
String tmp = String.format(String.format("%%0%dd", len),
Long.parseLong(analysis.substring(argOffset - len,
argOffset)) + 1);
tmpOne = analysis.substring(argOffset, digits)
+ tmp.substring(tmp.length() - len, tmp.length());
} else {
tmpOne = analysis.substring(argOffset, argOffset + argDiv);
}
return tmpOne;
} public long calIndex(int argOffset, int argDiv) {
String tmpTwo = getFstNum(argOffset, argDiv);
long total = 0;
long base = 0;
for (int i = 1; i < tmpTwo.length(); i++) {
base += Math.pow(10, i - 1);
total += 9 * i * base;
}
total += tmpTwo.length()
* (Long.parseLong(tmpTwo) - Math.pow(10, tmpTwo.length() - 1) + 1);
total -= (argOffset + 1);
if (argDiv == digits + 1) {
total++;
}
return total;
} public void Print() {
analyse();
System.out.println("the input String: " + analysis);
System.out.println("the first extracted number is "
+ getFstNum(rstOffset, rstDiv) + "  rstOffset(在原串中出现的位置）: "
+ rstOffset + "   rstDiv（位数）：" + rstDiv);
System.out.println("the position of first appearance is "
+ (rstIndex + 1));
} public static void main(String[] args) {
// 在构造函数中输入要求位置的字符串
Headache tm = new Headache("001");
tm.Print(); }
}

Answer 15

我觉得大家把问题想得复杂了
支持一楼
楼主只是说要查询第一次出现的位置而已
直接用indexOf()方法 返回的就是子字符串第一次出现的位置其他不用想了

Answer 16

两种方案：
1 判断给定数字：
如：1256
先判断第一位的数字，假设为一位的数字，判断后面的数字是否符合；
如不符合，则假设为两位数字，先从两位数字的一位判断，后面数字是否符合，不附合在假设为两位数字的第二位，再进行判断，以此类推；
如果判断到和给定数字同大小的数字，比如四位数字，则判断构造的四位数字是否比该数字大，如果小则继续判断，如果大，直接给出该四位数字按照规律出现的位置。
2 先给出给定数字出现的位置，并构造串，再使用index索引，如果有则给出值，没有则使用初时值。

Answer 17

public class A
{
public static void main(String args[])
{ Scanner scan = new Scanner(System.in);
 String s=scan.nextLine();
 int a=Interger.parseInt(s);
 String t="";
 for(int i=1;i<=a;i++)
 t+=i;
 System.out.println(t.indexof(s));}}
这样比较简单，没有运行，应该可以

Answer 18

呵呵，有个地方忘记改了，判断太多，心里也不太有底，这样应该可以了
package quiz;public class Headache {
private String analysis;
private int digits;
private int rstOffset, rstDiv;
private long rstIndex = Long.MAX_VALUE;
private String outPut; Headache(String src) {
analysis = src;
digits = src.length();
} public void analyse() {
boolean find = false;
if (Long.parseLong(analysis) == 0) {
rstOffset = digits;
rstDiv = digits + 1;
rstIndex = calIndex(digits, digits + 1);
}
for (int n = 1; n <= digits; n++) {
// 对同一个n的不同offset匹配结果须比较大小
if (find) {
return;
}
inner1: for (int offset = 0; offset < n; offset++) {
int i = n; // 当前最高位数
int index = 0; // 当前索引
boolean carry = false; // 是否产生进位
String pre;
String suc;
if (offset != 0) {
pre = analysis.substring(0, offset);
index += offset;
} else {
pre = analysis.substring(0, i);
index += i;
}
if (hasLeadingZero(pre) && offset == 0) {
continue inner1;
}
if (isMax(pre)) {
i++;
carry = true;
}
while (true) {
if (index + i >= digits) {
if (offset == 0 && n == digits) {
if (hasLeadingZero(analysis)) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
continue inner1;
}
if (index == digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
continue inner1;
}
suc = analysis.substring(index, digits);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
} else {
if (offset != 0 && index == offset) {
if (suc.length() - (digits - n) < 0
|| n == digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
} else if (String.format(
String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(
suc.length() - (digits - n),
suc.length()).equals(
suc.substring(suc.length()
- (digits - n), suc.length()))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
} }
continue inner1;
}
if (String.valueOf(Long.parseLong(pre) + 1)
.substring(0, suc.length()).equals(suc)) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
}
continue inner1;
} suc = analysis.substring(index, index + i);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (!suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
continue inner1;
} else {
carry = false;
}
} else {
if (offset != 0 && index == offset) {
if (!String.format(String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(
n - offset, n).equals(
suc.substring(n - offset, n))) {
continue inner1;
}
} else {
if (!String.valueOf(Long.parseLong(pre) + 1)
.equals(suc)) {
continue inner1;
}
}
}
index += i;
if (isMax(suc)) {
i++;
carry = true;
}
pre = suc;
}
}
}
} public boolean hasLeadingZero(String test) {
return test.charAt(0) == '0';
} public boolean isMax(String test) {
return test.equals(test.replaceAll("\\d", "9"));
} public String getFstNum(int argOffset, int argDiv) {
if (argDiv == digits + 1) {
return "1" + analysis;
}
String tmpOne;
if (argOffset + argDiv > digits) {
int len = argDiv - (digits - argOffset);
String tmp = String.format(String.format("%%0%dd", len),
Long.parseLong(analysis.substring(argOffset - len,
argOffset)) + 1);
tmpOne = analysis.substring(argOffset, digits)
+ tmp.substring(tmp.length() - len, tmp.length());
} else {
tmpOne = analysis.substring(argOffset, argOffset + argDiv);
}
return tmpOne;
} public long calIndex(int argOffset, int argDiv) {
String tmpTwo = getFstNum(argOffset, argDiv);
long total = 0;
long base = 0;
for (int i = 1; i < tmpTwo.length(); i++) {
base += Math.pow(10, i - 1);
total += 9 * i * base;
}
total += tmpTwo.length()
* (Long.parseLong(tmpTwo) - Math.pow(10, tmpTwo.length() - 1) + 1);
total -= (argOffset + 1);
if (argDiv == digits + 1) {
total++;
}
return total;
} public void Print() {
analyse();
System.out.println("the input String: " + analysis);
System.out.println("the first extracted number is "
+ getFstNum(rstOffset, rstDiv) + "  rstOffset(在原串中出现的位置）: "
+ rstOffset + "   rstDiv（位数）：" + rstDiv);
System.out.println("the position of first appearance is "
+ (rstIndex + 1));
} public static void main(String[] args) {
// 在构造函数中输入要求位置的字符串
Headache tm = new Headache("011");
tm.Print(); }
}
 

Answer 19

刚才看了一下，原来已经有大大想出这个了，还有大大提出0的问题，做了一下修改
import java.util.Scanner;
public class A 
{ 
public static void main(String args[]) 
{ Scanner scan = new Scanner(System.in); 
String s=scan.nextLine(); 
if(s.charAt(0)=='0')
s="1"+s;
int a=Integer.parseInt(s); 
String t=""; 
for(int i=1;i <=a;i++) 
t+=i; 
System.out.println(t.indexOf(s.substring(1)));}} 
至于数的大小，位数够不够，应该不是重点

Answer 20

这几分好难赚啊，再发修正版
package quiz;import java.io.*;public class Headache {
private String analysis;
private int digits;
private int rstOffset, rstDiv;
private long rstIndex = Long.MAX_VALUE; Headache(String src) {
analysis = src;
digits = src.length();
} public void analyse() {
boolean find = false;
if (Long.parseLong(analysis) == 0) {
rstOffset = digits;
rstDiv = digits + 1;
rstIndex = calIndex(digits, digits + 1);
}
for (int n = 1; n <= digits; n++) {
// 对同一个n的不同offset匹配结果须比较大小
if (find) {
return;
}
inner1: for (int offset = 0; offset < n; offset++) {
int i = n; // 当前最高位数
int index = 0; // 当前索引
boolean carry = false; // 是否产生进位
String pre;
String suc;
if (offset != 0) {
pre = analysis.substring(0, offset);
index += offset;
} else {
pre = analysis.substring(0, i);
index += i;
}
if (hasLeadingZero(pre) && offset == 0) {
continue inner1;
}
if (isMax(pre)) {
i++;
carry = true;
}
while (true) {
if (index + i >= digits) {
if (offset == 0 && n == digits) {
if (!hasLeadingZero(analysis)) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
continue inner1;
}
if (index == digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
continue inner1;
}
suc = analysis.substring(index, digits);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
} else {
if (offset != 0 && index == offset) {
if (suc.length() - (digits - n) < 0
|| n == digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
} else if (String.format(
String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(
suc.length() - (digits - n),
suc.length()).equals(
suc.substring(suc.length()
- (digits - n), suc.length()))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
} }
continue inner1;
}
if (String.valueOf(Long.parseLong(pre) + 1)
.substring(0, suc.length()).equals(suc)) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
}
continue inner1;
} suc = analysis.substring(index, index + i);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (!suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
continue inner1;
} else {
carry = false;
}
} else {
if (offset != 0 && index == offset) {
if (!String.format(String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(
n - offset, n).equals(
suc.substring(n - offset, n))) {
continue inner1;
}
} else {
if (!String.valueOf(Long.parseLong(pre) + 1)
.equals(suc)) {
continue inner1;
}
}
}
index += i;
if (isMax(suc)) {
i++;
carry = true;
}
pre = suc;
}
}
}
} public boolean hasLeadingZero(String test) {
return test.charAt(0) == '0';
} public boolean isMax(String test) {
return test.equals(test.replaceAll("\\d", "9"));
} public String getFstNum(int argOffset, int argDiv) {
if (argDiv == digits + 1) {
return "1" + analysis;
}
String tmpOne;
if (argOffset + argDiv > digits) {
int len = argDiv - (digits - argOffset);
String tmp = String.format(String.format("%%0%dd", len),
Long.parseLong(analysis.substring(argOffset - len,
argOffset)) + 1);
tmpOne = analysis.substring(argOffset, digits)
+ tmp.substring(tmp.length() - len, tmp.length());
} else {
tmpOne = analysis.substring(argOffset, argOffset + argDiv);
}
return tmpOne;
} public long calIndex(int argOffset, int argDiv) {
String tmpTwo = getFstNum(argOffset, argDiv);
long total = 0;
long base = 0;
for (int i = 1; i < tmpTwo.length(); i++) {
base += Math.pow(10, i - 1);
total += 9 * i * base;
}
total += tmpTwo.length()
* (Long.parseLong(tmpTwo) - Math.pow(10, tmpTwo.length() - 1));
total -= argOffset;
if (argDiv == digits + 1) {
total++;
}
return total;
} public void Print() {
analyse();
System.out.println("the input String: " + analysis);
System.out.println("the first extracted number is "
+ getFstNum(rstOffset, rstDiv) + "  rstOffset(在原串中出现的位置）: "
+ rstOffset + "   rstDiv（位数）：" + rstDiv);
System.out.println("the position of first appearance is "
+ (rstIndex + 1));
} public static void main(String[] args) throws IOException {
// 空行或 Ctrl - Z 结束程序
BufferedReader stdin = new BufferedReader(new InputStreamReader(
System.in));
String s;
while ((s = stdin.readLine()) != null && s.length() != 0) {
Headache tm = new Headache(s);
tm.Print();
}
}
}

Answer 21

全零的时候做了下调整，最终版，哈哈，我真够闲的package quiz;import java.io.*;public class Headache {
private String analysis;
private int digits;
private int rstOffset, rstDiv;
private long rstIndex = Long.MAX_VALUE; Headache(String src) {
analysis = src;
digits = src.length();
} public void analyse() {
boolean find = false;
if (Long.parseLong(analysis) == 0) {
rstOffset = -1;
rstDiv = digits + 1;
rstIndex = calIndex(-1, digits + 1);
}
for (int n = 1; n <= digits; n++) {
// 对同一个n的不同offset匹配结果须比较大小
if (find) {
return;
}
inner1: for (int offset = 0; offset < n; offset++) {
int i = n; // 当前最高位数
int index = 0; // 当前索引
boolean carry = false; // 是否产生进位
String pre;
String suc;
if (offset != 0) {
pre = analysis.substring(0, offset);
index += offset;
} else {
pre = analysis.substring(0, i);
index += i;
}
if (hasLeadingZero(pre) && offset == 0) {
continue inner1;
}
if (isMax(pre)) {
i++;
carry = true;
}
while (true) {
if (index + i >= digits) {
if (offset == 0 && n == digits) {
if (!hasLeadingZero(analysis)) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
continue inner1;
}
if (index == digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
continue inner1;
}
suc = analysis.substring(index, digits);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
} else {
if (offset != 0 && index == offset) {
if (suc.length() - (digits - n) < 0
|| n == digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
} else if (String.format(
String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(
suc.length() - (digits - n),
suc.length()).equals(
suc.substring(suc.length()
- (digits - n), suc.length()))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
} }
continue inner1;
}
if (String.valueOf(Long.parseLong(pre) + 1)
.substring(0, suc.length()).equals(suc)) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
}
continue inner1;
} suc = analysis.substring(index, index + i);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (!suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
continue inner1;
} else {
carry = false;
}
} else {
if (offset != 0 && index == offset) {
if (!String.format(String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(
n - offset, n).equals(
suc.substring(n - offset, n))) {
continue inner1;
}
} else {
if (!String.valueOf(Long.parseLong(pre) + 1)
.equals(suc)) {
continue inner1;
}
}
}
index += i;
if (isMax(suc)) {
i++;
carry = true;
}
pre = suc;
}
}
}
} public boolean hasLeadingZero(String test) {
return test.charAt(0) == '0';
} public boolean isMax(String test) {
return test.equals(test.replaceAll("\\d", "9"));
} public String getFstNum(int argOffset, int argDiv) {
if (argDiv == digits + 1) {
return "1" + analysis;
}
String tmpOne;
if (argOffset + argDiv > digits) {
int len = argDiv - (digits - argOffset);
String tmp = String.format(String.format("%%0%dd", len),
Long.parseLong(analysis.substring(argOffset - len,
argOffset)) + 1);
tmpOne = analysis.substring(argOffset, digits)
+ tmp.substring(tmp.length() - len, tmp.length());
} else {
tmpOne = analysis.substring(argOffset, argOffset + argDiv);
}
return tmpOne;
} public long calIndex(int argOffset, int argDiv) {
String tmpTwo = getFstNum(argOffset, argDiv);
long total = 0;
long base = 0;
for (int i = 1; i < tmpTwo.length(); i++) {
base += Math.pow(10, i - 1);
total += 9 * i * base;
}
total += tmpTwo.length()
* (Long.parseLong(tmpTwo) - Math.pow(10, tmpTwo.length() - 1));
total -= argOffset;
return total;
} public void Print() {
analyse();
System.out.println("the input String: " + analysis);
System.out.println("the first extracted number is "
+ getFstNum(rstOffset, rstDiv) + "  rstOffset(在输入串中出现的位置）: "
+ rstOffset + "   rstDiv（位数）：" + rstDiv);
System.out.println("the position of first appearance is "
+ (rstIndex + 1));
} public static void main(String[] args) throws IOException {
// 空行或 Ctrl - Z 结束程序
BufferedReader stdin = new BufferedReader(new InputStreamReader(
System.in));
String s;
while ((s = stdin.readLine()) != null && s.length() != 0) {
Headache tm = new Headache(s);
tm.Print();
}
}
}

Answer 22

虽然还没具体看
但是觉得不可思议
麻烦你自己测试一下这个串s1=“999888777666555444333222111”
如果能测试出来的话再测试一下s2=s1+s1
还行的话测试一下s3=s2+s2

Answer 23

这个问题确实疏忽了，这们兄弟真仔细，这个问题只有在第一位为9，而后面刚好满足这样一个递增模式的时候才出现，稍等，马上DEBUG

Answer 24

直接复制到Eclipse里
一大片错误，麻烦好好写写

Answer 25

多加了一个条件，ok，其实思路就是逐步试探，想想如果输入串能匹配一个n位数开始的递增序列，那就不用考虑n + 1位了，所以从一位数开始试探，一位数不行，再两位数，对每个n> 1，还要进行n -1 趟匹配，因为有的情况是从中间截断的，如果在n = i 时找到一个匹配，则记下，完成n = i 时剩下的匹配，取最小值即为解，最坏的情况是输入串为全零，此时只在全零串前加1即为第一个匹配数，再求索引，如不为全零串，最坏的情况即为n 等于输入串长时，其实这时要是先根据每个初始值构造模式串，代码应该简洁很多，也少很多判断，可惜一开始想的是追求效率和难度，出了很几个BUG，想想不值啊，动态匹配效率应该也没提高多少 
package quiz;import java.io.*;public class Headache {
private String analysis;
private int digits;
private int rstOffset, rstDiv;
private long rstIndex = Long.MAX_VALUE; Headache(String src) {
analysis = src;
digits = src.length();
} public void analyse() {
boolean find = false;
if (Long.parseLong(analysis) == 0) {
rstOffset = -1;
rstDiv = digits + 1;
rstIndex = calIndex(-1, digits + 1);
}
for (int n = 1; n <= digits; n++) {
// 对同一个n的不同offset匹配结果须比较大小
if (find) {
return;
}
inner1: for (int offset = 0; offset < n; offset++) {
int i = n; // 当前最高位数
int index = 0; // 当前索引
boolean carry = false; // 是否产生进位
String pre;
String suc;
if (offset != 0) {
pre = analysis.substring(0, offset);
index += offset;
} else {
pre = analysis.substring(0, i);
index += i;
}
if (hasLeadingZero(pre) && offset == 0) {
continue inner1;
}
if (isMax(pre) && offset == 0) {
i++;
carry = true;
}
while (true) {
if (index + i >= digits) {
if (offset == 0 && n == digits) {
if (!hasLeadingZero(analysis)) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
continue inner1;
}
if (index == digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
continue inner1;
}
suc = analysis.substring(index, digits);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
} else {
if (offset != 0 && index == offset) {
if (suc.length() - (digits - n) < 0
|| n == digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
} else if (String.format(
String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(
suc.length() - (digits - n),
suc.length()).equals(
suc.substring(suc.length()
- (digits - n), suc.length()))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
} }
continue inner1;
}
if (String.valueOf(Long.parseLong(pre) + 1)
.substring(0, suc.length()).equals(suc)) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
}
continue inner1;
} suc = analysis.substring(index, index + i);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (!suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
continue inner1;
} else {
carry = false;
}
} else {
if (offset != 0 && index == offset) {
if (!String.format(String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(
n - offset, n).equals(
suc.substring(n - offset, n))) {
continue inner1;
}
} else {
if (!String.valueOf(Long.parseLong(pre) + 1)
.equals(suc)) {
continue inner1;
}
}
}
index += i;
if (isMax(suc)) {
i++;
carry = true;
}
pre = suc;
}
}
}
} public boolean hasLeadingZero(String test) {
return test.charAt(0) == '0';
} public boolean isMax(String test) {
return test.equals(test.replaceAll("\\d", "9"));
} public String getFstNum(int argOffset, int argDiv) {
if (argDiv == digits + 1) {
return "1" + analysis;
}
String tmpOne;
if (argOffset + argDiv > digits) {
int len = argDiv - (digits - argOffset);
String tmp = String.format(String.format("%%0%dd", len),
Long.parseLong(analysis.substring(argOffset - len,
argOffset)) + 1);
tmpOne = analysis.substring(argOffset, digits)
+ tmp.substring(tmp.length() - len, tmp.length());
} else {
tmpOne = analysis.substring(argOffset, argOffset + argDiv);
}
return tmpOne;
} public long calIndex(int argOffset, int argDiv) {
String tmpTwo = getFstNum(argOffset, argDiv);
long total = 0;
long base = 0;
for (int i = 1; i < tmpTwo.length(); i++) {
base += Math.pow(10, i - 1);
total += 9 * i * base;
}
total += tmpTwo.length()
* (Long.parseLong(tmpTwo) - Math.pow(10, tmpTwo.length() - 1));
total -= argOffset;
return total;
} public void Print() {
analyse();
System.out.println("the input String: " + analysis);
System.out.println("the first extracted number is "
+ getFstNum(rstOffset, rstDiv) + "  rstOffset(在输入串中出现的位置）: "
+ rstOffset + "   rstDiv（位数）：" + rstDiv);
System.out.println("the position of first appearance is "
+ (rstIndex + 1));
} public static void main(String[] args) throws IOException {
// 空行或 Ctrl - Z 结束程序
BufferedReader stdin = new BufferedReader(new InputStreamReader(
System.in));
String s;
while ((s = stdin.readLine()) != null && s.length() != 0) {
Headache tm = new Headache(s);
tm.Print();
}
}
}

Answer 26

首先赞一个pioneer604
我先想到的方法是，
1.试图构造String src=“1234567891011...101”先把最大设置到101
2.拿到待查找的输入串如String s =“100”
3.src.indexof(s)就是结果先不考虑效率和不完全性，我的程序结果应该是正确的吧，（如果输入的“999999999”则返回-1，不存在）
然后我试图加大上限等到“123456...10万”到10万的时候，计算机已经处理不过来了

Answer 27

package gqz.test;import java.io.*;public class Head {

public static String createString(){
String s="";
String s1;
for(int i = 1;i < 101;i++){
s1=String.valueOf(i);
s = s+s1;
}
return s;
}
public static void main(String[] args) {
BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
String sx;
String src = createString();
System.out.println("ok,get String src");
System.out.println(src);
System.out.println("字符串长度"+src.length());

try {
while((sx = stdin.readLine()) != null && sx.length() != 0){ System.out.println("the input String: " + sx);

System.out.println("the position of first appearance is:"+src.indexOf(sx));
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

Answer 28

我已经把你的程序贴到Eclipse里，并测试“100”第一次出现的位置结果：
“the position of first appearance is 208”我用我写的测试结果：
“字符串长度192
the input String: 100
the position of first appearance is:189”很明显“100”在“98 99 100 101”的时候首次出现，你的好像还不是很正确，因为src的长度才192

Answer 29

难道我把String src = "12345678910..101"都构造出来了
再求src.length计算机能求错
src.length就是192

Answer 30

嗯，我计算索引的公式错了，汗，一开始还是对的，后来改成错的了
package quiz;import java.io.*;public class Headache {
private String analysis;
private int digits;
private int rstOffset, rstDiv;
private long rstIndex = Long.MAX_VALUE; Headache(String src) {
analysis = src;
digits = src.length();
} public void analyse() {
boolean find = false;
if (Long.parseLong(analysis) == 0) {
rstOffset = -1;
rstDiv = digits + 1;
rstIndex = calIndex(-1, digits + 1);
}
for (int n = 1; n <= digits; n++) {
// 对同一个n的不同offset匹配结果须比较大小
if (find) {
return;
}
inner1: for (int offset = 0; offset < n; offset++) {
int i = n; // 当前最高位数
int index = 0; // 当前索引
boolean carry = false; // 是否产生进位
String pre;
String suc;
if (offset != 0) {
pre = analysis.substring(0, offset);
index += offset;
} else {
pre = analysis.substring(0, i);
index += i;
}
if (hasLeadingZero(pre) && offset == 0) {
continue inner1;
}
if (isMax(pre) && offset == 0) {
i++;
carry = true;
}
while (true) {
if (index + i >= digits) {
if (offset == 0 && n == digits) {
if (!hasLeadingZero(analysis)) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
continue inner1;
}
if (index == digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
continue inner1;
}
suc = analysis.substring(index, digits);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
} else {
if (offset != 0 && index == offset) {
if (suc.length() - (digits - n) < 0
|| n == digits) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
} else if (String.format(
String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(
suc.length() - (digits - n),
suc.length()).equals(
suc.substring(suc.length()
- (digits - n), suc.length()))) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
} }
continue inner1;
}
if (String.valueOf(Long.parseLong(pre) + 1)
.substring(0, suc.length()).equals(suc)) {
if (calIndex(offset, n) < rstIndex) {
rstOffset = offset;
rstDiv = n;
rstIndex = calIndex(offset, n);
find = true;
}
}
}
continue inner1;
} suc = analysis.substring(index, index + i);
if (hasLeadingZero(suc)) {
continue inner1;
}
if (carry) {
if (!suc.equals(suc.replaceAll("\\d", "0")
.replaceFirst("\\d", "1"))) {
continue inner1;
} else {
carry = false;
}
} else {
if (offset != 0 && index == offset) {
if (!String.format(String.format("%%0%dd", n),
Long.parseLong(pre) + 1).substring(
n - offset, n).equals(
suc.substring(n - offset, n))) {
continue inner1;
}
} else {
if (!String.valueOf(Long.parseLong(pre) + 1)
.equals(suc)) {
continue inner1;
}
}
}
index += i;
if (isMax(suc)) {
i++;
carry = true;
}
pre = suc;
}
}
}
} public boolean hasLeadingZero(String test) {
return test.charAt(0) == '0';
} public boolean isMax(String test) {
return test.equals(test.replaceAll("\\d", "9"));
} public String getFstNum(int argOffset, int argDiv) {
if (argDiv == digits + 1) {
return "1" + analysis;
}
String tmpOne;
if (argOffset + argDiv > digits) {
int len = argDiv - (digits - argOffset);
String tmp = String.format(String.format("%%0%dd", len),
Long.parseLong(analysis.substring(argOffset - len,
argOffset)) + 1);
tmpOne = analysis.substring(argOffset, digits)
+ tmp.substring(tmp.length() - len, tmp.length());
} else {
tmpOne = analysis.substring(argOffset, argOffset + argDiv);
}
return tmpOne;
} public long calIndex(int argOffset, int argDiv) {
String tmpTwo = getFstNum(argOffset, argDiv);
long total = 0;
for (int i = 1; i < tmpTwo.length(); i++) {
total += 9 * i * Math.pow(10, i - 1);
}
total += tmpTwo.length()
* (Long.parseLong(tmpTwo) - Math.pow(10, tmpTwo.length() - 1));
total -= argOffset;
return total;
} public void Print() {
analyse();
System.out.println("the input String: " + analysis);
System.out.println("the first extracted number is "
+ getFstNum(rstOffset, rstDiv) + "  rstOffset(在输入串中出现的位置）: "
+ rstOffset + "   rstDiv（位数）：" + rstDiv);
System.out.println("the position of first appearance is "
+ (rstIndex + 1));
} public static void main(String[] args) throws IOException {
// 空行或 Ctrl - Z 结束程序
BufferedReader stdin = new BufferedReader(new InputStreamReader(
System.in));
String s;
while ((s = stdin.readLine()) != null && s.length() != 0) {
Headache tm = new Headache(s);
tm.Print();
}
}
}

Answer 31

哥们，各位一起试试，这是我编过的BUG最多的小程序了，惭愧

Answer 32

直接
S.indexOf(S1)
不行嗎？

Answer 33

package com.test;public class FindNumber { /**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
int num=1253;
int length=(num+"").length();
int possition=0;
////规律
/*if (length==1) {
possition=num;
}
if (length==2) {
possition=10+(num-10)*2;
}
if (length==3) {
possition=(10-0)*1+(100-10)*2+(num-100)*3;
}
if (length==4) {
possition=(10-0)*1+(100-10)*2+(1000-100)*3+(num-1000)*4;
}
System.out.println(possition);
possition=0;*/
for (int i = 1; i <length; i++) {
possition+=(power(i)-power(i-1))*i;
}
System.out.println(possition);
possition=possition+(num-power(length-1))*length;
System.out.println(possition);

}
public static int power(int i){
if (i==0) {
return i;
}
int b=1;
for (int j = 0; j < i; j++) {
b=b*10;
}
return b;
}}

Answer 34

这题用的代码不用很长，
微软大饼（69楼）的代码不错，代码精炼，pioneer604大哥代码太长了，可以算出结果但是麻烦了。

Answer 35

//解析这个数是单独的还是由多个数组成的。如s="1516",是由15和16组成，出现在1516的前面，那么就应该算15的位置，而不是1516的位置
public static String getNumber(String s)
{
int len=s.length()/2;
for(int i=1;i<=len;i++)
{
String fs=s.substring(0,i);
long l=Long.parseLong(fs);

while(true)
{
l++;
fs=fs+String.valueOf(l);
if(fs.length()>=s.length())
{
break;
}
}
if(fs.equals(s))return s.substring(0,i);
}
return s;
}
//长度是1的数字有9个，那么长度是2的就是99-9=90,长度是3的就是999-99=900，那么长度为n就是9乘以10的n-1次方
public static long getPosition(String n)
{
long len=n.length();//数的长度
long l=Long.parseLong(n);
long c=0;
long l1=len*l;
for(int i=0;i<len;i++)
{
c+=9*(long)Math.pow(10,i)*(len-(i+1));
}
long l2=l1-c;
l2=l2-len;//里面包括了这个数的长度，所以要减去

return l2;

}

public static void main(String[] args) 
{
System.out.print(getPosition(getNumber("1617")));
}

Answer 36

我觉得还有点小问题：
1.要求任意长度，所以不能用 int / long 而要用 BigInteger.
2.我们可以首先分析要查找的数字本身是否多个数拼在一起，因为拼在一起的数是后一个比并一个+1,很容易知道是不是，首先推测它可能是几种情况，然后再试，因为 s1 比起 S 来说很短，分析更省时间，得到几个可能的情况后再查找。没注释看不懂程序啊，不知道是不是这么做的。我测试了一下这个程序觉得好像是有错误的，下面这两个输入是否存在，它的结果位置应该只差3，实际上差了很21：
99100101
the input String: 99100101
the first extracted number is 99  rstOffset(在输入串中出现的位置）: 0   rstDiv（位数）：2
the position of first appearance is 188
00101102
the input String: 00101102
the first extracted number is 101  rstOffset(在输入串中出现的位置）: 2   rstDiv（位数）：3
the position of first appearance is 209

Answer 37

大家都来测测吧，看看有没有bug!