Générer une chaîne de 6 caractères à partir d'un alphabet de 15 caractères

17

Dans l'un de nos projets à l'œuvre, nous avons récemment découvert une méthode particulièrement importante pour générer une chaîne de 6 caractères à partir d'un alphabet de 15 caractères. Quelques-uns d'entre nous ont affirmé "Je parie que nous pouvons obtenir cela en une seule ligne", ce qui a commencé un petit jeu interne de code golf.

Votre tâche est de nous battre, ce qui sans doute ne tardera pas!

L'algorithme d'origine utilisait l'alphabet 0-9A-E, mais nous avons expérimenté d'autres alphabets. Il y a donc trois sous-tâches.

  1. Générez une 6chaîne de caractères en sélectionnant de manière aléatoire à partir d'un 15alphabet de caractères codés en dur arbitraire comme ABC123!@TPOI098. (Ceci n'est qu'un exemple et devrait être personnalisable sans affecter le nombre d'octets.)
  2. Générez une 6chaîne de caractères en sélectionnant au hasard dans un 15alphabet de caractères 0123456789ABCDE.
  3. Générez une 6chaîne de caractères en sélectionnant au hasard dans un 15alphabet de caractères de votre choix (caractères imprimables uniquement s'il vous plaît).

Chaque personnage devrait avoir une chance égale de sélection et la répétition devrait être possible.

Le mieux que nous ayons pu gérer pour chacune des sous-tâches est:

  • "ABC123! @ TPOI098" - 24 bytes
  • "0123456789ABCDE" - 21 bytes
  • Alphabet personnalisé - 13 bytes

Votre score est la somme des octets dans la solution de chaque sous-tâche. c'est-à-dire que notre score est actuellement de 58.

Nous avons essayé d'utiliser entre autres CJam et Ruby. L'original était en C #. Utilisez n'importe quelle langue que vous aimez, mais nous serons intéressés de voir des solutions dans ces langues en particulier

code-golf generation James Webster
la source
5
Concernant les défis en plusieurs parties. Malheureusement, je n'ai pas de bonne solution dans ce cas, car ces trois sous-tâches sont beaucoup trop similaires pour qu'il soit logique de les diviser en plusieurs défis. J'ai également envisagé de proposer une exception à cette politique pour les défis en plusieurs parties où les sous-tâches ne sont que des variations mineures du même défi. (Bien que cela pose toujours le problème que des sous-solutions peuvent être tirées d'autres réponses.) Je ne vais donc pas mod-hammer cela, et voir ce que la communauté pense.
Martin Ender
"Votre score est la somme des octets ..." donc mon premier exemple est regrettable. Je vais modifier un autre exemple potentiel
James Webster
2
@MartinEnder Mes 2 cents: Je pense que c'est OK et ne sera pas VTC. Bien sûr, je pense généralement qu'un défi avec une seule tâche intéressante est meilleur, mais puisque ces tâches sont très similaires, c'est beaucoup mieux qu'un "terrain de golf" qui dit "faites ces 8 tâches aléatoires sans rapport". Même s'il n'y a pas d'interaction entre les tâches, à mes yeux, ce défi n'est pas très différent de celui de Golf toutes les 16 portes logiques .
DJMcMayhem
Y a-t-il des limites de temps ou de mémoire? Les sous-tâches doivent-elles être indépendantes ou sont-elles autorisées à partager du code?
Dennis
2
Est-ce que «générer une chaîne» signifie que le code doit réellement générer une valeur de chaîne avec les caractères appropriés, ou est-ce que la sortie des six caractères (non séparés par un espace ou des retours à la ligne) est acceptable?
DLosc

Réponses:

6

Gelée , 38 octets

Liens TryItOnline A , B et C .

A :ABC123!@£POI098, 22 octets

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

(penser à une compression pour diminuer celle-ci)

B :0123456789ABCDE, 8 octets:

ØHṖWẋ6X€

C :123456789ABCDEF(choix), 8 octets:

ØHḊWẋ6X€

Comment?

...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
la source
8

CJam (23 + 14 + 10 = 47 octets)

Alphabet arbitraire: 23 octets ( démo en ligne )

{"ABC123!@TPOI098"mR}6*

Alphabet hexadécimal: 14 octets ( démo en ligne )

