22

3 पूर्णांकों को देखते हुए, तीसरे में गुणा करने के लिए पहले दो पूर्णांकों के लिए न्यूनतम संभव आधार निर्धारित करें। यदि आप जीवन के अंतिम प्रश्न, ब्रह्मांड और सब कुछ के उत्तर के बारे में सोचते हैं, तो 6 * 9 == 42, बेस 13 में सच है।

इनपुट में ऐसे नंबर शामिल हो सकते हैं जिनके अंक 0-9, az और AZ अक्षर का उपयोग करते हैं, जहां aबेस 10 में 10 के बराबर है, और Zबेस 10 में 61 है।

इनपुट आपको किसी भी तरह से इनपुट किए जाने चाहिए (हार्ड-कोडिंग को छोड़कर), और आप एक व्यक्तिगत फ़ंक्शन या संपूर्ण प्रोग्राम लिख सकते हैं।

माना जाने वाला अधिकतम आधार बेस 62 है, और न्यूनतम आधार बेस 2 है।

आप मान सकते हैं कि पहले दो मान तीसरे से छोटे हैं। आप यह भी निष्कर्ष निकाल सकते हैं कि न्यूनतम आधार इनपुट से उच्चतम अंक / वर्ण से एक है (उदाहरण के लिए, यदि इनपुट हैं 3 1a 55, तो न्यूनतम आधार बेस 11 होगा, क्योंकि aउच्चतम अंक है)।

यदि ऐसा कोई आधार नहीं है, तो अपनी पसंद का एक कबाड़ मूल्य लौटाएं।

यह कोड गोल्फ है, इसलिए सबसे छोटा कोड जीतता है।

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

6 9 42     -->   13
a a 64     -->   16
aA bB 36jk -->   41
2 3 20     -->   <junk value>
10 10 100  -->   2

code-golf number base-conversion

— erdekhayser
स्रोत

मुझे लगता है कि STDIN शायद बेहतर होगा, और या तो ठीक होगा।

— erdekhayser

@ मार्टिनबटनर तो क्या मुझे किसी भी रूप में इनपुट की अनुमति देनी चाहिए?

— erdekhayser

1

स्पष्टीकरण के एक बिंदु के रूप में क्या किया जाना चाहिए यदि कई आधार वैध हैं जैसे कि आपका अंतिम उदाहरण (जिसे अब हटा दिया गया है - यह 10 * 10 = 100 था) जहां यह आधार 10 में भी मान्य है और वास्तव में किसी अन्य आधार पर आप परवाह करते हैं उल्लेख ...

— क्रिस

1

@Kay अगर मैं bसामान्य तरीके से आधार में स्थितीय प्रणाली को परिभाषित करता हूं a_0 b^0 + a_1 b^1 + a_2 b^2 + ...( जैसे कि a_0आधार 1 से कम महत्वपूर्ण अंक है) निश्चित रूप से समझ में आता है। इसके अलावा, ओपी के निष्कर्ष में खोज में आधार 1 भी शामिल होगा यदि सबसे बड़ा वर्तमान अंक 0. है

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

2

आधार 1 के बारे में, यूनिरी एक संख्या प्रणाली है। en.m.wikipedia.org/wiki/Unary_numeral_system

— erdekhayser

3

CJam, 52 51 48 बाइट्स

