ROT-13 перетворює стандартний вхід

34

Завдання: прочитати вхід довільної довжини та створити ROT13 введення. Усі символи, крім AZ, повинні бути скопійовані у вихідний дослівно, а регістр повинен бути збережений, якщо це можливо.

Будь-яка мова, яка вміє читати та писати стандартні потоки - це чесна гра.

code-golf  cryptography 
— MiffTheFox
джерело
3
Проблема не повинна бути тегом, тому я видалив ROT13, просто FYI
— Нік Берарді
2
Ви не маєте на увазі A-Za-z (щоб рахувати і великі, і малі регістри)?
— Joey Adams
5
@Chris Jester-Young, він належить до цієї категорії на wikipedia. Це частина криптографії, тільки не найважча. У всякому разі, я більше не переглядаю цей сайт. Громада мене розчарувала. Вибачте. GL HF.
— Накілон
17
Скажіть, що xor не є шифруванням, це як сказати, що + b не є математикою .
— Накілон
3
Теги використовуються для категоризації питань та допомоги в пошуку подібних питань. Криптографія тег (від грецького Kryptos, «прихований, таємний», і graphein, «листи») , зокрема , для шифрування і дешифрування проблем. Всі шифрування та дешифрування, не тільки ті, які захищені для сучасних програм.
— Ангс

Відповіді:

25

Баш, 23 байти

Канонічна відповідь на 23 символи:

tr A-Za-z N-ZA-Mn-za-m
— Кріс Єстер-Янг
джерело
1
На даний момент я не маю доступу до башу, але думаю, що це має спрацювати: tr A-za-m N-ZA-z(16 годин)
— Nabb
2
@Nabb: Приємно бачити вас, GolfScript-містер! : -Я думаю, що ваше рішення тут порушить умову про те, що "Усі символи, крім AZ, повинні бути скопійовані у дослідний висновок".
— Кріс Єстер-Янг
@Chris: Так, схоже, ти маєш рацію.
— Nabb
@Nabb: Ні, для мене це виглядає так, ніби він помиляється. Або ти можеш показати приклад?
— користувач невідомий
2
@user unknown: Введіть [\\]^_`вхід. Він повернеться як NOPQRS, ніж [\\]^_`, принаймні, у версії, яку trя маю. (Це шість персонажів ASCII, які лежать між Zі a. Очевидно, всі інші персонажі будуть працювати правильно.)
— Кріс Jester-Young
20

Баш - 5 чарів

rot13

 

— гніблер
джерело
18
Поки що два голосні записки (без зауважень), але жодні рейтинги для питання. Я припускаю, що це означає, що це нормально запитувати тривіальних кодових гольфів, але не давати тривіальної відповіді. Більш жорсткі кодографи, будь ласка!
— гніблер
8
Яка баш-версія? У мене немає вбудованої гнилі13. bash --version GNU bash, Version 4.0.33(1)-release (i486-pc-linux-gnu)
— користувач невідомий
12
Я подав би це як rot13 - 0 chars…;)
— кабінка
2
'це coreutils мій друг, а не Bash
— TheDoctor
3
гм ... ні. мій bash (Ubuntu 13.10) каже "команду не знайдено, ви можете встановити цю програму sudo apt-get install bsdgames"
17

Python 2, 34 байти

print raw_input().encode('rot13')
— Хуан
джерело
1
-1 Я думаю, що це обман, що ви використовуєте вбудовану бібліотеку.
— Гленн Нельсон
16
Я використовував їх у кожному коді гольфу, в якому я брав участь ... Також, якщо використання стандартної lib python є обманом, то як використовувати tr ні?
— Хуан
3
@ У будь-якому випадку це неприємність, яку ти просто ігноруєш. Це не за межею, немає ніяких правил, встановлених ОП, ані громадою. Звичайно, можливо, моє не є нагородами рішення, як те, що використовує тр, який б'є дупу. Але це не жарт, я використовую силу пітона, щоб зменшити кількість, як і будь-який інший.
— Хуан
2
@Glenn: навпаки, я ніколи не бачив речі з кодом-гольфу, яка так говорить. Також не використовуйте codegolf.com, golf.shinh.org або SPOJ SHORTEN.
— hallvabo
9
@Glenn, я думаю, що функції бібліотеки - це чесна гра. Питання про гольф залежить від того, щоб бути досить цікавим, щоб не знаходитись ні в кого в бібліотеці або спеціально виключати.
— гніблер
15

