Jimmy può appendere alla sua corda?

18

Ancora un'altra sfida di Jimmy da parte del padre originale. Vedi queste altre adorabili sfide .

Come tutti sapete, recentemente abbiamo assistito a sfide legate a Jimmy su piattaforme. Ora, Jimmy è un acrobata come ho detto prima, e ha altri trucchi nella manica.

Uno di questi trucchi è appeso alle corde. Ecco un esempio di una corda che Jimmy potrebbe appendere:

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

Quando Jimmy si blocca su una corda, sembra così:

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

Può appendere a sinistra oa destra della corda, quindi questo:

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

è anche valido. Ma non può appendere solo per una parte del corpo, quindi niente del genere:

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

è invalido. Nota che quando è appeso a una parte del corpo, l'altra metà della corda è visibile perché Jimmy non la copre.

Inoltre, a Jimmy non piace appendere sul fondo della corda - lo spaventa - quindi questo:

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

è invalido.

La sfida

Prendi l'input di una situazione di Jimmy come quelle sopra e fai sapere se Jimmy si aggrapperà alla corda o meno attraverso un valore di verità o falsità.

I dettagli

  • Scrivi un programma che accetta input. Ciò può avvenire tramite una funzione o qualsiasi altro metodo di input appropriato.

    1. L'ingresso dovrebbe essere una scena di un Jimmy e una corda come esemplificato sopra.

  • Il programma dovrebbe generare un valore di verità o falsa sulla console in base al fatto che Jimmy possa aggrapparsi alla corda o se cadrebbe dalla corda, rispettivamente.

  • I criteri per Jimmy in grado di appendere alla corda:

    1. Due delle sue parti del corpo sono sulla corda.

    2. Non è sul fondo della corda.

    3. Non galleggia a mezz'aria.

  • Puoi presumere che la corda sarà diritta, composta da ||segmenti e che sarà più lunga di un personaggio in altezza.

  • Puoi presumere un'intera corda e un Jimmy singolare sarà presente nella tua scena, né più né meno.

  • Puoi presumere che non ci saranno newline finali nella parte inferiore della corda.

  • È necessario coprire qualsiasi quantità di spazi iniziali o finali prima e dopo la corda.

Casi test

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


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


        ||
       /o\                    TRUTHY
        ||


            ||
           /o\                FALSY


         /o\
          ||                  TRUTHY


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

punteggio

Questo è code-golf , quindi il punteggio più basso in byte vince dopo circa una settimana.

Classifica

Puoi visualizzare la classifica per questo post espandendo il widget / snippet di seguito. Affinché il tuo post sia incluso nelle classifiche, è necessario un header ( # header text) con le seguenti informazioni:

  • Il nome della lingua (termina con una virgola ,o un trattino -), seguito da ...

  • Il conteggio dei byte, come l'ultimo numero da visualizzare nell'intestazione.

Ad esempio, JavaScript (ES6), 72 bytesè valido, ma Fortran, 143 bytes (8-bit)non è valido perché il conteggio dei byte non è l'ultimo numero nell'intestazione (la risposta verrà riconosciuta come 8 byte, non approfittarne).

<!-- 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>
Espandi frammento

code-golf  string  ascii-art  parsing 
— connectyourcharger
fonte
1
La corda avrà sempre lo stesso numero di spazi prima o può variare?
— mprogrammer,
@Maxwell Questo può variare.
— connectyourcharger
Possiamo prendere l'input come qualcosa di simile a un elenco, in cui ogni riga è una stringa separata o deve essere una singola stringa?
— mprogrammer
19
Jimmy dovrebbe davvero fare una vacanza
— Luis Mendo il
7
@LuisMendo Jimmy è dedicato a ciò che fa!
— connectyourcharger

Risposte:

13

Japt , 5 byte

Penso che sia giusto; Ho lavorato per 16 ore di fila e conosco a malapena il mio nome, quindi non sarei sorpreso se non lo fosse!

Õø|io

Provalo

Õø|io     :Implicit input
Õ         :Transpose
 ø        :Contains?
  |io     :  "|" prepended with "o"
— ispido
fonte
2
16 ore? Questa è dedizione!
— connectyourcharger
2
Aspetta quindi ti ci sono volute 16 ore per scrivere 5 byte? ;-)
— Cullub,
Sembra che tu abbia bisogno di una pausa (lo stesso consiglio vale per la piccola Jimmy!).
— ihavenoidea,
@connectyourcharger, no, questa è la mia vita! La dedizione lo farebbe senza una pausa. Che ho fatto!
— Shaggy,
1
@ihavenoidea, Pfft! Dormirò quando sarò morto!
— Shaggy,
22

