Genere una cadena de 6 caracteres a partir de un alfabeto de 15 caracteres

17

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

code-golf  generation 
— James Webster
fuente
55
En cuanto a los desafíos de múltiples partes. Desafortunadamente, no tengo una buena solución en este caso, ya que estas tres subtareas son demasiado similares para que tenga sentido dividirlas en múltiples desafíos. También he estado considerando proponer una excepción a esa política para desafíos de múltiples partes donde las subtareas son solo pequeñas variaciones del mismo desafío. (Aunque eso todavía tiene el problema de que se pueden tomar sub-soluciones de otras respuestas). Por lo tanto, no criticaré esto y veré qué piensa la comunidad.
— Martin Ender
"Tu puntaje es la suma de los bytes ...", así que mi primer ejemplo es desafortunado. Enmendaré otro ejemplo potencial
— James Webster,
2
@ MartinEnder Mis 2 centavos: Creo que está bien y no será VTC. Claro, generalmente creo que un desafío con una sola tarea interesante es mejor, pero dado que estas tareas son muy similares, es mucho mejor que un "campo de golf" que dice "haz estas 8 tareas no relacionadas al azar". A pesar de que no hay interacción entre las tareas, en mi opinión, este desafío no es muy diferente de decir Golf 16 puertas lógicas .
— DJMcMayhem
¿Hay algún límite de tiempo o memoria? ¿Las subtareas tienen que ser independientes o se les permite compartir código?
— Dennis
2
¿"Generar una cadena" significa que el código tiene que generar realmente un valor de cadena con los caracteres apropiados, o que la salida de los seis caracteres (no separados por espacio o líneas nuevas) es aceptable?
— DLosc

Respuestas:

6

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)
— Jonathan Allan
fuente
8

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.

— Peter Taylor
fuente
2
AbHbes brillante Pensé en ese enfoque general, pero _9>7*+fue demasiado largo.
— Martin Ender
6

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)

— Dada
fuente
2
Buenas respuestas! Tenía casi lo mismo para el primero y el último, pero puedes guardar un byte usando say: say map{("ABC123!@)POI098"=~/./g)[rand 15]}1..6y say map{(A..O)[rand 15]}1..6. Por el segundo puede usar printf: ¡ printf"%X",rand 15for 1..6para ahorrar 11 en total! ¡Estoy seguro de que Ton puede aconsejar algo de magia arcana para ahorrar más también!
— Dom Hastings
1
En realidad con el alfabeto personalizado substrguarda otro:say map{substr"ABC123!@)POI098",15*rand,1}1..6
— Dom Hastings
1
@DomHastings Hmm de hecho, eso es bueno, bien jugado! Gracias :-)
— Dada
2
Me gusta que hayas eliminado la nota sobre que el código es sencillo: D
— Dom Hastings
@DomHastings con printf"%X", substr..randy map, es un poco menos obvio, ¡así que dejo que la gente disfrute de la magia perl sin spoilers! : D
— Dada
4

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.

— rturnbull
fuente
4

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):''
— Arnauld
fuente
1
(n=6)=>n?f(n-1)+("ABCDE"[n=Math.random()*15|0]||n-5):''te ahorra un byte.
— Neil
1/8+Mathes genial :)
— ETHproductions
Pero .1+JSONes mejor;)
— ETHproductions
1
O 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)

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

— Neil
fuente
Puede guardar un byte en el último con **:_=>((Math.random()+1)*15**6|0).toString(15).slice(1)
— ETHproductions
@ETHproductions ¿Seguramente eso sería ES7, en lugar de ES6? (Además, me parece un ahorro de 3 bytes.)
— Neil
Sí, y parece guardar 3 bytes. Debo haber incluido el f=en el conteo de bytes
— ETHproductions
3

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)

— skeevey
fuente
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
fuente
2

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!

— Martin Ender
fuente
Tuve una mala idea Si consideramos que U + FFFE es un carácter, en ~clugar de 'A+devolver algo técnicamente imprimible.
— jimmy23013
Puede ser que esté equivocado. No encontré una definición de caracteres Unicode imprimibles.
— jimmy23013
2

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}*''
— Michael Kohl
fuente
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

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

— Karl Napf
fuente
¿Por qué lo usas from random import*? Creo que puedes usar import randomy random.choiceal menos en los dos primeros ejemplos.
— Roman Gräf
import random random.choicees 27, pero from random import* choicees de 26 años, también import random as r r.choicees 27
— Karl Napf
Para el caso hexadecimal, creo que podemos hacerlo un poco mejor usando format(randrange(8**8),'X').
— DSM
@DSM el problema es que no debe haber F
— Karl Napf
1

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
— Conor O'Brien
fuente
En el segundo caso, hay un nombre incorporado hfdque se convierte en h ex f rom d ecimal. Puede obtener una solución de 9 bytes usando ,hfd?6#15. El último caso, solo para tener algo fácil de leer, utiliza el alfabeto de 'A'una solución de 10 bytes u:65+?6#15, lo que hace un total de 24 + 9 + 10 = 45.
— millas
@miles Creo que el segundo caso requiere letras mayúsculas. En cuanto al último caso ... jaja, oops. Olvidé por completo la adición vectorizada.
— Conor O'Brien el
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ú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));
— Cripto
fuente
No creo que pueda aceptar tu segunda parte. ae no es lo mismo 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))

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

— corvus_192
fuente
0

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!

— DLosc
fuente
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`

Elección (31 bytes):

random 6 char string from `A-M`
— Oliver Ni
fuente
¿Puedes mover la abertura `a la izquierda?
— Addison Crump
@VTCAKAVSMoACE No, no te deja
— Oliver Ni
0

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
— Conor O'Brien
fuente
0

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
— AdmBorkBork
fuente
-1

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(^)
— Azul
fuente
Esto parece generar 6 caracteres separados por una nueva línea en lugar de una cadena de 6 caracteres.
— Emigna
La pregunta no indica el formato de salida.
— Azul
Veo las palabras Generar una cadena de 6 caracteres en 4 lugares en la especificación.
— Emigna
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.