คุณกำลังพัฒนารหัสบางส่วนเพื่อสร้างหมายเลข 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แทนที่ด้วย666xxxxx66700000

JavaScript (อัปเดตเพื่อทำงานกับกรณีทดสอบทั้งหมด)

ความจริงที่รู้จักกันน้อยคือมีสี่ตัวจริง6แต่หนึ่งในนั้นถูกทรยศคนอื่น ๆ และ polymorphed เป็นรูปแบบรหัสเพื่อกำจัดพวกเขาจากตัวเลขโลกของตัวเลข นี่คือคนทรยศหก:

    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);

ตอนนี้ขอเอาสิ่งที่ไร้ประโยชน์เหมือน'' + stringและ'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

ไซต์นี้มีคำตอบของ 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 *)

_{ฉันต้องการได้รับคำพูดที่ทรงพลังมากขึ้นจาก The Exorcistเข้ามาในเรื่องนี้ คุณสามารถอ่านหน้า IMDB ได้}

Perl

คุณบอกว่าเราจะต้องไม่เพิ่มขึ้นในวง ฉันไม่ได้ใช้ตัวดำเนินการทางคณิตศาสตร์เลย! นี่คือวิธีการทดแทน regex บริสุทธิ์ (ไม่รับประกันว่าปลอดภัยสำหรับสติของคุณ)

#!/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เป็นศูนย์ การเปลี่ยนตัวผู้เล่นสุดท้ายจะเปิดที่เหลือเป็น666667

โบนัสจะทำงานกับจำนวนเต็มหลายตัวในอินพุตตราบเท่าที่พวกมันถูกคั่นด้วยอักขระที่ไม่ใช่ตัวเลข

LiveScript

นี่คือการดัดกฎ คุณเห็นแล้วคุณบอกว่าฉันจะต้องไม่ใช้ลูปที่เพิ่มเข้าไปจนกว่าจะพบผลลัพธ์ที่ถูกต้อง ดังนั้นฉันจึงลบลบหนึ่งแทน!

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

รุ่น golfed ใน53 48 45 ไบต์เพื่อความสนุกสนาน:

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

ขอบคุณuser1737909 ที่ช่วยตีกอล์ฟให้ไกลขึ้น

การทดสอบ

ต้องการNode.jsพร้อมLiveScriptโมดูล npm หรือไลบรารี assert ที่เข้ากันได้

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 (ยกเว้นการลบ cheaty -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

PowerShell

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

J

ในที่สุดการใช้งานที่ดีสำหรับE.!

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

ในสาระสำคัญเราจะพบตำแหน่งแรกที่อาร์กิวเมนต์มีเต็ม666และเราแทนที่สตริงย่อยนั้นและทุกอย่างหลังจากนั้น66700000...จนถึงสิ้นสุด

อธิบายรายละเอียด:

• ":@>: - เพิ่มขึ้นทีละหนึ่งแล้วแปลงเป็นสตริง
• '666'&E. - สร้างเวกเตอร์ของบูลีนจริงในแต่ละที่ที่ '666' เริ่มขึ้นในสตริง
• i.1: - ค้นหาดัชนีของจริงแรกในเวกเตอร์, มิฉะนั้นคืนความยาวของเวกเตอร์
• #@[-]- ความยาวของสตริง (ซึ่งเป็นความยาวของเวกเตอร์) i.ลบผลมาจากการ
• '667'{.!.'0'~ - ใช้สตริงย่อยของ '667' ที่มีความยาวของผลลัพธ์โดยเติมด้านขวาด้วย '0' หากจำเป็น
• {.~- Take 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 #

148 137 ตัวอักษร

สามารถโกนหนวดได้สองสามตัวขอบคุณ @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'));}

Ungolfed:

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')); 
}

Fiddle: 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)

Perl

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

รหัสแบบอินไลน์ซึ่งเปลี่ยนแปลงเนื้อหาข้างใน$_อุดมการณ์มาตรฐานใน Perl สามารถใช้ร่วมกับการ-pตั้งค่าสถานะเช่นนี้:

$ perl -p % <<< 66666
66700

J

ไม่มีสตริงลูปหรือเงื่อนไข:

   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

เช่นเดียวกับโซลูชันของ cardboard_box วิธีนี้จะแยกตัวเลขออกเป็นกลุ่มตัวเลขสามหลักโดยหารด้วยกำลังสิบ จะใช้ดัชนีของการเกิดขึ้นครั้งแรกของ 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ลดรายการตัวเลขให้เหลือหนึ่ง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

ดูดี. และเพียงเพื่อความสนุกสนานรุ่น golfed

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 ด้วย 667 งาน

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จากนั้นจะเปลี่ยนเป็นค่าสุดท้ายและ6a สำหรับอักขระต่อไปนี้ทั้งหมด70

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

หรือมากกว่า verbosely:

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

แก้ไข: ทางออกที่ 2

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 ซ้ายสุดและคำนวณจำนวนการปรับจำนวนเมื่อ popping call stack อีกครั้ง

ชุด

การจัดการสตริงที่วนซ้ำง่าย

@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 จากนั้นจะแทนที่ด้วย 666 ด้วย 667 และวนไปตามความยาวของสตริงที่เพิ่มศูนย์

กรณีทดสอบทั้งหมดให้ผลลัพธ์ที่ถูกต้อง

Perl 45 ไบต์

regex เดียวที่มีแฟล็ก / 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 ++

ฉันรู้ว่านี่ไม่ใช่ code-golf แต่ (a) บางคนแนะนำว่ามันเป็นความท้าทายกอล์ฟที่ดีและ (b) นี่คือความท้าทายครั้งแรกของฉัน / คำตอบกอล์ฟฉันคิดว่ามันจะสนุกและถ้าฉันทำ นี่ฉันไม่ได้ปรากฏตัวในการแข่งขันกอล์ฟที่แท้จริงสำหรับการเป็นนักกอล์ฟที่น่ากลัว X)

โดยพื้นฐานแล้วการแทนที่ '666' ด้วย '667' จะใช้งานได้หากคุณใช้อินสแตนซ์แรกในหมายเลขแล้วเขียน 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;}

Ungolfed:

#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, ไม่มีไบต์

รุ่นที่สั้นกว่าโซลูชันล่าสุดของฉันโดยใช้การคำนวณแบบผสมและ regex

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)"