Erstellen Sie eine 6-stellige Zeichenfolge aus einem 15-stelligen Alphabet

17

In einem unserer Arbeitsprojekte haben wir kürzlich eine besonders umfangreiche Methode zur Generierung einer 6-stelligen Zeichenfolge aus einem 15-stelligen Alphabet entdeckt. Einige von uns behaupteten "Ich wette, wir können das in einer Zeile bekommen", was ein kleines internes Codegolfspiel auslöste.

Ihre Aufgabe ist es, uns zu besiegen, was zweifellos nicht lange dauern wird!

Der ursprüngliche Algorithmus verwendete das Alphabet 0-9A-E, aber wir haben mit anderen Alphabeten experimentiert. Es gibt also drei Unteraufgaben.

  1. Generieren Sie eine 6zufällige Zeichenfolge, indem Sie ein beliebiges hartcodiertes 15Alphabet wie auswählen ABC123!@TPOI098. (Dies ist nur ein Beispiel und sollte anpassbar sein, ohne die Byteanzahl zu beeinflussen.)
  2. Generieren Sie eine 6zufällige Zeichenfolge aus einem 15Buchstabenalphabet 0123456789ABCDE.
  3. Generieren Sie eine 6zufällige Zeichenfolge aus einem 15Buchstaben Ihrer Wahl (nur druckbare Zeichen bitte).

Jeder Charakter sollte die gleiche Auswahlmöglichkeit haben und Wiederholungen sollten möglich sein.

Das Beste, was wir für jede Unteraufgabe bewältigen konnten, ist:

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

Ihre Punktzahl ist die Summe der Bytes in der Lösung jeder Teilaufgabe. dh unsere Punktzahl ist derzeit 58.

Wir haben unter anderem versucht, CJam und Ruby zu verwenden. Das Original war in C #. Verwenden Sie eine beliebige Sprache, wir sind jedoch daran interessiert, Lösungen in diesen Sprachen zu finden

code-golf  generation 
— James Webster
quelle
5
In Bezug auf mehrteilige Herausforderungen. Leider habe ich in diesem Fall keine gute Lösung, da diese drei Teilaufgaben viel zu ähnlich sind, als dass es sinnvoll wäre, sie in mehrere Herausforderungen aufzuteilen. Ich habe auch darüber nachgedacht, eine Ausnahme von dieser Richtlinie für mehrteilige Herausforderungen vorzuschlagen, bei denen die Unteraufgaben nur geringfügige Variationen derselben Herausforderung sind. (Obwohl dies immer noch das Problem hat, dass Teillösungen aus anderen Antworten übernommen werden können.) Ich werde das also nicht modifizieren und sehen, was die Community denkt.
— Martin Ender
"Ihre Punktzahl ist die Summe der Bytes ..." Mein erstes Beispiel ist also unglücklich. Ich werde ein anderes mögliches Beispiel ändern
— James Webster
2
@MartinEnder Meine 2 Cent: Ich finde es OK und will kein VTC. Sicher, ich denke im Allgemeinen, dass eine Herausforderung mit einer einzelnen interessanten Aufgabe besser ist, aber da diese Aufgaben sehr ähnlich sind, ist es viel besser als ein "Golfplatz", auf dem steht "Tu diese 8 zufälligen Aufgaben ohne Bezug". Auch wenn es keine Interaktion zwischen den Aufgaben gibt, ist diese Herausforderung in meinen Augen nicht sehr unterschiedlich als Golf alle 16 Logikgatter zu sagen .
— DJMcMayhem
Gibt es Zeit- oder Speicherbeschränkungen? Müssen die Unteraufgaben unabhängig sein oder dürfen sie Code teilen?
— Dennis
2
Bedeutet "eine Zeichenfolge generieren", dass der Code tatsächlich eine Zeichenfolge mit den entsprechenden Zeichen generieren muss, oder ist die Ausgabe der sechs Zeichen (nicht durch Leerzeichen oder Zeilenumbrüche getrennt) akzeptabel?
— DLosc

Antworten:

6

Jelly , 38 Bytes

TryItOnline Verbindungen A , B , und C .

A :ABC123!@£POI09822 Bytes

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

