Kimlik numaraları oluşturmak için bazı kodlar geliştiriyorsunuz. Politika, hiçbir ID numarasının 666 rakam dizisini içermesini gerektirmez .

Olumlu bir tamsayı parametresi alan ve o tamsayı ondalık sayıyla ifade edildiğinde 666 içermeyen bir sonraki tamsayıyı döndüren bir işlev (veya dilinizin eşdeğeri) oluşturun . (60606 iyi, 66600 değil.)

Kodunuz, kurallara uyan bir sonuç bulana kadar bir tane ekleyen bir döngü kullanmamalıdır.

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.

GÜNCELLEME:
Girişte birden fazla 666 varsa, 666'yı 667 ile değiştirmek işe yaramaz.

Python, dize manipülasyonu yok

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, yetkilerini bularak İşleri p666 görünür ve ekleme p - n % piçin nyerini hangi 666xxxxxile 66700000.

JavaScript (tüm test durumlarıyla çalışmak üzere güncellendi)

Az bilinen gerçek şu ki, aslında dört 6saniye var, ancak diğerlerine ihanet eden ve sayıların dünyadaki rakamlarından kurtulmak için kod biçiminde polimorlanan bir kişi . İşte o hain altı altı:

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

İşte bir açıklama. İlk olarak, kodu güzelleştirmek ve benzeri yararsız şeyler kaldırmak ''+'string've ((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)
);

Garip notasyonları (gibi ~indexOfve ['replace']) daha yaygın olanlara dönüştürün:

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

Ve şimdi basitçe algoritmanın böyle gittiğini anlayın:

• Girişte zaten bir 666 varsa,

  • 667 ile değiştirin.
  • Bundan sonra her rakamı 0 ile değiştirin.

• Başka,

  • numaraya bir tane ekleyin.
  • NOT: şimdi, dize sonunda 666, 666, ya da zaten sonuna kadar sıfır sıfır olan başka bir yerde 666 olacağımız garantilidir ("manuel" ekleme yaparken "taşımayı" düşünün).
  • 666 varsa, 667 ile değiştirin.

Eski sürüm (için çalışmıyor 666666666) :

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

Bunu anlamak için önce onu güzelleştirelim:

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

Şimdi gibi faydasız şeyleri kaldırmak izin '' + stringve 'str' + 'ing'gereksiz kaldırmak sdeğişken ve benzeri garabeti değiştirmek -~![]içine 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,'')basitçe "length":

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

Ve "undefined"[0]olduğu "u"ve "u".lengtholduğu 1:

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

Şimdi bitti! Şimdi anlamak oldukça kolay olmalı.

applescript

Bu sitenin yeterli Applescript cevabı yok. Bazı şeytanları kovalım!

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)

Günlük çıkışı:

(* 667 *)
(* 66700000 *)
(* 1266700 *)
(* 1213 *)

_{Exorcist'ten daha güçlü alıntılardan bazılarını bu konuya dahil etmek istedim , ama bu kesinlikle NSFW'yi ilan ederdi. Bunun yerine IMDB sayfasını okuyabilirsiniz.}

Perl

Bir döngüde artış yapmamamız gerektiğini söyledin. Hiçbir matematiksel operatör kullanmıyorum! İşte saf bir regex ikame yaklaşımı (akıl sağlığınız için güvenli olduğunu garanti etmiyoruz).

#!/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($_)

İlk üç oyuncu değişikliği sayıyı bir artırır. Bu sorunu bir kez kendi kendime çözdüm, ancak başka bir değişiklik yapılıncaya kadar döngülenmesi gereken bir oyuncu değişikliği içeriyordu, bu yüzden bunun yerine Andrew Cheong'un yaklaşımını kullandım.

Dördüncü ikame a'dan sonra gelen tüm rakamları 666sıfırlara çevirir . Son oyuncu değişikliği kalanı a'ya 666dönüştürür 667.

Bir bonus olarak bu, rakam olmayan karakterlerle ayrıldığı sürece girişteki çoklu tam sayılarla çalışacaktır.

LiveScript

Bu kuralları büküyor. Gördün mü, doğru bir sonuç bulana kadar bir tane ekleyen bir döngü kullanmamam gerektiğini söyledin . Bu yüzden eksi bir yerine çıkarmak !

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

Eğlence için 53 48 45 byte'lık golf versiyonu :

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

Kullanıcıya daha fazla golf atmaya yardımcı olduğu için teşekkür ederiz .

Testler

Npm modülü veya uyumlu bir assert kütüphanesi ile Node.js gerektirir 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

Yakut

Bu (bence) 666666666 için çalışan ilk cevap. (-1 cevabı çıkartan hile hariç.;))

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

Şimdi acelem var; açıklama daha sonra eklenecektir.

Güncelleme : çok daha verimli sürüm (neredeyse sürekli çalışma zamanı inanıyorum):

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

Güç kalkanı

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

J

Sonunda, iyi bir kullanım için E.!

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

Temelde, argümanın dolu olduğu ilk pozisyonu buluruz ve 666bu alt dizgiyi ve 66700000...sonuna kadar devam eden her şeyi değiştiririz .

