बुराई पूर्णांक से बचें! [बन्द है]

Question

आईडी नंबर जनरेट करने के लिए आप कुछ कोड विकसित कर रहे हैं। नीति के लिए आवश्यक है कि कोई भी आईडी संख्या में अंक 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 से अधिक है तो 666 के साथ 666 की जगह काम नहीं करेगा।

Comments

456667 जैसी किसी चीज के बारे में क्या? 456670 को वापस करना चाहिए, या हम केवल एक प्रमुख 666 के बारे में चिंतित हैं?

— काइल कानोस

मुझे लगता है कि यह लोकप्रियता-प्रतियोगिता की तुलना में कोड-गोल्फ के रूप में बेहतर होगा क्योंकि ऐसे सीधे समाधान हैं।

— नैट एल्ड्रेडज

@ nyuszika7h लेकिन परिणाम होना चाहिए 66700।

— मार्टिन एंडर

वास्तविक चुनौती के रूप में, कोड में कहीं भी "666" न होने की आवश्यकता भी होनी चाहिए

— DLeh

अपने regex कार्यान्वयन के आधार पर, आप 666 का पता लगाने के लिए '6 {3}' का उपयोग कर सकते हैं।

— celtschk

Answer 1

अजगर, कोई स्ट्रिंग हेरफेर नहीं

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।

Comments

मुझे यह पसंद है कि अगर यह वास्तव में एक वास्तविक ग्राहक की आवश्यकता होती है, तो यह कार्यान्वयन गैर-हैसी, समझदार और कुशल है।

— रोमनस्ट्रीम

क्या यह संख्याओं के साथ काम करेगा जिसमें 666 के कई उदाहरण हैं?

— सुपरकैट

हाँ। सबसे बाईं ओर वाला 666 एकमात्र ऐसा है जो वास्तव में मायने रखता है, और यह एल्गोरिथ्म उस आखिरी को ठीक करता है।

— कार्डबोर्ड_बॉक्स

@romkyns अन्य लोगों को उनके लिए अपना काम करने के लिए धोखा देने के लिए एक वास्तविक वास्तविक ग्राहक की आवश्यकता है? यह बुराई है! ( छुपता है )

— बिल्वपत्र

अजगर 3 का उपयोग करने वाले सभी लोगों के लिए: यह कोड अजगर 3+ पर काम नहीं करता है, अजगर 3 पर इस कोड को चलाने के लिए आपको बदलना m /= 10होगा m //= 10। यदि आप नहीं करते हैं तो मीटर फ्लोट बन जाएगा और हालत m % 1000 == 666लगातार झूठी होगी और n में अन्य "666" अपरिवर्तित रह जाएंगे।

— Sirac

Answer 2

जावास्क्रिप्ट (सभी परीक्षण मामलों के साथ काम करने के लिए अद्यतन)

अल्पज्ञात सत्य यह है कि वास्तव में चार 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 से बदलें।

• अन्य,

  • संख्या में एक जोड़ें।
  • नोट: हम अब स्ट्रिंग के अंत में या तो 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चर, और तरह weirdness बदलने -~![]में 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);

अब हम कर चुके हैं! अब इसे समझना बहुत आसान होना चाहिए।

Comments

मैं अपने जवाब चाहते हैं, लेकिन इसके लिए विफल रहता है666666666

— माइकल एम

@ मिचेल ने नया संस्करण जोड़ा! के लिए काम करता है 666666666, और के फ़ॉन्ट 6है अधिक सजावटी;)

— दरवाज़े

हुह - का उपयोग कर ~1के लिए != -1बहुत अच्छा है।

— wchargin

@Chargin बहुत खराब है जो LiveScript में काम नहीं करता है। मुझे पता है कि यह कोड गोल्फ नहीं है, लेकिन मेरे पास मनोरंजन के लिए मेरी पोस्ट में एक गोल्फ संस्करण है।

— nyuszika7h

यह LiveScript :) में काम करता है। ~a.indexOf('b')सही JS जेनरेट करता है, इसे lifecript.net पर आज़माएं!

— शुक्र

Answer 3

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 पृष्ठ पढ़ सकते हैं।}

Comments

ओएस एक्स के बिना आप इसे कैसे चलाते हैं?

— nyuszika7h

मुझे लगता है कि Applescript OSX stackoverflow.com/questions/7642299/… पर बहुत अधिक निर्भर है - मैं अन्य प्लेटफार्मों के लिए किसी भी बंदरगाह के बारे में नहीं जानता हूं। ओएस 9 में एप्सस्क्रिप्ट का एक संस्करण था , हालांकि कोई गारंटी नहीं है कि यह स्क्रिप्ट वहां चलेगी।

