Gere uma sequência de 6 caracteres a partir de um alfabeto de 15 caracteres

17

Em um de nossos projetos em andamento, recentemente descobrimos um método particularmente grande para gerar uma sequência de 6 caracteres a partir de um alfabeto de 15 caracteres. Alguns de nós alegaram "eu aposto que podemos colocar isso em uma linha", que iniciou um pequeno jogo interno de código de golfe.

Sua tarefa é nos vencer, o que, sem dúvida, não vai demorar!

O algoritmo original usava o alfabeto 0-9A-E, mas experimentamos outros alfabetos. Existem, portanto, três subtarefas.

  1. Gere uma 6sequência de caracteres selecionando aleatoriamente a partir de um 15alfabeto arbitrário de caracteres codificados como ABC123!@TPOI098. (Este é apenas um exemplo e deve ser personalizável sem afetar a contagem de bytes.)
  2. Gere uma 6sequência de caracteres selecionando aleatoriamente a partir de um 15alfabeto de caracteres 0123456789ABCDE.
  3. Gere uma 6sequência de caracteres selecionando aleatoriamente a partir de um 15alfabeto de caracteres de sua escolha (somente caracteres imprimíveis).

Cada personagem deve ter chances iguais de seleção e repetição deve ser possível.

O melhor que conseguimos gerenciar para cada uma das subtarefas é:

  • "ABC123! @ TPOI098" - 24 bytes
  • "0123456789ABCDE" - 21 bytes
  • Alfabeto personalizado - 13 bytes

Sua pontuação é a soma dos bytes na solução de cada subtarefa. ou seja, nossa pontuação é atualmente 58.

Tentamos usar, entre outros, CJam e Ruby. O original estava em c #. Use qualquer idioma que você quiser, mas estaremos interessados ​​em ver soluções nesses idiomas, particularmente

code-golf generation James Webster
fonte
5
Em relação aos desafios de várias partes. Infelizmente, não tenho uma boa solução nesse caso, pois essas três subtarefas são muito semelhantes para fazer sentido dividi-las em vários desafios. Também estive pensando em propor uma exceção a essa política para desafios com várias partes em que as subtarefas são apenas pequenas variações do mesmo desafio. (Embora isso ainda tenha o problema de que sub-soluções podem ser extraídas de outras respostas.) Portanto, não modificarei isso e ver o que a comunidade pensa.
Martin Ender
"Sua pontuação é a soma dos bytes ...", então meu primeiro exemplo é lamentável. Vou alterar para outro exemplo em potencial
James Webster
2
@ MartinEnder Meus 2 centavos: Eu acho que está tudo bem e não vai VTC. Claro, geralmente acho que um desafio com uma única tarefa interessante é melhor, mas como essas tarefas são muito semelhantes, é muito melhor do que um "campo de golfe" que diz "faça essas 8 tarefas aleatórias e não relacionadas". Embora não exista interação entre tarefas, aos meus olhos esse desafio não é muito diferente do que dizer Golf todos os 16 portões lógicos .
DJMcMayhem
Existem limites de tempo ou memória? As subtarefas precisam ser independentes ou têm permissão para compartilhar código?
Dennis
2
"Gerar uma string" significa que o código precisa realmente gerar um valor de string com os caracteres apropriados ou a saída dos seis caracteres (não separados por espaço ou novas linhas) é aceitável?
DLosc

Respostas:

6

Gelatina , 38 bytes

TryItOnline liga A , B , e C .

R :ABC123!@£POI09822 bytes

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

(pensando em uma compressão para diminuir esta)

B :0123456789ABCDE8 bytes:

ØHṖWẋ6X€

C :123456789ABCDEF(escolha), 8 bytes:

ØHḊWẋ6X€

Quão?

...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
fonte
8

CJam (23 + 14 + 10 = 47 bytes)

Alfabeto arbitrário: 23 bytes ( demonstração online )

{"ABC123!@TPOI098"mR}6*

Alfabeto hexadecimal: 14 bytes ( demonstração online )

