17

Trong một trong những dự án của chúng tôi tại nơi làm việc, gần đây chúng tôi đã phát hiện ra một phương pháp đặc biệt lớn để tạo chuỗi 6 ký tự từ bảng chữ cái 15 ký tự. Một số người trong chúng tôi tuyên bố "Tôi cá là chúng tôi có thể đạt được điều đó trong một dòng", bắt đầu một trò chơi nội bộ nhỏ về môn đánh gôn.

Nhiệm vụ của bạn là đánh bại chúng tôi, điều mà tôi chắc chắn sẽ không mất nhiều thời gian!

Thuật toán ban đầu đã sử dụng bảng chữ cái 0-9A-E, nhưng chúng tôi đã thử nghiệm với các bảng chữ cái khác. Do đó có ba nhiệm vụ.

Tạo một 6chuỗi ký tự chọn ngẫu nhiên từ một 15bảng chữ cái ký tự mã hóa tùy ý như thế nào ABC123!@TPOI098. (Đây chỉ là một ví dụ và nên có thể tùy chỉnh mà không ảnh hưởng đến số byte.)
Tạo 6chuỗi ký tự chọn ngẫu nhiên từ 15bảng chữ cái ký tự 0123456789ABCDE.
Tạo 6chuỗi ký tự chọn ngẫu nhiên từ 15bảng chữ cái ký tự bạn chọn (chỉ có thể in các ký tự có thể in).

Mỗi nhân vật nên có cơ hội lựa chọn và lặp lại như nhau là có thể.

Điều tốt nhất chúng tôi có thể quản lý cho mỗi nhiệm vụ là:

"ABC123! @ TPOI098" - 24 bytes
"0123456789ABCDE" - 21 bytes
Bảng chữ cái tùy chỉnh - 13 bytes

Điểm của bạn là tổng số byte trong mỗi giải pháp của nhiệm vụ con. tức là điểm của chúng tôi hiện là 58.

Chúng tôi đã cố gắng sử dụng trong số những người khác, CJam và Ruby. Bản gốc là trong C #. Sử dụng bất kỳ ngôn ngữ nào bạn thích, nhưng chúng tôi sẽ quan tâm để xem các giải pháp trong các ngôn ngữ này đặc biệt

code-golf generation

— James Webster
nguồn

5

Về những thách thức đa phần. Thật không may, tôi không có một giải pháp tốt trong trường hợp này, vì ba nhiệm vụ này quá giống nhau nên không hợp lý để chia chúng thành nhiều thử thách. Tôi cũng đã xem xét đề xuất một ngoại lệ cho chính sách đó cho các thách thức đa phần trong đó các nhiệm vụ chỉ là các biến thể nhỏ của cùng một thách thức. (Mặc dù điều đó vẫn có vấn đề là các giải pháp phụ có thể được lấy từ các câu trả lời khác.) Vì vậy, tôi sẽ không sửa đổi điều này và xem cộng đồng nghĩ gì.

— Martin Ender

"Điểm của bạn là tổng số byte ..." vì vậy ví dụ đầu tiên của tôi là không may. Tôi sẽ sửa đổi thành một ví dụ tiềm năng khác

— James Webster

2

@MartinEnder 2 xu của tôi: Tôi nghĩ rằng nó ổn và sẽ không VTC. Chắc chắn, tôi thường nghĩ rằng một thử thách với một nhiệm vụ thú vị duy nhất là tốt hơn, nhưng vì các nhiệm vụ này rất giống nhau, nó tốt hơn nhiều so với "sân golf" có nội dung "thực hiện 8 nhiệm vụ không liên quan ngẫu nhiên này". Mặc dù không có sự tương tác giữa các nhiệm vụ, nhưng trong mắt tôi, thử thách này không khác lắm so với nói Golf tất cả 16 cổng logic .

— DJMcMayhem

Có bất kỳ giới hạn thời gian hoặc bộ nhớ? Các nhiệm vụ phải độc lập hay chúng được phép chia sẻ mã?

— Dennis

2

