En uno de nuestros proyectos en el trabajo, recientemente descubrimos un método particularmente grande para generar una cadena de 6 caracteres a partir de un alfabeto de 15 caracteres. Algunos de nosotros afirmamos "Apuesto a que podemos poner eso en una línea", que comenzó un pequeño juego interno de golf de código.

¡Tu tarea es vencernos, lo que sin duda no tardará!

El algoritmo original usaba el alfabeto 0-9A-E, pero hemos experimentado con otros alfabetos. Por lo tanto, hay tres subtareas.

1. Genere una 6cadena de caracteres seleccionando aleatoriamente de un 15alfabeto de caracteres codificados arbitrariamente comoABC123!@TPOI098 . (Esto es solo un ejemplo, y debe ser personalizable sin afectar el recuento de bytes).
2. Genere una 6cadena de caracteres seleccionando aleatoriamente de un 15alfabeto de caracteres0123456789ABCDE .
3. Genere una 6cadena de caracteres seleccionando al azar del 15alfabeto de caracteres que elija (solo caracteres imprimibles, por favor).

Cada personaje debe tener la misma posibilidad de selección y la repetición debe ser posible.

Lo mejor que hemos podido administrar para cada una de las subtareas es:

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

Su puntaje es la suma de los bytes en la solución de cada subtarea. es decir, nuestro puntaje es actualmente 58.

Intentamos usar, entre otros, CJam y Ruby. El original estaba en C #. Use cualquier idioma que desee, pero nos interesará ver soluciones en estos idiomas particularmente

Jalea , 38 bytes

TryItOnline une A , B , y C .

A :ABC123!@£POI09822 bytes

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

(pensando en una compresión para disminuir esta)

B :0123456789ABCDE8 bytes:

ØHṖWẋ6X€

C :123456789ABCDEF(opción), 8 bytes:

ØHḊWẋ6X€

¿Cómo?

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

Alfabeto arbitrario: 23 bytes ( demostración en línea )

{"ABC123!@TPOI098"mR}6*

Alfabeto hexadecimal: 14 bytes ( demostración en línea )

