Caesar Shifting

22

Eine Caesar-Schicht ist wahrscheinlich etwas, mit dem wir alle vertraut sind.

(Vielleicht machen Sie es sogar als Hausaufgabe. Wenn ja, kopieren Sie diese Antworten bitte nicht, Ihr Lehrer möchte mit ziemlicher Sicherheit nichts Ähnliches wie die Antworten hier.)

Nur für den Fall, dass Sie es nicht sind, ist eine Caesar-Verschiebung eine sehr einfache Form der Verschlüsselung. Es wird eine Zeichenfolge und eine Ganzzahl benötigt, um verschlüsselt zu werden. Führen Sie dann für jedes alphabetische Zeichen in der Zeichenfolge die folgende Transformation durch:

  1. Ermitteln Sie die Position des Zeichens im Alphabet (0-basiert).
  2. Addieren Sie zu dieser Zahl die Ganzzahl, die Sie am Anfang erhalten haben.
  3. Wenn die Zahl größer als 25 ist, subtrahieren Sie 26 davon.
  4. Ermitteln Sie die Position des Alphabets, in dem es sich befindet.

Lassen Sie den Rest der Zeichen unverändert.

Großbuchstaben müssen respektiert werden, denn was ist Englisch ohne Großbuchstaben?

Beispiele:

abcdefghijklmnopqrstuvwxyz 1 -> bcdefghijklmnopqrstuvwxyza
Spam spam spam sausage and spam! 13 -> Fcnz fcnz fcnz fnhfntr naq fcnz!
abcdefghijklmnopqrstuvwxyz 52 -> abcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz -1 -> zabcdefghijklmnopqrstuvwxy
ABCxyz 3 -> DEFabc

Annahmen

  • Sie können jedes druckbare ASCII-Zeichen erhalten
  • Die eingegebene Zahl kann negativ sein und ist immer größer als -128 und kleiner als 128 ( -128<x<128).
  • Sie müssen in der Lage sein, Großbuchstaben und Nicht-Großbuchstaben reversibel zu kodieren.
  • Sie müssen ein vollständiges Programm erstellen, nicht nur eine Funktion oder ein Snippet
  • Sie erhalten Ihre Eingabe von STDIN oder der nächstgelegenen Alternative
  • Sie können das Format für Ihre Eingabe auswählen, bitte geben Sie dies in Ihrer Antwort an

  • Die Zeichen, die verschoben werden müssen, sind ASCII-Codepunkte 0x41 - 0x5Aund 0x61-0x7A- Groß- und Kleinbuchstaben

    • Großbuchstaben sollten groß bleiben
    • Kleinbuchstaben sollten kleiner bleiben
    • Zeichen, die nicht in diesem Bereich liegen, sollten so belassen werden, wie sie sind

  • Hinweis für diese Herausforderung, müssen Sie nur auf Chiffre - Strings haben, müssen Sie sie nicht in der Lage automatisch zu lösen (aber geben -xumkehren wird die Chiffre)


Da es sich um einen Katalog handelt, dürfen Sprachen, die nach dieser Herausforderung erstellt wurden, miteinander konkurrieren. Beachten Sie, dass ein Dolmetscher vorhanden sein muss, damit die Einreichung getestet werden kann. Es ist erlaubt (und sogar empfohlen), diesen Dolmetscher für eine zuvor nicht implementierte Sprache selbst zu schreiben. Ansonsten müssen alle Standardregeln des Code-Golfs eingehalten werden. Einsendungen in den meisten Sprachen werden in Bytes in einer geeigneten, bereits vorhandenen Codierung (normalerweise UTF-8) bewertet.

Katalog

Das Stapel-Snippet am Ende dieses Beitrags generiert den Katalog aus den Antworten a) als Liste der kürzesten Lösungen pro Sprache und b) als Gesamt-Bestenliste.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

## Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

## Perl, 43 + 2 (-p flag) = 45 bytes

Sie können den Namen der Sprache auch als Link festlegen, der dann im Snippet angezeigt wird:

## [<><](https://esolangs.org/wiki/Fish), 121 bytes

Code-Snippet anzeigen

code-golf  string  cipher 
— Blau
quelle
8
"Vielleicht machst du es sogar als Hausaufgabe. Wenn ja, kopiere diese Antworten bitte nicht, dein Lehrer möchte mit ziemlicher Sicherheit nichts Ähnliches wie die Antworten hier ." Ich frage mich, was passieren würde, wenn Sie einem Lehrer einen 90-Byte-Klumpen unordentlicher Zeichen und Abkürzungen geben würden ...
— ASCIIThenANSI

Antworten:

9

Pyth, 13 Bytes

uXGH.<HQrBG1z

Testsuite

Grundsätzlich beginnen wir mit den beiden Zeichenfolgen, die wir verschieben möchten, dem Kleinbuchstaben und dem Großbuchstaben. Die Liste, die diese beiden Elemente enthält, wird durch rBG1Bifurkieren in Großbuchstaben erstellt. Dann reduzieren wir diese Liste, indem wir mit der Eingabezeichenfolge beginnen und zuerst Kleinbuchstaben und dann Großbuchstaben um die entsprechende Verschiebung übersetzen.

— isaacg
quelle
Sehr schön, ich vergesse immer wieder, dass es eine Gabelung gibt ...: P
— FryAmTheEggman
5

Bash + BSD-Spiele-Paket, 21

caesar $[($1+130)%26]

Builtins FTW! Fühlt sich fast wie Mathematica an. Pyth-Antworten sind jedoch immer noch kürzer.

Eingabezeichenfolge, die von STDIN und Ganzzahl von der Befehlszeile gelesen wird. z.B:

$ ./caesar.sh 13 <<< "Spam spam spam sausage and spam!"
Fcnz fcnz fcnz fnhfntr naq fcnz!
$

Oder wenn Sie das eingebaute nicht mögen:

Bash + Coreutils, 63

printf -va %s {a..z}
t=${a:$1%26}${a:0:$1%26}
tr A-Z$a ${t^^}$t
— Digitales Trauma
quelle
Es scheint mir, dass die Coreutils-Version mit -127 und / oder 127 nicht funktioniert?
— Neil
@ Neil Ja. Guter Fang. Fest.
— Digital Trauma
5

JavaScript (ES6), 122 118 114 111 Byte

alert((p=prompt)().replace(/[a-z]/gi,c=>String.fromCharCode((x=c.charCodeAt(),a=x&96,x-a+n+129)%26-~a),n=+p()))

4 Bytes gespart dank @Neil !

Erläuterung

Die erste Eingabeaufforderung übernimmt die Eingabezeichenfolge. Die zweite ist die Zahl, um die jeder Buchstabe verschoben werden soll.

alert(
  (p=prompt)()              // get input string
    .replace(/[a-z]/gi,c=>  // for each letter
      String.fromCharCode((
        x=c.charCodeAt(),   // x = code of character
        a=x&96,             // a = index of letter a (-1) in same capitalisation
        x-a+n+129)%26-~a    // add N to the letter code and wrap at 26
      ),                    // (+129 is needed to make the % work with negative numbers)
      n=+p()                // get number to shift by
    )
)
— user81655
quelle
1
Sehr schön! Es funktioniert jedoch nicht bei allen Eingaben. versuchen Sie es "abcdefg", -26. Dies kann durch Ändern der Formel in behoben werden (x-a+n+130)%26.
— ETHproductions
@ETHproductions Danke, dass du das erwischt hast!
— user81655
"Sie müssen ein vollständiges Programm erstellen, nicht nur eine Funktion oder einen Ausschnitt"
— LegionMammal978
@ LegionMammal978 Danke, das habe ich nicht bemerkt.
— user81655
Hilft das a=x&96,(x-a+n+129)%26+a+1?
— Neil
3

CJam, 34 22 21 20 Bytes

Vielen Dank an FryAmTheEggman für das Speichern von 1 Byte.

