Bu, bir mesajı kodlamak için PI rakamlarını kullanan basit bir şifreleme yöntemidir, yöntem basittir:

Anahtar, yalnızca pencerenin nerede başladığını belirten pozitif bir tamsayıdır:

Şifrelemek için, yalnızca küçük harfler içeren, boşluk içermeyen bir dize verildiğinde, uzunluğunu alırsınız, daha sonra PI'nin N'inci basamağını bulursunuz ve daha sonra her harfi, rakamla belirtilen miktar için sağa kaydırmaya devam edersiniz.

Örneğin, anahtar ise 2ve kodlamak istiyorsam house, ikincisinden 5 basamaklı bir pencere alırım: 14159ve sonra olur:

h -> i
o -> s
u -> v
s -> x
e -> n

a.- Programınız / fonksiyonunuz / algoritmanız, yalnızca boşluk içermeyen küçük harflerden ve anahtardan oluşan iki parametre alacaktır; bu, 1 (1, 3'ü ifade eder) ve 1000 arasında pozitif bir tamsayı olacaktır ve bu daha fazla olabilir. veya daha az olduğu için PI'nin belirtilen doğrulukla hesaplanmasının ne kadar sürdüğünden emin değilim:

b.- Kodunuzda PI'yi kendiniz hesaplamalısınız, burada karşılaştırmak için temiz bir web sayfası var: Pi Günü . Giriş asla PI değerini 1000 basamağın ötesinde hesaplamamalıdır, yani bu uzunluk (mesaj) + tuşu <= 1000'dir.

Pi hesaplayarak, kodunuzda (kod golf için aptal) kodlamak veya kodunuzda herhangi bir gömülü sabit veya herhangi bir trigonometrik kimlik (2 * acos (0)) veya herhangi bir web referansı kullanmak istemiyorum.

c.- Çıktı sadece şifrelenmiş dize olacaktır.

Bu bir kod golf sorusu, daha kısa kod kazanır!

14 Temmuz 2014'te kazanan cevabı kabul edeceğim.

CJam - 51

l_,li(2e4,-2%{2+_2/@*\/2e2000+}*Ab><]z{~+_'z>26*-}%

Örnek girdi:

zebra
20

Çıktı:

dkdxe

Bu (dize uzunluğu) + anahtar <= 2000 için çalışır, ancak çevrimiçi yorumlayıcı için oldukça yavaştır (java yorumlayıcıyla hala hızlıdır).

İşte 200'e kadar çalışan bir sürüm ve çok uzun beklemeden http://cjam.aditsu.net/ adresinde deneyebilirsiniz :

l_,li(2e3,-2%{2+_2/@*\/2e200+}*Ab><]z{~+_'z>26*-}%

Python - 370

Tamam, güzel olan, nihayet link1 ve link2 sayesinde pi şey var .

from decimal import *
def f(s,n): 
 j=len(s)
 getcontext().prec=j+n+5
 d=Decimal
 e=d(0)
 for k in range(0,j+n+5): 
  e+=(d(16)**(-k)*(d(4)/(8*k+1)-d(2)/(8*k+4)-d(1)/(8*k+5)-d(1)/(8*k+6)))
 c=`e`.split("'")[1].replace('.','')
 t=''
 for i,l in enumerate(s):
  o=ord(l)
  for v in[0,32]:
   if 64+v<o<91+v:
    l=chr(((o-65-v)+int(c[i+n-1]))%26+65+v)
  t+=l   
 print t

Örnek çıktı:

>>> f('house',2)
isvxn

ve başka:

Wimt fcy d dnyh uhkvkv qhvadil   

>>> f ('Bu çok gizli bir mesajdı', 1)

JavaScript - 167 173 176

Michael'a 16 gücün zekice temsili için teşekkürler .

Bu, 16ncı basamağa kadar PI hesaplayabilir.

function e(s,o){for(p=i=n=r='',m=1;s[+i];m<<=4,n>o?r+=String.fromCharCode(s.charCodeAt(i)-+-(1e15*p+'')[o+i++]):0)p-=(4/((d=8*n++)+1)-2/(d+=4)-1/++d-1/++d)/m;return r}

Test durumu:

> e("house",2)
"isvxn"

Python - 321 304 288 285

from decimal import*
d=Decimal
s,n=raw_input(),input()
l=len(s)
getcontext().prec=n+l
print''.join([chr((v-97)%26+97)for v in map(sum,zip(map(ord,s),map(int,str(sum([(d(4)/(8*k+1)-d(2)/(8*k+4)-d(1)/(8*k+5)-d(1)/(8*k+6))/16**k for k in range(0,l+n)])).replace('.','')[n-1:n+l])))])

Golfçü versiyonun çoğunu okumak ve anlamak kolaydır. Son satır aşağıda çözülmüştür:

# Calculate PI using the BBP formula.
pi = 0
for k in range(0,l+n):
    pi += (d(1)/(16**k))*((d(4)/(8*k+1))-(d(2)/(8*k+4))-(d(1)/(8*k+5))-(d(1)/(8*k+6)))

# Remove the decimal point in PI.
pi = str(pi).replace('.','')

result = []
# For the ASCII sum of each pair of letters in `s` and its digit in PI 
for v in sum(zip(map(ord, s), map(int, pi))):
    result.append((v-97)%26+97)

# Convert all the ordinal values to characters
print ''.join(map(chr, result))

EDIT # 1: modül aritmetiğimi basitleştirdi.

EDIT # 2: BBP formülünü yeniden düzenledi.

Haskell - 265 267 bayt (GÇ yok)

p=g(1,0,1,1,3,3)where g(q,r,t,k,n,l)=if 4*q+r-t<n*t then n:g(10*q,10*(r-n*t),t,k,div(10*(3*q+r))t-10*n,l) else g(q*k,(2*q+r)*l,t*l,k+1,div(q*(7*k+2)+r*l)(t*l),l+2)
e i s=zipWith(\k c->toEnum$fromIntegral k+fromEnum c::Char)(take(length s)$drop(fromIntegral$i-1)p)s

phttp://rosettacode.org/wiki/Pi#Haskell adresinde bulunan algoritmanın golf edilmiş bir sürümüdür

e kodlama fonksiyonudur:

λ> e 2 "house"
"isvxn"

Bir indeks küçük harfli alfabe dışındaysa döngü yapmaz. Bu, diğer bazı karakterlerin kodlanmış dizede kayabileceği anlamına gelir:

"Sfufv#Kork(mq}nns j{i&sv&xitmujtu&vey|h{xljej|35.)(\"%(\"\"&\" %\"\"$()$ ''\"&'!)$'(\"&($(\"& !$'&)]hrs\"ow olih7$Tdkhnsj ns&qpdlw}oplwmxbipn#o{ur!vhbp\"mitj/"

Ne yazık ki, ofseti 10 000hesaplamaktan daha büyük ofsetlerle birkaç saniye sürüyor . Neyse ki, birden çok kez aynı ofseti kullanırken, rakamların yalnızca ilk kez hesaplanması gerekir.

Bonus - Kod Çözme

d i s=zipWith(\k c->toEnum$fromEnum c-fromIntegral k::Char)(take(length s)$drop(i-1)p)s

Yine aşağıdakilerle test yaparsak isvxn:

λ> d 2 "isvxn"
"house"

CoffeeScript - 148 Karakter / Bayt

İlk Code Golf'üm

Ne yazık ki kaydırmayı desteklemiyor (Yani az noktalama işareti olacak)

e = (m, k) -> (m.split (''). harita (v, i) -> String.fromCharCode v.charCodeAt () + parseInt Math.PI.toString (). değiştir ('.', '') .slice (k-1, m.length + k-1) [i]). (birleştirme '')

Üzerinde Demosu CSSDeck

Aranan:

uyarı 'ev', 2

isvxn