Échangez l'alphabet

48

Dans ce défi, vous allez "inverser" l'alphabet ou échanger a-zavec z-a. Ceci est communément appelé le chiffre Atbash .

Comme cette transformation donne à la sortie l'apparence d'une langue étrangère, votre code devra être aussi court que possible.

Exemples

abcdefghijklmnopqrstuvwxyz
zyxwvutsrqponmlkjihgfedcba

Programming Puzzles & Code Golf
Kiltiznnrmt Kfaaovh & Xlwv Tlou

Hello, World!
Svool, Dliow!

spécification

  • L'entrée peut contenir plusieurs lignes et sera uniquement en ASCII.
  • Aucun espace supplémentaire ne doit être ajouté à la sortie
  • Le boîtier doit être préservé

Classement

Afficher l'extrait de code

C'est code-golf donc le code le plus court en octets gagne

code-golf  string 
— Downgoat
source
24
+1 pour la justification "Comme cette transformation donne à la sortie l'apparence d'une langue étrangère, votre code doit être aussi court que possible."
— chat le
11
Quelques Anecdotes: c'est Atbash , un chiffre connu aussi vieux que la bible.
— Jacob le
6
"Parce que cette transformation donne à la sortie l'apparence d'une langue étrangère, votre code devra être aussi court que possible." Quelle sorte de logique est-ce?? Comme votre description soulève à peu près autant de points d'interrogation que si elle avait été écrite dans une langue étrangère, votre réponse à cette question devrait être en langage naturel intelligible et une certaine verbosité est appréciée.
— Bart
Kiltiznnrmt Kfaaovh & Xlwv Tlou devrait être le nouveau site de "Programmation Trivials & Code Bowling" ...
— Erik the Outgolfer
Pourquoi n'autorisez-vous pas d'espaces supplémentaires? Cela le rend impossible dans certaines langues qui ont toujours une fin de ligne. Je ne le vois pas ajouter quoi que ce soit au défi.
— Fruit Esolanging

Réponses:

11

Pyth, 8 octets

XXzG)rG1

@xnor a suggéré cette approche plus simple sur la réponse Pyth de @ FryAmTheEggman, puis je l'ai traduite en Pyth.

Ceci utilise le comportement pratique de X(translate) quand on ne donne que deux arguments: il traduit du second argument au second argument inversé. Nous faisons cela d'abord avec l'alphabet minuscule ( G), puis avec une majuscule G.

— lirtosiast
source
16

C, 59 octets

Désolé d’avoir à nouveau évoqué C, mais j’ai été un peu déçu de ne voir que les fonctions C ici. J'avais l'impression que OP recherchait un produit utilisable.

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

Compilé sur Ubuntu 14.04 avec un simple:

cc swalpha.c

L'exécutable résultant lit n'importe quel nombre de lignes de stdin et écrit le résultat dans stdout.

Merci à tant d’autres affiches pour le tour XOR.

— Ruud Helderman
source
11

CJam, 17 octets

Je voulais aider GamrCorps à gérer sa solution CJam, mais le résultat a été si différent que j'ai décidé de donner une réponse distincte.

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

Essayez-le en ligne.

Explication

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.
— Martin Ender
source
4
Eh bien, je suis content que vous essayiez d'aider! C'est la solution que j'essayais de faire, je ne pouvais tout simplement pas comprendre le XOR. Bon travail!
— GamrCorps
1
La coloration syntaxique de SE déteste les esolangs.
— Cyoce
@ Cyoce Ils n'ont probablement pas le temps; compte tenu du nombre de langues sur ce site. Cela dit, CJam est probablement l’un des plus faciles, car elle ne se modifie pas elle-même et a une structure assez claire. J'aimerais les voir essayer d'ajouter la surbrillance de la syntaxe à un langage qui se modifie lui-même, comme ///.
— Fruit Esolanging
@ Challenger5 afaik, la coloration syntaxique utilise simplement la prétention de Google, il faudrait y ajouter divers esolangs.
— Martin Ender
11

JavaScript (ES6), 69 à 67 octets

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

Utilise la même stratégie que ma réponse 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.

Maudissez vos noms de propriété incroyablement longs, JS ...

