Wygeneruj ciąg 6 znaków z 15-znakowego alfabetu

17

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

code-golf  generation 
— James Webster
źródło
5
Odnośnie wyzwań wieloczęściowych. Niestety w tym przypadku nie mam dobrego rozwiązania, ponieważ te trzy podzadania są zbyt podobne, aby rozdzielić je na wiele wyzwań. Zastanawiałem się również nad zaproponowaniem wyjątku od tej zasady dla wyzwań wieloczęściowych, w których podzadania są tylko niewielkimi odmianami tego samego wyzwania. (Chociaż nadal istnieje problem polegający na tym, że pod-rozwiązania można wyciągnąć z innych odpowiedzi.) Więc nie będę modyfikować tego i nie zobaczę, co myśli społeczność.
— Martin Ender
„Twój wynik to suma bajtów ...”, więc mój pierwszy przykład jest niefortunny. Zmienię na inny potencjalny przykład
— James Webster,
2
@MartinEnder Moje 2 centy: Myślę, że jest w porządku i nie będzie VTC. Jasne, generalnie uważam, że wyzwanie z jednym interesującym zadaniem jest lepsze, ale ponieważ zadania te są bardzo podobne, jest o wiele lepsze niż „pole golfowe”, które mówi „wykonaj te 8 losowo niepowiązanych zadań”. Mimo że nie ma interakcji między zadaniami, moim zdaniem to wyzwanie nie różni się niczym od powiedzenia golfowi wszystkich 16 bramek logicznych .
— DJMcMayhem
Czy są jakieś limity czasu lub pamięci? Czy podzadania muszą być niezależne, czy mogą współdzielić kod?
— Dennis
2
Czy „generowanie ciągu” oznacza, że ​​kod musi faktycznie wygenerować wartość ciągu z odpowiednimi znakami, czy też jest w stanie wyprowadzić sześć znaków (nie oddzielonych spacją ani znakami nowej linii)?
— DLosc

Odpowiedzi:

6

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)
— Jonathan Allan
źródło
8

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.

— Peter Taylor
źródło
2
AbHbjest genialny. Myślałem o tym ogólnym podejściu, ale _9>7*+było za długo.
— Martin Ender
6

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)

— Dada
źródło
2
Dobre odpowiedzi! Miałem prawie to samo dla pierwszego i ostatniego, ale możesz zapisać bajt, używając say: say map{("ABC123!@)POI098"=~/./g)[rand 15]}1..6i say map{(A..O)[rand 15]}1..6. Po drugie możesz użyć printf: printf"%X",rand 15for 1..6aby zapisać 11 ponad wszystko! Jestem pewien, że Ton może doradzić ci magiczną magię, aby zaoszczędzić więcej!
— Dom Hastings,
1
W rzeczywistości z niestandardowym alfabetem substrzapisuje inny:say map{substr"ABC123!@)POI098",15*rand,1}1..6
— Dom Hastings
1
@DomHastings Hmm, rzeczywiście, to miłe, dobrze zagrane! Dzięki :-)
— Dada,
2
Podoba mi się, że usunąłeś notatkę o prostocie kodu: D
— Dom Hastings,
@DomHastings z printf"%X", substr..randi map, to jest trochę mniej oczywiste, więc pozwalam ludziom cieszyć się perlową magią bez spoilerów! : D
— Dada,
4

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.

— rturnbull
źródło
4

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):''
— Arnauld
źródło
1
(n=6)=>n?f(n-1)+("ABCDE"[n=Math.random()*15|0]||n-5):''oszczędza bajt.
— Neil
1/8+Mathjest świetne :)
— ETHproductions
Ale .1+JSONjest lepiej;)
— ETHprodukcje
1
Lub JSON+f( [object JSON](n=> " (JNOS[]bcejnot")
— ETHprodukcje
@ETHproductions Nice one. :)
— Arnauld
3

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

— Neil
źródło
Możesz zapisać bajt na ostatnim z **:_=>((Math.random()+1)*15**6|0).toString(15).slice(1)
— ETHprodukcje
@ETHproductions Z pewnością sprawiłoby to, że ES7, a nie ES6? (Poza tym wygląda mi to na 3-bajtowe oszczędzanie.)
— Neil
Tak i wydaje się, że zapisuje 3 bajty. Musiałem uwzględnić f=liczbę bajtów
— ETHproductions
3

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)

— skeevey
źródło
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 White
źródło
2

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}*''
— Michael Kohl
źródło
1

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

— Karl Napf
źródło
Dlaczego używacie from random import*? Myślę, że możesz użyć import randomi random.choiceprzynajmniej w pierwszych dwóch przykładach.
— Roman Gräf
import random random.choicema 27 lat, ale from random import* choicema 26 lat, a także import random as r r.choice27
— Karl Napf
Wydaje mi się, że w przypadku heksadecymalnym możemy nieco lepiej, używając format(randrange(8**8),'X').
— DSM
@DSM problem polega na tym, że nie może byćF
— Karl Napf
1

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
— Conor O'Brien
źródło
W drugim przypadku, nie ma wbudowanego nazwany hfdktóry konwertuje do h ex f rom d ecimal. Możesz uzyskać rozwiązanie 9-bajtowe za pomocą ,hfd?6#15. Ostatni przypadek, żeby coś łatwo odczytać, używa alfabetu od 'A'10-bajtowego rozwiązania u:65+?6#15, co daje w sumie 24 + 9 + 10 = 45.
— mil
@miles Myślę, że drugi przypadek wymaga wielkich liter. Co do ostatniego przypadku ... haha, ups. Zupełnie zapomniałem o wektoryzowanym dodawaniu.
— Conor O'Brien
1

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));
— Crypto
źródło
Nie sądzę, że mogę zaakceptować twoją drugą część. ae to nie to samo co AE
— James Webster
0

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

— corvus_192
źródło
0

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!

— DLosc
źródło
0

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`
— Oliver Ni
źródło
Czy możesz przesunąć otwór `w lewo?
— Addison Crump
@VTCAKAVSMoACE Nie, to nie pozwala
— Oliver Ni
0

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
— Conor O'Brien
źródło
0

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
— AdmBorkBork
źródło
-1

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(^)
— niebieski
źródło
Wydaje się, że daje to 6 znaków oddzielonych znakiem nowej linii zamiast ciągu 6 znaków.
— Emigna
Pytanie nie określa formatu wyjściowego.
— Blue
Widzę słowa Wygeneruj ciąg 6 znaków w 4 miejscach w specyfikacji.
— Emigna
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.