Cezar Shifting

22

Zmiana Cezara jest prawdopodobnie czymś, co wszyscy znamy.

(Być może robisz to nawet jako zadanie domowe. Jeśli tak, nie kopiuj tych odpowiedzi, nauczyciel prawie na pewno nie chce tutaj takich odpowiedzi).

Na wszelki wypadek zmiana Cezara jest bardzo prostą formą szyfru. Do zaszyfrowania potrzebny jest ciąg znaków i liczba całkowita. Następnie dla każdego znaku alfabetu w ciągu wykonaj następującą transformację:

  1. Ustal pozycję postaci w alfabecie (w oparciu o 0).
  2. Dodaj do tego numeru liczbę całkowitą otrzymaną na początku.
  3. Gdy liczba jest większa niż 25, odejmij od niej 26.
  4. Wyznacz położenie alfabetu, w którym się znajduje.

Pozostaw pozostałe znaki niezmienione.

Należy przestrzegać wielkich liter, ponieważ co to jest angielski bez wielkich liter?

Przykłady:

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

Założenia

  • Możesz otrzymać dowolny znak ASCII do wydruku
  • Liczba wejściowa może być ujemna i zawsze będzie większa niż -128 i mniejsza niż 128 ( -128<x<128)
  • Musisz mieć możliwość odwracalnego kodowania wielkich i małych liter.
  • Musisz utworzyć pełny program, a nie tylko funkcję lub fragment kodu
  • Otrzymasz swój wkład ze STDIN lub najbliższej alternatywy
  • Możesz wybrać format danych wejściowych, podaj to w odpowiedzi

  • Znaki, które należy przesunąć, to punkty kodowe ASCII 0x41 - 0x5Aoraz 0x61-0x7A- wielkie i małe litery

    • Wielkie litery powinny pozostać duże
    • Małe litery powinny pozostać niższe
    • Znaki spoza tego zakresu powinny pozostać takie, jakie są

  • Uwaga: w przypadku tego wyzwania musisz tylko szyfrować ciągi, nie musisz być w stanie rozwiązać ich automatycznie (ale podanie -xodwróci szyfr)


Ponieważ jest to katalog, języki utworzone po tym wyzwaniu mogą konkurować. Pamiętaj, że musi być tłumacz, aby można było przetestować zgłoszenie. Zezwala się (a nawet zachęca) do samodzielnego napisania tego tłumacza dla wcześniej niewdrożonego języka. Poza tym należy przestrzegać wszystkich standardowych zasad gry w golfa kodowego . Zgłoszenia w większości języków będą oceniane w bajtach w odpowiednim wcześniej istniejącym kodowaniu (zwykle UTF-8).

Katalog

Fragment kodu na dole tego postu generuje katalog na podstawie odpowiedzi a) jako listy najkrótszych rozwiązań według języka oraz b) jako ogólnej tabeli wyników.

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

## Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

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

Jeśli chcesz umieścić w nagłówku wiele liczb (np. Ponieważ twój wynik jest sumą dwóch plików lub chcesz osobno wymienić kary za flagi tłumacza), upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku:

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

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie:

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

Pokaż fragment kodu

code-golf  string  cipher 
— niebieski
źródło
8
„Być może robisz to nawet jako zadanie domowe. Jeśli tak, nie kopiuj tych odpowiedzi, nauczyciel prawie na pewno nie chce tutaj takich odpowiedzi ”. Zastanawiam się, co by się stało, gdybyś wręczył nauczycielowi 90-bajtową mieszankę niechlujnych znaków i skrótów ...
— ASCIIThenANSI,

Odpowiedzi:

9

Pyth, 13 bajtów

uXGH.<HQrBG1z

Zestaw testowy

Zasadniczo zaczynamy od dwóch łańcuchów, które chcemy przesunąć Cezar, małych i wielkich liter. Lista zawierająca oba z nich jest generowana przez rBG1, bifurcate na wielkich literach. Następnie zmniejszamy tę listę, zaczynając od ciągu wejściowego i tłumacząc najpierw małe litery, a następnie wielkie litery o odpowiednie przesunięcie.

— isaacg
źródło
Bardzo miło, wciąż zapominam o istnieniu rozwidlenia ...: P
— FryAmTheEggman,
5

Pakiet Bash + bsd-games, 21

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

Wbudowane FTW! Prawie czuję się jak Mathematica. Odpowiedzi na pytania są wciąż krótsze.

Łańcuch wejściowy odczytany ze STDIN i liczba całkowita z wiersza poleceń. na przykład:

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

Lub jeśli nie lubisz wbudowanego:

Bash + coreutils, 63

printf -va %s {a..z}
t=${a:$1%26}${a:0:$1%26}
tr A-Z$a ${t^^}$t
— Cyfrowa trauma
źródło
Wydaje mi się, że wersja Coreutils nie działa z -127 i / lub 127?
— Neil,
@Neil Tak. Dobry chwyt Naprawiony.
— Cyfrowy uraz
5

JavaScript (ES6), 122 118 114 111 bajtów

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

Zaoszczędź 4 bajty dzięki @Neil !

