Una scena di diversità Jimmy

25

Come probabilmente saprai, ci sono state diverse adorabili sfide Jimmy recentemente spuntate. In queste sfide, sei stato sfidato con le abilità acrobatiche del nostro amato amico. Ora abbiamo una sfida diversa per te. Oggi identificherai diversi tipi di Jimmys!

Spiegazione

Esistono tre varietà di Jimmys: nano, acrobata e culturista.

This is dwarf Jimmy:               o

This is acrobat Jimmy:            /o\

This is bodybuilder Jimmy:       /-o-\

Questi Jimmy sono tutti grandi amici e amano stare sulla stessa linea l'uno dell'altro. Il tuo compito è, data una scena Jimmy in questo modo:

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

Stampa la quantità di nani, acrobati e culturisti sulla linea, rispettivamente.

La sfida

  • Prendi input in qualsiasi forma ragionevole come una scena di Jimmy, come mostrato in un esempio sopra.

    1. La stringa di input dovrebbe essere di una riga e facoltativamente contiene le tre varietà di Jimmys e gli spazi bianchi opzionali.

    2. La stringa non conterrà necessariamente tutte le varietà o gli spazi bianchi di Jimmy.

    3. La stringa non conterrà alcun carattere non presente o/\ -.

    4. È possibile qualsiasi combinazione di varietà Jimmy. Ciò significa che lo stesso o diverso tipo di Jimmy può essere uno accanto all'altro. Devi renderlo conto.

    5. Lo spazio bianco iniziale e finale è facoltativo e non è necessario in alcun modo: il programma dovrebbe tenere conto di una stringa con o senza spazio bianco iniziale e / o finale.

    6. La stringa deve contenere solo Jimmy e spazi bianchi validi. Ad esempio, ---///---non è consentito perché non è una sequenza Jimmy valida.

  • Stampa tre numeri: il numero di nani, acrobati e culturisti nella scena (nel rispettivo ordine).

    1. Questo può essere un output per la console come numeri interi separati da spazio, oppure può essere un valore di ritorno da una funzione come una sorta di contenitore (cioè un tipo di array).

    2. L'output, in qualunque formato, deve essere ordinato come indicato nel punto in alto sopra questa regola.

  • Si applicano regole standard e scappatoie.

Casi test

     /-o-\           /-o-\     o/o\  /-o-\       /-o-\                /-o-\
OUTPUT: 1 1 5


      o o               /o\    o o      o                    /o\             /o\
OUTPUT: 5 3 0


 /-o-\     /-o-\            /-o-\/-o-\   o /o\/o\    /-o-\o /-o-\       /o\/-o-\
OUTPUT: 2 3 7


  /-o-\  o                 /-o-\               o/o\
OUTPUT: 2 1 2

Se desideri più casi di test, utilizza questo strumento per generare più casi di test casuali.

punteggio

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

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 @xMikee1 on Github. -->    <iframe src="https://ozewski.github.io/ppcg-leaderboard/?id=188391" 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  counting 
— connectyourcharger
fonte
Possiamo supporre che tutti gli input abbiano almeno uno spazio iniziale e finale?
— Shaggy,
7
@connectyourcharger un modo più standard sarebbe richiedere risposte per specificare l'ordine.
— Dati scaduti il
4
Giusto per essere espliciti, Dwarf Jimmys può stare insieme? Non vedo nulla che suggerisca diversamente. Se è così, un caso di prova oo /o\ o osarebbe bello
— Veskah
1
@Veskah: il generatore di test case è in grado di generare la sequenza oo.
— ricorsivo il
8
Deve esserci un tag jimmy .
— MilkyWay90,

Risposte:

8

Jelly , (12?) 13 byte

ċⱮ“-/o”H1¦ŻIṚ

Un collegamento monadico che accetta un elenco di caratteri che produce un elenco di numeri interi, [ dwarves, acrobats, and body-builders](salva il Ṛbyte se possiamo specificare il nostro output)

Provalo online!

Come?

Tutti i Jimmys mostrano un o; tutti i non nani mostrano a /; tutti i body-builder ne mostrano due -. Conta questi, dimezza il conteggio -ed esegui la sottrazione per trovare i conteggi di Jimmy:

ċⱮ“-/o”H1¦ŻIṚ - Link: list of characters
  “-/o”       - list of characters ['-', '/', 'o']
 Ɱ            - map across right with:
ċ             -   count occurrences   = [n('-'), n('/'), n('o')]
         ¦    - sparse application...
        1     - ...to indices: [1] -- i.e. n('-')
       H      - ...action: halve    = [n('-')/2, n('/'), n('o')]
          Ż   - prepend a zero =   [0, n('-')/2, n('/'), n('o')]
           I  - incremental differences
              -     = [n('-')/2, n('/')-n('-')/2, n('o')-n('/')]
            Ṛ - reverse
              -     = [n('o')-n('/'), n('/')-n('-')/2, n('-')/2]
— Jonathan Allan
fonte
21

Python 3.8 (pre-release) , 51 byte

lambda s:((c:=s.count)('o')-c('/'),c('/o'),c('/-'))

Provalo online!

— Erik the Outgolfer
fonte
FINALMENTE Python ha aggiunto qualcosa del genere. Aspetto da un po 'che Python consenta gli incarichi come espressioni. Un peccato ci vuole un byte in più, ma lo prenderò: P
— HyperNeutrino il
@HyperNeutrino Questo è fondamentalmente l'unico motivo per cui ora potresti vedere "Python 3.8 (pre-release)" fluttuare nel sito. Un'altra restrizione è che, a meno che non sia di per sé e non l'unica espressione in un'istruzione (nel qual caso potresti preferire un incarico regolare), deve essere tra parentesi (+2 byte).
— Erik the Outgolfer,
In che modo il primo conteggio delle ('o')chiamate viene chiamato senza un c?
— Quinn,
@Quinn I assegna un'espressione di assegnazione s.counta ce poi restituisce.
— Erik the Outgolfer,
@ErikTheOutgolfer cool, TIL
— Quinn
12

Python 2 , 50 byte

x,y,z=map(input().count,'o/-')
print x-y,y-z/2,z/2

Provalo online!

-10 byte convertendo l'espressione lambda in un programma completo grazie a @xnor (rimuove la cosa annidata double lambda e utilizza invece l'assegnazione)

— HyperNeutrino
fonte
3
Questo è un bel metodo ed è più breve come programma .
— xnor
8

PowerShell , 59 55 byte

$c=,0*3
$args|sls '/?-?o'-a|% m*|% le*|%{++$c[$_-1]}
$c

Provalo online!

srotolato:

$counters=,0*3
$args|select-string '/?-?o'-AllMatches|% Matches|% Length|%{++$counters[$_-1]}
$counters
— Mazzy
fonte
5

J , 36 25 byte

-11 byte grazie a Cole!

2-/\0,~1 1 2%~1#.'o/-'=/]

Provalo online!

Soluzione originale

J , 36 byte

[:(-/@}:,-/@}.,{:)1 1 2%~1#.'o/-'=/]

Provalo online!

Spiegazione:

                            'o/-'=/] compare the input with each one of "o/-" characters
                                     / the result is a 3-row matrix /
                         1#.         add up each row to find the number of occurences
                                     of each character, the result is a vector of 3 items
                  1 1 2%~            divide the last item by 2 to find the number of 
                                     bodybuilder Jimmys
[:(              )                   use the result to construct the following vector:
               {:                    the last item
              ,                      appended to
         -/@}.                       the difference of the second and the third items
        ,                            appended to
   -/@}:                             the difference of the first and the second items

Una sessione J di esempio :

a=:'  /-o-\  o                 /-o-\               o/o\'
   'o/-'=/a
0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0
0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0
0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
   1#.'o/-'=/a
5 3 4  
   1 1 2%~1#.'o/-'=/a
5 3 2
   (-/@}:,-/@}.,{:)1 1 2%~1#.'o/-'=/a
2 1 2
— Galen Ivanov
fonte
1
— Cole
Ehi, non posso più modificare il mio commento - anche questo è 25 byte se è corretto, fa un modo diverso di aggiungere lo 0
— cole
1
@cole Hah, come spesso mi viene in mente, non ho visto lo schema. Grazie!
— Galen Ivanov,
è un peccato che l'ho visto bene solo mentre stavi modificando quella spiegazione - è sempre un peccato perdere lo sforzo di spiegare.
— Cole
@cole Ecco perché terrò visibile la spiegazione del mio errore :)
— Galen Ivanov il
5

Excel come CSV, 130 byte

