17

In uno dei nostri progetti al lavoro, abbiamo recentemente scoperto un metodo particolarmente grande per generare una stringa di 6 caratteri da un alfabeto di 15 caratteri. Alcuni di noi hanno affermato "Scommetto che possiamo ottenerlo in una riga" che ha iniziato un piccolo gioco interno di codice golf.

Il tuo compito è quello di batterci, che senza dubbio non ci vorrà molto!

L'algoritmo originale utilizzava l'alfabeto 0-9A-E, ma abbiamo sperimentato altri alfabeti. Vi sono quindi tre sottoattività.

Genera una 6stringa di caratteri selezionando in modo casuale da un hardcoded arbitraria 15alfabeto personaggio come ABC123!@TPOI098. (Questo è solo un esempio e dovrebbe essere personalizzabile senza influire sul conteggio dei byte.)
Genera una 6stringa di caratteri in modo casuale selezionando da un 15alfabeto di caratteri 0123456789ABCDE.
Genera una 6stringa di caratteri selezionando casualmente da un 15alfabeto di caratteri a tua scelta (solo caratteri stampabili, per favore).

Ogni personaggio dovrebbe avere pari possibilità di selezione e la ripetizione dovrebbe essere possibile.

Il migliore che siamo riusciti a gestire per ciascuna delle attività secondarie è:

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

Il tuo punteggio è la somma dei byte nella soluzione di ogni sottoattività. cioè il nostro punteggio è attualmente 58.

Abbiamo tentato di utilizzare, tra gli altri, CJam e Ruby. L'originale era in C #. Usa qualsiasi lingua che ti piace, ma saremo interessati a vedere soluzioni in queste lingue in particolare

code-golf generation

— James Webster
fonte

5

Per quanto riguarda le sfide in più parti. Sfortunatamente, in questo caso non ho una buona soluzione, dal momento che queste tre attività secondarie sono troppo simili per avere senso dividerle in più sfide. Ho anche considerato di proporre un'eccezione a tale politica per le sfide in più parti in cui le attività secondarie sono solo variazioni minori della stessa sfida. (Anche se questo ha ancora il problema che le soluzioni secondarie possono essere prese da altre risposte.) Quindi non mod-martello questo, e vedere cosa pensa la comunità.

— Martin Ender,

"Il tuo punteggio è la somma dei byte ..." quindi il mio primo esempio è sfortunato. Modificherò un altro potenziale esempio

— James Webster,

2

@MartinEnder I miei 2 centesimi: penso che sia OK e non VTC. Certo, in genere penso che una sfida con un singolo compito interessante sia migliore, ma poiché questi compiti sono molto simili, è molto meglio di un "campo da golf" che dice "fai questi 8 compiti casuali non correlati". Anche se non vi è alcuna interazione tra compiti, ai miei occhi questa sfida non è molto diversa da quella di dire Golf tutte e 16 le porte logiche .

— DJMcMayhem

Ci sono limiti di tempo o di memoria? Le attività secondarie devono essere indipendenti o possono condividere il codice?

— Dennis,

2

"Genera una stringa" significa che il codice deve effettivamente generare un valore di stringa con al suo interno i caratteri appropriati o è accettabile l'output dei sei caratteri (non separati da spazio o nuove righe)?

— DLosc,

6

Gelatina , 38 byte

TryItOnline collega A , B , e C .

A :ABC123!@£POI098, 22 byte

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

(pensando a una compressione per ridurre questa)

B :0123456789ABCDE, 8 byte:

ØHṖWẋ6X€

C :123456789ABCDEF(scelta), 8 byte:

ØHḊWẋ6X€

Come?

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

Alfabeto arbitrario: 23 byte ( demo online )

{"ABC123!@TPOI098"mR}6*

Alfabeto esadecimale: 14 byte ( demo online )