Liệu "tạo một chuỗi" có nghĩa là mã phải thực sự tạo ra một giá trị chuỗi với các ký tự phù hợp trong đó, hoặc xuất ra sáu ký tự (không được phân tách bằng dấu cách hoặc dòng mới) có thể chấp nhận được không?

— DLosc

6

Thạch , 38 byte

TryItOnline liên kết Một , B , và C .

A :ABC123!@£POI098, 22 byte

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

(suy nghĩ về việc nén để giảm bớt cái này)

B :0123456789ABCDE, 8 byte:

ØHṖWẋ6X€

C :123456789ABCDEF(lựa chọn), 8 byte:

ØHḊWẋ6X€

Làm sao?

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

— Jonathan Allan
nguồn

8

CJam (23 + 14 + 10 = 47 byte)

Bảng chữ cái tùy ý: 23 byte ( bản demo trực tuyến )

{"ABC123!@TPOI098"mR}6*

Bảng chữ cái thập lục phân: 14 byte ( bản demo trực tuyến )

{FmrAbHb'0+}6*

Bảng chữ cái tùy chỉnh : ABCDEFGHIJKLMNO, 10 byte ( bản demo trực tuyến )

{Fmr'A+}6*

Mổ xẻ

Cái thập lục phân là cái thú vị:

{      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

Sáu ký tự được để lại trên ngăn xếp và được in tự động.

— Peter Taylor
nguồn

2

AbHblà rực rỡ. Tôi nghĩ về cách tiếp cận chung đó nhưng _9>7*+quá dài.

— Martin Ender

6

Perl, 46 + 26 + 26 = 98 byte

Rất nhiều khoản tín dụng được gửi tới @Dom Hastings để tiết kiệm 13 byte!

3 chương trình này khá giống nhau, ngoại trừ bảng chữ cái thay đổi.

Bảng chữ cái mã hóa cứng ( ABC123!@)POI098trong ví dụ này) -> 46 byte:

say map{substr"ABC123!@)POI098",15*rand,1}1..6
Đã sửa bảng chữ cái 0123456789ABCDE-> 26 byte:

printf"%X",rand 15for 1..6
Bảng chữ cái tùy chỉnh 0123456789ABCDEtrong trường hợp đó -> 26 byte:

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

Bạn có thể đặt tất cả chúng trong một tệp để chạy chúng:

$ 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 "";chỉ ở đây để cải thiện định dạng đầu ra)

— Dada
nguồn

2

Câu trả lời tốt! Tôi đã có khá nhiều tương tự cho lần đầu tiên và cuối cùng, nhưng bạn có thể lưu một byte bằng cách sử dụng say: say map{("ABC123!@)POI098"=~/./g)[rand 15]}1..6và say map{(A..O)[rand 15]}1..6. Lần thứ hai bạn có thể sử dụng printf: printf"%X",rand 15for 1..6để tiết kiệm 11 trên tất cả! Tôi chắc rằng Ton có thể khuyên về một số phép thuật phức tạp để tiết kiệm nhiều hơn nữa!

— Dom Hastings

1

Trên thực tế với bảng chữ cái tùy chỉnh substrtiết kiệm khác:say map{substr"ABC123!@)POI098",15*rand,1}1..6

— Dom Hastings

1

@DomHastings Hmm, thật tuyệt, chơi hay đấy! Cảm ơn :-)

— Dada

2

Tôi thích rằng bạn đã xóa ghi chú về mã đơn giản: D

— Dom Hastings

@DomHastings với printf"%X", substr..randvà map, nó chỉ là một chút ít rõ ràng, vì vậy tôi cho phép mọi người thưởng thức ma thuật perl mà không có spoilers! : D

— Dada

4

R, 33 + 43 + 59 = 135 byte

Bảng chữ cái mã hóa cứng tùy ý (thay đổi chuỗi để thay đổi bảng chữ cái):

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

Bảng chữ cái của [0-9A-E]:

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

Bảng chữ cái do người dùng định nghĩa từ stdin:

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

Tất cả các trường hợp in từ đầu ra đến thiết bị xuất chuẩn.

— rturnbull
nguồn

4