— डिजिटल ट्रामा

इसने पोस्ट को सुरक्षित कार्य के लिए नहीं बनाया होगा? डेमिट, मेरा काम खतरनाक नहीं है

— क्रंचर

@ क्रंचर oops ;-)

— डिजिटल ट्रामा

वेरिएबल नामों की पसंद के लिए +1 (और क्योंकि ऐप्पल स्क्रिप्ट शांत है)।

— फ्लोरिस

Answer 4

पर्ल

आपने कहा कि हमें लूप में वृद्धि नहीं करनी चाहिए। मैं किसी भी गणितीय ऑपरेटरों का उपयोग नहीं कर रहा हूँ! यहां एक शुद्ध रेगेक्स-प्रतिस्थापन दृष्टिकोण है (कोई गारंटी नहीं है कि यह आपकी पवित्रता के लिए सुरक्षित है)।

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

पहले तीन प्रतिस्थापन एक-एक करके संख्या में वृद्धि करते हैं। मैंने उस समस्या को स्वयं एक बार हल किया था, लेकिन इसमें एक प्रतिस्थापन शामिल था जिसे तब तक लूप किया जाना था जब तक कि कोई और प्रतिस्थापन नहीं किया जाता था, इसलिए मैंने इसके बजाय एंड्रयू च्योंग के दृष्टिकोण का उपयोग किया।

चौथा प्रतिस्थापन एक 666शून्य में निम्नलिखित सभी अंकों को बदल देता है । अंतिम प्रतिस्थापन 666एक में शेष को बदल देता है 667।

एक बोनस के रूप में यह इनपुट में कई पूर्णांकों के साथ काम करेगा जब तक कि वे गैर-अंकीय वर्णों द्वारा अलग हो जाते हैं।

Answer 5

LiveScript

यह नियमों को झुका रहा है। आप देखें, आपने कहा था कि मुझे एक लूप का उपयोग नहीं करना चाहिए जो एक को जोड़ता है जब तक कि यह एक सही परिणाम नहीं मिलता है इसलिए मैं इसके बजाय माइनस घटाता हूं !

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

Comments

जब आप 665999 पर पहुंचेंगे तो यह बुरी तरह से विफल हो जाएगा, क्योंकि आपका स्टैक फट जाएगा।

— तिमुल्ला

बहुत चालाक। इस तरह की खामियों को दूर करने के लिए आपको RFC लिखना चाहिए।

— बिल्वपत्र

@TimWolla दिलचस्प है। आपने कैसे पाया?

— nyuszika7h

@ nyuszika7h: यदि आप इसके बारे में सोचते हैं, तो 666999 के माध्यम से 666000 सभी विफल हो जाएंगे ... आप कम से कम 1000 बार दोहरा रहे होंगे।

— एंड्रयू कॉन्स

मेरे पास कोई विशेष कारण नहीं है, मुझे लगता है।

— nyuszika7h

Answer 6

माणिक

यह (मुझे लगता है) पहला जवाब है जो 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

Comments

वास्तव में, मेरा जवाब 666666666 के लिए ठीक काम करता है।

— इसहाक

लगातार क्रम असंभव है। यहां तक ​​कि अगर "666" मौजूद है, तो जाँच करना एक रैखिक समस्या है। यह उससे कहीं ज्यादा कठिन समस्या है।

— क्रंचर

Answer 7

शक्ति कोशिका

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

Answer 8

जे

अंत में, के लिए एक अच्छा उपयोग E.!

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

संक्षेप में, हम पहली स्थिति पाते हैं जिसमें तर्क पूर्ण है 666, और हम उस प्रतिस्थापन और सब कुछ 66700000...को अंत तक के बाद प्रतिस्थापित करते हैं ।

विस्तार से बताया:

• ":@>: - एक से वृद्धि और स्ट्रिंग में कनवर्ट करें।
• '666'&E. - बूलियन का एक वेक्टर बनाएं, प्रत्येक स्थान पर सच है कि स्ट्रिंग में '666' शुरू होता है।
• i.1: - वेक्टर में पहले सच का सूचकांक ढूंढें, अन्यथा वेक्टर की लंबाई वापस करें।
• #@[-]- स्ट्रिंग की लंबाई (जो कि वेक्टर की लंबाई भी है) का परिणाम शून्य है 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

और चूंकि यह एक कोड गोल्फ नहीं है, इसलिए इसके लिए पागल अनुकूलन के साथ नरक में जाने के लिए गोल्फ नहीं है। हर कोई जीतता है!

Answer 9

सी#

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

फिडल: http://dotnetfiddle.net/XB83bf

Comments

