Генерация шифра

15

Генерация шифра с учетом числа и строки

Ваша задача проста. Учитывая строку sи число в 0 <= n <= 9качестве входных данных, вставьте псевдослучайный печатный символ ASCII между каждым символом строки nраз. Такой, что для каждого символа между ними sесть nслучайные символы. Пространства должны быть обрезаны.

Входные данные:

  • строковая sфраза для шифрования в шифре
  • целое число nв диапазоне0 <= n <= 9

Пример:

Входные данные:

The treasure is here
2

Выход:

T ! 0 h 32 e F4 t 0i r lk e hm a 7y s # 0 u * & r * h e ! 2 i H ^ s B, h ! @ E 0) r $ h e


Это поэтому выигрывает самый короткий код! Удачи и получайте удовольствие!

jacksonecac
источник
3
Случайный печатный символ ASCII Вам необходимо определить, что здесь означает случайный . Shold все печатные символы ASCII имеют одинаковую вероятность? Должны ли они быть статистически независимыми? Какую гибкость мы имеем в отношении этого?
Луис Мендо
3
@ jacksonecac Я не согласен. Просто сказать случайное недостаточно. Например, если я выбираю только случайные символы с четными кодами ASCII, это все равно случайно, но, вероятно, это не принято (или не так ли?). Если каждая серия nсимволов состоит из nкопий одного и того же случайного символа, они все еще случайные, но они не является статистически независимым. И так далее
Луис Мендо
5
@jacksonecac «случайный» - это очень широкий термин. Могу ли я выбрать символы с нормальным распределением, чтобы символы вокруг Oбыли более вероятными, чем пробелы или ~? Если оно должно быть равномерным, то вы должны сказать об этом явно. И если оно не должно быть равномерным, то вы должны хотя бы указать, что каждый персонаж должен иметь ненулевую вероятность. Вы также указаны в предыдущем комментарии , что каждый символ имеет иметь независимое распределение, так что, если это важно, следует отметить , в задаче. Существует очень широкий спектр случайности.
Мартин Эндер
3
Это на самом деле не шифр. Возможно, это стеганография.
Грег Мартин
2
Это неправильный ответ на правильную точку @MartinEnder. Решение состоит в том, чтобы явно указать, что символы должны быть однородными и статистически независимыми друг от друга, и комментарии прекратятся. Альтернативной (но более открытой для злоупотребления) спецификацией может быть то, что перекошенные распределения или те, где символы зависят друг от друга, в порядке, если все символы имеют ненулевую возможность возникновения. В коде гольф спецификация важна для справедливости. Поскольку вы, по-видимому, не хотите отвечать на эти действительные комментарии по поводу в противном случае хорошей задачи, я голосую за закрытие.
Уровень Река St

Ответы:

7

C #, 141 131 байт

Очень похоже на Java-ответ @ Geobit , за исключением более длинного в настоящее время :(

(I,n)=>{var R=new System.Random();var o="";int i,r;foreach(var c in I)if(c>32)for(i=r=0,o+=c;i++<n;){r=R.Next(33,127);o+=(char)r;}return o;};

Полный лямбда-материал:

Func<string, int, string> a = (I,n) =>
{
    var R=new System.Random();
    var o="";
    int i;
    foreach(var c in I)
        if(c>32)
            for(i=0,o+=c;i++<n;o+=(char)R.Next(33,127));
    return o;
};
Yodle
источник
почему R=...вы можете просто использовать напрямую, new System.Random().Next(...)я думаю
Роман Gräf
2
@ RomanGräf msdn.microsoft.com/en-us/library/h343ddh9(v=vs.110).aspx Случайный класс C # без начального числа будет использовать системные часы, поэтому, если вы вызываете в быстрой последовательности (например, в цикл значений), большинство значений оказываются идентичными, что не сработает в большинстве случаев :( Поверьте мне, я всегда стараюсь, а потом вспоминаю это.
Йодль
7

05AB1E , 11 байт

ð-vy²FžQ.RJ

Попробуйте онлайн!

объяснение

ð-           # remove spaces from input string
  v          # for each char in the string
   y         # push the char
    ²F       # input-2 number of times do:
      žQ.R   # push a random ascii character
          J  # join to string
Emigna
источник
близко! обрезать пространства! :)
jacksonecac
@jacksonecac: пропустил эту часть извините. Исправлено сейчас :)
Emigna
хорошая работа! это работает!
Jacksonecac
1
@carusocomputing: добавляет случайные символы после последней буквы. Не только между буквами.
Эминья
1
@Emigna После недавнего комментария по этому вопросу, это, кажется, хорошо :)
geisterfurz007
6