JavaScript (ES6), 167 166 164 163 byte

Đã lưu 1 byte nhờ Neil
Lưu 2 byte nhờ ETHproductions
Lưu 1 byte nhờ premek.v

Mã hóa cứng: "ABC123!@TPOI098" (58 byte)

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

Đã sửa lỗi: "0123456789ABCDE" ( 58 57 byte)

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

Tùy chỉnh: "()+.1=>?M[afhnt" ( 51 49 48 byte)

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

— Arnauld
nguồn

1

(n=6)=>n?f(n-1)+("ABCDE"[n=Math.random()*15|0]||n-5):''giúp bạn tiết kiệm một byte.

— Neil

1/8+Mathlà tuyệt vời :)

— Sản phẩm ETH

Nhưng .1+JSONtốt hơn;)

— ETHproductions

1

Hoặc JSON+f( [object JSON](n=> " (JNOS[]bcejnot")

— Sản phẩm điện tử

@ETHproductions Đẹp một. :)

— Arnauld

3

JavaScript (ES6), 184 byte

Bảng chữ cái tùy chỉnh: 66 byte

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

0-9A-E: 63 byte

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

0-9a-e: 55 byte

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

(Trừ 6 byte nếu tính ngẫu nhiên dựa trên ngày được cho phép.)

— Neil
nguồn

Bạn có thể lưu một byte trên cái cuối cùng với **:_=>((Math.random()+1)*15**6|0).toString(15).slice(1)

— ETHproductions

@ETHproductions Chắc chắn điều đó sẽ biến nó thành ES7 chứ không phải ES6? (Ngoài ra, nó trông giống như tiết kiệm 3 byte đối với tôi.)

— Neil

Có, và nó xuất hiện để lưu 3 byte. Tôi phải bao gồm số f=byte

— ETHproductions

3

q, 42 byte

Một

19 byte

6?"ABC123!@TPOI098"

B

14 byte

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

C

9 byte

6?15#.Q.a

(sử dụng mười lăm chữ cái đầu tiên của bảng chữ cái)

— hoài nghi
nguồn

3

Julia (36 + 26 + 21 = 83)

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

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

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

— Lyndon trắng
nguồn

2

CJam, 48 byte

Bảng chữ cái tùy ý, 23 byte:

{"ABC123!@TPOI098"mR}6*

Hãy thử trực tuyến!

Chữ số hex, 15 byte:

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

Hãy thử trực tuyến!

Bảng chữ cái ABCDEFGHIJKLMNO, 10 byte:

{Fmr'A+}6*

Hãy thử trực tuyến!

— Martin Ender
nguồn

Tôi đã có một ý tưởng tồi. Nếu chúng tôi coi U + FFFE là một ký tự, ~cthay vì 'A+trả về một cái gì đó có thể in kỹ thuật.

— jimmy23013

Có lẽ tôi sai. Tôi không tìm thấy định nghĩa về các ký tự Unicode có thể in được.

— jimmy23013

2

Hồng ngọc 47 + 37 + 31 = 115

Mã hóa cứng: "ABC123! @ TPOI098" (47)

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

Đã sửa lỗi: "0123456789ABCDE" (37)

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

Tùy chỉnh: "ABCDEFGHIJKLMNO" (31)

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

— Michael Kohl
nguồn

1

05AB1E , 43 byte

Bảng chữ cái Arbitratry ( ABC123!@TPOI098), 23 byte Hãy thử trực tuyến

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

Bảng chữ cái gần như thập lục phân ( 0123456789ABCDE), 10 byte Hãy thử trực tuyến

14Ýh6F.r¬?

Bảng chữ cái tùy chỉnh ( abcdefghijklmno), 10 byte Hãy thử trực tuyến

A15£6F.r¬?

— Biểu tượng
nguồn

1

Python 2, 70 + 70 + 64 = 204 byte

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

Thật không may, ví dụ thứ hai dễ dàng hơn với phương thức đầu tiên hơn là một cái gì đó như choice([randint(48,57)),choice(65,69)])

— Karl Napf
nguồn

