ID 번호를 생성하는 코드를 개발 중입니다. 정책에 따라 ID 번호에 숫자 시퀀스 666이 포함되지 않아야합니다 .

양의 정수 매개 변수를 사용하고 해당 정수가 10 진수로 표시 될 때 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이 있으면 666을 667으로 바꾸면 작동하지 않습니다.

파이썬, 문자열 조작 없음

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)의 힘을 찾는 작품 p666가 나타납니다, 그리고 추가 p - n % p로 n대체하는 666xxxxx과 66700000.

자바 스크립트 (모든 테스트 사례에서 작동하도록 업데이트 됨)

잘 알려진 사실은 실제로 4 개가 6있지만, 다른 하나는 배신 당하고 다른 하나는 숫자의 세계 숫자 에서 근절하기 위해 코드 형식으로 변형되었습니다 . 그 배신자 여섯은 다음과 같습니다.

    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으로 바꿉니다.

• 그밖에,

  • 숫자에 1을 더하십시오.
  • 참고 : 이제 문자열 끝에 666, 666 또는 끝으로 0이있는 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 답변이 없습니다. 악마를 추방하자!

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

_{나는 Exorcist 의 더 강력한 인용문을 이것에 넣고 싶었지만 , 이것이 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를 0 으로 바꿉니다 . 최종 대체는 나머지를 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 에게 감사드립니다 .

테스트

npm 모듈 또는 호환 가능한 어설 션 라이브러리가있는 Node.js 가 필요합니다 LiveScript.

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에 효과가있는 첫 번째 답변입니다. (Chainty 빼기 -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'

제이

마지막으로, 좋은 사용 E.!

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

본질적으로 인수가 full 666인 첫 번째 위치를 찾은 다음 해당 하위 문자열과 모든 부분을 66700000...끝까지 바꿉니다.

자세히 설명 :

• ":@>: -1 씩 증가시키고 문자열로 변환합니다.
• '666'&E. -부울로 구성된 벡터를 만듭니다. 문자열에서 '666'이 시작되는 각 위치에서 true입니다.
• i.1: -벡터에서 첫 번째 참의 인덱스를 찾고 그렇지 않으면 벡터의 길이를 반환합니다.
• #@[-]-문자열의 길이 (벡터의 길이이기도 함)에서 결과를 뺀 값입니다 i..
• '667'{.!.'0'~ -필요한 경우 오른쪽에 '0'을 채워서 결과 길이가 '667'인 부분 문자열을 가져옵니다.
• {.~-에서 원래 결과의 길이를 가진 부분 문자열을 가져옵니다 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

그리고 이것은 코드 골프가 아니기 때문에 미친 최적화로 지옥에 빠질 필요가 없습니다. 모두가 이긴다!

씨#

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

내용을 변경하는 인라인 코드 $_, 펄의 표준 이데올로기. 다음과 같이 -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

cardboard_box의 솔루션과 유사하게, 이것은 10의 거듭 제곱으로 나누어 숫자를 세 자리 그룹으로 분리합니다. 666의 첫 항목 색인을 사용하여 숫자를 적절히 반올림합니다.

하스켈 (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;
}

아르 자형

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마지막 문자를 찾을 때까지 각 문자를 반복하여 다음 문자 를 마지막 6으로 변경하고 모든 후속 문자에 대해 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. 자바 스크립트

정규식 사용하기 :

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을 찾을 때까지 끝까지 작동 한 다음 666을 667로 바꾸고 0을 추가하는 문자열의 길이로 반복합니다.

테스트 사례는 모두 올바른 결과를 생성합니다.

펄, 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

씨#

내가 제대로하고 있니

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) 이것이 첫 번째 도전 / 골프 답변입니다. 재미있을 것이라고 생각했습니다. 이것은 끔찍한 골퍼가되기위한 실제 골프 챌린지에 나타나지 않습니다. 엑스)

기본적으로 '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;}

언 골프 드 :

#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

펄, 36 서브, 바이트 없음

산술 및 정규 표현식을 혼합하여 사용하는 마지막 솔루션보다 짧은 버전입니다.

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

씨

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

OK-경계 검사가없고 공백이 너무 많지만 골프는 아닙니다. "while (d-> 0)"형식의 재미있는 부분도 있습니다.