In questa sfida, sarà "invertire" l'alfabeto o lo scambio a-zcon z-a. Questo è comunemente noto come il cifrario Atbash .

Poiché questa trasformazione rende l'output simile a una lingua straniera, il codice dovrà essere il più breve possibile.

Esempi

abcdefghijklmnopqrstuvwxyz
zyxwvutsrqponmlkjihgfedcba

Programming Puzzles & Code Golf
Kiltiznnrmt Kfaaovh & Xlwv Tlou

Hello, World!
Svool, Dliow!

specificazione

• L'input può contenere più righe e sarà solo ASCII
• Nessuno spazio bianco aggiuntivo deve essere aggiunto all'output
• Il caso deve essere conservato

Classifica

var QUESTION_ID=68504,OVERRIDE_USER=40695;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Questo è code-golf, quindi vince il codice più breve in byte

Pyth, 8 byte

XXzG)rG1

@xnor ha suggerito questo approccio più semplice sulla risposta Pyth di @ FryAmTheEggman, quindi l'ho tradotto in Pyth.

Questo utilizza il pratico comportamento di X(translate) quando vengono dati solo due argomenti: si traduce dal secondo argomento al secondo argomento invertito. Lo facciamo prima con l'alfabeto minuscolo ( G) e poi con le maiuscole G.

C, 59 byte

Ci scusiamo per aver richiamato nuovamente C, ma sono rimasto un po 'deluso nel vedere solo le funzioni C qui. Avevo l'impressione che OP stesse cercando un prodotto utilizzabile.

main(c){while(~(c=getchar()))putchar(isalpha(c)?c+4^31:c);}

Compilato su Ubuntu 14.04 con un semplice:

cc swalpha.c

L'eseguibile risultante legge qualsiasi numero di righe dallo stdin e scrive il risultato su stdout.

Grazie a tanti altri manifesti per il trucco XOR.

CJam, 17 byte

Volevo aiutare GamrCorps a giocare a golf con la sua soluzione CJam, ma il risultato è stato così diverso che ho deciso di dare una risposta separata.

q'[,_el^_W%32f^er

Provalo online.

Spiegazione

q     e# Read all input.
'[,   e# Get a character range from the null byte up to and including "Z".
_el   e# Duplicate and convert to lowercase.
^     e# Symmetric set difference. Due to the lowercase operation only letters will not
      e# appear in both sets, and so we get a string with all uppercase letters followed
      e# by all lowercase letters, i.e "ABC...XYZabc...xyz".
_W%   e# Duplicate and reverse. Gives: "zyx...cbaZYX...CBA".
32f^  e# Take each character XOR 32 which swaps the case, so now we have:
      e#                               "ZYX...CBAzyx...cba"
er    e# Transliterate: substitute each character in the first string with the correspoding
      e# character in the second string.

JavaScript (ES6), 69 67 byte

x=>x.replace(/[A-Z]/gi,c=>String.fromCharCode(c.charCodeAt()+4^31))

Utilizza la stessa strategia della mia risposta Japt :

x=>x.replace(/[A-Z]/gi,C=>   // Replace each letter C with
 String.fromCharCode(        //  the character with char code
  C.charCodeAt()+4^31))      //   the char code of C, plus 4, with the last 5 bits flipped.

Maledici i tuoi nomi di proprietà incredibilmente lunghi, JS ...

Retina , 17 14 13 byte

Codice:

\T`w`_dZ-Az-a

Spiegazione:

\             # This suppresses the trailing linefeed
 T            # Switches to transliterate mode
  `w          # w is short for _0-9A-Za-z
    `_d       # d is short for 0-9
       Z-Az-a # Z-Az-a

Questo fa alcune cose magiche e completa il compito.

Provalo qui .

Pyth, 10 9

uXGr;H)2z

Grazie a Jakube per aver salvato un byte con la nuova funzionalità di ;!

Test Suite

Una rapida spiegazione: ridurre a partire dall'input sui numeri 0 e 1. L'operazione da eseguire è tradurre l'alfabeto minuscolo con una r...0o r...1che sono rispettivamente le funzioni inferiore e superiore di Python, e poi invertite.