Tại sao bạn sử dụng from random import*? Tôi nghĩ bạn có thể sử dụng import randomvà random.choiceít nhất là trong hai ví dụ đầu tiên.

— Roman Gräf

import random random.choicelà 27 nhưng from random import* choicelà 26, cũng import random as r r.choicelà 27

— Karl Napf

Đối với trường hợp hex, chúng tôi có thể làm tốt hơn một chút bằng cách sử dụng format(randrange(8**8),'X'), tôi nghĩ vậy.

— DSM

@DSM vấn đề là, phải không cóF

— Karl Napf

1

Vitsy, 27 + 24 22 + 13 10 = 64 62 59 byte

# 1:

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

Hãy thử trực tuyến!

# 2:

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

Hãy thử trực tuyến!

# 3:

6\[eR5F-O]

Trường hợp các ký tự có sẵn là:

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

Hãy thử trực tuyến!

— Addison Crump
nguồn

1

J, 24 + 24 + 18 10 = 58 byte

8 byte lưu nhờ dặm!

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

Vâng, chuỗi thứ hai không dễ nén trong J:

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

Nếu một bảng chữ cái hex chữ thường là tốt, thì có ,hfd?6#159 byte, như @miles đã lưu ý.

Nhưng dù sao, ?6#15là 6 số ngẫu nhiên trong khoảng từ 0 đến 15; {~là lấy từ. u:chuyển đổi số thành ký tự. Ví dụ cuối cùng mã hóa ABCDEFGHIJKLMNOP.

Tiền thưởng: trường hợp chung

