Leonardo da Pisano, yani Fibonacci, Hindu-Arap rakam sistemini Avrupa'ya getirmede etkili oldu. Bundan önce, matematikçiler Roma rakamlarıyla altmış bazda çalıştılar.

Örneğin, ikisinin karekökü, üç bin altı yüzyüzünün altmış ve elli bir bölümünün bir ve yirmi dört kısmı , ve bağlam olarak belirlenen ölçekleme ile şu şekilde yazılabilir: i xxiv li . O zamanlar “hiçlik” biliniyordu ( yani sıfır), ancak bu sayı sisteminde standart bir temsili yoktu.

Fibonacci seyahatleri sırasında karşılaştığı bu yeni-ondalık basamakları görmezden gelseydi, mevcut sistemdeki eksikliklere kesinlikle değinirdi. Bu geliştirilmiş sisteme Fibonacci'nin cinsellikleri diyeceğiz .

Göreviniz ASCII veya ikili biçimde kayan nokta sayısı alan ve altmış Romen rakamıyla çıktı veren bir program, fonksiyon veya kod snippet'i yazmaktır. Giriş dosya, konsol, komut satırı veya işlev bağımsız değişkeni olabilir ve çıktı en kolay olanı dosya veya konsol olabilir.

Çıktı büyük veya küçük olabilir ve şu geliştirmeleri içermelidir:

• null değerini belirtmek için n veya N kullanın ; bir yerin değeri yoktur, yani “sıfır” (sistemle ilgili bir sorun)
• kullanmak e veya E göstermek için ve altmış tabanlı noktasına (sistemle birlikte başka bir sorun), karşılık gelen
• Romen rakamları gruplarını ayırmak için orta nokta · veya yıldız işareti * kullanın (yine de sistemle ilgili başka bir sorun)

Girdinin mantis lix · lix · lix · lix · lix'ten büyük olmayan kayan nokta olacağını varsayın . N · e · n · n · n · n · i'den küçük kesirler göz ardı edilebilir. Dolayısıyla, girdinin bu kısıtlamaları olması koşuluyla, bir e ile en fazla on Romen rakamı grubu çıkarılabilir.

Daha az Sayılar i lider olması gerekir · n e bağlam açık olduğundan emin olmak için.

Bazı örnekler: input→ çıktı

• 0→ n
• 1→ ben
• 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

Çıkış gereksiz lider kaçınmak gerekir n ° mantis kısmen izole edilmiş, e , ya da takip eden n-· çıkış fraksiyonel parçası. Yani mesela, n · n · n · n · i , i · e ve i · e · n · n · n · n · n girişi için yanlış çıkışlardır 1.

Çıktıdaki artı veya eksi n · e · n · n · n · n · i farkları tolerans dahilindedir ve kabul edilebilir.

Giriş, seçtiğiniz dilde herhangi bir yasal kayan noktadır, bu nedenle girdi yukarıda belirtilen aralığın dışında olmadığı sürece pozitif veya negatif üsler içerebilir.

Ve son olarak, Romen rakamı yerleşik ins vardır izin verilir!

Python 3, 323 319 320 bayt

Bu cevap, Fibonacci'nin cinsiyetsel sayılarını sınırlayıcı ile *ve Romen rakamları listelerinde Kolmogorov karmaşıklığına bakmadan uygular (en azından şimdilik). Roma rakamlarının bir döngü altında oluşturulduğu whileve fordöngüsüne katılma girişimleri yapıldı , ancak bu girişimler henüz başarılı olmadı. Herhangi bir golf ipuçları ve önerilerinizi bekliyoruz ve takdir edilmektedir.

Düzenleme: Hata düzeltme ve golf.

Düzenleme: Daha fazla hata düzeltmesi.

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 bayt

Rekabetçi değil (açıkçası), ancak ilham kaynağı olarak hizmet etmek için:

#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;}

Farklı kaydet fs.c, birlikte oluştur gcc -o fs fs.c -lmve farklı çalıştır./fs <arg> .

Test senaryoları:

$ ./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

En büyük mantis ve kesri:

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

Ben doubleçalışma türü olarak kullanıyorum , bu yüzden en büyük mantis ve kesir bu tür doğal doğruluğu aşıyor. Onun long doubleyerine kullandıysam halledebilirdi.

Haskell ( 333 322 315 bayt)

Ben son seksageimal basamağın yuvarlanıp yuvarlanmayacağını veya kesilmesine izin verilip verilmediğine emin değilim; bu kesilir, ben de Python3 biri olabilir mi?

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 bayt, sayesinde H.PWiz ! -2 ortadan kaldırarak bayt whereiçin (\->)$-5 devamı icat, dfonksiyon ve golf a++"."++xiçin 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))

Tam sayıları romen rakamlarına dönüştürme yöntemi, StackOverflow'da Thomas Ahle'den utanmadan çalındı ve biraz golf oynadı.