Écrivez du code dans n'importe quelle langue qui entre une chaîne telle que "Aujourd'hui est un grand jour" (notez qu'il n'y a pas de ponctuation) et le convertissez en "Langue secrète". Voici les règles du "langage secret".

• a = c, b = d, c = e et ainsi de suite (y = a et z = b)
• séparez chaque mot par un espace
• assurez-vous qu'il y a une bonne capitalisation

Exemple:

Input: "Today is a great day"

Output: "Vqfca ku c itgcv fca"

C'est un concours de popularité. Les autres utilisateurs devraient donner des points en recherchant la plupart des codes "au point" mais "uniques".

DÉFI: Je cherchais des langages de programmation inhabituels et j'ai trouvé un langage appelé Piet ( esolang ). Je mets au défi quiconque de l'écrire dans cette langue.

Smalltalk (Smalltalk / X), 29 27 caractères

J'ai de la chance - il est déjà dans la classe String:

'Today is a great day' rot:2
    -> 'Vqfca ku c itgcv fca'

en ajoutant des E / S, cela fait:

(Stdin nextLine rot:2)print

dans l'esprit de l'exemple obscurci de la poignée de porte ci-dessous, que diriez-vous:

Parser evaluate:('(Uvfkp pgzvNkpg tqv:2)rtkpvPN' rot:-2)

Ruby, édition obscurcie (avec commentaire inclus!)

Je suggère de lire le tout; Je trouve ça assez amusant;)

$s='';class Module;def const_missing c

# MAGIC:
$s+="#{c}".split("#{$;}").map{|x|x.ord-8**2}.reduce(:"#{43.chr}").chr;end;end

              # My commentary ;)

ZZZY          # ?
YAYYY         # Oookay; you seem excited
Yaz           # Typo?
Yay           # Better
JEEEEEEF      # You misspelled Jeff's name
LAZZZY        # Yes, you are very lazy
Yax           # Another typo...
LLAMA         # Definitely not completely random at all...
EEEEEEEEEEEEE # Ouch my ears
IIIII         # Ouch stop
ASDFASDFASDF  # I SAID STOP BANGING ON THE KEYBOARD
YUMMY         # ... you eat keyboards?
IIIII         # Stop!
YUMMYY        # Why are you eating your keyboard
LLAMA         # That doesn't make sense :(
VV            # :(
LLAMA         # Could you stop saying that?!
CODEGOLF      # Yay, one of my favorite SE sites! :D
VW            # I don't drive
ASDFASDFASDF  # Why do you keep banging on your keyboard?!?!
EEEEEEEEEEEEE # No
VVV           # Stop
HELLOo        # ...it's a little late for a greeting, isn't it?
DOGS          # ...
OOOOOo        # No, you're not a ghost.
HELLOOOO      # Just a *bit* late.
NNNNNNN       # Huh?
LLAMA         # I said to stop.

print eval$s

Conseils sur la façon dont cela fonctionne (spoilers, survolez pour montrer):

Ce code crée une chaîne, puis l'évalue.

Il utilise const_missingpour construire la chaîne caractère par caractère.

La chaîne qu'il finit par construire est gets.tr'A-Za-z','C-ZABc-zab'.

Postscript

Le QG exige que dorénavant tous les agents reçoivent uniquement des communications sous forme imprimée (car les canaux électroniques se sont révélés trop peu fiables) en utilisant une police spéciale très secrète. Il est de votre responsabilité d'inclure cette procédure top secrète dans le prologue de notre logiciel d'impression:

/define_Secret_font {
    /Secret_font
    /Coronet findfont dup 
    /Encoding get 
    aload pop 256 array astore 
    /secret_proc {
        2 copy
        26 getinterval aload pop 
        26 -2 roll 26 array astore
        putinterval
    } def
    dup 65 secret_proc
    dup 97 secret_proc
    exch dup length dict dup
    3 -1 roll {put dup} forall
    exch /Encoding 4 -1 roll put 
    definefont pop
} def

