Escreva algum código em qualquer idioma que insira uma sequência como "Hoje é um ótimo dia" (observe que não há pontuação) e converte-a para a "Linguagem Secreta". Aqui estão as regras para a "Linguagem Secreta".

• a = c, b = d, c = e assim por diante (y = a e z = b)
• separar cada palavra por um espaço
• verifique se existe uma capitalização adequada

Exemplo:

Input: "Today is a great day"

Output: "Vqfca ku c itgcv fca"

É um concurso de popularidade. Outros usuários devem atribuir pontos procurando pelo código "direto ao ponto", mas "exclusivo".

DESAFIO: Eu estava pesquisando linguagens de programação incomuns e encontrei uma linguagem chamada Piet ( esolang ). Desafio qualquer um a escrever neste idioma.

Smalltalk (Smalltalk / X), 29 27 caracteres

Tenho sorte - ele já está na classe String:

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

adicionando E / S, isso faz com que:

(Stdin nextLine rot:2)print

no espírito ofuscado do exemplo da maçaneta da porta abaixo, que tal:

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

Ruby, edição ofuscada (com comentários incluídos!)

Eu sugiro ler a coisa toda; Acho 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

Dicas sobre como funciona (spoilers, passe o mouse para mostrar):

Esse código cria uma string e depois a avalia.

Utiliza-se const_missingpara construir a cadeia caractere por caractere.

A string que ele acaba construindo é gets.tr'A-Za-z','C-ZABc-zab'.

Postscript

O QG exige que, a partir de agora, todos os agentes recebam comunicação apenas em formato impresso (como os canais eletrônicos se mostraram pouco confiáveis) usando uma fonte ultra-secreta especial. É de sua responsabilidade incluir este procedimento extremamente secreto no prólogo do nosso software de impressão:

/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

E somente essa fonte é permitida, por exemplo:

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

E é isso que imprime:

bater

Clássico.

tr A-Za-z C-ZABc-zab

Exemplo:

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

DFSORT (programa de classificação do IBM Mainframe)

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

Nenhuma instrução de controle SORT pode iniciar na coluna um.

Para que o acima funcione por conta própria, você precisará alterar a tabela de conversão alternativa da instalação padrão, para compensar todos os valores das letras maiúsculas e minúsculas, envolvendo as duas letras finais.

Sem alterar a tabela padrão, seria necessária uma instrução ALTSEQ listando todos os pares necessários de valores hexadecimais (de código hexadecimal seguido imediatamente por código hexadecimal, cada par de valores hexadecimais separados por vírgula):

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

Então, para obter EBCDIC maiúsculo A para C e B para D:

CÓDIGO ALTSEQ = (C1C3, C2C4)

No geral, seria uma digitação muito propensa a erros, é claro, então você usaria outra etapa SORT para gerar os cartões de controle para essa etapa e permitir que a SORT os leia no conjunto de dados criado por essa nova etapa.

Obviamente, para qualquer idioma que suporte uma "tabela de tradução", é tão fácil quanto alterar a tabela de tradução. Bom programa COBOL, com uma página de código específica, e isso pode ser feito em uma linha do código de procedimento COBOL (mais as linhas obrigatórias de COBOL que acompanham tudo ... não tantas nesse caso em particular).

Ah, o 1,80 é a "imagem do cartão" que conterá o texto. Provavelmente tudo em maiúsculas na primeira execução ...

C, 75 bytes

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

Exemplo:

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

Pitão

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

Resultado:

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

Não é o mais curto!

Exemplo ao 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 (o idioma que é executado nas 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 é um bom software de criptografia (para uma TI-83). Com ti-83, quero dizer qualquer calculadora da família ti-83 ou ti-84. "->" significa "LOJA" acessada por "STO>"

Rubi 40. 32.

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

update (como visto na solução danieros bash):

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

Java, é realmente compreensível.

Eu sei que qualquer coisa com espaço em branco e parênteses tem dificuldade em CG, mas aqui está uma chance.

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

Existem concursos separados para ofuscar código, mas também posso tornar o meu 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);

Com todos os comentários, meu hamster pode entender isso.

Eu acho que vou ROT2-lo!

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

Aqui está uma implementação baseada em lente. Estou usando Isopara representar o isomorfismo entre texto normal e texto convertido em linguagem secreta. A menos que você forneça a --fromopção, a entrada é convertida no idioma secreto. Se a --fromopção for fornecida, a conversão oposta será executada.

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)

Exemplos:

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

32é spaceassim que nós imprimi-lo como é
88é Xtão nada menos do que 89se move para cima 2 personagens
90é Ztão nada menos do que 91lances bem conseguidos 24 caracteres (com nada menos do que 89já tratada tão somente 89e 90de forma eficaz)
Repita o mesmo processo para letras minúsculas, que vão desde 97como apara 122como 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

Resultado:

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

PHP

Esta solução é bastante chata:

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

Python 3

Eu acho que não entendi direito a pergunta, mas de qualquer maneira:

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

Uma tentativa de uma solução Python rica em recursos.

Recursos:

• o uso de um ditado
• lidar com a lista de forma circular, para que shift=2 possa variar
• você também pode usá-lo para decifrar quando souber shift (use menos), também permitirá que você teste sua saída.
• capacidade de adicionar "escopos móveis" - escopos nos quais você alterna
• opção de ser strict para caracteres indefinidos ou apenas retornar o caractere de entrada indefinido.
• uma linguagem secreta não deixa vestígios;)

Aqui vai:

# 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    

Prova:

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

Você pode decifrar 'Wrpruurz lv qrw edg hlwkhu!':)?

BrainFuck estendido

Como este é um concurso de popularidade, escrevi isso com a intenção de ser tão fácil de acompanhar quanto o EBF pode ser. É muito comentado e usei intencionalmente macros para tornar o programa mais literal.

Provavelmente, a coisa mais difícil aqui é a chave principal, já que o EBF não tem nenhum meio especial de fazê-lo, portanto, na realidade, não é mais simples do que como se faria no BrainFuck, exceto pelas variáveis ​​e parênteses de equilíbrio.

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

Sim, isso não é código-golfe. Fui o mais curto de qualquer maneira (ou pelo menos, fiz uma primeira tentativa)

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

Formatado:

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

Sim, eu dei uma olhada na resposta dos 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

... se você tiver o pacote bsdgames instalado! Lê da entrada padrão.

caesar 2

Exemplo

echo Today is a great day|caesar 2

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