Java 7, 132 124 байта

String f(int n,char[]a){String o="";int i;for(char b:a)if(b>32)for(i=0,o+=b;i++<n;o+=(char)(33+Math.random()*94));return o;}

Ничего особенного, просто двойная петля, как и следовало ожидать. Наружный цикл для петли, внутренний для заполнения случайных чисел:

String f(int n,char[]a){
    String o="";
    int i;
    for(char b:a)
        if(b>32)
            for(i=0,
                o+=b;
                    i++<n;
                        o+=(char)(33+Math.random()*94));
    return o;
}
Geobits
источник
Не нужно k: String f(int n,char[]a){String o="";for(char b:a)if(b>32){o+=b;for(int i=0;i++<n;o+=(char)(33+Math.random()*94));}return o;}(125 байт)
Оливье Грегуар
Ооо верно. Я использовал это с другим методом. Не думал о том, чтобы снять его, когда я пошел с charактерами. Благодарность!
Geobits
Виноват. Я ошибся, мое предложение было также 124 байта: я проверил столбец вместо длины;)
Оливье Грегуар
Да, я заметил это при сравнении двух :)
Geobits
5

Пайк, 12 11 9 байт

d-FQV~KHs

Попробуй это здесь!

d-        -  remove spaces from input
  F       - for i in ^:
   QV     -  repeat (number) times:
     ~KH  -    random_from(printable)
        s -   sum(^)

Конечный случайный символ в порядке в соответствии с OP.

синий
источник
5

Октава, 43 байта

@(s,n)[s(s>32);33+94*rand(n,nnz(s>32))](:)'

Это принимает строку sи целое число в nкачестве входных данных. Строка в Octave - это просто массив символов. s>32является логической картой 1для любых непространственных символов. Код добавляет матрицу со nстроками и таким же количеством столбцов, что s(s>32)и содержит числа с плавающей запятой в диапазоне от 33 до 126. Она неявно округляется до целых чисел и преобразуется в символы ASCII, когда объединяется со строкой s. (:)'выправляет это к горизонтальному массиву символов.

Проверьте это здесь!

Стьюи Гриффин
источник
1
Неявное округление! Ницца
Луис Мендо
4

Python 2, 123 122 118 114 98 байт

Чувак, хотелось бы, чтобы это randomбыло не так дорого (и чтобы нам не приходилось фильтровать места). Теперь у нас есть большая экономия от того, что в конце нам разрешено иметь зашифрованные символы :) В любом случае, вот так:

from random import*
f=lambda s,n:s and(' '<s[0])*eval('s[0]'+'+chr(randint(32,126))'*n)+f(s[1:],n)
Када
источник
4

JavaScript (Firefox 30+), 96 байт

(s,n)=>s.replace(/. */g,x=>x[0]+String.fromCharCode(...[for(_ of Array(n))Math.random()*95+32]))

Чистая ES6 на два байта длиннее:

(s,n)=>s.replace(/. */g,x=>x[0]+String.fromCharCode(...[...Array(n)].map(_=>Math.random()*95+32)))

Вот действительно крутой подход, который, к сожалению, на 26 байт длиннее:

(s,n)=>String.raw({raw:s.split` `.join``},...[for(_ of s)String.fromCharCode(...[for(_ of Array(n))Math.random()*95+32])])
ETHproductions
источник
Строго говоря /. *(?=.)/, не работает для строк, начинающихся или заканчивающихся в пробелах, не то, чтобы кто-то заботился. (Тебе даже разрешено отследить случайные символы сейчас.)
Нил
@Neil Трейлинг случайные символы разрешены? Я думаю, я могу просто удалить, (?=.)который заботится о пробелах в конце строки.
ETHproductions
Спецификация не так ясна, но я думаю, что вы должны избегать вставки пробелов, поэтому 94+33вместо95+32
edc65
3