Python 2 o 3 ,  33  30 byte

-3 grazie a Maxwell

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

Una funzione senza nome che accetta un elenco di righe

Provalo online!

Come?

Deve esserci una sezione di corda oscurata da Jimmy che non è quella inferiore.

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)
— Jonathan Allan
fonte
Salva tre byte:lambda l:'o'in map(max,l[:-1])
— mprogrammer
Oh, molto astuto - grazie!
— Jonathan Allan,
È un uso molto intelligente dei valori ASCII. Bello.
— Fondo Monica's Lawsuit
16

Python 2, 28 byte

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

Provalo online!

Come funziona? Prende l'input come un elenco di stringhe e zip unisce la stringa. Jimmy resta sulla corda se c'è un "|" sotto una "o", quindi questo codice unisce tutte le righe e controlla se c'è una "o" seguita da una "|".

Codice annotato:

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

(Vecchia risposta) Python 2 o 3, 39 byte

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

Una funzione che accetta l'input come un elenco di stringhe, ciascuna delle quali è una riga diversa.

-11 byte grazie a xnor! -2 byte grazie a Jonathan Allan!

Provalo online! (Se si desidera provare altri casi di test, è sufficiente inserire un "." Dopo ogni serie di righe nella casella di input.)

Come funziona? Bene, se Jimmy è completamente sulla corda, quella linea non avrà alcun "|" personaggi. Pertanto, possiamo controllare ogni riga e se ne troviamo una senza "|" personaggi, allora sappiamo che Jimmy può stare sulla corda. Tuttavia, Jimmy non può aggrapparsi al fondo della corda; pertanto, non includiamo la riga finale nel nostro controllo. Se la linea finale è solo un'altra parte della corda, non importa, perché troveremo ancora una fila valida più in alto, ma se la linea finale è quella con Jimmy, allora non troverà una linea senza "|" ovunque e restituirà False.

— mprogrammer
fonte
Puoi farlo senza il controllo che la linea abbia un "/"?
— xnor
@xnor Yup! -11 byte
— mprogrammer
1
Salva un paio così:lambda x:1-all("|"in i for i in x[:-1])
— Jonathan Allan il
1
Ahi, sei stato più veloce :)
— Daniil Tutubalin,
1
@KlaymenDK La funzione scorre attraverso x [: - 1], non x. x [: - 1] sono tutti gli elementi della lista tranne l'elemento finale, perché in Python puoi usare indici negativi. Pertanto, restituisce (correttamente) un risultato errato se Jimmy si trova nella parte inferiore della corda.
— mprogrammer
8

Gelatina ,  9 7  6 byte

Ṗ<”|ṀẠ

Un collegamento monadico che accetta un elenco di righe

Provalo online!

Come?

Deve esserci una sezione di corda oscurata da Jimmy che non è quella inferiore.

Ṗ<”|ṀẠ - Main Link: list of lines of characters
Ṗ      - remove last line
  ”|   - pipe character
 <     - less than? (vectorises) - Note that all other characters are
    Ṁ  - maximum
     Ạ - all?
— Jonathan Allan
fonte
1
Mi sento così strano a scrivere queste sfide su Jimmies. Inizia a farti sentire strano una volta che immagini più Jimmies appesi alla stessa corda.
— connectyourcharger
1
@connectyourcharger Foreshadowing?
— negativo 7
@negativeseven Forse. Ho già considerato una wiki della meta community per indicizzare tutti i post di Jimmy.
— connectyourcharger
1
Nove byte, e ancora una volta, scopriamo ancora come qualcuno può morire.
— IMustBe Qualcuno il
1
" Note that all other characters are [less than '|']"?
— Erik the Outgolfer,
5

brainfuck, 79 64 byte

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

Provalo online!

Emette il byte 0x01 per verità e niente per falsa.

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
— Maniglia
fonte
4

05AB1E , 5 byte

Çü%àθ

Provalo online!

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

Gli unici caratteri che possono apparire nell'input sono \o/ |, con i rispettivi punti di codice 92, 111, 47, 32, 124 (non ci sono nuove righe, poiché abbiamo scelto di prendere l'input come un array di linee). I possibili risultati componendo due di questi numeri sono 0, 13, 15, 17, 19, 28, 30, 32, 45, 47, 92, 111. 111 è il più grande di quelli e anche l'unico che termina con 1 , quindi il codice genererà true se e solo se 111 è presente nell'elenco (solo 1 è true in 05AB1E). 111 è 111 ( o)% 124 ( |), e quindi si verifica solo se nell'input è presente una osopra |a.

