सभी बुनियादी बाइनरी के बारे में

29

कृपया शीर्षक शीर्षक का बहाना करें।

यह एक प्रश्न 82000 की ए क्यूरियस प्रॉपर्टी से प्रेरित है । इसमें, लेखक इंगित करता है कि 82000 संख्या 2, 3, 4, और 5 में बाइनरी है। पोस्ट तब सवाल पूछता है "एक संख्या है जो आधार 2, 3, 4, 5 और 6 में द्विआधारी है "? (उन उत्सुक लोगों के लिए, मैंने 10 ^ 1,000,000 तक मानों की जाँच की है और अब तक इसका उत्तर नहीं है।)

यह मुझे सोच में पड़ गया: एक नंबर दिया, यह किस आधार पर द्विआधारी है?

हमारी उत्सुक संख्या, 82000, वास्तव में छह आधारों में द्विआधारी है:

Base 2 = 10100000001010000
Base 3 = 11011111001
Base 4 = 110001100
Base 5 = 10111000
Base 81999 = 11
Base 82000 = 10

सभी नंबरों में बाइनरी बेस नहीं होंगे जो अनुक्रमिक हैं। संख्या 83521 पर विचार करें। यह 2, 17, 289, 83520 और 83521 आधारों में द्विआधारी है।

आपकी चुनौती यह निर्धारित करना और प्रदर्शित करना है कि कौन सा आधार एक संख्या में द्विआधारी है।

नियम

  • किसी दिए गए आधार में एक संख्या को "बाइनरी" माना जाता है यदि उस आधार में इसका प्रतिनिधित्व केवल शून्य और लोगों का होता है। 110110एक द्विआधारी मूल्य है, जबकि 12345नहीं है, A380Fनिश्चित रूप से नहीं है।
  • आपका नंबर मानक इनपुट पर प्रदान किया जाएगा। यह 2 और 2 ^ 32-1 के बीच पूर्णांक मान होगा और इसे बेस -10 प्रारूप में प्रदान किया जाएगा।
  • आरोही क्रम में, प्रत्येक आधार को एक से अधिक प्रदर्शित करें जो संख्या द्विआधारी है। प्रत्येक आधार अपनी लाइन पर होना चाहिए। यदि आप उस आधार में बाइनरी मान शामिल करते हैं (नीचे बोनस स्कोरिंग देखें), आधार और बाइनरी मान को एक स्थान के साथ अलग करें। केवल मानक आउट के आउटपुट को आंका जाएगा, मानक त्रुटि और अन्य स्रोतों को अनदेखा किया जाएगा।

स्कोरिंग

आपका स्कोर बाइट्स में आपके प्रोग्राम का आकार है। स्कोर जितना कम होगा, उतना अच्छा होगा।

बोनस :
यदि आपका प्रोग्राम पाया गया आधारों में द्विआधारी मूल्यों को भी आउटपुट करता है, तो अपने स्कोर को 0.75 से गुणा करें।
आपके प्रदर्शित बाइनरी मूल्य में कोई अतिरिक्त विराम चिह्न नहीं होना चाहिए, कोई बाहरी ज़ीरो नहीं होना चाहिए, कोई दशमलव बिंदु नहीं है, बस ज़ीरो और हैं।

उदाहरण

इनपुट:

82000

आउटपुट (बोनस प्राप्त करता है):

2 10100000001010000
3 11011111001
4 110001100
5 10111000
81999 11
82000 10

इनपुट:

1234321

आउटपुट (कोई बोनस नहीं):

