Cette chaîne fonctionnerait-elle en tant que chaîne?

92

Ecrivez un programme qui prend une seule ligne que vous pouvez supposer ne contiendra que les caractères /\_‾. (Il s'agit de barres obliques, soulignées et surlignées en avant et en arrière . Vous pouvez utiliser le ~surlignage si vous en avez besoin, car le surlignage n'est pas pratique en ASCII.)

Par exemple, une entrée possible est:

__/‾‾\/\_/‾

Votre programme doit générer une valeur de vérité ou de fausseté selon que le bord gauche de la chaîne est "connecté", pour ainsi dire, au bord droit de la chaîne via les lignes des caractères. Donc, si le crénage était un peu moins, il y aurait une ligne noire continue (du moins crépue) du bord gauche au droit, comme un morceau de ficelle ou de ficelle ininterrompu.

La sortie pour l'exemple ci-dessus serait vraie car les bords sont connectés:

exemple de chemin

Pour être clair sur les connexions:

  • / se connecte en bas à gauche et en haut à droite
  • \ se connecte en haut à gauche et en bas à droite
  • _ se connecte en bas à gauche et en bas à droite
  • (ou ~) se connecte en haut à gauche et en haut à droite

Aussi:

  • Peu importe que les bords de la chaîne commencent en haut ou en bas, il importe simplement qu'ils se connectent horizontalement sur toute la longueur de la chaîne.

  • Vous pouvez supposer que la chaîne d'entrée est non vide et, bien entendu, sur une seule ligne.

Voici d'autres exemples suivis de 1 (vérité) s'ils sont connectés ou de 0 (falsie) sinon:

__/‾‾\/\_/‾
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

Le code le plus court est le gagnant.

Jeux discrets
la source
37
Bienvenue chez PPCG! Beau premier défi.
AdmBorkBork
1
Les caractères spécifiés dans votre défi sont-ils les seuls à apparaître dans la chaîne?
Incarnation de l'Ignorance
@EmbodimentofIgnorance Oui, seulement les 4.
Discrete Games
30
Attendez, vous pourriez en faire une langue
Delioth
2
@Arnauld Non, je ne pense vraiment que vérité pour connecté et fausseté pour non connecté. (Sauf si autoriser un échange est normal pour ce genre de question?)
Discrete Games

Réponses:

34

Gelée , 9 octets

-1 octet grâce à @EriktheOutgolfer

Attendez-vous ~au lieu de . Retourne ou .01

O*Ɲ:⁽8ƇḂẠ

Essayez-le en ligne! , Suite de tests Truthy , suite de tests Falsy

En utilisant cette formule (mais similaire à la version 11 octets ci-dessous):

n=Xy15145

La transition est valide si est impair ou invalide si est pair.nn

Commenté

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 octets

Prend en charge (et attend) le caractère dans la chaîne d'entrée. Retourne ou .01

O*Ɲ%276%7ỊẠ

Essayez-le en ligne! , Suite de tests Truthy , suite de tests Falsy

Comment?

Étant donné deux caractères consécutifs des codes ASCII et , nous voulons une fonction qui vérifie s’ils forment une transition valide.Xy

Nous avons besoin d'une opération non commutative, car le résultat peut changer lorsque les caractères sont inversés. Par exemple, _/est valide mais /_ne l’est pas.

En utilisant exponentiation, une formule possible 1 est:

n=(Xymod276)modsept

La transition est valide si , ou invalide si .n1n>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. Trouvé avec une recherche par force brute dans Node.js (en utilisant BigInts)

Commenté

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
Arnauld
la source
2
méthode de la table de correspondance a remporté de nombreux problèmes
qwr
9 octets : ⁽"Oest identique à 9580.
Erik l'Outgolfer
@EriktheOutgolfer Merci. :) Peut-être que le script fourni dans cette astuce devrait être mis à jour pour prendre en charge ce format (le cas échéant).
Arnauld
1
@Arnauld En fait, Jonathan Allan a fait cela .
Erik l'Outgolfer
16

Ruby -n , 30 octets

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

Essayez-le en ligne!

Réduit toutes les séquences de rupture de chaîne à deux cas en utilisant les classes de caractères Regex.