— ETHproductions
source
1
+1 pour avoir mentionné les noms de propriété extrêmement longs de JS. Mon préféré est toujours l'infâmedocument.getElementById
— Cyoce
2
@Cyoce Try document.getElementsByClassNameou, sur Firefox et Chrome,document.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC
— Ismael Miguel
Cela ne semble être que 66 octets et non 67
— Downgoat
@ Doᴡɴɢᴏᴀᴛ Vous avez raison à ce sujet, merci!
— ETHproductions
Il semble que vous manquiez d'un crochet de fermeture à la fin du code golfé.
— starbeamrainbowlabs
10

Retina , 17 14 13 bytes

Code:

\T`w`_dZ-Az-a

Explication:

\             # 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

Cela fait des trucs magiques et complète la tâche.

Essayez ici .

— Adnan
source
2
Heureusement que j'ai récemment ajouté \. Malheureusement, je n'ai pas encore ajouté de classes de caractères pour les lettres et les classes de caractères inversées.
— Martin Ender
@ MartinBüttner Très chanceux, cela a presque invalidé ma réponse :)
— Adnan
Pour référence, à partir de Retina 0.7.2, vous pouvez le faire \T`lL`RlRL.
— Martin Ender
9

Pyth, 10 9

uXGr;H)2z

Merci à Jakube d’avoir économisé un octet avec la nouvelle fonctionnalité de ;!

Suite de tests

Une explication rapide: réduisez en commençant par la saisie par les nombres 0 et 1. L’opération à effectuer consiste à traduire l’alphabet en minuscule avec r...0ou r...1les fonctions inférieure et supérieure de python, respectivement, qui lui sont appliquées, puis inversées.

— FryAmTheEggman
source
1
9 octets en raison d'une nouvelle fonctionnalité (pas même d'un jour):uXGr;H)2z
— Jakube
5
Pouvez-vous ajouter une explication?
— TanMath
1
Ne pouvez-vous pas utiliser Xl'alphabet, puis l'alphabet en majuscule?
— xnor
1
@xnor XXzG)rG1? Cela semble fonctionner.
— lirtosiast
Ou peut-être que X sur les alphabets minuscules et majuscules est concaténé, puis remplacez le casse? C'est probablement plus long, en fait.
— xnor
6

Julia, 74 61 47 octets

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

C'est une fonction lambda qui accepte une chaîne et renvoie une chaîne. Pour l'appeler, assignez-le à une variable.

Nous apparions chaque lettre en utilisant une expression régulière et remplaçons chaque lettre par le caractère ASCII correspondant à 31 X ou le code ASCII de la lettre, moins 4.

— Alex A.
source
Wow, c'est très élégant. Je reçois un avertissement de dépréciation pour $que vous souhaitiez peut-être le mettre à jour ⊻. Je ne savais pas que vous pouvez utiliser une fonction dans replace.
— niczky12
5

C, 150 129 octets

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

Cette fonction convertit simplement char en int et ajoute le décalage approprié à int avant l'impression. Je sais que ce n'est pas le plus court, mais je n'ai pas vu une implémentation en C.

Exemple d'utilisation

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

UPDATE: raccourci un nom de variable.

— Danwakeem
source
Bienvenue dans Programmation Puzzles et Code Golf Stack Exchange! C'est une très bonne approche. On pourrait jouer plus au golf en faisant en sorte que toutes les variables (y compris temp) aient exactement un caractère.
— wizzwizz4
Ahh tu as raison! Je vais regolf celui-ci
— Danwakeem
1
Pensez-vous que vous pourriez essayer mon défi? Analysez votre chaise
— wizzwizz4
1
Oui, cela fonctionnera sans les en-têtes, vous obtenez juste un avertissement du compilateur @ edc65 Je pense, car il compile et s'exécute, il ne sera pas considéré comme de la triche mais dans le monde réel, vous devriez toujours inclure les en-têtes.
— Danwakeem
1
107 octets:i,t;r(char*s){for(;i<strlen(s);i++){t=s[i]+25;t=t<116?180-t:244-t;isalpha(s[i])?putchar(t):putchar(s[i]);}}
— Spikatrix
5