(Denken Sie über eine Komprimierung nach, um diese zu verringern.)

B :0123456789ABCDE8 Bytes:

ØHṖWẋ6X€

C :123456789ABCDEF(Auswahl), 8 Bytes:

ØHḊWẋ6X€

Wie?

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

CJam (23 + 14 + 10 = 47 Bytes)

Beliebiges Alphabet: 23 Bytes ( Online-Demo )

{"ABC123!@TPOI098"mR}6*

Hexadezimales Alphabet: 14 Byte ( Online-Demo )

{FmrAbHb'0+}6*

Benutzerdefiniertes Alphabet: ABCDEFGHIJKLMNO10 Byte ( Online-Demo )

{Fmr'A+}6*

Präparation

Das Hexadezimale ist das 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

Die sechs Zeichen bleiben auf dem Stapel und werden automatisch gedruckt.

— Peter Taylor
quelle
2
AbHbist genial. Ich dachte über diesen allgemeinen Ansatz nach, _9>7*+war aber zu lang.
— Martin Ender
6

Perl, 46 + 26 + 26 = 98 Bytes

Ein Großteil des Kredits geht an @Dom Hastings für die Einsparung von 13 Bytes!

Die 3 Programme sind bis auf das sich ändernde Alphabet ziemlich identisch.

  • Hartcodiertes Alphabet ( ABC123!@)POI098in diesem Beispiel) -> 46 Bytes:

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

  • Festes Alphabet 0123456789ABCDE-> 26 Bytes:

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

  • Benutzerdefiniertes Alphabet 0123456789ABCDEin diesem Fall -> 26 Bytes:

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

Sie können sie alle in eine Datei einfügen, um sie auszuführen:

$ 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

(Das say "";sind nur hier, um das Ausgabeformat zu verbessern)

— Dada
quelle
2
Gute Antworten! Beim ersten und letzten Mal war es ziemlich ähnlich, aber Sie können ein Byte mit say: say map{("ABC123!@)POI098"=~/./g)[rand 15]}1..6und speichern say map{(A..O)[rand 15]}1..6. Für die Sekunde können Sie verwenden printf: printf"%X",rand 15for 1..6um insgesamt 11 zu sparen! Ich bin mir sicher, dass Ton zu arkaner Magie raten kann, um noch mehr zu sparen!
— Dom Hastings
1
Eigentlich mit dem benutzerdefinierten Alphabet substrspeichert eine andere:say map{substr"ABC123!@)POI098",15*rand,1}1..6
— Dom Hastings
1
@DomHastings Hmm, das ist schön, gut gespielt! Danke :-)
— Dada
2
Ich finde es gut, dass Sie die Notiz entfernt haben, dass der Code unkompliziert ist: D
— Dom Hastings
@DomHastings mit printf"%X", substr..randund mapes ist nur ein bisschen weniger offensichtlich, ich so lassen die Menschen ohne Spoiler perl Magie genießen! : D
— Dada
4

R, 33 + 43 + 59 = 135 Bytes

Beliebiges hartcodiertes Alphabet (ändern Sie die Zeichenfolge, um das Alphabet zu ändern): 

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

Alphabet von [0-9A-E]:

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

Benutzerdefiniertes Alphabet von stdin:

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

In allen Fällen wird das Ausgabewort auf stdout gedruckt.

— rturnbull
quelle
4

JavaScript (ES6), 167 166 164 163 Bytes

1 Byte dank Neil
gespeichert 2 Byte dank ETHproductions
gespeichert 1 Byte dank premek.v gespeichert

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

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

Behoben: "0123456789ABCDE" ( 58 57 Bytes)

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

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

f=(n=6)=>n?(f+1)[Math.random()*15|0+5]+f(n-1):''
— Arnauld
quelle
1
(n=6)=>n?f(n-1)+("ABCDE"[n=Math.random()*15|0]||n-5):''Spart dir ein Byte.
— Neil
1/8+Mathis great :)
— ETHproductions
.1+JSON
— Ist
1
Oder JSON+f( [object JSON](n=> " (JNOS[]bcejnot")
— ETHproductions
@ETHproductions Schöne. :)
— Arnauld
3

JavaScript (ES6), 184 Byte

Benutzerdefiniertes Alphabet: 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)