Wyjaśnienie

Pierwszy monit pobiera ciąg wejściowy. Drugi to liczba, o którą należy przesunąć każdą literę.

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
    )
)
— użytkownik 81655
źródło
1
Bardzo dobrze! Ale to nie działa na wszystkich wejściach; spróbuj "abcdefg", -26. Można to naprawić, zmieniając formułę na (x-a+n+130)%26.
— ETHproductions
@ETHproductions Dzięki za złapanie tego!
— user81655,
„Musisz utworzyć pełny program, a nie tylko funkcję lub fragment
— kodu
@ LegionMammal978 Dzięki, nie zauważyłem tego.
— user81655,
Czy a=x&96,(x-a+n+129)%26+a+1pomaga
— Neil,
3

CJam, 34 22 21 20 bajtów

Dzięki FryAmTheEggman za zapisanie 1 bajtu.

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

Sprawdź to tutaj.

Dane wejściowe to łańcuch, który należy przesunąć w pierwszym wierszu, a przesunięcie w drugim.

Wyjaśnienie

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
źródło
@FryAmTheEggman The '[,_el^to tip from Dennis. Nie wiem jednak, o co ci chodzi f, czy wydaje się to dość normalnym użytkowaniem?
— Martin Ender,
Wydaje mi się, że po prostu nie przeczytałem wystarczającej liczby odpowiedzi CJam: P Bardzo fajnie jest używać go jako mapy, ale zmienić kolejność argumentów.
— FryAmTheEggman,
@FryAmTheEggman, właściwie nie potrzebuję @wcale. :)
— Martin Ender,
2

Java, 249 bajtów

To jest tak krótkie, jak tylko mogłem. Czytanie ze standardowego zjada tonę bajtów. Rozwiązanie wykorzystujące argumenty wiersza poleceń jest zauważalnie krótsze, ale w tym zadaniu podano wejście standardowe.

Format wejściowy to najpierw Łańcuch, a następnie numer zmiany w nowym wierszu.

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

Za pomocą argumentów wiersza polecenia to rozwiązanie ma tylko 188 bajtów. Dane wejściowe to ciąg znaków jako pierwszy argument, a przesunięcie jako drugi.

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
źródło
1

R, 111 bajtów

kod

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

bez golfa

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
}

Ten program pobiera dane wejściowe od STDIN, najpierw zmienną całkowitą, a następnie ciąg znaków, znak po znaku.

— Mutador
źródło
1

Perl, 81 bajtów

(+1 za -pflagę)

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

Nadal pracuję nad golfem ...

Test:

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
— Klamka
źródło
1

Python 2, 163 160 bajtów

Nie jestem pewien, czy nadal mogę grać w golfa…

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

Ponieważ jest to dość nieczytelne, oto wersja bez golfa:

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)

Jeśli chodzi o dane wejściowe: Oczekuje dwóch argumentów, pierwszy musi być łańcuchem, a drugi liczbą całkowitą (kwota przesunięcia). Przykłady (plik nazywa się csr.py):

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

Uwaga: W drugim przykładzie charakter ucieczki i ""są potrzebne

— ბიმო
źródło
1

Python 2, 118 116 bajtów

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
źródło
Zamiast if/elseinstancji możesz użyć list ( codegolf.stackexchange.com/a/62/36885 ). Na przykład print''.join([[c,chr((ord(c)-97+n)%26+97)]['~'<c<'{'],chr((ord(c)-65+n)%26+65)]['@'<c<'[']for c in s)jest nieco krótszy i powinien działać tak samo. (Z wyjątkiem zmiany tyldy na tyknięcie, tak jak wcześniej - Nie mogłem sprawić, by ten backt wyświetlał się poprawnie).
— Mathmandan
1

Mathematica, 117 bajtów

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

Bierze ciąg, po którym następuje nowa linia, a następnie współczynnik przesunięcia. Może nadal być golfa ...

— LegionMammal978
źródło
1

Perl 6 , 73 + 1 = 74 bajty

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

Pierwszy wiersz wprowadzania to liczba znaków, o którą należy przesunąć litery w górę.

Stosowanie:

$ 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
źródło
1

C ++, 163 154 152 bajtów

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

Stosowanie:

$ ./caesar -1 <<< "123 a A z Z aBcDeFgHiKlMnOpQrStUvWxYz"
123 z Z y Y zAbCdEfGhJkLmNoPqRsTuVwXy
— Simon D.
źródło
0

k4, 80 bajtów

Program akceptuje numer zmiany jako argument wiersza poleceń i odczytuje tekst ze standardowego wejścia.

Z powodu ograniczeń technicznych przesunięcia ujemne muszą być kodowane znakiem podkreślenia zamiast łącznika minus. (Bez parsera do interpretacji tego kodowania rozwiązaniem byłoby 64 bajty).

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

Oto wykonane przykłady:

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

A oto mała głupia uprząż testowa, która weryfikuje zarówno kodowanie, jak i dekodowanie. (To jest zsh; dla bashlub kshzmień forindeksowanie pętli na ((i=0;i<5;i++)). Tablice oparte na jednym, 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
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.