Befunge - 7x30 = 210 6x26 = 156 символів

Нова потокова версія, яка підтримує і верхній і нижній регістр, і повинна підтримувати необмежену кількість даних.

v,<               <<     <
  ^-4-9<    >:"A"\`|
     >:"a"\`|     #>:"Z"`|
>~:0`| #    >:"z"`|
,    @ |    <`"m":<v`"M":<
^  +4+9<    ^      <

Стара версія

Це зберігає значення всередині власного вихідного коду. Дійсно показує, наскільки жахливо намагатися виводити збережені значення в тому ж порядку, коли ви їх отримуєте. Підтримує лише малі символи.

vp0p11:+1g11<      < <
v                    ^-4-9<
v    >:"a"\`|>:"z"`|>:"m"`|
>~:0`|      >^     >^#
                     ^+4+9<
     >$011g1+0p>12g1+:12p0g:v
               ^           ,_@

Я не впевнений, які саме обмеження це має, використовуючи http://www.quirkster.com/iano/js/befunge.html як інтерпретатор, який, як видається, порушується з великими входами.

— Nemo157
джерело
Ви можете видалити пробіли в кінці рядків.
— Zacharý
10

Рубі - 60 57 38 37 символів

Редагувати: І тільки що зрозуміли, що у рядках Ruby є trметод.

puts$<.read.tr'A-Za-z','N-ZA-Mn-za-m'

Тест

input = "The challenge: To read an input of arbitrary length and produce the ROT13 of the input. All characters besides A-Z should be copied to the output verbatim, and case should be preserved if possible.

Any language that can read and write standard streams is fair game."

output = `echo '#{input}' | ruby golf-rot13.rb`

puts "Input:"
puts input
puts "-------"
puts "Output:"
puts output

Дає:

Input:
The challenge: To read an input of arbitrary length and produce the ROT13 of the input. All characters besides A-Z should be copied to the output verbatim, and case should be preserved if possible.

Any language that can read and write standard streams is fair game.
-------
Output:
Gur punyyratr: Gb ernq na vachg bs neovgenel yratgu naq cebqhpr gur EBG13 bs gur vachg. Nyy punenpgref orfvqrf N-M fubhyq or pbcvrq gb gur bhgchg ireongvz, naq pnfr fubhyq or cerfreirq vs cbffvoyr.

