फाइबोनैचि की सेक्सैजिमल्स

Question

लियोनार्डो दा पिसानो उर्फ फाइबोनैचि हिंदू-अरबी अंक प्रणाली को यूरोप में लाने में सहायक थे। इससे पहले, वहाँ गणितज्ञों ने रोमन अंकों के साथ आधार साठ में काम किया था।

उदाहरण के लिए, दो के वर्गमूल को इस प्रकार समझा जा सकता है: साठ के चौबीस भाग और तीन-हजार-छः सौ में से इक्यावन भाग , और इस प्रकार लिखा जाता है: i xxiv li , संदर्भ द्वारा निर्धारित स्केलिंग के साथ। उस समय, "शून्यता" ज्ञात था ( अर्थात शून्य), लेकिन इस संख्या प्रणाली में कोई मानक प्रतिनिधित्व नहीं था।

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

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

आउटपुट ऊपरी या निचले मामले में हो सकता है, और इन सुधारों को शामिल करना चाहिए:

• का उपयोग एन या एन इंगित करने के लिए अशक्त एक जगह अर्थ का कोई मूल्य नहीं है, यानी "शून्य" (सिस्टम के साथ एक समस्या)
• का उपयोग ई या ई इंगित करने के लिए एट सेक्साजेसिमल बात करने के लिए (सिस्टम के साथ एक और समस्या) इसी
• रोमन अंकों के समूहों को अलग करने के लिए एक मध्य बिंदु · या एक तारांकन * का उपयोग करें (फिर भी सिस्टम के साथ एक और समस्या)

मान लें कि इनपुट फ़्लोटिंग पॉइंट होगा जिसमें मंटिसा लिक्स · लिक्स · लिक्स · लिक्स · लिक्स से अधिक नहीं होगी । N · e · n · n · n · n · i से कम अंशों को अनदेखा किया जा सकता है। तो, प्रदान की साथ एक इनपुट रोमन अंकों के सबसे दस समूहों में इन प्रतिबंधों, है ई outputted जा सकता है।

संदर्भ स्पष्ट है यह सुनिश्चित करने के लिए मेरे पास कम संख्या में एक अग्रणी n · e होना चाहिए ।

कुछ उदाहरण: input→ आउटपुट

• 0→ n
• 1→ मैं
• 60→ i · n
• 0.1→ n · e · vi
• 3600→ i · n · n
• 10.5→ x · e · xxx
• 16777215→ i · xvii · xl · xx · xv
• 3.1415926536→ iii · e · viii · xxix · xliv · n · xlvii

आउटपुट को अनावश्यक अग्रणी n से बचना चाहिए । मैन्टिसा भाग में, अलग-अलग ई , या आउटपुट के आंशिक भाग में एन को पीछे छोड़ना चाहिए । इसलिए उदाहरण के लिए, n · n · n · n · i , i · e , और i · e · n · n · n · n · n गलत इनपुट के लिए आउटपुट हैं 1।

उत्पादन में प्लस या माइनस n · e · n · n · n · n · i का अंतर सहिष्णुता और स्वीकार्य के भीतर है।

इनपुट आपकी पसंद की भाषा में कोई भी कानूनी फ़्लोटिंग पॉइंट है, इसलिए सकारात्मक या नकारात्मक घातांक को तब तक शामिल कर सकते हैं जब तक इनपुट ऊपर निर्दिष्ट सीमा से बाहर न हो।

और अंत में, रोमन अंक बिल्ट-इन की अनुमति है!

Comments

जितना मैं इतिहास से प्यार है, फिबोनैकी विशेष रूप से फाइबोनैचि अनुक्रम के लिए आरक्षित है, आप बदलना चाहते हैं जब तक टैग विकि ...

— एडिसन Crump

टैग "लियोनार्डो फाइबोनैचि के लिए जाना जाता है, जो ज्यादातर रिट्रेसमेंट अनुक्रम (0, 1, 1, 2, 3, 5, 8, 13, ...) के लिए जाना जाता है।"

मुझे लगता है कि इस चुनौती के बारे में थोड़ी जानकारी होनी चाहिए कि रोमन अंक कैसे काम करते हैं और इस प्रक्रिया में केवल आत्म-निहित होना शामिल है।