2
1111
1234320
1234321
code-golf  math  number  base-conversion 
— श्री लामा
स्रोत
क्या इनपुट एक नई सीमा के साथ समाप्त हो सकता है?
— लेजियन मम्मल 978
@ LegionMammal978 - उह ... निश्चित? मेरा आशय यह था कि आप एक साधारण फ़िज़ूल, रीडलाइन या कुछ समान के साथ इनपुट नंबर प्राप्त करने में सक्षम होना चाहिए।
— श्री ललाम
1
सामान्य तौर पर, nहमेशा अड्डों में कम से कम द्विआधारी है 1(नहीं गिना), 2, n-1, और n।
— mbomb007
1
जब आप कहते हैं, "आपका नंबर मानक इनपुट पर प्रदान किया जाएगा," क्या आपका मतलब केवल एसटीडीआईएन है, या हम वैकल्पिक रूप से नंबर को फ़ंक्शन तर्क के रूप में स्वीकार कर सकते हैं जो साइट के लिए मानक है?
— एलेक्स ए।
क्या बाइनरी प्रतिनिधित्व (बोनस भाग में) का एक निश्चित प्रारूप होना चाहिए? विशेष रूप [1, 0, 1, 1, 0]से ठीक होगा , या संख्याओं को शामिल करना होगा 10110?
— जेक्यूब

जवाबों:

14

अजगर, १४ १३

jbf!-jQTU2tSQ

नए Sफ़ंक्शन को इंगित करने के लिए जकुबे का धन्यवाद ।

इसे यहाँ आज़माएँ।

ऑनलाइन संस्करण करना बहुत धीमा है 1234321। यह बस प्रत्येक बेस को 2 से इनपुट में परिवर्तित करता है और उन परिणामों को छोड़ता है जिनमें 0 और 1 के अलावा अन्य मान होते हैं।

स्पष्टीकरण:

                           : Q=eval(input) (implicit)
jb                         : join on newlines the list...
  f!                       : filter away nonempty values (impliticly named T)
    -jQTU2                 : sewtise difference of number converted to base and range(2)
     jQT                   : convert Q to base T
        U2                 : range(2)
          tSQ              : over the range [2 Q+1)

इसके अलावा, यह एक ( अच्छी तरह से अब अच्छी तरह से गोल्फ नहीं है, फिर से जेक्यूब के लिए धन्यवाद) बोनस संस्करण (20/75-15): है।

VQI!-JjQK+2NU2pdKjkJ

इसे यहाँ आज़माएँ

— FryAmTheEggman
स्रोत
पायथ सिर्फ अपडेट हो गया। तो आप वास्तविक समाधान से लिंक कर सकते हैं।
— जकुबे
और यहां 20 * 0.75 = 15 समाधान है: VQI!-JjQK+2NU2pdKjkJकभी-कभी कार्यात्मक प्रोग्रामिंग सबसे अच्छा तरीका नहीं है।
— जकुबे
10

जूलिया, 72 70 बाइट्स

यह वास्तव में बोनस के साथ लंबा है, इसलिए यहां कोई बोनस नहीं है।

n=int(readline());for j=2:n all(i->i∈0:1,digits(n,j))&&println(j)end

यह STDIN की एक पंक्ति को पढ़ता है, इसे एक पूर्णांक में परिवर्तित करता है, और परिणाम को प्रिंट करता है। एक क्रूर बल विधि होने के बावजूद, इनपुट 1234321 ने मेरे लिए 1 सेकंड से भी कम समय लिया।

असंगठित + स्पष्टीकरण:

# Read n from STDIN and convert to integer
n = int(readline())

# For every potential base from 2 to n
for j = 2:n
    # If all digits of n in base j are 0 or 1
    if all(i -> i ∈ 0:1, digits(n, j))
        # Print the base on its own line
        println(j)
    end
end

उदाहरण:

julia> n=int(readline());for j=2:n all(i->i∈0:1,digits(n,j))&&println(j)end
1234321
2
1111
1234320
1234321

julia> n=int(readline());for j=2:n all(i->i∈0:1,digits(n,j))&&println(j)end
82000
2
3
4
5
81999
82000

नोट : यदि इनपुट STDIN (ओपी से पुष्टि की प्रतीक्षा) के बजाय एक फ़ंक्शन तर्क के रूप में लिया जा सकता है, तो समाधान 55 बाइट्स है।

