Escriba un código en cualquier idioma que ingrese una cadena como "Hoy es un gran día" (Tenga en cuenta que no hay puntuación) y lo convierte al "Idioma secreto". Aquí están las reglas para el "lenguaje secreto".

• a = c, b = d, c = e y así sucesivamente (y = a y z = b)
• separe cada palabra por un espacio
• asegúrese de que haya una capitalización adecuada

Ejemplo:

Input: "Today is a great day"

Output: "Vqfca ku c itgcv fca"

Es un concurso de popularidad. Otros usuarios deberían dar puntos buscando la mayoría del código "al punto" pero "único".

DESAFÍO: Estaba buscando lenguajes de programación poco comunes y encontré un lenguaje llamado Piet ( esolang ). Reto a cualquiera a que lo escriba en este idioma.

Smalltalk (Smalltalk / X), 29 27 caracteres

Tengo suerte, ya está en la clase String:

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

agregando E / S, esto hace que:

(Stdin nextLine rot:2)print

en el espíritu del ejemplo ofuscado del pomo de la puerta a continuación, ¿qué tal:

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

Ruby, edición ofuscada (¡con comentarios incluidos!)

Sugiero leer todo el asunto; Lo encuentro bastante divertido;)

$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

Sugerencias sobre cómo funciona (spoilers, mostrar para mostrar):

Este código crea una cadena y luego la evalúa.

Se utiliza const_missingpara construir la cadena carácter por carácter.

La cadena que termina construyendo es gets.tr'A-Za-z','C-ZABc-zab'.

Posdata

El cuartel general requiere que, de ahora en adelante, todos los agentes reciban comunicación solo en forma impresa (ya que los canales electrónicos resultaron demasiado poco confiables) utilizando una fuente especial de alto secreto. Es su responsabilidad incluir este procedimiento de alto secreto en el prólogo de nuestro software de impresión:

/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

Y solo se permite esa fuente, por ejemplo:

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

Y eso es lo que imprime:

golpetazo

Clásico.

tr A-Za-z C-ZABc-zab

Ejemplo:

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

DFSORT (programa de clasificación de mainframe de IBM)

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

Ninguna instrucción de control SORT puede comenzar en la columna uno.

Para que lo anterior funcione solo, tendría que cambiar la tabla de traducción alternativa de instalación predeterminada, para compensar todos los valores de letras mayúsculas y minúsculas, envolviendo las dos letras finales.

Sin cambiar la tabla predeterminada, se requeriría una declaración ALTSEQ que enumerara todos los pares de valores hexadecimales requeridos (código de hexadecimal seguido inmediatamente por código de hexadecimal, cada par de valores hexadecimales separados por una coma):

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

Entonces, para obtener EBCDIC en mayúsculas A a C y B a D:

CÓDIGO ALTSEQ = (C1C3, C2C4)

Para todo, eso sería una gran cantidad de tipeos propensos a errores, por supuesto, por lo que usaría otro paso SORT para generar las tarjetas de control para este paso, y dejaría que SORT las leyera desde el conjunto de datos creado por ese nuevo paso.

Por supuesto, para cualquier idioma que admita una "tabla de traducción", es tan fácil como cambiar la tabla de traducción. Buen programa COBOL, con una página de códigos específica, y podría hacerse en una línea de código de procedimiento COBOL (más las líneas obligatorias de COBOL que van con todo ... no muchas en este caso en particular).

Oh, el 1,80 es la "imagen de la tarjeta" que contendrá el texto. Probablemente todo en mayúsculas en la primera ejecución ...

C, 75 bytes

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

Ejemplo:

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

Pitón

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

Salida:

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

¡No es el más corto!

Ejemplo en vivo: 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);

Nota:

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

TI-Basic (el lenguaje que se ejecuta en las calculadoras gráficas 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  

Este es un buen software de encriptación (para una TI-83). Por ti-83 me refiero a cualquier calculadora de la familia ti-83 o ti-84. "->" significa "TIENDA" accedido por "STO>"

Rubí 40 32

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

actualización (como se ve desde danieros bash solution):

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

Java, en realidad es comprensible.

Sé que cualquier cosa con espacios en blanco y paréntesis tiene dificultades en CG, pero aquí hay una oportunidad.

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

Hay concursos por separado para ofuscar código, pero también puedo hacer que el mío sea ridículo.

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

Con todos los comentarios, mi hámster puede entender esto.

¡Creo que lo 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

Aquí hay una implementación basada en lentes. Estoy usando Isopara representar el isomorfismo entre el texto normal y el texto convertido al lenguaje secreto. A menos que proporcione la --fromopción, la entrada se convierte al idioma secreto. Si --fromse proporciona la opción, se realiza la conversión opuesta.

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)

Ejemplos:

$ ./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

32es spaceasí que imprimirlo como es
88es Xasí que cualquier cosa menos que 89se mueve hacia arriba 2 caracteres
90es Zasí que cualquier cosa menos de 91proyección por 24 caracteres (con algo menos que 89ya se maneja de manera única 89y 90efectiva)
Repita el proceso en letras minúsculas, que van desde 97como aa 122lo 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));
    }
}

Potencia Shell

$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

Salida:

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

PHP

Esta solución es bastante aburrida:

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

Python 3

Creo que no entendí bien la pregunta, pero de todos modos:

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

Un intento de una solución Python rica en funciones.

caracteristicas:

• el uso de un dict
• manejar la lista de forma circular, para que shift=2pueda variarse
• También puede usarlo para descifrar cuando lo sepa shift(solo use menos), también le permitirá probar su salida.
• capacidad de agregar "ámbitos cambiantes": ámbitos en los que realiza un ciclo
• opción para ser strictpara caracteres indefinidos, o simplemente devolver el carácter de entrada indefinido.
• un lenguaje secreto no deja rastro;)

Aquí va:

# 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    

Prueba:

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

¿Puedes descifrar 'Wrpruurz lv qrw edg hlwkhu!':)?

BrainFuck extendido

Como se trata de un concurso de popularidad, he escrito esto con la intención de que sea tan fácil de seguir como EBF puede ser. Está muy comentado y he usado intencionalmente macros para hacer que el programa fluya de manera más literal.

Probablemente lo más difícil aquí es el cambio principal, ya que EBF no tiene ningún medio especial para hacerlo, por lo que en realidad no es más simple que cómo se haría en BrainFuck, excepto por las variables y los paréntesis de equilibrio.

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

Sí, esto no es código golf. Fui por el más corto de todos modos (o al menos, hice un primer intento)

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

Formateado:

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

Sí, eché un vistazo a la respuesta de ufis .

C # 5KB

(381 caracteres)

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 caracteres

... si tienes el paquete bsdgames instalado! Lee de entrada estándar.

caesar 2

Ejemplo

echo Today is a great day|caesar 2

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