CJam , 21 18 байт

lS-(ol~f{{95mrSc+\}*}

Попробуйте онлайн!

Печатает nслучайные символы в конце.

объяснение

lS-        e# Read line and remove spaces.
l~         e# Read and evaluate another line.
f{         e# For each character (passing in N)...
  {        e#   Do this N times...
    95mr   e#     Push random integer in [0, 95).
    Sc+    e#     Add to space character, giving a random printable ASCII character.
  }*
}
           e# All characters remaining on the stack are printed implicitly
           e# at the end of the program.
Мартин Эндер
источник
3

Баш, 124 байта

Чистый bash + coreutils , нет структур потока управления, нет подъязыков, нет "eval"

Golfed

E() { N=${1// /};paste <(fold -1<<<$N) <(tr -cd "\\40-\\176"<\/dev\/urandom|head -c$(($2*${#N}-$2))|fold -$2)|tr -d '\t\n';}

Тестовое задание

>E "The treasure is here" 2
TkZhf(e&Rt@FrS,edha+-sJTuh.rX@eVKi+3s<7hftey8r*/e
дирижабль
источник
3

Q / KDB +, 39 36 34 байт

raze{""sv(raze x;`char$40+n?87)}prior s
(,/)({""sv((,/)x;`char$40+n?87)}':)s

(,/)({""sv((,/)x;10h$40+n?87)}':)s

Переменные в использовании:

s:"The treasure is here"
n:2

При этом используется предыдущее наречие, которое применяет функцию слева между каждым элементом справа и его предшественником. (По сути, применяет функцию слева между каждым символом справа.)

Генерация n случайных чисел от 40 до 126, а затем преобразование их в эквивалентный символ: (q, кажется, только символы для них)

`char$40+n?87

//Possible characters.
()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Пример вывода:

TVghrveVp Rpti+r0sea3a9nsIjuRXrAReJ; +di=ys`{ ikhKTe4trTZesz

РЕДАКТИРОВАТЬ:
3 байта были сохранены путем преобразования размера q в (, /) с использованием записи k и аналогичным образом изменены до `: Благодаря @slackwear за обновление побрили 2 байта :)

Адам Дж
источник
1
может спасти пару байтов, 10h$
применив
2

Java 8, 114 байт

Golfed

(n,s)->s.chars().forEach((c)->{if(c>32)for(int i=0;i<=n;)System.out.print((char)(++i==1?c:33+Math.random()*94));})

Лямбда, которая принимает целое число и строку. Вдохновленный ответом Java 7, String.charsвыполните двойной цикл с использованием некоторого синтаксиса Java 8 Stream ( ) для экономии нескольких байтов.

вход

3, "Hello world!"

Выход

HfKIedb3l<-Ul%}vod"Bw\"|oa`%rH-}l/-{dMS;!B#X
Xanderhall
источник
2

Скала, 95 94 байта

def c(s:String,i:Int)=s.filter(_>32).mkString(scala.util.Random.alphanumeric.take(i).mkString)

Ничего особенного, кроме использования mkString для String. Он обрабатывает строку как список символов и позволяет мне вставить разделитель между ними. Мой разделитель - это соответствующее количество случайно сгенерированных буквенно-цифровых символов.

Итан
источник
Не совсем отвечает на вопрос. Природа Random.alphanumericзаставит каждый кусок быть одинаковым, так что это неубедительный шифр ... Смотрите этот пример:scala> c("Hello", 1) res0: String = Hbeblblbo
Джейкоб
Кстати, вы можете удалить filter. Вызов mkStringString будет рассматривать его как коллекцию символов.
Джейкоб
@Jacob фильтр - самый эффективный способ удаления пробелов. Я оставил случайное как есть, так как это казалось достаточным, но если у меня будет время, я добавлю отдельную функцию для правильного случайного текста.
Итан
2

> <> (Рыба) 107 106 103 байта

<v}:{r&" "
1xv+
2<v+
v}<
<~v!?=&:&:
6.>ol2-?!;a
:{{:}l1-[rv
v2<
<1x|!}:}-1<v!?:{{:o-+
^3<v ~}}r]~<
.40<

Попробуйте онлайн!

Это не супер случайно, но это случайно. Просто поместите строку и целое число в стек (пример: «Hello world!», 5).

Input: "Hello world!", 5
Output: H^\^]^eceeedldcdeclgfffhowhhfggojkkkkrdccedl]]\]\d