(Subtrahieren Sie 6 Bytes, wenn eine datumsbasierte Zufälligkeit zulässig ist.)

— Neil
quelle
Sie können ein Byte für das letzte speichern mit **:_=>((Math.random()+1)*15**6|0).toString(15).slice(1)
— ETHproductions 16.10.16
@ETHproductions Würde das wohl eher ES7 als ES6 machen? (Es sieht auch so aus, als würde ich 3 Byte sparen.)
— Neil,
Ja, und es scheint 3 Bytes zu sparen. Ich muss die f=in der
— Byteanzahl
3

q, 42 Bytes

EIN

19 Bytes

6?"ABC123!@TPOI098"

B

14 Bytes

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

C

9 Bytes

6?15#.Q.a

(verwendet die ersten fünfzehn Buchstaben des Alphabets)

— Skeevey
quelle
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
quelle
2

CJam, 48 Bytes

Beliebiges Alphabet, 23 Bytes:

{"ABC123!@TPOI098"mR}6*

Probieren Sie es online!

Hexadezimalstellen, 15 Bytes:

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

Probieren Sie es online!

Alphabet ABCDEFGHIJKLMNO, 10 Bytes:

{Fmr'A+}6*

Probieren Sie es online!

— Martin Ender
quelle
Ich hatte eine schlechte Idee. Wenn wir U + FFFE als Zeichen betrachten, wird ~cstattdessen 'A+etwas technisch Druckbares zurückgegeben.
— Jimmy23013
Vielleicht bin ich falsch. Ich habe keine Definition für druckbare Unicode-Zeichen gefunden.
— Jimmy23013
2

Ruby 47 + 37 + 31 = 115

Hardcoded: "ABC123! @ TPOI098" (47)

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

Behoben: "0123456789ABCDE" (37)

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

Benutzerdefiniert: "ABCDEFGHIJKLMNO" (31)

(1..6).map{[*?A..?O].sample}*''
— Michael Kohl
quelle
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

Leider ist das zweite Beispiel mit der ersten Methode einfacher als so etwas choice([randint(48,57)),choice(65,69)])

— Karl Napf
quelle
Warum benutzt du from random import*? Ich denke, Sie können import randomund random.choicezumindest in den ersten beiden Beispielen verwenden.
— Roman Gräf
import random random.choiceist 27, from random import* choiceist aber 26, import random as r r.choiceist auch 27
— Karl Napf
Für den Hex-Fall können wir format(randrange(8**8),'X'), glaube ich, mit ein bisschen mehr erreichen.
— DSM
@DSM das Problem ist, es muss keine gebenF
— Karl Napf
1

J, 24 + 24 + 18 10 = 58 Bytes

Dank Meilen 8 Bytes gespart!

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

Ja, die zweite Zeichenfolge ist in J nicht leicht komprimierbar:

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

Wenn ein Hex-Alphabet in Kleinbuchstaben in Ordnung ist, gibt es ,hfd?6#15 9 Bytes zulässig, wie in @miles angegeben.

Jedenfalls ?6#15sind 6 Zufallszahlen zwischen 0 und 15; {~ist take-from. u:konvertiert Zahlen in Zeichen. Das letzte Beispiel codiertABCDEFGHIJKLMNOP .

Bonus: allgemeiner Fall