Et seule cette police est autorisée, par exemple:

define_Secret_font
/Secret_font 36 selectfont
0 841 translate
20 -60 moveto
(Today is a great day) show
20 -120 moveto
(Programming Puzzles & Code Golf) show
showpage

Et c'est ce qu'il imprime:

frapper

Classique.

tr A-Za-z C-ZABc-zab

Exemple:

$ tr A-Za-z C-ZABc-zab <<< "Today is a great day"
Vqfca ku c itgcv fca

DFSORT (programme de tri IBM Mainframe)

 OPTION COPY
 INREC BUILD=(1,80,TRAN=ALTSEQ)

Aucune instruction de contrôle SORT ne peut commencer dans la première colonne.

Pour que ce qui précède fonctionne seul, vous devez modifier la table de traduction alternative d'installation par défaut, pour compenser toutes les valeurs des lettres majuscules et minuscules, en entourant les deux dernières lettres.

Sans changer la table par défaut, il faudrait une instruction ALTSEQ listant toutes les paires de valeurs hexadécimales requises (from-hex-code immédiatement suivi de to-hex-code, chaque paire de valeurs hexadécimales étant séparée par une virgule):

 OPTION COPY
 INREC BUILD=(1,80,TRAN=ALTSEQ)
 ALTSEQ CODE=(xxyy,...)

Donc, pour obtenir les EBCDIC majuscules A à C et B à D:

CODE ALTSEQ = (C1C3, C2C4)

Pour le tout, ce serait beaucoup de saisie sujette aux erreurs, bien sûr, donc vous utiliseriez une autre étape SORT pour générer les cartes de contrôle pour cette étape, et laissez SORT les lire à partir du jeu de données créé par cette nouvelle étape.

Bien sûr, pour n'importe quelle langue qui prend en charge une "table de traduction", c'est aussi simple que de changer la table de traduction. Beau programme COBOL, avec une page de code spécifique, et cela pourrait être fait en une seule ligne de code de procédure COBOL (plus les lignes obligatoires de COBOL qui vont avec tout ... pas tellement dans ce cas particulier).

Oh, le 1,80 est "l'image de la carte" qui contiendra le texte. Probablement tous en majuscules lors de la première exécution ...

C, 75 octets

main(c){while((c=getchar())>0)putchar(isalpha(c)?(c&224)+((c&31)+2)%26:c);}

Exemple:

$echo "Today is a great day" |./a.out
Vqfca ku c itgcv fca

Python

a = list('abcdefghijklmnopqrstuvwxyz')
b = list('yzabcdefghijklmnopqrstuvwx')

c = {}

#generate conversion dictionary

for i in range(len(a)):
    c[a[i]] = b[i]

instring = "the weather is very nice today"

outstring = ""

for i in list(instring):
    try:
        outstring += c[i]
    except:
        outstring += i

print outstring

Production:

rfc ucyrfcp gq tcpw lgac rmbyw

Javascript

// setup alphabet and secret rotated alphabet
//
var alpha=' abcdefghijklmnopqrstuvwxyz'
var rotor=' cdefghijklmnopqrstuvwxyzab'
alpha+=alpha.toUpperCase()
rotor+=rotor.toUpperCase()

function encrypt(str) {
 return crypt(str, alpha, rotor)
}

function decrypt(str) {
 return crypt(str, rotor, alpha)
}

// swap position of char from one dictionary to the other
function crypt(msg, d1, d2) {
 var out=''
 var len=str.length
 for(var i=0; i < len; i++) {
  var c = msg.charAt(i)
  var j = d1.indexOf(c)
  out += d2.charAt(j)
 }
 return out
}

PHP

Pas le plus court cependant!

Exemple en direct: https://eval.in/102173

