W jednym z naszych projektów w pracy niedawno odkryliśmy szczególnie dużą metodę generowania ciągu 6 znaków z 15 znaków alfabetu. Kilku z nas twierdziło: „Założę się, że możemy uzyskać to w jednej linii”, co rozpoczęło małą wewnętrzną grę w golfa kodowego.

Twoim zadaniem jest pokonanie nas, co bez wątpienia nie potrwa długo!

Oryginalny algorytm używał alfabetu 0-9A-E, ale eksperymentowaliśmy z innymi alfabetami. Istnieją zatem trzy podzadania.

1. Wygeneruj 6ciąg znaków losowo, wybierając dowolny dowolny 15alfabet zakodowany na stałe ABC123!@TPOI098. (To tylko przykład i powinien być dostosowywany bez wpływu na liczbę bajtów).
2. Wygeneruj 6ciąg znaków losowo wybierając z 15alfabetu znaków 0123456789ABCDE.
3. Wygeneruj 6ciąg znaków losowo wybierając z wybranego 15alfabetu znaków (tylko znaki do wydruku).

Każda postać powinna mieć równe szanse wyboru, a powtórzenie powinno być możliwe.

Najlepsze, jakie udało nam się wykonać dla każdego podzadania, to:

• „ABC123! @ TPOI098” - 24 bytes
• „0123456789ABCDE” - 21 bytes
• Alfabet niestandardowy - 13 bytes

Twój wynik to suma bajtów w rozwiązaniu każdego podzadania. tzn. nasz wynik wynosi obecnie 58.

Próbowaliśmy używać między innymi CJam i Ruby. Oryginał był w C #. Używaj dowolnego języka, który ci się podoba, ale będziemy zainteresowani rozwiązaniem w tych językach

Galaretka , 38 bajtów

TryItOnline łączy A , B i C .

Odp . :ABC123!@£POI09822 bajtów

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

(myśląc o kompresji, aby ją zmniejszyć)

B :0123456789ABCDE, 8 bajtów:

ØHṖWẋ6X€

C :123456789ABCDEF(wybór), 8 bajtów:

ØHḊWẋ6X€

W jaki sposób?

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

CJam (23 + 14 + 10 = 47 bajtów)

Dowolny alfabet: 23 bajty ( demo online )

{"ABC123!@TPOI098"mR}6*

Alfabet szesnastkowy: 14 bajtów ( demo online )

