Encore un autre défi Jimmy de son père d'origine. Voir ces autres beaux défis .

Comme vous le savez tous, récemment, nous avons vu des défis liés à Jimmy sur les plateformes. Maintenant, Jimmy est un acrobate comme je l'ai mentionné auparavant, et il a d'autres trucs dans sa manche.

L'une de ces astuces est suspendue par des cordes. Voici un exemple d'une corde à laquelle Jimmy pourrait accrocher:

            ||
            ||
            ||
            ||
            ||
            ||

Lorsque Jimmy est suspendu à une corde, cela ressemble à ceci:

            ||
            ||
           /o\
            ||
            ||
            ||

Il peut accrocher à gauche ou à droite de la corde, donc ceci:

            ||
            ||
            ||
            /o\
            ||
            ||

est également valide. Mais il ne peut pas accrocher par une seule partie du corps, donc quelque chose comme ça:

            ||
            ||
            ||
          /o\|
            ||
            ||

est invalide. Notez que lorsqu'il est suspendu par une partie du corps, l'autre moitié de la corde est visible car Jimmy ne la recouvre pas.

De plus, Jimmy n'aime pas être accroché au bas de la corde - cela lui fait peur - alors ceci:

            ||
            ||
            ||
            ||
            ||
            /o\

est invalide.

Le défi

Prenez en compte une situation Jimmy comme celles ci-dessus et indiquez si Jimmy va s'accrocher à la corde ou non grâce à une valeur véridique ou fausse.

Les spécificités

• Écrivez un programme qui accepte des données. Cela peut se faire via une fonction ou toute autre méthode d'entrée appropriée.

  1. L'entrée doit être une scène d'un Jimmy et d'une corde comme illustré ci-dessus.

• Le programme devrait sortir une valeur véridique ou fausse sur la console selon que Jimmy peut s'accrocher à la corde ou s'il tomberait de la corde, respectivement.

• Les critères pour que Jimmy puisse s'accrocher à la corde:

  1. Deux de ses parties du corps sont sur la corde.

  2. Il n'est pas au bas de la corde.

  3. Il ne flotte pas dans les airs.

• Vous pouvez supposer que la corde sera droite, composée de ||segments et aura plus d'un caractère en hauteur.

• Vous pouvez supposer qu'une corde entière et un Jimmy singulier seront présents dans votre scène, ni plus ni moins.

• Vous pouvez supposer qu'il n'y aura pas de retour à la ligne au bas de la corde.

• Vous devez couvrir n'importe quelle quantité d'espaces avant ou arrière avant et après la corde.

Cas de test

           ||
           ||
           ||                 TRUTHY
           /o\
           ||
           ||


            ||
            ||
          /o\|                FALSY
            ||
            ||


        ||
       /o\                    TRUTHY
        ||


            ||
           /o\                FALSY


         /o\
          ||                  TRUTHY


            ||
            ||
       /o\  ||                FALSY
            ||
            ||

Notation

C'est le code-golf , donc le score le plus bas en octets gagne après environ une semaine.

Classement

Vous pouvez afficher le classement de cet article en développant le widget / extrait ci-dessous. Pour que votre message soit inclus dans le classement, vous avez besoin d'un en-tête ( # header text) avec les informations suivantes:

• Le nom de la langue (terminez-le par une virgule ,ou un tiret -), suivi de ...

• Le nombre d'octets, comme le dernier nombre à apparaître dans votre en-tête.