आपके regex में वर्गाकार कोष्ठक अनावश्यक होते हैं, और बहुत सारे वाक्यविन्यास अनावश्यक स्थान भी होते हैं।

— पुनरावर्ती

ओह, और के Int32साथ प्रतिस्थापित किया जा सकता है int।

— पुनरावर्ती

@recursive आप सही हैं, धन्यवाद!

— कोशिश कर रहा

ध्यान दें कि यह एक लोकप्रियता-प्रतियोगिता है न कि कोड-गोल्फ । कहा जाता है कि यदि आपको लगता है कि आप पात्रों को शेविंग करना चाहते हैं, तो आपका उत्तर अधिक लोकप्रिय होगा, तो इसके लिए जाएं!

— डिजिटल ट्रॉमा

पहले मैंने dotnetfiddle.net =) देखा है!

— सीओपी

Answer 10

अजगर

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)

Answer 11

पर्ल

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

इनलाइन कोड जो सामग्री को अंदर बदलता है $_, पर्ल में एक सुंदर मानक विचारधारा। -pइस तरह ध्वज के साथ संयोजन के रूप में इस्तेमाल किया जा सकता है :

$ perl -p % <<< 66666
66700

Answer 12

जे

कोई तार, लूप या सशर्त:

   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

कार्डबोर्ड_बॉक्स के समाधान के समान, यह संख्या को दस की शक्तियों से विभाजित करके तीन अंकों के समूहों में विभाजित करता है। यह 666 की पहली घटना के सूचकांक को उचित रूप से संख्या को गोल करने के लिए उपयोग करता है।

Answer 13

हास्केल (70 अक्षर)

यहाँ हास्केल में एक सरल कार्यान्वयन है।

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संभवतः एक बुराई आईडी को अंकों की सूची में बदलने के लिए उपयोग करता है।
• अगला, 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

अछा लगता है। और सिर्फ एक गोल्फ संस्करण का मज़ा लेने के लिए।

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

Answer 14

जावा

क्या ऐसा करना पर्याप्त नहीं है?

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

Comments

बंद है, लेकिन यह होना चाहिए String.valueOf(currentId + 1)।

— nyuszika7h

ओह ठीक है, मैं भूल गया कि +1 चीज़! : डी

— वैलेंटाइन ग्राईगोइरे

वह शर्त बेकार है; मेरे सुझाव के अनुसार थोड़ा संशोधित मूल समाधान भी काम करेगा:return Integer.parseInt(String.valueOf(currentId + 1).replace("666", "667"));

— nyuszika7h

सच नहीं है ... 66600 को 66701 के रूप में लौटाया जाएगा, जो कि 1 बहुत अधिक है।

— वैलेंटाइन ग्राएगोइरे

Answer 15

आर

667 कार्यों के साथ 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

Answer 16

3 अलग जावास्क्रिप्ट जवाब:

1. जावास्क्रिप्ट (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. जावास्क्रिप्ट (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

Comments

अपने पहले संस्करण के साथ, यदि आप 6 सेप्टिलियन, 666 सेक्स्टिलियन दर्ज करते हैं, तो आपको 6.667तकनीकी रूप से यह अभी भी वहाँ है। हालांकि यह मदद की जा सकती है मत सोचो।

— Spedwards

1e20परिमाण के सबसे बड़े क्रम के बारे में है कि जावास्क्रिप्ट (कम से कम फ़ायरफ़ॉक्स में) वैज्ञानिक संकेतन का सहारा लिए बिना पूर्णांक के रूप में मुद्रित होगा।

— MT0

Answer 17

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

Comments

जो सही उत्तर नहीं लगता है। 665 को 667, 66600 को 66700 इत्यादि देने चाहिए

— ace_HongKongInd डिपेंडेंस

आपके परिणामों में बहुत सारे "666" पदार्थ होते हैं।

— ग्लेन रैंडर्स-पीहरसन

शर्म की बात है। मैंने 2 (!) बाड़-पोस्ट-त्रुटियों को मैंने ठीक किया क्योंकि मैं भूल गया था कि awkअनुक्रमित 1-आधारित तार।

— एमएसचिल्ली

@ क्रंचर स्पष्ट रूप से सवाल में कहा गया है, f(665) returns 667क्योंकि यह "अगले पूर्णांक जिसमें 666 शामिल नहीं है" के लिए पूछ रहा है

— ace_HongKongInd डिपेंडेंस

मैंने एक दूसरा तरीका जोड़ा है जो a) अधिक awkish है और b) स्ट्रिंग फ़ंक्शंस के उपयोग को कम करता है।

— mschilli

Answer 18

अजगर:

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

Comments

