Question

我希望获得一个字符串的长度，包括表示其自身长度的字符串的一部分，而不使用填充或使用结构或类似强制固定长度的类似物。

所以例如我希望能够将此字符串作为输入：

- (void)viewDidAppear:(BOOL)animated{
    [super viewDidAppear:YES];

    ConnectionService *connectionService = [[ConnectionService alloc]init];
    [connectionService refreshProducts:^(NSDictionary *featuredProducts) {
       self.featuredProducts = featuredProducts;
       NSLog(@"featuredProducts: %@", self.featuredProducts);
       NSArray *keys = [[NSArray alloc]initWithArray:[self.featuredProducts allKeys]];
       NSLog(@"All featured product keys: %@", keys);

       //Reload data here...
}];

然后回复：

"A string|"

Answer 1

基于OP容忍这种方法（以及为最终的python答案提供实现技术），这里是Java的解决方案。

 final String s = "A String|";
 int n = s.length(); // `length()` returns the length of the string.
 String t; // the result
 do {
      t = s + n; // append the stringified n to the original string
      if (n == t.length()){
          return t; // string length no longer changing; we're good.
      }                       
      n = t.length(); // n must hold the total length
 } while (true); // round again

当然，问题是在附加n时，字符串长度会发生变化。但幸运的是，只有的长度增加或保持不变。所以它会很快收敛：由于n长度的对数性质。在这种特殊情况下，n的尝试值为9,10和11.这是一个有害的案例。

Answer 2

一个简单的解决方案是：

def addlength(string):
    n1=len(string)
    n2=len(str(n1))+n1
    n2 += len(str(n2))-len(str(n1)) # a carry can arise
    return string+str(n2)

由于可能的进位会使长度增加至多一个单位。

示例：

In [2]: addlength('a'*8)
Out[2]: 'aaaaaaaa9'

In [3]: addlength('a'*9)
Out[3]: 'aaaaaaaaa11'

In [4]: addlength('a'*99)
Out[4]: 'aaaaa...aaa102'

In [5]: addlength('a'*999)
Out[5]: 'aaaa...aaa1003'

Answer 3

以下是Bathsheba的一个简单的Python端口答案：

def str_len(s):
    n = len(s)
    t = ''
    while True:
        t = s + str(n)
        if n == len(t):
            return t
        n = len(t)

这比我想要尝试的任何东西都更加聪明和简单！

假设您有s = 'abcdefgh|，在第一次通过时t = 'abcdefgh|9 自从n != len(t)（现在为10）后，它再次通过：t = 'abcdefgh|' + str(n)和str(n)='10'，因此您abcdefgh|10仍然不太正确！现在n=len(t)终于n=11了，你就明白了。非常聪明的解决方案！

Answer 4

这是一个棘手的问题，但我认为我已经弄清楚了。

在Python 2.7中匆忙完成，请完全测试 - 这应该处理最多998个字符的字符串：

import sys

orig = sys.argv[1]

origLen = len(orig)

if (origLen >= 98):
    extra = str(origLen + 3)
elif (origLen >= 8):
    extra = str(origLen + 2)
else:
    extra = str(origLen + 1)

final = orig + extra

print final

非常简短的测试结果

C：\ Users \ PH \ Desktop＆gt; python test.py“tiny |”

<强>微小| 6

C：\ Users \ PH \ Desktop＆gt; python test.py“myString |”

<强>的myString | 11

C：\ Users \ PH \ Desktop＆gt; python test.py“myStringWith98Characters ................................ ......................................... |“

<强> myStringWith98Characters ........................................... .............................. | 101

Answer 5

找到字符串的长度。然后遍历数字的每个值，结果字符串可能具有的长度。在迭代时，检查要追加的位数和初始字符串长度之和是否等于结果字符串的长度。

def get_length(s):
    s = s + "|"
    result = ""
    len_s = len(s)
    i = 1
    while True:
        candidate = len_s + i
        if len(str(candidate)) == i:
            result = s + str(len_s + i)
            break
        i += 1

Answer 6

这是一个直接的等式（所以没有必要构造字符串）。如果s是字符串，则字符串的长度（包括附加长度的长度）将为：

L1 = len(s) + 1 + int(log10(len(s) + 1 + int(log10(len(s)))))

这里的想法是，当附加的长度超过10的幂时，直接计算是有问题的;也就是说，9，98，99，997，998，999，9996等等。通过，1 + int(log10(len(s)))是s长度中的位数。如果我们将其添加到len(s)，然后9->10，98->100，99->101等，但仍然是8->9，97->99等，所以我们可以根据需要完全超过10的力量。也就是说，添加它会在添加后生成一个具有正确位数的数字。然后再次执行日志以查找该数字的长度，这就是答案。

测试一下：

from math import log10

def find_length(s):
    L1 = len(s) + 1 + int(log10(len(s) + 1 + int(log10(len(s)))))
    return L1

# test, just looking at lengths around 10**n
for i in range(9):
    for j in range(30):
        L = abs(10**i - j + 10) + 1
        s = "a"*L
        x0 = find_length(s)
        new0 = s+`x0`
        if len(new0)!=x0:
            print "error", len(s), x0, log10(len(s)), log10(x0)

Answer 7

此代码给出了结果。

我使用了一些var，但最后显示了您想要的输出：

def len_s(s):
    s = s + '|'
    b = len(s)
    z = s + str(b)
    length = len(z)
    new_s = s + str(length)
    new_len = len(new_s)
    return s + str(new_len)

s = "A string"
print len_s(s)

查找包含其自身长度的字符串的长度？

7 个答案: