Scrivi del codice in qualsiasi lingua che inserisca una stringa come "Oggi è un grande giorno" (Nota che non c'è punteggiatura) e lo converte in "Lingua segreta". Ecco le regole per la "lingua segreta".

• a = c, b = d, c = e e così via (y = a e z = b)
• separare ogni parola con uno spazio
• assicurarsi che ci sia una corretta capitalizzazione

Esempio:

Input: "Today is a great day"

Output: "Vqfca ku c itgcv fca"

È un concorso di popolarità. Altri utenti dovrebbero dare punti cercando la maggior parte del codice "al punto" ma "unico".

SFIDA: Stavo cercando linguaggi di programmazione non comuni e ho trovato un linguaggio chiamato Piet ( esolang ). Sfido chiunque a scriverlo in questa lingua.

Smalltalk (Smalltalk / X), 29 27 caratteri

Sono fortunato - è già nella classe String:

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

aggiungendo I / O, questo lo rende:

(Stdin nextLine rot:2)print

nello spirito dell'esempio offuscato della maniglia della porta di seguito, che ne dici di:

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

Ruby, edizione offuscata (con commento incluso!)

Suggerisco di leggere l'intera cosa; Lo trovo abbastanza divertente;)

$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

Suggerimenti su come funziona (spoiler, hover da mostrare):

Questo codice crea una stringa e quindi la valuta.

Usa const_missingper costruire la stringa carattere per carattere.

La stringa che finisce per costruire è gets.tr'A-Za-z','C-ZABc-zab'.

poscritto

Il quartier generale richiede che d'ora in poi tutti gli agenti ricevano comunicazioni solo in forma stampata (poiché i canali elettronici si sono rivelati troppo inaffidabili) utilizzando uno speciale carattere top-secret. È tua responsabilità includere questa procedura top secret nel prologo del nostro software di stampa:

/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 è consentito solo quel tipo di carattere, ad esempio:

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

Ed è quello che stampa:

bash

Classico.

tr A-Za-z C-ZABc-zab

Esempio:

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

DFSORT (programma di ordinamento IBM Mainframe)

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

Nessuna istruzione di controllo SORT può iniziare nella prima colonna.

Affinché quanto sopra funzioni da solo, dovresti modificare la tabella di traduzione alternativa di installazione predefinita, per compensare tutti i valori per le lettere maiuscole e minuscole, avvolgendo le ultime due lettere.

Senza modificare la tabella predefinita, richiederebbe un'istruzione ALTSEQ che elenca tutte le coppie richieste di valori esadecimali (da codice esadecimale immediatamente seguito da codice esadecimale, ogni coppia di valori esadecimali separati da una virgola):

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

Quindi, per ottenere le maiuscole EBCDIC da A a C e da B a D:

CODICE ALTSEQ = (C1C3, C2C4)

Nel complesso, sarebbe una grande quantità di errori, ovviamente, quindi useresti un altro passo SORT per generare le carte di controllo per questo passo e lasceresti che SORT le leggesse dal set di dati creato da quel nuovo passo.

Naturalmente, per qualsiasi lingua che supporti una "tabella di traduzione", è facile come cambiare la tabella di traduzione. Bel programma COBOL, con una Codepage specifica, e potrebbe essere fatto in una riga del codice di procedura COBOL (più le righe obbligatorie di COBOL che vanno con tutto ... non così tante in questo caso particolare).

Oh, 1,80 è "l'immagine della carta" che conterrà il testo. Probabilmente tutto in maiuscolo alla prima manche ...

C, 75 byte

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

Esempio:

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

Pitone

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

Produzione:

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

Non il più corto però!

Esempio live: 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 (il linguaggio che gira su calcolatori grafici 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  

Questo è un bel software di crittografia (per una TI-83). Per ti-83 intendo qualsiasi calcolatrice della famiglia ti-83 o ti-84. "->" significa "STORE" a cui accede "STO>"

Rubino 40 32

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

aggiornamento (come visto dalla soluzione bash di danieros):

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

Java, in realtà è comprensibile.

So che qualsiasi cosa con spazi bianchi e parentesi fa fatica a CG, ma ecco un colpo.

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

Ci sono concorsi separati per il codice offuscante, ma posso anche rendere il mio ridicolo.

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 tutti i commenti, il mio criceto può capirlo.

Penso che lo farò 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

Ecco un'implementazione basata sull'obiettivo. Sto usando Isoper rappresentare l'isomorfismo tra testo normale e testo convertito nella lingua segreta. A meno che non si fornisca l' --fromopzione, l'input viene convertito nella lingua segreta. Se --fromviene fornita l' opzione, viene eseguita la conversione opposta.

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)

Esempi:

$ ./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(_))

GIAVA

32è spacequindi il risultato della stampa fuori come è
88è Xcosì niente di meno che 89si muove fino 2 caratteri
90è Zquindi qualcosa di meno di 91azione corale 24 caratteri (con niente di meno che 89già gestito in modo che solo 89e 90in modo efficace)
Ripetere lo stesso processo per le lettere minuscole, che vanno da 97come aa 122come 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

Produzione:

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

PHP

Questa soluzione è piuttosto noiosa:

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

Python 3

Penso di non aver capito bene la domanda, ma comunque:

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 tentativo di una soluzione Python ricca di funzionalità.

Caratteristiche:

• l'uso di un dict
• gestire l'elenco in modo circolare, in modo che shift=2possa essere variato
• puoi anche usarlo per decifrare quando lo sai shift(usa solo meno), ti permetterà anche di testare il tuo output.
• possibilità di aggiungere "ambiti mobili" - ambiti in cui si esegue il ciclo
• opzione strictper caratteri non definiti o per restituire il carattere di input non definito.
• un linguaggio segreto non lascia traccia;)

Ecco qui:

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

Puoi decifrare 'Wrpruurz lv qrw edg hlwkhu!':)?

BrainFuck esteso

Dal momento che questo è un concorso di popolarità, l'ho scritto con l'intenzione che sia facile da seguire come può essere EBF. È fortemente commentato e ho usato intenzionalmente le macro per rendere il flusso del programma più letterale.

Probabilmente la cosa più difficile qui è l'interruttore principale poiché EBF non ha alcun mezzo speciale per farlo, quindi in realtà non è più semplice di come si farebbe in BrainFuck ad eccezione delle variabili e delle parentesi di bilanciamento.

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

Giava

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ì, questo non è code-golf. Sono andato per il più breve comunque (o almeno, ho fatto una prima pugnalata)

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

formattato:

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ì, ho dato una sbirciatina alla risposta degli ufis .

C # 5KB

(381 caratteri)

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 personaggi

... se ti capita di avere installato il pacchetto bsdgames! Legge da input standard.

caesar 2

Esempio

echo Today is a great day|caesar 2

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