,=LEN(A3)-LEN(A4)
=SUBSTITUTE(A1,"-o",""),=(LEN(A2)-LEN(A3))/2
=SUBSTITUTE(A2,"/o",""),=(LEN(A1)-LEN(A2))/2
=SUBSTITUTE(A3,"o","")

Inserisci l'input nello spazio prima del primo , , salva come .csv, apri in Excel. Uscite nani, Acrobati e Bodybuilders in B1, B2e B3rispettivamente.

Excel, 244 byte

=LEN(SUBSTITUTE(SUBSTITUTE(A1,"-o",""),"/o",""))-LEN(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A1,"-o",""),"/o",""),"o",""))&" "&(LEN(SUBSTITUTE(A1,"-o",""))-LEN(SUBSTITUTE(SUBSTITUTE(A1,"-o",""),"/o","")))/2&" "&(LEN(A1)-LEN(SUBSTITUTE(A1,"-o","")))/2
— Wernisch
fonte
4

Kotlin 131 130 129 121 117 97 96 88 byte

fun String.j(b:Int=count{'-'==it}/2,a:Int=count{'/'==it})=listOf(count{'o'==it}-a,a-b,b)

Provalo online!

Modifica - Wew, ce l'ho sotto 100! Dubito di poterlo restringere di più, ma solo il tempo lo dirà ...

Modifica: parlato troppo presto, ha lasciato cadere un altro byte utilizzando un elenco anziché una stringa

Modifica - meno 8 byte grazie ad AsoLeo che suggerisce di usare una funzione di estensione

— Quinn
fonte
1
Lascia che ti parli dei metodi di estensione, amico mio: fun String.j(b:Int=count{'-'==it}/2,a:Int=count{'/'==it})=listOf(count{'o'==it}-a,a-b,b)88 byte.
— Aso Leo,
@AsoLeo bello, in realtà l'avevo scritto inizialmente come una funzione di estensione, ma devo aver sbagliato qualcos'altro perché il mio era più byte
— Quinn
3

Retina , 39 35 byte

Modifica: -4 byte grazie a @FryAmTheEggMan

^((o)|(/o.)|(/-o-.)| )*
$#2 $#3 $#4

Provalo online!

Spiegazione:

Una semplice fase di sostituzione. Trova tutte le corrispondenze della regex ^((o)|(/o.)|(/-o-.)| )*(che dovrebbe risultare in una corrispondenza - l'intera stringa) e la sostituisce con il numero di acquisizioni dei gruppi 2, 3 e 4. Ecco la regex suddivisa:

^((o)|(/o.)|(/-o-.)| )*
^                               start at the beginning of the string
 (                       )*     have any amount of Jimmy / spaces
     |       |         |        select one of:
  (o)                           capturing group 2 - dwarf
      (/o.)                   capturing group 3 - acrobat
              (/-o-.)         capturing group 4 - bodybuilder

Dobbiamo iniziare con ^o la fine dei conteggi dell'input come una corrispondenza. Nella sintassi di sostituzione di Retina,$n riferimento all'ennesimo gruppo di acquisizione e il modificatore #conta il numero di corrispondenze effettuate.

— lolad
fonte
Puoi salvare alcuni byte scappando di meno, poiché la stringa è garantita solo come jimmy: provala online!
— FryAmTheEggman,
3

JavaScript, 55 byte

Ricerche la stringa usando un pattern matching regex o, o-o o-\; incrementa il conteggio corrispondente in un array, usando la lunghezza di ogni corrispondenza per determinare l'indice.

s=>s.replace(/o-?\\?/g,m=>a[m.length-1]++,a=[0,0,0])&&a

Provalo online!

— darrylyeo
fonte
1
@JonathanAllan Ho riscritto la mia risposta.
— darrylyeo,
2

R , 63 byte

Utilizza la corrispondenza Regex per trovare e contare i Jimmy. 

library(stringr)
str_count(scan(,''),c('(?<![/-])o','/o','/-'))

Provalo online!

— CT Hall
fonte
1

Perl 5 -p , 41 byte

$_=1*s/o(?!\\|-)//g.$".1*s|/o||g.$".y/o//

Provalo online!

Conta il numero di volte che oappare senza essere seguito da \o -per trovare i nani e rimuoverli dalla stringa. Quindi conta il numero di volte che /oappare per trovare gli acrobati e rimuoverli dalla stringa. Quindi conta il numero di orimanenti per determinare i body builder. Inserisce spazi tra i numeri e genera implicitamente il risultato.

— Xcali
fonte
— Nahuel Fouilleul il
@NahuelFouilleul Non funziona se c'è un nano alla fine di una riga. Lo conta come un body builder.
— Xcali,
vero, altrimenti -4 byte semplicemente rimuovendo1*
— Nahuel Fouilleul il
@NahuelFouilleul Anche questo non funziona. Se non ci sono esempi di questi tipi, non genera nulla ( undef) invece di 0.
— Xcali,
ok, ho appena esaminato i casi di test
— Nahuel Fouilleul il
1

SNOBOL4 (CSNOBOL4) , 135 byte

	I =INPUT
B	I '-o' =	:F(A)
	B =B + 1	:(B)
A	I '/o' =	:F(D)
	A =A + 1	:(A)
D	I 'o' =	:F(O)
	D =D + 1	:(D)
O	OUTPUT =+D ' ' +A ' ' +B
END

Provalo online!

Rimuove -o, /oe odalla stringa e incrementa i contatori appropriati ogni volta. Lascia dietro di sé un sacco di braccia e gambe ( /-\, \, e niente).

— Giuseppe
fonte
0

Forth (gforth) , 118 byte

: c -rot 0 tuck do over i + c@ 3 pick = - loop nip nip ;
: f 2dup '/ c >r 2dup '- c 2/ -rot 'o c i - . r> over - . . ;

Provalo online!

Spiegazione

  • Ottenere conte di /, -eo personaggi
  • Bodybuilder è il numero di -personaggi diviso per 2
  • Acrobat è il numero di /caratteri meno il numero di body builder
  • Nano è il numero di opersonaggi meno il numero di Acrobat e Culturisti

Spiegazione del codice

\ c counts the number of occurrences of the given character in a string
\ stack usage is ( c-addr u1 w1 - u )
: c                 \ start a new word definition
  -rot 0 tuck       \ sets up parameters for a counted loop
  do                \ loop from 0 to string-length - 1 (inclusive)
    over i +        \ get the address of the current character in the string
    c@              \ get the ascii value of the current character              
    3 pick =        \ compare it to the character we're counting
    -               \ subtract result from the accumulator (subtract because -1 = true in forth)
  loop              \ end the loop
  nip nip           \ remove extra values from the stack
;                   \ end the word definition

\ Main function 
: f                 \ start a new word definition
  2dup              \ duplicate the string address and length
  '/ c >r           \ count the number of '/' characters and stick the result on the return stack
  2dup '- c 2/      \ count the number of '-' characters and divide by 2
  -rot 'o c         \ move the string to the top of the stack and count the number of 'o characters
  i - .             \ calculate number of dwarf jimmy's and print
  r> over - .       \ calculate number of acrobat jimmy's and print (drop '/' count from return stack)
  .                 \ print number of body-builder jimmy's
;                   \ end word definition
— reffu
fonte
0

05AB1E , 13 byte

…-/oS¢ć;š0š¥R

Questo potrebbe essere di 12 byte rimuovendo il Rcaso in cui [bodybuilder, acrobat, dwarf]fosse stato consentito un ordine di output di .

Provalo online o verifica tutti i casi di test .

Alternativa minore di uguali byte:

…-/oS¢R`;0)üα

Provalo online o verifica tutti i casi di test .

Spiegazione:

…-/o           # Push string "-/o"
    S          # Split to a list of characters: ["-","/","o"]
     ¢         # Count the occurrence of each character in the (implicit) input-string
      ć        # Extract the head; pop and push head and remainder-list
       ;       # Halve this head
        š      # And prepend it back in front of the remainder-list
         0š    # Then also prepend a 0
           ¥   # Get the deltas (forward differences)
            R  # And reverse the list to get the required order of output-counts
               # (after which the result is output implicitly)

…-/oS¢         # Same as above
      R        # Reverse this list
       `       # Pop the list and push its values separately to the stack
        ;      # Halve the top value on the stack
         0     # Push a 0
          )    # Wrap all values on the stack into a list
           ü   # For each overlapping pair of values:
            α  #  Get the absolute difference between the two values
               # (after which the result is output implicitly)
— Kevin Cruijssen
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.