l'[,_el^_26/l~fm<ser

Teste es hier.

Die Eingabe ist die Zeichenfolge, die in der ersten Zeile fünf und in der zweiten Zeile die Verschiebung sein soll.

Erläuterung

l    e# Read the first line of input.
'[,  e# Push a string with all ASCII characters up to and including Z.
_el  e# Duplicate and convert to lower case. This only affects the letters.
^    e# Symmetric set-difference: except for the letters, each character appears in both
     e# sets and will be omitted from the difference, but all the letters will be included.
     e# This gives us "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".
_26/ e# Duplicate and split into chunks of 26 characters, separating lower and upper case.
l~   e# Read the second line of input and evaluate.
fm<  e# Shift each of the two substrings by that many characters to the left.
s    e# Convert to a single string, joining both substrings back together.
     e# On the stack are now the input, the letters in alphabetical order and the letters
     e# in shifted order.
er   e# Character transliteration: replace each occurrence of a letter with the character
     e# at the corresponding position in the shifted string.
— Martin Ender
quelle
@FryAmTheEggman The '[,_el^ist ein Tipp von Dennis. Ich weiß aber nicht, was du meinst f, es scheint ziemlich normal zu sein?
— Martin Ender
Ich schätze, ich habe einfach nicht genug CJam-Antworten gelesen: P Es scheint einfach sehr ordentlich zu sein, es wie eine Karte zu verwenden, aber die Argumentreihenfolge zu ändern.
— FryAmTheEggman
@FryAmTheEggman eigentlich brauche ich das gar nicht @. :)
— Martin Ender
2

Java, 249 Bytes

Dies ist so kurz wie ich es bekommen könnte. Das Lesen von stdin isst eine Tonne Bytes. Eine Lösung, die Befehlszeilenargumente verwendet, ist merklich kürzer, aber diese Aufgabe gab stdin für die Eingabe an.

Das Eingabeformat ist der String, gefolgt von der Schichtnummer in einer neuen Zeile.

interface C{static void main(String[]a){java.util.Scanner r=new java.util.Scanner(System.in);String s=r.nextLine();int i=(r.nextInt()+26)%26;s.chars().forEach(c->System.out.print((char)(c>64&c<91|c>96&c<123?c<91?65+(c+i-65)%26:97+(c+i-97)%26:c)));}}

Mit Befehlszeilenargumenten beträgt diese Lösung nur 188 Byte. Eingabe ist der String als erstes Argument und die Verschiebung als zweites.

interface C{static void main(String[]a){int i=(Integer.parseInt(a[1])+26)%26;a[0].chars().forEach(c->System.out.print((char)(c>64&c<91|c>96&c<123?c<91?65+(c+i-65)%26:97+(c+i-97)%26:c)));}}
— Ankh-Morpork
quelle
1

R, 111 Bytes

Code

n=scan();s=scan(,"");for(l in as.numeric(sapply(s,charToRaw))){v=97;if(l<97)v=65;cat(intToUtf8((l+n-v)%%26+v))}

ungolfed

n <- scan()                           # input integer
s <- scan(,"")                        # input string letter by letter
z <- as.numeric(sapply(s,charToRaw))  # get ASCII index of character
for (l in z){                         # loop through chars
  v=97                                # base index of not capitalized chars
  if(l<97)v=65                        # base index of capitalized chars
  cat(intToUtf8((l+n-v)%%26+v))       # paste the char of the shifted index
}

Dieses Programm verwendet die Benutzereingabe von STDIN, zuerst den Integer-Shifter und dann die Zeichenfolge, Zeichen für Zeichen.

— Mutador
quelle
1

Perl, 81 Bytes

(+1 für die -pFlagge)

s/[^ ]+ //;$n=$&%26;eval"y/a-zA-Z/".($x=chr(97+$n)."-za-".chr$n+96).uc$x."/"if$n

Ich arbeite immer noch daran, es runter zu spielen ...

Prüfung:

llama@llama:...code/perl/ppcg67044caesar$ printf '1 abcdefghijklmnopqrstuvwxyz\n13 Spam spam spam sausage and spam!\n52 abcdefghijklmnopqrstuvwxyz\n-1 abcdefghijklmnopqrstuvwxyz\n3 ABCxyz' | perl -p caesar.pl; echo
bcdefghijklmnopqrstuvwxyza
Fcnz fcnz fcnz fnhfntr naq fcnz!
abcdefghijklmnopqrstuvwxyz
zabcdefghijklmnopqrstuvwxy
DEFabc
— Türknauf
quelle
1

Python 2, 163 160 Bytes

Ich bin mir nicht sicher, ob ich noch Golf spielen kann.

import sys;k=sys.argv
def f(x,n):r=chr((ord(x.lower())-97+n)%26+97);return(x,[r,r.upper()][x.isupper()])
print''.join(f(x,int(k[2]))[x.isalpha()] for x in k[1])

Da es ziemlich unleserlich ist, gibt es hier eine unbenutzte Version:

import sys

def shift(x,n):
    # shift character x by n (all in lowercase)
    r = chr((ord(x.lower())-97+n)%26+97)
    if x.isalpha() and x.islower():
        return r
    elif x.isalpha() and x.isupper():
        return r.upper()
    else:
        return x

# 'map' the function shift to each character of the input   
output = ''.join(shift(x,int(sys.argv[2])) for x in sys.argv[1])
print(output)

In Bezug auf die Eingabe: Es werden zwei Argumente erwartet, das erste muss eine Zeichenfolge und das zweite eine Ganzzahl (der Verschiebungsbetrag) sein. Beispiele (Datei heißt csr.py):

$ python csr.py gnu 9
pwd
$ python csr.py "Spam spam spam sausage and spam\!" 13
Fcnz fcnz fcnz fnhfntr naq fcnz!

Hinweis: Im zweiten Beispiel werden ein Escape-Zeichen und ""benötigt

— ბიმო
quelle
1

Python 2, 118 116 Bytes

s,n=input()
print''.join([[c,chr((ord(c)-97+n)%26+97)]['`'<c<'{'],chr((ord(c)-65+n)%26+65)]['@'<c<'[']for c in s)
— TFeld
quelle
Möglicherweise möchten Sie Listen anstelle der if/elseInstanzen verwenden ( codegolf.stackexchange.com/a/62/36885 ). Zum Beispiel print''.join([[c,chr((ord(c)-97+n)%26+97)]['~'<c<'{'],chr((ord(c)-65+n)%26+65)]['@'<c<'[']for c in s)ist etwas kürzer und sollte genauso funktionieren. (Mit der Ausnahme, dass Sie die Tilde in ein Backtick wie zuvor geändert haben - ich konnte das Backtick nicht richtig anzeigen.)
— mathmandan
1

Mathematica, 117 Bytes

Echo[InputString[]~StringReplace~Thread[Join[a=Alphabet[],b=ToUpperCase@a]->(c=RotateLeft)[a,d=Input[]]~Join~c[b,d]]]

Übernimmt die Zeichenfolge, gefolgt von einer neuen Zeile, gefolgt vom Verschiebungsfaktor. Könnte noch golffähig sein ...

— LegionMammal978
quelle
1

Perl 6 , 73 + 1 = 74 Bytes

$ perl6 -pe 's:g:i/<[a..z]>/{chr ((my$o=ord ~$/)-(my$a=$o+&96+1)+BEGIN get%26)%26+$a}/' # 73+1

Die erste Eingabezeile gibt die Anzahl der Zeichen an, um die die Buchstaben nach oben verschoben werden sollen.

Verwendung:

$ perl6 -pe 's:g:i/<[a..z]>/{...}/' <<< \
'1
abcdefghijklmnopqrstuvwxyz'
bcdefghijklmnopqrstuvwxyza
$ perl6 -pe 's:g:i/<[a..z]>/{...}/' <<< \
'13
Spam spam spam sausage and spam!'
Fcnz fcnz fcnz fnhfntr naq fcnz!
$ perl6 -pe 's:g:i/<[a..z]>/{...}/' <<< \
'52
abcdefghijklmnopqrstuvwxyz'
abcdefghijklmnopqrstuvwxyz
$ perl6 -pe 's:g:i/<[a..z]>/{...}/' <<< \
'-1
abcdefghijklmnopqrstuvwxyz'
zabcdefghijklmnopqrstuvwxy
$ perl6 -pe 's:g:i/<[a..z]>/{...}/' <<< \
'3
ABCxyz'
DEFabc
$ perl6 -pe 's:g:i/<[a..z]>/{...}/' <<< \
'1000000000000000000000000000000000000000
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ'
mnopqrstuvwxyzabcdefghijkl
MNOPQRSTUVWXYZABCDEFGHIJKL
— Brad Gilbert b2gills
quelle
1

C ++, 163 154 152 Bytes

#include<cstdio>
#include<cstdlib>
int main(int x,char**a){for(int c,b,s=atoi(a[1]);1+(c=getchar());putchar(c<b|c>b+26?c:(c+s-b+26)%26+b))b=c<97?65:97;}

Verwendung:

$ ./caesar -1 <<< "123 a A z Z aBcDeFgHiKlMnOpQrStUvWxYz"
123 z Z y Y zAbCdEfGhJkLmNoPqRsTuVwXy
— Simon D.
quelle
0

k4, 80 Bytes

Das Programm akzeptiert die Schichtnummer als Befehlszeilenargument und liest Text aus stdin.

Aus technischen Gründen müssen negative Verschiebungen mit einem Unterstrich anstelle eines Bindestrich-Minus codiert werden. (Ohne den Parser zum Interpretieren dieser Codierung wäre die Lösung 64 Byte.)

% wc -c c.k
80 c.k
% cat c.k
c:{x;,/x{y!(x_y),x#y}'.Q`a`A}
.z.pi:{1@x^c[.q.mod[.*{x^((!).$"_-")x}.z.x]26]x;}
%

Hier sind die ausgeführten Beispiele:

% echo abcdefghijklmnopqrstuvwxyz|q c.k 1
bcdefghijklmnopqrstuvwxyza
% echo 'Spam spam spam sausage and spam!'|q c.k 13
Fcnz fcnz fcnz fnhfntr naq fcnz!
% echo abcdefghijklmnopqrstuvwxyz|q c.k 52
abcdefghijklmnopqrstuvwxyz
% echo abcdefghijklmnopqrstuvwxyz|q c.k _1
zabcdefghijklmnopqrstuvwxy
% echo ABCxyz|q c.k 3
DEFabc
%

Und hier ist ein albernes kleines Testgeschirr, das sowohl das Kodieren als auch das Dekodieren überprüft. (Dies ist zsh; für bashoder ksh, ändern Sie die forSchleifenindizierung in ((i=0;i<5;i++)). Einbasierte Arrays, ugh ....)

% a=(abcdefghijklmnopqrstuvwxyz 'Spam spam spam sausage and spam!' abcdefghijklmnopqrstuvwxyz abcdefghijklmnopqrstuvwxyz ABCxyz)
% b=(1 13 52 _1 3)
% c=(bcdefghijklmnopqrstuvwxyza 'Fcnz fcnz fcnz fnhfntr naq fcnz!' abcdefghijklmnopqrstuvwxyz zabcdefghijklmnopqrstuvwxy DEFabc)
% for ((i=1;i<=5;i++))
for> do
for>     r=$(echo "${a[i]}"|q c.k "${b[i]}")
for>     s=$(echo "$r"|if [[ ${b[i]} == _* ]]; then q c.k "${b[i]/_}"; else q c.k "_${b[i]}"; fi)
for>     printf '%s\t%s\n' "$([[ ${c[i]} == $r ]] && echo good || echo bad)" "$([[ ${a[i]} == $s ]] && echo good || echo bad)"
for> done
good    good
good    good
good    good
good    good
good    good
%
— Aaron Davies
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.