Würde diese Zeichenfolge als Zeichenfolge funktionieren?


92

Schreiben Sie ein Programm, das eine einzeilige Zeichenfolge verwendet, von der Sie annehmen können, dass sie nur die Zeichen enthält /\_‾. (Dies sind Schrägstriche in Vorwärts- und Rückwärtsrichtung, Unterstreichungen und Überstriche . Sie können diese ~anstelle von Überstrichen verwenden, wenn Sie dies benötigen, da Überstriche kein bequemes ASCII-Format sind.)

Eine mögliche Eingabe ist beispielsweise:

__/‾‾\/\_/‾

Ihr Programm muss einen Wahrheits- oder Falschwert ausgeben, je nachdem, ob der linke Rand des Strings sozusagen über die Zeilen der Zeichen mit dem rechten Rand des Strings "verbunden" ist. Wenn das Kerning also etwas geringer wäre, gäbe es eine durchgehende schwarze (wenn auch verworrene) Linie vom linken Rand bis zum rechten, wie ein ungebrochenes Stück Schnur oder Faden.

Die Ausgabe für das obige Beispiel wäre wahr, da die Kanten verbunden sind:

Beispielpfad

Um die Verbindungen zu verdeutlichen:

  • / verbindet links unten und rechts oben
  • \ verbindet oben links und unten rechts
  • _ Verbindet links unten und rechts unten
  • (oder ~) verbindet oben links und oben rechts

Ebenfalls:

  • Es ist egal, ob die Kanten der Saite oben oder unten beginnen, es ist nur wichtig, dass sie horizontal über die gesamte Länge der Saite verbunden sind.

  • Sie können davon ausgehen, dass die Eingabezeichenfolge nicht leer ist, und natürlich nur eine Zeile.

Hier sind einige weitere Beispiele, gefolgt von 1 (wahr), wenn sie verbunden sind, oder 0 (falsch), wenn nicht:

__/‾‾\/\_/‾
1

_
1

\
1

/
1

‾
1

___
1

\/
1

/\/
1

/\/\
1

‾‾‾
1

\\
0

‾‾
1

_‾
0

‾_
0

\_____/
1

\/\\/\\___
0

\/\__/‾‾\
1

______/\_____
1

‾‾‾‾‾‾\\_____
0

‾‾‾‾‾‾\______
1

_____/‾‾‾‾‾
1

\___/‾‾‾\___/‾‾‾
1

\_/_\_
0

\_/\_
1

/\/\/\/\/\/\/\/\/\/\/\/
1

____________________
1

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
1

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾/
0

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\
1

/\‾/\‾___/\_\/__\/\‾‾
0

Der kürzeste Code ist der Gewinner.


37
Willkommen bei PPCG! Schöne erste Herausforderung.
AdmBorkBork

1
Sind die in Ihrer Challenge angegebenen Zeichen die einzigen, die in der Zeichenfolge erscheinen?
Verkörperung der Ignoranz

@EmbodimentofIgnorance Ja, nur die 4.
Diskrete Spiele

30
Warten Sie, Sie könnten eine Sprache daraus machen
Delioth

2
@Arnauld Nein, ich denke wirklich nur, dass Wahres für Verbundenes und Falsches für Unverbundenes gilt. (Es sei denn, ein Swap ist für diese Art von Frage normal?)
Diskrete Spiele

Antworten:


34

Gelee , 9 Bytes

-1 Byte dank @EriktheOutgolfer

Erwarten ~statt . Gibt 0 oder 1 .

O*Ɲ:⁽8ƇḂẠ

Probieren Sie es online! , Wahrheitstestsuite , Falsche Testsuite

Mit dieser Formel (aber ansonsten ähnlich der 11-Byte-Version unten):

n=xy15145

Der Übergang ist gültig, wenn n ungerade ist, oder ungültig, wenn n ist.

Kommentiert

O*Ɲ:⁽8ƇḂẠ     - main link, taking a string          e.g. "\_/"
O             - get ASCII codes                     -->  [92, 95, 47]
 *Ɲ           - exponentiation on all pairs         -->  [92**95, 95**47]
   :⁽8Ƈ       - integer division by 15145           -->  [23964828…8421, 59257069…0485]
       Ḃ      - least significant bit (i.e. parity) -->  [1, 1]
        Ạ     - all values equal to 1?              -->  1