Полное объяснение

Это немного более старая версия кода, пока я не обновлю объяснение. Это в основном то же самое, просто, может быть, немного легче читать:

< v}:{r&" "
+1xv
+2<v
   }
:&:<~ v!?=&
?!;a6.>ol2-
:{{:}l1-[rv
v2<
<1x|!}:}-1<v!?:{{:o+*
^3<v ~}}r]~<
.43<

Мы притворимся, что строковый параметр is, sа целочисленный параметр is i.

< v}:{r&" "

Он <приказывает рыбе немедленно сдвинуться влево, что оборачивается вокруг " ", что добавляет пространство, обозначенное в стопке. Затем рыба путешествует &, что добавляет место в регистр. rпереворачивает стек и {:}сдвигает стек влево (помещая iконец стека), копирует значение в конец стека и затем сдвигает его вправо. vговорит рыбе начать движение вниз.

+1xv
+2<v
   }

xприказывает рыбе двигаться в произвольном направлении, в результате чего рыба движется направо и продолжает движение вниз, либо переходит 1+или 2+заранее. Они добавляют 1 или 2 соответственно к числу в конце стека. Если рыба движется вверх, она vснова попадает и спускается вниз. }сдвигает стек вправо, затем имеет iпозицию 1 в стеке и эту новую переменную в позиции 0 (мы назовем ее m).

:&:<~ v!?=&

Этот раздел является функцией, назовем ее whitespaceTrimmer . Это начинается там, где <есть. Он просто удаляет пробелы, которые находятся в конце стека (то есть в начале строки), пока не встретится непробельный символ.

Таким образом, рыба немедленно плывет в <и должна двигаться влево. Затем он сталкивается с:&:& копирует значение, которое копирует значение в конец стека, помещает пространство из регистра в конец стека, копирует его и помещает обратно в регистр.

Затем рыба попадает =?!v ~, или, точнее говоря, =извлекает последние два значения (два, которые мы только что создали) из стека, сравнивает их, помещает 1 в конец стека, если они равны, и 0 на конец стека, если они разные. ?Выскакивает новое значение с конца стека, если 0 оно не выполняет следующую инструкцию, которая в данном случае !, вместо этого он исполняет v, который заказывает рыбу двигаться вниз (выход из функции).

Однако, если он равен 1, то он нашел пробел, поэтому он выполняет !батут, и это заставляет рыбу пропустить следующую инструкцию, которая является v, и рыба продолжает. Перед рыбой он видит, ~что говорит ему выкинуть последнее значение из стека (подтверждено, что это пробел), затем рыба продолжает и снова запускает функцию.

?!;a6.>ol2-

Рыбе немедленно приказывают плавать прямо на a >, затем вывести последний символ в стеке o(который при первом запуске является первым символом s). Он получает длину стека l, помещает a 2в конец стека и затем -вычитает 2 из l. Это поражает, ?!;что, помня, что ?делает, заставляет рыбу пропускать! если стек пуст, и приземляется ;, что завершает программу.

Следуя, если в стеке все еще есть символы, мы выполняем, !что заставляет рыбу подпрыгивать над ;и выполнять a6., который хранит a(AKA 10), и 6в конце стека, которые являются x, yкоординатами для. которых они выталкиваются из конца стека, затем телепортирует рыбу 10, 6и выполняет инструкцию справа от этого положения (поскольку рыба плывет вправо).

Это менее сложно, чем кажется, когда вы понимаете, что yпозиция 6 - это линия ниже этой. xпозиция 10 есть v, а справа от этого есть , что не может. Это заставляет рыбу продолжать плавать правильно и фактически начинать выполнение в начале строки ...