{~6?@##

{~6?@## ist ungefähr:

{~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
quelle
Im zweiten Fall gibt es ein eingebautes Element namens hfd, das in h ex f konvertiert wird rom d ecimal. Sie können eine 9-Byte-Lösung mit erhalten ,hfd?6#15. Der letzte Fall, nur um etwas leicht zu lesen, verwendet das Alphabet von 'A'für eine 10-Byte-Lösung u:65+?6#15, was insgesamt 24 + 9 + 10 = 45 ergibt .
— Meilen
@ Meilen Ich denke, der zweite Fall erfordert Großbuchstaben. Was den letzten Fall betrifft ... haha, hoppla. Ich habe die vektorisierte Addition völlig vergessen.
— Conor O'Brien
1

PHP, 46 + 36 + 35 = 117 Bytes

Hardcoded (46 Bytes)

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

(47 Bytes)

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

Hexadezimal (Kleinbuchstaben) (36 Byte)

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

Für Großbuchstaben 46 Bytes mit Hardcoded-Version.

Benutzerdefiniert (AO) (35 Byte)

for(;$k++<6;)echo chr(rand(65,79));
— Krypto
quelle
Ich glaube nicht, dass ich deinen zweiten Teil akzeptieren kann. ae ist nicht dasselbe wie AE
— James Webster
0

Scala, 154 Bytes

Hartcodiertes Alphabet (54 Bytes):

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

Hex-Alphabet (54 Bytes):

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

Benutzerdefiniertes Alphabet ABCDEFGHIJKLMNO(47 Byte):

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

Erläuterung:

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' Erzeugt eine Folge von 15 Zeichen (A bis O)

— corvus_192
quelle
0

Pip , 42 Bytes

Hardcoded Alphabet, 22 Bytes:

L6ORC"ABC123!@TPOI098"

Hexadezimalziffern, 11 Bytes:

L6ORR15TB16

Erste 15 Kleinbuchstaben, 9 Bytes:

L6Oz@RR15

Erläuterung

Alle drei Programme beginnen mit L6O: 6-maliger Schleife und geben den angegebenen Ausdruck aus.

  • RC"...": Zufällige Auswahl eines Zeichens aus der fest codierten Zeichenfolge
  • RR15TB16: RandRange (15), konvertiert zur Basis 16
  • z@RR15: Kleinbuchstaben z, indiziert mit RandRange (15)

Probieren Sie es online!

— DLosc
quelle
0

Skript / skQuery , 108 Bytes

Hardcoded (43 Bytes):

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

0123456789ABCDE (34 Byte):

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

Auswahl (31 Bytes):

random 6 char string from `A-M`
— Oliver Ni
quelle
Können Sie die Öffnung `nach links verschieben?
— Addison Crump
@ VTCAKAVSMoACE Nein, es lässt dich nicht
— Oliver Ni
0

Jolf, 26 + 14 + 13 = 51 Bytes

Μ*S6d rG"ABC123!@TPOI098"E

Benutzerdefiniertes Alphabet, 24 Byte. Probieren Sie es hier aus!

Μ*S6d r lp^0wά

0-9A-E Alphabet, 14 Bytes. Probieren Sie es hier aus! lp^0wάwird lp(0-Z) geschnitten ( l) von 0bis 15( wά).

Μ*S6d r lp^1ά

1-9A-F Alphabet, 13 Bytes. Probieren Sie es hier aus! lp^1άist dasselbe wie oben, außer von 1bis 16.

Allgemeine Methode:

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

Andere Versuche (mit String-Komprimierung):

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

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

Festes Alphabet, 45 Bytes

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

Fast hexadezimales Alphabet, 44 Byte

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

Benutzerdefiniertes Alphabet (A bis O), 37 Byte

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

Alle folgen der gleichen Musterschleife von 0bis 5, wobei jede Iteration ein RandomZeichen oder einen ASCII-Wert charauswählt und diesen gegebenenfalls als -array ausgibt, und-join zu einer Zeichenfolge zusammenfügt. Diese Zeichenfolge verbleibt in der Pipeline, und die Ausgabe ist implizit.

Beispiele

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

Pyke, 35 Bytes

Beliebiges Alphabet, 20 Bytes

6V"ABC123!@TPOI098"H

Probieren Sie es hier aus!

Hex-Alphabet, 8 Bytes

6V~J15<H

Probieren Sie es hier aus!

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

Benutzerdefiniertes Alphabet, 7 Byte

6VG15<H

Probieren Sie es hier aus!

G15< - alphabet[:15]

Alphabet gewählt: abcdefghijklmno

6V     - repeat 6 times:
  ...  -   get alphabet
     H -  choose_random(^)
— Blau
quelle
Dies scheint 6 Zeichen, die durch Zeilenvorschub getrennt sind, anstelle eines 6-Zeichen-Strings auszugeben.
— Emigna
Die Frage gibt das Ausgabeformat nicht an.
— Blue
Ich sehe die Wörter, die eine Zeichenkette mit 6 Buchstaben in 4 Stellen in der Spezifikation erzeugen.
— Emigna
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.