Japt, 23 22 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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
— ETHproductions
source
Belle idée (que j'ai empruntée ...) d'utiliser XOR pour cela
— Luis Mendo
5

C, 64

Une fonction void qui modifie la chaîne en place.

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

Test: ideone

— edc65
source
1
c;t(char*p){for(;c=*p;)*p++=c>64&c<91|c>96&c<123?(c^31)-4:c;}
— Spikatrix
@CoolGuy oui, mais je n'aime pas le rôle global à l'intérieur d'une fonction ... c'est juste pour moi
— edc65
N'est-ce pas 64 octets?
— Downgoat
@ Oui, c'est .. merci ..
— edc65
5

R, 69 61 octets

Merci à @Giuseppe pour avoir supprimé quelques octets supplémentaires:

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

La version précédente:

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

Ceci est une fonction anonyme. Usage:

> 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.
— planificateur
source
1
intToUtf8(c(122:97,90:65))au lieu des rawconversions, et vous pouvez vous en débarrasser catégalement. Je prends l'habitude de jouer au golf avec vos réponses à plus d'un an ...
— Giuseppe
4

Sérieusement, 31 octets (non concurrents)

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

Décharge Hex:

a3a3962bbba352a396522bbc2c603bbda1755744be452858305758604dee6a

Essayez-le en ligne

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

Je viens de me rendre compte que les spécifications n'imposent aucun espace supplémentaire, mais il n'y a aucun moyen de supprimer les nouvelles lignes en sortie dans Seriously, donc il n'y a pas de solution Seriously.

— quintopie
source
1
Que ESACREPPUesacrewolsignifie
— Downgoat
3
@ Doᴡɴɢᴏᴀᴛ UPPERCASE inversé LOWERCASE inversé
— Mama Fun Roll
2
l'alphabet majuscule inversé précédé de l'alphabet minuscule inversé
— quintopia le
4

Ruby, 40 octets

Nouvelle solution: vous avez volé la magie de quelques-uns des autres messages ici:

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

Ruby, 55 46 octets

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

9 octets de moins grâce à @manatwork

essai:

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

2, 12 caractères / 26 octets (non concurrentiel)

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

Try it here (Firefox only).

Ajout de la fonction de translittération après la publication du défi.

Explication

ïĪ(ᶐ+ᶛ,ᶐᴙ+ᶛᴙ // implicit: ï=input
ïĪ(           // transliterate ï...
   ᶐ+ᶛ,       // from uppercase+lowercase alphabet...
       ᶐᴙ+ᶛᴙ  // ... to reversed uppercase+reversed lowercase alphabet
              // implicit output
— Maman Fun Roll
source
Je pensais que 𝔼𝕊𝕄𝕚𝕟 2 allait s'appeler ∞?
— Downgoat
1
Non, j'ai décidé de garder ça pour une langue complémentaire (mais différente) pour.
— Mama Fun Roll
IIRC Il y a un tableau en gras 2.
— Conor O'Brien
@ ՊՓԼՃՐՊՃՈԲՍԼ Appelez-le ESMax (en doublestruck).
— mbomb007
3

CJam, 21 octets

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

Pas une solution optimale ... pour l'instant ... Essayez-le en ligne

Il est difficile à expliquer sans regrouper les éléments. Voici donc une explication générale: obtient une entrée, insère deux fois l’alphabet majuscule et deux fois en minuscule, fait pivoter les éléments, combine les chaînes majuscules et minuscules, l’inverse et utilise la translittération (similaire à la réponse Retina).

— GamrCorps
source
Est-ce que cette sortie est un retour à la ligne?
— LegionMammal978
@ LegionMammal978 Cela ne devrait pas, sauf si aditsu, changer la façon dont la pile est sortie.
— GamrCorps
@ LegionMammal978 Je ne le fais pas.
— Martin Ender
3

PostgreSQL, 118 125 octets

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

Sortie:

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

Contribution: SELECT text'...'s

MODIFIER:

Entrée sous forme de tableau:

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

SqlFiddleDemo

Sortie:

╔══════════════════════════════════╦═════════════════════════════════╗
║                s                 ║            translate            ║
╠══════════════════════════════════╬═════════════════════════════════╣
║ Hello, World!                    ║ Svool, Dliow!                   ║
║ Programming Puzzles & Code Golf  ║ Kiltiznnrmt Kfaaovh & Xlwv Tlou ║
║ abcdefghijklmnopqrstuvwxyz       ║ zyxwvutsrqponmlkjihgfedcba      ║
╚══════════════════════════════════╩═════════════════════════════════╝
— lad2025
source
Hey lad2025, je pense que c'est plus court que 118, mais je ne suis pas un expert dans les règles de comptage
— t-clausen.dk
2

Python 3, 195 169 168 166 octets

Merci à @TrangOul pour -2 octets!

Comment n'ai-je pas vu que j'aurais pu jouer cela auparavant? 

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) ungolfed:

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

Essayez-le sur Ideone!

— chat
source
1
Vous pouvez économiser 2 octets en supprimant le plus externe []de join.
— Trang Oul
@ TrangOul vraiment? C'est une compréhension de la liste, alors j'ai pensé qu'elle devait être une liste sinon vous aurez generator object <genexpr> at..., mais je vais la tester
— cat
@TrangOul Nevermind, j'ai appris quelque chose, merci!
— chat le
Tous les [contenant des strvaleurs] itérables peuvent être passés à join()function.
— Trang Oul
2

Python, 61 octets

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

Une fonction anonyme. Sur les lettres, effectue l’opération d’inversion sur la représentation des bits en ajoutant 4, puis en retournant les cinq derniers bits, comme pour la réponse Javascript d’ ETHproductions .

— Xnor
source
Je viens d'écrire exactement la même chose haha
— sagiksp
2

Haskell, 119 à 104 octets

Sauvegardé 15 octets grâce à @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

Usage:

f "abcdefghijklmnopqrstuvwxyz"
"zyxwvutsrqponmlkjihgfedcba"

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

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

Explication 

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

Je suis nouveau à Haskell ... en programmation fonctionnelle ... et sur le site, et je sais qu'il existe de nombreuses meilleures réponses à cette question, mais supportez-moi.

— oreilles moelleuses
source
Quelques conseils de golf: a) pas besoin d’utiliser let. Commencez directement avec c=fromEnum. Utilisez (155-c x)et (219-c x). c) Truepeut être remplacé par 1<2. - Le code ne parvient pas à charger pour moi avec l'erreur "ambigu type type" pour les fonctions cet s(ghci 7.10.2), mais cela peut facilement être corrigé avec f[]=""au lieu de f[]=[].
— nimi
Merci!, Je me demandais en fait s'il était valide sans "let", puisqu'il ne fonctionnait pas directement sur GHC.
— oreilles moelleuses
2