histocrate
la source
5
Vous pouvez économiser 4 octets en utilisant à la ~place de . Je ne sais pas si cela compte pour ce défi, car le nombre de personnages est le même.
iamnotmaynard
Avez-vous besoin d’échapper au /s alors qu’ils sont entre crochets?
Solomon Ucko
14

JavaScript (ES6), 45 octets

La manière naïve.

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

Essayez-le en ligne!

Arnauld
la source
1
Donc, cela vérifie toutes les paires non valides, en s'assurant qu'elles n'existent pas dans la chaîne? Intelligent.
Discrete Games
@ DiscreteGames Oui, exactement. (Sauf que j'en ai oublié 2. Maintenant corrigé.)
Arnauld
35 octets: s=>!/[~\/][\/_]|[_\\][\\~]/.test(s). Il vérifie si \/ou se ~termine par \/ou _. Et puis, il vérifie si \\ou se _termine dans \\ou ~.
Ismael Miguel
@IsmaelMiguel Ceci peut être posté séparément, mais je préférerais laisser celui-ci inchangé pour référence, car il montre l'expression régulière la plus simple (comme dans «moins compliquée») qui résout le problème.
Arnauld
Vous pouvez l'afficher comme alternative, mais pas de réponse définitive.
Ismael Miguel
10

R , 89 87 81 78 octets

-2 octets grâce à @ Giuseppe

-6 octets grâce à @Nick Kennedy

-3 octets remplaçant 1:length(y)par seq(a=y), où aest un raccourci pouralong.with

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

utilise \ / _ ~. Ce n’est probablement pas aussi bref qu’une solution basée sur l’expression régulière, mais j’ai envie de faire quelque chose de différent de tout le monde.

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

Les personnages de moins de 93 commutent l’état de haut en bas (ou inversement) et se comportent comme tels -1tandis que les autres ne font rien et se comportent comme 1, cumprod suit l’état par rapport au début. Les nombres pairs sont dans un état de nord (représenté par -1), les nombres impairs sont à l'état bas ( 1). Si la chaîne n'est pas interrompue, l'état de suivi multiplié par la position haut / bas, ne doit pas changer, ce sera toujours la condition de départ ( -1, ou 1)

Essayez-le en ligne

Aaron Hayman
la source
2
c'est assez intelligent, et une façon unique de faire les choses! Je pense que vous pouvez supprimer les ()environs y%%2pour économiser 2 octets, car les opérateurs spéciaux %(any)%ont une priorité assez élevée.
Giuseppe
3
Que diriez-vous de tio pour 83 octets? Profite de la contrainte implicite à la logique par!
Nick Kennedy
9

Python , 46 octets

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

Essayez-le en ligne!

Confirme que chaque paire de caractères adjacents se connecte en vérifiant qu'ils apparaissent consécutivement dans __/~~\/\_. Cette chaîne peut être vue comme une séquence De_Bruijn_n sur les triplets de positions haute / basse.23=8

J'ai essayé d'autres méthodes moins banales pour vérifier les paires de caractères, mais elles étaient toutes plus longues que le codage en dur de toutes les paires légales comme celle-ci.

Xnor
la source
8

C (gcc) , 93 octets

w,o,r;k(char*_){for(r=0;w=*_,o=*++_;)r|=w-126&&w>47?w-95&&w-92?0:o>47&&o-95:o-92&&o<126;_=r;}

Essayez-le en ligne!

Jonathan Frech
la source
3
J'apprécie w,o,r;k.
Esolanging Fruit
6

Puce -z , 17 octets

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

Essayez-le en ligne! (TIO inclut -vpour faciliter la compréhension de la sortie.)

Attend l' _/~\ensemble. Retourne soit \x00(fausseté) ou \x01(vérité).

La stratégie pour ma réponse utilise les informations suivantes:

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

A: Cette position de bit se trouve 1quand le côté gauche du symbole est bas et 0quand il est haut
F: Cette position de bit se trouve 0quand le côté droit du symbole est bas et 1quand il est haut
C: Cette position de bit arrive à toujours être1

En utilisant ces informations, je dois simplement vérifier que le caractère Fde chaque caractère correspond à celui not Adu suivant. Une xorporte est un moyen pratique pour y parvenir.

Le code suivant fait cela, mais donne une sortie pour chaque paire (plus un extra 1au début) (7 octets):

FZ!
A}a

