Questo è simile a Fare un acronimo , ma ci sono diverse differenze chiave, incluso il metodo per recuperare l'acronimo, e questa sfida include un output flessibile.

Compito

Data una stringa (è consentito un elenco di caratteri / stringhe di lunghezza 1) contenente solo ASCII stampabile, visualizza tutte le lettere maiuscole nell'input che sono precedute da uno spazio o un trattino o sono il primo carattere nell'input. La stringa vuota è un comportamento indefinito.

Casi test:

Uscita può essere nel formato "TEST", ["T","E","S","T"]o qualunque altro funziona per voi.

Self-contained Underwater Breathing Apparatus
SUBA

a Programming Language
PL

NATO Atlantic TREATY Organization
NATO

DEFCON 2
D

hello, world!


light-Emitting dioDe
E

What Does the Fox Say?
WDFS


3D mov-Ies
I

laugh-Out Lou-D
OLD

Best friends FOREVE-r
BF

--


<space>


--  --a -  - --


--  -- -  - -- A
A

Step-Hen@Gmail-Mail Mail.CoM m
SHMM

Questo è code-golf , quindi vince la risposta più breve in byte.

V , 7 byte

ÍÕü¼À!õ

Provalo online!

Ecco un hexdump per provare il conteggio dei byte:

00000000: cdd5 fcbc c021 f5                        .....!.

Spiegazione:

Í       " Search and replace all occurrences on all lines:
        " (Search for)
 Õ      "   A non-uppercase letter [^A-Z]
  ü     "   OR
      õ "   An uppercase letter
    À!  "   Not preceded by...
   ¼    "   A word-boundary
        " (implicitly) And replace it with:
        "   Nothing

Questo è breve tutto grazie alla meravigliosa del V compressione regex .

R , 66 63 byte

function(s)(s=substr(strsplit(s,' |-')[[1]],1,1))[s%in%LETTERS]

Provalo online!

-3 byte grazie a Scarabee

Una funzione anonima; restituisce l'acronimo come un vettore c("N","A","T","O")che è implicitamente stampato.

Per una volta, questo non è male in R! si divide su -o (space), prende il primo elemento di ciascuno di questi, e quindi restituisce quelli che sono maiuscoli ( LETTERSè una R incorporata con le lettere maiuscole), in ordine.

Python 2 , 59 56 byte

^{-3 byte grazie a Lynn}

lambda s:[b for a,b in zip(' '+s,s)if'@'<b<'['>a in' -']

Provalo online!

Javascript 21 byte

Accetta un input di stringa e genera un array di stringhe contenenti i caratteri di acronimo

x=>x.match(/\b[A-Z]/g)

Spiegazione

È solo una corrispondenza regex globale per parola-limite seguita da una lettera maiuscola.

Retina , 21 17 byte