:{{:}l1-[rv
v2<
<1x|!}:}-1<v!?:{{:o+*
^3<v ~}}r]~<
.43<

Так что это функция, которая добавляет случайный текст между символами. Это немного глоток, но это только потому, что я пытался сделать это немного более случайным. Давайте назовем это genRandomChars .

:{{:}l1-[rvФактически установка для функции, и менее , так часть самой фактической функции. Рыба сначала переплывает, :{{что копирует значение в конец стека, затем дважды сдвигает его влево. Если вы вспомните, что это iбыло в позиции 1 в стеке, то вы бы знали, iчто теперь это конец стека.

Рыба затем переплывает то, :}что копирует i, и сдвигает стопку вправо, помещая ее iкак в начало, так и в конец стопки. l1-[пусть рыба поместит длину в конец стека, вычтет из нее 1, а затем [создаст новый стек, переместив l-1(длина стека минус 1) значения в новый стек (поэтому просто оставляя iв старом стеке). Затем рыба просто ударяется, rvчто снова переворачивает стопку (я думаю, что создание новой стопки переворачивает ее по какой-то причине), и приказывает рыбе снова плавать вниз, действительно начиная функцию с< ниже.

Так что в настоящее время конец стека имеет mи наш временный i, который мы будем называть ti. Сразу же рыба переплывает 1-}, что вычитает 1 из tiи перемещает его в начало стека. Затем, :}который просто копирует mи перемещает его в начало стека (помещаяti в позицию стека 1).

Это когда мы попали в эту маленькую вещь:

v2<
<1x|!
^3<

Это на самом деле очень просто. !Заставляет рыбу пропустить |и выполнить x. Помня, что xделает, мы помним, что это заставляет рыбу двигаться в любых 4 направлениях. |просто зеркало, и заставляет рыбу плыть обратноx . Таким образом, по сути, рыба поместит 1, 2 или 3 в конец стека и продолжит движение влево, оборачиваясь вокруг.

Затем выполняется выполнение fish, в результате *+oчего последние два значения в стеке отбрасываются, умножаются вместе, и результат возвращается обратно, затем то же самое с добавлением, затем окончательное значение отбрасывается из стека и выводится с помощью o. Наш стек теперь относительно нормально снова , содержащий только [ m, ti,s ].

:}}:приводит к тому, что значение на конце стека (в основном sпозиция 0) не копируется, затем стек сдвигается вправо дважды ( tiснова помещается на переднюю часть), а затем tiкопируется. ?!vдолжно быть довольно легко понять сейчас. В основном, если ti0, то мы выходим из функции с помощью v, в противном случае мы выполняем !и пропускаемv (делая еще один цикл).

Если tiравно 0, и мы закончили выводить немного случайные символы, тогда мы выполняем vи видим:

   v ~}}r]~<
.43<

Здесь нет ничего особенного. Удаляем tiиз стека через ~. Затем ]новый, он выталкивает все наши значения из стека и помещает их в старый стек! Из - за этого вопроса разворота мы с обратной r, то сдвигать стек вправо дважды }}~, shufting стек справа, что дает нам [ m, i,s ], то ~есть , чтобы удалить лишнюю дублированныйs[0] ранее в функции , как мы должны были бы, если мы делали петлю (но мы не, мы уходим). vговорит рыбе плыть вниз и в >34.(инвертировано, чтобы показать порядок выполнения), что говорит рыбе просто плыть влево и внутрь 3, 4(потому что. это прыжок!). 3, 4на самом деле только справа от началаwhitespaceTrimmer, что идеально, потому что мы едем налево.

Следуя всей этой логике, мы можем следовать за рыбой до тех пор, пока стек в конечном итоге не станет пустым и программа не выйдет сразу после whitespaceTrimmerвыполнения.

redstarcoder
источник
Хм, я не видел, что персонаж должен быть печатным. Это потребует небольшой модификации, которая может сделать его менее случайным и меньшим.
Redstarcoder
Это не выглядит намного менее случайным. Я считаю, что это должно работать в большинстве случаев, у меня еще не получилось. Он будет работать с любой заглавной или строчной буквой, а также с некоторыми символами. Я уверен, что это удовлетворяет требованиям задачи.
Redstarcoder
2