Ayrıntılı olarak açıklanmıştır:

• ":@>: - Bir artırma ve dizeye dönüştürme.
• '666'&E. - '666' dizgisinde başlayan her yerde doğru olan bir boole vektörü yapın.
• i.1: - Vektördeki ilk true dizinini bulun, aksi halde vektörün uzunluğunu döndürür.
• #@[-]- Dize uzunluğu (aynı zamanda vektörün uzunluğudur) eksi sonucu i..
• '667'{.!.'0'~ - Gerekirse sağda '0' ile doldurduğunuzda, sonuç olarak bir '667' alt dizgesi alın.
• {.~- Orijinal sonucun uzunluğundan bir alt dize alın i..
• , - İkisini birlikte ekleyin.

Kullanımda:

   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

Bu bir kod golf olmadığından, çılgınca optimizasyonlarla cehenneme gitmeye gerek yok. Herkes kazanır!

C #

148 137 karakter

@Recursive sayesinde birkaç karakterden kurtulmayı başardım

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

Keman: http://dotnetfiddle.net/XB83bf

piton

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

İçerideki içeriği değiştiren satır içi kod $_, perl'de oldukça standart bir ideoloji. Bu -pbayrakla birlikte kullanılabilir :

$ perl -p % <<< 66666
66700

J

Dizgi, döngü veya koşul yok:

   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

Carton_box çözümüne benzer şekilde, bu sayı onluk bir güçle bölerek üç basamaklı gruplara ayrılır. Sayıyı uygun bir şekilde toplamak için 666 ilk oluşum endeksini kullanır.

Haskell (70 karakter)

İşte Haskell'de basit bir uygulama.

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 []         = []

• Birincisi, map digitToInt . showkötü niyetli bir kimliği rakam listesine dönüştürmek için kullanılır .
• Ardından, purgekötü kalıba uyuyor ve onu iyi bir eşdeğerle değiştiriyor.
• Son olarak, foldl' ((+).(*10)) 0hane listesini bire indirir Integer.

Bakalım işe yarayıp yaramadı!

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

İyi görünüyor. Ve sadece eğlence için bir golf versiyonu.

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

Java

Bunu yapmak için yeterli değil mi?

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

R,

666'yı 667 eserle değiştirmek.

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

Sonuçlar

> 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 Farklı JavaScript cevapları:

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)

Bulduğu kadar sonra yinelenir her karakterin üzerinde bir dizeye numarayı çevirir 666o zaman bu son değişiklikleri 6bir etmek 7ve çıkışları 0aşağıdaki tüm karakterler için.

2. JavaScript (ECMAScript 6 Taslağı)

Dize manipülasyon olmadan özyinelemeli fonksiyon:

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

Veya daha ayrıntılı olarak:

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

Testler:

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

3. JavaScript

Düzenli ifadeler kullanarak:

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

Veya (aynısı ancak ECMAScript 6 kullanarak)

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_

verir

2
667
667000000
667000000
66700

düzenleme: 2. çözüm

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_

verim

2
667
667000000
667000000
66700
1236670

Python:

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

Veya:

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

Java

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
    }
}

En soldaki 666'yı bulmak için özyinelemeli işlevini kullanmak ve çağrı yığınını tekrar açarken sayının ne kadar ayarlanacağını hesaplamak.

Grup, yığın, parça, bir defada alınan miktar

Basit yinelenmiş dize manipülasyonu.

@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%

Sayının ilk üç karakterinde (bir dize olarak) başlar ve 666'yı bulana kadar sonuna kadar çalışır, daha sonra bu 666'yı 667 ile değiştirir ve dize uzunluğuna sıfır ekler.

Test durumlarının hepsi doğru sonuçları verir.

perl, 45 bayt

/ E bayrağını içeren tek bir regex buradaki bütün işleri yapar:

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

SQL

Kesin olarak, 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

piton

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)

Julia

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 sonuçları

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 #

Doğru yapıyor muyum

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

Eylemde:

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

sonuç:

2 
667 
667000000 
667000000 
66700 
456670 

C ++

Bunun kod-golf olmadığını biliyorum, ancak (a) bazı insanlar bunun iyi bir golf mücadelesi olduğunu öne sürdüler ve (b) bu ​​benim ilk mücadelem / golf cevabı, eğlenceli olacağını düşündüm ve Buradaki korkunç bir golfçü olduğum için gerçek bir golf mücadelesinde ortaya çıkmıyorum. X)

Temel olarak, '666'yı' 667 'ile değiştirdi, eğer sayıdaki ilk örnek için yaparsanız ve ardından 0s yazınız.

Golf ( 175 155 karakter):

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

Yakut

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 sadece bir alt, bayt yok

Aritmetik ve regex ops karışımı kullanan son çözümümden daha kısa bir versiyon.

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

Tamam - kontrol sınır yok ve çok fazla boşluk var ama golf değil. Ayrıca "while (d -> 0)" biçiminde eğlenceli bir bit.