{FmrAbHb'0+}6*

Alfabeto personalizado:, ABCDEFGHIJKLMNO10 bytes ( demonstração online )

{Fmr'A+}6*

Dissecação

O hexadecimal é o interessante:

{      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

Os seis caracteres são deixados na pilha e impressos automaticamente.

Peter Taylor
fonte
2
AbHbé brilhante. Eu pensei sobre essa abordagem geral, mas _9>7*+foi muito longo.
Martin Ender
6

Perl, 46 + 26 + 26 = 98 bytes

Muito do crédito vai para @Dom Hastings por economizar 13 bytes!

Os 3 programas são praticamente idênticos, exceto pelo alfabeto que muda.

  • Alfabeto codificado ( ABC123!@)POI098neste exemplo) -> 46 bytes:

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

  • Alfabeto fixo 0123456789ABCDE-> 26 bytes:

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

  • Alfabeto personalizado 0123456789ABCDEnesse caso -> 26 bytes:

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

Você pode colocá-los todos em um arquivo para executá-los:

$ 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 "";estão aqui apenas para melhorar o formato de saída)

dada
fonte
2
Boas respostas! Eu tinha praticamente o mesmo para o primeiro e o último, mas você pode salvar um byte usando say: say map{("ABC123!@)POI098"=~/./g)[rand 15]}1..6e say map{(A..O)[rand 15]}1..6. Para o segundo você pode usar printf: printf"%X",rand 15for 1..6economizar 11 no total! Tenho certeza que Ton também pode aconselhar sobre alguma magia arcana para economizar mais!
Dom Hastings
11
Na verdade, com o alfabeto personalizado, substrsalva outro:say map{substr"ABC123!@)POI098",15*rand,1}1..6
Dom Hastings
11
@DomHastings Hmm, de fato, isso é legal, bem jogado! Obrigado :-)
Dada
2
Gosto que você tenha removido a observação sobre o código ser direto: D
Dom Hastings
@DomHastings com printf"%X", substr..rande map, é apenas um pouco menos óbvio, então eu deixo as pessoas aproveitarem a magia perl sem spoilers! : D
Dada
4

R, 33 + 43 + 59 = 135 bytes

Alfabeto codificado arbitrário (altere a string para alterar o alfabeto): 

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

Alfabeto de [0-9A-E]:

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

Alfabeto definido pelo usuário de stdin:

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

Todos os casos imprimem a palavra de saída em stdout.

rturnbull
fonte
4

JavaScript (ES6), 167 166 164 163 bytes

Guardado 1 byte graças a Neil
Salvo 2 bytes graças a ETHproductions
Salvo 1 byte graças a premek.v

Codificado: "ABC123!@TPOI098" (58 bytes)

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

Fixo: "0123456789ABCDE" ( 58 57 bytes)

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

Personalizado: "()+.1=>?M[afhnt" ( 51 49 48 bytes)

f=(n=6)=>n?(f+1)[Math.random()*15|0+5]+f(n-1):''
Arnauld
fonte
11
(n=6)=>n?f(n-1)+("ABCDE"[n=Math.random()*15|0]||n-5):''economiza um byte.
Neil
1/8+Mathé ótimo :)
ETHproductions 16/16
Mas .1+JSONé melhor;)
ETHproductions 16/16
11
Ou JSON+f( [object JSON](n=> " (JNOS[]bcejnot")
ETHproductions
@ETHproductions Nice one. :)
Arnauld
3

JavaScript (ES6), 184 bytes

Alfabeto personalizado: 66 bytes

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

0-9A-E: 63 bytes

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

0-9a-e: 55 bytes

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

(Subtraia 6 bytes se a aleatoriedade com base na data for permitida.)

Neil
fonte
Você pode salvar um byte no último com **:_=>((Math.random()+1)*15**6|0).toString(15).slice(1)
ETHproductions
@ETHproductions Certamente isso tornaria o ES7, e não o ES6? (Além disso, parece que uma poupança de 3 bytes para mim.)
Neil
Sim, e parece salvar 3 bytes. Eu devo ter incluído o f=na contagem de bytes
ETHproductions
3

q, 42 bytes

UMA

19 bytes

6?"ABC123!@TPOI098"

B

14 bytes

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

C

9 bytes

6?15#.Q.a

(usa as primeiras quinze letras do alfabeto)

skeevey
fonte
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
fonte
2

CJam, 48 bytes

Alfabeto arbitrário, 23 bytes:

{"ABC123!@TPOI098"mR}6*

Experimente online!

Dígitos hexadecimais, 15 bytes:

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

Experimente online!

Alfabeto ABCDEFGHIJKLMNO, 10 bytes:

{Fmr'A+}6*

Experimente online!

Martin Ender
fonte
Eu tive uma má ideia. Se considerarmos U + FFFE um caractere, em ~cvez de 'A+retornar algo tecnicamente imprimível.
jimmy23013
Talvez eu esteja errado. Não encontrei uma definição de caracteres Unicode imprimíveis.
jimmy23013
2

Ruby 47 + 37 + 31 = 115

Codificado permanentemente: "ABC123! @ TPOI098" (47)

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

Corrigido: "0123456789ABCDE" (37)

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

Costume: "ABCDEFGHIJKLMNO" (31)

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

Python 2, 70 + 70 + 64 = 204 bytes

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

Infelizmente, o segundo exemplo é mais fácil com o primeiro método do que algo como choice([randint(48,57)),choice(65,69)])

Karl Napf
fonte
Por que você usa from random import*? Eu acho que você pode usar import randome random.choicepelo menos nos dois primeiros exemplos.
Roman Gräf 15/10
import random random.choiceé 27, mas from random import* choiceé 26, também import random as r r.choiceé 27
Karl Napf
Para o caso hexadecimal, podemos fazer um pouco melhor usando format(randrange(8**8),'X'), eu acho.
DSM
@DSM o problema é que não existe deve serF
Karl Napf
1