Jelly ,  14 12  11 Bytes

Unterstützt (und erwartet) das Zeichen in der Eingabezeichenfolge. Gibt 0 oder 1 .

O*Ɲ%276%7ỊẠ

Probieren Sie es online! , Wahrheitstestsuite , Falsche Testsuite

Wie?

Bei zwei aufeinanderfolgenden Zeichen der ASCII-Codes x und y wollen wir eine Funktion, die prüft, ob sie einen gültigen Übergang bilden.

Wir benötigen eine nicht kommutative Operation, da sich das Ergebnis ändern kann, wenn die Zeichen vertauscht werden. Zum Beispiel _/ist gültig, aber /_nicht.

Unter Verwendung der Potenzierung ist eine mögliche Formel 1 :

n=(xymod276)mod7

Der Übergang ist gültig, wenn n1 , oder ungültig, wenn n>1 .

 chars |    x |    y | (x**y)%276 | %7 | valid
-------+------+------+------------+----+-------
   __  |   95 |   95 |      71    |  1 |  yes
   _/  |   95 |   47 |     119    |  0 |  yes
   _‾  |   95 | 8254 |     265    |  6 |   no
   _\  |   95 |   92 |     265    |  6 |   no
   /_  |   47 |   95 |      47    |  5 |   no
   //  |   47 |   47 |      47    |  5 |   no
   /‾  |   47 | 8254 |       1    |  1 |  yes
   /\  |   47 |   92 |       1    |  1 |  yes
   ‾_  | 8254 |   95 |     136    |  3 |   no
   ‾/  | 8254 |   47 |      88    |  4 |   no
   ‾‾  | 8254 | 8254 |     196    |  0 |  yes
   ‾\  | 8254 |   92 |     196    |  0 |  yes
   \_  |   92 |   95 |      92    |  1 |  yes
   \/  |   92 |   47 |      92    |  1 |  yes
   \‾  |   92 | 8254 |     184    |  2 |   no
   \\  |   92 |   92 |     184    |  2 |   no

1. Gefunden mit einer Brute-Force-Suche in Node.js (unter Verwendung von BigInts)

Kommentiert

O*Ɲ%276%7ỊẠ   - main link, taking a string          e.g. "\_/"
O             - get ASCII codes                     -->  [92, 95, 47]
 *Ɲ           - exponentiation on all pairs         -->  [92**95, 95**47]
   %276       - modulo 276                          -->  [92, 119]
       %7     - modulo 7                            -->  [1, 0]
         Ị    - ≤1?                                 -->  [1, 1]
          Ạ   - all values equal to 1?              -->  1

2
Die Nachschlagetabellenmethode hat so manche Probleme gelöst
qwr

9 Bytes : ⁽"Oist das Gleiche wie 9580.
Erik der Outgolfer

@EriktheOutgolfer Danke. :) Vielleicht sollte das Skript in diesem Tipp aktualisiert werden, um dieses Format zu unterstützen (wenn es relevant ist).
Arnauld

1
@Arnauld Eigentlich hat, Jonathan Allan machte dies .
Erik der Outgolfer

16

Ruby -n , 30 Bytes

p !/[_\\][\\‾]|[\/‾][_\/]/

Probieren Sie es online!

Reduziert alle Zeichenfolgen mit Regex-Zeichenklassen auf zwei Fälle.


5
Sie können 4 Bytes sparen, indem Sie ~anstelle von verwenden . Ich bin mir nicht sicher, ob es für diese Herausforderung wichtig ist, da die Anzahl der Charaktere gleich ist.
iamnotmaynard

Müssen Sie die /s entkommen , obwohl sie in eckigen Klammern stehen?
Solomon Ucko

14

JavaScript (ES6), 45 Byte

Der naive Weg.

s=>!/\/\/|\\\\|_~|~_|~\/|_\\|\/_|\\~/.test(s)

Probieren Sie es online!


1
Dies überprüft also alle ungültigen Paarungen und stellt sicher, dass sie nicht in der Zeichenfolge vorhanden sind. Clever.
Diskrete Spiele