— एलेक्स ए।
स्रोत
7

CJam, 20 बाइट्स (या 27 बाइट्स * 0.75 = 20.25)

यहाँ कोई बोनस संस्करण नहीं है, 20 बाइट्स:

ri:X,2f+{X\b2,-!},N*

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

बस मज़े के लिए, यहाँ बोनस संस्करण है, 27 बाइट्स:

ri:X{X\)b2,-!},1>{)SX2$bN}/

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत
ज़रूर। एक बार जब मैं थोड़ा गोल्फ का काम कर रहा हूं।
— ऑप्टिमाइज़र
1
ri_,f{2+S@2$bN}4/{2=2,-!},(19.5 बाइट्स)
— डेनिस
7

गणितज्ञ, 59 बाइट्स

Print/@Select[1+Range[n=Input[]],Max@IntegerDigits[n,#]<2&]

ऊ ... IntegerDigitsडी:

कोड के बारे में समझाने के लिए वास्तव में बहुत कुछ नहीं है ... 12 बाइट्स एसटीडीआईएन और एसटीडीयूएसटी का उपयोग करने की आवश्यकता से बर्बाद हो जाते हैं।

मुझे नहीं लगता कि मैं बोनस का दावा कर सकता हूं। मेरे पास सबसे अच्छा 84 बाइट्स है (जो 60 से अधिक स्कोर देता है):

Print@@@Select[{b=#+1," ",##&@@n~IntegerDigits~b}&/@Range[n=Input[]],Max@##3<2&@@#&]
— मार्टिन एंडर
स्रोत
7

पायथन 2, 88 86 80

बहुत सीधा, कोई बोनस नहीं। पायथन अच्छा है और वैश्विक चर के साथ उदार है।

N=input();g=lambda n:n<1or(n%b<2)*g(n/b)
for b in range(2,N+1):
 if g(N):print b

सबसे अच्छा मैं बोनस के लिए प्राप्त करने में कामयाब रहा 118 * .75 = 87.75 :

N=input();g=lambda n:0**n*" "or" "*(n%b<2)and(g(n/b)+`n%b`)*(g(n/b)>'')
for b in range(2,N+1):
 if g(N):print`b`+g(N)
— KSab
स्रोत
अच्छा समाधान, मुझे बहुत कम कोड के साथ इसे हराया।
— काडे
इसके g(N)बजाय सिर्फ करना कम होगा n=N।
— feersum
@ फ़ेर्सम ओह ये (यह g(N,b)ऐसा हुआ करता था कि कॉमा ने दो को बराबर कर दिया), लेकिन आपका क्या मतलब है कि मुझे एन के लिए एक चर की आवश्यकता नहीं होगी?
— केसाब
@स्कैब मैंने उस दूसरे भाग को हटा दिया; कोई बात नहीं।
— feersum
मैं गलत हो सकता हूं, लेकिन क्या आप केवल 'बैकटिक' का प्रतिनिधित्व g(n/b)करने के लिए बदलकर बोनस नहीं प्राप्त कर सकते हैं (g(n/b)+'n%b')?
— feersum
4

पायथन 2, 90 * 0.75 = 67.5

n=input();b=1
while b<n:
 b+=1;s="";c=k=n
 while k:s=`k%b`+s;c*=k%b<2;k/=b
 if c:print b,s

बहुत सीधा चलने का तरीका।

बोनस के बिना, यह 73 बाइट्स है:

n=input();b=1
while b<n:
 b+=1;c=k=n
 while k:c*=k%b<2;k/=b
 if c:print b
— Sp3000
स्रोत
4

SQL (PostgreSQL), 247.5 255 230.25 (307 * .75)

चूंकि एसक्यूएल इस प्रकार की चुनौतियों के लिए अद्भुत माना जाता है, मैंने सोचा कि मैंने बेहतर एक साथ रखा है :) बोनस वास्तव में इस एक के लिए सार्थक था।
यह कल्पना के साथ पालन करना चाहिए, लेकिन मेरे पास स्टॉपिन से कॉपी आई का परीक्षण करने का कोई आसान तरीका नहीं है । निश्चित क्रम
संपादित करें । किसी सरणी का उपयोग करने के लिए स्तंभ R को जिस तरह से संभाला जाता है, उसे बदला।

CREATE TABLE IF NOT EXISTS I(I INT);TRUNCATE TABLE I;COPY I FROM STDIN;WITH RECURSIVE R AS(SELECT n,I/n I,ARRAY[I%n] R FROM generate_series(2,(SELECT I FROM I))g(n),(SELECT I FROM I)I(I)UNION ALL SELECT n,I/n,I%n||R FROM R WHERE I>0)SELECT n||' '||array_to_string(R,'')FROM R WHERE 2>ALL(R)and i=0ORDER BY n

परीक्षण के रूप में मैंने सिर्फ Iतालिका में सीधे आवेषण का उपयोग किया । टेस्ट रन का विस्तार और टिप्पणी की गई।

-- Create the table to accept the input from the copy command
CREATE TABLE IF NOT EXISTS I(I INT);
-- Make sure that it is empty
TRUNCATE TABLE I;
-- Popoulate it with a value from STDIN
--COPY I FROM STDIN;
INSERT INTO I VALUES(82000); -- Testing
--Using a recursive CTE query
WITH RECURSIVE R AS (
    -- Recursive anchor
    SELECT n,                -- base for the row
       I/n I,                -- integer division
       ARRAY[I%n] R   -- put mod value in an array
    FROM generate_series(2,(SELECT I FROM I))g(n), -- series for the bases
         (SELECT I FROM I)I(I) -- Cross joined with I,  saves a few characters
    UNION ALL 
    -- for each row from r recursively repeat the division and mod until i is 0
    SELECT n,
        I/n,
        I%n||R -- Append mod to beginning of the array
    FROM R WHERE I>0
    )
-- return from r where i=0 and r has 1's and 0's only
SELECT n||' '||array_to_string(R,'')
FROM R 
WHERE 2 > ALL(R)and i=0
ORDER BY n -- Ensure correct order

2 10100000001010000
3 11011111001
4 110001100
5 10111000
81999 11
82000 10

— MickyT
स्रोत
बहुत करीब! आउटपुट बेस को आरोही क्रम में होना चाहिए। हालांकि एक अपरंपरागत भाषा का उपयोग करने के लिए +1।
— श्री लामा
@ श्री लामा ने इसे ठीक कर दिया order by। अब देखना है कि क्या मैं उन किरदारों को वापस पा सकता हूं
— मिकट
3

हास्केल 109 * 0.75 = 81.75 बाइट्स

0#x=[]
n#x=n`mod`x:div n x#x 
f n=[show x++' ':(n#x>>=show)|x<-[2..n+1],all(<2)$n#x]
p=interact$unlines.f.read

उपयोग उदाहरण (नोट: द्विआधारी मान पहले lsb हैं):

p 82000

2 00001010000000101
3 10011111011
4 001100011
5 00011101
81999 11
82000 01

इनपुट / आउटपुट प्रतिबंधों के बिना, यानी फ़ंक्शन तर्क के माध्यम से इनपुट, आरईपीएल के माध्यम से मूल प्रारूप में आउटपुट):

हास्केल, 67 * 0.75 = 50.25 बाइट्स

0#x=[]
n#x=n`mod`x:div n x#x
f n=[(x,n#x)|x<-[2..n+1],all(<2)$n#x]

(आधार, मान) जोड़े की सूची लौटाता है। मान पहले lsb हैं, उदाहरण के लिए (newlines / रिक्त स्थान बेहतर प्रदर्शन के लिए जोड़े गए):

 f 82000
 [ (2,[0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,1]),
   (3,[1,0,0,1,1,1,1,1,0,1,1]),
   (4,[0,0,1,1,0,0,0,1,1]),
   (5,[0,0,0,1,1,1,0,1]),
   (81999,[1,1]),
   (82000,[0,1]) ]
— nimi
स्रोत
2

आर, 111

शायद इस समय इसे सुधारने के लिए बहुत जगह है

i=scan();b=2:i;R=i%%b;I=rep(i,i-1);while(any(I<-I%/%b))R=cbind(I%%b,R);for(x in b)if(all(R[x-1,]<2))cat(x,'\n')

चेतावनियों के साथ चलता है

> i=scan();b=2:i;R=i%%b;I=rep(i,i-1);while(any(I<-I%/%b))R=cbind(I%%b,R);for(x in b)if(all(R[x-1,]<2))cat(x,'\n')
1: 82000
2: 
Read 1 item
There were 17 warnings (use warnings() to see them)
2 
3 
4 
5 
81999 
82000
>
— MickyT
स्रोत
@AlexA। क्लॉज I%/%bमें एक तार्किक के लिए मजबूर करने के कारण चेतावनी any()। `
— मिकट
2

जावा, 181 155.25 (207 * .75) 151.5 (202 * .75) बाइट्स

class I{public static void main(String[]a){a:for(long b=new java.util.Scanner(System.in).nextLong(),c,d=1;d++<b;){String e="";for(c=b;c>0;e=c%d+e,c/=d)if(c%d>1)continue a;System.out.println(d+" "+e);}}}

स्पष्टीकरण के साथ विस्तारित:

class I {
    public static void main(String[]a){
        a:for(long b=new java.util.Scanner(System.in).nextLong(),c,d=1; //b = input(), d = base
              d++<b;) {                                           //For all bases in range(2,b+1)
            String e="";
            for(c = b;c > 0; e = c % d + e,c /= d)                //Test all digits of base-d of b
                           //e = c % d + e                        //Append digits to string
                if (c % d > 1)                                    //Reject base if the digit is greater than 1
                    continue a;
            System.out.println(d+" "+e);                          //Print base and digits.
        }
    }
}

मूल (बोनस के बिना):

class I{public static void main(String[]a){long b=new java.util.Scanner(System.in).nextLong(),c,d=1;a:for(;d++<b;){c=b;while(c>0){if(c%d>1)continue a;c/=d;}System.out.println(d);}}}

3.75 बाइट्स Ypnypn के लिए धन्यवाद :)

— नंबर एक
स्रोत
2

आर, 94 83 79

n=scan();cat((2:n)[!sapply(2:n,function(x){while(n&n%%x<2)n=n%/%x;n})],sep="\n")

उपयोग:

> n=scan();cat((2:n)[!sapply(2:n,function(x){while(n&n%%x<2)n=n%/%x;n})],sep="\n")
1: 82000
2: 
Read 1 item
2
3
4
5
81999
82000
> n=scan();cat((2:n)[!sapply(2:n,function(x){while(n&n%%x<2)n=n%/%x;n})],sep="\n")
1: 1234321
2: 
Read 1 item
2
1111
1234320
1234321

फ़ंक्शन का मूल है !sapply(2:n,function(x){while(n&n%%x<2)n=n%/%x;n}), जो प्रत्येक बेस x के लिए 2 से n तक है, भागफल n / x को तब तक रखें जब तक शेष या तो 0 है और 1. तब यह परिणाम को आउटपुट करता है (जो 0 है यदि सभी अवशेष 1 या तो थे 0) और इसे नकारता है (0 TRUE के लिए नकारात्मक है, बाकी सब FALSE के लिए नकारात्मक है)। फ़ंक्शन स्कोप के लिए धन्यवाद, n के लिए डमी वैरिएबल बनाने की कोई आवश्यकता नहीं है। बूलियन के परिणामस्वरूप वेक्टर का उपयोग तब अनुक्रमणिका के लिए किया जाता है 2:nऔर इसलिए केवल उन आधारों को आउटपुट करता है जिसके लिए यह काम करता था।

— plannapus
स्रोत
1

टीआई-बेसिक, 45 बाइट्स

Input N
For(B,2,N
If prod(seq(BfPart(iPart(N/B^X)/B),X,0,log(N)/log(B))<2
Disp B
End

व्याख्या

  • इनपुट एन
  • 2 से एन तक प्रत्येक बी के लिए
    • यदि N, आधार B में केवल 0 और 1 है
      • प्रदर्शन बी
  • अंत लूप

जटिल हिस्सा है

दूसरी पंक्ति इस प्रकार काम करती है:

  • 0 से हर X के लिए B N लॉग करें
  • B × fPart (iPart (N / B X ) / B) आधार B में Nth अंक है, जिसे पीछे की ओर गिना जाता है
  • इसे एक सूची के रूप में देखें
  • प्रत्येक तत्व के लिए, यदि अंक 2 से कम है, तो उपज 1 (सत्य), और 0 (गलत)
  • उत्पाद लें: 1 iff सभी तत्व 1 हैं

ध्यान दें

यदि एक समापन कोष्ठक )को दूसरी पंक्ति के अंत में रखा जाता है, तो कार्यक्रम काफी तेजी से चलता है । इसके बारे में अधिक जानकारी के लिए यहां देखें ।

— Ypnypn
स्रोत
1

टीआई-बेसिक, 31 29

For(B,2,Ans
If 2>round(Bmax(fPart(Ans/B^randIntNoRep(1,32
Disp B
End

यह शायद TI-BASIC के लिए इष्टतम है।

स्पष्टीकरण:

randIntNoRep(1,32)1 से 32 तक की संख्याओं का एक यादृच्छिक क्रमांकन लौटाता है (हमें जो कुछ भी चाहिए वह संख्या किसी क्रम में है; TI-BASIC के पास APL के iota कमांड की तरह कुछ भी नहीं है)। 32 तत्व पर्याप्त हैं क्योंकि सबसे छोटा संभव आधार 2 है और सबसे बड़ी संख्या 2 ^ 32-1 है। B^randIntNoRep(1,31)उस सूची को Bth पावर में ऊपर उठाता है, जिसके परिणामस्वरूप सूची सभी में B^1,B^2,...,B^32(किसी क्रम में) होती है।

फिर इनपुट (इन Ansवेरिएबल, जो कि फॉर्म में इनपुट है [number]:[program name]) को उस नंबर से विभाजित किया जाता है। यदि आपका इनपुट 42 है और आधार 2 है, तो परिणाम सूची में होगा 21,10.5,5.25,...,42/32,42/64,[lots of numbers less than 1/2], फिर से कुछ क्रम में।

भिन्नात्मक भाग लेना और संख्या को अपने आधार से गुणा करना बेस-बी प्रतिनिधित्व में उस स्थिति में अंक देता है। यदि सभी अंक 2 से कम हैं, तो सबसे बड़ा अंक 2 से कम होगा।

जैसा कि Ypnypn ने कहा, Forबयान पर एक बंद कोष्ठक एक पार्सर बग के कारण इसे गति देता है।

31-> 31: एक बाइट लेकिन निश्चित गोलाई त्रुटियों को सहेजा जो बाइट को फिर से जोड़ता है।

31-> 29: के RandIntNoRep()बजाय का उपयोग करके दो बाइट्स सहेजे गए cumSum(binomcdf())।

— lirtosiast
स्रोत
क्या TI-BASIC का अनुक्रम कार्य है?
— श्री ललाम
हाँ, आदेश है seq(expression, variable, start, end[, step])। यदि कोई स्टेप नहीं दिया गया है, तो यह 1 को डिफॉल्ट करता है। हालांकि, cumSum(binomcdf(31,08 बाइट्स है, जबकि seq(X,X,1,329 बाइट्स है।
— lirtosiast
आह, यह बताते हैं। मैं TI-Basic में स्कोरिंग कार्यों से परिचित नहीं हूँ।
— श्री लामा
1

जेली , 9 बाइट्स

³bṀỊµÐfḊY

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

चैट में कैयर सिक्काहेयराहिंग के साथ-साथ ।

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

³b³f³Y पूरा कार्यक्रम।

     Ðf अंतर्निहित उत्पन्न रेंज को फ़िल्टर करें [1, इनपुट]।
    ad एक नई मौद्रिक श्रृंखला शुरू करता है।
³b सूची के रूप में इनपुट को वर्तमान संख्या के आधार में परिवर्तित करें।
  Ṁ अधिकतम।
   Ant तुच्छ। अनुपस्थित (Z)) 1 की जाँच करता है।
       Ue Dequeue; सूची के पहले तत्व को हटाता है (आधार 1 को छोड़ने के लिए)।
        Y newlines द्वारा जुड़ें।
— श्री Xcoder
स्रोत
0

जावास्क्रिप्ट, ईएस 6, 118 * .75 = 88.5 110 * .75 = 82.5

f=x=>{res={};for(b=2;b<=x;++b)if(!+(res[b]=(c=x=>x%b<2?x?c(x/b|0)+""+x%b:"":"*")(x)))delete res[b];return res}

पुराना वर्जन:

f=x=>{res={};for(q=2;q<=x;++q)if(!+(res[q]=(c=(x,b)=>x%b<2?x?c(x/b|0,b)+""+x%b:"":"*")(x,q)))delete res[q];return res}

चेक:

f(82000)
Object { 2: "10100000001010000", 3: "11011111001", 4: "110001100", 5: "10111000", 81999: "11", 82000: "10" }
— Qwertiy
स्रोत
यहां आपके पास कोई इनपुट नहीं है और कोई आउटपुट नहीं है।
— edc65
0

जावास्क्रिप्ट ( ईएस 6 ) 65

एक पैरामीटर और कंसोल आउटपुट के साथ फ़ंक्शन के लिए 68 बाइट्स।

f=n=>{s=n=>n%b>1||b<n&&s(n/b|0);for(b=1;b++<n;)s(n)||console.log(b)}

पॉपअप के माध्यम से I / O के साथ 65 बाइट्स 

n=prompt(s=n=>n%b>1||b<n&&s(n/b|0));for(b=1;b++<n;)s(n)||alert(b)

बोनस का दावा: 88 * 0.75 => 66

n=prompt(s=n=>n%b>1?9:(b<=n?s(n/b|0):'')+n%b);for(b=1;b++<n;)s(n)<'9'&&alert(b+' '+s(n))
— edc65
स्रोत
0

गणितज्ञ, 76 * 0.75 = 57

n=Input[];G=#~IntegerDigits~b&;If[Max@G@n<2,Print[b," ",Row@G@n]]~Do~{b,2,n}

शुरू में इनपुट आवश्यकताओं के बारे में भूल गए ... सौभाग्य से, उन लोगों ने बहुत अधिक अतिरिक्त नहीं जोड़ा।

— गणना
स्रोत
0

पर्ल 5 , 63 बाइट्स

map{$t=$n;1while($f=$t%$_<2)&&($t=int$t/$_);say if$f}2..($n=<>)

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

इस पर कोई बोनस नहीं क्योंकि यह बोनस के साथ मेरे संस्करण की तुलना में बहुत थोड़ा बेहतर है:

पर्ल 5 , 85 बाइट्स * 0.75 = 63.75

map{my$r;$t=$n;$r=$/.$r while($/=$t%$_)<2&&($t=int$t/$_);say"$_ 1$r"if$/<2}2..($n=<>)

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

— Xcali
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.