— Grimmy
fonte
1
Molto bello con il modulo pairwise.
— Kevin Cruijssen,
2

JavaScript, 39 33 byte

Grazie @Daniil Tutubalin per il golf off 2 byte

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

Questo corrisponde a qualsiasi linea che non è la linea in cui si presenta il braccio sinistro e nessuna della corda mostra.

Provalo online!

— fənɛtɪk
fonte
Sembra fallire se si trova in fondo alla corda
— f 6nɛtɪk il
Dovrebbe fallire se è in fondo, giusto? Perché Jimmy cade se è in fondo alla corda
— programmatore
Voglio dire che quando l'ho messo nella parte inferiore della corda la tua funzione per qualche motivo è tornata 1
— f 6nɛtɪk
Hm, non importa allora.
— mprogrammer
1
Che dire /^ *.o. *\n/?
— TSH
2

/// , 53 50 byte

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

Provalo online!

Poiché non esiste un altro modo per inserire input in ///, è hardcoded:

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

Spiegazione:

L'approccio generale è quello di sostituire Jimmy con un unario 1, quindi rimuoverlo da tutte le situazioni in cui è in pericolo. Se sopravvive, viene espulso. Se non lo fa, allora niente lo è. I ~nel codice sono un sostituto di //, che consente di accorciare il codice di 3 byte qui. Sono omessi dalla spiegazione.

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

          {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\
           ||.

Provalo online!

— Compagno SparklePony
fonte
2

Ruby 2.5.5, 22 byte

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

Si aspetta una matrice di linee. Richiede un minimo della versione 2.5.5 perché è quando è Array#all?(pattern)stato aggiunto.

A causa dei vincoli secondo cui l'ingresso sarà sempre una scena valida di Jimmy e una corda, si riduce al fatto che una delle linee prima dell'ultima linea sia oscurata.

— DaveMongoose
fonte
1

Retina , 9 byte

m`^[^|]+^

Provalo online!

Ora, non ho mai programmato in Retina prima, ma per quanto posso dire questo funziona. È un'espressione regolare che trova una stringa contenente (1) l'inizio dell'input, (2) no "|" personaggi e (3) una nuova riga.

Le persone che hanno più familiarità con le espressioni regolari o con la Retina sono incoraggiate a offrire suggerimenti. -2 byte grazie a Neil!

— mprogrammer
fonte
Due alternative: 1) Rimuovi il \nperché una nuova linea non è una |e quindi corrisponderà comunque, e il finale è ^sufficiente per assicurarti di aver effettivamente abbinato una nuova linea. 2) Usa un pilrow invece di \ne rimuovi il trailing ^(perché questo è sempre vero dopo una nuova riga in modalità multilinea).
— Neil
1

Befunge-98 (PyFunge) , 26 24 byte

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

Provalo online!

Esce con il codice di ritorno 3 se \n viene rilevato e l'ultima riga contiene 3 caratteri non spaziali, altrimenti esce con il codice di ritorno 0 su EOF. Pertanto, ciò si basa sull'ultima riga che non contiene una nuova riga finale.

sezionato

]~                     :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
— sette negativi
fonte
1

05AB1E (legacy) , 6 byte

ζJ„o|å

Porto di risposta @ Shaggy's Japt .

Inserisci come un elenco di righe.

Provalo online.

Spiegazione:

ζ       # 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)
— Kevin Cruijssen
fonte
1
— Grimmy
1

Olmo 0,19, 68 byte

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

Accetta input come un elenco di righe. Ignorando l'ultima riga, controlla se ce ne sono alcuni con no'|' - implicando che la corda è completamente coperta da Jimmy.

Verifica qui tutti i casi di test .

— OOBalance
fonte
0

Pyret, 79 byte

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

Si aspetta una matrice di linee come stringhe. Crea una copia in link(0,l)cui tutte le righe sono state spostate verso il basso di una. Passa attraverso ogni riga re ndove n è la riga sotto r. Verifica che se il corpo di Jimmy si "o"trova in una certa posizione, la riga sotto ha un tubo lì (cioè Jimmy è appeso alla corda e non è in fondo).

— MLavrentyev
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.