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

Ваша задача проста. Учитывая строку 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

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

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

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

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

Пайк, 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.

Октава, 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. (:)'выправляет это к горизонтальному массиву символов.

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

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)

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

R, 97 байт

Безымянная функция принимает входные данные x(строку) и n.

function(x,n,l=nchar(x))for(i in 1:l)cat(substr(x,i,i),if(i<l)intToUtf8(sample(32:126,n)),sep="")

Попробуйте это на R-скрипке

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.

Баш, 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

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 байта :)

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

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

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

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

> <> (Рыба) 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выполнения.

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.

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

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

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

PHP, 96 байт

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

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

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

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

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

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

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