63,{_ea{i32b~\([G-35-9]=-_Xe>:X;}f%fbW%~*=\X>*}#

इसका परीक्षण यहां करें। ऑनलाइन परीक्षक ARGV के माध्यम से इनपुट का समर्थन नहीं करता है। निकटतम विकल्प 6 9 42एसटीडीआईएन में इनपुट डालना और उपयोग करना है:

lS/:E;
63,{_E{i32b~\([G-35-9]=-_Xe>:X;}f%fbW%~*=\X>*}#

यह प्रिंट -1अगर कोई वैध आधार 62 तक नहीं मिल सकता है।

पीटर के लिए अंक पार्सिंग कोड के लिए बहुत धन्यवाद!

मैंने बहुत सी समस्याएं तय कीं जिन्होंने गिनती में 14 बाइट्स जोड़े। निम्नलिखित स्पष्टीकरण अभी भी मेरे मूल प्रस्तुत करने के लिए है, और मैं इसे कल कुछ समय के लिए अपडेट करूंगा।

63,{_ea{i32b~\([G-35-9]=-_Xe>:X;}f%fbW%~*=\X>*}#
63,                                              "Push the array [0 1 .. 62].";
   {                                          }# "Find the first index for which the block returns
                                                  a truthy value.";
    _                                            "Duplicate the current base.";
     ea                                          "Read ARGV into an array of strings.";
       {                        }f%              "Apply this block to each character.";
        i32b                                     "Convert to code point, and then to base-32. The
                                                  most significant digit now identifies the 'type'
                                                  of digit.";
            ~\(                                  "Unwrap the array. Swap the digits. Decrement.";
               [G-35-9]                          "Push array [16 -35 -9] of digit offsets.";
                       =-                        "Select the relevant offset and subtract it from 
                                                  the least significant digit.";
                         _                       "Duplicate the current digit D.";
                          Xe>:X;                 "X := max(X,D). X is predefined as 1.";
                                   fb            "Convert all numbers to the current base.";
                                     W%          "Reverse the list of numbers.";
                                       ~         "Unwrap the array.";
                                        *=       "Multiply factors. Check equality with product.";
                                          \      "Swap result with current base.";
                                           X>    "Ensure base is greater than X.";
                                             *   "Multiply boolean results.";

कार्यक्रम के अंत में सूचकांक स्वचालित रूप से मुद्रित होता है।

— मार्टिन एंडर
स्रोत

जीएस में अंकों को पार्स किया जा सकता है 32base~\[-16.35 9]=+। मुझे पता है कि CJam का आधार रूपांतरण कम है।

— पीटर टेलर

7

एपीएल (Dyalog यूनिकोड) , 30 बाइट्स ^SBCS

⊢{3⊃e=×/2↑e←⍵⊥⍺:⍵⋄⍺∇⍵+1}1+⌈/∘,

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

मदद के लिए Adám को धन्यवाद।

स्पष्टीकरण:

⊢{3⊃e=×/2↑e←⍵⊥⍺:⍵⋄⍺∇⍵+1}1+⌈/∘, ⍝ 
⊢                              ⍝ left argument ⍺: the vector (do nothing)
                        1+⌈/∘, ⍝ right argument ⍵: our starting base.
                             , ⍝             start by flattening the matrix of arguments                               ⌈/   ⍝             reduce by max (find the highest number)
                            ∘  ⍝             compose both of these together
                        1+     ⍝             increment by one
 {         ⍵⊥⍺         }       ⍝ convert inputs to the current base
 {       e←            }       ⍝ store the converted values in 3
 {      2↑             }       ⍝ take the first 2 values
 {    ×/               }       ⍝ multiply them together (reduce-multiply)
 {  e=                 }       ⍝ compare with e (the converted inputs)
 {3⊃                   }       ⍝ only keep the result of the comparison with the 3rd element (expected result)
 {             :⍵      }       ⍝ if truthy, return the current base.
 {               ⋄     }       ⍝ otherwise...
 {                ⍺∇⍵+1}       ⍝ ...recurse with the base incremented

हम Inइनपुट को अधिक पैलेटेबल फॉर्मेट में प्राप्त करने के लिए , एक सहायक फ़ंक्शन का उपयोग करते हैं। अन्यथा इनपुट को 3 कॉलम का एक मैट्रिक्स प्राप्त होता है।

'3 9 42' उदाहरण के लिए (ऊपर-नीचे तो बाएं से दाएं पढ़ें) देंगे:

0 0 4
3 9 2

और इसके लिए 'aA bB 36jk'(यहां a10 है, b11 है, A36 है, आदि)

— Ven
स्रोत

2

अजगर 2 - 197 213

क्या एक राक्षस ... (CJam की तुलना में)

from string import*
I=raw_input()
x,y,z=I.split()
B=lambda s,b:sum(b**i*(digits+lowercase+uppercase).find(s[-i-1])for i in range(len(s)))
print([b for b in range(B(max(I),10)+1,62)if B(x,b)*B(y,b)==B(z,b)]+[0])[0]

दुर्भाग्य से intआधार रूपांतरण केवल 36 तक के ठिकानों को संभाल सकता है। इसलिए मुझे इसे स्वयं लागू करने की आवश्यकता है। ( यह अद्भुत समाधान देखें )

— फ़ाल्को
स्रोत

क्या यह सुनिश्चित करता है कि सबसे बड़े अंकों के बराबर या उससे कम आधार न लौटाया जाए?

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

@ मार्टिनबटनर: मुझे यकीन नहीं है। कम से कम स्पष्ट रूप से नहीं। क्या आपके पास एक परीक्षण मामला है जहां यह एक मुद्दा है? (वास्तव में, ओपी द्वारा परीक्षण मामलों को उत्पन्न करने पर ध्यान दिया जाना चाहिए ...)

— फाल्को

2 * 3 = 20 को आज़माएं जिसमें त्रुटि मामले में आधार 3 है। 3 टर्नरी अंक प्रणाली में एक अंक नहीं है।

— काय

2

सीजेएम, 53 बाइट्स

lA,s'{,97>+'[,65>+f#_$W=1e>)63,>_@Wa/W%f{fb~*=}1#\0+=

जैसे STDIN से तीन इनपुट लेता है

6 9 42

प्रिंट 0यदि किसी भी आधार में उत्पाद संभव नहीं है

इसे और आगे बढ़ाने की कोशिश करेंगे।

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

— अनुकूलक
स्रोत

1

जावास्क्रिप्ट (E6) 129 139

2 से 62 तक सभी आधारों का पुनरावर्ती प्रयास करें, -1 लौटाए यदि कोई मूल्य ठीक नहीं है।
जावास्क्रिप्ट parseInt फ़ंक्शन 36 तक बेस के साथ काम करता है, इसलिए अधिक से अधिक आधारों के लिए थोड़ी मदद की आवश्यकता होती है।
सावधान रहें, पैरामीटर x, y, z स्ट्रिंग्स हैं, संख्याएं नहीं।
यह जितना लगता है उससे कहीं ज्यादा मुश्किल है। पहले संस्करण में एक बुनियादी बग को इंगित करने के लिए मार्टिन का धन्यवाद।

F=(x,y,z,b=2,N=n=>[for(d of(t=0,n))t=(v=parseInt(d,36)+(d>'@'&d<'a')*26)<b?t*b+v:NaN]&&t)=>b<63?N(x)*N(y)!=N(z)?F(x,y,z,b+1):b:-1

कम गोल्फ वाला

F=(x,y,z,b=2,
   D=d=>parseInt(d,36)+(d>'@'&d<'a')*26, // parse a single digit
   N=n=>[for(d of(t=0,n))t=(v=D(d))<b?t*b+v:NaN]&&t // parse a string
)=>b<63?N(x)*N(y)!=N(z)?F(x,y,z,b+1):b:-1

फायरफॉक्स / फायरबग कंसोल में टेस्ट ।
परीक्षण विभिन्न आधारों के साथ 1000 की संख्या की कोशिश करता है (36 तक, 62 नहीं)। यह ध्यान देने योग्य है कि पाया गया आधार सही हो सकता है लेकिन परीक्षण मामले को उत्पन्न करने वाले आधार से कम हो सकता है।

for(i=0;i<1000;i++)
{
   x=Math.random()*100|0,y=Math.random()*100|0,z=x*y,b=Math.random()*35+2|0
   bx=x.toString(b),by=y.toString(b),bz=z.toString(b),
   nb=F(bx,by,bz)
   nx=parseInt(bx,nb),ny=parseInt(by,nb),nz=parseInt(bz,nb)
   // if (nx*ny != nz) // uncomment to se output for errors only
     console.log(x,y,z,'base '+b,bx,by,bz, 'found base '+nb,nx,ny,nz,nx*ny)
}

— edc65
स्रोत

@ MartinBüttner पैरामीटर तार हैं (संभव मान एए बीबी 36jk की तरह कुछ हैं ...)। जवाब में स्पष्ट किया।

— edc65

ओह ठीक है, यह समझ में आता है।

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

1

चारकोल , 28 बाइट्स

Ｉ⌊Φ…⊕⍘⌈⁺⁺θηζ⁶²¦⁶³⁼×⍘θι⍘ηι⍘ζι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। Noneयदि कोई वैध आधार नहीं मिलता है तो आउटपुट । स्पष्टीकरण:

         θ                      First input
        ⁺                       Concatenated with
          η                     Second input
       ⁺                        Concatenated with
           ζ                    Third input
      ⌈                         Maximum character (by ordinal)
     ⍘                          Converted from base
            ⁶²                  Literal 62
    ⊕                           Incremented
   …                            Range up to
               ⁶³               Literal 63
  Φ                             Filtered by
                    θ           First input
                   ⍘            Converted from base
                     ι          Current value
                  ×             Multiplied by
                       η        Second input
                      ⍘         Converted from base
                        ι       Current value
                 ⁼              Equals
                          ζ     Third input
                         ⍘      Converted from base
                           ι    Current value
 ⌊                              Minimum
Ｉ                               Cast to string
                                Implicitly print

— नील
स्रोत

क्या TIO प्रोग्राम करना संभव है जो आपके द्वारा पोस्ट किए गए वास्तविक कोड का उपयोग करता है?

— mbomb007

@ mbomb007 आप इसे ऑनलाइन आज़मा सकते हैं ! लेकिन एएसटी जनरेटर लगता है लगता ⍘है Anyकिसी कारण के लिए ...

— नील

0

एरलैंग (एस्क्रिप्ट) - 200

main(X)->m(2,X).
m(63,_)->0;m(C,X)->try[F,G,I]=[c(0,C,Y)||Y<-X],I=F*G,io:fwrite("~p",[C])catch _:_->m(C+1,X)end.
c(A,B,[H|T])->D=H-if$A>H->$0;$a>H->29;0<1->87end,if D<B->c(A*B+D,B,T)end;c(A,_,_)->A.

दो प्रमुख न्यूलाइन्स जोड़ें, जो मौजूद होनी चाहिए।

पठनीय में:

#!/usr/bin/env escript

main(Args) -> test(2, Args).

test(63, _) -> 0;
test(Base, Args) ->
    try
        [Factor1, Factor2, Product] = [convert(0, Base, Arg) || Arg <- Args],
        Product = Factor1 * Factor2,
        io:fwrite("~p", [Base])
    catch _:_ ->
        test(Base + 1, Args)
    end.

convert(Accumulator, Base, [Head|Tail]) ->
    Digit = Head - if Head < $A -> $0;
                      Head < $a -> $A - 10 - 26;
                      true      -> $a - 10
                   end,
    if Digit < Base ->
        convert(Accumulator * Base + Digit, Base, Tail)
    end;
convert(Accumulator, _, _) -> Accumulator.

मंगलाचरण:

$ escript x.erl 6 9 42
13
$ escript -i x.erl a a 64
16
$ escript -i x.erl aA bB 36jk
41
$ escript -i x.erl 2 3 20
(no output)
$ escript -i x.erl 10 10 100
2

— Kay
स्रोत

क्या यह सुनिश्चित करता है कि आधार को सबसे बड़े अंकों से कम या उसके बराबर नहीं लौटाया जाए?

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

हाँ, if Digit < Base -> … endभाग इसकी देखभाल करता है। यदि किसी ifब्लॉक की कोई सच्ची शाखा नहीं है, तो एक अपवाद फेंका जाता है, जो पकड़ में आ जाता है try … catch _:_ -> … end।

— काय

0

हास्केल 216 चार (177?)

जितना संभव हो सके गोल्फ के लिए यह प्रयास किया। यदि आयात को गिना जाता है, तो यह मेरा सबसे छोटा कोड है (216)

import Data.Char
import Data.List
m=maximum
j[]=0;j(x:_)=x
f=reverse.map(\x->ord x-48)
g[]_=0;g(m:n)x=m+x*g n x
main=do
l<-getLine
let k@[x,y,z]=words l
print$j[n|n<-[2..62],g(f x)n*g(f y)n==g(f z)n,n>(m.map(m.f)$k)]

हालांकि, आयातों की गणना नहीं की गई थी, तो यह मेरा सबसे अच्छा संस्करण है (177):

import Data.Char
import Data.List
import Control.Applicative
m=maximum
j[]=0;j(x:_)=x
f=reverse.map(\x->ord x-48)
g[]_=0;g(m:n)x=m+x*g n x
main=words<$>getLine>>= \k@[x,y,z]->print$j[n|n<-[2..62],g(f x)n*g(f y)n==g(f z)n,n>(m.map(m.f)$k)]

यह प्रत्येक संख्या को एक बहुपद P (x) के रूप में मानता है जहां x आधार है, इस शर्त पर कि कोई गुणांक x से बड़ा नहीं है; मैं तब प्रत्येक संभावित आधार पर बहुपदों का मूल्यांकन करता हूं, जब मैं एक समानता (पी) (x) * Q (x) = R (x) को संतुष्ट करता है, तो मैं पहुंचता हूं। 'आधार सबसे बड़े अंकों से बड़ा है' नियम को पैटर्न मैच में अंतिम गार्ड के साथ लागू किया गया है n>(m.map(m.f)$k)। मुझे पता है कि अलग-अलग गोल्फिंग चुनौतियां और अलग-अलग चैलेंज-मेकर्स के पास अलग-अलग नीतियां हैं जो आयात के बारे में एक-एक स्कोरिंग करती हैं, इसलिए दूसरे को नमक के दाने के साथ लें।

— archaephyrryx
स्रोत

समाधान क्रमशः 216 और 177 बाइट्स / वर्ण हैं। लेकिन दूसरा समाधान अमान्य है, क्योंकि आयात की गणना तब तक की जाती है जब तक कि ओपी स्पष्ट रूप से निर्दिष्ट नहीं करता है, जो कि यहां तक मामला नहीं है जहां तक मैं बता सकता हूं।

— nyuszika7h

0

प्रोलोग - 195 बाइट्स

मूल रूप से मेरे Erlang जवाब के रूप में एक ही विचार:

:-use_module(library(main)).
main(A):-between(2,62,B),maplist(x(B),A,[F,G,P]),0is F*G-P,write(B).
c(I,B,Q,O):-Q=[H|T]->(H<65->D=48;H<97->D=29;D=87),H-D<B,c(I*B+H-D,B,T,O);O=I.
c(B)-->name,c(0,B).

पठनीय में:

:- use_module(library(main)).

main(Args) :-
    between(2, 62, Base),
    maplist(convert(Base), Args, [Factor1, Factor2, Product]),
    0 is Factor1 * Factor2 - Product,
    write(Base).

convert(Accumulator, Base, List, Output) :-
    List = [Head|Tail] ->
        (   Head < 65 -> Offset = 48;
            Head < 97 -> Offset = 29;
                         Offset = 87),
        Head - Offset < Base,
        convert(Accumulator * Base + Head - Offset, Base, Tail, Output);
    Output = Accumulator.

convert(Base, Input, Output) :-
    name(Input, List),
    convert(0, Base, List, Output).

मंगलाचरण:

$ swipl -qg main x.pl 6 9 42
13
$ swipl -qg main x.pl aA bB 36jk
41
$ swipl -qg main x.pl 2 3 20
ERROR: Unknown message: goal_failed(main([2,3,20]))

— Kay
स्रोत

आधार निर्धारित करें जहां एक दिया गया समीकरण सत्य है

CJam, 52 51 48 बाइट्स

एपीएल (Dyalog यूनिकोड) , 30 बाइट्स SBCS

अजगर 2 - 197 213

सीजेएम, 53 बाइट्स

जावास्क्रिप्ट (E6) 129 139

चारकोल , 28 बाइट्स

एरलैंग (एस्क्रिप्ट) - 200

हास्केल 216 चार (177?)

प्रोलोग - 195 बाइट्स

एपीएल (Dyalog यूनिकोड) , 30 बाइट्स ^SBCS