backstory

Incontra il mio amico Jimmy:

/o\

Jimmy è un piccolo personaggio a cui piace stare su piattaforme. Ecco Jimmy in piedi sicuro su una piattaforma:

         /o\
  -------------

Ora, Jimmy ha un buon senso dell'equilibrio, quindi può stare tranquillamente in piedi con una gamba fuori dalla piattaforma, in questo modo:

   /o\
    -------------------

Anche se se sta con due o più parti del corpo fuori dalla piattaforma, cadrà. Entrambi questi sono esempi in cui cadrà Jimmy:

/o\                                       /o\
  ----------        ----------------------   

La sfida

La tua sfida è scrivere un programma per determinare, data una stringa con la piattaforma e la posizione di Jimmy, se Jimmy può stare sulla piattaforma senza cadere.

• Input: due linee che mostrano la posizione di Jimmy e la posizione della piattaforma sotto di lui. Questo può provenire da due input separati, un singolo input o un array di qualche tipo.

  1. È possibile accettare input in qualsiasi forma ragionevole, incluse funzioni e input standard. Ricorrere al codice hard solo se la tua lingua non supporta gli altri metodi di input.

• Output: i valori booleani true e false o gli interi 1 o 0 per rappresentare rispettivamente true / false.

  1. Il valore booleano si basa sul fatto che Jimmy possa rimanere sulla piattaforma o meno: vero se Jimmy può rimanere sulla piattaforma o falso se cadrà.

• Le dimensioni della piattaforma sono arbitrarie e possono essere modificate a piacimento. Il tuo programma dovrebbe tenerne conto.

  1. La piattaforma non può avere una lunghezza pari a zero e la piattaforma deve essere completa (nessun foro nella piattaforma).

  2. Ricorda che Jimmy cade quando due delle sue parti del corpo pendono dalla piattaforma. Una parte del corpo è un personaggio ASCII del suo corpo.

  3. Non è richiesto il trascinamento di spazi bianchi alla fine della piattaforma, ma il programma dovrebbe tenere conto di entrambe le situazioni, in cui vi è spazio bianco dopo la piattaforma e dove non lo è.

• Prestare attenzione alle scappatoie standard vietate.

Casi test

         /o\               ✔️ TRUE
  -------------

/o\                        ✔️ TRUE
 ----------

                    /o\    ❌ FALSE
  ------------------

               /o\         ❌ FALSE
  -------

    /o\                    ❌ FALSE
     -

punteggio

Questo è code-golf , quindi vince il conteggio di byte più basso.

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 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 @xMikee1 on Github -->    <iframe src="https://xmikee1.github.io/ppcg-leaderboard/?id=187586" 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>

Gelatina , 6 byte

n⁶Sċ2Ẓ

Provalo online!

Spiegazione:

n⁶Sċ2Ẓ  args: z (e.g. [['/', 'o', '\\'], [' ', '-']] => 0)
        implicit return value: z ([['/', 'o', '\\'], [' ', '-']])
n⁶      dyad-nilad pair ([[1, 1, 1], [0, 1]])
 ⁶       4th command-line argument or space [4th CLA assumed absent] (' ')
n        vectorized inequality ([[1, 1, 1], [0, 1]])
  S     reduction by addition with base case 0 ([1, 2, 1])
   ċ2   dyad-nilad pair (1)
    2    literal (2)
   ċ     number of occurrences of right in left (1)
     Ẓ  primality (0)

JavaScript (ES6), 38 byte

Accetta input come (a)(b). Restituisce $0$ o $1$ .

a=>b=>b[a.search`o`]=='-'&/--/.test(b)

Provalo online!

Come?

Cerchiamo la posizione della parte centrale "o"del corpo di Jimmy nella prima corda e testiamo se c'è un trattino nella seconda corda nella stessa posizione.

b[a.search`o`] == '-'

L'unico caso in cui Jimmy non sarebbe sicuro in questa situazione è con una piattaforma a trattino singolo:

/o\
 -

Quindi ci assicuriamo inoltre che la piattaforma abbia una larghezza di almeno $2$ :

/--/.test(b)

JavaScript (ES6), 36 byte

