पृष्ठभूमि

जब मैं प्राथमिक विद्यालय में था, हम गणित की कक्षा में एक खेल खेलते थे जो इस प्रकार है।

सभी बच्चे एक बड़े घेरे में बैठते हैं और गिनती शुरू करते हैं, जो 1 से शुरू होती है ।

हालांकि, गिनती करते समय निम्नलिखित संख्याओं को छोड़ दिया जाना चाहिए:

संख्या जो 3 के गुणक हैं ।
संख्याएँ जिनके दशमलव प्रतिनिधित्व में 3 है।

बच्चों को कहना चाहिए कि पहले 15 नंबर

1 2 4 5 7 8 10 11 14 16 17 19 20 22 25

जब भी किसी को कोई नंबर गलत मिलता है - वह नंबर कहता है जो अनुक्रम में नहीं है या एक नंबर को छोड़ देता है - वह सर्कल से हटा दिया जाता है। यह तब तक चलता है जब तक कि केवल एक बच्चा नहीं बचा है।

कार्य

आप इस खेल में बुरे हैं, इसलिए आप धोखा देने का फैसला करते हैं। एक प्रोग्राम या एक फ़ंक्शन लिखें, जो अनुक्रम का एक नंबर दिया गया है, अनुक्रम की अगली संख्या की गणना करता है।

आपको उन नंबरों को संभालना नहीं है जिन्हें आपकी भाषा के मूल सांख्यिक प्रकार का उपयोग करके नहीं दिखाया जा सकता है, बशर्ते कि आपका प्रोग्राम सही ढंग से इनपुट 251 तक काम करता हो और यह कि आपका एल्गोरिथ्म मनमाने ढंग से बड़े इनपुट के लिए काम करता हो।

इनपुट और आउटपुट किसी भी सुविधाजनक आधार का उपयोग कर सकते हैं।

चूँकि आपको अपना कोड छुपाना है, इसलिए यह यथासंभव छोटा होना चाहिए। वास्तव में, यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है।

परीक्षण के मामलों

— डेनिस
स्रोत

5

मुझे लगता है कि हमारे पास इस तरह की चुनौती थी ...

— कॉनर ओ'ब्रायन

5

7जब मैं इसे बजाता था तो हमेशा ऐसा होता था, लेकिन आप पंक्ति में अगले नंबर पर जाने के बजाय कुछ और कहेंगे।

— mbomb007

12

@ mbomb007: जब मैंने इसे खेला था, तो आपको सर्कल से नहीं हटाया जाएगा। इसके बजाय, आप पीते होंगे। लेकिन वह प्राथमिक विद्यालय में नहीं था। वैसे भी, 80 से अधिक प्राप्त करना असंभव था, खासकर पहले घंटे के बाद।

— तोमाज़

10

@ mbomb007 रक्त शराब एकाग्रता पर निर्भर करता है।

— डेनिस

4

@ mbomb007: जो आप पी रहे हैं उसके प्रमाण पर निर्भर करेगा।

— टॉमसz

21

ब्रेकीलॉग , 10 बाइट्स

<.='e3:I'*

इसे ऑनलाइन आज़माएं!

व्याख्या

(?)<.                Output > Input
    .=               Assign a value to the Output
    . 'e3            3 cannot be an element of the Output (i.e. one of its digits)
        3:I'*(.)     There is no I such that 3*I = Output

— Fatalize
स्रोत

3

इस तरह के उत्तर Brachylog में बहुत सुंदर हैं :)

— Emigna

3

@Emigna यह लगभग कभी-कभी गोल्फ को पर्याप्त महसूस नहीं करता है क्योंकि यह मूल रूप से सीधे चुनौती का वर्णन करता है। उस भाषा में बहुत सारे उत्तरों के लिए यह मामला है :)

— घातक

14

जावास्क्रिप्ट (ईएस 6), 30 बाइट्स

f=n=>++n%3*!/3/.test(n)?n:f(n)

— ETHproductions
स्रोत

इंडेक्स 2 और इंडेक्स 3 दोनों इस फ़ंक्शन के साथ नंबर 4 पर लौटते हैं

— nl-x

1