मैं नहीं देखता कि यह कैसे काम करता है। इसके बजाय 666666में बदल जाएगा ? 667667667000

— मार्टिन एंडर

@ m.buettner अच्छा बिंदु, मुझे लगता है कि मेरे पास पहले से ही एक समाधान है।

— atı 16uʎs

Answer 19

जावा

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 खोजने के लिए और गणना करें कि कॉल स्टैक को फिर से पॉप करने पर संख्या को समायोजित करने के लिए कितना।

Comments

मुझे नहीं लगता कि यह कोड सही है। यह 666666666 इनपुट के लिए क्या परिणाम देता है?

— एल्गोरिथमशार्क

आप सही हैं, महसूस नहीं किया कि इनपुट में पहले से ही ईविल नंबर हो सकते हैं। तो f (666666666) -> 667667667?

— रोजर लिंडजॉ

f(666666666) -> 667000000

— djhurio

@djhurio लगता है कि मैं आज किनारे के मामलों के लिए परीक्षण उत्पन्न नहीं कर सकता। मेरा मानना ​​है कि यह अब तय हो गया है, लेकिन कोड इतना कम नहीं है।

— रोजर लिंडजो

@ RogerLindsjö यह एक popularity-contest, नहीं है code-golf।

— nyuszika7h

Answer 20

जत्था

सरल पुनरावृत्त स्ट्रिंग हेरफेर।

@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 के साथ 666 की जगह लेता है, और स्ट्रिंग जोड़ते हुए शून्य की लंबाई तक लूप करता है।

परीक्षण के मामले सभी सही परिणाम देते हैं।

Answer 21

पर्ल, 45 बाइट्स

/ ई ध्वज के साथ एक एकल रेगेक्स यहां सभी काम करता है:

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

Answer 22

एसक्यूएल

सटीक होने के लिए, 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

Answer 23

अजगर

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)

Answer 24

जूलिया

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

Answer 25

सी#

क्या मैं यह ठीक कर रहा हूँ

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

Answer 26

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 

Answer 27

सी ++

मुझे पता है कि यह कोड-गोल्फ नहीं है, लेकिन (ए) कुछ लोगों ने सुझाव दिया है कि यह एक अच्छा गोल्फ चैलेंज है, और (बी) यह मेरी पहली चुनौती है / गोल्फ जवाब है, मुझे लगा कि यह मजेदार होगा, और अगर मैं करता हूं यहाँ मैं एक भयानक गोल्फ खिलाड़ी होने के लिए एक वास्तविक गोल्फ चुनौती में नहीं दिखा। एक्स)

मूल रूप से, ically 666 ’को 67 667’ कार्यों के साथ प्रतिस्थापित किया जाता है यदि आप इसे संख्या में पहली बार करते हैं और फिर 0 से पता लगाते हैं।

गोल्फ ( 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;
}

Comments

मुझे लगता है कि आपको जरूरत नहीं है x+=c=='6'?1:0, आप दूर हो सकते हैं x+=c=='6'। हालांकि यह कोशिश नहीं की है।

— nyuszika7h

इसके अलावा, आप std::पहले बाहर छोड़ दिया है stringstream। यह उसके बिना संकलन नहीं है।

— nyuszika7h

जोड़ा गया std ::, उस @ nyuszika7h के लिए धन्यवाद। मैंने एक IDE का उपयोग करने की गलती की है जो 'नाम स्थान std का उपयोग करते हुए' स्वतः पूर्ण हो गई है; में यह परीक्षण करने के लिए -_- मैं x+=c=='6'कमी की कोशिश करूँगा , साथ ही साथ इसे सस्टर्ड वर्णों के बजाय अंतर अंकों के साथ करने की कोशिश कर रहा हूं ...

— mike32

Answer 28

माणिक

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

Answer 29

पर्ल, 36 बस एक उप, कोई बाइट्स

अंकगणित और रेगेक्स ऑप्स के मिश्रण का उपयोग करते हुए मेरे पिछले समाधान की तुलना में एक छोटा संस्करण।

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

Comments

प्रिंट + (<> + 1) = ~ s / 666 (। *) / 667 $ 1 / r- $ 1 (आपको बाइट से बचाया) (दो और अगर आप कहते हैं तो उपयोग करें) - हालांकि अनुरोध एक फ़ंक्शन के लिए था इसलिए प्रिंट + का उपयोग करें और उपयोग करें उप {...}

— Altreus

Answer 30

सी

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

ठीक है - कोई सीमा नहीं जाँच रहा है और बहुत अधिक व्हॉट्सएप लेकिन यह गोल्फ नहीं है। साथ ही "जबकि (d -> 0)" में फ़ॉर्मेटिंग का एक मजेदार तरीका।