{FmrAbHb'0+}6*

Alfabeto personalizzato:, ABCDEFGHIJKLMNO10 byte ( demo online )

{Fmr'A+}6*

Dissezione

Quello esadecimale è quello 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

I sei personaggi vengono lasciati in pila e stampati automaticamente.

— Peter Taylor
fonte

2

AbHbè geniale. Ho pensato a quell'approccio generale ma _9>7*+era troppo lungo.

— Martin Ender,

6

Perl, 46 + 26 + 26 = 98 byte

Gran parte del merito va a @Dom Hastings per aver salvato 13 byte!

I 3 programmi sono praticamente identici, tranne l'alfabeto che cambia.

Alfabeto hardcoded ( ABC123!@)POI098in questo esempio) -> 46 byte:

say map{substr"ABC123!@)POI098",15*rand,1}1..6
Alfabeto fisso 0123456789ABCDE-> 26 byte:

printf"%X",rand 15for 1..6
Alfabeto personalizzato 0123456789ABCDEin quel caso -> 26 byte:

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

Puoi metterli tutti in un file per eseguirli:

$ 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 "";sono qui solo per migliorare il formato di output)

— Dada
fonte

2

Buone risposte! Ho avuto praticamente lo stesso per il primo e l'ultimo, ma puoi salvare un byte usando say: say map{("ABC123!@)POI098"=~/./g)[rand 15]}1..6e say map{(A..O)[rand 15]}1..6. Per il secondo puoi usare printf: printf"%X",rand 15for 1..6per salvare 11 su tutti! Sono sicuro che Ton può consigliare qualche magia arcana per risparmiare anche di più!

— Dom Hastings,

1

In realtà con l'alfabeto personalizzato ne substrsalva un altro:say map{substr"ABC123!@)POI098",15*rand,1}1..6

— Dom Hastings,

1

@DomHastings Hmm davvero, è bello, ben suonato! Grazie :-)

— Dada,

2

Mi piace che tu abbia rimosso la nota sul fatto che il codice sia semplice: D

— Dom Hastings,

@DomHastings con printf"%X", substr..randed mapè solo un po 'meno ovvio, quindi lascio che le persone si divertano con la magia del perl senza spoiler! : D

— Dada,

4

R, 33 + 43 + 59 = 135 byte

Alfabeto con codice hard arbitrario (cambia la stringa per cambiare l'alfabeto):

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

Alfabeto di [0-9A-E]:

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

Alfabeto definito dall'utente da stdin:

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

Tutti i casi stampano la parola di output su stdout.

— rturnbull
fonte

4

JavaScript (ES6), 167 166 164 163 byte

Salvato 1 byte grazie a Neil
Salvato 2 byte grazie a ETHproductions
Salvato 1 byte grazie a premek.v

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

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

Risolto: "0123456789ABCDE" ( 58 57 byte)

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

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

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

— Arnauld
fonte

1

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

— Neil,

1/8+Mathè fantastico :)

— ETHproductions

Ma .1+JSONè meglio;)

— ETHproductions

1

Oppure JSON+f( [object JSON](n=> " (JNOS[]bcejnot")

— ETHproductions

@ETHproductions Nice one. :)

— Arnauld,

3

JavaScript (ES6), 184 byte

Alfabeto personalizzato: 66 byte

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

0-9A-E: 63 byte

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

0-9a-e: 55 byte

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

(Sottrai 6 byte se la casualità basata sulla data è consentita.)

— Neil
fonte

È possibile salvare un byte sull'ultimo con **:_=>((Math.random()+1)*15**6|0).toString(15).slice(1)

— ETHproductions

@ETHproductions Sicuramente lo renderebbe ES7, anziché ES6? (Inoltre, mi sembra un risparmio di 3 byte.)

— Neil,

Sì, e sembra salvare 3 byte. Devo aver incluso il f=nel conteggio byte

— ETHproductions

3

q, 42 byte

UN

19 byte

6?"ABC123!@TPOI098"

B

14 byte

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

C

9 byte

6?15#.Q.a

