सीज़र स्थानांतरण

22

सीज़र शिफ्ट शायद कुछ ऐसा है जिससे हम सभी परिचित हैं।

(आप इसे होमवर्क कार्य के रूप में भी कर रहे होंगे। यदि हां, तो कृपया इन उत्तरों को कॉपी न करें, आपका शिक्षक लगभग निश्चित रूप से यहां के उत्तरों की तरह कुछ भी नहीं चाहता है।)

बस अगर आप नहीं हैं, तो सीज़र बदलाव सिफर का एक बहुत ही सरल रूप है। यह ciphered और पूर्णांक होने के लिए एक स्ट्रिंग लेता है। फिर स्ट्रिंग में प्रत्येक वर्णमाला वर्ण के लिए, निम्नलिखित परिवर्तन करें:

  1. वर्णमाला में वर्ण की स्थिति पर काम करें (0 आधारित)।
  2. आरंभ में प्राप्त पूर्णांक उस संख्या में जोड़ें।
  3. जबकि संख्या 25 से बड़ी है, इसमें से 26 घटाएं।
  4. यह जिस वर्णमाला में है, उसकी स्थिति पर काम करें।

बाकी किरदारों को अनफिट कर दें।

पूंजी पत्रों का सम्मान करना होगा क्योंकि पूंजी पत्रों के बिना अंग्रेजी क्या है?

उदाहरण:

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

मान्यताओं

  • आपको कोई मुद्रण योग्य ASCII वर्ण प्राप्त हो सकता है
  • इनपुट संख्या ऋणात्मक हो सकती है और हमेशा -128 से बड़ी होगी और कम से कम 128 ( -128<x<128)
  • आपको बड़े अक्षरों और गैर-कैपिटल अक्षरों को उलटने में सक्षम होना चाहिए।
  • आपको केवल एक फ़ंक्शन या स्निपेट ही नहीं, बल्कि एक पूर्ण कार्यक्रम बनाना होगा
  • आपको अपना इनपुट STDIN या निकटतम वैकल्पिक से मिलेगा
  • आप अपने इनपुट के लिए प्रारूप चुन सकते हैं, कृपया अपने उत्तर में यह बताएं

  • जिन पात्रों को स्थानांतरित करने की आवश्यकता है, वे ASCII कोडपॉइंट 0x41 - 0x5Aऔर 0x61-0x7A- ऊपरी और निचले मामले के अक्षर हैं

    • ऊपरी मामले के पत्रों को ऊपरी रहना चाहिए
    • लोअर केस लेटर्स कम रहना चाहिए
    • इस सीमा में वर्णों को नहीं छोड़ा जाना चाहिए जैसा कि वे हैं

  • इस चुनौती के लिए ध्यान दें, आपको केवल तार को समझना होगा, आपको उन्हें स्वचालित रूप से हल करने में सक्षम नहीं होना चाहिए (लेकिन देने -xसे पिंजरे को उलट दिया जाएगा)


चूंकि यह एक कैटलॉग है, इस चुनौती के बाद बनाई गई भाषाओं को प्रतिस्पर्धा करने की अनुमति है। ध्यान दें कि एक दुभाषिया होना चाहिए ताकि सबमिशन का परीक्षण किया जा सके। यह अनुमति दी जाती है (और यहां तक ​​कि प्रोत्साहित किया जाता है) कि इस दुभाषिया को पहले से बिना पढ़ी हुई भाषा के लिए स्वयं लिखें। इसके अलावा, कोड-गोल्फ के सभी मानक नियमों का पालन ​​करना चाहिए। अधिकांश भाषाओं में प्रस्तुतियाँ बाइट्स में एक उपयुक्त preexisting एन्कोडिंग (आमतौर पर UTF-8) में बनाई जाएंगी।

सूची

इस पोस्ट के निचले भाग में स्टैक स्निपेट उत्तर से सूची बनाता है) क) प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

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

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

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

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

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

कोड स्निपेट दिखाएं

code-golf  string  cipher 
— नीला
स्रोत
8
"आप इसे एक होमवर्क कार्य के रूप में भी कर रहे होंगे। यदि हां, तो कृपया इन उत्तरों की प्रतिलिपि न करें , आपका शिक्षक लगभग निश्चित रूप से यहां के उत्तरों की तरह कुछ भी नहीं चाहता है ।" मुझे आश्चर्य है कि अगर आप एक शिक्षक को गंदे चरित्रों और शॉर्टकट का 90-बाइट का
— कीचड़