J, 24 + 24 + 18 10 = 58 bytes

8 bytes economizados graças às milhas!

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

Sim, a segunda string não é facilmente compactável em J:

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

Se um alfabeto hexadecimal em letras minúsculas estiver bom, haverá ,hfd?6#159 bytes, como observou @miles.

De qualquer forma, ?6#15são 6 números aleatórios entre 0 e 15; {~é retirada. u:converte números em caracteres. O último exemplo codificaABCDEFGHIJKLMNOP .

Bônus: caso geral

{~6?@##

{~6?@## é aproximadamente:

{~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
fonte
No segundo caso, há um embutido chamado hfdque se converte em h ex f rom d ecimal. Você pode obter uma solução de 9 bytes usando ,hfd?6#15. O último caso, apenas para ter algo ler facilmente, usa o alfabeto a partir 'A'de uma solução de 10 byte u:65+?6#15, perfazendo um total de 24 + 9 + 10 = 45.
milhas
@ milhas Eu acho que o segundo caso requer letras maiúsculas. Quanto ao último caso ... haha, oops. Eu esqueci completamente da adição vetorizada.
Conor O'Brien
1

PHP, 46 + 36 + 35 = 117 bytes

Codificado (46 bytes)

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

(47 bytes)

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

Hexadecimal (minúscula) (36 bytes)

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

Para maiúsculas, 46 bytes com a versão codificada.

Personalizado (AO) (35 bytes)

for(;$k++<6;)echo chr(rand(65,79));
Crypto
fonte
Acho que não posso aceitar sua segunda parte. ae não é o mesmo que AE
James Webster
0

Scala, 154 bytes

Alfabeto codificado (54 bytes):

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

Alfabeto hexadecimal (54 bytes):

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

Alfabeto personalizado ABCDEFGHIJKLMNO(47 bytes):

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

Explicação:

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' cria uma sequência de 15 caracteres, de A a O

corvus_192
fonte
0

Pip , 42 bytes

Alfabeto codificado, 22 bytes:

L6ORC"ABC123!@TPOI098"

Dígitos hexadecimais, 11 bytes:

L6ORR15TB16

Primeiras 15 letras minúsculas, 9 bytes:

L6Oz@RR15

Explicação

Todos os três programas começam com L6O: loop 6 vezes e produz a expressão especificada.

  • RC"...": Escolha aleatória de um caractere da sequência codificada
  • RR15TB16: RandRange (15), convertido em Base 16
  • z@RR15: alfabeto em minúsculas z, indexado com RandRange (15)

Experimente online!

DLosc
fonte
0

Skript / skQuery , 108 bytes

Codificado (43 bytes):

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

0123456789ABCDE (34 bytes):

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

Escolha (31 bytes):

random 6 char string from `A-M`
Oliver Ni
fonte
Você pode mover a abertura `para a esquerda?
Addison Crump #
@VTCAKAVSMoACE Não, isso não permite que você #
Oliver Ni #
0

Jolf, 26 + 14 + 13 = 51 bytes

Μ*S6d rG"ABC123!@TPOI098"E

Alfabeto personalizado, 24 bytes. Experimente aqui!

Μ*S6d r lp^0wά

Alfabeto 0-9A-E, 14 bytes. Experimente aqui! lp^0wάé lp(0-Z) fatiado ( l) de 0até 15( wά).

Μ*S6d r lp^1ά

Alfabeto 1-9A-F, 13 bytes. Experimente aqui! lp^1άé o mesmo que acima, exceto de 1para 16.

Método geral:

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

Outras tentativas (usando compactação de string):

Μ*S6d rGμpwΞ $AE
Conor O'Brien
fonte
0

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

Alfabeto fixo, 45 bytes

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

Alfabeto quase hexadecimal, 44 bytes

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

Alfabeto personalizado (A a O), 37 bytes

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

Todos eles seguem o mesmo padrão - loop de 0para 5, cada iteração selecionando um Randomcaractere ou valor ASCII, lançando-o como uma charmatriz, se necessário, e-join reunindo-o em uma string. Essa sequência é deixada no pipeline e a saída é implícita.

Exemplos

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
fonte
-1

Pyke, 35 bytes

Alfabeto arbitrário, 20 bytes

6V"ABC123!@TPOI098"H

Experimente aqui!

Alfabeto hexadecimal, 8 bytes

6V~J15<H

Experimente aqui!

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

Alfabeto personalizado, 7 bytes

6VG15<H

Experimente aqui!

G15< - alphabet[:15]

Alfabeto escolhido: abcdefghijklmno

6V     - repeat 6 times:
  ...  -   get alphabet
     H -  choose_random(^)
Azul
fonte
Isso parece gerar 6 caracteres separados por nova linha, em vez de uma string de 6 caracteres.
Emigna
A pergunta não indica o formato de saída.
Blue
Vejo as palavras Gerar uma sequência de 6 caracteres em 4 lugares na especificação.
Emigna 17/10