您正在开发一些代码以生成ID号。策略要求ID号不包括数字序列666。

创建一个函数（或与您的语言等效的函数），该函数带有一个正整数参数，并在该整数以十进制表示时返回不包含666的下一个整数。（60606可以，但66600可以。）

您的代码在找到符合规则的结果之前，不得使用加一的循环。

f(1) returns 2.
f(665) returns 667.
f(665999999) returns 667000000 without having looped a million times.
(Following examples added since the question was first posed.)
f(666666666) also returns 667000000.
f(66600) returns 66700.
f(456667) returns 456670.

更新：
如果输入中有多个666，则用667代替666无效。

Python，无字符串操作

def f(n):
    n += 1
    p = 1
    m = n
    while m:
        if m % 1000 == 666:
            n += p - n % p
        p *= 10
        m /= 10
    return n

通过找到的10，权力作品p，其中666出现，以及添加p - n % p到n它取代666xxxxx有66700000。

JavaScript（已更新为可用于所有测试用例）

鲜为人知的事实是实际上有四个6s，但是其中一个被出卖，另一个被多态化为代码形式以从数字的世界数字中消除它们。这就是叛徒六：

    x=prompt(''+
  'Enter number');
 alert(      ( (~x[
'ind'+
'exOf']('666')))?(x 
.replace(/666(.*)$/,
function    (mat,g){
return       '667'+g
 ['re'+      'place'
 ](/./g,0)})):((+x+
    1+'').replace(
     666,667)));

这是一个解释。首先，美化代码并删除诸如''+'string'和这样的无用的东西((code))：

x = prompt('Enter number');
alert(
    ~x['indexOf']('666')
        ?
    x.replace(/666(.*)$/, function(mat,g) {
        return '667' + g['replace'](/./g,0)
    })
        :
    (+x+1+'').replace(666, 667)
);

将怪异的符号（如~indexOf和['replace']）转换为更常见的符号：

x = prompt('Enter number');
alert(
    x.indexOf('666') > -1
        ?
    x.replace(/666(.*)$/, function(mat, g) {
        return '667' + g.replace(/./g, 0)
    })
        :
    ((parseInt(x) + 1) + '').replace(666, 667)
);

现在，只需了解该算法是这样的：

• 如果输入中已经有666，

  • 用667代替。
  • 将其后的每个数字替换为0。

• 其他，

  • 在数字上加一个。
  • 注意：现在我们保证在字符串的末尾没有666，没有666，或者在其他地方已经有零的666到末尾（做“手动”加法时考虑“携带”）。
  • 如果有666，请换成667。

旧版本（不适用于666666666）：

    s='Enter number';x
  =prompt(           ''+
 s);x=+x+
(-~![]);
x=(''+x).replace('666',
666+([][         +[]]+[])
[+[]]['l         ength'[
 'repla'+       'ce'](
  / /g,'')]);alert(x)

要了解这一点，让我们首先对其进行美化：

s = 'Enter number';
x = prompt('' + s);
x = +x + (-~![]);
x = ('' + x).replace('666',666+([][+[]]+[])[+[]]['l         ength'['repla'+'ce'](/ /g,'')]);
alert(x);

现在，让我们删除诸如'' + stringand之类的无用的东西'str' + 'ing'，删除不必要的s变量，并将怪异性更改-~![]为1：

x = prompt('Enter number');
x = +x + 1;
x = ('' + x).replace('666', 666+"undefined"[0]['l         ength'['replace'](/ /g,'')]);
alert(x);

'l ength'['replace'](/ /g,'')很简单"length"：

x = prompt('Enter number');
x = +x + 1;
x = ('' + x).replace('666', 666+"undefined"[0].length);
alert(x);

和"undefined"[0]是"u"，并且"u".length是1：

x = prompt('Enter number');
x = +x + 1;
x = ('' + x).replace('666', 666 + 1);
alert(x);

现在我们完成了！现在应该很容易理解了。

苹果脚本

该网站没有足够的Applescript答案。让我们驱散一些恶魔！

property demon : "666"
property trinity : 1