Par exemple, JavaScript (ES6), 72 bytesest valide, mais Fortran, 143 bytes (8-bit)n'est pas valide car le nombre d'octets n'est pas le dernier nombre dans l'en-tête (votre réponse sera reconnue comme 8 octets - n'en profitez pas).

<!-- Run the snippet to see the leaderboard. Report any bugs to @ozewski on Github. -->    <iframe src="https://ozewski.github.io/ppcg-leaderboard/?id=187759" width="100%" height="100%" style="border:none;">Oops, your browser is too old to view this content! Please upgrade to a newer version of your browser that supports HTML5.</iframe><style>html,body{margin:0;padding:0;height:100%;overflow:hidden}</style>

Japt , 5 octets

Je pense que c'est juste; Je travaille depuis 16 heures d'affilée et je connais à peine mon propre nom donc je ne serais pas surpris si ce n'était pas le cas!

Õø|io

Essayez-le

Õø|io     :Implicit input
Õ         :Transpose
 ø        :Contains?
  |io     :  "|" prepended with "o"

Python 2 ou 3 ,  33  30 octets

-3 grâce à Maxwell

lambda l:'o'in map(max,l[:-1])

Une fonction sans nom acceptant une liste de lignes

Essayez-le en ligne!

Comment?

Il doit y avoir une section de corde obscurcie par Jimmy qui n'est pas celle du bas.

lambda l:'o'in map(max,l[:-1])
lambda l:                      # a function taking l (the lines as strings)
                       l[:-1]  # strip off the last line
               map(max,      ) # maximum of each line (where '|'>'o'>'\'>'/'>' ')
         'o'in                 # was 'o' one of them? (hence Jimmy obscured all the rope)

Python 2, 28 octets

lambda x:"o', '|"in`zip(*x)`

Essayez-le en ligne!

Comment ça marche? Il prend l'entrée comme une liste de chaînes et zip joint la chaîne. Jimmy reste sur la corde s'il y a un "|" sous un "o", donc ce code joint toutes les lignes et vérifie s'il y a un "o" suivi d'un "|".

Code annoté:

lambda x: # Creates an anonymous function that takes one argument
  "o', '|" # If this substring is in the zip object, then Jimmy's "o" is above a "|"
    in
    `    # Back quotes change the object into its string representation
    zip(*x)` # Joins the lines together

(Ancienne réponse) Python 2 ou 3, 39 octets

lambda x:1-all("|"in i for i in x[:-1])

Une fonction qui prend l'entrée comme une liste de chaînes, chaque chaîne étant une ligne différente.

-11 octets grâce à xnor! -2 octets merci à Jonathan Allan!

Essayez-le en ligne! (Si vous voulez essayer plus de cas de test, mettez simplement un "." Après chaque ensemble de lignes dans la zone de saisie.)

Comment cela marche-t-il? Eh bien, si Jimmy est complètement sur la corde, alors cette ligne n'aura pas de "|" personnages. Par conséquent, nous pouvons vérifier chaque ligne, et si nous en trouvons sans "|" personnages, alors nous savons que Jimmy peut rester sur la corde. Cependant, Jimmy ne peut pas s'accrocher au bas de la corde; par conséquent, nous n'incluons pas la dernière ligne dans notre chèque. Si la ligne finale n'est qu'une autre partie de la corde, cela n'aura pas d'importance, car nous trouverons toujours une ligne valide plus haut, mais si la ligne finale est celle avec Jimmy, elle ne trouvera pas de ligne sans "|" n'importe où, et retournera Faux.

Gelée ,  9 7  6 octets

Ṗ<”|ṀẠ

Un lien monadique acceptant une liste de lignes

Essayez-le en ligne!

Comment?

Il doit y avoir une section de corde obscurcie par Jimmy qui n'est pas celle du bas.

Ṗ<”|ṀẠ - Main Link: list of lines of characters
Ṗ      - remove last line
  ”|   - pipe character
 <     - less than? (vectorises) - Note that all other characters are
    Ṁ  - maximum
     Ạ - all?

Grime , 5 octets

\o/\|

Essayez-le en ligne!

Le bon outil pour le travail.

\o        # match an "o"
  /       # above
   \|     # a "|"

brainfuck, 79 64 octets

>>+<<,[----------[<]>>[.-]+<[>-]+[---------<-->]<[<]>>[-]<[>]<,]

Essayez-le en ligne!

Génère l'octet 0x01 pour la vérité et rien pour la fausse.

Z: 0
A: input
B: 0
C: has no | been found on this line?

>>+<<                       initialize C to 1
,[                          loop over each char

  ----------                set A to 0 if input was \n
  [<]>>                     move to C if input was \n; B otherwise
  [                         if input was \n and C is true
    .-                      output 1
  ]

  +                         this will reinitialize C to 1 if input was \n
                            but also clobber B with 1 if it wasn't
                            now we have { 0   0   0  (1)} if input was \n;
                                        { 0   _  (1)  _ } otherwise
  <[>-]                     clear own cell if the one to the left is positive
                            this yields { 0   0  (0)  1 } and
                                        { 0   _  (0)  _ } as desired

  +[---------<-->]          set A to 0 if input was |
  <[<]>>                    move to C if input was |; B otherwise
  [-]                       zero out current cell: clears C if input was |
  <[>]<                     realign pointer onto A

,]                          break on end of input

Stax , 6 octets

é¿┤4╠q

Exécuter et déboguer

Transpose l'entrée, puis recherche "o |".

05AB1E , 5 octets

Çü%àθ

Essayez-le en ligne!

Ç         # convert the input to a 2D array of codepoints
 ü%       # pairwise modulo (vectorized)
   à      # maximum (*not* vectorized, returns a single number)
    θ     # tail (last digit)

Les seuls caractères qui peuvent apparaître dans l'entrée sont \o/ |, avec les points de code respectifs 92, 111, 47, 32, 124 (il n'y a pas de nouvelle ligne, puisque nous avons choisi de prendre l'entrée comme un tableau de lignes). Les résultats possibles en modulant deux de ces nombres sont 0, 13, 15, 17, 19, 28, 30, 32, 45, 47, 92, 111. 111 est le plus grand de ceux-ci, et aussi le seul qui se termine par 1 , donc le code affichera la vérité si et seulement si 111 est présent dans la liste (seulement 1 est vrai dans 05AB1E). 111 est 111 ( o)% 124 ( |), et ne se produit donc que s'il y a un oau-dessus de a |dans l'entrée.

APL (Dyalog Unicode) , 8 octets ^SBCS

Fonction de préfixe tacite anonyme, prenant comme argument une matrice de caractères.

1∊'o|'⍷⍉

Essayez-le en ligne!

⍉ transposer

'o|'⍷ masque pour partout oest immédiat suivi de|

1∊ en est-on membre?

Dyalog APL Extended, 14 13 11 9 octets

3∊¯1+/⍤↓<

Essayez-le en ligne!

JavaScript, 39 33 octets

Merci @Daniil Tutubalin d'avoir joué au golf sur 2 octets

x=>!!x.match(/^( *)\/[^|]*\n/m)

Cela correspond à n'importe quelle ligne qui n'est pas la ligne où son bras gauche apparaît et aucune corde ne montre.

Essayez-le en ligne!

/// , 53 50 octets

/~/\/\~/\/o\\/1~1 /1~ 1/1~|1~/1|~/|~/1.~/ ~/.~/
~.

Essayez-le en ligne!

Parce qu'il n'y a pas d'autre moyen de prendre des entrées dans ///, il est codé en dur:

/~/\/\~/\/o\\/1~1 /1~ 1/1~|1~/1|~/|~/1.~/ ~/.~/
~<INPUT HERE>.

Explication:

L'approche générale consiste à remplacer Jimmy par un 1 unaire, puis à le retirer de toutes les situations où il est en danger. S'il survit, il est sorti. S'il ne le fait pas, alors rien ne l'est. Les ~dans le code sont un remplacement pour //, ce qui permet au code d'être raccourci de 3 octets ici. Ils sont omis de l'explication.

/{/\//
/}/\/\//

          {The top two lines allow me to leave comments without disturbing the code.}

/\/o\\/1/ {Replace Jimmy with a 1.}
/1 /1/    {Get rid of any spaces in front of Jimmy. This moves Jimmy towards the rope from the left.}
/ 1/1/    {Get rid of any spaces after Jimmy. This moves Jimmy towards the rope from the right.}

/|1//     {If Jimmy is touching the rope, remove him and the rope.}
/1|//     {This is based on the observation that in all cases where Jimmy is safe, there is no visible rope on his line.}


/|//      {Remove any remaining rope. If Jimmy was touching a rope, it's already too late for him.}
/1.//     {This handles the case where Jimmy is at the bottom of the rope (hence the period at the end).}


/ //      {The remaining lines clean up the output.}
/.//
/
//

           ||
           ||
           ||
           /o\
           ||.

Essayez-le en ligne!

Ruby 2.5.5, 22 octets

->x{x.pop;!x.all? /\|/}

Attend un tableau de lignes. Nécessite un minimum de la version 2.5.5 car c'est à ce moment qu'a Array#all?(pattern)été ajouté.

En raison des contraintes selon lesquelles l'entrée sera toujours une scène valide de Jimmy et d'une corde, il se résume à savoir si l'une des lignes avant la dernière ligne a la corde obscurcie.

Kotlin , 93 84 octets

fun j(a:List<String>){print(a.count{!it.contains("|")}==1&&!a.last().contains("o"))}

Essayez-le en ligne!

JavaScript, 38 37 octets

r=>r.some(x=>!~x.search`\\|`,r.pop())

Essayez-le en ligne!

Rétine , 9 octets

m`^[^|]+^

Essayez-le en ligne!

Maintenant, je n'ai jamais programmé de rétine auparavant, mais pour autant que je sache, cela fonctionne. C'est une expression régulière qui trouve une chaîne contenant (1) le début de l'entrée, (2) pas de "|" et (3) une nouvelle ligne.

Les personnes plus familières avec les expressions régulières ou la rétine sont encouragées à faire des suggestions. -2 octets grâce à Neil!

Perl 5 -p , 26 octets

$\||=!/\|/;$;=/o/}{$\&&=!$

Essayez-le en ligne!

Befunge-98 (PyFunge) , 26 24 octets

]~:a-!#v_' `+
^_-3q#$<
@

Essayez-le en ligne!

Quitte avec le code retour 3 si \n est rencontré et la dernière ligne contenait 3 caractères non-espace, sinon se termine avec le code retour 0 sur EOF. Ainsi, cela repose sur la dernière ligne ne contenant pas de nouvelle ligne de fin.

Disséqué

]~                     :a-!#v_                ' `+
 Read character,      Branch downwards if   Increment counter on 
 branch up (and        equal to 10 ('\n')   the stack if greater
 loop around) if                            than 32 (' ') and
 end of stream                              implicitly loop