जवाबों:

9

पायथ, 13 बाइट्स

uXGH.<HQrBG1z

परीक्षण सूट

असल में, हम उन दो तारों से शुरू करते हैं जिन्हें हम सीज़र, लोअरकेस और अपरकेस अल्फा में बदलना चाहते हैं। इन दोनों को मिलाकर जो सूची बनाई गई है rBG1, वह अपरकेस पर आधारित है। फिर, हम इस सूची को कम करते हैं, इनपुट स्ट्रिंग के साथ शुरू करते हैं और पहले लोअरकेस का अनुवाद करते हैं, फिर उपयुक्त शिफ्ट द्वारा अक्षरों को अपरकेस करते हैं।

— isaacg
स्रोत
बहुत अच्छा, मैं भूल रहा हूँ कि द्विभाजन मौजूद है ...: P
— FryAmTheEggman
5

बैश + बीएसडी-गेम पैकेज, 21

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

बिल्ट FTW! लगभग गणितज्ञ की तरह लगता है। Pyth के उत्तर हालांकि अभी भी कम हैं।

इनपुट स्ट्रिंग STDIN और कमांड-लाइन से पूर्णांक से पढ़ी जाती है। उदाहरण के लिए:

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

या अगर आपको बिलिन पसंद नहीं है:

बैश + कोरुटिल्स, 63

printf -va %s {a..z}
t=${a:$1%26}${a:0:$1%26}
tr A-Z$a ${t^^}$t
— डिजिटल आघात
स्रोत
यह मुझे लगता है कि कोर्यूटिल्स संस्करण -127 और / या 127 के साथ काम नहीं करता है?
— नील
@ नील हां। अच्छी पकड़। फिक्स्ड।
— डिजिटल ट्रॉमा
5

जावास्क्रिप्ट (ईएस 6), 122 118 114 111 बाइट्स

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 बाइट्स बचाए !

व्याख्या

पहला संकेत इनपुट स्ट्रिंग लेता है। प्रत्येक अक्षर को शिफ्ट करने के लिए दूसरा नंबर है।

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
स्रोत
1
बहुत अच्छा! लेकिन यह सभी इनपुट पर काम नहीं करता है; कोशिश करो "abcdefg", -26। यह सूत्र को बदलकर तय किया जा सकता है (x-a+n+130)%26।
— ETHproductions
@ETHproductions कि पकड़ने के लिए धन्यवाद!
— user81655
"आपको एक पूर्ण कार्यक्रम बनाना चाहिए, न कि केवल एक फ़ंक्शन या स्निपेट"
— LegionMammal978
@ LegionMammal978 धन्यवाद, मैंने ध्यान नहीं दिया।
— user81655
a=x&96,(x-a+n+129)%26+a+1मदद करता है?
— नील
3

CJam, 34 22 21 20 बाइट्स

1 बाइट बचाने के लिए FryAmTheEggman को धन्यवाद।

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

इसका परीक्षण यहां करें।

इनपुट पहली पंक्ति में शिफ्ट होने के लिए स्ट्रिंग है और दूसरी पर शिफ्ट।

व्याख्या

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.
— मार्टिन एंडर
स्रोत
@FryAmTheEggman '[,_el^डेनिस से एक टिप है। मुझे नहीं पता कि आपका क्या मतलब है f, हालांकि यह काफी सामान्य उपयोग जैसा लगता है?
— मार्टिन एंडर
मुझे लगता है कि मैंने अभी पर्याप्त CJam उत्तर नहीं पढ़े हैं: P यह वास्तव में एक मानचित्र की तरह उपयोग करने के लिए बहुत अच्छा लगता है लेकिन तर्क क्रम को बदलता है।
— FryAmTheEggman
@FryAmTheEggman वास्तव में, मुझे बिल्कुल ज़रूरत नहीं है @। :)
— मार्टिन एंडर
2

जावा, 249 बाइट्स

यह उतना ही छोटा है जितना मुझे मिल सकता है। स्टड से पढ़ना एक टन बाइट खाता है। कमांड लाइन आर्ग का उपयोग करने वाला एक समाधान काफी कम है लेकिन, यह कार्य इनपुट के लिए स्टड निर्दिष्ट करता है।