{FmrAbHb'0+}6*

Niestandardowy alfabet ABCDEFGHIJKLMNO:, 10 bajtów ( demo online )

{Fmr'A+}6*

Sekcja

Interesujący jest układ szesnastkowy:

{      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

Sześć znaków pozostawia się na stosie i drukuje automatycznie.

Perl, 46 + 26 + 26 = 98 bajtów

Wiele zasługa @Dom Hastings za uratowanie 13 bajtów!

3 programy są prawie identyczne, z wyjątkiem zmieniającego się alfabetu.

• Alfabet zakodowany na stałe ( ABC123!@)POI098w tym przykładzie) -> 46 bajtów:

  say map{substr"ABC123!@)POI098",15*rand,1}1..6

• Naprawiono alfabet 0123456789ABCDE-> 26 bajtów:

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

• 0123456789ABCDEW takim przypadku niestandardowy alfabet -> 26 bajtów:

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

Możesz umieścić je wszystkie w pliku, aby je uruchomić:

$ 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 "";są tutaj, aby poprawić format wyjściowy)

R, 33 + 43 + 59 = 135 bajtów

Arbitralny alfabet na stałe (zmień ciąg, aby zmienić alfabet):

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

Alfabet [0-9A-E]:

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

Alfabet zdefiniowany przez użytkownika od standardowego:

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

Wszystkie przypadki wypisują słowo wyjściowe na standardowe wyjście.

JavaScript (ES6), 167 166 164 163 bajtów

Zapisano 1 bajt dzięki Neilowi
Zapisano 2 bajty dzięki ETHproductions
Zapisano 1 bajt dzięki premek.v

Na stałe: "ABC123!@TPOI098" (58 bajtów)

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

Naprawiono: "0123456789ABCDE" ( 58 57 bajtów)

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

Niestandardowy: "()+.1=>?M[afhnt" ( 51 49 48 bajtów)

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

JavaScript (ES6), 184 bajty

Alfabet niestandardowy: 66 bajtów

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

0–9 A – E: 63 bajty

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

0–9 a – e: 55 bajtów

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

(Odejmij 6 bajtów, jeśli dopuszczalna jest przypadkowość oparta na dacie).

q, 42 bajty

ZA

19 bajtów

6?"ABC123!@TPOI098"

b

14 bajtów

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

do

9 bajtów

6?15#.Q.a

(używa pierwszych piętnastu liter alfabetu)

Julia (36 + 26 + 21 = 83)

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

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

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

CJam, 48 bajtów

Dowolny alfabet, 23 bajty:

{"ABC123!@TPOI098"mR}6*

Wypróbuj online!

Cyfry szesnastkowe, 15 bajtów:

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

Wypróbuj online!

Alfabet ABCDEFGHIJKLMNO, 10 bajtów:

{Fmr'A+}6*

Wypróbuj online!

Rubinowy 47 + 37 + 31 = 115

Na stałe: „ABC123! @ TPOI098” (47)

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

Naprawiono: „0123456789ABCDE” (37)

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

Niestandardowe: „ABCDEFGHIJKLMNO” (31)

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

05AB1E , 43 bajty

Alfabet arbitrażowy ( ABC123!@TPOI098), 23 bajty Wypróbuj online

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

Prawie alfabet szesnastkowy ( 0123456789ABCDE), 10 bajtów Wypróbuj online

14Ýh6F.r¬?

Niestandardowy alfabet ( abcdefghijklmno), 10 bajtów Wypróbuj online

A15£6F.r¬?

Python 2, 70 + 70 + 64 = 204 bajty

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

Niestety drugi przykład jest łatwiejszy przy pierwszej metodzie niż coś podobnego choice([randint(48,57)),choice(65,69)])

Vitsy, 27 + 24 22 + 13 10 = 64 62 59 bajtów

# 1:

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

Wypróbuj online!

# 2:

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

Wypróbuj online!

# 3:

6\[eR5F-O]

Gdzie są dostępne postacie:

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

Wypróbuj online!

J, 24 + 24 + 18 10 = 58 bajtów

8 bajtów zapisanych dzięki milom!

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

Tak, drugi ciąg nie jest łatwo kompresowalny w J:

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

Jeśli alfabet szesnastkowy jest w porządku, oznacza to, że istnieje ,hfd?6#159 bajtów, jak zauważył @miles.

W każdym razie ?6#15jest 6 liczb losowych od 0 do 15; {~jest na wynos.u:konwertuje liczby na znaki. Ostatni przykład kodujeABCDEFGHIJKLMNOP .

Bonus: ogólny przypadek

{~6?@##

{~6?@## jest z grubsza:

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

PHP, 46 + 36 + 35 = 117 bajtów

Na stałe (46 bajtów)

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

(47 bajtów)

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

Szesnastkowy (małe litery) (36 bajtów)

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

Dla wielkich liter 46 bajtów w wersji na stałe.

Niestandardowy (AO) (35 bajtów)

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

Scala, 154 bajtów

Alfabet na stałe (54 bajty):

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

Alfabet szesnastkowy (54 bajty):

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

Alfabet niestandardowy ABCDEFGHIJKLMNO(47 bajtów):

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

Wyjaśnienie:

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' tworzy sekwencję 15 znaków, od A do O

Pypeć , 42 bajty

Alfabet na stałe, 22 bajty:

L6ORC"ABC123!@TPOI098"

Cyfry szesnastkowe, 11 bajtów:

L6ORR15TB16

Pierwsze 15 małych liter, 9 bajtów:

L6Oz@RR15

Wyjaśnienie

Wszystkie trzy programy rozpoczynają się od L6O: zapętlają 6 razy i wyświetlają dane wyrażenie.

• RC"...": Losowy wybór znaku z zakodowanego ciągu
• RR15TB16: RandRange (15), przekonwertowany na bazę 16
• z@RR15: małe litery z, indeksowane RandRange (15)

Wypróbuj online!

Skript / skQuery , 108 bajtów

Na stałe (43 bajty):

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

0123456789ABCDE (34 bajty):

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

Wybór (31 bajtów):

random 6 char string from `A-M`

Jolf, 26 + 14 + 13 = 51 bajtów

Μ*S6d rG"ABC123!@TPOI098"E

Alfabet niestandardowy, 24 bajty. Wypróbuj tutaj!

Μ*S6d r lp^0wά

Alfabet 0-9A-E, 14 bajtów. Wypróbuj tutaj! lp^0wάto lp(0-Z) plastry ( l) od 0do 15( wά).

Μ*S6d r lp^1ά

Alfabet 1-9A-F, 13 bajtów. Wypróbuj tutaj! lp^1άjest taki sam jak powyżej, z wyjątkiem od 1do 16.

Ogólna metoda:

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

Inne próby (przy użyciu kompresji ciągów):

Μ*S6d rGμpwΞ $AE

PowerShell v2 +, 45 + 44 + 37 = 126 bajtów

Naprawiono alfabet, 45 bajtów

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

Alfabet prawie szesnastkowy, 44 bajty

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

Alfabet niestandardowy (od A do O), 37 bajtów

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

Wszystkie mają ten sam wzorzec - pętla od 0do 5, każda iteracja wybiera Randomznak lub wartość ASCII, w charrazie potrzeby rzutuje ją na tablicę i -joinłączy w ciąg. Ten ciąg jest pozostawiony w potoku, a dane wyjściowe są niejawne.

Przykłady

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

Pyke, 35 bajtów

Dowolny alfabet, 20 bajtów

6V"ABC123!@TPOI098"H

Wypróbuj tutaj!

Alfabet szesnastkowy, 8 bajtów

6V~J15<H

Wypróbuj tutaj!

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

Niestandardowy alfabet, 7 bajtów

6VG15<H

Wypróbuj tutaj!

G15< - alphabet[:15]

Wybrany alfabet: abcdefghijklmno

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