— लियाम

वह अभीष्ट उपयोग नहीं है। मैंने इसे दर्शाने के लिए टैग विकी अंश संपादित किया है।

— डेनिस

Answer 1

पायथन 3, 323 319 320 बाइट्स

यह उत्तर फैबोनैचि के लिंगानुपात को परिसीमन के साथ लागू *करता है और रोमन अंकों की सूची में (अब, कम से कम) कोलमोगोरोव जटिलता के संबंध के बिना। प्रयास में शामिल होने के किए गए थे whileऔर forपाश जिसके तहत रोमन अंकों एक पाश के तहत उत्पन्न कर रहे हैं, लेकिन उन प्रयासों के अभी तक सफलता के साथ नहीं मिले हैं। किसी भी गोल्फिंग सुझावों और सुझावों का स्वागत और सराहना की जाती है।

संपादित करें: बग फिक्सिंग और गोल्फिंग।

संपादित करें: अधिक बग फिक्सिंग।

def f(x):
 v=divmod;f=x%1;n=int(x);d=",I,II,III,IV,V,VI,VII,VIII,IX".split(",");t=",X,XX,XXX,XL,L".split(",");z=["N"];a=f>0;s=z*0**n+["E"]*a
 while n:n,m=v(n,60);j,k=v(m,10);s=[z,[t[j]+d[k]]][m>0]+s
 for i in range(5*a):m,f=v(f*60,1);j,k=v(int(m),10);s+=[z,[t[j]+d[k]]][m>0]
 while s[-1:]==z*a:s.pop()
 return"*".join(s)

Ungolfed:

def f(x):
    integ = int(x)
    frac = x % 1
    units=",I,II,III,IV,V,VI,VII,VIII,IX".split(",")
    tens=",X,XX,XXX,XL,L".split(",")
    zero = ["N"]
    output = []
    a = frac != 0
    if integ == 0:
        output += z
    if a:
        output += ["E"]
    while integ > 0:
        integ, digit = divmod(integ, 60)
        j, k = divmod(int(digit), 10)
        if digit:
            output += [tens[j], units[k]]
        else:
            output += zero
    for i in range(5*a):
        digit, frac = divmod(frac*60, 1)
        j, k = divmod(int(digit), 10)
        if digit:
            output += [tens[j], units[k]]
        else:
            output += zero
    while output[-1:] == zero * a:
        output.pop()
    return "*".join(output)

Answer 2

सी - 584 बाइट्स

गैर-प्रतिस्पर्धी (स्पष्ट रूप से), लेकिन प्रेरणा के रूप में सेवा करने के लिए:

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
char*f(int z){static char r[8];char*l[]={"","I","II","III","IV","V","VI","VII","VIII","IX"},*h[]={"","X","XX","XXX","XL","L"};if(!z)return"N";sprintf(r,"%s%s",h[z/10],l[z%10]);return r;}int main(int c,char**v){char*s="";int i,j,z[10],k=60;long x;double d,y;y=modf(atof(v[1]),&d);x=d;for(i=4;i>=0;i--){z[i]=x%k;x/=k;}for(i=5;i<=9;i++){z[i]=(y*=k);y-=z[i];}for(i=0;!z[i]&&i<4;i++);for(;i<5;i++){printf("%s%s",s,f(z[i]));s="*";}for(j=9;!z[j]&&j>=i;j--);if(i<=j)printf("*E");for(;i<=j;i++)printf("*%s",f(z[i]));printf("\n");return 0;}

के रूप में सहेजें fs.c, साथ बनाएँ gcc -o fs fs.c -lm, और के रूप में चलाएँ./fs <arg> ।

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

$ ./fs 0
N
$ ./fs 1
I
$ ./fs 60
I*N
$ ./fs 0.1
N*E*VI
$ ./fs 3600
I*N*N
$ ./fs 10.5
X*E*XXX
$ ./fs 16777215
I*XVII*XL*XX*XV
$ ./fs 3.1415926536
III*E*VIII*XXIX*XLIV*N*XLVII

सबसे बड़ा मंटिसा और अंश:

$ ./fs 777599999
LIX*LIX*LIX*LIX*LIX
$ ./fs 0.999999998713992
N*E*LIX*LIX*LIX*LIX*LIX

मैं doubleकामकाजी प्रकार के रूप में उपयोग कर रहा हूं , इसलिए सबसे बड़ा मंटिसा और अंश संयुक्त उस प्रकार की मूल सटीकता से अधिक है। अगर मैं long doubleइसके बजाय इस्तेमाल करता तो इसे संभाल सकता था।

Comments

int mainलौटना नहीं है 0।

— Zacharý

Answer 3

हास्केल ( 333 322 315 बाइट्स)

मुझे यह स्पष्ट नहीं है कि जब मैं करता हूं या क्या ट्रंकेशन की अनुमति दी जाती है, तो अंतिम सेक्सेजिमल अंक को गोल किया जाना चाहिए या नहीं; मुझे लगता है कि पायथन 3 एक भी हो सकता है?

d n f 0=n;d n f x=f x
x!n=60*(x-fromInteger n)
f 0=[];f x=(\n->n:f(x!n))$floor x
l 0=[];l x=(\(d,m)->l d++[m])$divMod x 60
v=[50,40,10,9,5,4,1]
n&i|n==0=""|n>=v!!i=words"l xl x ix v iv i"!!i++(n-v!!i)&i|True=n&(i+1)
q=foldl1(\a x->a++'.':x).map(d"n"(&0))
p x=(\n->d"n"(q.l)n++d""((".e."++).q.take 5.f)(x!n))$floor x

-9 बाइट्स, धन्यवाद H.PWiz -2 बाइट्स समाप्त करने के whereलिए (\->)$, -5 और इस dफंक्शन का आविष्कार करके और गोल्फ के a++"."++xलिएa++'.':x ।)

Ungolfed:

-- this function gets called `d` for default
onZero :: (Eq n, Num n) => z -> (n -> z) -> n -> z
onZero def f x 
 | x == 0    = def
 | otherwise = f x 

-- this function gets called `f`
fracPart :: RealFrac a => a -> [Integer]
fracPart x
  | x == 0    = [] 
  | otherwise = n : fracPart (60 * (x - fromInteger n))
    where n = floor x

-- this function gets called `l`
leadPart :: Integral n => n -> [Integer]
leadPart x
  | x == 0    = [] 
  | otherwise = leadPart div ++ [ mod ]
    where (div, mod) = x `divMod` 60

-- these get called `v`
romanValues :: [Integer]
romanValues = [50, 40, 10, 9, 5, 4, 1]

-- these get inlined with `words`, and correspond to the values above
romanLetters :: [String]
romanLetters = ["l", "xl", "x", "ix", "v", "iv", "i"]

-- this becomes (&)
romanNumeralLoop :: Integer -> Int -> String
romanNumeralLoop n i
 | n == 0                  = "" 
 | n >= (romanValues !! i) = (romanLetters !! i) ++ romanNumeralLoop (n - (romanValues !! i)) i
 | otherwise               = romanNumeralLoop n (i + 1)

-- this becomes `q`
concatRomanWithDots :: [Integer] -> String
concatRomanWithDots numbers = concatWithDots (map toRoman numbers)
  where 
    toRoman = onZero "n" (\x -> romanNumeralLoop x 0)
    concatWithDots = foldl1 concatDot
    concatDot acc item = acc ++ "." ++ item

-- this becomes `p`
solve x = onZero "n" elseRomanizeLeadPart n ++ onZero "" elseRomanizeFracPart f
  where
    n = floor x
    f = 60 * (x - fromInteger n) 
    elseRomanizeLeadPart l = concatRomanWithDots (leadPart l)
    elseRomanizeFracPart f = ".e." ++ concatRomanWithDots (take 5 (fracPart f))

पूर्णांक को रोमन अंकों में बदलने की विधि को बेशर्मी से स्टैकऑवरफ्लो पर थॉमस अहले से चुराया गया था और बस थोड़ा सा गढ़ दिया गया था।

Comments

["l","xl","x","ix","v","iv","i"]हो सकता हैwords"l xl x ix v iv i"

— H.PWiz

@ H.PWiz धन्यवाद, शामिल!

— सीआर ड्रॉस्ट