<?php
$str = 'Today is a great day';
$out = implode('', array_map(function ($val) {
  if ($val == ' ') return ' ';
  $c = ord($val)+2;

  if (ctype_lower($val)) {
    if ($c > ord('z')) {
      return chr(ord('`') + ($c - ord('z')));
    }
    return chr($c);
  }
  else {
    if ($c > ord('Z')) {
      return chr(ord('A') + ($c - ord('Z')));
    }
    return chr($c);
  }  
}, str_split($str)));

var_dump($out);

Remarque:

ord('`') = ord('a') - 1

TI-Basic (le langage qui s'exécute sur les calculatrices graphiques TI-83)

:ClrHome  
:" abcdefghijklmnopqrstuvwxyz" //all symbols that can be interpreted  
:Ans+Ans+Ans->Str1  
:Menu("crippter","encript",1,"decript",2  
:Lbl 2  
:1->C  
:Lbl 1  
:if not(C)  
:Imput ">",Str2  
:if C  
:Imput "<",Str2  
:length(Str2)->D  
:lenght(Str1)/3->E  
:if not(C)  
:Then  
:randInt(1,E)->B  
:sub(Str1,B,1)->Str3  
:Else  
:inString(Str1,sub(Str2,1,1),1)->B  
":"->Str3  
:For(X,1+C,D  
:inString(Str1,sub(Str2,X,1)->A  
:if not(C  
:A+E-B-X->A  
:if C  
:A+B+X-1->A  
:Str3+sub(Str1,A,1)->Str3  
:End  
:if C  
:sub(Str3,2,D-1)->Str3  
:Pause Str3  
:Goto A  

Ceci est un bon logiciel de cryptage (pour une TI-83). Par ti-83, je veux dire n'importe quelle calculatrice de la famille ti-83 ou ti-84. "->" signifie "MAGASIN" accessible par "STO>"

Rubis 40 32

p gets.tr("A-XY-Za-xy-z","C-ZA-Bc-za-b") 

mise à jour (vue depuis la solution basier danieros):

p gets.tr("A-Za-z","C-ZABc-zab")

Java, c'est en fait compréhensible.

Je sais que tout ce qui a des espaces et des parenthèses a du mal sur CG, mais voici un plan.

    class SecretLanguage {

    public static void main(String[] args) {
    for (String S : args) {
        for (char s : S.toCharArray()) {
        System.out.print((char) (s + ((s < 'y') ? 2 : -24)));
        }
        System.out.print(" ");
    }
    }
}

Il existe des concours distincts pour brouiller le code, mais je peux aussi rendre le mien ridicule.

class S{public static void main(String[]args){for(String str:args){for(char i:(str).toCharArray())System.out.print((char)(i+((i<'y')?2:-24)));System.out.print(" ");}}

Javascript

var str = '';
var textInput = 'myString';
for (var i = 0; i < textInput.length; i++) {
    str += textInput.charAt(i).replace(/([a-zA-Z])[^a-zA-Z]*$/, function (a) {
        var c = a.charCodeAt(0);
        switch (c) {
            case 89:
                return 'A'; //Letter Y!
            case 90:
                return 'B'; //Letter Z!
            case 121:
                return 'a'; //Letter y!
            case 122: //Letter z!
                return 'b';
            default:
                return String.fromCharCode(c + 2); //If not y, Y, z, or Z, then just two more from the usual char code
        }
    })
}
console.log(str);

Avec tous les commentaires, mon hamster peut comprendre cela.

Je pense que je vais le ROT2!

Javascript

function r(a,b){return++b?String.fromCharCode((a<"["?91:123)>(a=a.charCodeAt()+2)?a:a-26):a.replace(/[A-z]/g,r)}

console.log(r('Qccipcr'));

Haskell

Voici une implémentation basée sur l'objectif. J'utilise Isopour représenter l'isomorphisme entre le texte normal et le texte converti en langage secret. Sauf si vous fournissez cette --fromoption, l'entrée est convertie dans la langue secrète. Si l' --fromoption est fournie, la conversion opposée est effectuée.

module Main where
import Control.Lens
import System.Environment (getArgs)
import Data.Char          (ord, chr, isUpper, isSpace)
import Data.Word          (Word8)

ord8 :: Char -> Word8
ord8 = fromIntegral . ord

chr8 :: Word8 -> Char
chr8 = chr . fromIntegral

ordIso :: Iso' Char Word8
ordIso = iso ord8 chr8

firstLetterOrd :: Word8 -> Word8
firstLetterOrd n
  | n ^. from ordIso . to isUpper = ord8 'A'
  | otherwise                     = ord8 'a'

secretChar :: Iso' Char Char
secretChar =
  iso toSecret
      fromSecret
  where
    toSecret, fromSecret :: Char -> Char
    toSecret   = secretConversion   2
    fromSecret = secretConversion (-2)

secretConversion :: Int -> Char -> Char
secretConversion n c
  | isSpace c = c
  | otherwise = c & over ordIso (secretShift n)

secretShift :: Int -> Word8 -> Word8
secretShift shiftAmount =
  preserveLetters $ (`mod` 26) . (+ shiftAmount)

preserveLetters :: (Int -> Int) -> Word8 -> Word8
preserveLetters fn n =
  firstLetter + overWord8 fn (n - firstLetter)
  where
    firstLetter = firstLetterOrd n

overWord8 :: (Int -> Int) -> Word8 -> Word8
overWord8 fn = fromIntegral . fn . fromIntegral

help :: IO ()
help =
  putStr
  $ unlines
      ["SecretLang [--from]"
      ,"If the --from option is provided, the program"
      ,"converts from the secret language. Otherwise,"
      ,"it converts to the secret language."
      ]

convertContents :: (String -> String) -> IO ()
convertContents fn = do
  input <- getContents
  putStrLn . ("Output: " ++) $ fn input

main :: IO ()
main = do
  args <- getArgs

  case args of
    ("--from":_) ->
      convertContents (^. mapping (from secretChar))

    ("--help":_) -> help
    ("-h"    :_) -> help

    _            ->
      convertContents (^. mapping secretChar)

Exemples:

$ ./SecretLang
Today is a great day
Output: Vqfca ku c itgcv fca

$ ./SecretLang --from
Vqfca ku c itgcv fca
Output: Today is a great day

C

    #include<stdio.h>

    int main()
    { char p[256];
    int i;
    fgets ( p, 256, stdin );
    for(i=0; i<256 ; i++)
    {
   if ( p[i] == '\n' )
    {
    p[i] = '\0';
    break;
    }
    else
    {

    if((p[i] >= 'a' && p[i] <= 'x') || (p[i] >= 'A' && p[i] <= 'X') )
    {
        p[i] +=2;
    }

    else
    {
    switch(p[i])
     {
        case 'y':    p[i] = 'a';
                     break;

       case 'Y':    p[i] = 'A';
                     break;

       case 'z':    p[i] = 'b';
                     break;
       case 'Z':    p[i] = 'B';
                     break;
       case ' ':    p[i] = ' ';
                     break;


     }
    }
}}

printf("%s", p);

    return 0;
 }

EcmaScript 6:

alert(prompt(_='').split(_).map(x=>String.fromCharCode(x.charCodeAt()+(x>' '?x>'x'|x>'X'&x<'['?-24:2:0))).join(_))

JAVA

32est spacedonc nous l' imprimer tout comme
88est Xdonc rien de moins que 89se déplace jusqu'à 2 caractères
90est Zdonc rien de moins que 91se déplace vers le bas de 24 caractères (avec rien de moins que 89déjà traité de façon seulement 89et 90efficace)
Répétez même processus pour les lettres minuscules, allant de 97aussi aà 122que z.

void secret(String s) {
    for (char c : s.toCharArray()) {
        System.out.print((char)(c == 32 ? c : c < 89 ? c + 2 : c < 91 ? c - 24 : c < 121 ? c + 2 : c - 24));
    }
}

Powershell

$chars = [int]('a')[0]..[int]('z')[0] | %{ [char]$_, [char]::ToUpper([char]$_) }

$y = $args[0].ToCharArray() | %{
    $idx = $chars.indexOf($_);
    if ($idx -ge 0) {
        $chars[($idx + 4) % 52]
    } else  {
        $_
    } 
}

-join [char[]]$y

Production:

PS C:\Temp> .\z.ps1 "Today is a great day"
Vqfca ku c itgcv fca
PS C:\Temp>

PHP

Cette solution est plutôt ennuyeuse:

echo strtr('Today is a great day','ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz','CDEFGHIJKLMNOPQRSTUVWXYZABcdefghijklmnopqrstuvwxyzab');

Python 3

Je pense que je n'ai pas bien compris la question, mais de toute façon:

alphabet = "abcdefghijklmnopqrstuvwxyz"
rot = alphabet[2:] + alphabet[:2]
rot = rot + rot.upper()
alphabet = alphabet + alphabet.upper()

def encode_letter(letter):
    return rot[alphabet.index(letter)]

def encode_word(word):
    return "".join(encode_letter(letter) for letter in word)

def encode_string(string):
    return " ".join(encode_word(word) for word in string.split())

print("Output: " + encode_string(input("Input: ")))

Python 2.x

Une tentative de solution Python riche en fonctionnalités.

Fonctionnalités:

• l'utilisation d'un dict
• gérer la liste de manière circulaire, de sorte que cela shift=2peut être modifié
• vous pouvez également l'utiliser pour déchiffrer quand vous le savez shift(utilisez simplement moins), cela vous permettra également de tester votre sortie.
• possibilité d'ajouter des "étendues mobiles" - des étendues dans lesquelles vous pédalez
• soit strictpour les caractères non définis, soit pour renvoyer simplement le caractère d'entrée non défini.
• une langue secrète ne laisse aucune trace;)

Voici:

# Shifting scopes
lower_case = map(chr, range(97, 123))
upper_case = map(chr, range(65, 91))
space = [" "] # space will always be transformed to space

def secret(instring, shift, scopes, strict=False):
    def buildTranslationDict(scores):
        translation_dict = {}
        for scope in scopes: 
            for index in range(len(scope)): 
                translation_dict[scope[index]] = scope[(index+shift) % len(scope)]
        return translation_dict 
    translation_dict = buildTranslationDict(scopes)
    # Use the translation dictionary to transform input
    output = ""        
    for char in instring:
        if strict:
           output += translation_dict[char]   # will crash if unexpected char
        else:
            try:    
               output += translation_dict[char]
            except: 
               output += char
    return output    

Preuve:

secret(instring="Today is a great day", shift=2, scopes=[lower_case, upper_case, space])
'Vqfca ku c itgcv fca'

Pouvez-vous déchiffrer 'Wrpruurz lv qrw edg hlwkhu!':)?

BrainFuck étendu

Puisqu'il s'agit d'un concours de popularité, j'ai écrit ceci dans le but qu'il soit aussi facile à suivre que l'EBF. C'est très commenté et j'ai intentionnellement utilisé des macros pour rendre le programme plus littéral.

La chose la plus difficile ici est probablement l'interrupteur principal car EBF n'a pas de moyen spécial de le faire, donc ce n'est en réalité pas plus simple que la façon dont on le ferait dans BrainFuck, sauf pour les variables et les parenthèses d'équilibrage.

;;;; rot2.ebf : Perform rot2 on ascii text
;;;; Usage: bf ebf.bf < rot2.ebf > rot2.bf
;;;;        echo "Today is a great day" | bf rot2.bf
;;;;        # => Vqfca ku c itgcv fca
;;;;
;;;; BF interpreter/Compiler requirement: 
;;;; Wrapping cells at any size (allmost all of them do)
;;;;


;;; Memory map  
:tmp    ; a temporary cell used for the read routine
:input  ; a copy of the input for output purposes
:switch ; a copy of the input for the switch statements
:flag   ; flag to indicate the predicate has been processed or not

;;; Macros
;; Ultracompatible read
;; supports EOF 0, -1 and no change
{read_tmp 
  $input+ 
  $tmp(-),
  [+[-$input-]] ; blanks for all EOFs
  $switch [
    @input &clear
    $switch
  ]
}

;; for the switch we need
;; to do destructive testing
;; and we need to preserve the
;; original as well. 
{copy_input 
  $tmp(-$input+$switch+)
}

;; clears the cell
{clear (-)}

;; prints current cell
{print .}

;;; Main proram
;;; flow starts here
&read_tmp
while $tmp not eof
(
  &copy_input
  $flag+
  $switch 10-(22-(
    ;; not linefeed/space
    $switch 57-(-(31-(-(
       ;; default: not wrapping
       &clear
       $flag-
       $input 2+))))
    $flag (-
       ;; wrapping
       $input 24-)))
  $flag &clear
  $input &print &clear
  &read_tmp
)
;;; End

Javascript

var STR = "Today is a great day";
//so i can replace chars at a index in the string
String.prototype.replaceAt=function(i, char) {
    var a = this.split("");
    a[i] = char;
    return a.join("");
}

function secretIt( str ){
    for( var i = 0; i < str.length; i++ ) {
        var c = str.charCodeAt( i );
        /**
        * check for spaces first
        * check if get outside of the letter range for both lower and upper
        * if we dont go then were good
        * if so go back 26 chars
        */
        str = str.replaceAt( i, String.fromCharCode( ( c == 32 ) ? c : ( ( c = c + 2 ) > 91 && c < 97 || c < 123 ) ? c : c - 26 ) ) ;
    }
    return str;
}

console.log( secretIt( "Qsncp qcapcr ambc" ), ' ' , secretIt( STR ));

Q

{x^(raze a!'rotate[2] each a:.Q`a`A)x}

Java

void sl(String s){
    for (char c: s.toCharArray()){
        char l = Character.toLowerCase(c);
        System.out.print((char)(c + (l < 'y'? l < 'a'? 0: 2: -24)));
    }
}

C #, 163

Oui, ce n'est pas du golf de code. Je suis allé le plus court de toute façon (ou du moins, j'ai fait un premier coup de couteau)

using System.Linq;class P{static void Main(string[]a){System.Console.WriteLine(string.Concat(a[0].Select(c=>(char)(c==32?c:c<89?c+2:c<91?c-24:c<121?c+2:c-24))));}}

Formaté:

using System.Linq;
class P
{
    static void Main(string[] a)
    {
        System.Console.WriteLine(string.Concat(a[0].Select(c => (char)(c == 32 ? c : c < 89 ? c + 2 : c < 91 ? c - 24 : c < 121 ? c + 2 : c - 24))));
    }
}

Oui, j'ai jeté un œil à la réponse des ufis .

C # 5KB

(381 caractères)

391

using System;
namespace WinHelper {
    class P {
        static void Main(string[] args) {
            char[] f =  "abcdefghijklmnopqrstuvwxyz ".ToCharArray();
            char[] g =  "cdefghijklmnopqrstuvwxyzab ".ToCharArray();

            foreach (char c in Console.ReadLine().ToCharArray().ToLower()) 
                Console.Write(g[Array.FindIndex(f, a => a == c)]);
        }
    }
}

Bash, 8 caractères

... s'il vous arrive d'avoir le paquet bsdgames installé! Lit à partir de l'entrée standard.

caesar 2

Exemple

echo Today is a great day|caesar 2

Production: Vqfca ku c itgcv fca

C

#include <stdio.h>
char c[100];
int main()
{
gets(c);
char *p=c,x;
while(*p)
{
    x=*p;
    if(x>='a'&&x<='z')
    {
        *p=((*p-'a'+2)%(26)+'a');
    }
    if(x>='A'&&x<='Z')
    {
        *p=((*p-'A'+2)%(26)+'A');
    }

    p++;
}
puts(c);
}