Dies ist eine einfache Verschlüsselungsmethode, bei der PI-Ziffern zum Verschlüsseln einer Nachricht verwendet werden. Die Methode ist einfach:

Der Schlüssel ist nur eine positive Ganzzahl, die angibt, wo das Fenster dann beginnt:

Wenn Sie eine zu verschlüsselnde Zeichenfolge angeben, die nur Kleinbuchstaben und keine Leerzeichen enthält, nehmen Sie deren Länge, suchen Sie die n-te Ziffer von PI und verschieben Sie dann jeden Buchstaben um den durch die Ziffer angegebenen Betrag nach rechts.

Wenn zum Beispiel der Schlüssel ist 2und ich verschlüsseln möchte house, nehme ich ein Fenster mit 5 Stellen von der zweiten: 14159und dann wird es:

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

a.- Ihr Programm / Ihre Funktion / Ihr Algorithmus erhält zwei Parameter, eine Zeichenfolge, die nur aus Kleinbuchstaben ohne Leerzeichen besteht, und den Schlüssel, der nur eine positive ganze Zahl zwischen 1 (1 bezieht sich auf 3) und 1000 ist, die mehr sein kann oder weniger, da ich nicht ganz sicher bin, wie lange es dauert, PI mit dieser Genauigkeit zu berechnen, weil:

b.- Sie müssen PI selbst in Ihrem Code berechnen. Hier ist eine ordentliche Webseite zum Vergleich mit: Pi Day . Bei der Eingabe sollte der PI niemals über die 1000-stellige Zahl hinaus berechnet werden, dh Länge (Nachricht) + Taste <= 1000.

Mit Berechnung von Pi meine ich, dass es nicht in Ihrem Code harcodiert wird (albern für einen Codegolf), noch dass eine in Ihren Code eingebettete Konstante oder eine trigonometrische Identität (2 * acos (0)) oder eine Webreferenz verwendet wird.

c.- Die Ausgabe ist nur die verschlüsselte Zeichenfolge.

Dies ist eine Code Golf Frage, kürzere Code gewinnt!

Ich werde die Gewinnerantwort am 14. Juli 2014 annehmen.

CJam - 51

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

Beispiel Eingabe:

zebra
20

Ausgabe:

dkdxe

Dies funktioniert für (Zeichenkettenlänge) + key <= 2000, ist jedoch für den Online-Interpreter recht langsam (mit dem Java-Interpreter immer noch schnell).

Hier ist eine Version, die bis zu 200 unterstützt. Sie können sie unter http://cjam.aditsu.net/ ausprobieren, ohne zu lange zu warten:

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

Python - 370

Ok, schön, dank link1 und link2 ist es endlich soweit .

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

Beispielausgabe:

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

und ein anderer:

Wimt fcy d dnyh uhkvkv qhvadil   

>>> f ('Dies war eine sehr geheime Nachricht', 1)

JavaScript - 167 173 176

Vielen Dank an Michael für die clevere Darstellung der Potenzen von 16.

Dies kann PI bis zur 16. Stelle berechnen.

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}

Der Testfall:

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

Der Großteil der Golfversion ist leicht zu lesen und zu verstehen. Die letzte Zeile ist unten ungolfed:

# 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: vereinfacht meine Modularithmetik.

EDIT # 2: Die BBP-Formel wurde überarbeitet.

Haskell - 265 267 Bytes (kein IO)

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

pist eine Golf-Version des Algorithmus, die unter http://rosettacode.org/wiki/Pi#Haskell zu finden ist

e ist die Kodierungsfunktion:

λ> e 2 "house"
"isvxn"

Es wird keine Schleife ausgeführt, wenn sich ein Index außerhalb des Kleinbuchstaben befindet. Dies bedeutet, dass einige andere Zeichen in der codierten Zeichenfolge vorkommen können:

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

Leider dauert es bei größeren Offsets als 10 000der Berechnung der Ausgabe einige Sekunden . Glücklicherweise müssen bei mehrfacher Verwendung desselben Offsets die Ziffern nur beim ersten Mal berechnet werden.

Bonus - Decodierung

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

Nochmals, wenn wir testen mit isvxn:

λ> d 2 "isvxn"
"house"

CoffeeScript - 148 Zeichen / Byte

Mein allererster Code Golf

Leider unterstützt es kein Wrapping (also würde az am Ende Interpunktion sein)

e = (m, k) -> (m.split (''). map (v, i) -> String.fromCharCode v.charCodeAt () + parseInt Math.PI.toString (). replace ('.', '') .slice (k-1, m.Länge + k-1) [i]). join ('')

Demo auf CSSDeck

Angerufen mit:

Alarm e 'Haus', 2

isvxn