(usa le prime quindici lettere dell'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 byte

Alfabeto arbitrario, 23 byte:

{"ABC123!@TPOI098"mR}6*

Provalo online!

Cifre esadecimali, 15 byte:

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

Provalo online!

Alfabeto ABCDEFGHIJKLMNO, 10 byte:

{Fmr'A+}6*

Provalo online!

— Martin Ender
fonte

Ho avuto una cattiva idea. Se consideriamo U + FFFE un personaggio, ~cinvece di 'A+restituire qualcosa di tecnicamente stampabile.

— jimmy23013,

Forse sto sbagliando. Non ho trovato una definizione di caratteri Unicode stampabili.

— jimmy23013,

2

Rubino 47 + 37 + 31 = 115

Hardcoded: "ABC123! @ TPOI098" (47)

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

Risolto: "0123456789ABCDE" (37)

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

Personalizzato: "ABCDEFGHIJKLMNO" (31)

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

— Michael Kohl
fonte

1

05AB1E , 43 byte

Alfabeto arbitrario ( ABC123!@TPOI098), 23 byte Provalo online

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

Alfabeto quasi esadecimale ( 0123456789ABCDE), 10 byte Provalo online

14Ýh6F.r¬?

Alfabeto personalizzato ( abcdefghijklmno), 10 byte Provalo online

A15£6F.r¬?

— Emigna
fonte

1

Python 2, 70 + 70 + 64 = 204 byte

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

Sfortunatamente, il secondo esempio è più semplice con il primo metodo di qualcosa di simile choice([randint(48,57)),choice(65,69)])

— Karl Napf
fonte

Perché si usa from random import*? Penso che tu possa usare import randome random.choicealmeno nei primi due esempi.

— Roman Gräf,

import random random.choiceha 27 anni ma from random import* choice26, anche import random as r r.choice27

— Karl Napf,

Per il caso esadecimale, possiamo fare un po 'meglio usando format(randrange(8**8),'X'), penso.

— DSM,

@DSM il problema è che non ci deve essereF

— Karl Napf,

1

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

# 1:

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

Provalo online!

# 2:

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

Provalo online!

# 3:

6\[eR5F-O]

Dove sono i personaggi disponibili:

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

Provalo online!

— Addison Crump
fonte

1

J, 24 + 24 + 18 10 = 58 byte

8 byte salvati grazie alle miglia!

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

Sì, la seconda stringa non è facilmente comprimibile in J:

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

Se un alfabeto esadecimale minuscolo va bene, allora c'è ,hfd?6#15 9 byte, come notato da @miles.

Comunque, ?6#15sono 6 numeri casuali tra 0 e 15; {~è presa da. u:converte i numeri in caratteri. L'ultimo esempio codifica ABCDEFGHIJKLMNOP.

Bonus: caso generale

{~6?@##

{~6?@## è all'incirca:

{~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

Nel secondo caso, c'è un builtin chiamato hfdche si converte in h ex f rom d ecimal. È possibile ottenere una soluzione a 9 byte utilizzando ,hfd?6#15. L'ultimo caso, solo per avere qualcosa di facile da leggere, usa l'alfabeto 'A'per una soluzione da 10 byte u:65+?6#15, per un totale di 24 + 9 + 10 = 45.

— miglia

@miles Penso che il secondo caso richieda lettere maiuscole. Per quanto riguarda l'ultimo caso ... ahah, oops. Mi ero completamente dimenticato dell'aggiunta vettoriale.

— Conor O'Brien,

1

PHP, 46 + 36 + 35 = 117 byte

Hardcoded (46 byte)

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

~~(47 byte)~~

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

Esadecimale (minuscolo) (36 byte)

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

Per maiuscole, 46 byte con la versione codificata.

Personalizzato (AO) (35 byte)

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

— Crypto
fonte

Non credo di poter accettare la tua seconda parte. ae non è la stessa di AE

— James Webster il

0

Scala, 154 byte

Alfabeto hardcoded (54 byte):

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

Alfabeto esadecimale (54 byte):

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

Alfabeto personalizzato ABCDEFGHIJKLMNO(47 byte):

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

Spiegazione:

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 sequenza di 15 caratteri, da A a O

— corvus_192
fonte

0

Pip , 42 byte

Alfabeto hardcoded, 22 byte:

L6ORC"ABC123!@TPOI098"

Cifre esadecimali, 11 byte:

L6ORR15TB16

Prime 15 lettere minuscole, 9 byte:

L6Oz@RR15

Spiegazione

Tutti e tre i programmi iniziano con L6O: ciclo 6 volte e output dell'espressione data.

RC"...": Scelta casuale di un carattere dalla stringa codificata
RR15TB16: RandRange (15), convertito in base 16
z@RR15: alfabeto minuscolo z, indicizzato con RandRange (15)

Provalo online!

— DLosc
fonte

0

Skript / skQuery , 108 byte

Hardcoded (43 byte):

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

0123456789ABCDE (34 byte):

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

Scelta (31 byte):

random 6 char string from `A-M`

— Oliver Ni
fonte

Puoi spostare l'apertura `a sinistra?

— Addison Crump,

@VTCAKAVSMoACE No, non ti permette

— Oliver Ni

0

Jolf, 26 + 14 + 13 = 51 byte

Μ*S6d rG"ABC123!@TPOI098"E

Alfabeto personalizzato, 24 byte. Provalo qui!

Μ*S6d r lp^0wά

Alfabeto 0-9A-E, 14 byte. Provalo qui! lp^0wάè lp(0-Z) sliced ( l) da 0a 15( wά).

Μ*S6d r lp^1ά

1-9A-F alfabeto, 13 byte. Provalo qui! lp^1άè uguale a sopra, tranne da 1a 16.

Metodo generale:

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

Altri tentativi (utilizzando la compressione delle stringhe):

Μ*S6d rGμpwΞ $AE

— Conor O'Brien
fonte

0

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

Alfabeto fisso, 45 byte

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

Alfabeto quasi esadecimale, 44 byte

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

Alfabeto personalizzato (dalla A alla O), 37 byte

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

Tutti questi seguono lo stesso modello - ciclo da 0a 5, ogni iterazione selezionando un Randomcarattere o un valore ASCII, lanciandolo come un chararray se necessario e inserendolo -joinin una stringa. Quella stringa viene lasciata sulla pipeline e l'output è implicito.

Esempi

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 byte

Alfabeto arbitrario, 20 byte

6V"ABC123!@TPOI098"H

Provalo qui!

Alfabeto esadecimale, 8 byte

6V~J15<H

Provalo qui!

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

Alfabeto personalizzato, 7 byte

6VG15<H

Provalo qui!

G15< - alphabet[:15]

Alfabeto scelto: abcdefghijklmno

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

— Blu
fonte

Questo sembra generare 6 caratteri separati da newline invece di una stringa da 6 caratteri.

— Emigna,

La domanda non indica il formato di output.

— Blu,

Vedo le parole Genera una stringa di 6 caratteri in 4 punti nella specifica.

— Emigna,

Genera una stringa di 6 caratteri da un alfabeto di 15 caratteri

Gelatina , 38 byte

Come?

CJam (23 + 14 + 10 = 47 byte)

Dissezione

Perl, 46 + 26 + 26 = 98 byte

R, 33 + 43 + 59 = 135 byte

JavaScript (ES6), 167 166 164 163 byte

JavaScript (ES6), 184 byte

q, 42 byte

Julia (36 + 26 + 21 = 83)

CJam, 48 byte

05AB1E , 43 byte

Python 2, 70 + 70 + 64 = 204 byte

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

J, 24 + 24 + 18 10 = 58 byte

Bonus: caso generale

PHP, 46 + 36 + 35 = 117 byte

Hardcoded (46 byte)

Esadecimale (minuscolo) (36 byte)

Personalizzato (AO) (35 byte)

Scala, 154 byte

Pip , 42 byte

Spiegazione

Skript / skQuery , 108 byte

Jolf, 26 + 14 + 13 = 51 byte

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

Esempi

Pyke, 35 byte

Alfabeto arbitrario, 20 byte

Alfabeto esadecimale, 8 byte

Alfabeto personalizzato, 7 byte