{FmrAbHb'0+}6*

Alfabeto personalizado: ABCDEFGHIJKLMNO10 bytes ( demostración en línea )

{Fmr'A+}6*

Disección

El hexadecimal es el interesante:

{      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

Los seis caracteres se dejan en la pila y se imprimen automáticamente.

Perl, 46 + 26 + 26 = 98 bytes

¡Gran parte del crédito va a @Dom Hastings por ahorrar 13 bytes!

Los 3 programas son bastante idénticos, excepto por el alfabeto que cambia.

• Alfabeto codificado ( ABC123!@)POI098en este ejemplo) -> 46 bytes:

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

• Alfabeto fijo 0123456789ABCDE-> 26 bytes:

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

• Alfabeto personalizado 0123456789ABCDEen ese caso -> 26 bytes:

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

Puede ponerlos todos en un archivo para ejecutarlos:

$ 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án aquí para mejorar el formato de salida)

R, 33 + 43 + 59 = 135 bytes

Alfabeto codificado arbitrario (cambie la cadena para cambiar el 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 por el usuario de stdin:

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

Todos los casos imprimen la palabra de salida en stdout.

JavaScript (ES6), 167 166 164 163 bytes

Guardado 1 byte gracias a Neil
Guardado 2 bytes gracias a ETHproductions
Guardado 1 byte gracias a premek.v

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

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

Corregido: "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):''

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)

(Reste 6 bytes si la aleatoriedad basada en la fecha es permisible).

q, 42 bytes

UN

19 bytes

6?"ABC123!@TPOI098"

si

14 bytes

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

C

9 bytes

6?15#.Q.a

(usa las primeras quince letras del alfabeto)

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 bytes

Alfabeto arbitrario, 23 bytes:

{"ABC123!@TPOI098"mR}6*

Pruébalo en línea!

Dígitos hexadecimales, 15 bytes:

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

Pruébalo en línea!

Alfabeto ABCDEFGHIJKLMNO, 10 bytes:

{Fmr'A+}6*

Pruébalo en línea!

Rubí 47 + 37 + 31 = 115

Codificado: "ABC123! @ TPOI098" (47)

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

Corregido: "0123456789ABCDE" (37)

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

Personalizado: "ABCDEFGHIJKLMNO" (31)

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

05AB1E , 43 bytes

Alfabeto arbitrario ( ABC123!@TPOI098), 23 bytes Pruébelo en línea

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

Alfabeto casi hexadecimal ( 0123456789ABCDE), 10 bytes Pruébelo en línea

14Ýh6F.r¬?

Alfabeto personalizado ( abcdefghijklmno), 10 bytes Pruébelo en línea

A15£6F.r¬?

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

Desafortunadamente, el segundo ejemplo es más fácil con el primer método que algo como choice([randint(48,57)),choice(65,69)])

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

# 1:

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

Pruébalo en línea!

# 2:

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

Pruébalo en línea!

# 3:

6\[eR5F-O]

Donde están los caracteres disponibles:

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

Pruébalo en línea!

J, 24 + 24 + 18 10 = 58 bytes

¡8 bytes guardados gracias a las millas!

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

Sí, la segunda cadena no es fácilmente comprimible en J:

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

Si un alfabeto hexadecimal en minúscula está bien, entonces hay ,hfd?6#15para 9 bytes, como señaló @miles.

De todos modos, ?6#15son 6 números aleatorios entre 0 y 15; {~es tomar deu:Convierte números en caracteres. El último ejemplo codifica ABCDEFGHIJKLMNOP.

Bonus: caso general

{~6?@##

{~6?@## es más o menos:

{~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 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úsculas) (36 bytes)

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

Para mayúsculas, 46 bytes con versión codificada.

Personalizado (AO) (35 bytes)

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

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

Explicación:

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' crea una secuencia de 15 caracteres, de A a O

Pipa , 42 bytes

Alfabeto codificado, 22 bytes:

L6ORC"ABC123!@TPOI098"

Dígitos hexadecimales, 11 bytes:

L6ORR15TB16

Primeras 15 letras minúsculas, 9 bytes:

L6Oz@RR15

Explicación

Los tres programas comienzan con L6O: bucle 6 veces y generan la expresión dada.

• RC"...": Elección aleatoria de un personaje de la cadena codificada
• RR15TB16: RandRange (15), convertido a Base 16
• z@RR15: alfabeto en minúsculas z, indexado con RandRange (15)

Pruébalo en línea!

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`

Elección (31 bytes):

random 6 char string from `A-M`

Jolf, 26 + 14 + 13 = 51 bytes

Μ*S6d rG"ABC123!@TPOI098"E

Alfabeto personalizado, 24 bytes. Pruébalo aquí!

Μ*S6d r lp^0wά

Alfabeto 0-9A-E, 14 bytes. Pruébalo aquí! lp^0wάes lp(0-Z) cortado ( l) de 0a 15( wά).

Μ*S6d r lp^1ά

Alfabeto 1-9A-F, 13 bytes. Pruébalo aquí! lp^1άes el mismo que el anterior, excepto de 1a 16.

Método general:

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

Otros intentos (usando compresión de cadena):

Μ*S6d rGμpwΞ $AE

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

Alfabeto fijo, 45 bytes

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

Alfabeto casi 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 estos siguen el mismo patrón: bucle de 0a 5, cada iteración selecciona un Randomcarácter o valor ASCII, charconvirtiéndolo en una matriz si es necesario, y uniéndolo -joinen una cadena. Esa cadena se deja en la tubería, y la salida es implícita.

Ejemplos

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 bytes

Alfabeto arbitrario, 20 bytes

6V"ABC123!@TPOI098"H

Pruébalo aquí!

Alfabeto hexadecimal, 8 bytes

6V~J15<H

Pruébalo aquí!

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

Alfabeto personalizado, 7 bytes

6VG15<H

Pruébalo aquí!

G15< - alphabet[:15]

Alfabeto elegido: abcdefghijklmno

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