on exorcise above possessed
    set possessed to possessed as text
    set relic to AppleScript's text item delimiters
    set AppleScript's text item delimiters to demon
    set deliverance to possessed's first text item
    if possessed is deliverance then
        set deliverance to possessed + trinity
    else
        set AppleScript's text item delimiters to trinity
        set compellingPower to ¬
            (count of possessed's characters) - ¬
            (count of deliverance's characters) - ¬
            (count of demon's characters)
        set deliverance to ¬
            deliverance & ¬
            demon + trinity & ¬
            last text item of (((10 ^ compellingPower) as integer) as text)
    end if
    set AppleScript's text item delimiters to relic
    return deliverance
end exorcise

log (exorcise above 666)
log (exorcise above 66666666)
log (exorcise above 1266612)
log (exorcise above 1212)

日志输出：

（* 667 *）
（* 66700000 *）
（* 1266700 *）
（* 1213 *）

_{我想从《驱魔人》中得到一些更有力的报价，但是那肯定会让NSFW贴出来。您可以改为阅读IMDB页面。}

佩尔

您说过我们不能循环增加。我根本不使用任何数学运算符！这是一种纯正则表达式替换方法（不保证对您的理智是安全的）。

#!/usr/bin/perl

$_ = <>;

s/$/ ~0123456789/;
s/(?=\d)(?:([0-8])(?=.*\1(\d)\d*$)|(?=.*(1)))(?:(9+)(?=.*(~))|)(?!\d)/$2$3$4$5/g;
s/9(?=9*~)(?=.*(0))|~| ~0123456789$/$1/g;
s/(?!^)\G\d|(666)\d/${1}0/g;
s/666/667/g;

print($_)

前三个替换将数字加一。我曾经自己解决过这个问题，但是它包含一个替换，该替换必须循环进行，直到不再进行替换为止，因此我改用Andrew Cheong的方法。

第四次替换将a后面的所有数字666变为零。最后的替换将剩余的666变成667。

另外，只要输入之间用非数字字符分隔，它就可以使用多个整数。

实时脚本

这违反了规则。您看，您说过在找到正确结果之前，请勿使用添加一个的循环。因此我改为减去减一！

nextId = (id) ->
  while (id + 1).toString!indexOf('666') != -1
    id -= -1
  id + 1

高尔夫版本的53 48 45字节，很有趣：

n=(i)->(while~(i+1+'')indexOf(\666)=>i-=-1);i+1

感谢user1737909帮助进一步打高尔夫球。

测验

需要的Node.js与LiveScriptNPM模块或兼容的断言库。

assert = require \assert

assert.equal nextId(1), 2
assert.equal nextId(665), 667
assert.equal nextId(665999999), 667000000
assert.equal nextId(66600), 66700
assert.equal nextId(456667), 456670

红宝石

这是（我认为）适用于666666666的第一个答案。（除了作弊的减法-1答案。；））

x = gets.chomp.to_i + 1
p (x..x.to_s.gsub('666', '667').to_i).select{|i| !(i.to_s.index '666') }.min

我现在很着急。稍后将添加说明。

更新：更有效的版本（我相信几乎是恒定的运行时）：

x = gets.chomp
if x.index '666'
    # replace ex. 6661234 with 6670000
    puts x.sub(/666(.*)/){ "667#{"0" * $1.length}" }
else
    # old algorithm (guaranteed to result in
    # 0 or 1 666s now)
    puts (x.to_i+1).to_s.sub(/666/, "667")
end

电源外壳

($args[0]+1 -replace '(?<=666.*).','0') -replace '666', '667'

Ĵ

最后，对有用E.！

(({.~ , '667' {.!.'0'~ #@[ - ]) '666'&E. i. 1:) @ ": @ >:

本质上，我们找到参数具有full的第一个位置666，然后替换该子字符串以及之后的所有内容，66700000...直到结尾。

详细说明：

• ":@>: -加一并转换为字符串。
• '666'&E. -设置布尔向量，在字符串中以“ 666”开头的每个位置为真。
• i.1: -找到向量中第一个true的索引，否则返回向量的长度。
• #@[-]-字符串的长度（也是向量的长度）减去的结果i.。
• '667'{.!.'0'~ -取一个带有结果长度的'667'子字符串，如有必要，在右侧填充'0'。
• {.~-取一个子字符串，其长度为的原始结果i.。
• , -将两者一起附加。

正在使用：

   f =: (({.~,'667'{.!.'0'~#@[-])'666'&E.i.1:)@":@>:
   f 1              NB. this leaves okay numbers untouched
2
   f 665999999      NB. properly handles multiple increments
667000000
   f 16266366646666 NB. only takes effect at sets of 3 sixes
16266366700000

而且由于这不是代码高尔夫，所以不必通过疯狂的优化而陷入困境。每个人都赢了！

C＃

148137个字符

通过@recursive能够删除一些字符

public static int f(int b){b++;var z=new Regex("666\\d*");var q=z.Replace(b+"","667",1);return int.Parse(q.PadRight((b+"").Length,'0'));}

取消高尔夫：

public static int f(int b)
{
    b++;
    var z = new Regex("666[\\d]*");
    var q = z.Replace(b+"", "667", 1);
    return Int32.Parse(q.PadRight((b+"").Length, '0')); 
}

小提琴：http : //dotnetfiddle.net/XB83bf

蟒蛇

def next_id(id_num):
  id_num_p1=str(id_num+1)
  pieces=id_num_p1.split('666')
  if len(pieces)==1:
    return id_num+1
  next_id_str=pieces[0]+'667'+'0'*(len(id_num_p1)-len(pieces[0])-3)
  return int(next_id_str)

佩尔

$_++;$_.=$/;s:666(.*):667 .'0'x($+[1]-$-[1]):e

内联代码可更改内部内容$_，这是perl中的一种非常标准的意识形态。可以与以下-p标志一起使用：

$ perl -p % <<< 66666
66700

Ĵ

没有字符串，循环或条件：

   next =: 3 :'<.(y+1)(+-|~)10^<:666 i:~666,1000|<.(y+1)%10^i.<.10^.>:y'

   next 1
2
   next 665
667
   next 665999999
667000000
   next 666666666
667000000
   next 66600
66700

与硬纸板解决方案类似，它通过除以10的幂将数字分成三位数的组。它使用首次出现的666的索引对数字进行适当的四舍五入。

Haskell（70个字符）

这是Haskell中的一个简单实现。

import Data.List
import Data.Char

nextid :: Integer -> Integer
nextid = foldl' ((+).(*10)) 0 . purge . map digitToInt . show . (+1)
  where purge (6:6:6:xs) = 6 : 6 : 7 : map (const 0) xs
        purge (x:xs)     = fromIntegral x : purge xs
        purge []         = []

• 首先，它使用 map digitToInt . show将可能有害的ID转换为数字列表。
• 下一个， purge匹配邪恶的模式并将其替换为良好的等效模式。
• 最后，foldl' ((+).(*10)) 0将数字列表减少为1 Integer。

让我们看看它是否有效！

ghci> nextid 1
2
ghci> nextid 665
667
ghci> nextid 665999999
667000000
ghci> nextid 666666666
667000000
ghci> nextid 66600
66700
ghci> nextid 456667
456670
ghci> nextid 6660239486660239466
6670000000000000000

看起来不错。只是为了好玩高尔夫版本。

f=read.w.show.(+1);w('6':'6':'6':t)="667"++(t>>"0");w(h:t)=h:w t;w t=t

爪哇

这样做还不够吗？

private static int nextId(int currentId) {
    String currentIdStr = String.valueOf(currentId);
    return currentIdStr.contains("666") ? Integer.parseInt(currentIdStr.replace("666", "667")) : ++currentId;
}

[R

将666替换为666。

f <- function(x) {
  x <- as.integer(x + 1)
  if (grepl(666, x)) {
    k <- regexpr(666, x)
    cat(substring(x, 1, k + 1), 7, rep(0, nchar(x) - k - 2), sep = "")
  }
  else cat(x)
}

结果

> f(1)
2
> f(665)
667
> f(665999999)
667000000
> f(666666666)
667000000
> f(66600)
66700
> f(126660)
126670
> f(126661)
126670
> f(666666666)
667000000

3种不同的JavaScript答案：

1. JavaScript（ECMAScript 6）

f=x=>(a=b=c=0,[c?'0':a+(a=b)+(b=i)==666?(c='7'):i for(i of ""+(x+1))].join('')*1)

将数字转换为字符串，然后遍历每个字符，直到找到666然后将其最后更改6为a 7并输出0所有后续字符。

2. JavaScript（ECMAScript 6草案）

没有字符串操作的递归函数：

g=(x,y=x+1,p=1)=>y?g(y%1e3==666?y*p+p:y>x?y:x,y/10|0,p*10):x

或更详细地说：

function g(x,y=x+1,p=1)
{
  if ( y == 0 )
    return x;
  else if ( y % 1000 == 666 )
    return g( y*p+p, Math.floor(y/10), p*10 );
  else
    return g( Math.max(y, x), Math.floor(y/10), p*10 );
}

测试：

g(5) // 6
g(65) // 66
g(665) // 667
g(66599) // 66700
g(66666) // 66700
g(6656665665) // 6656670000

3. JavaScript

使用正则表达式：

function h(x)(""+(x+1)).replace( /^(.*?)(666)(.*)$/, function(a,b,c,d)(b+667+d.replace(/./g,0)) )*1

或（相同，但使用ECMAScript 6）

h=x=>(""+(x+1)).replace(/^(.*?)(666)(.*)$/,(a,b,c,d)=>b+667+d.replace(/./g,0))*1

AWK

awk '{i=index(++$0,"666")}
      i{a=substr($0,1,i-1)
       b=substr($0,i+3)
       gsub(/./,0,b)
       $0=a"667"b}
      1
' <<_INPUT_
1
665
665999999
666666666
66600
_INPUT_

给

2
667
667000000
667000000
66700

编辑：第二个解决方案

awk -F666 -vOFS=667 '{++$0;$1=$1}
    NF-1{for(gsub(/./,0,$2);NF>2;--NF){$2=$2 0 0 0
               for(i=length($NF);i;--i)$2=$2 0}}1
' <<_INPUT_
1
665
665999999
666666666
66600
1236661
_INPUT_

产量

2
667
667000000
667000000
66700
1236670

蟒蛇：

def f(b):
    b = `b+1`
    while '666' in b: b = b.replace('666','667',1)
    return int(b)

要么：

 f=lambda b:int(`b+1`.replace('666','667'))

爪哇

public static int f(int i) {
    i++;
    i += findAdjustment(i);
    return i;
}

private static int findAdjustment(int i) {
    if (i < 666) {
        return 0;
    }
    int adjustment = findAdjustment(i / 10);
    if (adjustment != 0) {
        // Leftmost 666 found, fix adjustment by current last digit
        return adjustment * 10 - i % 10;
    } else if (i % 1000 == 666) {
        return 1; // This is leftmost 666, need to be corrected by 1
    } else {
        return 0; // no adjustment needed
    }
}

使用递归函数查找最左边的666，并计算再次弹出调用堆栈时要调整的数量。

批量

简单的迭代字符串操作。

@echo off

setLocal enableDelayedExpansion
set /a inp=%1+1
for /f usebackq %%a in (`powershell "&{'%inp%'.length-1}"`) do (
    set a len=%%a-2
    set chars=%%a
)

for /l %%b in (0, 1, %len%) do (
    if "!inp:~%%b,3!"=="666" (
        set inp=!inp:~0,%%b!667
        set /a a=%%b+3
        for /l %%c in (!a!, 1, %chars%) do set inp=!inp!0
        goto :break
    )
)

:break

echo %inp%

它从数字的前三个字符（作为字符串）开始，一直到结尾，直到找到666，然后将其替换为667，再将其替换为667，并循环到字符串的长度加零。

所有测试用例都能产生正确的结果。

perl，45个字节

带有/ e标志的单个正则表达式在这里完成所有工作：

$_=<>+1;s/666(.*)$/"667".0 x length$1/e;print

的SQL

确切地说，是SQL Server 2012 Transact-SQL。

create function dbo.GoodIntegers( @i bigint )
returns bigint
as begin
    declare @s varchar(20) = cast( @i+1 as varchar(20) ) ;
    declare @badindex int = charindex( '666', @s ) ;
    declare @rv bigint  = cast ( 
        iif( @badindex = 0 ,
            @s ,
            concat( left( @s, @badindex - 1 ), '667', replicate( '0', len( @s ) - @badindex - 2 ) )
        ) as bigint 
    ) ;
    return @rv ;
end ; -- function dbo.GoodIntegers

蟒蛇

import re
def exorcise(number):
    number = str(number+1)
    i = re.compile("^(\d*?)(666)(\d*)$")
    if re.match(i,number):
        n = re.match(i,number).groups()
        return int(n[0]+"667"+"".join(["0"*len(n[2])]))
    return int(number)

朱莉亚

function f(x::Int)
    y = string(x+1)
    n = length(y)
    z = string(^("0",n))
    ~ismatch(r"6{3}", y) ?
    int(y) :
    while ismatch(r"6{3}",y)
        m = match(r"6{3}", y)
        y = string(y[1:m.offset+1], '7', z[m.offset+3:n])
    end
    int(y)
end

REPL成绩

julia> f(1)
2

julia> f(665)
667

julia> f(665999999)
667000000

julia> f(666666666)
667000000

julia> f(66600)
66700

julia> f(456667) 
456670

C＃

我做对了吗

static int F(int n)
{
    n++;

    int a = 666;
    int b = 1;

    while (n >= b)
    {
        if (((n - a) / b) % 1000 == 0)
        {
            n += b;
        }

        a *= 10;
        b *= 10;
    }

    return n;
}

vba

Function f(num As Long) As Long
Dim SixPos As Long
Dim s As String
s = CStr(num)
SixPos = InStr(s, "666")
If SixPos = 0 Then
    s = CStr(num + 1)
    SixPos = InStr(s, "666")
End If
If SixPos Then
    Mid(s, SixPos + 2, 1) = "7"
    If Len(s) > SixPos + 2 Then
        Mid(s, SixPos + 3, Len(s) - SixPos + 3) = String$(Len(s) - SixPos + 3, "0")
    End If
End If

f = CLng(s)

End Function

实际上：

Sub demo()
Debug.Print f(1) 'returns 2.
Debug.Print f(665) 'returns 667.
Debug.Print f(665999999) 'returns 667000000 without having looped a million times.
'(Following examples added since the question was first posed.)
Debug.Print f(666666666) 'also returns 667000000.
Debug.Print f(66600) 'returns 66700.
Debug.Print f(456667) 'returns 456670.
End Sub

结果：

2 
667 
667000000 
667000000 
66700 
456670 

C ++

我知道这不是代码高尔夫，但是（a）一些人认为这是一个很好的高尔夫挑战，并且（b）这是我的第一个挑战/高尔夫答案，我认为这很有趣，如果我这样做在这里，我并没有因为成为一名糟糕的高尔夫球手而出现在实际的高尔夫挑战赛中。X）

基本上，如果您是在数字中的第一个实例中用“ 667”代替“ 666”，则可以写出尾随的0。

Golfed（175 155个字符）：

#include<sstream>
int f(int x){std::stringstream s,o;s<<++x;x=0;for(char c=s.get();!s.eof();c=s.get())o<<((x+=c=='6')++==3?'7':--x>3?'0':c);o>>x;return x;}

取消高尔夫：

#include<sstream>
int f(int x){
    std::stringstream s,o;
    s<<++x;    // Increment to next int.
    x=0;       // Reusing this to count 6s
    for(char c=s.get();!s.eof();c=s.get()){    // For each digit
        if (c=='6'){
           ++x;    // Count sixes...
        }
        if(x==3) {  // Devil's number!
            c='7'; // Output 7 here.
            ++x;   // Increment once more.
        } else if (x > 3) {
            c='0';    // Already replaced 666 with 667, so write out 0s
        }
        o<<c;   // Append digit
    }
    o>>x; // Get int
    return x;
}

红宝石

n=(gets.chomp.to_i+1).to_s
i=n.index("666")
if i!=nil
    n=n[0..i+1]+"7"+"0"*(n.length-i-3)
end
puts n

perl，36个子元素，无字节

比我的上一个解决方案短的版本，使用了算术运算和正则表达式运算。

sub{($_[0]+1)=~s/666(.*)/667$1/r-$1}

C

#include <stdlib.h>
#include <stdio.h>

int next(int a)
{
    for(int b=a+1,c=0,d=0; b>665 ;b/=10, c++)
        if(b%1000==666) {d=c; a=b;}

    a++;
    while(d --> 0) a*=10;

    return a;
}

void main(int a, char *v[])
{
    int c = a>1?atoi(v[1]):0;

    printf("%d\n",next(c));
}

好的-没有边界检查，空格太多，但这不是高尔夫。在“ while（d-> 0）”中格式化也很有趣。