Nal ynathntr gung pna ernq naq jevgr fgnaqneq fgernzf vf snve tnzr.
— Nemo157
джерело
Після цього вам не потрібно місця puts, і "Az" - це ярлик для "A-Za-z"
— Вентеро
1
@ Ventro: Спасибі, після трохи тестування здається, що 'A-z'це насправді 'A-Z[\]^_a-z ' , damn ascii having characters between Z` і a.
— Nemo157
1
За суті , одні і ті ж , але 35 символів: puts gets.tr'A-Za-z','N-ZA-Mn-za-m'.
— Майкл Коль
@Michael: За винятком getsлише повернення першого рядка, використовуючи $ <. Read read до EOF. Питання нічого не говорить про те, чи може вхід містити нові рядки, тому я просто помилився з боку обережності.
— Nemo157
Досить справедливо, але оскільки специфікація вправи згадувала лише "довільну тривалість", але нічого не говорила про нові рядки, я скоріше помиляюся на стороні стислості у кодегольфі ;-)
— Майкл Коль
10

vim, 5 натискань клавіш

Якщо припустити звичайний режим і що текст уже записаний у буфер:

ggg?G

Або, дотримуючись умов вімгольфа:

g?GZZ

Ви також можете викликати його як термінальну команду, приблизно так:

$ vim -c 'norm g?G' -
< your text here ...
... multiple lines if you want ...
... terminate input with ctrl+D on a blank line >

Я думаю, що останній вважатиметься "програмою" з 8 символів ( norm g?G)

— даньєро
джерело
norm g?Gкороткий для normal g?Gцього становить 8 символів.
— Патрік Осіті
Я думаю, ви можете сміливо припускати, що почати на лінії 1, тому перший ggможна залишити. Я б сказав 3 натискання клавіш, коли файл відкритий.
— Патрік Осіті
1
Якщо ми використовуємо конвенції vimgolf (ви починаєте з ванільного vim, щойно відкрив файл, але його потрібно зберегти та вийти), ми також отримаємо 5 ( g?GZZ).
— FireFly
7

C - 83 79 символів

main(c,b){while((c=getchar())>=0)b=c&96,putchar(isalpha(c)?b+1+(c-b+12)%26:c);}

Читаема версія:

#include <ctype.h>
#include <stdio.h>

int main(void)
{
    int c, base;

    while ((c = getchar()) >= 0) {
        if (isalpha(c)) {
            base = (c & 96) + 1; /* First letter of the upper or lower case. */
            c = base + (c - base + 13) % 26;
        }
        putchar(c);
    }

    return 0;
}
— Джої Адамс
джерело
1
Ви включаєте заголовки, які ви включаєте до свого рахунку?
— JPvdMerwe
@JPvdMerwe: Я не включав жодних заголовків у версію для гольфу, а також не потрібно.
— Джої Адамс
Ви можете скористатися оператором коми перед путчаром, щоб зняти пару брекетів.
— Олександру
Чи можете ви пояснити головне (с, б)? Це вперше я бачу це.
— Олександру
2
@Alexandru більшість компіляторів C підтримують основні з будь-якими параметрами. Також оригінальний стандарт C визначає, що аргумент без типу є int. Таким чином, ви можете оголосити int без фактичного написання int.
— Хуан
7

Python (117 байт)

Ось версія Python, яка уникає rot13()методу -m.

import sys
print"".join([chr(x/32*32+1+(x%32+12)%26if 64<x<91or 96<x<123 else x)for x in map(ord,sys.stdin.read())])
— JPvdMerwe
джерело
raw_input повертає один рядок не весь вхід.
— Олександру
вам потрібно import sysі використовувати sys.stdin.read().
— Олександру
@Alexandru: зробимо
— JPvdMerwe
-2 байти, якщо ви усунете, []щоб список став генератором: tio.run/…
— connectyourcharger
7

tr///рішення в Perl (39 символів), котельну плиту можна видалити за допомогою -p:

while(<>){y/a-zA-Z/n-za-mN-ZA-M/;print}

Використання -p(23 символи, включаючи додатковий перемикач):

perl -pe'y/a-zA-Z/n-za-mN-ZA-M/'
— Анон.
джерело
Додайте 1 знак для p, але будь ласка, зніміть котельну плиту!
— JB
7

R, 37 байт

example("chartr");cat(rot(scan(,"")))

example("chartr")запускає приклади для chartr, що включає в себе rotфункцію, яка ROT13за замовчуванням ....

— ядра
джерело
5

Постійного струму ( 111 108 для постійного струму)

Гаразд, ось він знаходиться в (здебільшого) dc та деякій sed і od magic, щоб отримати його у потрібному форматі для коду. Якщо ви не рахуєте вхідну річ ( echo -n MESSAGE |), це 160 байт:

od -An -t dC|sed 's/^\ *//;s/\ \{2,3\}/\n/g'|dc -e'[13+26%]sm[65-lmx65+]su[97-lmx97+]sl[96<b64<dPc]sa[91>c]sd[123>e]sb[lux]sc[llxdd]se[ddddlaxlrx]sy[?z0<y]dsrx'

Як точку інтересу, сама програма dc довжиною лише 108 байт , коротше, ніж небібліотечна версія пітона. Він навіть зберігає регістр і розділові знаки, і перемагає Javascript у наведеному вище поданні! Якби я міг краще проаналізувати вихід од, або ще краще замінити його взагалі.

EDIT: Варто зазначити, що питання не вказує на новий проміжок, 10Pякий зберігає мені три наступні байти.

EDIT 2: Немає специфікацій для формату вводу, тому я припускаю, що він прийнятий так, як це зручно для моєї програми: P

— Хіато
джерело
5

Befunge-93, 85 (сітка: 41x3 = 123)

Це давнє запитання, але я подумав, що відроджую його, щоб розмістити трохи приємнішу відповідь Бефундже.

#v_~::" "/2%" "*-::"@"`!#v_"Z"#v`#!_1
v> "M"`2*1\-34*1+*+    1:>$!   _:"."-!#@_
>,^

Ви можете протестувати його тут . Введіть одночасно один символ; він закінчується після введення .символу (ви можете змінити це, змінивши "."найближчу праву частину другого ряду). Працює з верхнього та нижнього регістру, а також пунктуації та без обмежень для введення.

Я не сподіваюся, що це отримає багато грошей або що-небудь, але я просто хотів продемонструвати, наскільки дивовижною Befunge є те, що ти можеш зробити трохи краще, ніж інша відповідь.

Можливо, я міг би зробити його ще коротшим у Befunge-98.

— Касран
джерело
Ви можете додати мій фрагмент звідси, щоб мати вбудованого перекладача, якщо хочете. :)
— Інго Бюрк
О, я ще не дуже досліджував фрагменти. Я погляну, дякую!
— Касран
Це не працює, якщо на вході є пробіл. Він переходить у нескінченний цикл у послідовності, >$! _тому що у вас є два нулі на стеку в той момент, коли ви очікуєте ненульове значення.
— Джеймс Холдернес
4

PHP - 103 98 80 символів

(не використовується str_rot13 ())

<?=preg_replace('#[a-zA-Z]#e','chr(($x=ord("\0"))-$x%32+1+($x%32+12)%26)',`cat`);
— Арно Ле Блан
джерело
4

Дельфи, 110

var c:Char;begin repeat Read(c);Write(Chr(Ord(c)+(Ord(c in['A'..'M'])-Ord(c in['N'..'Z']))*13));until EOF;end.
— PatrickvL
джерело
var c:Char;begin repeat Read(c);Write(Chr(Ord(c)+(Ord(c in['A'..'M'])-Ord(c in['N'..'Z']))*13));until EOF;end.рятує одного персонажа :)
— Wouter van Nifterick
@Wouter van Nifterick: Добре місце! Я
— оновлю
4

Хаскелл, 100 символів

a%b=([a..b]++)
main=interact$map$toEnum.((0%64$78%90$65%77$91%96$110%122$97%109$[123..])!!).fromEnum
— MtnViewMark
джерело
3

Java 251 символів

public class r{public static void main(String[] a){String s = a[0];for(int i=0;i<s.length();){char c=s.charAt(i++);if(c>='a'&&c<='m')c+=13;else if(c>='n'&&c<='z')c-= 13;else if(c>='A'&&c<='M')c+=13;else if(c>='A'&&c <='Z')c-=13;System.out.print(c);}}}
— Клайд Лобо
джерело
3

Пітон 3 (107)

Гаразд, я обіцяю перестати відповідати на це запитання зараз, але я почував вимушеність перемогти відповідь DC в Python. Це, мабуть, погано відбивається на мені, як на людині :).

import sys;[print(x.isalpha()and chr((ord(x)&96)+1+(ord(x)%32+12)%26)or x,end='')for x in sys.stdin.read()]
3

C: 69 68 символів

Гаразд, я знаю, що цей потік давно мертвий, але я не витримав (тривалого) C-рішення, яке навіть не компілюється на Clang (але є в GCC).

main(c){putchar(isalpha(c=getchar())*((c|32)<110?13:-13)+c);main();}

Це, мабуть, майже досі стискається. Це, безумовно, було стислим. І не тільки його було стискати, можна було зробити його рекурсивним.

— Форс
джерело
3

05AB1E , 13 12 байт

Збережено байт завдяки Robbie0630

ADu)øJD2äRJ‡

Спробуйте в Інтернеті!

Пояснення

ADu           # push lower-case and uppercase alphabet
   )øJ        # zip, flatten and join, producing aAbB..zZ
      D2äRJ   # split a copy in 2 pieces, reverse and join producing nNoO..mM
           ‡  # translate input by replacing members of the alphabet 
              # with the corresponding member of the rot-13 alphabet
              # implicitly display
— Емінья
джерело
Я зіткнувся з цим --debug, і, здається, що ˜в даному випадку є неоператив, і його можна вирізати.
— грабі
@ robbie0630: Правда.
— Поняття
2

JavaScript 1.8, 106

alert(prompt().replace(/\w/g,function(c)String.fromCharCode(c.charCodeAt()+(c.toLowerCase()<'n'?13:-13))))

JavaScript, 115

alert(prompt().replace(/\w/g,function(c){return String.fromCharCode(c.charCodeAt()+(c.toLowerCase()<'n'?13:-13))}))

Це рішення вирішує проблему, додаючи 13 до коду символів, якщо відповідний символ знаходиться в першій половині алфавіту, або віднімаючи 13, якщо він знаходиться у другій половині.

— Кейсі Чу
джерело
Ви можете зберегти 7 символів, замінивши +(c.toLowerCase()<'n'?13:-13))на -13+26*/[a-m]/i.test(c).
— Яків
2

CHIQRSX9 + , 1

R

Вам просто потрібно використовувати правильний інструмент для вирішення проблеми.
CHIQRSX9 + - Тьюрінг завершений, і він може читати та писати зі стандартних каналів за допомогою C.

— Йоганнес Кун
джерело
5
@ nyuszika7h Мова була винайдена до того, як було написано це запитання, тож воно дійсне.
— Йоганнес Кун
1
Це все ж одна з речей, для якої вона була винайдена. Мені здається, що мені обман.
— nyuszika7h
7
@ nyuszika7h І гольфскрипт був винайдений для того, щоб перемагати в кодово-гольф-викликах. Ви вважаєте, що це теж обман?
— Йоганнес Кун
2
@Mego Навряд чи справедливо застосовувати ці стандарти тут, коли вони були написані через рік після цієї відповіді.
— Дверна ручка
2
— Mego
2

C, 136 байт

Я ніколи не відчував, що будь-яке з моїх рішень достатньо гарне для публікації тут, але я зробив це для розваги, і подумав, що це буде моїм наркотиком на шляху до коду гольфу.

#define z(x) c>=x&&c<x+13
#define q(w) c>=w&&c<w+13
main(c){for(;(c=getchar())>=0;putchar(z('A')||z('a')?c+13:q('M')||q('m')?c-13:c));}
— Торміст
джерело
4
Ласкаво просимо до головоломки програмування та обміну стека коду для гольфу. Чудова перша відповідь. І тільки для запису, ми всі інколи так відчуваємо, просто знаємо, що все, що ти створюєш, - десь "досить добре".
— GamrCorps
2
Тут все на PPCG - це просто для розваги (або уявних точок Інтернету) - будь ласка, не відчувайте, що робота, яку ви зробили, щоб розробити рішення, не є «достатньо хорошою»
— кіт
Дякую за всю підтримку. Я думаю, що розміщувати щось було все, що мені потрібно, щоб отримати голову в спорядженні. Я збираюся спробувати свої сили у більшій частині цих проблем найближчим часом.
— Тормист
2

Javascript, 177 байт

Це передбачає, що є дві функції: print and readLine:

f=String.fromCharCode;print(readLine().replace(/[a-z]/g,function(a){return f((a.charCodeAt(0)-84)%25+97);}).replace(/[A-Z]/g,function(a){return f((a.charCodeAt(0)-52)%25+65);}))
— jrtapsell
джерело
2

LispLisp (16 636)

Мені шкода.

((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
  (lisp lisp))
 (((lisp (lisp (lisp (lisp lisp))))
   ((lisp (lisp (lisp lisp)))
    ((lisp (lisp (lisp (lisp lisp))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (((lisp (lisp (lisp (lisp lisp))))
          (((lisp (lisp (lisp (lisp lisp))))
            ((lisp (lisp (lisp lisp)))
             (lisp (lisp (lisp (lisp lisp))))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (lisp (lisp (lisp lisp)))))
            (((lisp (lisp (lisp (lisp lisp))))
              ((lisp (lisp (lisp lisp)))
               (lisp (lisp (lisp (lisp lisp))))))
             (((lisp (lisp (lisp (lisp lisp))))
               ((lisp (lisp (lisp lisp)))
                ((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))))
              (lisp (lisp (lisp lisp))))))))
         ((lisp (lisp (lisp lisp)))
          (lisp (lisp (lisp lisp)))))))
      (((lisp (lisp (lisp (lisp lisp))))
        ((lisp (lisp (lisp lisp)))
         (((lisp (lisp (lisp (lisp lisp))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (lisp (lisp (lisp lisp)))))))
            (((lisp (lisp (lisp (lisp lisp))))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 ((lisp (lisp (lisp lisp)))
                  ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
             ((lisp (lisp (lisp lisp)))
              (((((lisp (lisp (lisp (lisp lisp))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     (lisp (lisp (lisp (lisp lisp))))))
                   (lisp (lisp (lisp lisp)))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp (lisp lisp))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (lisp (lisp (lisp (lisp lisp))))))
                      (lisp (lisp (lisp lisp))))))
                   (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                    (lisp lisp)))
                  (((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (lisp lisp))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                     ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                 (lisp (lisp (lisp lisp)))))
               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 (((lisp (lisp (lisp (lisp lisp))))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp))
                     ((((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         ((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                           ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                       (lisp (lisp (lisp lisp))))))))
                  (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                         (lisp (lisp (lisp lisp))))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       (lisp lisp))))))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         (lisp (lisp (lisp (lisp lisp))))))
                       (lisp (lisp (lisp lisp)))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp))))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp (lisp lisp))))))
                           (lisp (lisp (lisp lisp)))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp))))
                             ((lisp (lisp (lisp lisp)))
                              (lisp (lisp (lisp (lisp lisp))))))
                            (lisp (lisp (lisp lisp)))))
                          (lisp lisp)))))
                      ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                        (lisp lisp))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       ((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                         ((lisp (lisp (lisp lisp)))
                          ((((lisp (lisp (lisp (lisp lisp))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                (lisp (lisp (lisp (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp (lisp lisp))))))
                                  (lisp (lisp (lisp lisp)))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  ((lisp (lisp (lisp lisp)))
                                   (lisp (lisp (lisp (lisp lisp))))))
                                 (lisp (lisp (lisp lisp)))))
                               (lisp lisp)))))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (lisp (lisp (lisp (lisp lisp))))))
                             (lisp (lisp (lisp lisp)))))))))))
                     (lisp (lisp (lisp lisp)))))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (((lisp (lisp (lisp (lisp lisp))))
                     ((lisp (lisp (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp)))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     ((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp lisp)))))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                              ((lisp (lisp (lisp lisp)))
                               ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
                          ((lisp (lisp (lisp lisp)))
                           (((((lisp (lisp (lisp (lisp lisp))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  (lisp (lisp (lisp (lisp lisp))))))
                                (lisp (lisp (lisp lisp)))))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp)))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      ((lisp (lisp (lisp lisp)))
                                       (lisp (lisp (lisp (lisp lisp))))))
                                     (lisp (lisp (lisp lisp)))))
                                   (lisp lisp)))))
                               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                                 (lisp lisp))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                ((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (lisp lisp))
                                  ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 ((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      ((lisp (lisp (lisp (lisp lisp))))
                                       (lisp lisp))))
                                    (lisp (lisp (lisp lisp))))))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp lisp)))))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp lisp)))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      (lisp lisp))
                                     (lisp lisp)))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp))))))))))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))))))))
                   (lisp (lisp (lisp lisp))))))))))))
          (lisp lisp))))
       (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
        ((lisp (lisp (lisp lisp)))
         (lisp (lisp (lisp lisp))))))))))
  (((lisp (lisp (lisp (lisp lisp))))
    (((lisp (lisp (lisp (lisp lisp))))
      ((lisp (lisp (lisp lisp)))
       (lisp (lisp (lisp (lisp lisp))))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (lisp (lisp (lisp lisp)))))
      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
       (lisp lisp)))))
   ((lisp (lisp (lisp lisp)))
    (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
     ((lisp (lisp (lisp lisp)))
      ((lisp (lisp (lisp lisp))) (lisp lisp))))))))
— SYZYGY-DEV 333
джерело
Це реальна мова з реалізацією? Якщо так, то можете, будь ласка, посилання на нього?
— Джо Кінг
@JoKing Wikipedia TIO
— Бенджамін Уркхарт
@BenjaminUrquhart Так, Лісп - це мова. Лісплісп, однак, я не знайшов жодних доказів
— Джо Кінг,
— Бенджамін Уркхарт
1
Ось перекладач на LazyK (це просто реалізація обчислення комбінатора SKI). gist.github.com/SYZYGY-DEV333/d74ca36b9a4c504b25c0a2380203c98d
— SYZYGY-DEV 333
2

Машинний код 8086, 27 байт

Не зібрано:

        STLOOP:
AC          LODSB               ; load byte from SI into AL, advance SI 
8B D0       MOV  DX, AX         ; save original char in DL 
0C 20       OR   AL, 020H       ; lowercase the char 
3C 61       CMP  AL, 'a'        ; is char less than 'a'? 
7C 0F       JL   STCHR          ; if so, do not rotate 
3C 7A       CMP  AL, 'z'        ; is char greater than 'z'? 
7F 0B       JG   STCHR          ; if so, do not rotate 
B6 0D       MOV  DH, 'n'-'a'    ; add or subtract 13 
3C 6E       CMP  AL, 'n'        ; is char less than 'n'? 
7C 02       JL   ADD13          ; if so, add positive 13 
F6 DE       NEG  DH             ; otherwise add -13 
        ADD13:
92          XCHG AX, DX         ; original char back to AL 
02 C4       ADD  AL, AH         ; add 13 or -13 to original char
        STCHR:
AA          STOSB               ; store converted byte into DI, advance DI 
E2 E5       LOOP STLOOP         ; continue loop through string

Рядок введення в SI, довжина в CX. Буфер вихідних рядків у DI.

Перевірте випуск програми IBM PC DOS:

введіть тут опис зображення

Завантажте програму тестування R13.COM (ПК DOS).

— 640 КБ
джерело
1

Haskell - 112 символів

r l=drop 13 l++take 13 l
t=['a'..'z']
s=['A'..'Z']
main=interact$map(\x->maybe x id$lookup x$zip(t++s)$r t++r s)
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.