{FmrAbHb'0+}6*

Alphabet personnalisé:, ABCDEFGHIJKLMNO10 octets ( démo en ligne )

{Fmr'A+}6*

Dissection

L'héxadécimal est l'intéressant:

{      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

Les six caractères sont laissés sur la pile et imprimés automatiquement.

Peter Taylor
la source
2
AbHbest génial. J'ai pensé à cette approche générale mais _9>7*+c'était trop long.
Martin Ender du
6

Perl, 46 + 26 + 26 = 98 octets

Une grande partie du mérite revient à @Dom Hastings pour avoir économisé 13 octets!

Les 3 programmes sont à peu près identiques, à l'exception de l'alphabet qui change.

  • Alphabet codé en dur ( ABC123!@)POI098dans cet exemple) -> 46 octets:

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

  • Alphabet fixe 0123456789ABCDE-> 26 octets:

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

  • Alphabet personnalisé 0123456789ABCDEdans ce cas -> 26 octets:

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

Vous pouvez les mettre tous dans un fichier pour les exécuter:

$ 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

(les say "";sont juste là pour améliorer le format de sortie)

Dada
la source
2
Bonnes réponses! J'avais à peu près la même chose pour le premier et le dernier, mais vous pouvez enregistrer un octet en utilisant say: say map{("ABC123!@)POI098"=~/./g)[rand 15]}1..6et say map{(A..O)[rand 15]}1..6. Pour la seconde, vous pouvez utiliser printf: printf"%X",rand 15for 1..6pour économiser 11 sur l'ensemble! Je suis sûr que Ton peut vous conseiller sur la magie des arcanes pour économiser plus aussi!
Dom Hastings
1
En fait, avec l'alphabet personnalisé substrenregistre un autre:say map{substr"ABC123!@)POI098",15*rand,1}1..6
Dom Hastings
1
@DomHastings Hmm en effet, c'est sympa, bien joué! Merci :-)
Dada
2
J'aime que vous ayez supprimé la note sur le code étant simple: D
Dom Hastings
@DomHastings avec printf"%X", substr..randet map, c'est juste un peu moins évident, donc je laisse les gens profiter de la magie de perl sans spoilers! : D
Dada
4

R, 33 + 43 + 59 = 135 octets

Alphabet codé en dur arbitraire (changez la chaîne pour changer l'alphabet): 

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

Alphabet de [0-9A-E]:

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

Alphabet défini par l'utilisateur de stdin:

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

Tous les cas impriment le mot de sortie sur stdout.

rturnbull
la source
4

JavaScript (ES6), 167 166 164 163 octets

1 octet enregistré grâce à Neil
2 octets enregistrés grâce à ETHproductions
1 octet enregistré grâce à premek.v

Hardcoded: "ABC123!@TPOI098" (58 octets)

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

Corrigé: "0123456789ABCDE" ( 58 57 octets)

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

Personnalisé: "()+.1=>?M[afhnt" ( 51 49 48 octets)

f=(n=6)=>n?(f+1)[Math.random()*15|0+5]+f(n-1):''
Arnauld
la source
1
(n=6)=>n?f(n-1)+("ABCDE"[n=Math.random()*15|0]||n-5):''vous fait gagner un octet.
Neil
1/8+Mathest génial :)
ETHproductions
Mais .1+JSONc'est mieux;)
ETHproductions
1
Ou JSON+f( [object JSON](n=> " (JNOS[]bcejnot")
ETHproductions
@ETHproductions Nice one. :)
Arnauld
3

JavaScript (ES6), 184 octets

Alphabet personnalisé: 66 octets

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

0-9A-E: 63 octets

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

0-9a-e: 55 octets

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

(Soustrayez 6 octets si le caractère aléatoire basé sur la date est autorisé.)

Neil
la source
Vous pouvez enregistrer un octet sur le dernier avec **:_=>((Math.random()+1)*15**6|0).toString(15).slice(1)
ETHproductions
@ETHproductions Cela ferait sûrement de l'ES7, plutôt que de l'ES6? (De plus, cela ressemble à une économie de 3 octets pour moi.)
Neil
Oui, et il semble économiser 3 octets. Je dois avoir inclus le f=dans le nombre d'octets
ETHproductions
3

q, 42 octets

UNE

19 octets

6?"ABC123!@TPOI098"

B

14 octets

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

C

9 octets

6?15#.Q.a

(utilise les quinze premières lettres de l'alphabet)

skeevey
la source
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
la source
2

CJam, 48 octets

Alphabet arbitraire, 23 octets:

{"ABC123!@TPOI098"mR}6*

Essayez-le en ligne!

Chiffres hexadécimaux, 15 octets:

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

Essayez-le en ligne!

Alphabet ABCDEFGHIJKLMNO, 10 octets:

{Fmr'A+}6*

Essayez-le en ligne!

Martin Ender
la source
J'avais une mauvaise idée. Si nous considérons U + FFFE un caractère, ~cau lieu de 'A+renvoie quelque chose de techniquement imprimable.
jimmy23013
J'ai peut-être tort. Je n'ai pas trouvé de définition des caractères Unicode imprimables.
jimmy23013
2

Rubis 47 + 37 + 31 = 115

Hardcoded: "ABC123! @ TPOI098" (47)

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

Correction: "0123456789ABCDE" (37)

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

Personnalisé: "ABCDEFGHIJKLMNO" (31)

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

Python 2, 70 + 70 + 64 = 204 octets

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

Malheureusement, le deuxième exemple est plus facile avec la première méthode que quelque chose comme choice([randint(48,57)),choice(65,69)])

Karl Napf
la source
Pourquoi utilisez-vous from random import*? Je pense que vous pouvez utiliser import randomet random.choiceau moins dans les deux premiers exemples.
Roman Gräf
import random random.choicea 27 ans mais a from random import* choice26 ans, import random as r r.choice27 ans également
Karl Napf
Pour le cas hexadécimal, nous pouvons faire un peu mieux en utilisant format(randrange(8**8),'X'), je pense.
DSM
@DSM, le problème est qu'il ne doit pas y avoirF
Karl Napf
1

J, 24 + 24 + 18 10 = 58 octets

8 octets économisés grâce aux miles!

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

Oui, la deuxième chaîne n'est pas facilement compressible 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 alphabet hexadécimal en minuscule convient, alors il y en a ,hfd?6#15pour 9 octets, comme l'a noté @miles.

Quoi qu'il en soit, ?6#15est 6 nombres aléatoires entre 0 et 15; {~est à prendre. u:convertit les nombres en caractères. Le dernier exemple codeABCDEFGHIJKLMNOP .

Bonus: cas général

{~6?@##

{~6?@## est à peu près:

{~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
la source
Sur le second cas, il y a un nom builtin hfdqui se transforme en h ex f rom d ecimal. Vous pouvez obtenir une solution de 9 octets en utilisant ,hfd?6#15. Le dernier cas, juste pour avoir quelque chose de facile à lire, utilise l'alphabet de 'A'pour une solution de 10 octets u:65+?6#15, soit un total de 24 + 9 + 10 = 45.
miles
@miles Je pense que le deuxième cas nécessite des lettres majuscules. Quant au dernier cas ... haha, oups. J'ai complètement oublié l'ajout vectorisé.
Conor O'Brien
1

PHP, 46 + 36 + 35 = 117 octets

Hardcoded (46 octets)

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

(47 octets)

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

Hexadécimal (minuscule) (36 octets)

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

Pour les majuscules, 46 octets avec la version codée en dur.

Personnalisé (AO) (35 octets)

for(;$k++<6;)echo chr(rand(65,79));
Crypto
la source
Je ne pense pas pouvoir accepter votre 2e partie. ae n'est pas le même que AE
James Webster
0

Scala, 154 octets

Alphabet codé en dur (54 octets):

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

Alphabet hexadécimal (54 octets):

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

Alphabet personnalisé ABCDEFGHIJKLMNO(47 octets):

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

Explication:

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' crée une séquence de 15 caractères, de A à O

corvus_192
la source
0

Pip , 42 octets

Alphabet codé en dur, 22 octets:

L6ORC"ABC123!@TPOI098"

Chiffres hexadécimaux, 11 octets:

L6ORR15TB16

15 premières lettres minuscules, 9 octets:

L6Oz@RR15

Explication

Les trois programmes commencent par L6O: boucle 6 fois et produisent l'expression donnée.

  • RC"...": Choix aléatoire d'un caractère dans la chaîne codée en dur
  • RR15TB16: RandRange (15), converti en base 16
  • z@RR15: alphabet minuscule z, indexé avec RandRange (15)

Essayez-le en ligne!

DLosc
la source
0

Skript / skQuery , 108 octets

Hardcoded (43 octets):

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

0123456789ABCDE (34 octets):

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

Choix (31 octets):

random 6 char string from `A-M`
Oliver Ni
la source
Pouvez-vous déplacer l'ouverture `vers la gauche?
Addison Crump
@VTCAKAVSMoACE Non, ça ne vous laisse pas
Oliver Ni
0

Jolf, 26 + 14 + 13 = 51 octets

Μ*S6d rG"ABC123!@TPOI098"E

Alphabet personnalisé, 24 octets. Essayez-le ici!

Μ*S6d r lp^0wά

Alphabet 0-9A-E, 14 octets. Essayez-le ici! lp^0wάest lp(0-Z) tranché ( l) de 0à 15(wά ).

Μ*S6d r lp^1ά

Alphabet 1-9A-F, 13 octets. Essayez-le ici! lp^1άest le même que ci-dessus, sauf1 à 16.

Méthode générale:

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

Autres tentatives (en utilisant la compression de chaînes):

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

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

Alphabet fixe, 45 octets

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

Alphabet presque hexadécimal, 44 octets

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

Alphabet personnalisé (A à O), 37 octets

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

Tous ces éléments suivent le même modèle - boucle de 0à 5, chaque itération sélectionne un Randomcaractère ou une valeur ASCII, le chartransforme en tableau si nécessaire, et l' -joinintègre ensemble dans une chaîne. Cette chaîne est laissée sur le pipeline et la sortie est implicite.

Exemples

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
la source
-1

Pyke, 35 octets

Alphabet arbitraire, 20 octets

6V"ABC123!@TPOI098"H

Essayez-le ici!

Alphabet hexadécimal, 8 octets

6V~J15<H

Essayez-le ici!

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

Alphabet personnalisé, 7 octets

6VG15<H

Essayez-le ici!

G15< - alphabet[:15]

Alphabet choisi: abcdefghijklmno

6V     - repeat 6 times:
  ...  -   get alphabet
     H -  choose_random(^)
Bleu
la source
Cela semble produire 6 caractères séparés par un saut de ligne au lieu d'une chaîne de 6 caractères.
Emigna
La question ne précise pas le format de sortie.
Blue
Je vois les mots Générer une chaîne de 6 caractères à 4 endroits dans la spécification.
Emigna