Zum Thema Drahtsequenzen
Diese Herausforderung stammt aus einem Spiel, Keep Talking And Nobody Explodes .
Es ist schwer zu sagen, wie dieser Mechanismus funktioniert. Die Technik ist ziemlich beeindruckend, aber es muss eine einfachere Möglichkeit gegeben haben, neun Drähte zu verwalten. - aus dem Handbuch
Eingang
Genau 9 "Drähte", die jeweils mit "A", "B" oder "C" gekennzeichnet und rot, blau oder schwarz gefärbt sind.
Eingabeformat und -typ spielen keine Rolle, solange sie die Drähte eindeutig identifizieren. Insbesondere können die Alphabete beliebig codiert werden, ebenso die Farben.
Ziel und Leistung
Geben Sie die Indizes der Drähte aus, die geschnitten werden müssen. Das Ausgabeformat und der Ausgabetyp spielen ebenfalls keine Rolle, solange sie die zu schneidenden Drähte eindeutig identifizieren.
Welchen Draht soll ich schneiden?
Wenn der Draht Farbe hat \$X\$und es ist das \$N\$Der Draht dieser Farbe, den Sie bisher gesehen haben, sehen Sie sich den Eintrag von color \ an$X\$in Zeile \$N\$des Tisches. Wenn und nur wenn das Etikett des Drahtes in diesem Eintrag aufgeführt ist, ist es zu schneiden.
$$ \begin{array}{c|ccc} & \text{Red} & \text{Blue} & \text{Black} \\ \hline \text{1st} & \text{C} & \text{B} & \text{A, B, or C} \\ \text{2nd} & \text{B} & \text{A or C} & \text{A or C} \\ \text{3rd} & \text{A} & \text{B} & \text{B} \\ \text{4th} & \text{A or C} & \text{A} & \text{A or C} \\ \text{5th} & \text{B} & \text{B} & \text{B} \\ \text{6th} & \text{A or C} & \text{B or C} & \text{B or C} \\ \text{7th} & \text{A, B, or C} & \text{C} & \text{A or B} \\ \text{8th} & \text{A or B} & \text{A or C} & \text{C} \\ \text{9th} & \text{B} & \text{A} & \text{C} \end{array} $$
Beispiel
Angenommen, die Drähte sind 1-indiziert und erhalten den folgenden Eingang:
Blue C
Blue C
Black C
Black B
Black A
Red C
Blue C
Black A
Black A
Der 1. Draht ist der 1. blaue Draht, der nicht mit B verbunden ist. Lassen Sie ihn also.
Der 2. Draht ist der 2. blaue Draht, der mit A oder C verbunden ist. Schneiden Sie ihn also ab.
Der 3. Draht ist der 1. schwarze Draht, also schneiden Sie ihn ab.
Der 4. Draht ist der 2. schwarze Draht, der weder mit A noch mit C verbunden ist. Lassen Sie ihn also.
Der 5. Draht ist der 3. schwarze Draht, der nicht mit B verbunden ist. Lassen Sie ihn also.
Der 6. Draht ist der 1. rote Draht, der mit C verbunden ist. Schneiden Sie ihn also ab.
Der 7. Draht ist der 3. blaue Draht, der nicht mit B verbunden ist. Lassen Sie ihn also.
Der 8. Draht ist der 4. schwarze Draht, der mit A oder C verbunden ist. Schneiden Sie ihn also ab.
Der 9. Draht ist der 5. schwarze Draht, der nicht mit B verbunden ist. Lassen Sie ihn also.
Die Ausgabe ist also [2,3,6,8].
Antworten
Gelee , 27 25 Bytes
ċṪ$Ƥżḅ3Ʋị“µỵƓṢ⁴ż]¶:ɼ’ḃ7¤&
Ein dyadischer Link, der eine Liste der Drahtfarben links und eine Liste der Drahtetiketten rechts akzeptiert, die eine Liste von Indikatoren für das Schneiden jedes Drahtes liefert.
Eingaben:
Red : 1 A : 1
Blue : 2 B : 2
Black : 3 C : 4
Ausgänge:
Cut : non-zero (truthy)
Don't cut : zero (falsey)
Probieren Sie es online aus!
Hier ist eine einfacher zu verwendende Version, die die Farben RBK(rot, blau, schwarz) in der ersten Zeile und die Beschriftungen ABCin der zweiten Zeile akzeptiert und eine Liste der zu schneidenden Drahtnummern liefert.
Wie?
ċṪ$Ƥżḅ3Ʋị“...’ḃ7¤& - Link: colours, labels
Ʋ - last four links as a monad - f(colours):
Ƥ - for prefixes:
$ - last two links as a monad - f(prefix):
Ṫ - tail -> current wire's colour
ċ - count -> number of such wires seen before
ż - zip with (colours)
3 - three
ḅ - convert (zip result items) from base (3)
X = the indexes to check in the flattened table
¤ - nilad followed by link(s) as a nilad:
“...’ - 41650313607423351764917
7 - seven
ḃ - bijective-base -> [4,2,7,2,5,5,1,2,2,5,1,5,2,2,2,5,6,6,7,4,3,3,5,4,2,1,4]
Y = the flattened table as bitmasks of labels to cut
ị - (each of X) index into (Y)
& - (that) bitwise AND with (labels) (vectorises)
JavaScript (ES6), 75 74 67 Byte
Erwartet eine Liste von [color, label]Paaren, die 0-2für beide verwendet werden. Gibt ein binäres Array zurück, das beschreibt, welche Drähte abgeschnitten werden müssen.
a=>a.map(([c,w])=>(m[c]/=8)>>w&1,m=[334844576,228136272,611931512])
Probieren Sie es online aus!
63 Bytes
Wir können einige Bytes sparen, indem wir A=1, B=2, C=4eine Liste von Null- / Nicht-Null-Werten nehmen und zurückgeben.
a=>a.map(([c,w])=>w&=m[c]/=8,m=[334844576,228136272,611931512])
Probieren Sie es online aus!
Wie?
Jede Farbe wird als eine Bitmaske Beschreiben der Draht Etiketten für die 1 codiert st an die 9 th Aussehen.
# | 9 8 7 6 5 4 3 2 1 (0)
Label | CBA CBA CBA CBA CBA CBA CBA CBA CBA ---
-------+-----------------------------------------
Red | 010 011 111 101 010 101 001 010 100 000 -> 334844576
Blue | 001 101 100 110 010 001 010 101 010 000 -> 228136272
Black | 100 100 011 110 010 101 010 101 111 000 -> 611931512
Immer wenn eine Farbe erscheint, verschieben wir die entsprechende Bitmaske um 3 Positionen nach rechts (indem wir sie durch 8 teilen) und testen das Bit 0, 1 oder 2 entsprechend der Bezeichnung.
Retina 0,8,2 , 119 Bytes
s`(\d)(?<=(\1.*?)+)
$1$#2
%`(23|4|26|19)A|(22|1[136]|03|5|06|29)B|(2[148]|04|6|17|09)C|(07|28)[AB]|([10]2|18)[AC]|01|27
Probieren Sie es online aus! Übernimmt die Eingabe als Liste von Ziffern + Buchstaben-Paaren, wobei die Ziffer 2für Rot, 1für Blau und 0für Schwarz steht. Die Ausgabe ist eine Liste, ob jeder Draht geschnitten werden soll. Erläuterung:
s`(\d)(?<=(\1.*?)+)
$1$#2
Fügen Sie nach jeder Ziffer die Anzahl der kumulativen Erscheinungsbilder ein.
%`(23|4|26|19)A|(22|1[136]|03|5|06|29)B|(2[148]|04|6|17|09)C|(07|28)[AB]|([10]2|18)[AC]|01|27
Überprüfen Sie für jeden Draht, ob er geschnitten werden muss.
Rost , 89 Bytes
|w|w.scan([0;3],|a,&(c,l)|{a[c]+=1;Some(b"TGjEQBMERBuFgCkDJD"[2*a[c]-2+c/2]>>c%2*3+l&1)})
Probieren Sie es online aus!
Erläuterung:
Sowohl Farben als auch Beschriftungen werden als Zahlen von 0-2 codiert. Der Ausgang ist eine Zahl für jeden Draht: 1, wenn er abgeschnitten werden soll, andernfalls 0. Die b"TG...D"Zeichenfolge enthält eine binäre Codierung der obigen Tabelle. Die in jede Zelle zu schneidenden Beschriftungen werden in eine 3-Bit-Maske umgewandelt. Drei dieser Masken können in zwei Bytes gepackt werden (Rot und Blau im ersten Byte und Schwarz im zweiten Byte). Das 6. Bit (das nicht verwendet wird) wird ebenfalls gesetzt, um alle Zeichen ASCII-druckbar zu machen (um keine Escape-Sequenzen oder rohen Zeichenfolgen zu benötigen).
J , 61 Bytes
Nimmt in Werten Red Blue Black -> 0 1 2, A B C -> 0 1 2umgesetzt, so Farbe oben Brief in der Matrix steht. Gibt eine Bitmaske der zu schneidenden Drähte zurück.
(9 3 3$-.#:2005405163341131167346014x){::~(1#.{:=}:)\@{.|:@,]
Probieren Sie es online aus!
Wie es funktioniert
Die Tabelle ist in codiert (9 3 3$-.#:2005405163341131167346014x). Konvertieren Sie die lange Zahl in Basis 2, negieren Sie sie und formen Sie sie in um 9 3 3. Mit einem Index wie 4 1 1(5. blaues B) erhalten wir eine 1, die dem Schnitt entspricht. Ich benutze die negierte Form, damit wir eine führende 1 haben. Lustige Tatsache: Die Tabelle, die zu einer Liste in Basis 2 zerrissen wurde, 412446475888127182066337ist prim!
t{::~(1#.{:=}:)\@{.|:@,]
{. the first row (colors)
\@ for each prefix (1, 1 1, 1 1 2, …)
{:=}: compare last element to all other
1#. and count the occurrences
,] prepend this to the original list
|:@ and transpose it
t{::~ get the corresponding bit of the table
Holzkohle , 33 Bytes
⭆觔)∧∨⦃↧dＧ↓◨h↓WK”⍘⁺№Ｅ…θκ§λ⁰§ι⁰ι³
Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Übernimmt die Eingabe als Liste von Ziffern + Buchstaben-Paaren, wobei die Ziffer 2für Rot, 1für Blau und 0für Schwarz steht. Die Ausgabe ist eine binäre Zeichenfolge, die angibt, ob jeder Draht abgeschnitten werden soll. Erläuterung:
θ Input list
⭆ Map over elements and join
”...” Compressed binary lookup table
§ Cyclically indexed by
№ Count of
§ ⁰ First character of
ι Current entry in
… κ Prefix of
θ Input list
Ｅ Map over entries
§ ⁰ First character of
λ Inner entry
⁺ Concatenated with
ι Current entry
⍘ ³ Interpreted as base 3
Implicitly print
Als Beispiel ist der letzte Draht aus dem Beispiel 0Ader fünfte schwarze Draht, daher enthält das Präfix vier Drähte, was zu einer Zeichenfolge führt 40A. Dies wird konvertiert als 4 * 9 + 0 * 3 + A, wo die Buchstaben mit decodiert werden a=10, ... z=35, A=36, ... Z=61, was zu einer endgültigen Summe von 72 führt. Die Verwendung von Großbuchstaben erfordert hier lediglich, dass die gesamte Nachschlagetabelle um 36 Bit gedreht wird, sodass die Buchstaben nicht codiert werden müssen.
Python 3 , 92 Bytes
def f(w):
m,i=[41855572,28517034,76491439],1
for c,t in w:t&m[c]and print(i);i+=1;m[c]>>=3
Nimmt die Eingabe als Liste von (Farb-, Draht-) Tupeln auf. Die Farbe ist rot = 0, blau = 1 und schwarz = 2 codiert. Die Drähte sind mit A = 1, B = 2 und C = 4 codiert. Das Beispiel ist also
[(1, 4), (1, 4), (2, 4), (2, 2), (2, 1), (0, 4), (1, 4), (2, 1), (2, 1)]
mist die codierte Tabelle. Die 1. Zeile ist in den niedrigstwertigen Bits codiert. In binär:
table = [
# 9 8 7 6 5 4 3 2 1 <- table row
# CBA CBA CBA CBA CBA CBA CBA CBA CBA
0b_010_011_111_101_010_101_001_010_100,
0b_001_101_100_110_010_001_010_101_010,
0b_100_100_011_110_010_101_010_101_111
]
Nach dem Überprüfen einer Farb- / Etikettenkombination wird die Tabellenspalte um 3 Bit verschoben, sodass der 1. rote Draht, der 2. rote Draht usw. nicht verfolgt werden müssen.
05AB1E , 32 Bytes
ε•1ä)eι()2×rK•b3ô3ô¯yн©¢è®èyθ讈
Eingabe als Paar [color, wire], wo die Farben red=2, blue=1, black=0und Drähte sind A=0, B=1, C=2. Gibt eine Liste von Nullen und Einsen aus, wobei die Einsen die Position der Drähte sind, die geschnitten werden sollen.
Probieren Sie es online aus.
Erläuterung:
ε # Map over each pair `y` of the (implicit) input:
•1ä)eι()2×rK• # Push compressed integer 2199241953913589502631010
b # Convert it to binary: 111010001101101010010010100101100101010010010011011101110001111001101110001100010
3ô # Split it into parts of size 3: ["111","010","001","101","101","010","010","010","100","101","100","101","010","010","010","011","011","101","110","001","111","001","101","110","001","100","010"]
3ô # Split that list into parts of size 3 again: [["111","010","001"],["101","101","010"],["010","010","100"],["101","100","101"],["010","010","010"],["011","011","101"],["110","001","111"],["001","101","110"],["001","100","010"]]
¯ # Push the global array
yн # Get the first item of the pair
© # Store it in variable `®` (without popping)
¢ # Count the amount of times it occurs in the global array
è # Use that to index into the list of triplets
® # Push the first item of variable `®` again
è # Use that to index into the triplet
yθ # Push the last item of the pair
è # Use that to index into the binary-string
®ˆ # Add the first item of variable `®` to the global array
# (after which the resulting list is output implicitly)
Lesen Sie diesen 05AB1E-Tipp von mir (Abschnitt Komprimieren großer Ganzzahlen? ) , Um zu verstehen, warum dies so •1ä)eι()2×rK•ist 2199241953913589502631010.
C (gcc) , 107 Bytes
_,O;P(int*T){for(int R[3]={O=0};9>O++;"T+R&%*{9+*"[_/7]>>_%7&1&&printf("%d ",O))_=*T+R[*T++/3]++*9+*T++;}
Probieren Sie es online aus!
Nimmt ein Array von {Farbe 1, Etikett 1, Farbe 2, Etikett 2, ...
Jeder Tabelleneintrag wird in drei Tripletts von Bits codiert, eines für jede Farbe, wobei jedes Bit eine Bezeichnung darstellt
rb bla RedBluBla
abcabcabc
1. cb abc -> 001010111
2 b ac ac -> 010101101
3 abb -> 100010010
4 ac a ac -> 101100101
5 bbb -> 010010010
6 ac bc bc -> 101011011
7 abc c ab -> 111001110
8 ab ac c -> 110101001
9 bac -> 010100001
Dann werden alle Bits verbunden, um 7 verschüttet, umgekehrt und in eine Zeichenfolge umgewandelt T+R&%*{9+*.
Um die Zielbitposition zu erhalten, multiplizieren wir die benötigte Tabellenzeile mit 9 und addieren den Farbwert und den Beschriftungswert.
Dann teilen wir durch 7, um das Zeichen zu erhalten, das wir in der codierten Zeichenfolge benötigen, und verschieben uns um Modulo 7 zurück