@ DiscreteGames Ja, genau. (Außer dass ich 2 von ihnen vergessen habe. Jetzt behoben.)
Arnauld

35 Bytes s=>!/[~\/][\/_]|[_\\][\\~]/.test(s). Es prüft ob \/oder ~endet in \/oder _. Und dann prüft es, ob \\oder _endet in \\oder ~.
Ismael Miguel

@IsmaelMiguel Dies könnte als separate Antwort veröffentlicht werden, aber ich lasse dies lieber als Referenz unverändert, da es den einfachsten (wie in "am wenigsten komplizierten") regulären Ausdruck zeigt, der das Problem löst.
Arnauld

Sie können es als alternative, aber nicht endgültige Antwort posten.
Ismael Miguel

10

R , 89 87 81 78 Bytes

-2 Bytes dank @Giuseppe

-6 Bytes dank @Nick Kennedy

-3 Bytes ersetzen 1:length(y)durch seq(a=y), wobei adie Abkürzung für stehtalong.with

y=utf8ToInt(scan(,''));all(!diff(cumprod(c(1,y>93)*2-1)[seq(a=y)]*(y%%2*2-1)))

verwendet \ / _ ~. Dies ist wahrscheinlich nicht so kurz wie eine auf Regex basierende Lösung, aber ich wollte etwas tun, das sich von allen anderen unterscheidet.

utf8ToInt('\\/_~')
# [1]  92  47  95 126

Die Zeichen unter 93 wechseln den Status von oben nach unten (oder umgekehrt) und verhalten sich als solche, -1während die anderen nichts tun und sich als 1solche verhalten . Cumprod verfolgt den Status in Bezug auf den Start. Die geraden Zahlen befinden sich in einem Aufwärtszustand (dargestellt mit -1), die ungeraden Zahlen in einem Abwärtszustand ( 1). Wenn die Zeichenfolge ungebrochen ist, sollte sich der Verfolgungsstatus multipliziert mit der Auf- / Ab-Position nicht ändern. Dies ist immer die Startbedingung ( -1, oder 1).

Probieren Sie es online aus


2
Das ist ziemlich clever und eine einzigartige Art, Dinge zu tun! Ich glaube, Sie können das ()um entfernen y%%2, um 2 Bytes zu sparen, da die speziellen Operatoren %(any)%eine ziemlich hohe Priorität haben.
Giuseppe

3
Wie wäre es mit tio für 83 Bytes? !
Nick Kennedy

9

Python , 46 Bytes

f=lambda s:s==''or s[:2]in"__/~~\/\_"*f(s[1:])

Probieren Sie es online!

__/~~\/\_23=8

Ich habe andere weniger einfache Methoden zum Überprüfen von Zeichenpaaren ausprobiert, aber sie waren alle länger als das Hardcodieren aller zulässigen Paare wie dieses.



6

Chip -z , 17 Bytes

FZ!C~aS
A}^]--^~t

Probieren Sie es online! (TIO enthält -v, um das Verständnis der Ausgabe zu erleichtern.)

Erwartet das _/~\Set. Gibt entweder \x00(falsch) oder \x01(wahr) zurück.

Die Strategie für meine Antwort verwendet die folgenden Informationen:

Symbol  Binary
   _    0101 1111
   /    0010 1111
   ~    0111 1110
   \    0101 1100
          ^   ^ ^
        HGFE DCBA

A: Diese Bitposition ist zufällig, 1wenn die linke Seite des Symbols niedrig ist, und 0wenn sie hoch ist
F: Diese Bitposition ist zufällig, 0wenn die rechte Seite des Symbols niedrig ist, und 1wenn sie hoch ist
C: Diese Bitposition ist zufällig sei immer1

Anhand dieser Informationen muss ich nur überprüfen, ob die FZeichen der einzelnen Zeichen mit denen not Ader nächsten übereinstimmen . Ein xorTor ist ein bequemer Weg, um dies zu erreichen.

Der folgende Code erledigt dies, gibt jedoch für jede Kopplung eine Ausgabe aus (plus eine zusätzliche 1am Anfang) (7 Bytes):

FZ!
A}a