Julia, 74 61 47 byte

s->replace(s,r"[a-z]"i,t->Char(31$Int(t[1])-4))

Questa è una funzione lambda che accetta una stringa e restituisce una stringa. Per chiamarlo, assegnarlo a una variabile.

Abbiniamo ogni lettera usando un'espressione regolare e sostituiamo ogni lettera con il carattere ASCII corrispondente a 31 XOR il codice ASCII per la lettera, meno 4.

C, 150 129 byte

void rev(char*s){int i,t;for(i=0;i<strlen(s);i++){t=s[i]+25;t=t<116?180-t:244-t;isalpha(s[i])?printf("%c",t):printf("%c",s[i]);}}

Questa funzione converte semplicemente char in int e aggiunge l'offset appropriato a int prima della stampa. So che non è il più breve ma non ho visto un'implementazione in C.

Esempio di utilizzo

#include<stdio.h>
#include<string.h>
#include<ctype.h>

void rev(char*s){int i,temp;for(i=0;i<strlen(s);i++){temp=s[i]+25;temp=temp<116?180-temp:244-temp;isalpha(s[i])?printf("%c",temp):printf("%c",s[i]);}}


int main(){
   char *s = "hello, there";
   rev(s);
   return 0;
}

AGGIORNAMENTO: abbreviato un nome variabile.

Japt, 23 22 byte

Ur"[A-Za-z]"_c +4^31 d

Provalo online!

Come funziona

Ur"[A-Za-z]"_  // Take the input and replace each letter with:
 c +4          //  Take its char code and add 4. This results in
               //  the string      "ABC...XYZabc...xyz"
               //  becoming        "EFG...\]^efg...|}~".
 ^31           //  XOR the result by 31. This flips its last five 5 bits.
               //  We now have     "ZYX...CBAzyx...cba".
 d             //  Convert back from a char code.
               // Implicit: output last expression

C, 64

Una funzione nulla che modifica la stringa in atto.

t(char*p){for(int c;c=*p;)*p++=c>64&c<91|c>96&c<123?(c^31)-4:c;}

Test: ideone

R, 69 61 byte

Grazie a @Giuseppe per aver alcuni byte extra:

function(s)cat(chartr("a-zA-Z",intToUtf8(c(122:97,90:65)),s))

Versione precedente:

function(s)cat(chartr("a-zA-Z",rawToChar(as.raw(c(122:97,90:65))),s))

Questa è una funzione anonima. Uso:

> f=function(s)cat(chartr("a-zA-Z",rawToChar(as.raw(c(122:97,90:65))),s))
> f("Hello, World!")
Svool, Dliow!
> f("Programming Puzzles & Code Golf")
Kiltiznnrmt Kfaaovh & Xlwv Tlou
> f("This is
+ a multiline
+ example.")
Gsrh rh
z nfogrormv
vcznkov.

Scherzi a parte, 31 byte (non concorrenti)

úúû+╗úRúûR+╝,`;╜íuWD╛E(X0WX`Mεj

Dump esadecimale:

a3a3962bbba352a396522bbc2c603bbda1755744be452858305758604dee6a

Provalo online

expl:

úúû+╗                             Put UPPERCASElowercase in reg0
     úRúûR+╝                      Put ESACREPPUesacrewol in reg1
            ,                     Fetch input.
             `             `Mεj   Map over the characters in string as list, joining result
              ;╜íu                Find 1-index of character in UPPERCASElowercase
                  W     0WX       If it is positive (present): 
                   D              Convert back to 0-index
                    ╛E            Look it up in ESACREPPUesacrewol
                      (X          Delete the original character.
                                  (Else just leave the original character unchanged.)

Ho appena realizzato che le specifiche non dicono spazi bianchi aggiuntivi, ma non c'è modo di sopprimere le nuove righe finali nell'output Seriously, quindi non esiste una soluzione Seriously.

Rubino, 40 byte

Nuova soluzione: ruba quel pizzico di magia lanciando alcuni degli altri post qui:

->s{s.gsub(/[a-z]/i){($&.ord+4^31).chr}}

Rubino, 55 46 byte

->s{s.tr'a-zA-Z',[*?A..?Z,*?a..?z].reverse*''}

9 byte di sconto grazie a @manatwork

prova:

->s{s.gsub(/[a-z]/i){($&.ord+4^31).chr}}["Kiltiznnrmt Kfaaovh & Xlwv Tlou"]
=> "Programming Puzzles & Code Golf"

Jolf, 15 byte

~Ai+plpu+_pl_pu
~A              I don't know what to call this, besides "dictionary replace"
  i              the input
   +plpu         previous dictionary: lower + upper alphabet
        +_p1_pu  new dictionary: reversed lower + reversed upper

Prova la suite o provala con i tuoi input

𝔼𝕊𝕄𝕚𝕟 2, 12 caratteri / 26 byte (non competitivo)

ïĪ(ᶐ+ᶛ,ᶐᴙ+ᶛᴙ

Try it here (Firefox only).

Aggiunta la funzione di traslitterazione dopo la pubblicazione della sfida.

Spiegazione

ïĪ(ᶐ+ᶛ,ᶐᴙ+ᶛᴙ // implicit: ï=input
ïĪ(           // transliterate ï...
   ᶐ+ᶛ,       // from uppercase+lowercase alphabet...
       ᶐᴙ+ᶛᴙ  // ... to reversed uppercase+reversed lowercase alphabet
              // implicit output

CJam, 21 byte

q'[,65>__el_@+W%@@+er

Non è una soluzione ottimale ... ancora ... Provalo online

È difficile da spiegare senza raggruppare le cose, quindi ecco una spiegazione generale: ottiene input, sposta due volte l'alfabeto maiuscolo e due volte minuscolo, ruota le cose intorno, combina stringhe maiuscole e minuscole, inverte una e usa la traslitterazione (simile alla risposta Retina).

C (funzione), 50

f(char*s){for(;*s;s++)*s=isalpha(*s)?*s+4^31:*s;}

Questo si basa su tutti e tre i precedenti risposte C, quindi merito a @Ruud, @Danwakeem e @ edc65.

Questa funzione modifica un array di caratteri attivo.

La mia comprensione è che le voci di funzione sono consentite se non esplicitamente vietate nella domanda.

Provalo online.

PostgreSQL, 118 125 byte

SELECT s,TRANSLATE(s,t||UPPER(t),REVERSE(t)||REVERSE(UPPER(t)))
FROM(SELECT text'Programming Puzzles & Code Golf's,text'abcdefghijklmnopqrstuvwxyz't)r

SqlFiddleDemo

Produzione:

╔══════════════════════════════════╦═════════════════════════════════╗
║                s                 ║            translate            ║
╠══════════════════════════════════╬═════════════════════════════════╣
║ Programming Puzzles & Code Golf  ║ Kiltiznnrmt Kfaaovh & Xlwv Tlou ║
╚══════════════════════════════════╩═════════════════════════════════╝

Ingresso: SELECT text'...'s

MODIFICARE:

Inserisci come tabella:

SELECT s,TRANSLATE(s,t||UPPER(t),REVERSE(t)||REVERSE(UPPER(t)))
FROM i,(SELECT text'abcdefghijklmnopqrstuvwxyz't)r
GROUP BY s,t

SqlFiddleDemo

Produzione:

╔══════════════════════════════════╦═════════════════════════════════╗
║                s                 ║            translate            ║
╠══════════════════════════════════╬═════════════════════════════════╣
║ Hello, World!                    ║ Svool, Dliow!                   ║
║ Programming Puzzles & Code Golf  ║ Kiltiznnrmt Kfaaovh & Xlwv Tlou ║
║ abcdefghijklmnopqrstuvwxyz       ║ zyxwvutsrqponmlkjihgfedcba      ║
╚══════════════════════════════════╩═════════════════════════════════╝

Python 3, 195 169 168 166 byte

Grazie a @TrangOul per -2 byte!

Come non ho visto che avrei potuto giocare a golf prima?

x=__import__('string').ascii_letters;y,z=x[26:],x[:26];a,b=y[::-1],z[::-1];print(''.join(b[z.index(i)]if i in b else a[y.index(i)]if i in a else i for i in input()))

(sorta) non golfato:

x = __import__('string').ascii_letters;
y, z = x[26: ], x[: 26];
a, b = y[::-1], z[::-1];
print(''.join(b[z.index(i)]
    if i in b
    else a[y.index(i)]
    if i in a
    else i
    for i in input()
))

Provalo su Ideone!

Python, 61 byte

lambda x:''.join([c,chr(ord(c)+4^31)][c.isalpha()]for c in x)

Una funzione anonima. Sulle lettere, esegue l'operazione di inversione sulla rappresentazione dei bit aggiungendo 4, quindi capovolgendo gli ultimi cinque bit, in modo simile alla risposta Javascript di ETHproductions .

Haskell, 119 104 byte

15 byte salvati grazie a @nimi.

c=fromEnum;s=toEnum;f[]="";f(x:y)|64<c x&&c x<91=s(155-c x):f y|96<c x&&c x<123=s(219-c x):f y|0<1=x:f y

Uso:

f "abcdefghijklmnopqrstuvwxyz"
"zyxwvutsrqponmlkjihgfedcba"

f "Programming Puzzles & Code Golf"
"Kiltiznnrmt Kfaaovh & Xlwv Tlou"

f "Hello, World!"
"Svool, Dliow!"

Spiegazione

let c=fromEnum;s=toEnum;--wrap names for later use, fromEnum gets ascii code from char, toEnum gets char from ascii code
f[]=[];                 --feed empty list (of chars in this case), get empty list
f(x:y)                  --feed a list, separate the first element and...
|64<c x&&c x<91=        --if its an uppercase char (using ascii code range)...
s(c x*(-1)+155)         --  inverse its ascii code value, move it to the range of uppercase and get the new char
                        --  (like rotating half turn a ruler by the side and then sliding it to the space it previously occupied)
:f y                    --  feed the rest of the list and stick the new char in front of the result
|96<c x&&c x<123=       --if its a lowercase char (using ascii code range)...
s(c x*(-1)+219)         --  inverse its ascii code value, move it to the range of lowercase and get the new char
:f y                    --  feed the rest of the list and stick the new char in front of the result
|True=x:f y             --otherwise feed the rest of the list and stick the char in front of the result

Sono nuovo di Haskell ... nella programmazione funzionale ... e nel sito, e so che ci sono (molte) risposte migliori a questa domanda, ma abbiate pazienza.

Perl 6 , 28 byte

{S:g/\w/{chr $/.ord+4+^31}/}

Uso:

# give it a lexical name
my &swap = { … }

say swap 'Programming Puzzles & Code Golf';
# Kiltiznnrmt Kfaaovh & Xlwv Tlou

say swap ('a'..'z').join
# zyxwvutsrqponmlkjihgfedcba

Java, 136 byte

void x(String i){for(char c:i.toCharArray()){if(Character.isLetter(c))c=c<91?(char)(90-(c-65)):(char)(122-(c-97));System.out.print(c);}}

Esempio di utilizzo:

class Test {
  static void x(String i){for(char c:i.toCharArray()){if(Character.isLetter(c))c=c<91?(char)(90-(c-65)):(char)(122-(c-97));System.out.print(c);}}
  public static void main(String[] args) {
    x("Programming Puzzles & Code Golf");
    // produces "Kiltiznnrmt Kfaaovh & Xlwv Tlou"
  }
}

Probabilmente il peggior linguaggio comunemente usato in termini di dimensione dei byte.

Unix shell + tr + printf, 35 byte

tr A-Za-z `printf %s {Z..A} {z..a}`

Ecco a voi una risposta canonica in tr. Ho pensato come poteva una domanda per traslitterare l'alfabeto senza una risposta canonica a tr ansliterate l'alfabeto?

tr da solo non fa nemmeno un "Ciao, mondo!" e come tale non è un linguaggio di programmazione, quindi ho contrassegnato la risposta come non competitiva ^[1] .

[1]: Modifica: attualmente la shell Unix è la lingua e tr è la libreria standard . Grazie a Downgoat e Digital Trauma per avermi aiutato a individuarlo.

05AB1E , 5 byte [non concorrenti]

žnžo‡

Utilizza il set di caratteri CP-1252 .

Provalo online!

Spiegazione:

žn    - Push [A-Za-z]
  žo  - Push [Z-Az-a]
    ‡ - Transliterate.

MATL , 21 28 byte

Utilizza la versione 6.0.0 , che è precedente a questa sfida. Il codice viene eseguito in Octave.

jttk2Y2mXK)o31Z~4-cK(

Esempio

>> matl
 > jttk2Y2mXK)o31Z~4-cK(
 >
> Hello, World!
Svool, Dliow!

Spiegazione

j             % input string
t             % duplicate
tk            % duplicate and convert to lowercase
2Y2           % string 'abc...xyz'
m             % "ismember" function: produces logical index of letter positions
XK            % copy to clipboard K
)             % index into string to get its letters
o31Z~4-       % bitwise XOR with 31 and subtract 4
c             % convert to char
K             % paste logical index from clipboard K
(             % put back modified letters into original string

Vecchio approccio, 28 byte

j1Y2!tkh"t@2#m@0v27b-)wXK)K(

MATLAB, 61 byte

@(x)[abs(-x+ismember(x,65:90)*155+ismember(x,97:122)*219),'']

Ho provato f=@ismember, e rendendo l'intervallo a=65:90una variabile e fare 32+anella seconda ismemberchiamata. Tutto ciò ha abbreviato il codice, ma si tradurrebbe in un programma e quindi richiederebbe entrambi dispeinput .

Questo da:

ans('Hello, World!')
ans =
Svool, Dliow!

ans('Programming Puzzles & Code Golf')
ans =
Kiltiznnrmt Kfaaovh & Xlwv Tlou

Brachylog , 66 byte

_|hH(:64>:91<,77-H+78=X;H:96>:123<,109-H+110=X;HX),[X]:"~c"w,?b:0&

La mancanza di built-in fa davvero male qui, quindi dobbiamo ricorrere a buoni vecchi calcoli di codici ASCII.

Il predicato brachylog_mainprevede una stringa di codici carattere come input e nessun output, ad esbrachylog_main(`Hello, World!`,_).

Spiegazione

_                                                                  § If the input is empty,
                                                                   § return true
                                                                   §
 |                                                                 § Else
                                                                   §
  hH(                                            ),[X]:"~c"w       § Print variable X which
                                                                   § depends on the head of
                                                                   § the input as a char code
                                                                   §
                                                            ,?b:0& § Recursive call on the
                                                                   § tail of the input
                                                                   §
     :64>:91<,77-H+78=X                                            § If H is capital, X =
                                                                   § 77 - H + 78
                       ;                                           § Else if H is non-cap, X=
                        H:96>:123<,109-H+110=X                     § 109 - H + 110
                                              ;                    § Else (not a letter)
                                               HX                  § H = X    

Perl 6, 40 39 byte

Poiché tutti gli altri svolgono funzioni anonime:

my &f=*.trans(/\w/=>{chr $/.ord+4+^31})

(Grazie @ b2gills per la segnalazione)

Utilizza lo stesso bit lanciando voodoo di alcuni degli altri post. Non ero sicuro di includere la dichiarazione variabile / funzione nel conteggio dei byte, quindi l'ho fatto per ogni evenienza. Senza di essa questa soluzione è di soli 34 byte.

Uso:

> f "zyxwvutsrqponmlkjihgfedcba"
abcdefghijklmnopqrstuvwxyz
> f "Kiltiznnrmt Kfaaovh & Xlwv Tlou"
Programming Puzzles & Code Golf
> f "Svool, Dliow!"
Hello, World!

Python 3, 164 159 byte

def f(t,a="abcdefghijklmnopqrstuvwxyz",b=""):
 for c in t:u=64<ord(c)<91;c=c.lower();c=a[::-1][a.index(c)] if c in a else c;b+=c.upper() if u else c
 return b