Nous voulons nous arrêter au premier échec, et indiquer également si nous nous sommes arrêtés dans la chaîne ou au terminateur null (nous ajoutons également -zpour nous donner un terminateur nul). Nous pouvons utiliser not Cpour indiquer où nous nous sommes arrêtés, et cela nous donne ce programme (13 octets):

FZ!C~a
A}^]~t

Mais nous avons toujours des "zéros non significatifs" (par exemple, \_/\donne 00 00 00 00 01), ceci est donc transformé en réponse donnée en haut.

Phlarx
la source
Bien, j'avais remarqué ce modèle mais je ne connaissais pas un bon langage pour l'exploiter.
Histocrat
6

05AB1E , 29 14 9 octets

ÇümŽb‘÷ÈP

La réponse du Port of @Arnauld 's Jelly , assurez-vous de l’avoir à son tour revigorée!

Entrée avec .

Essayez-le en ligne ou vérifiez tous les cas de test .


Réponse originale de 29 octets :

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

Entrer avec ~au lieu de .

Cela sonnait plus court dans ma tête .. Je vais essayer de jouer au golf ici.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication: "

_~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)

Voir cette astuce 05AB1E (sections Comment compacter les grands nombres entiers? Et Comment compresser les listes d’entiers? ) Pour comprendre pourquoi •6_üê{↕est 1781179816800959, ƵΔest 180et •6_üê{↕ƵΔвest [52,66,69,100,103,131,179].

Explication supplémentaire:

24["/_", 52]["\~", 66]["_~", 69]["//", 100]["\\", 100]["_\", 103]["~_", 131]["~/", 179]
__~~//\\0100~et _ dans la chaîne d'entrée, avant de calculer et de vérifier les différences de paires.

Kevin Cruijssen
la source
1
Maintenant 9 octets .
Arnauld
@Arnauld Oh gentil!
Kevin Cruijssen
Cette explication fonctionnerait comme une chaîne.
connectyourcharger
@connectyourcharger Que voulez-vous dire?
Kevin Cruijssen
6

Python 3 , 79 70 63 octets

16 octets sauvés grâce à Arnauld et Jo King, merci!

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

Essayez-le en ligne!

Python 3 , 67 60 octets avec ~ au lieu de

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

Essayez-le en ligne!

Joachim Worthington
la source
2
Belle première réponse! Vous pouvez économiser 6 octets en supprimant des espaces. (Vous pouvez ajouter un lien TIO, BTW.)
Arnauld
1
Je vous remercie! J'apprécie apprendre toutes ces astuces
Joachim Worthington
4

Python 3, 126 octets

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])
Henry T
la source
4

Haskell , 70 octets

Cette variante utilise à la ~place des surlignages. Il prend les huit paires valides et vérifie si la chaîne ne contient que celles-ci:

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

Essayez-le en ligne!

Ungolfed:

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

Perl 6 , 32 octets

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

Essayez-le en ligne!

Une solution d'expression régulière qui vérifie simplement que la chaîne ne contient aucune séquence invalide.

Explication:

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

R , 43 caractères, 47 octets

C'est la même chose que les autres réponses utilisent, mais adaptée pour R.

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

Essayez-le en ligne!

Et obligatoire xkcd .

CT Hall
la source
1
vous pouvez utiliser ~à la place de 43 octets, 43 caractères.
Giuseppe
2
C'est vrai, mais c'est plus amusant avec la barre. :)
CT Hall
4

Forth (gforth) , 100 98 octets

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

Essayez-le en ligne!

Explication

Parcourez la chaîne et déterminez si chaque caractère commence à la même position (haut ou bas) que celle qui précède. Soustrayez 1 du compteur s’ils ne correspondent pas. A la fin, si le compteur a changé, la chaîne n'est pas une chaîne.

La position finale est haute si le caractère est /(47) ou ~(126). Sinon c'est bas

La position de départ est haute si le caractère est \(92) ou ~(126). Sinon c'est bas

Explication du code

\ 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
reffu
la source
3

Python 3 , 80 78 octets

