Schreiben Sie Code in einer beliebigen Sprache, die eine Zeichenfolge wie "Heute ist ein großartiger Tag" eingibt (beachten Sie, dass keine Interpunktion vorhanden ist), und konvertieren Sie ihn in die "Geheime Sprache". Hier sind die Regeln für die "Geheime Sprache".

• a = c, b = d, c = e usw. (y = a und z = b)
• trenne jedes Wort durch ein Leerzeichen
• Stellen Sie sicher, dass die Kapitalisierung korrekt ist

Beispiel:

Input: "Today is a great day"

Output: "Vqfca ku c itgcv fca"

Es ist ein Beliebtheitswettbewerb. Andere Benutzer sollten Punkte vergeben, indem sie nach den meisten "auf den Punkt" und dennoch "eindeutigen" Codes suchen.

HERAUSFORDERUNG: Ich habe nach ungewöhnlichen Programmiersprachen gesucht und eine Sprache namens Piet ( esolang ) gefunden. Ich fordere jeden auf, es in dieser Sprache zu schreiben.

Smalltalk (Smalltalk / X), 29 27 Zeichen

Ich habe Glück - es ist bereits in der String-Klasse:

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

Durch Hinzufügen von E / A wird Folgendes erreicht:

(Stdin nextLine rot:2)print

Wie wäre es im Geiste des verschleierten Beispiels von Türknauf unten:

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

Ruby, verschleierte Ausgabe (mit Kommentar!)

Ich schlage vor, die ganze Sache zu lesen; Ich finde es ziemlich amüsant;)

$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

Hinweise zur Funktionsweise (Spoiler, Hover zu zeigen):

Dieser Code erstellt eine Zeichenfolge und wertet sie dann aus.

Es wird verwendet const_missing, um die Zeichenfolge zeichenweise zu erstellen.

Die Zeichenfolge, die am Ende erstellt wird, ist gets.tr'A-Za-z','C-ZABc-zab'.

Nachsatz

Das Hauptquartier verlangt, dass von nun an alle Agenten die Kommunikation nur in gedruckter Form (da sich elektronische Kanäle als zu unzuverlässig erwiesen haben) unter Verwendung einer speziellen streng geheimen Schriftart erhalten. Es liegt in Ihrer Verantwortung, dieses streng geheime Verfahren in den Prolog unserer Drucksoftware aufzunehmen:

/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

Und nur diese Schriftart ist erlaubt, zB:

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

Und das druckt es:

Bash

Klassisch.

tr A-Za-z C-ZABc-zab

Beispiel:

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

DFSORT (IBM Mainframe-Sortierprogramm)

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

In Spalte 1 kann keine SORT-Steueranweisung beginnen.

Damit das oben Gesagte von selbst funktioniert, müssen Sie die alternative Übersetzungstabelle für die Standardinstallation ändern, um alle Werte für Groß- und Kleinbuchstaben zu versetzen und die letzten beiden Buchstaben zu umschließen.

Ohne Änderung der Standardtabelle wäre eine ALTSEQ-Anweisung erforderlich, in der alle erforderlichen Hex-Wertepaare aufgelistet sind (vom Hex-Code unmittelbar gefolgt vom Hex-Code, wobei jedes Hex-Wertepaar durch ein Komma getrennt ist):

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

So erhalten Sie EBCDIC A bis C und B bis D in Großbuchstaben:

ALTSEQ CODE = (C1C3, C2C4)

Für das Ganze wäre das natürlich eine Menge fehleranfälliger Eingaben. Sie würden also einen weiteren SORT-Schritt verwenden, um die Steuerkarten für diesen Schritt zu generieren, und SORT sie aus dem durch diesen neuen Schritt erstellten Datensatz lesen lassen.

Natürlich ist es für jede Sprache, die eine "Übersetzungstabelle" unterstützt, so einfach wie das Ändern der Übersetzungstabelle. Nettes COBOL-Programm mit einer bestimmten Codepage, und es könnte in einer Zeile des COBOL-Prozedurcodes ausgeführt werden (plus den obligatorischen Zeilen von COBOL, die zu allem passen ... in diesem speziellen Fall nicht so viele).