इनपुट प्रारूप एक स्ट्रिंग है जिसके बाद एक नई लाइन पर शिफ्ट नंबर आता है।

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

कमांड लाइन तर्क का उपयोग करना यह समाधान केवल 188 बाइट्स है। इनपुट पहले तर्क के रूप में स्ट्रिंग है और दूसरी के रूप में शिफ्ट।

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)));}}
— आंख-morpork
स्रोत
1

आर, 111 बाइट्स

कोड

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
}

यह प्रोग्राम उपयोगकर्ता इनपुट को STDIN से लेता है, पहले पूर्णांक शिफ्टर और फिर स्ट्रिंग, वर्ण वर्ण द्वारा।

— Mutador
स्रोत
1

पर्ल, 81 बाइट्स

( -pझंडे के लिए +1 )

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

अभी भी यह नीचे गोल्फ काम पर ...

परीक्षा:

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
— Doorknob
स्रोत
1

पायथन 2, 163 160 बाइट्स

यकीन नहीं होता कि मैं अभी भी इसे नीचे गिरा सकता हूं।

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

चूंकि यह बहुत ही अपठनीय है, यहाँ एक अपुष्ट संस्करण है:

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)

इनपुट के बारे में: यह दो तर्कों की उम्मीद करता है, पहला एक स्ट्रिंग और दूसरा एक पूर्णांक (शिफ्ट राशि) होना चाहिए। उदाहरण (फ़ाइल कहा जाता है csr.py):

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

नोट: दूसरे उदाहरण में एक बच चरित्र और ""जरूरत है

— ბიმო
स्रोत
1

पायथन 2, 118 116 बाइट्स

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
स्रोत
आप if/elseउदाहरणों के बजाय सूचियों का उपयोग करना चाह सकते हैं ( codegolf.stackexchange.com/a/62/36885 )। उदाहरण के लिए, print''.join([[c,chr((ord(c)-97+n)%26+97)]['~'<c<'{'],chr((ord(c)-65+n)%26+65)]['@'<c<'[']for c in s)थोड़ा छोटा है, और उसी तरह काम करना चाहिए। (टिल्ड को छोड़कर आप पहले की तरह बैकटिक में बदल सकते हैं - मैं इसे प्रदर्शित करने के लिए बैकटिक नहीं प्राप्त कर सका।)
— मैथुमन
1

मैथेमेटिका, 117 बाइट्स

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

स्ट्रिंग को ले जाता है, उसके बाद एक नई रेखा, जिसके बाद स्थानांतरण कारक होता है। अभी भी गोल्फ हो सकता है ...

— LegionMammal978
स्रोत
1

पर्ल 6 , 73 + 1 = 74 बाइट्स

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

इनपुट की पहली पंक्ति अक्षरों की संख्या को अक्षरों को ऊपर स्थानांतरित करने के लिए है।

उपयोग:

$ 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
— ब्रैड गिल्बर्ट b2gills
स्रोत
1

सी ++, 163 154 152 बाइट्स

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

उपयोग:

$ ./caesar -1 <<< "123 a A z Z aBcDeFgHiKlMnOpQrStUvWxYz"
123 z Z y Y zAbCdEfGhJkLmNoPqRsTuVwXy
— साइमन डी।
स्रोत
0

k4, 80 बाइट्स

कार्यक्रम शिफ्ट नंबर को कमांड-लाइन तर्क के रूप में स्वीकार करता है और स्टड से पाठ पढ़ता है।

एक तकनीकी बाधा के कारण, नकारात्मक बदलावों को एक हाइफ़न-माइनस के बजाय एक अंडरस्कोर के साथ एन्कोड किया जाना चाहिए। (इस एन्कोडिंग की व्याख्या के लिए पार्सर के बिना, समाधान 64 बाइट्स होगा।)

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

यहां निष्पादित उदाहरण हैं:

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

और यहाँ एक मूर्खतापूर्ण थोड़ा परीक्षण हार्नेस है जो एनकोड और डिकोड दोनों को सत्यापित करता है। (यह है zsh, के लिए bashया ksh, forलूप अनुक्रमण को ((i=0;i<5;i++))एक-आधारित सरणियों, 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
%
— हारून डेविस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.