Perl 5, 81 байт

($_,$n)=<>;chomp;y/ //d;$\=chop;print map{$_,map{chr 33+int rand 94}1..$n}split//

Я надеюсь, что следующее поможет вам понять, что делает однострочник:

($_, $n) = <STDIN>;  # Reads in the string into $_,
                     # and the number into $n, from standard input.
                     # (<STDIN> works slightly different from <>.)
chomp($_);           # Removes the newline from the string.
$_ =~ tr/ //d;       # `Tr/`ansliterates ASCII space characters
                     # into nothing, effectively `/d`eleting them.
$\ = chop($_);       # Chop()s off the last character out of $_ and
                     # appends it to the output when print()ing.
                     # (Perl always prints $\ after you call print().)
print( map {         # Each element of [List 1] will be mapped to:
    $_,              #   -- Itself, and
                     # (When mapping, each element is available as $_.)
    map {            # (`map` resembles `foreach` but returns a list.)
        chr(         #   -- A random ASCII character, in the range
          33 + int(rand(94)) ) # from 33 (!, hex 21) to 126 (~, hex 7E)
    } 1..$n          # ...$n times! (Over the range 1 to $n, actually.)
} split(//, $_) );   # [List 1] is $_, split() into characters.
g4v3
источник
1

Clojure, 126 123 118 122 117 байт

(defn c[m n](apply str(remove #(=\space %)(mapcat #(apply str %(for [_(range n)](char(rand-nth(range 32 127)))))m))))

Наносит на карту сообщение, вставляет случайные символы, затем объединяет результат.

Инструкции предполагают, что все пробелы должны быть удалены из результирующей строки. Если предполагается удалить только пробелы из исходного сообщения, я могу это изменить.

Ungolfed:

(defn cipher [message n]
  (apply str
    (remove #(= \space %)
        (mapcat #(apply str %
                     (for [_ (range n)]
                       (char (rand-nth (range 32 127)))))
                message))))
Carcigenicate
источник
1

Python 3, 127 байт

import random
a,b=input(),input()
print(''.join([x+''.join([chr(random.randint(33,126))for c in range(int(b))]) for x in a]))

Вероятно, намного дольше, чем необходимо, но пока это мой гольф.

Vedvart1
источник
1
Это добавляет случайные символы перед первым символом, и пробелы не обрезаются. Я думаю, что обе эти вещи нарушают правила.
Стьюи Гриффин
1

PHP, 96 байт

Принимает String в качестве аргумента 1 и Number в качестве аргумента 2

for(;($s=str_replace(' ','',$argv[1]))[$j]>'';)echo$i++%($argv[2]+1)?chr(rand(33,127)):$s[$j++];

Попробуйте онлайн

крипто-
источник
1

Python 3, 133 байта

from random import *
c=int(input())
print(''.join([i+''.join([chr(randint(33,126))for i in range(c)])for i in input().strip(' ')])[:-c])
sonrad10
источник
1

Node.js, 88 байт

(s,n)=>s.replace(/./g,c=>c!=" "?c+crypto.randomBytes(n).toString`base64`.substr(0,n):"")

Пример выходов:

f("The treasure is here", 2)
// THphdwekAtMArbSeU1aDTsZWuqnr2yek1iyUsKshqXewvrVCeTi

f("The treasure is here", 2)
// TYshlcep6t4Iru7e29aQ1sl/uvQrlzeSJihysDhhOLe1urpte1m

Попробуйте онлайн!

Флоран
источник
1

С, 102 100 байт

-2 байта для пропуска continue.

i;f(char*s,int n){do{while(*s==32)++s;putchar(*s);i=n;while(i--)putchar(32+rand()%95);}while(*s++);}

Ungolfed:

i;
f(char*s,int n){
 do{
  while(*s==32)++s;
  putchar(*s);
  i=n;
  while(i--)
    putchar(32+rand()%95);
 }while(*s++);
}

Использование:

main(){
  char a[]="A   A A";
  f(a,3);
}
Карл Напф
источник