Versione alternativa se assumiamo che ci siano sempre trattini o spazi sotto Jimmy (ovvero l'input è rettangolare).

a=>b=>b[a.search`o`]!=0&/--/.test(b)

Provalo online!

Sfrutta il fatto che la coercizione a un valore numerico è $0$ per uno spazio e NaN per un trattino.

Excel, 67 45 44 byte

=(MID(A2,FIND("o",A1),1)="-")*(TRIM(A2)>"-")

Metti Jimmy dentro A1, su una piattaforma dentro A2.

2 condizioni controllate:

• Il torso di Jimmy ( o) è sulla piattaforma?
• La piattaforma è più che semplice -?

Python 3, 88 43 byte

L'input viene dato sotto forma di un elenco contenente due stringhe: la prima stringa è la prima riga; la seconda stringa è la seconda riga.

lambda a:sum(1-(" "in i)for i in zip(*a))>1

Provalo online!

Un'altra versione, che lega per 43 byte (non sono stato in grado di ottenerlo più corto di 43):

lambda a,b:b[a.find("/"):][:3].count("-")>1

Provalo online!

Giù di 42 byte grazie a un suggerimento di Jo King.

Vecchia versione:

lambda s:sum((s.split("\n")[1]+" "*len(s))[i]=="-"and s[i]!=" "for i in range(len(s)))>1

-2 byte grazie allo Sriotchilism O'Zaic.

Funziona prendendo due input separati, quindi accoppiando le lettere corrispondenti. Conta il numero di coppie in cui nessuno dei due caratteri è uno spazio, quindi restituisce True se quel numero è maggiore di 1.

Perl 6 , 18 byte

{?/''B|Bq/}o&[~^]

Provalo online!

Accetta due parametri e restituisce un valore booleano per sapere se Jimmy rimarrà sulla piattaforma. Questo funziona XORing le due linee insieme e controllando se una delle parti di Jimmy è ancora sulla piattaforma.

Spiegazione:

             &[~^]   # String XOR operator
{          }o        # Combined with the anonymous function
 ?/       /          # That checks for the regex match
   ''B              # Unprintable, B, which is "/o" ~^ "--"
       |Bq           # Or B, q, which is "o\" ~^ "--"

Python 2 , 42 37 byte

lambda j,p:'--'in p[j.find('/'):][:3]

Provalo online!

5 byte da thx a sette negativi

Haskell , 34 byte

a#b=[1|(p,'-')<-zip a b,p>' ']>[1]

Provalo online!

Ho ottenuto questo combinando la mia tecnica di seguito con l'altra risposta haskell .

Haskell , 45 byte

x#'-'|x/=' '=1
x#y=0
(((>1).sum).).zipWith(#)

Provalo online!

Questo conta il numero di parti del corpo (caratteri non spaziali) che si trovano in cima alla piattaforma e quindi controlla che sia maggiore di 1. Il motivo per cui contiamo le parti del corpo sulla piattaforma anziché le parti del corpo è che zipWithtaglia la linea superiore essere la lunghezza del fondo e quindi tagliare le parti del corpo di Jimmy. Questo ci impedisce di dover fare qualcosa di simile cycle" "per riempire l'elenco.

MathGolf , 6 14 byte

`^@╞^αmÆû-oñ╧╙

Provalo online!

Sono stati aggiunti 8 byte per tenere conto del caso limite presentato da Nick Kennedy.

Verifica se "-o-"è una sottostringa della stringa zippata di entrambe le linee e della stringa zippata in cui la prima riga di input ha il primo carattere rimosso. Accetta l'input come due stringhe separate, con l'unica modifica apportata al carattere come input /o\\, poiché \\è il modo corretto di inserire una barra rovesciata in una stringa in MathGolf.

Spiegazione

`                duplicate the top two items
 ^               zip top two elements on stack
  @              rrot3
   ╞             discard from left of string/array
    ^            zip top two elements on stack
     α           wrap last two elements in array
      mÆ         explicit map using 5 operators
        û-oñ     push "-o" and palindromize to make "-o-"
            ╧    pop a, b, a.contains(b)
                 map block ends here
             ╙   max of list

05AB1E (legacy) , 9 8 7 byte

ζðм2ùgp

-1 byte grazie a @ Mr.Xcoder con l'approccio di ðм2ù.

Immettere come elenco di due stringhe.

Funziona solo nella versione legacy di 05AB1E, perché ζpuò trasporre un elenco di stringhe e un elenco di caratteri 2D, mentre ilζ nella nuova versione 05AB1E funziona solo con l'elenco di caratteri 2D.

Provalo online o verifica tutti i casi di test .

Spiegazione:

ζ        # Zip/transpose; swapping rows/columns, with space as default filler
 ðм      # Remove all spaces from each string
   2ù    # Only leave strings of size 2
     g   # Count how many there are left
      p  # Check if this is a prime (2 or 3)
         # (after which the result is output implicitly)

Rubino , 28 byte

->a,b{!(/--/!~b[a=~/\//,3])}

Provalo online!

Dyalog APL esteso, 11 10 8 byte

2≤1⊥∧⌿⍤<

Provalo online!

Spiegazione:

2≤1⊥∧⌿⍤<  a monadic train
       <  Compare the input with the implicit prototype element - a space.
          Returns a boolean matrix of characters that are greater than 0x20
    ∧⌿⍤   and-reduce that, i.e. places where both Jimmy and a platform is
  1⊥      base 1 decode, aka sum - the amount of body parts over the platform
2≤        is that greater-or-equal to 2?

-2 grazie ad Adám.

Excel, 36 byte

=LEN(TRIM(MID(A2,FIND("/",A1),3)))>1

Jimmy dentro A1 , su una piattaforma dentro A2.

Trova la posizione di Jimmy, prende i 3 byte della piattaforma e taglia gli spazi. Se la lunghezza della piattaforma risultante è abbastanza lunga, Jimmy resta in piedi.

EXCEL, 94 71 byte. VBA (Excel), 87 byte

A1 = Jimmy, A2 = piattaforma

-23 byte. Grazie @Wernisch.

=(FIND("-",A2)-FIND("/",A1)<2)*(FIND("\",A1)-LEN(A2)<2)*(TRIM(A2)<>"-")

?[(FIND("-",A2)-FIND("/",A1)<2)*(FIND("\",A1)-LEN(A2)<2)]*(len(replace([A2]," ",""))>1)

/// , 85 93 87 byte

/~/\/\///\/o\\/(o)~ 
/
~
~/ (o) /(o)~ (o)-/(o)~- -/--~(o) - ~/) ~/)-~/o~/(-/1~-~/(~/)~ 

Provalo online!

L'output è 1 se Jimmy è sicuro. Altrimenti non genera nulla. (Unario 1 e 0.) Poiché non esiste un altro modo per inserire input in ///, è necessario che sia codificato:

/~/\/\///\/o\\/(o)~ 
/
~
~/ (o) /(o)~ (o)-/(o)~- -/--~(o) - ~/) ~/)-~/o~/(-/1~-~/(~/)~ //<INPUT HERE> 

Per esempio:

/\/o\\/(o)// 
/
//
/// (o) /(o)// (o)-/(o)//- -/--//(o) - ///) ///)-///o///(-/1//-///(///)//         /o\
  ------------- 

( Provalo online! )

Nota lo spazio dopo il <INPUT HERE>.

Spiegazione:

NOTA! Il codice esplicativo non può essere eseguito a causa dei commenti. I commenti sono racchiusi tra parentesi graffe. Inoltre, il codice originale utilizza un golf dove //viene sostituito ~. Questo codice viene omesso dalla spiegazione.

/\/o\\/(o)/            {replace Jimmy with a Jimmy with curvy arms, because slashes are hard to manipulate in this language}
/ 
/
/                      {remove unneeded spaces after Jimmy, but before the floor}

/
//                     {get rid of the line break

/ (o) /(o)/            {remove all the spaces before both Jimmy and the floor}
/ (o)-/(o)/            {for each floor tile, remove it and one space before Jimmy. This detects whether Jimmy lines up with the floor.}
                       {If Jimmy is before the floor, then there will be extra floor.}
                       {If Jimmy is behind the floor, then there will be extra spaces before Jimmy.}
/- -/--/               {Handle the case where there is a hole beneath Jimmy but he is still well-supported}

/(o) - //              {Handle the case where only Jimmy's head is on the floor. The space at the end of the code is necessary for this.}
/) //                  {The rest of the substitutions clean up the result and handle each of the possible results that could exist at this point}
/)-//
/o//
/(-/1/
/-//
/(//
/)//


              /o\   
               --
 {there is a space right before this comment. The comment is only here to make the space visible and explain itself.}

• +8 byte per correggere un bug
• -6 byte applicando un ///trucco da golf standard .

R , 35 byte

function(x)sum(colSums(x!=" ")>1)>1

Provalo online!

Basato sull'eccellente risposta Jelly di @EriktheOutgolfer per favore, vota anche quella!

L'input è una matrice 2-d di caratteri.

Haskell, 59 byte

f a b=sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']<2

Provalo online!

La funzione si chiama così: f "/o\\ " " -- "

Come funziona (per f "/o\\" " -"):

b++cycle" "- Aggiunge un numero infinito di spazi dopo bper assicurarsi che Jimmy sia sempre sopra un -o (" -" →" - ..."

zip a$b++cycle" "- Comprime insieme le due stringhe ( [('/',' '), ('o','-'), ('\\',' ')])

(p,q)<-zip a$b++cycle - Per ogni coppia nell'elenco zippato

[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']- Genera un elenco di 1s, la cui lunghezza è il numero di coppie che soddisfano le condizioni:

elem p"/o\\"- Il personaggio nella stringa superiore è una delle parti del corpo di Jimmy. (Soddisfatto di tutte e tre le coppie in questo esempio)

q==' '- Il carattere nella stringa inferiore è uno spazio. (Soddisfatto di ('/', ' ')e('\\', ' ') )

Quindi, la coppia deve essere quella in cui una delle parti del corpo di Jimmy si trova sopra uno spazio.

Perché in questo esempio, due coppie soddisfano entrambe le condizioni, l'elenco è [1,1]

sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']- Prendi la somma di quelle 1s (cioè la lunghezza della lista), che in questo esempio è 2.

sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']<2- Controlla se il numero di parti del corpo sopra uno spazio è inferiore a 2. In questo esempio, non lo è, quindi Jimmy cadrà. :(

C (gcc) , 73 byte

f(s,t,c)char*s,*t;{for(t=strchr(s,c=10);*s%5**t;)c-=*++t%2**s++%8;c=c<0;}

Provalo online!

Kotlin, 60 byte

fun String.c(b:String)=zip(b){i,j->i>' '&&j>' '}.count{it}>1

Spiegazione:

fun String.c  # Define an extension function on string, so we don't have to provide a first argument (and we also have string method calls for free)
(b:String)    # Pass the second string as argument
=             # Shorthand syntax for fun body
zip(b)        # Essentially a.zip(b). Creates a List<Pair> by joining both arrays. 
              # Takes care of trailing whitespace, because it will be the size of the smaller array
{i,j->        # Declare a transformer lambda as second function argument
i>' '&&j>' '} # This essentially translates to: If i!=' ' and j=='-'
.count{it}    # Count the true values
>1

/// , 57 byte

/|/\/\///\/o\\/J| J/J*|
/|* /|  -/  | /|*-/|--/!|-/|*/|J|

Provalo online!

Aggiungi l'input alla fine del programma per poterlo eseguire. Restituisce la stringa vuota se Jimmy cade dalla piattaforma, altrimenti una stringa di punti esclamativi.

• /|/\/\//sostituisce |con //, il che rende il codice più breve e più leggibile ( |viene utilizzato per delimitare ogni sostituzione)
• /\/o\\/J| J/J*/sostituisce Jimmy con Jper brevità e cambia lo spazio a sinistra di lui a *destra di lui
• Il prossimo sostituto si sbarazza delle nuove linee.
• /* /| -/ | // annulla * e con lo spazio a sinistra della piattaforma. Se rimangono due o più spazi, Jimmy sta cadendo a sinistra e la piattaforma viene eliminata. Questa parte rimuove anche qualsiasi spazio bianco a destra della piattaforma.
• /*-/|--/!/annulla se *e con la lunghezza della piattaforma. Se ne rimangono almeno due -, Jimmy non sta cadendo a destra, quindi vengono sostituiti con a !.
• /-/|*/|J// elimina tutti i personaggi rimanenti che non lo sono !

Japt , 8 byte

Õ·kèS Êz

Provalo

Retina 0.8.2 , 16 byte

 (.*¶).
$1
¶ ?--

Provalo online! Il link include la suite di test. Spiegazione:

+`^ (.*¶).
$1

Mentre c'è ancora uno spazio sulla prima riga ed entrambe le righe hanno ancora più di un carattere, elimina lo spazio e il primo carattere della riga successiva. Nota: questo presuppone che non ci sia spazio finale dopo Jimmy. +1 byte necessario se è necessario consentire lo spazio finale.

¶ ?--

Controlla che ci siano almeno due pezzi di piattaforma sotto Jimmy.

Perl 5 -pl , 42 byte

/o/g;$_=(($_=<>)=~/./g)[-1+pos]eq'-'&&/--/

Provalo online!

Ruby 2.5.3, 44 byte

->a,b{a.zip(b).map(&:join).grep(/\S-/).size>1}

Input preso come due array. Sicuramente non è l'approccio più adatto al golf (vedi la risposta di GB), ma mi piace ogni scusa per usare la zipfunzione.

PowerShell , 63..55 53 byte

^{-1 byte grazie a mazzy}

param($j,$f)''+($f|% t*y|?{$j[$i++]-gt32})-match'- -'

Provalo online!

Accetta input come due righe.

srotolato:

param($j,$f)            #Take $jimmy and $floor
''+                     #Implicitly converts next part to string
($f |% ToCharArray      #Convert $f to a char[] and...
    |?{                 #Only take the chars where...
        $j[$i++]-gt32   #The same indexed char in $j's ASCII # is > ' ' i.e. only get /o\
     }
)-match'- -'            #Arrays.ToString are joined with a space and we need 2 -'s

C # (compilatore interattivo Visual C #) , 44 40 39 byte

-4 byte grazie a Jo King

a=>b=>a.Zip(b,(x,y)=>x>y?y:0).Sum()>109

Provalo online!

Python 3.7 , 71 56 byte

lambda s:sum(j in'/o\\'and p=='-'for j,p in zip(*s))>1

Versione molto semplice e la più breve che potrei pensare di usare questo approccio. Ingressos è un elenco di due stringhe, la prima per la riga Jimmy, la seconda per la piattaforma. Comprimi i caratteri che si trovano uno sopra l'altro, quindi controlla se si -trova al di sotto di una parte di Jimmy in almeno due casi.

EDIT: ridotto di alcuni byte grazie a Blue!

Chevron, 84 87 byte

>^__>^j
^i<<0
^i<<^i+1
^h<^i>^j
->+2??^h=/
->-3
>^__>^p
^q<^i|2>^p
->+2??^q<--
><0
><1

Questo è un linguaggio abbastanza nuovo di mia creazione: prototipo di interprete, documentazione e programmi di esempio sono disponibili su https://github.com/superloach/chevron .

Spiegazione:

• >^__>^j - accetta jimmy come input TXT
• ^i<<0 - inizializza l'indice su 0
• ^i<<^i+1 - indice di incremento
• ^h<^i>^j - Ottieni carattere di Jimmy all'indice
• ->+2??^h=/ - saltare fuori dal giro alla gamba sinistra di Jimmy
• ->-3 - torna all'inizio del loop
• >^__>^p - accetta la piattaforma come input TXT
• ^q<^i|2>^p - ritaglia 3 caratteri in jimmy
• ->+2??^q<-- - se 2 trattini sotto jimmy, salta all'uscita vera
• ><0 - falsa uscita
• ><1 - uscita sincera

C (gcc), 103 byte

i,j,l;f(char*s){for(i=0;*s-10;j=*s++-47?j:i)++i;l=strlen(s)>j+1;s+=j;return l&&*s+s[1]+(s[2]?:32)>109;}

Provalo online!

Sarebbe molto più breve ( 75 byte ), se si potesse presumere che ci sia uno spazio bianco in coda dopo la piattaforma.

Japt -¡, 9 byte

-1 byte se l'ingresso può essere invertito.

VtUao)è-²

Provalo online

V , 18 byte

0vt/"_dj.d3lVkp0#x

Provalo online!

Spazi bianchi in uscita solo se caduta jimmy della piattaforma. Produce qualcosa di non bianco se Jimmy rimane sulla piattaforma.