@ nl-x हां, क्योंकि 4 2 और 3 के बाद अनुक्रम में अगला नंबर है। यह अनुक्रमित नहीं है; यह अनुक्रम में बस अगली संख्या है।

— ETHproductions

मुझे लगता है कि मैं इसे समझना शुरू कर रहा हूं ... मेरा बुरा

— nl-x

8

जे, 24 बाइट्स

3(]0&({$:)~e.&":+.0=|)>:

स्ट्रेट-फ़ॉरवर्ड अप्रोच जो कि इनपुट n से आगे की ओर ले जाती है जब तक कि वह नियमों द्वारा मान्य अगली संख्या नहीं पाती।

फार्म पाँच स्माइली, $:, :), 0=, =|, और >:।

प्रयोग

   f =: 3(]0&({$:)~e.&":+.0=|)>:
   (,.f"0) 1 2 11 22 29 251
  1   2
  2   4
 11  14
 22  25
 29  40
251 254

व्याख्या

3(]0&({$:)~e.&":+.0=|)>:  Input: integer n
                      >:  Increment n
3                         The constant 3
 (                   )    Operate dyadically with 3 (LHS) and n+1 (RHS)
                    |       Take (n+1) mod 3
                  0=        Test if equal to 0
             &":            Format both 3 and n+1 as a string
           e.               Test if it contains '3' in str(n+1)
                +.          Logical OR the results from those two tests
  ]                         Right identity, gets n+1
   0&(   )~                 If the result from logical OR is true
       $:                     Call recursively on n+1
      {                       Return that as the result
                            Else act as identity function and return n+1

— मील की दूरी पर
स्रोत

खैर, जे शायद सबसे स्माइली-प्रोन प्रोग्रामिंग भाषा है।

— Adám

8

पायथन 2, 73 66 43 बाइट्स

मुझे बताने के लिए xnor के लिए धन्यवाद मैं 2 चर का उपयोग करके मूर्खतापूर्ण था, और मिच श्वार्ट्ज के लिए भी धन्यवाद।

x=~input()
while'3'[:x%3]in`x`:x-=1
print-x

— डैनियल
स्रोत

1

दो-चर अद्यतन बहुत जटिल लग रहा है। मुझे लगता है कि आपको बस जरूरत है x=input()+1 while'3'[:x%3]in`x`:x+=1 print x।

— xnor

@xnor, ओह, हाँ, मुझे मूर्खता है कि मुझे नहीं पता कि मैंने ऐसा क्यों किया

— डैनियल

एक बाइट सुधार के साथ शुरू करने x=~input(), जोड़ने के बजाय घटाना, और मुद्रण -x।

— मिच श्वार्ट्ज

1

@Artyer उस संपादन में शुरू की गई 3 गलतियों में से केवल 1 है।

— मिच श्वार्ट्ज

1

@ डोप्प वर्तमान संशोधन (अंतरिक्ष के बिना) 43 बाइट्स है? mothereff.in/…

— Artyer

7

05AB1E , 11 बाइट्स

[>Ð3ås3Ö~_#

इसे ऑनलाइन आज़माएं!

व्याख्या

               # implicit input
[              # start loop
 >             # increase current number
  Ð            # triplicate
          #    # break loop IF
         _     # logical negation of
   3å          # number has one or more 3's in it
        ~      # OR
     s3Ö       # number % 3 == 0

— Emigna
स्रोत

7

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

18 बाइट्स कोड + 1 के लिए -p।

++$_%3&&!/3/||redo

प्रयोग

perl -pe '++$_%3&&!/3/||redo' <<< 8
10

perl -pe '++$_%3&&!/3/||redo' <<< 11
14

— डोम हेस्टिंग्स
स्रोत

1

@ dan1111 यह पर्ल है, आपको क्या उम्मीद थी? स्पष्टता?

— आउटगोल्फ

1

@EriktheGolfer क्या? यह "स्व-दस्तावेजीकरण कोड" की बहुत परिभाषा है।

@ dan1111 ऐसा लगता है कि आप पर्ल को जानते हैं। मुझे इस बात का कोई अंदाजा नहीं है कि पर्ल अपनी प्रसिद्ध अजीबता के कारण कैसे काम करता है।

— आउटगोल्फर

@ dan1111 धन्यवाद! यह कितना छोटा निकला, इससे खुश!

— डोम हेस्टिंग्स

1

@DomHastings खैर, PPCG में, हम पर्ल को अजीबता के शीर्ष स्तर के रूप में लेते हैं, और जेली / वास्तव में / O5AB1E गड़बड़ के शीर्ष स्तर के रूप में। ऐसा लगता है कि आपने कभी भी इस चुनौती को नहीं देखा है :)

— एर्ग आउटफ्लोफर

6

जावा 8, 57 56 55 50 बाइट्स

1 बाइट के लिए @Numberknot को धन्यवाद और 5 बाइट के लिए @ केविन क्रूज़सेन को धन्यवाद

i->{for(;++i%3<1|(i+"").contains("3"););return i;}

यह है एक Function<Integer, Integer>

व्याख्या

Naive कार्यान्वयन जो केवल स्वीकार्य संख्या तक पहुंचने तक बढ़ जाता है।

टेस्ट क्लास

public class CodeGolf {

    public static void main(String[] args) {
        Function<Integer, Integer> countingGame = i->{for(;++i%3<1|(i+"").contains("3"););return i;};
        int val = 1;
        for (int i = 0; i < 10; i++) {
            System.out.print(val + " ");
            val = countingGame.apply(val);
        }
    }

}

टेस्ट क्लास का आउटपुट:

1 2 4 5 7 8 10 11 14 16

— सोक्रेटिक फीनिक्स
स्रोत

2

आप |इसके बजाय का उपयोग कर सकते हैं||

— नंबर

1

@ नम्बरनॉट मुझे नहीं पता था कि कुछ संदर्भों में बिटवाइज़ ऑपरेटरों ने तार्किक लोगों के रूप में काम किया है! धन्यवाद!

— सुकराती फीनिक्स

1

क्यों do-while? बस एक नियमित रूप से लूप छोटा होता है: i->{for(;++i%3<1|(i+"").contains("3"););return i;}( 50 बाइट्स )

— केविन क्रूज़सेन 11

@ केविनक्रूजसेन वेल ... मैंने तुलना करने के बारे में सोचा whileऔर do-while, और उन्होंने दोनों मुझे एक ही स्कोर दिया, लेकिन मुझे do-whileदेखा हुआ तरीका पसंद आया ... मैंने forलूप का उपयोग करने के बारे में नहीं सोचा ... धन्यवाद!

— सुकराती फीनिक्स

5

जाप, 18 बाइट्स

°U%3*!Us f'3 ?U:ßU

इसे ऑनलाइन टेस्ट करें

मैं अंत में उपयोग करने का मौका है ß:-)

यह काम किस प्रकार करता है

                    // Implicit: U = input integer
°U%3                // Increment U, and take its modulo by 3.
     !Us f'3        // Take all matches of /3/ in the number, then take logical NOT.
                    // This returns true if the number does not contain a 3.
    *               // Multiply. Returns 0 if U%3 === 0  or the number contains a 3.
             ?U     // If this is truthy (non-zero), return U.
               :ßU  // Otherwise, return the result of running the program again on U.
                    // Implicit: output last expression

— ETHproductions
स्रोत

5

PowerShell v2 +, 46 बाइट्स

for($a=$args[0]+1;$a-match3-or!($a%3)){$a++}$a

इनपुट लेता है $args[0], जोड़ता है 1, बचाता है $a, एक forलूप शुरू करता है। सशर्त लूप रखता है जबकि या तो $a-match3(रेगेक्स मैच) -or $a%3शून्य ( !जिसमें से 1) है। पाश बस वेतन वृद्धि $a++। लूप के अंत में, हम बस $aपाइपलाइन पर जगह रखते हैं , और निहितार्थ के माध्यम से आउटपुट Write-Outputकार्यक्रम पूरा होने पर होता है।

उदाहरण

PS C:\Tools\Scripts\golfing> 1,2,11,22,29,33,102,251,254|%{"$_ --> "+(.\count-without-three.ps1 $_)}
1 --> 2
2 --> 4
11 --> 14
22 --> 25
29 --> 40
33 --> 40
102 --> 104
251 --> 254
254 --> 256

— AdmBorkBork
स्रोत

4

आर, 46 बाइट्स

n=scan()+1;while(!n%%3|grepl(3,n))n=n+1;cat(n)

— plannapus
स्रोत

मुझे लगता है कि मान वापस लौटने के बजाय (स्टडआउट में प्रिंट करने की अनुमति है), इसलिए आप केवल nइसके बजाय 5 बाइट्स बचा सकते हैं cat(n)।

— rturnbull

4

पायथन 2, 49 44 42 बाइट्स

f=lambda x:'3'[:~x%3]in`~x`and f(x+1)or-~x

अन्य पायथन प्रविष्टि इसे हराती है (संपादित करें: कोई और अधिक: -D), लेकिन मैंने इसे पोस्ट किया क्योंकि मुझे इसकी पुनरावृत्ति दृष्टिकोण पसंद है। मिच श्वार्ज और एरिक गोल्फर की मदद करने के लिए धन्यवाद कि मैंने इसे छोटा किया।

— 0WJYxW9FMN
स्रोत

1

आप इसे पायथन 2 में कर सकते हैं f=lambda x:f(x+1)if x%3>1or'3'in`x+1`else-~x:। यदि आप पायथन 3 को रखना चाहते हैं, तो आप अंतरिक्ष x+1को अंतिम -~xऔर गोल्फ को हटा सकते हैं।

— निकोलग्राफ

@EriktheGolfer धन्यवाद! मैं इसे अजगर 2 में बदल दूंगा, क्योंकि यह छोटा है।

— 0WJYxW9FMN

42s: f=lambda x:'3'[:~x%3]in`~x`and f(x+1)or-~xऔरf=lambda x:f(x+1)if'3'[:~x%3]in`~x`else-~x

— मिच श्वार्ट्ज

3

लुआ, 58 बाइट्स

i=...+1while(i%3==0or(i..""):find"3")do i=i+1 end print(i)

— Cyv
स्रोत

3

पाइके, 13 बाइट्स

Whii3%!3`i`{|

यहाँ कोशिश करो!

              - i = input
W             - do:
 hi           -  i += 1
   i3%!       -    not (i % 3)
            | -   ^ or V
       3`i`{  -    "3" in str(i)
              - while ^

— नीला
स्रोत

1

पहले तो मैंने यह whileशुरुआत में कहा ।

— कॉनर ओ'ब्रायन

यदि आप इसे देखें तो मैं देख सकता हूं कि

— ब्लू

3

सी #, 56 , 51 बाइट्स।

यह आश्चर्यजनक रूप से C # उत्तर के लिए छोटा है!

x=>{while(++x%3<1|(x+"").Contains("3"));return x;};

— मॉर्गन थ्राप्प
स्रोत

आप इसे 43 तक ले जा सकते हैं यदि आप इसे पुनरावर्ती बनाते हैं t=x=>(++x)%3<1|(x+"").Contains("3")?t(x):x; दृश्य स्टूडियो में, आपको बस चर को परिभाषित करने और इसे शून्य पर सेट करने की आवश्यकता है Func<int, int> t = null;और फिर निम्न पंक्ति पर पुनरावर्ती फ़ंक्शन को परिभाषित करना होगा।

— ग्रैक्स 32

समस्या यह है कि अगर मैं इसे पुनरावर्ती बनाता हूं, तो मुझे फ़ंक्शन को गिनना होगा और परिभाषाएं टाइप करनी होंगी।

— मॉर्गन थ्रैप

क्या इन दिशानिर्देशों को देखने के लिए मैं कहीं जा सकता हूं? मैं यहाँ पर सी # गोल्फिंग को भ्रमित करता हूँ।

— ग्रैक्स 32

@Grx मूल रूप से, आपको एक गैर-पुनरावर्ती फ़ंक्शन के मामले में एक नाम के लिए असाइनमेंट को छोड़कर कोड के लिए आवश्यक किसी भी कोड को शामिल करना होगा। मुझे नहीं पता कि आपको दिशानिर्देशों का एक ठोस सेट कहाँ मिलेगा, दुर्भाग्य से।

— मॉर्गन थ्रैप

@ मॉर्गनट्रैप कृपया 49 सीट्स पर पुनरावृत्ति के साथ मेरे सी # उत्तर की जाँच करें :)

— lee

3

हास्केल, 50 48 बाइट्स

f n=[x|x<-[n..],mod x 3>0,notElem '3'$show x]!!1

Ideone पर इसे आज़माएं। @Charlie हार्डिंग के लिए 2 बाइट्स धन्यवाद सहेजे गए ।

वैकल्पिक: (50 बाइट्स)

g=f.(+1)
f n|mod n 3<1||(elem '3'.show)n=g n|1<3=n

— Laikoni
स्रोत

1

इसके अलावा 50 बाइट्स until(\x->mod x 3>0&&notElem '3'(show x))succ.succ:।

— निमि

3

अजगर, 11 बाइट्स

f&-I`T3%T3h

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

f&-I`T3%T3hQ   implicit Q at the end
f         hQ   find the smallest integer T >= input + 1 which fulfills:
  -I`T3           T is invariant under removing the digit 3
 &                and
       %T3        T mod 3 leaves a positive remainder

— Jakube
स्रोत

2

गोल्फशार्प , 43 बाइट्स

m=>r(m,m).w(n=>n%3>0&!n.t().I("3")).a()[1];

— downrep_nation
स्रोत

2

रूबी, 47 बाइट्स

i=gets.to_i;i while(i+=1)%3==0||"#{i}"=~/3/;p i

मुझे वास्तव में ऐसा लग रहा है कि इसे और आगे बढ़ाया जा सकता है।

— Elenian
स्रोत

आप iइसके बजाय का उपयोग कर सकते हैं"#{i}"

— Mhmd

2

MATL , 14 बाइट्स

`Qtt3\wV51-hA~

इसे ऑनलाइन आज़माएं!

व्याख्या

`       % Do...while
  Q     %   Add 1. Takes input implicitly in the first iteration
  tt    %   Duplicate twice
  3\    %   Modulo 3
  wV    %   Swap, string representation
  51-   %   Subtract 51, which is ASCII for '3'
  h     %   Concatenate
  A~    %   True if any result was 0. That indicates that the number
        %   was a multiple of 3 or had some '3' digit; and thus a 
        %   new iteration is needed

— लुइस मेंडो
स्रोत

2

भूलभुलैया , 117 102 बाइट्स

?       """""""""""_
):_3    (         0/{!@
;  %;:}_';:_3-_10 1
"  1            %;_
""""_""""""""{;;'

इसे ऑनलाइन आज़माएं!

भूलभुलैया एक द्वि-आयामी, स्टैक-आधारित प्रोग्रामिंग भाषा है और जंक्शनों पर, स्टैक के शीर्ष द्वारा दिशा निर्धारित की जाती है (सकारात्मक सही जाती है, नकारात्मक बाएं जाती है, शून्य सीधे जाती है)। इस कार्यक्रम में दो मुख्य लूप हैं। पहला मोड पूर्णांक इनपुट को 3 से बढ़ाता है और 0. यदि दूसरा अंक 3 है (3 घटाकर और 10 से घटाकर) तो दूसरा बार-बार नया अंक प्राप्त करने के लिए विभाजित करता है।

— रॉबर्ट हिकमैन
स्रोत

2

PHP, 60 55 54 46 बाइट्स

कुछ बाइट्स बंद करने के लिए @ user59178 के लिए धन्यवाद, @ बाइट के लिए @AlexHowansky, कुछ अन्य बाइट्स के लिए @ टिट्स

for(;strstr($i=++$argv[1],51)|$i%3<1;);echo$i;

कमांड लाइन से कॉल किया गया -r। Naive विधि जो संख्या को 3 से गुणा करती है, या उसके अंकों में 3 है।

— Xanderhall
स्रोत

1

आप केवल एक फ़ंक्शन के बजाय कमांड लाइन से इनपुट लेने वाले प्रोग्राम का उपयोग करके 7 बाइट्स बचा सकते हैं: यह भी उपयोग करते समय for($i=$argv[1];!(++$i%3)|strpos(" $i",'3'););echo$i;असाइन $iकरके बेहतर करना संभव हो सकता है ।

— user59178

@ user59178 मैंने मान लिया कि समारोह में $ i

— Xanderhall

अधिकांश समय प्रश्न बहुत लचीले होते हैं कि इनपुट और आउटपुट कैसे किया जाता है, जब तक कि सही चीज़ को दिया और प्राप्त नहीं किया जाता है। इसके अलावा, अन्य भाषाओं में उत्तरों को देखते हुए, अधिकांश स्टैडआउट में प्रिंट करना चुनते हैं।

— user59178

एक बाइट को बचाएंstrpos(_.$i,'3')

— एलेक्स हॉवंस्की

इसके साथ एक बाइट को बचाएं %3<1, एक के 51बजाय '3', दो के साथ और दो के strstr($i)बजाय दूसरे संस्करण में ऑपरेंड strpos(_.$i)स्वैप करके |: <?for(;strstr($i=++$argv[1],51)|$i%3<1;);echo$i;-> 48 बाइट्स

— टाइटस

2

PHP, 47 41 बाइट्स

Xanderhall से प्रेरित है , लेकिन नवीनतम विचार अंत में अपने ही जवाब को सही ठहराता है।

while(strstr($n+=$n=&$argn%3,51));echo$n;

या

while(strpbrk($n+=$n=&$argn%3,3));echo$n;

यह इस तथ्य से लाभ उठाता है कि इनपुट अनुक्रम से भी है: इसके लिए $n%3==1, नया मोडुलो है 2। के लिए $n%3==2, नया मोडुलो है 4-3=1। $n%3==0कभी नहीं होता।

पाइप के साथ चलाएं -Rया उन्हें ऑनलाइन आज़माएं ।

— टाइटस
स्रोत

2

APL (Dyalog Unicode) , 33 28 27 19 बाइट्स ^SBCS

1∘+⍣{('3'∊⍕⍺)<×3|⍺}

इसे ऑनलाइन आज़माएं!

-6 Adám को धन्यवाद। -8 ngn के लिए धन्यवाद।

पुरानी व्याख्या:

1-⍨g⍣((×3|⊢)>'3'∊⍕)∘(g←+∘1)
                       +∘1  ⍝ curry + with 1, gives the increment function
                            ⍝ increments the left argument so we do not return the number itself
                    (g←   ) ⍝ assign to "g"
                   ∘        ⍝ compose g with the repeat
                 ⍕          ⍝ does parsing the argument to a string...
             '3'∊           ⍝ ...contain '3'?
        3|⊢                 ⍝ residue of a division by 3
      (×   )                ⍝ direction (0 if 0, 1 if greater, ¯1 is lower)
     (      >     )         ⍝ and not (we want the left side to be 1, the right side 0)
   g⍣                       ⍝ repeat "g" (increment) until this function is true ^
1-⍨                         ⍝ afterwards, decrement: inversed -

APL (Dyalog Extended) , 23 17 बाइट्स ^SBCS

1∘+⍣(3(×⍤|>∊⍥⍕)⊣)

इसे ऑनलाइन आज़माएं!

Adám को धन्यवाद। -6 धन्यवाद ngn करने के लिए।

पुरानी व्याख्या:

0+⍣(3(×⍤|>∊⍥⍕)⊢)⍢(1+⊢)⊢
0                       ⍝ the left argument (⍺)
 +⍣(3(×⍤|>∊⍥⍕)⊢)        ⍝ the left function (⍺⍺)
                 (1+⊢)  ⍝ the right function (⍵⍵)
                        ⍝     (increments its argument)
                      ⊢ ⍝ the right argument (⍵)
                        ⍝     (just returns the input)
                ⍢       ⍝ under:
                        ⍝     calls (⍵⍵ ⍵) first, which increments the input
                        ⍝     also (⍵⍵ ⍺) which gives 1
                        ⍝     then calls (⍺incremented ⍺⍺ ⍵incremented)
                        ⍝     afterwards, does the opposite of ⍵⍵, and decrements the result
  ⍣                     ⍝ ⍣ fixpoint: repeats the left operation until the right side is truthy
 +                      ⍝ calls + with ⍺incremented and the input (so, 1+input)
   (3(×⍤|>∊⍥⍕)⊢)        ⍝ right operation
    3                   ⍝ on its left, "3"
              ⊢         ⍝ on its right, the current iteration
      ×⍤|               ⍝ divisibility check: × atop |
        |               ⍝     starts with 3|⊢ (residue of ⊢/3)
      ×                 ⍝     then returns the direction (0 if 0, 1 if greater, ¯1 is lower)
          ∊⍥⍕           ⍝ contains 3:
            ⍕           ⍝    stringifies both its arguments (3 and ⊢)
          ∊⍥            ⍝    checks for membership
         >              ⍝ divisibility "and not" contains 3

— Ven
स्रोत

2

पर्ल 6 , 27 25 24 बाइट्स

{max $_+1...{!/3/&$_%3}}

इसे ऑनलाइन आज़माएं!

इनपुट की तुलना में पहले नंबर को बड़ा पाता है जिसमें तीन नहीं होते हैं और शेष है जब 3 से moduloed। मैं स्थिति के साथ कुछ फैंसी करने की उम्मीद कर रहा था, जैसे कि !/3/&*%3लेकिन यह साथ काम नहीं करता है !।:(

स्पष्टीकरण:

{                      }   # Anonymous code block
     $_+1                  # From the input+1
         ...               # Get the series
            {         }    # That ends when
             !/3/            # The number does not contain a 3
                 &           # and
                  $_%3       # The number is not divisible by 3
 max                       # And get the last element of the series

— मजाक कर रहा है
स्रोत

1

सी, 81 बाइट्स

f(int n){int m;l:if(++n%3){for(m=n;m>0;m/=10)if(m%10==3)goto l;return n;}goto l;}

— Steadybox
स्रोत

1

जालीदार, 30 बाइट्स

in v
?v$>1+d3,qds:3@cQm*
;\$o

इसे ऑनलाइन आज़माएं!

व्याख्या

1: प्रारंभ

in v

यह iनट को एक number में परिवर्तित करता है , फिर नीचे जाता है ( v)

2: लूप

?v$>1+d3,qds:3@cQm*
   >                 go right!              [n]
    1+               add 1                  [n+1]
      d3,            duplicate and mod 3    [n+1, (n+1)%3]
         qd          reverse and duplicate  [(n+1)%3, n+1, n+1]
           s         cast to string         [(n+1)%3, n+1, `n+1`]
            :3@c     count numbers of "3"   [(n+1)%3, n+1, `n+1`.count(3)]
                Qm*  negate and rotate      [n+1, continue?]
?v                   terminate if continue
  $                  drop continue

3: अंतिम

;\$o
 \$o  drop and output
;     terminate

— कोनोर ओ ब्रायन
स्रोत

1

बैच, 93 बाइट्स

@set/pn=
:l
@set/an+=1,r=n%%3
@if %r%==0 goto l
@if not "%n:3=%"=="%n%" goto l
@echo %n%

STDIN पर इनपुट लेता है।

— नील
स्रोत

1

CJam, 19 बाइट्स

ri{)__3%!\`'3e=e|}g

ऑनलाइन

स्पष्टीकरण:

ri{)__3%!\`'3e=e|}g
r                   Get token
 i                  Convert to integer
  {              }  Block
   )                 Increment
    _                Duplicate
     _               Duplicate
      3              Push 3
       %             Modulo
        !            NOT gate
         \           Swap
          `          String representation
           '3        Push '3'
             e=      Count occurrences
               e|    OR gate
                  g While popped ToS is true

यदि एक कम वर्बोज़ स्पष्टीकरण पूछा गया था, तो मैंने ऐसा किया होगा:

ri{)__3%!\`'3e=e|}g
ri                  Get integer
  {              }  Block
   )                 Increment
    __               Triplicate
      3%!            Test non-divisibility with 3
         \           Swap
          `'3e=      Count occurrences of '3' in string repr
               e|    OR gate
                  g While popped ToS is true

— आउटग्रॉफर को एरिक करें
स्रोत

1

पायथ, 19 बाइट्स

JhQW|!%J3/`J\3=hJ;J

परीक्षण सूट

मुझे यकीन है कि मैं इसे गोल्फ कर सकता हूं ... यह मेरे सीजाम के उत्तर के समान है।

स्पष्टीकरण:

JhQW|!%J3/`J\3=hJ;J
  Q                 Evaluated input
 h                  Increment
J                   Assign J to value
       J            Variable J
        3           Value 3
      %             Modulo
     !              Logical NOT
           J        Variable J
          `         String representation
            \3      Value "3"
         /          Count occurrences
    |               Logical OR
               h    Increment
                J   Variable J
              =     Apply function then assign
                 ;  End statement block
                  J Variable J

— आउटग्रॉफर को एरिक करें
स्रोत

मैंने एक तरह से छोटा समाधान पोस्ट किया। फिर भी यहाँ आपके दृष्टिकोण के लिए एक टिप है: चर का उपयोग न करें J। आप वेतन वृद्धि कर सकते हैं Q। और अगर आपका यह चालाक है, तो आप ऑपरेशन को इनलाइन स्थिति में कर सकते हैं: W|!%=hQ3/Q \ 3; Q`।

— याकूब '

क्षमा करें:W|!%=hQ3/`Q\3;Q

— 19

@Jakube चर केवल वृद्धि नहीं है, लेकिन धन्यवाद।

— आउटगोल्फर

1

क्लोजर, 73 बाइट्स

(fn c[n](let[m(inc n)](if(or(=(rem m 3)0)(some #(=\3 %)(str m)))(c m)m)))

पुनरावर्ती लूप जबकि n3 से विभाज्य है, या इसके स्ट्रिंग प्रतिनिधित्व में 3 शामिल है। हालांकि मैं अडॉप्ट किए गए पुनरावर्तन का उपयोग कर रहा हूं, यह एक इनपुट के रूप में 2999999 को संभालने में सक्षम था, इसलिए यह ठीक होना चाहिए।

Ungolfed

(defn count-without-3 [n]
  (let [m (inc n)]
    (if (or (= (rem m 3) 0)
            (some #(= \3 %) (str m)))
      (count-without-3 m)
      m)))

— Carcigenicate
स्रोत

3 के बिना गिनती

पृष्ठभूमि

कार्य

परीक्षण के मामलों

ब्रेकीलॉग , 10 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 30 बाइट्स

जे, 24 बाइट्स

प्रयोग

व्याख्या

पायथन 2, 73 66 43 बाइट्स

05AB1E , 11 बाइट्स

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

प्रयोग

जावा 8, 57 56 55 50 बाइट्स

जाप, 18 बाइट्स

यह काम किस प्रकार करता है

PowerShell v2 +, 46 बाइट्स

उदाहरण

आर, 46 बाइट्स

पायथन 2, 49 44 42 बाइट्स

लुआ, 58 बाइट्स

पाइके, 13 बाइट्स

सी #, 56 , 51 बाइट्स।

हास्केल, 50 48 बाइट्स

अजगर, 11 बाइट्स

स्पष्टीकरण:

गोल्फशार्प , 43 बाइट्स

रूबी, 47 बाइट्स

MATL , 14 बाइट्स

व्याख्या

भूलभुलैया , 117 102 बाइट्स

PHP, 60 55 54 46 बाइट्स

PHP, 47 41 बाइट्स

APL (Dyalog Unicode) , 33 28 27 19 बाइट्स SBCS

APL (Dyalog Extended) , 23 17 बाइट्स SBCS

पर्ल 6 , 27 25 24 बाइट्स

स्पष्टीकरण:

सी, 81 बाइट्स

जालीदार, 30 बाइट्स

व्याख्या

1: प्रारंभ

2: लूप

3: अंतिम

बैच, 93 बाइट्स

CJam, 19 बाइट्स

पायथ, 19 बाइट्स

क्लोजर, 73 बाइट्स

APL (Dyalog Unicode) , 33 28 27 19 बाइट्स ^SBCS

APL (Dyalog Extended) , 23 17 बाइट्स ^SBCS