Leonardo da Pisano หรือที่รู้จักว่า Fibonacci เป็นเครื่องมือสำคัญในการนำระบบตัวเลขฮินดู - อาหรับเข้าสู่ยุโรป ก่อนหน้านั้นนักคณิตศาสตร์มีการทำงานในฐานหกสิบกับตัวเลขโรมัน

ตัวอย่างเช่นรากที่สองของทั้งสองอาจประมาณว่า: หนึ่งและยี่สิบสี่ส่วนของหกสิบห้าสิบเอ็ดส่วนของสามพันหกร้อยและเขียนเป็น: i xxiv liโดยมีการกำหนดโดยบริบท ในเวลานั้น“ ไม่มีอะไร” เป็นที่รู้จัก ( เช่นศูนย์) แต่ไม่มีการแสดงมาตรฐานในระบบหมายเลขนี้

หากฟีโบนัชชีไม่สนใจตัวเลขทศนิยมใหม่ที่เขาพบระหว่างการเดินทางเขาจะต้องจัดการกับข้อบกพร่องในระบบปัจจุบันอย่างแน่นอน ระบบที่ปรับปรุงแล้วนี้เราจะเรียกเพศของฟีโบนักชี

งานของคุณคือการเขียนโปรแกรมฟังก์ชั่นหรือตัวอย่างของรหัสซึ่งใช้ตัวเลขทศนิยมในรูปแบบ ASCII หรือไบนารีและเอาท์พุทในฐานหกสิบตัวเลขโรมัน อินพุตสามารถเป็นไฟล์คอนโซลบรรทัดคำสั่งหรืออาร์กิวเมนต์ของฟังก์ชันและเอาต์พุตสามารถเป็นไฟล์หรือคอนโซลใดก็ได้ที่ง่ายที่สุด

เอาต์พุตสามารถเป็นตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็กและต้องรวมการปรับปรุงเหล่านี้:

• ใช้nหรือNเพื่อบ่งบอกว่าnullหมายถึงสถานที่ไม่มีค่าเช่น “ zero” (ปัญหาเกี่ยวกับระบบ)
• ใช้eหรือEเพื่อระบุและสอดคล้องกับประเด็นเรื่องเพศ (ปัญหาอื่นกับระบบ)
• ใช้จุดกึ่งกลาง·หรือเครื่องหมายดอกจัน * เพื่อแยกกลุ่มของตัวเลขโรมัน (ยังเป็นปัญหาของระบบ)

สมมติการป้อนข้อมูลที่จะได้รับการจุดลอยกับ mantissa ไม่เกินlix · lix · lix · lix · lix เศษส่วนน้อยกว่าn · e · n · n · n ·ฉันสามารถข้ามได้ ดังนั้นหากอินพุตมีข้อ จำกัด เหล่านี้กลุ่มของตัวเลขโรมันส่วนใหญ่ที่มีหนึ่งeสามารถส่งออกได้

ตัวเลขน้อยกว่าฉันจะต้องมีชั้นนำE n ·เพื่อให้แน่ใจว่าบริบทที่มีความชัดเจน

ตัวอย่างบางส่วน: เอาต์พุต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 ·ที่ไม่จำเป็นในส่วนแมนทิสซา, ตัวแยกeหรือต่อท้าย·ในส่วนที่เป็นเศษส่วนของเอาต์พุต ดังนั้นสำหรับตัวอย่างเช่นn · n · n · n ·ฉัน , ฉัน·อีและฉัน·อี· n · n · n · n · n1มีผลที่ไม่ถูกต้องสำหรับการป้อนข้อมูลของ

ความแตกต่างของการบวกหรือลบn · e · n · n · n · iในเอาต์พุตอยู่ภายในความคลาดเคลื่อนและยอมรับได้

อินพุตเป็นจุดลอยตัวทางกฎหมายในภาษาที่คุณเลือกดังนั้นสามารถรวมเลขชี้กำลังเป็นค่าบวกหรือลบได้ตราบใดที่อินพุตไม่อยู่นอกช่วงที่ระบุข้างต้น

และในที่สุดตัวเลขโรมันสร้างอินจะได้รับอนุญาต!

Python 3, 323 319 320 bytes

คำตอบนี้ใช้การแยกเพศของฟีโบนักชีโดยใช้ตัวคั่น*และไม่คำนึงถึงความซับซ้อนของโคลโมโกรอฟในรายการตัวเลขโรมัน (อย่างน้อยก็ตอนนี้) มีความพยายามในการเข้าร่วม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)

C - 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เป็นประเภทการทำงานดังนั้น mantissa และเศษส่วนที่ใหญ่ที่สุดรวมกันเกินความแม่นยำดั้งเดิมของประเภทนั้น ถ้าฉันใช้long doubleแทนมันสามารถจัดการได้

Haskell ( 333) 322 315 ไบต์)

ฉันไม่ชัดเจนว่าควรจะปัดเศษตัวเลขเซ็กส์สุดท้ายหรือไม่เมื่อตัดหรืออนุญาตให้มีการตัดปลายหรือไม่ ตัดทอนนี้ฉันคิดว่า Python3 อาจจะเหมือนกันไหม?

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

วิธีการแปลงจำนวนเต็มเป็นตัวเลขโรมันถูกขโมยไปอย่างไร้ยางอายจากThomas Ahle ใน StackOverflowและเล่นกอล์ฟเพียงเล็กน้อย