Wir möchten beim ersten Fehler anhalten und auch ausgeben, ob wir in der Zeichenfolge angehalten haben, oder am Nullterminator (wir fügen hinzu -z, um uns einen Nullterminator zu geben). Wir können not Cangeben, wo wir aufgehört haben, und das gibt uns dieses Programm (13 Bytes):

FZ!C~a
A}^]~t

Wir haben aber immer noch "führende Nullen" (zB \_/\gibt 00 00 00 00 01), so dass dies in die oben angegebene Antwort umgewandelt wird.


Schön, ich hatte dieses Muster bemerkt, aber keine gute Sprache, um es auszunutzen.
Histokrat

6

05AB1E , 29 14 9 Bytes

ÇümŽb‘÷ÈP

Antwort von Port of @Arnauld 's Jelly , also stelle sicher, dass du ihn auch positiv bewertest!

Eingabe mit .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .


Ursprüngliche 29- Byte- Antwort:

„_~SD2×s:Çü-т+•6_üê{↕ƵΔвåO_

Eingabe mit ~statt .

In meinem Kopf klang es kürzer. Ich werde versuchen, es von hier aus nach unten zu spielen.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung: "

_~S                          # Push the characters ["_","~"]
    D2×                       # Duplicate it, and increase each to size 2: ["__","~~"]
       s:                     # Swap and replace all "__" with "_" and all "~~" with "~"
                              #  in the (implicit) input-string
         Ç                    # Convert the remaining characters to unicode values
          ü-                  # Calculate the difference between each pair
            т+                # Add 100 to each
              6_üê{↕       # Push compressed integer 1781179816800959
                       ƵΔ     # Push compressed integer 180
                         в    # Convert the larger integer to Base-180 as list: 
                              #  [52,66,69,100,103,131,179]
                          å   # Check for each if it's in the difference-list
                              # (1 if present; 0 if not)
                           O  # Sum the truthy values
                            _ # Check if this sum is exactly 0 (1 if 0; 0 otherwise)
                              # (and output this result implicitly)

Sehen Sie diese 05AB1E Spitze von mir (Abschnitte Wie groß ganzen Zahlen comrpess? Und Wie integer Listen komprimieren? ) Zu verstehen , warum •6_üê{↕ist 1781179816800959, ƵΔist 180und •6_üê{↕ƵΔвist[52,66,69,100,103,131,179] .

Zusätzliche Erklärung:

24 diese Unterschiede . Da komprimierte Ganzzahllisten in 05AB1E nur positive Ganzzahlen enthalten müssen, addiere ich jeweils 100 . Die ungültigen Paare und ihre entsprechenden Werte sind dann ["/_", 52]:; ["\~", 66], ["_~", 69], ["//", 100], ["\\", 100], ["_\", 103], ["~_", 131], ["~/", 179], Weshalb ich die komprimierte integer Liste in meinem Code enthält diese Werte haben.
Da __und ~~genauso gut gefällt //und \\ergibt 0(oder 100nachdem ich 100 addiert habe), entferne ich zuerst alle angrenzenden Duplikate von~und _ in der Eingabezeichenfolge, bevor die Paardifferenzen berechnet und überprüft werden.


1
Jetzt 9 Bytes .
Arnauld

@ Arnauld Oh schön!
Kevin Cruijssen

Diese Erklärung würde als Zeichenfolge funktionieren.
connectyourcharger

@connectyourcharger Was meinst du?
Kevin Cruijssen

6

Python 3 , 79 70 63 Bytes

Dank Arnauld und Jo King 16 Byte gespeichert, danke!

p=lambda s:len(s)<2or((ord(s[-2])%13>5)^ord(s[-1])%2)&p(s[:-1])

Probieren Sie es online!

Python 3 , 67 60 Bytes mit ~ anstelle von ‾

p=lambda s:len(s)<2or(~(ord(s[-2])//7^ord(s[-1]))&p(s[:-1]))

Probieren Sie es online!


2
Schöne erste Antwort! Sie können 6 Bytes einsparen, indem Sie Leerzeichen entfernen. (Vielleicht möchten Sie einen TIO-Link hinzufügen, übrigens.)
Arnauld

1
Danke! Ich genieße es, all diese Tricks zu lernen
Joachim Worthington,

4

Python 3, 126 Bytes

lambda s,d={'‾':'\‾','_':'/_','/':'\‾','\\':'/_'}:len(s)<2or all([s[i+1] in d[s[i]]for i in range(len(s)-1)if s[i]in d])

4

Haskell , 70 Bytes

Diese Variante verwendet ~anstelle von Überstrichen. Es nimmt alle acht gültigen Paare und prüft, ob der String nur diese enthält:

f(a:b:x)=[a,b]`elem`words"__ _/ /~ ~~ ~\\ \\_ \\/ /\\"&&f(b:x)
f _=1>0

Probieren Sie es online!

Ungolfed:

validate :: String -> Bool
validate xs = all valid $ zip xs (tail xs)
  where
    valid (a,b) = [a,b] `elem` starts
    starts      = words "__ _/ /~ ~~ ~\\ \\_ \\/ /\\"

4

Perl 6 , 32 Bytes

{!/< \\\ \~ ~/ // _~ ~_ _\ /_>/}

Probieren Sie es online!

Eine Regex-Lösung, die einfach überprüft, ob die Zeichenfolge keine ungültigen Sequenzen enthält.

Erläuterung:

{                              }   # Anonymous code block
  /<                         >/    # Find the longest sequence from
     \\\                           # \\
         \~                        # \‾
            ~/                     # ‾/
               //                  # //
                  _~               # _‾
                     ~_            # ‾_
                        _\         # _\
                           /_      # /_
 !                                 # And logically negate the match

4

R , 43 Zeichen, 47 Bytes

Es ist derselbe reguläre Ausdruck, den die anderen Antworten verwenden, aber für R angepasst.

!grepl('[/‾][/_]|[\\\\_][\\\\‾]',scan(,''))

Probieren Sie es online!

Und obligatorische xkcd .


1
Sie können ~anstelle von 43 Bytes 43 Zeichen verwenden.
Giuseppe

2
Stimmt, aber es macht mehr Spaß mit der Overbar. :)
CT Hall

4

Viertens (gviertens) , 100 bis 98 Bytes

: x = swap '~ = + ;
: f 1 tuck ?do over i + >r i 1- c@ r> c@ dup 92 x swap dup 47 x <> + loop 0> ;

Probieren Sie es online!

Erläuterung

Gehen Sie die Zeichenfolge durch und stellen Sie fest, ob jedes Zeichen an derselben Position (oben oder unten) beginnt, an der es endet. Subtrahieren Sie 1 von einem Zähler, wenn sie nicht übereinstimmen. Wenn sich der Zähler am Ende geändert hat, ist die Zeichenfolge keine Zeichenfolge.

Die Endposition ist hoch, wenn char /(47) oder ~(126) ist. Ansonsten ist es niedrig

Die Startposition ist hoch, wenn char \(92) oder ~(126) ist. Ansonsten ist es niedrig

Code-Erklärung

\ x is basically just extracting some common logic out into a function to save a few bytes
\ it checks if the first number is equal to the second number
\ or the third number is equal to 126   
: x                \ start a new word definition
  = swap           \ check if the first two numbers are equal then swap with the third
  '~ =             \ checks if the third number is equal to 126
  +                \ adds results together (cheaper version of or)
;                  \ end the word definition

: f                \ start a new word definition
  1 tuck           \ set up parameters for a loop (and create a bool/counter)
  ?do              \ start counted loop from 1 to string-length -1, 
                   \ ?do will skip if loop start and end are the same
    over i +       \ copy the string address and add the loop index to get the char address
    >r i           \ place char address on return stack and place a copy back on the stack
    1- c@          \ subtract 1 to get previous char address and grab ascii from memory
    r> c@          \ move char address back from return stack, then grab from memory
    dup 92 x       \ get the "output" position of the prev character
    swap dup 47 x  \ get the input position of the current character
    <> +           \ check if they aren't equal and add the result to the counter
                   \ the counter won't change if they're equal
  loop             \ end the loop
  0>               \ check if counter is less than 1 (any of the "links" was not valid)
;                  \ end word definition

3

Python 3 , 80 78 Bytes

Ich mache nicht wirklich viele Python-Code-Golfspiele, aber ich dachte, ich könnte es versuchen

  • -2 Bytes: realisiert nicht (any ()) ist das Gleiche wie alle (not ()) und könnte die not in den r-String verschieben
def f(x):*l,=map(r'_/\~'.find,x);return 1-any((i^j//2)%2for i,j in zip(l,l[1:]))

Probieren Sie es online!

Python 3.8 (Vorabversion) , 71 Byte

Ich wollte die neue :=Ausdruckszuweisung ausprobieren

lambda x:all((i^j//2)%2for i,j in zip(l:=[*map(r'\~_/'.find,x)],l[1:]))

Probieren Sie es online!


3

Jelly ,  13 12  11 Bytes

O*Ɲ%⁽wḃ%5ỊẠ

Ein monadischer Link, der eine Liste von Zeichen akzeptiert, verwendet die Option ~anstelle von .

Probieren Sie es online! Oder sehen Sie sich eine Testsuite an (... in der ich die 8 Falseys am Ende nachbestellt habe)

Diese Formel wurde gefunden, indem man mit der Hand herumfummelte: p (wie auch die folgenden)

Auch für dieses habe ich alle 16 Paare von Zeichenordnungszahlen als Potenzierung behandelt und nach einem großen Modulo gesucht, das in drei Bytes passt, gefolgt von einem Ein-Byte-Modulo (1,2,3,4,5,6,7,8 , 9,10,16,256), die die 16 so aufteilten, dass alle akzeptablen Ergebnisse entweder 1 oder 0 waren ("unbedeutend"), da ich weiß, dass sie kürzer sind als <5bei meiner vorherigen Lösung, bei der alle akzeptablen Ergebnisse kleiner als waren alle inakzeptabel.

O*Ɲ%⁽wḃ%5ỊẠ - Link: list of characters
O           - ordinals
  Ɲ         - for each pair of neighbours:
 *          -   exponentiate
    ⁽wḃ     - 30982
   %        - modulo (vectorises)
        5   - five
       %    - modulo (vectorises)
         Ị  - insignificant? (abs(x) <=1) (vectorises)
          Ạ - all truthy?

Die möglichen Nachbarzeichen und ihre internen Auswertungen:

(Ɲ)         (O)            (*%⁽wḃ)        (%5)      (Ị)
pair   a,b=ordinals   c=exp(a,b)%30982   d=c%5   abs(d)<=1
__       95,  95         28471             1         1
_/       95,  47         29591             1         1
/~       47, 126         19335             0         1
/\       47,  92          9755             0         1
~~      126, 126         28000             0         1
~\      126,  92         26740             0         1
\_       92,  95          9220             0         1
\/       92,  47         13280             0         1
~_      126,  95          3024             4         0
~/      126,  47         12698             3         0
\~       92, 126         27084             4         0
\\       92,  92         17088             3         0
_~       95, 126         28169             4         0
_\       95,  92          4993             3         0
/_       47,  95         22767             2         0
//       47,  47          7857             2         0

Vorherige @ 12:

O*Ɲ%⁽?K%⁴<8Ạ

Probieren Sie es online!


Vorherige @ 13:

O%7ḅ6$Ɲ%⁵%8ỊẠ

Probieren Sie es online!


Aus irgendeinem Grund dachte ich, das wäre eher ein Test abs(x)<1als ein Test abs(x)≤1. Dies bietet noch einige weitere Möglichkeiten. :) (Ich stecke aber momentan auch bei 11 Bytes fest.)
Arnauld,

Ich finde, dass das sehr oft nützlich ist.
Jonathan Allan


3

Excel, 150 Bytes

=SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A1,"_\",),"_‾",),"‾_",),"‾/",),"/_",),"//",),"\‾",),"\\",)=A1

Entfernt ungültige Paare und gibt dann zurück, truewenn dies zur ursprünglichen Zeichenfolge führt.


3

Haskell, 42 Bytes

g=tail>>=zip
h=all(`elem`g"__/~~\\/\\_").g

Diese Lösung verwendet ~, und die Funktion zum Aufrufen ist h (dh h stringgibt die Antwort)

Die Lösung verwendet eine Funktion g, die bei einer gegebenen Liste alle Tupel benachbarter Werte in der Liste zurückgibt.

Dann erzeugen wir mit g die Liste der erlaubten Nachbarn (in g"__/~~\\/\\_") und auch die Liste aller benachbarten Paare in der Eingabeliste. Dann prüfen wir, ob jedes benachbarte Paar ein erlaubtes Paar ist.


3

C (GCC) , 41 36 Bytes

f(char*_){_=!_[1]||*_/32+*++_&f(_);}

Probieren Sie es online!

-5 beseitigt aufgrund &1einer Idee von Peter Cordes ; Operatoren geändert (Vorrang), um Klammern zu entfernen


Verwendet ~. Überprüft das erste und sechste Bit der Binärdarstellungen der ersten beiden Zeichen:

_ 1011111
\ 1011100
/  101111
~ 1111110
   ^    ^

und durchläuft die Zeichenfolge rekursiv.

(*_ / 32) & 1gilt nur für Zeichen, die hoch enden, während *_ & 1dies nur für Zeichen gilt, die niedrig beginnen. (x&1) ^ (y&1) == (x+y)&1. XOR ist Add-without-Carry und Carry stört nicht das niedrigste Bit. Das 1kommt vom f(_)Rückgabewert, wenn der Rest der Zeichenkette stringy war.


Wenn Sie um 5 nach rechts verschieben, wird das 6. Bit unten angezeigt. Sie überprüfen also die Bits 0 und 5 oder das erste und das sechste Bit. (Dies ist ein wirklich schöner Trick, übrigens, gut gemacht. Dies c&32gilt für Zeichen, die hoch enden, während c&1dies nur für Zeichen gilt, die niedrig beginnen.)
Peter Cordes

Ich weiß, dass die Regeln es nur erfordern, an mindestens einer Implementierung zu arbeiten, aber es ist trotzdem erwähnenswert, dass *_ ^ *++_es sich um ein undefiniertes Verhalten handelt: Es ^handelt sich nicht um einen Sequenzpunkt, daher gibt es keine Vorher-Sequenz-Beziehung, die garantiert, dass sie unterschiedliche Zeichen erhalten. Natürlich fehlt auch ein return, daher funktioniert es nur dort, gcc -O0wo der Funktionskörper ein Anweisungsausdruck ist.
Peter Cordes

Hoppla, Sie haben Recht mit den Bits. Danke, dass
du

1
Doing &1doppelt so groß ist überflüssig. (x^y)&1 == (x&1) ^ (y&1). Aber angesichts C Operatorpräzedenz wo &hat höhere Priorität als ^( im Gegensatz zu arithmetischen Operatoren wobei + und - die gleiche Priorität haben), wir bräuchten hinzufügen ()2 Bytes entfernen &12 Bytes, weil (x&1) ^ ynicht entspricht. Aber vielleicht eröffnet die Verwendung von Parens Möglichkeiten für andere Einsparungen. Zum Glück kein Problem für eine x86-Maschinencode-Version, bei der die Bit-Manipulation sehr kompakt ist ...
Peter Cordes

Beendet meine x86-Maschinencode-Antwort , 13 Bytes mit diesem Algorithmus.
Peter Cordes

2

Bash, 30 Bytes

grep -E '//|\\\\|_~|~_|~/|_\\|/_|\\~'

Die Eingabe ist STDIN. Der Beendigungscode ist 1, wenn er gültig ist, und 0, wenn er ungültig ist.



1

Kohle , 32 18 Bytes

⌊⭆θ∨¬κ⁼№_/ι№\_§θ⊖κ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

  θ                 Input string
 ⭆                  Map over characters and convert to string
     κ              Current index
    ¬               Logical Not (i.e. is zero)
   ∨                Logical Or
          ι         Current character
       №            Count (i.e. contained in)
        _/          Literal _/ (i.e. begins at bottom)
      ⁼             Equals
               θ    Input string
              §     Indexed by
                 κ  Current index
                ⊖   Decremented (i.e. previous character)
           №        Count (i.e. contained in)
            \_      Literal \_ (i.e. ended at bottom)
⌊                   Minimum (i.e. if all true)
                    Implicitly print

1

x86-Maschinencode, 13 Byte.

(Oder 11 Bytes, ohne einzelne Zeichenfolgen zu verarbeiten, die trivial stringy sind.)

Verwendet die Bitpositionsprüfung aus der C-Antwort von @ attinat

Der gleiche Maschinencode funktioniert im 16-, 32- und 64-Bit-Modus. Die Quelle ist NASM für den 64-Bit-Modus.

nasm -felf64 -l/dev/stdout  listing
    17   addr                  global string_connected
    18           code          string_connected:
    19           bytes         ;;; input: char *RSI, transitions to check=RCX
    20                         ;;; output: AL=non-zero => connected.  AL=zero disconnected
    21                         .loop:                      ; do {
    22 00000000 AC                 lodsb                   ;   al = *p++
    23 00000001 E309               jrcxz  .early_exit        ; transitions=0 special case.  Checking before the loop would require extra code to set AL.
    24 00000003 C0E805             shr    al, 5
    25 00000006 3206               xor    al, [rsi]          ; compare with next char
    26 00000008 2401               and    al, 1
    27 0000000A E0F4               loopne .loop            ; }while(--rcx && al&1);
    28                         .early_exit:
    29 0000000C C3                 ret

Aufrufbar von C wie unsigned char string_connected(int dummy_rdi, const char *s, int dummy_rdx, size_t transitions);bei der x86-64-System-V-Aufrufkonvention. Nicht, boolweil die Übergänge = 0 einen ASCII-Code zurückgeben, nicht 1.

RCX = len = strlen(s) - 1. dh die Anzahl der Zeichengrenzen = Übergänge zum Einchecken der Zeichenfolge mit expliziter Länge.

Für transitions > 0gibt 0 (nicht übereinstimmend) oder 1 (verbunden) zurück und lässt ZF entsprechend gesetzt. For transitions == 0gibt das einzelne Byte der Zeichenfolge zurück (das nicht Null ist und daher auch wahr ist). Wenn dies nicht der Fall wäre, könnten wir den JRCXZ-Early-Exit fallen lassen. Es ist nur innerhalb der Schleife, weil AL dort ungleich Null ist.


Die Bitpositionslogik basiert auf der Beobachtung, dass Bit 0 des ASCII-Codes die Starthöhe und Bit 5 die Endhöhe angibt.

;;;  _ 1011111
;;;  \ 1011100
;;;  /  101111
;;;  ~ 1111110
;;;     ^    ^

    ; end condition (c>>5) & 1 =>  0 = low
    ; start cond: c&1 => 0 = high
    ; (prev>>5)&1 == curr&1  means we have a discontinuity
    ; ((prev>>5) ^ curr) & 1 == 0  means we have a discontinuity

Testkabelbaum (modifiziert von attinats TIO-Link, achten Sie auf den C-Sequenzpunkt UB in dieser C-Referenzfunktion). Probieren Sie es online! . Diese Funktion ist für alle 30 Fälle korrekt. (Einschließlich der Einzelzeichenfälle, in denen der Rückgabewert nicht übereinstimmt: In diesem Fall sind beide mit unterschiedlichen Werten ungleich Null wahr.)


1

Excel, 79 Bytes

Zelle A1als Eingabe

=1---SUMPRODUCT(--ISNUMBER(FIND({"//","/_","\~","\\","~/","~_","_\","_~"},A1)))


0

C ++, 132 110 Bytes

-22 Bytes nur dank ASCII

int f(char*s){int t[128];t[95]=0;t[47]=1;t[92]=2;t[126]=3;for(;*++s;)if(t[s[-1]]%2^t[*s]/2)return 0;return 1;}

Verwendet eine Bitmaske, um festzustellen, ob Anfang und Ende nach oben oder unten zeigen


hmm. Wäre die Portierung der C-Version nicht golfer: P
Nur ASCII




0

Regex, 34 Bytes

Ich konnte keine Regeln für die Verwendung von Regex als Sprache finden. Bitte lassen Sie mich wissen, wenn ich dies anpassen muss.

^(‾+|(‾*\\)?(_*\/‾*\\)*_*(\/‾*)?)$

Versuchen Sie es hier: https://regex101.com/r/s9kyPm/1/tests


2
Das sind 34 Bytes, nicht 24, oder?
Sara J

Nun, wirklich 42 Bytes, aber Sie können zu~
Jo King

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.