Oh, die 1,80 ist das "Kartenbild", das den Text enthält. Wahrscheinlich alles in Großbuchstaben beim ersten Lauf ...

C 75 Bytes

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

Beispiel:

$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

Ausgabe:

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

Nicht die kürzeste!

Live-Beispiel: 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);

Hinweis:

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

TI-Basic (die Sprache, die auf TI-83-Grafikrechnern ausgeführt wird)

: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  

Dies ist eine nette Verschlüsselungssoftware (für einen TI-83). Mit ti-83 meine ich jeden Taschenrechner in der ti-83- oder ti-84-Familie. "->" bedeutet "STORE", auf das über "STO>" zugegriffen wird.

Rubin 40 32

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

Update (aus der Danieros Bash-Lösung):

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

Java ist eigentlich verständlich.

Ich weiß, dass alles mit Leerzeichen und Klammern CG schwer fällt, aber hier ist ein Schuss.

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

Es gibt separate Wettbewerbe, um Code zu verschleiern, aber ich kann meinen auch lächerlich machen.

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

Was mein Hamster bei all den Kommentaren verstehen kann.

Ich denke ich werde es 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

Hier ist eine objektivbasierte Implementierung. Ich verwende Iso, um den Isomorphismus zwischen normalem Text und in die geheime Sprache konvertiertem Text darzustellen. Sofern Sie die --fromOption nicht angeben, wird die Eingabe in die geheime Sprache konvertiert. Wenn die --fromOption bereitgestellt wird, wird die entgegengesetzte Konvertierung durchgeführt.

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)

Beispiele:

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

32ist spaceso, dass wir es ausdrucken, wie es
88ist, Xso dass alles, was weniger als 892 Zeichen nach oben bewegt, so
90ist, Zdass alles weniger als 9124 Zeichen nach unten bewegt wird (mit weniger als 89bereits so 89und 90effektiv behandelt)
Wiederholen Sie den gleichen Vorgang für Kleinbuchstaben von 97bis abis 122as 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));
    }
}

Power 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

Ausgabe:

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

PHP

Diese Lösung ist ziemlich langweilig:

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

Python 3

Ich glaube, ich habe die Frage nicht ganz verstanden, aber trotzdem:

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.

Ein Versuch einer funktionsreichen Python-Lösung.

Eigenschaften:

• die Verwendung eines Diktats
• die Liste kreisförmig behandeln, so dass shift=2variiert werden kann
• Sie können es auch zum Entschlüsseln verwenden, wenn Sie wissen shift(verwenden Sie einfach Minus). Außerdem können Sie damit Ihre Ausgabe testen.
• Möglichkeit, "Verschiebungsbereiche" hinzuzufügen - Bereiche, in denen Sie Rad fahren
• Option, entweder strictfür undefinierte Zeichen zu sein oder einfach das undefinierte Eingabezeichen zurückzugeben.
• eine geheime Sprache hinterlässt keine Spuren;)

Hier geht:

# 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    

Beweis:

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

Kannst du entziffern 'Wrpruurz lv qrw edg hlwkhu!':)?

Erweiterter BrainFuck

Da dies ein Beliebtheitswettbewerb ist, habe ich dies mit der Absicht geschrieben, dass es so einfach zu verfolgen ist, wie es EBF sein kann. Es ist stark kommentiert und ich habe absichtlich Makros verwendet, um den Programmfluss wörtlicher zu machen.

Das wahrscheinlich schwierigste hier ist der Hauptschalter, da EBF keine speziellen Mittel dafür hat, so dass es in Wirklichkeit nicht einfacher ist als in BrainFuck, außer den Variablen und ausgleichenden Klammern.

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

Ja, das ist kein Code-Golf. Ich ging sowieso für den kürzesten (oder machte zumindest einen ersten Stich darauf)

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

Formatiert:

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

Ja, ich habe einen Blick auf die Antwort von ufis geworfen .

C # 5KB

(381 Zeichen)

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 Zeichen

... wenn Sie das bsdgames-Paket installiert haben! Liest von der Standardeingabe.

caesar 2

Beispiel

echo Today is a great day|caesar 2

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