Je ne fais pas vraiment beaucoup de golfs avec code python mais je pensais pouvoir essayer

  • -2 octets: réalisé not (any ()) est identique à tout (not ()) et peut déplacer le non dans la chaîne de caractères
def f(x):*l,=map(r'_/\~'.find,x);return 1-any((i^j//2)%2for i,j in zip(l,l[1:]))

Essayez-le en ligne!

Python 3.8 (pré-version) , 71 octets

Je voulais essayer la nouvelle :=tâche d'expression

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

Essayez-le en ligne!

Kroppeb
la source
3

Jelly ,  13 12  11 octets

O*Ɲ%⁽wḃ%5ỊẠ

Un lien monadique acceptant une liste de caractères utilise l' option ~in place of .

Essayez-le en ligne! Ou voir une suite de tests (... où j'ai réorganisé pour placer les 8 falsey à la fin)

Cette formule a été trouvée en jouant à la main: p (comme ceux ci-dessous)

Pour celui-ci, les 16 paires d'ordinaux de personnage sont également traitées comme une exponentiation et recherchent un grand modulo pouvant contenir trois octets, suivi d'un modulo d'un octet (1,2,3,4,5,6,7,8 , 9,10,16,256) qui a divisé le 16 de sorte que tous les résultats acceptables soient 1 ou 0 ("insignifiant"), car je sais qu’elle est plus courte que <5dans ma solution précédente, qui recherchait tous les résultats acceptables inférieurs à tous inacceptables.

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?

Les personnages voisins possibles et leurs évaluations internes:

(Ɲ)         (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

Précédent @ 12:

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

Essayez-le en ligne!


Précédent @ 13:

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

Essayez-le en ligne!

Jonathan Allan
la source
Pour une raison quelconque, je pensais que c'était tester abs(x)<1plutôt que abs(x)≤1. Cela offre encore quelques opportunités. :) (Je suis également bloqué à 11 octets pour le moment.)
Arnauld
Je trouve cela très utile très souvent.
Jonathan Allan
3

perl 5, 26 25 octets

en utilisant ;comme délimiteur, le délimiteur de fin peut être supprimé

$_=!m;[/~][_/]|[\\_][~\\]

TIO

26 octets

Nahuel Fouilleul
la source
3

Excel, 150 octets

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

Supprime toutes les paires non valides, puis renvoie le truerésultat s'il en résulte la chaîne d'origine.

Wernisch
la source
3

Haskell, 42 octets

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

cette solution utilise ~, et la fonction à appeler est h (c'est-à-dire, h stringdonne la réponse)

La solution utilise une fonction g qui donne une liste à tous les nuplets de valeurs adjacentes de la liste.

Ensuite, nous utilisons g pour générer la liste des voisins autorisés (en g"__/~~\\/\\_") ainsi que la liste de toutes les paires voisines de la liste en entrée. Ensuite, nous vérifions que chaque paire voisine est une paire autorisée.

fier haskeller
la source
3

C (gcc) , 41 36 octets

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

Essayez-le en ligne!

-5 éliminé à &1partir d'une idée de Peter Cordes ; opérateurs modifiés (priorité) pour supprimer les parenthèses


Utilise ~. Vérifie les premier et sixième bits des représentations binaires des deux premiers caractères:

_ 1011111
\ 1011100
/  101111
~ 1111110
   ^    ^

et traverse la chaîne récursivement.

(*_ / 32) & 1n'est vrai que pour les caractères qui se terminent haut, alors que ce *_ & 1n'est vrai que pour les caractères qui commencent bas. (x&1) ^ (y&1) == (x+y)&1. XOR est add-without-carry, et carry ne perturbe pas le bit le plus bas. Le 1provient de la f(_)valeur de retour, si le reste de la chaîne était stringy.

attinat
la source
Le décalage à droite de 5 laisse le 6ème bit en bas. Donc, vous vérifiez les bits 0 et 5, ou les premier et sixième bits. (C’est un très bon tour, BTW, bien fait. c&32C’est vrai pour les personnages qui se terminent haut, alors que cela c&1n’est vrai que pour les personnages qui commencent très bas.)
Peter Cordes
Je sais que les règles l’obligent à travailler sur au moins une implémentation, mais il convient néanmoins de signaler qu’il *_ ^ *++_s’agit d’un comportement indéfini: ce ^n’est pas un point de séquence; il n’ya donc aucune relation séquentielle avant garantissant qu’ils obtiennent des caractères différents. Bien sûr, il manque également un return, de sorte que cela ne fonctionne que gcc -O0lorsque le corps de la fonction est une expression de déclaration.
Peter Cordes
Oups, vous avez raison sur les bits. Merci d'avoir attrapé ça
attinat
1
Faire &1deux fois est redondant. (x^y)&1 == (x&1) ^ (y&1). Mais étant donné la priorité de l'opérateur C où la priorité& est supérieure à celle ^(contrairement aux opérateurs arithmétiques où + et - ont la même priorité), il faudrait ajouter ()2 octets pour supprimer &12 octets, car ce (x&1) ^ yn'est pas équivalent. Mais peut-être que l’utilisation de parens ouvre des possibilités d’épargne. Heureusement, ce n'est pas un problème pour une version code-x86 de cette machine, où la manipulation des bits est très compacte ...
Peter Cordes
Terminé ma réponse de code machine x86 , 13 octets en utilisant cet algorithme.
Peter Cordes
2

Bash, 30 octets

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

L'entrée est STDIN. Le code de sortie est 1 si valide, 0 si invalide.

vityavv
la source
1

SNOBOL4 (CSNOBOL4) , 58 octets

	INPUT '/_' | '_\' | '\\' | '//' | '~/' | '\~' @OUTPUT
END

Essayez-le en ligne!

N'émet rien pour truey et un entier positif (indiquant la position de la première rupture dans la chaîne) pour fausseté.

Giuseppe
la source
1

Charbon de bois , 32 à 18 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

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

Code machine x86, 13 octets.

(Ou 11 octets sans gérer les chaînes à caractère unique qui sont trivialement stringentes.)

Utilise le contrôle de position de bit de la réponse C de @ attinat

Le même code machine fonctionne en modes 16, 32 et 64 bits. La source est NASM pour le mode 64 bits.

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

Appelable à partir de C comme unsigned char string_connected(int dummy_rdi, const char *s, int dummy_rdx, size_t transitions);avec la convention d'appel System V x86-64. Non boolparce que le cas de transitions = 0 renvoie un code ASCII, pas 1.

RCX = len = strlen(s) - 1. c'est-à-dire le nombre de limites de caractère = transitions à archiver dans la chaîne de longueur explicite.

For transitions > 0, renvoie 0 (décalage) ou 1 (connecté) et laisse ZF défini en conséquence. Car transitions == 0, renvoie le seul octet de la chaîne (ce qui est différent de zéro et donc également vrai). Sans ce cas particulier, nous pourrions abandonner le JRCXZ à sortie anticipée. C'est à l'intérieur de la boucle uniquement parce qu'AL y est non nul.


La logique de position de bit est basée sur l'observation que le bit 0 du code ASCII vous indique la hauteur de départ et le bit 5, la hauteur de fin.

;;;  _ 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

Faisceau de test (modifié à partir du lien TIO d’attinat, méfiez-vous du UB de séquence C dans cette fonction de référence C). Essayez-le en ligne! . Cette fonction est correcte pour les 30 cas. (Y compris les observations à caractère unique où la valeur renvoyée ne correspond pas: les deux sont la vérité avec différentes valeurs non nulles dans ce cas.)

Peter Cordes
la source
1

Excel, 79 octets

Cellule A1en entrée

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

C ++, 132 110 octets

-22 octets grâce à ASCII uniquement

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;}

Utilise un bitmask pour savoir si le début et la fin sont hauts ou bas

HatsuPointerKun
la source
hmm. le portage de la version C ne serait pas plus golfeur: P
ASCII uniquement
114
ASCII uniquement
110
ASCII uniquement
0

Regex, 34 octets

Je ne pouvais pas trouver de règles sur l'utilisation de Regex en tant que langue. S'il vous plaît laissez-moi savoir si j'ai besoin d'ajuster cela.

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

Essayez-le ici: https://regex101.com/r/s9kyPm/1/tests

Hand-E-Food
la source
2
C'est 34 octets, pas 24, non?
Sara J
Eh bien, vraiment 42 octets, mais vous pouvez changer à~
Jo Roi