17

В одном из наших проектов мы недавно обнаружили особенно большой метод генерации 6-символьной строки из 15-символьного алфавита. Некоторые из нас заявили: «Могу поспорить, что мы можем получить это в одной строке», что положило начало небольшой внутренней игре в Code Golf.

Ваша задача - победить нас, что, без сомнения, не заставит себя долго ждать!

Оригинальный алгоритм использовал алфавит 0-9A-E, но мы экспериментировали с другими алфавитами. Поэтому есть три подзадачи.

Создайте 6строку символов, случайным образом выбирая их из произвольно заданного 15алфавита символов, например ABC123!@TPOI098. (Это всего лишь пример, и его следует настраивать, не влияя на количество байтов.)
Создайте 6строку символов, случайным образом выбирая 15алфавит символов 0123456789ABCDE.
Создайте 6строку символов, случайным образом выбирая из 15алфавита символов на ваш выбор (только для печати символов, пожалуйста).

Каждый персонаж должен иметь равные шансы на выбор и повторение должно быть возможным.

Лучшее, что мы смогли решить для каждой из подзадач:

"ABC123! @ TPOI098" - 24 bytes
"0123456789ABCDE" - 21 bytes
Пользовательский алфавит - 13 bytes

Ваша оценка - это сумма байтов в решении каждой подзадачи. то есть наша оценка в настоящее время 58.

Мы пытались использовать, среди прочего, CJam и Ruby. Оригинал был на C #. Используйте любой язык, который вам нравится, но нам будет интересно увидеть решения на этих языках, особенно

code-golf generation

— Джеймс Вебстер
источник

5

Относительно многочастных задач. К сожалению, у меня нет хорошего решения в этом случае, так как эти три подзадачи слишком похожи, чтобы иметь смысл разделить их на несколько задач. Я также обдумывал предложение об исключении из этой политики для задач, состоящих из нескольких частей, где подзадачи являются лишь незначительными вариациями одной и той же задачи. (Хотя по-прежнему существует проблема, заключающаяся в том, что дополнительные решения могут быть взяты из других ответов.) Таким образом, я не буду пытаться изменить это и посмотреть, что думает сообщество.

— Мартин Эндер

«Ваша оценка - это сумма байтов ...», поэтому мой первый пример неудачен. Я исправлю другой потенциальный пример

— Джеймс Вебстер

2

@MartinEnder Мои 2 цента: я думаю, что все в порядке и не будет VTC. Конечно, я обычно считаю, что задача с одной интересной задачей лучше, но, поскольку эти задачи очень похожи, это намного лучше, чем «поле для гольфа», которое говорит: «Выполняйте эти 8 случайных несвязанных задач». Несмотря на то, что между задачами нет взаимодействия, на мой взгляд, эта задача не сильно отличается от, скажем, Golf всех 16 логических ворот .

— DJMcMayhem

Есть ли ограничения по времени или памяти? Подзадачи должны быть независимыми или им разрешено делиться кодом?

— Денис

2

Означает ли «генерация строки», что код должен фактически генерировать строковое значение с соответствующими символами в нем, или приемлемо выводить шесть символов (не разделенных пробелом или символами новой строки)?

— DLosc

6

Желе , 38 байт

TryItOnline ссылки A , B и C .

A :ABC123!@£POI09822 байта

“ABC123!@£POI098”Wẋ6X€

(думая о сжатии, чтобы уменьшить это)

B :0123456789ABCDE8 байт:

ØHṖWẋ6X€

C :123456789ABCDEF(выбор), 8 байтов:

ØHḊWẋ6X€

Как?

...Wẋ6X€ - common theme
   W     - wrap (string) in a list
    ẋ6   - repeat six times
      X€ - random choice from €ach

ØH...... - hexadecimal digit yield: "0123456789ABCDEF"

..Ṗ..... - pop: z[:-1] (B)

..Ḋ..... - dequeue: z[1:] (C)

— Джонатан Аллан
источник

8

CJam (23 + 14 + 10 = 47 байт)

Произвольный алфавит: 23 байта ( онлайн-демонстрация )

{"ABC123!@TPOI098"mR}6*

Шестнадцатеричный алфавит: 14 байтов ( онлайн-демонстрация )