!`(?<=^| |-)[A-Z]

Provalo online!

Spiegazione

Emette le corrispondenze della regex (?<=^| |-)[A-Z]nell'input, una per riga ( !).

Dyalog APL, 29 23 byte

Caso di prova bonus: un linguaggio di programmazione (APL).

'(?<=^| |-)[A-Z]'⎕S'&'⊢

Restituisce un array di caratteri (viene mostrato come spazio separato su TIO).

Provalo online!

Posta precedente, 29 byte

{(⎕AV~⎕A)~⍨'(\w)\w+'⎕R'\1'⊢⍵}

Provalo online!

Come?

'(\w)\w+'⎕R - Sostituisci ogni gruppo di caratteri alfabetici

    '\1' - con il suo primo personaggio

~⍨ - rimuovi tutti i caratteri

    (⎕AV~⎕A) - questa non è una maiuscola ASCII

Python, 53 byte

import re
lambda s:re.findall("(?<=[ -])[A-Z]"," "+s)

Provalo online!

Una semplice espressione regolare con un lookahead per spazio o trattino. Piuttosto che abbinare l'inizio, anteporre uno spazio.

C #, 84 78 byte

using System.Linq;s=>s.Where((c,i)=>c>64&c<91&(i>0?s[i-1]==32|s[i-1]==45:1>0))

6 byte salvati grazie a @jkelm .

Provalo online!

Versione completa / formattata:

using System.Collections.Generic;
using System.Linq;

class P
{
    static void Main()
    {
        System.Func<string, IEnumerable<char>> f = s => s.Where((c, i) => c > 64 & c < 91 & (i > 0 ? s[i-1] == 32 | s[i-1] == 45: 1 > 0));

        System.Console.WriteLine(string.Concat(f("Self-contained Underwater Breathing Apparatus")));
        System.Console.WriteLine(string.Concat(f("a Programming Language")));
        System.Console.WriteLine(string.Concat(f("NATO Atlantic TREATY Organization")));
        System.Console.WriteLine(string.Concat(f("DEFCON 2")));
        System.Console.WriteLine(string.Concat(f("hello, world!")));
        System.Console.WriteLine(string.Concat(f("light-Emitting dioDe")));
        System.Console.WriteLine(string.Concat(f("What Does the Fox Say?")));
        System.Console.WriteLine(string.Concat(f("3D mov-Ies")));
        System.Console.WriteLine(string.Concat(f("laugh-Out Lou-D")));
        System.Console.WriteLine(string.Concat(f("Best friends FOREVE-r")));
        System.Console.WriteLine(string.Concat(f(" ")));
        System.Console.WriteLine(string.Concat(f("--  --a -  - --")));
        System.Console.WriteLine(string.Concat(f("--  -- -  - -- A")));

        System.Console.ReadLine();
    }
}

Julia 0.6.0 (57 byte)

s=split(s,r" |-");for w∈s isupper(w[1])&&print(w[1])end

Spiegazione: Questo è il mio primo codice-golf. Abbastanza diretto. Dividi le parole, stampa la prima lettera superiore di ciascuna.

Probabilmente è facile fare di meglio usando regex ma io sono nuovo in questo

05AB1E , 11 byte

'-ð‡ð¡ζнAuÃ

Provalo online!

C # (.NET Core) , 108 byte

n=>{var j="";n=' '+n;for(int i=0;++i<n.Length;)if(" -".IndexOf(n[i-1])>=0&n[i]>64&n[i]<91)j+=n[i];return j;}

Provalo online!

Gelatina ,  11  10 byte

-1 byte grazie a Erik the Outgolfer (si Ḳdivide in spazi> _ <)

⁾- yḲḢ€fØA

Un collegamento monadico che prende e restituisce elenchi di personaggi.
Come programma completo accetta una stringa e stampa il risultato.

Provalo online! o vedere una suite di test .

Come?

⁾- yḲḢ€fØA - Link: list of characters, x       e.g. "Pro-Am Code-golf Association"
   y       - translate x with:
⁾-         -   literal list of characters ['-',' '] "Pro Am Code golf Association"
    Ḳ      - split at spaces               ["Pro","Am","Code","golf","Association"]
     Ḣ€    - head each (1st character of each)      "PACgA"
        ØA - yield uppercase alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
       f   - filter keep                            "PACA"
           - if running as a full program: implicit print

Perl 5 , 25 byte

24 byte codice + 1 per -n.

Fastidioso che grep -Psupporta look-behind a lunghezza variabile ma Perl no :(.

print/(?:^| |-)([A-Z])/g

-1 byte grazie a @Dada !

Provalo online! - include -ll'esecuzione di tutti i test contemporaneamente.

MATL , 19 byte

'- 'X{&Yb'^[A-Z]'XX

Provalo online!

Brachylog , 25 23 22 byte

,Ṣ↻s₂ᶠ{h∈" -"&t.∧Ạụ∋}ˢ

Provalo online!

(-2 byte grazie a @Fatalize.)

,Ṣ↻                      % prepend a space to input
   s₂ᶠ                   % get all substrings of length 2 from that, to get prefix-character pairs
      {              }ˢ  % get the successful outputs from this predicate: 
       h∈" -"              % the prefix is - or space
               &t.∧        % then the character is the output of this predicate if:
                  Ạụ∋        % the alphabet uppercased contains the character

Japt , 19 16 14 byte

-2 byte grazie a Shaggy

f/^| |-)\A/ mÌ

Provalo online!

Swift 5 , 110 byte

-5 grazie a Cœur

import UIKit
func f(s:[String]){for i in zip(s,[" "]+s){if i.0.isUppercase()&&"- ".contains(i.1){print(i.0)}}}

Spiegazione dettagliata

• import Foundation- Importa il modulo per Foundationcui è vitale zip(), il pezzo principale di questo codice.

• func f(s:[String]){...}- Crea una funzione con un parametro s, ovvero un elenco di stringhe, che rappresenta i caratteri dell'input.

• for i in zip(s,[" "]+s){...}- Scorre iattraverso la zip dell'input e dell'input con uno spazio aggiunto all'inizio, che è molto utile per ottenere il carattere precedente nella stringa.

• if - Verifica se:

  • i.0==i.0.uppercased() - Il carattere corrente è maiuscolo,

  • &&"- ".contains(i.1) - e se il carattere precedente è uno spazio o un trattino.

• Se le condizioni di cui sopra sono soddisfatte, quindi:

  • print(i.0) - Il personaggio è stampato, perché fa parte dell'acronimo.

PowerShell , 43 byte

''+($args|sls '(?<=^| |-)[A-Z]'-a -ca|% m*)

Provalo online!

srotolato:

''+($args|select-string '(?<=^| |-)[A-Z]' -allmatches -caseSensitive|% matches)

Python 3 , 67 byte

lambda x:[c[0]for c in x.replace("-"," ").split()if c[0].isupper()]

Provalo online!

Python 3 , 73 70 byte

lambda n:[n[x]for x in range(len(n))if'@'<n[x]<'['and(' '+n)[x]in' -']

Provalo online!

Spiegazione

• lambda n:- Crea una funzione lambda anonima con un parametro String n.

• n[x]- Ottiene il carattere di nall'indice x.

• for x in range(len(n))- Passa 0alla lunghezza di n, denominando la variabile x.

• if - Controlli:

  • '@'<n[x]<'[' - Se il carattere è maiuscolo,

  • and(' '+n)[x]in' -'- E se è preceduto da uno spazio o un trattino nella stringa formata da uno spazio e n.

JavaScript (SpiderMonkey) , 62 byte

n=s=>(""+s.match(/([ -]|^)[A-Z]/g)).replace(/[ \-,]|null/g,"")

Provalo online!

QuadS , 17 byte

(?<=^| |-)[A-Z]
&

Provalo online!

Pyth, 15 16 byte

@rG1<R1:w"[ -]"3

Suite di test

Pyth, 12 byte

@rG1hMcXz\-d

Suite di test qui.

Bash (grep), 29 28 byte

grep -oP'(?<=^| |-)[A-Z]' a

Una porta della mia risposta Python ma perché pgrepsupporta lookbehinds di lunghezza variabile è notevolmente più breve (anche tenendo conto del sovraccarico di Python). Incolla i casi di test in un file chiamato a, l'output è di 1 carattere per riga.

-1 Grazie a Neil

RProgN 2 , 18 byte

`-` rû#ùr.'[a-z]'-

spiegato

`-` rû#ùr.'[a-z]'-
`-`                     # Push "-" literal, and " " literal.
    r                   # replace, Replaces all "-"s with " "s.
     û                  # Split, defaultly by spaces.
      #ù                # Push the head function literally.
        r               # Replace each element of the split string by the head function, which gets each first character.
         .              # Concatenate, which collapses the stack back to a string.
          '[a-z]'-      # Push the string "[a-z]" literally, then remove it from the string underneith, giving us our output. 

Provalo online!

PHP, 62 byte

for(;~$c=$argn[$i++];$p=$c!="-"&$c!=" ")$c<A|$c>Z|$p?:print$c;

Esegui come pipe -nRo provalo online .

altre soluzioni:

foreach(preg_split("#[ -]#",$argn)as$s)$s[0]>Z|$s<A?:print$s[0];  # 64 bytes
preg_match_all("#(?<=\s|-)[A-Z]#"," $argn",$m);echo join($m[0]);  # 64 bytes
preg_match_all("#(?<=\s|-)\p{Lu}#"," $argn",$m);echo join($m[0]); # 65 bytes

C ++, 168 byte

#include<string>
auto a=[](auto&s){auto r=s.substr(0,1);if(r[0]<65||r[0]>90)r="";for(int i=1;i<s.size();++i)if(s[i]>64&&s[i]<91&&(s[i-1]==32||s[i-1]==45))r+=s[i];s=r;};

Uscita eseguita tramite il parametro

Lua , 79 75 byte

for i=1,#t do for i in(" "..t[i]):gmatch"[%-| ]%u"do print(i:sub(2))end end

Provalo!

Ho bloccato una stampa () prima della fine finale nella versione di prova perché altrimenti è un casino. Questo programma aderisce perfettamente ai requisiti di I / O e di corrispondenza, ma senza quella nuova riga in più è piuttosto difficile da leggere.

L'input viene dato sotto forma di una tabella di numeri: stringa, numero che aumenta di 1 ogni volta e inizia da 1.

Spiegazione:

Per i cicli attraverso un gmatch di ogni stringa di input. La ricerca di gmatch è la seguente:

[% - | ] - Raggruppa, cerca un - o uno spazio

% u - Cerca un carattere maiuscolo

Quindi per ogni partita, lo stampa meno il trattino o lo spazio precedente

Modifica: golfato 4 byte rimuovendo la dichiarazione di 'a' e aggiungendo lo spazio all'ingresso all'interno del ciclo for in, nonché cambiando l'ingresso secondario a solo 2 anziché 2,2 (che producono risultati equivalenti)

Pyth , 12 byte

Creato un anno dopo la risposta iniziale.

rI#1hMcXQ\-d

Provalo online!

Pyth , 21 byte

Risposta iniziale.

:+dQ"(?<=[ -])[A-Z]"1

Provalo online!