{~6?@##

{~6?@## đại khái là:

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

— Conor O'Brien
nguồn

Trong trường hợp thứ hai, có một nội dung có tên hfdchuyển đổi thành h ex f rom d ecimal. Bạn có thể nhận được một giải pháp 9 byte bằng cách sử dụng ,hfd?6#15. Trường hợp cuối cùng, chỉ để có một cái gì đó dễ dàng đọc, sử dụng bảng chữ cái từ 'A'một giải pháp 10 byte u:65+?6#15, làm tổng cộng 24 + 9 + 10 = 45.

— dặm

@miles Tôi nghĩ trường hợp thứ hai yêu cầu viết hoa. Đối với trường hợp cuối cùng ... haha, ôi. Tôi hoàn toàn quên mất việc bổ sung véc tơ.

— Conor O'Brien

1

PHP, 46 + 36 + 35 = 117 byte

Mã hóa cứng (46 byte)

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

~~(47 byte)~~

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

Hệ thập lục phân (chữ thường) (36 byte)

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

Đối với chữ hoa, 46 byte với phiên bản Hardcoding.

Tùy chỉnh (AO) (35 byte)

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

— Tiền điện tử
nguồn

Tôi không nghĩ rằng tôi có thể chấp nhận phần 2 của bạn. ae không giống như AE

— James Webster

0

Scala, 154 byte

Bảng chữ cái mã hóa cứng (54 byte):

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

Bảng chữ cái hex (54 byte):

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

Bảng chữ cái tùy chỉnh ABCDEFGHIJKLMNO(47 byte):

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

Giải trình:

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' tạo một chuỗi gồm 15 ký tự, từ A đến O

— xác chết_192
nguồn

0

Pip , 42 byte

Bảng chữ cái mã hóa cứng, 22 byte:

L6ORC"ABC123!@TPOI098"

Các chữ số hex, 11 byte:

L6ORR15TB16

15 chữ cái viết thường đầu tiên, 9 byte:

L6Oz@RR15

Giải trình

Tất cả ba chương trình bắt đầu với L6O: lặp 6 lần và xuất biểu thức đã cho.

RC"...": Lựa chọn ngẫu nhiên một ký tự từ chuỗi mã hóa cứng
RR15TB16: RandRange (15), được chuyển đổi thành Cơ sở 16
z@RR15: bảng chữ cái viết thường z, được lập chỉ mục với RandRange (15)

Hãy thử trực tuyến!

— DLosc
nguồn

0

Skript / skQuery , 108 byte

Mã hóa cứng (43 byte):

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

0123456789ABCDE (34 byte):

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

Lựa chọn (31 byte):

random 6 char string from `A-M`

— Oliver Ni
nguồn

Bạn có thể di chuyển mở `sang bên trái?

— Addison Crump

@VTCAKAVSMoACE Không, nó không cho phép bạn

— Oliver Ni

0

Jolf, 26 + 14 + 13 = 51 byte

Μ*S6d rG"ABC123!@TPOI098"E

Bảng chữ cái tùy chỉnh, 24 byte. Hãy thử nó ở đây!

Μ*S6d r lp^0wά

Bảng chữ cái 0-9A-E, 14 byte. Hãy thử nó ở đây! lp^0wάlà lp(0-Z) được cắt ( l) từ 0đến 15( wά).

Μ*S6d r lp^1ά

Bảng chữ cái 1-9A-F, 13 byte. Hãy thử nó ở đây! lp^1άlà giống như trên, ngoại trừ từ 1đến 16.

Phương pháp chung:

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

Các lần thử khác (sử dụng nén chuỗi):

Μ*S6d rGμpwΞ $AE

— Conor O'Brien
nguồn

0

PowerShell v2 +, 45 + 44 + 37 = 126 byte

Bảng chữ cái cố định, 45 byte

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

Bảng chữ cái gần như thập lục phân, 44 byte

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

Bảng chữ cái tùy chỉnh (A đến O), 37 byte

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

Tất cả đều theo cùng một mẫu - lặp từ 0đến 5, mỗi lần lặp chọn một Randomký tự hoặc giá trị ASCII, chuyển nó thành một char-array nếu cần thiết và -joinghép nó thành một chuỗi. Chuỗi đó được để lại trên đường ống và đầu ra là ẩn.

Ví dụ

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

— AdBorkBork
nguồn

-1

Pyke, 35 byte

Bảng chữ cái tùy ý, 20 byte

6V"ABC123!@TPOI098"H

Hãy thử nó ở đây!

Bảng chữ cái hex, 8 byte

6V~J15<H

Hãy thử nó ở đây!

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

Bảng chữ cái tùy chỉnh, 7 byte

6VG15<H

Hãy thử nó ở đây!

G15< - alphabet[:15]

Bảng chữ cái được chọn: abcdefghijklmno

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

— Màu xanh da trời
nguồn

Điều này dường như xuất ra 6 ký tự được phân tách bằng dòng mới thay vì chuỗi 6 ký tự.

— Emigna

Câu hỏi không nêu định dạng đầu ra.

— Màu xanh

Tôi thấy các từ Tạo chuỗi 6 ký tự ở 4 vị trí trong đặc tả.

— Emigna

Tạo chuỗi 6 ký tự từ bảng chữ cái 15 ký tự

Thạch , 38 byte

Làm sao?

CJam (23 + 14 + 10 = 47 byte)

Mổ xẻ

Perl, 46 + 26 + 26 = 98 byte

R, 33 + 43 + 59 = 135 byte

JavaScript (ES6), 167 166 164 163 byte

JavaScript (ES6), 184 byte

q, 42 byte

Julia (36 + 26 + 21 = 83)

CJam, 48 byte

05AB1E , 43 byte

Python 2, 70 + 70 + 64 = 204 byte

Vitsy, 27 + 24 22 + 13 10 = 64 62 59 byte

J, 24 + 24 + 18 10 = 58 byte

Tiền thưởng: trường hợp chung

PHP, 46 + 36 + 35 = 117 byte

Mã hóa cứng (46 byte)

Hệ thập lục phân (chữ thường) (36 byte)

Tùy chỉnh (AO) (35 byte)

Scala, 154 byte

Pip , 42 byte

Giải trình

Skript / skQuery , 108 byte

Jolf, 26 + 14 + 13 = 51 byte

PowerShell v2 +, 45 + 44 + 37 = 126 byte

Ví dụ

Pyke, 35 byte

Bảng chữ cái tùy ý, 20 byte

Bảng chữ cái hex, 8 byte

Bảng chữ cái tùy chỉnh, 7 byte