Perl 6 , 28 octets

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

Usage:

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

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

say swap ('a'..'z').join
# zyxwvutsrqponmlkjihgfedcba
— Brad Gilbert b2gills
source
Quand je lance ceci, il dit: Warning: Use of "ord" without parentheses is ambiguous at (eval 8)[/System/Library/Perl/5.18/perl5db.pl:732] line 2.Je ne sais rien de Perl, est-ce que je fais quelque chose de mal? Comment pourrais-je courir ceci?
— Downgoat
@ Doᴡɴɢᴏᴀᴛ Si vous remarquez que cela est écrit en Perl 6, vous pouvez aller à # perl6 sur freenode et taperm: my &swap = {S:g/\w/{chr $/.ord+4+^31}/}; say swap ('a'..'z').join
— Brad Gilbert b2gills
Ah ok, apparemment je ne sais pas lire: P
— Downgoat
@ Doᴡɴɢᴏᴀᴛ j'ai ajouté une note que vous pouvez le tester sur # perl6 sur freenode
— Brad Gilbert b2gills
2

Java, 136 octets

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

Exemple d'utilisation:

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

Probablement le pire langage couramment utilisé en termes de taille en octets.

— Sean
source
1
— Rédigé le
Je sais que cela a été posté il y a environ un an et demi, mais vous pouvez void x(String i){for(Character c:i.toCharArray())System.out.print(c.isLetter(c)?(char)(c<91?90-(c-65):122-(c-97)):c);}
— jouer au
Ou même plus court: void y(String i){for(int c:i.getBytes())System.out.print((char)(c>65&c<91|c>96&c<123?c<91?90-(c-65):122-(c-97):c));}( 116 bytes )
— Kevin Cruijssen le
1
@KevinCruijssen Vous pouvez également réorganiser les calculs pour éliminer le besoin de parenthèses en effectuant un basculement 90-(c-65)dans -c+65+90 et 122-(‌​c-97)dans -c+97+122, ce qui enregistre un octet chacun.
— Zavada
2

Shell Unix + tr + printf, 35 octets

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

Ici vous êtes, une réponse canonique en tr. Je pensais comment une question translittération l'alphabet aller sans réponse canonique à tr ansliterate l'alphabet?

tr à lui seul ne fait même pas un "Hello, World!" et comme tel n’est pas un langage de programmation, j’ai donc marqué la réponse comme non compétitive [1] .

[1]: Edit: En fait, le shell Unix est la langue et tr est la bibliothèque standard . Merci à Downgoat et à Digital Trauma de m'avoir aidé à le comprendre.

— utilisateur48538
source
3
Je pense que c'est bien de réclamer shell ou bash en tant que langage et utilitaires communs ( tren coreutils) en tant que bibliothèque standard. Voir d'innombrables de mes réponses ;-)
— Digital Trauma
1
Mais cela ne fonctionne pas: tr: range-endpoints of 'Z-A' are in reverse collating sequence order. Je pense que vous devez faire quelque chose comme tr A-Za-z $(printf %s {Z..A} {z..a})(et remplacer $( )par des backticks)
— Digital Trauma
@ DigitalTrauma, mais tout le monde n’a pas printf sur son système.
— user48538
7
Je pense que vous auriez beaucoup de mal à trouver un système Unix qui n’a pas printf, après tout, sa spécification par Posix . C'est aussi une bash qui est assez omniprésente de nos jours. Quoi qu'il en soit, avoir quelque chose de pré-installé sur le système de tout le monde n'est pas une condition préalable au code-golf - tout le monde n'a pas CJam sur son système non plus ;-)
— Digital Trauma
1
L'espace entre }et {est requis - sinon l'extension devient quelque chose commeZz Zy Zx ... Za Yz ... Aa
— Digital Trauma
1

MATL , 21 28 octets

Utilise la version 6.0.0 , qui est antérieure à ce défi. Le code s'exécute dans Octave.

jttk2Y2mXK)o31Z~4-cK(

Exemple

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

Explication

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

Ancienne approche, 28 octets

j1Y2!tkh"t@2#m@0v27b-)wXK)K(
— Luis Mendo
source
1

MATLAB, 61 octets

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

J'ai essayé f=@ismember, et en faisant la gamme a=65:90une variable et fais 32+adans le deuxième ismemberappel. Tout cela a raccourci le code, mais aboutirait à un programme et nécessiterait donc les deux dispet input.

Cela donne:

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

ans('Programming Puzzles & Code Golf')
ans =
Kiltiznnrmt Kfaaovh & Xlwv Tlou
— Stewie Griffin
source
1

Brachylog , 66 octets

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

Le manque de fonctions intégrées fait vraiment mal ici, nous devons donc recourir à de bons vieux calculs de codes ASCII.

Le prédicat brachylog_mainattend une chaîne de codes de caractères en entrée et aucune sortie, par exemplebrachylog_main(`Hello, World!`,_).

Explication

_                                                                  § 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
— Fataliser
source
1

Perl 6, 40 39 octets

Puisque tout le monde fait des fonctions anonymes:

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

(Merci @ b2gills pour le tuyau)

Utilise le même bit en retournant vaudou que certains des autres messages. Je ne savais pas s'il fallait inclure la déclaration de variable / fonction dans le nombre d'octets, alors je l'ai fait au cas où. Sans cela, cette solution n’est que de 34 octets.

Usage:

> f "zyxwvutsrqponmlkjihgfedcba"
abcdefghijklmnopqrstuvwxyz
> f "Kiltiznnrmt Kfaaovh & Xlwv Tlou"
Programming Puzzles & Code Golf
> f "Svool, Dliow!"
Hello, World!
— Touches de raccourci
source
Vous pouvez utiliser *.trans(…)pour le rendre plus court.
— Brad Gilbert b2gills
1

Python 3, 164 159 octets

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
— Argenis García
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.