^_-3q#$<                    <
 Return with code 3
 if counter is equal to 3,
 otherwise reset counter
 and return to beginning

@
 Return with exit
 code 0

05AB1E (hérité) , 6 octets

ζJ„o|å

Port de @Shaggy réponse Japt de .

Saisie sous forme de liste de lignes.

Essayez-le en ligne.

Explication:

ζ       # Zip/transpose the (implicit) strings in the input-list, with space as filler
        # (NOTE: zip/transpose doesn't work on string-list in the new version of 05AB1E,
        #  which is why we use the legacy version)
 J      # Join these zipped/transposed lines together to a single string
  „o|å  # And check if it contains the string "o|"
        # (after which the result is output implicitly)

Orme 0,19, 68 octets

f r=List.any(not<<String.contains"|")(List.take((List.length r)-1)r)

Prend l'entrée comme une liste de lignes. Sans tenir compte de la dernière ligne, il vérifie s'il y en a sans'|' en a sans - ce qui implique que la corde est entièrement couverte par Jimmy.

Vérifiez tous les cas de test ici .

PowerShell , 26 octets

Réponse de Port of Maxwell pour Retina .

"$args"-match'(?m)^[^|]+^'

Essayez-le en ligne!

Explication:

true si:

1. il y a une ligne dans une scène qui ne contient pas le personnage |
2. et après cette ligne, il y a un début d'une nouvelle ligne.

false autrement.

Pyth , 9 octets

sPm!sqR\|

Suite de tests!

Pyret, 79 octets

{(l):all2({(r,n):string-char-at(n,string-index-of(r,"o") == "|")},l,link(0,l))}

Attend un tableau de lignes sous forme de chaînes. Effectue une copie dans link(0,l)laquelle toutes les lignes sont décalées d'une unité vers le bas. Parcourt chaque ligne ret noù n est la ligne sous r. Vérifie que si le corps de Jimmy "o"est dans une certaine position, alors la rangée en dessous a un tuyau là-bas (c'est-à-dire que Jimmy est accroché à la corde et n'est pas en bas).