{FmrAbHb'0+}6*

Пользовательский алфавит: ABCDEFGHIJKLMNO 10 байт ( онлайн демо )

{Fmr'A+}6*

рассечение

Шестнадцатеричный является интересным:

{      e# Loop...
  Fmr  e#   Select a random number from 0 to 14
  AbHb e#   Convert to base 10 and then to base 17
       e#   (i.e. add 7 if the number is greater than 9)
  '0+  e#   Add character '0' (i.e. add 48 and convert from integer to character)
       e#   Note that 'A' - '0' = 17
}6*    e# ...six times

Шесть символов остаются в стеке и печатаются автоматически.

— Питер Тейлор
источник

2

AbHbблестящий Я думал об этом общем подходе, но это _9>7*+было слишком долго.

— Мартин Эндер

6

Perl, 46 + 26 + 26 = 98 байт

Большая заслуга принадлежит @Dom Hastings для экономии 13 байтов!

3 программы в значительной степени идентичны, за исключением алфавита, который меняется.

Жестко закодированный алфавит ( ABC123!@)POI098в этом примере) -> 46 байт:

say map{substr"ABC123!@)POI098",15*rand,1}1..6
Фиксированный алфавит 0123456789ABCDE-> 26 байт:

printf"%X",rand 15for 1..6
Пользовательский алфавит 0123456789ABCDE в этом случае -> 26 байт:

printf"%X",rand 15for 1..6

Вы можете поместить их все в файл, чтобы запустить их:

$ cat 6chr_strings.pl
say map{substr"ABC123!@)POI098",15*rand,1}1..6;
say "";
printf"%X",rand 15for 1..6;
say "";
printf"%X",rand 15for 1..6;
say "";
$ perl -M5.010 6chr_string.pl
CB8!8!
24D582
9ED58C

( say "";только здесь, чтобы улучшить выходной формат)

— папа
источник

2

Хорошие ответы! У меня было почти то же самое для первого и последнего, но вы можете сохранить байт, используя say: say map{("ABC123!@)POI098"=~/./g)[rand 15]}1..6и say map{(A..O)[rand 15]}1..6. Для второго вы можете использовать printf: printf"%X",rand 15for 1..6сохранить 11 над всеми! Я уверен, что Тон может посоветовать немного тайной магии, чтобы сэкономить больше!

— Дом Гастингс

1

Собственно с нестандартным алфавитом substrспасает другое:say map{substr"ABC123!@)POI098",15*rand,1}1..6

— Дом Гастингс

1

@DomHastings Хм, действительно, это хорошо, хорошо сыграно! Спасибо :-)

— Дада

2

Мне нравится, что вы удалили примечание о простоте кода: D

— Dom Hastings

@DomHastings с printf"%X", substr..randи map, это немного менее очевидно, поэтому я позволяю людям наслаждаться магией Perl без спойлеров! : D

— Дада

4

R 33 + 43 + 59 = 135 байт

Произвольно жестко заданный алфавит (измените строку, чтобы изменить алфавит):

cat(sample(strsplit("ABC123!@TPOI098","")[[1]],6,1),sep="")

Алфавит [0-9A-E]:

cat(sample(c(0:9,LETTERS[1:6]),6,1),sep="")

Пользовательский алфавит из stdin:

cat(sample(scan(,''),6,1),sep="")

Во всех случаях выводится слово вывода на стандартный вывод.

— rturnbull
источник

4

JavaScript (ES6), 167 166 164 163 байта

Сохранено 1 байт благодаря Neil
Сохранено 2 байта благодаря ETHproductions
Сохранено 1 байт благодаря premek.v

Закодировано: "ABC123!@TPOI098" (58 байт)

f=(n=6)=>n?"ABC123!@TPOI098"[Math.random()*15|0]+f(n-1):''

Исправлено: "0123456789ABCDE" ( 58 57 байт)

f=(n=6)=>n?f(n-1)+("ABCDE"[n=Math.random()*15|0]||n-5):''

Пользовательский: "()+.1=>?M[afhnt" ( 51 49 48 байт)

f=(n=6)=>n?(f+1)[Math.random()*15|0+5]+f(n-1):''

— Arnauld
источник

1

(n=6)=>n?f(n-1)+("ABCDE"[n=Math.random()*15|0]||n-5):''экономит вам байт.

— Нил

1/8+Mathэто здорово :)

— ETHproductions

Но .1+JSONлучше;)

— ETHproductions

1

Или JSON+f( [object JSON](n=> " (JNOS[]bcejnot")

— ETHproductions

@ETHproductions Хороший. :)

— Арно

3

JavaScript (ES6), 184 байта

Пользовательский алфавит: 66 байт

_=>"......".replace(/./g,c=>"ABC123!@TPOI098"[Math.random()*15|0])

0-9A-E: 63 байта

_=>"......".replace(/./g,c=>"ABCDE"[n=Math.random()*15|0]||n-5)

0-9a-e: 55 байт

_=>(Math.random()*11390625+1e8|0).toString(15).slice(1)

(Вычтите 6 байтов, если допустима случайность на основе даты.)

— Нил
источник

Вы можете сохранить байт на последнем с **:_=>((Math.random()+1)*15**6|0).toString(15).slice(1)

— ETHproductions

@ETHproductions Конечно, это сделало бы это ES7, а не ES6? (Кроме того, это выглядит как 3-байтовое сохранение для меня.)

— Нил

Да, и кажется, что он экономит 3 байта. Я, должно быть, включил f=в число байтов

— ETHproductions

3

q, 42 байта

A

19 байт

6?"ABC123!@TPOI098"

В

14 байт

6?15#.Q.n,.Q.A

С

9 байт

6?15#.Q.a

(использует первые пятнадцать букв алфавита)

— skeevey
источник

3

Юлия (36 + 26 + 21 = 83)

join(rand(["ABC123!@TPOI098"...],6))

base(15,rand(15^6:15^7-1))

join(rand('a':'o',6))

— Линдон Уайт
источник

2

CJam, 48 байтов

Произвольный алфавит, 23 байта:

{"ABC123!@TPOI098"mR}6*

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

Шестнадцатеричные цифры, 15 байтов:

{A,'F,65>+mR}6*

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

Алфавит ABCDEFGHIJKLMNO, 10 байт:

{Fmr'A+}6*

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

— Мартин Эндер
источник

У меня была плохая идея. Если мы рассмотрим U + FFFE символ, ~cа не 'A+возвращает что-то технически печатное.

— jimmy23013

Может я не прав. Я не нашел определения печатаемых символов Юникода.

— jimmy23013

2

Рубин 47 + 37 + 31 = 115

Закодировано: "ABC123! @ TPOI098" (47)

(1..6).map{"5CABC123!@TPOI098".chars.sample}*''

Исправлено: "0123456789ABCDE" (37)

(1..6).map{[*0..9,*?A..?E].sample}*''

Таможня: "ABCDEFGHIJKLMNO" (31)

(1..6).map{[*?A..?O].sample}*''

— Майкл Коля
источник

1

05AB1E , 43 байта

Арбитражный алфавит ( ABC123!@TPOI098), 23 байта Попробовать онлайн

"ABC123!@TPOI098"6F.r¬?

Почти шестнадцатеричный алфавит ( 0123456789ABCDE), 10 байт. Попробуйте онлайн

14Ýh6F.r¬?

Пользовательский алфавит ( abcdefghijklmno), 10 байт. Попробуйте онлайн

A15£6F.r¬?

— Emigna
источник

1

Python 2, 70 + 70 + 64 = 204 байта

from random import*
s=""
exec"s+=choice('ABC123!@TPOI098');"*6
print s

from random import*
s=""
exec"s+=choice('0123456789ABCDE');"*6
print s

from random import*
s=""
exec"s+=chr(randint(65,80));"*6
print s

К сожалению, второй пример проще с первым методом, чем что-то вроде choice([randint(48,57)),choice(65,69)])

— Карл Напф
источник

Почему вы используете from random import*? Я думаю, что вы можете использовать import randomи random.choiceпо крайней мере в первых двух примерах.

— Роман Греф

import random random.choice27, но from random import* choice26, также import random as r r.choice27

— Карл Напф

В шестнадцатеричном случае format(randrange(8**8),'X'), я думаю , мы можем сделать немного лучше, используя .

— DSM

@DSM проблема в том, что не должно бытьF

— Карл Напф

1

Витси, 27 + 24 22 + 13 10 = 64 62 59 байт

# 1:

"ABC123!@TPOI098"6\[eR2+@O]

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

# 2:

aH7+D4+H6\[eR2+@68*+O]

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

# 3:

6\[eR5F-O]

Где доступны символы:

ﾖﾕﾔﾓﾒﾑﾐﾏﾎﾍﾌﾋﾊﾉﾈ

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

— Аддисон Крамп
источник

1

J 24 + 24 + 18 10 = 58 байт

8 миль сэкономлено благодаря миль!

'ABC123!@TPOI098'{~?6#15
'0123456789ABCDE'{~?6#15
u:65+?6#15

Да, вторая строка не легко сжимается в J:

u:47+23#.inv 12670682677028904639x
u:47+;(+i.@])/"1&.>1 10;18 5
('ABCDE',~1":i.10)
(toupper,hfd?6#15)
'0123456789ABCDE'

Если шестнадцатеричный алфавит в нижнем регистре ,hfd?6#15подойдет , то для 9 байтов, как заметил @miles.

Во всяком случае, ?6#15это 6 случайных чисел от 0 до 15; {~это взятие из. u:преобразует числа в символы Последний пример кодирует ABCDEFGHIJKLMNOP.

Бонус: общий случай

{~6?@##

{~6?@## примерно:

{~6?@##  input: y
      #  length of y
  6  #   six copies of the length
   ?@    random numbers between 0 and the length
{~       taken from y

— Конор О'Брайен
источник

На втором случае, есть встроенное имя , hfdкоторый преобразует в ч ех е ром д ecimal. Вы можете получить 9-байтовое решение, используя ,hfd?6#15. В последнем случае, просто чтобы что-то легко прочитать, используется алфавит из 'A'10-байтного решения u:65+?6#15, что в итоге составляет 24 + 9 + 10 = 45.

— миль

@ Мили Я думаю, что второй случай требует заглавных букв. Что касается последнего случая ... хаха, упс. Я полностью забыл про векторизованное сложение.

— Конор О'Брайен

1

PHP, 46 + 36 + 35 = 117 байт

Твердо закодировано (46 байт)

for(;$i++<6;)echo"ABC123!@TPOI098"[rand()%15];

~~(47 байт)~~

~~for(;$i++<6;)echo"ABC123!@TPOI098"[rand(0,14)];~~

Шестнадцатеричный (строчные буквы) (36 байт)

for(;$j++<6;)echo dechex(rand()%15);

В верхнем регистре 46 байтов в версии с жестким кодом.

Пользовательский (AO) (35 байт)

for(;$k++<6;)echo chr(rand(65,79));

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

Я не думаю, что могу принять вашу вторую часть. AE не то же самое, что AE

— Джеймс Вебстер

0

Scala, 154 байта

Твердо закодированный алфавит (54 байта):

Seq.fill(6)("ABC123!@TPOI098"((math.random*14).toInt))

Шестнадцатеричный алфавит (54 байта):

Seq.fill(6)("0123456789ABCDE"((math.random*14).toInt))

Пользовательский алфавит ABCDEFGHIJKLMNO(47 байт):

Seq.fill(6)(('A'to'O')((math.random*14).toInt))

Объяснение:

Seq.fill(6)(               //build a sequence of 6 elements, where each element is...
  "ABC123!@TPOI098"(         //from the string
    (math.random*14).toInt   //take a random char
  )
)

'A'to'O' создает последовательность из 15 символов, от А до О

— corvus_192
источник

0

Пип , 42 байта

Твердо закодированный алфавит, 22 байта:

L6ORC"ABC123!@TPOI098"

Шестнадцатеричные цифры, 11 байт:

L6ORR15TB16

Первые 15 строчных букв, 9 байтов:

L6Oz@RR15

объяснение

Все три программы начинаются с L6O: цикл 6 раз и выводит заданное выражение.

RC"...": Случайный выбор персонажа из жестко закодированной строки
RR15TB16: RandRange (15), преобразованный в базу 16
z@RR15: строчный алфавит z, проиндексированный с помощью RandRange (15)

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

— DLosc
источник

0

Скрипт / skQuery , 108 байт

Закодировано (43 байта):

random 6 char string from `A@cD%F3h9JK{mN!`

0123456789ABCDE (34 байта):

random 6 char string from `0-9A-E`

Выбор (31 байт):

random 6 char string from `A-M`

— Оливер Ни
источник

Вы можете переместить отверстие `влево?

— Эддисон Крамп

@VTCAKAVSMoACE Нет, не позволяет

— Оливер Ни

0

Джольф, 26 + 14 + 13 = 51 байт

Μ*S6d rG"ABC123!@TPOI098"E

Пользовательский алфавит, 24 байта. Попробуй это здесь!

Μ*S6d r lp^0wά

0-9A-E алфавит, 14 байтов. Попробуй это здесь! lp^0wάявляется lp(0-Z) нарезанным ( l) из 0to 15( wά).

Μ*S6d r lp^1ά

1-9A-F алфавит, 13 байтов. Попробуй это здесь! lp^1άто же самое, что и выше, за исключением 1к 16.

Общий метод:

Μ*S6d r
M*S6d      map six newlines over this function:
      r    select random element from array.

Другие попытки (с использованием сжатия строк):

Μ*S6d rGμpwΞ $AE

— Конор О'Брайен
источник

0

PowerShell v2 +, 45 + 44 + 37 = 126 байт

Фиксированный алфавит, 45 байт

-join(0..5|%{'ABC123!@TPOI098'[(Random)%15]})

Почти шестнадцатеричный алфавит, 44 байта

-join[char[]](0..5|%{Random(48..57+65..69)})

Пользовательский алфавит (от A до O), 37 байт

-join[char[]](0..5|%{Random(65..79)})

Все они следуют одному и тому же шаблону - цикл from 0до 5, каждая итерация выбирает Randomсимвол или значение ASCII, charпреобразует его как -array, если необходимо, и -joinобъединяет его вместе в строку. Эта строка остается в конвейере, а вывод неявным.

Примеры

PS C:\Tools\Scripts\golfing> -join(0..5|%{'ABC123!@TPOI098'[(Random)%15]})
32ATB3

PS C:\Tools\Scripts\golfing> -join(0..5|%{'ABC123!@TPOI098'[(Random)%15]})
III@B2

PS C:\Tools\Scripts\golfing> -join(0..5|%{'ABC123!@TPOI098'[(Random)%15]})
@302O@

PS C:\Tools\Scripts\golfing> -join[char[]](0..5|%{Random(48..57+65..69)})
74E117

PS C:\Tools\Scripts\golfing> -join[char[]](0..5|%{Random(48..57+65..69)})
09D7DD

PS C:\Tools\Scripts\golfing> -join[char[]](0..5|%{Random(65..79)})
COJDFI

PS C:\Tools\Scripts\golfing> -join[char[]](0..5|%{Random(65..79)})
EAKCNJ

— AdmBorkBork
источник

-1

Пайк, 35 байт

Произвольный алфавит, 20 байтов

6V"ABC123!@TPOI098"H

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

Шестнадцатеричный алфавит, 8 байт

6V~J15<H

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

~J15< - "0123456789abcdefghijklmno..."[:15]

Пользовательский алфавит, 7 байт

6VG15<H

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

G15< - alphabet[:15]

Алфавит выбран: abcdefghijklmno

6V     - repeat 6 times:
  ...  -   get alphabet
     H -  choose_random(^)

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

Это похоже на вывод 6 символов, разделенных символом новой строки вместо строки из 6 символов.

— Emigna

Вопрос не указывает формат вывода.

— Голубой

Я вижу слова Генерация 6-символьной строки в 4 местах в спецификации.

— Эминья

Создать 6-символьную строку из 15-символьного алфавита

Желе , 38 байт

Как?

CJam (23 + 14 + 10 = 47 байт)

рассечение

Perl, 46 + 26 + 26 = 98 байт

R 33 + 43 + 59 = 135 байт

JavaScript (ES6), 167 166 164 163 байта

JavaScript (ES6), 184 байта

q, 42 байта

Юлия (36 + 26 + 21 = 83)

CJam, 48 байтов

05AB1E , 43 байта

Python 2, 70 + 70 + 64 = 204 байта

Витси, 27 + 24 22 + 13 10 = 64 62 59 байт

J 24 + 24 + 18 10 = 58 байт

Бонус: общий случай

PHP, 46 + 36 + 35 = 117 байт

Твердо закодировано (46 байт)

Шестнадцатеричный (строчные буквы) (36 байт)

Пользовательский (AO) (35 байт)

Scala, 154 байта

Пип , 42 байта

объяснение

Скрипт / skQuery , 108 байт

Джольф, 26 + 14 + 13 = 51 байт

PowerShell v2 +, 45 + 44 + 37 = 126 байт

Примеры

Пайк, 35 байт

Произвольный алфавит, 20 байтов

Шестнадцатеричный алфавит, 8 байт

Пользовательский алфавит, 7 байт