Objetivo

Seu objetivo é criar um programa que converta uma entrada em sua sigla. Sua entrada é garantida para ter apenas letras e espaços. A entrada terá exatamente um espaço entre as palavras. Você deve gerar o acrônimo da entrada.

Regras

• Seu código não diferencia maiúsculas de minúsculas (por exemplo, fooe Fooé o mesmo)
• Seu código deve ignorar as seguintes palavras e não colocá-las na sigla: and or by of
• Você não pode assumir que as palavras são todas minúsculas.
• A saída deve ser totalmente maiúscula, sem separação entre caracteres.
• Uma nova linha à direita é aceita, mas não é necessária.
• Se o seu idioma tiver uma função de acrônimo embutida, você não poderá usá-lo.

Exemplos

(entradas / saídas agrupadas)

United States of America
USA

Light Amplification by Stimulation of Emitted Radiation
LASER

united states of america
USA

Jordan Of the World
JTW

Pontuação

Este é um desafio de código-golfe , de modo que o código mais curto vence.

Entre os melhores

var QUESTION_ID=75448,OVERRIDE_USER=8478;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Pitão, 25 21 20 bytes

shM-crz1dc4."@YK½¼

Experimente aqui!

Agradecemos a @Jakube por salvar um byte!

Explicação

shM-crz1dc4. "@ YK½¼ # z = entrada

     rz1 # converte entrada para maiúscula
    cd # split input nos espaços
         c4. "@ YK½¼ # cria uma lista de palavras de uma sequência compactada que deve ser ignorada
   - # filtrar essas palavras
 hM # leva apenas a primeira letra de todas as palavras
s # junte-os em uma sequência

A sequência empacotada se torna ANDBYOROF

Geléia , 21 20 bytes

,“°ɲịĊs°gɗ»ṣ€⁶Œuḟ/Ḣ€

Experimente online!

(-1 graças a @Dennis.)

,“°ɲịĊs°gɗ»              Pair input with the string "OR OF by AND"
           ṣ€⁶           Split both by spaces
              Œu         Uppercase
                ḟ/       Reduce filter (removing ignored words from input)
                  Ḣ€     Keep first letters of remaining words

O dicionário de Jelly é um pouco estranho, pois possui ANDletras maiúsculas e byminúsculas ...

Retina, 29 31 36 bytes

T`l`L
 |(AND|OR|BY|OF)\b|\B.

Nova linha pretendida no final.

Obrigado a Martin Büttner por salvar 5 bytes

Experimente online

T`l`L                  # Replace lowercase with uppercase
 |(AND|OR|BY|OF)\b|\B. # Regex match, it doesn't matter if we match 'AND' in SHAND
                       #   since the 'SH' will still become 'S' or am I missing something?
                       # Replace with nothing

JavaScript (ES6), 56 bytes

Guardou um byte graças a @ edc65.

s=>s.toUpperCase().replace(/\B.| |(AND|O[RF]|BY)\b/g,"")

Explicação

O código é auto-explicativo, apenas explicarei a regex:

\B.          // Matches any character (`.`), that's not the start of a word
|            // Matches spaces
|(...)\b     // Matches all the words that should be ignored

Ele removeu todos esses caracteres correspondentes e maiúscula a palavra

JavaScript, 61 64 66 63 bytes

a=>a.toUpperCase().replace(/(AND|O[FR]|BY|(\w)\w+)( |$)/g,"$2")

Ele usa uma expressão regular para encontrar palavras que não são da lista: and, or, of, bye captura a primeira letra. Em seguida, coloca em maiúscula a sequência de letras resultante.

EDIT: 64 bytes - corrigido para palavras que começam comof,or,by,and

EDIT: 66 bytes - corrigido para verificar todas as palavras, incluindo a última palavra.

EDIT: 63 bytes - economizou 3 bytes graças a @ edc65 e @Cyoce !

vim, 46

gUU:s/ /\r/g<cr>:g/\vAND|OR|OF|BY/d<cr>:%s/.\zs.*\n<cr>

gUU                      make line uppercase
:s/ /\r/g<cr>            replace all spaces with newlines
:g/\vAND|OR|OF|BY/d<cr>  remove unwanted words
:%s/.\zs.*\n<cr>         remove all non-initial characters and newlines

Eu particularmente gosto dessa última parte. O primeiro .na regex corresponde ao primeiro caractere da linha. Em seguida, usamos \zspara iniciar a parte "realmente sendo substituída", efetivamente não substituindo o caractere inicial. .*corresponde ao restante da linha e \ncorresponde à nova linha à direita. Como não especificamos uma string de substituição, o vim simplesmente remove tudo na correspondência, deixando apenas as iniciais.

CJam, 28 24 22 bytes

qeuS/"AOBONRYFD"4/z-:c

Experimente online . Agradecemos ao Sp3000 por apontar um erro e sugerir uma correção e a Dennis por salvar 4 6 (!) Bytes.

Explicação

qeuS/  e# Convert the input to uppercase and split on spaces
"AOBONRYFD"4/z  e# Push the array of short words. See more below
-      e# Remove each short word from the input words
:c     e# Cast the remaining words to characters, which is a
       e# shorter way of taking the first letter

Dennis sugeriu este truque para encurtar a lista de palavras: dividindo-se AOBONRYFDem pedaços de quatro, obtemos

AOBO
NRYF
D

Transpondo colunas em linhas com o zoperador, obtemos as palavras adequadas!

Julia, 72 63 61 55 bytes

s->join(matchall(r"\b(?!AND|OR|OF|BY)\S",uppercase(s)))

Esta é uma função anônima que aceita uma string e retorna uma string. Para chamá-lo, atribua-o a uma variável.

Convertemos a string em uppercase, selecionamos cada correspondência da expressão regular \b(?!AND|OR|OF|BY)\Scomo uma matriz e joinela em uma string.

Economizou 8 bytes graças a Dennis!

Perl, 32 bytes

say uc=~/\b(?!AND|OR|OF|BY)\S/g

+1 byte para o -nsinalizador.

Algoritmo roubado da resposta Julia de @ AlexA .

Ruby, 45 43 bytes

->s{s.upcase.scan(/\b(?!AND|OR|OF|BY)\S/)*''}

Esta é uma função lambda que aceita uma string e retorna uma string. Para chamá-lo, atribua-o a uma variável e faça f.call(input).

Ele usa a mesma abordagem da minha resposta Julia , ou seja, converter em maiúsculas, obter correspondências da expressão regular \b(?!AND|OR|OF|BY)\Se ingressar em uma string.

Experimente aqui

Economizou 2 bytes graças ao manatwork!

PHP, 92 bytes

Primeira tentativa de código de golfe.

foreach(explode(" ",str_replace(["AND","OR","BY","OF"],"",strtoupper($s)))as$x){echo$x[0];}

A variável $sé a frase a ser convertido: $s = "United States of America".

Requer PHP 5.4 ou superior para que a sintaxe de matriz curta funcione.

Bash + núcleo GNU, 103 76 bytes

for i in ${@^^};do grep -qE '\b(AND|OR|BY|OF)\b'<<<$i||echo -n ${i:0:1};done

Correr com

./codegolf.sh Light Amplification BY Stimulation of Emitted Radiationofo

com argumento único citado ou com vários argumentos.

(Distorci a última palavra a conter de ).

60 bytes

Graças a @manatwork.

for i in ${@^^};{ [[ $i = @(AND|OR|BY|OF) ]]||printf %c $i;}

JavaScript, 104 85 bytes

Economizou 19 bytes graças a @ Aplet123 .

Divide a sequência por espaços e verifica se são as palavras de, ou, e, ou por. Se for, ele a ignora; caso contrário, recebe a primeira letra. Em seguida, junta-se à matriz e torna a string maiúscula.

a=_=>_.split` `.map(v=>/\b(o(f|r)|and|by)\b/i.test(v)?"":v[0]).join("").toUpperCase()

Ungolfed:

function a(_) {
       _ = _.split` `; //Split on spaces
       _ = _.map(function(v){return new RegExp("\b(o(f|r)|and|by)\b","i").test(v)}); //Check if the banned words are in the result
       _ = _.join(""); //Join it into a string
       _ = _.toUpperCase(); //Convert it to uppercase
};

MATL , 34 27 bytes

1 byte menos graças a @AandN

KkYb'OF AND OR BY'YbX-c1Z)!

Experimente online!

Xk                  % convert to uppercase
Yb                  % split by spaces. Gives a cell array of input words
'AND OR BY OF'      % ignored words separated by spaces
Yb                  % split by spaces. Gives a cell array of ignored words
X-                  % setdiff: remove ignored words (result is stable)
c                   % convert to 2D char array, padding words with spaces
1Z)                 % take first column
!                   % transpose into a row

05AB1E , 33 32 28 bytes

Código:

‘€ƒ€—€‚€‹‘ð¡)Uuð¡)vXyQO>iy¬?

Usa CP-1252 codificação .

Python, 81 bytes

lambda s:''.join(c[0]for c in s.upper().split()if c not in'AND OF OR BY'.split())

Haskell, 100 99 98 82 75 bytes

Tenho certeza de que pode ser reduzido muito mais, pois ainda sou péssimo em usar $, .etc. , então continuo usando ()insted =)

Obrigado @nimi pela sua ajuda mágica!

import Data.Char
w=words
x=[h!!0|h<-w$toUpper<$>x,notElem h$w"OF BY OR AND"]

Exemplo:

*Main> a "united states by america"
"USA"

Python, 103 96 bytes

Esta é a minha primeira tentativa de código de golfe, e isso provavelmente poderia ser muito mais. Agradecemos a DenkerAffe por salvar sete caracteres.

lambda x:"".join([x[0]for y in x.split(" ") if y.lower() not in ['and','or','of','by']]).upper()

Ele pega a entrada, a transforma em uma lista de palavras e pega a primeira letra, se não for uma das palavras proibidas, depois transforma tudo em maiúsculas.

JavaScript, 80 72 55 53 bytes

Código

function a(t){t=t.toUpperCase();t=t.replace(/AND|OR|BY|OF|\B.| |/g,"");return t}

function a(t){return t.toUpperCase().replace(/AND|OR|BY|OF|\B.| |/g,"")}

Acabei de ler sobre as funções das setas e percebi que poderia encurtar ainda mais isso.

a=t=>t.toUpperCase().replace(/AND|OR|BY|OF|\B.| |/g,"")

De acordo com isso , você não conta a atribuição no comprimento, portanto, -2 bytes.

t=>t.toUpperCase().replace(/AND|OR|BY|OF|\B.| |/g,"")

Este é o meu primeiro golfe, por isso não é muito bom.

PHP, 68 61 58 bytes

Usa a codificação ISO-8859-1.

for(;$w=$argv[++$x];)stripos(_AND_OR_BY_OF,$w)||print$w&ß;

Execute assim ( -dadicionado apenas para estética):

php -d error_reporting=30709 -r 'for(;$w=$argv[++$x];)stripos(_AND_OR_BY_OF,$w)||print$w&ß; echo"\n";' united states oF america

Ungolfed:

// Iterate over the CLI arguments (words).
for(;$w = $argv[++$x];)
    // Check if the word is one of the excluded words by substring index.
    // The check is case insensitive.
    stripos("_AND_OR_BY_OF", $w) ||
        // Print the word, converting to uppercase and getting only the
        // first char by using bitwise AND.
        print $w & "ß";

• Economizou 7 bytes usando AND bit a bit em vez de usar ucwords.
• Salva 3 bytes usando a codificação ISO-8859-1 e usando ß(binário 11011111) para binário em ANDvez de um espaço negado (binário 00100000).

Mathematica, 132 117 bytes

ToUpperCase[First/@Characters@DeleteCases[StringDelete[StringSplit@#,"of"|"and"|"or"|"by",IgnoreCase->True],""]<>""]&

15 bytes salvos graças a @CatsAreFluffy.

PowerShell, 81 bytes

(-join($args[0].Split(" ")|?{$_-notmatch"^(and|or|by|of)$"}|%{$_[0]})).ToUpper()

Explicação

Divida os espaços criando uma matriz. Solte os membros ofensores. Puxe o primeiro personagem e junte-se. Use ToUpper()na sequência resultante.

Lua, 122 bytes

Eu adoraria usar um padrão para se livrar das palavras proibidas, mas, infelizmente, lua não é feita para combinar com grupos de caracteres ... Então, eu tive que usar um loop for, o que é muito mais caro.

s=arg[1]for k,v in next,{"of","and","by","or"}do
s=s:gsub(v,"")end
print(s:gsub("(%a)%a+",string.upper):gsub("%s","").."")

Ungolfed

s=arg[1]                               -- initialise s with the argument
for k,v in next,{"of","and","by","or"} -- iterate over the array of banned words
do
    s=s:gsub(v,"")                     -- replace the occurences of v by 
end                                    --   an empty string
print(s:gsub("(%a)%a+",                -- replace words (separated by spaces)
              string.upper)            -- by their first letter capitalised
         :gsub("%s","")                -- replace spaces with empty strings
                       .."")           -- concatenate to prevent the number of 
                                       -- substitutions to be shown

Fator, 175 bytes

Eu aprendi muito escrevendo isso.

USING: strings ascii sets splitting kernel sequences math.ranges ;
>lower " " split [ { "and" "or" "by" "of" } in? not ] filter [ first dup [a,b] >string ] map "" join >upper 

Como uma palavra:

USING: strings ascii sets splitting kernel sequences math.ranges ;

: >initialism ( str -- str )
  >lower " " split                            ! string.lower.split(" ")
  [ { "and" "or" "by" "of" } in? not ] filter ! word in { } ?
  [ first dup [a,b] >string ]          map    ! word[0]
  "" join >upper ;                            ! "".join.upper

Testes unitários:

USING: tools.test mk-initialism ;
IN: mk-initialism.tests

{ "LASER" } [ "Light Amplification by Stimulation of Emitted Radiation" >initialism ] unit-test
{ "USA"   } [ "United States OF Americaof" >initialism ]                              unit-test
{ "USA"   } [ "united states and america" >initialism ]                               unit-test
{ "JTW"   } [ "Jordan Of the World" >initialism ]                                     unit-test

Passar!

Lua, 113 112 93 bytes

arg[1]:upper():gsub("%w+",function(w)io.write(("AND OR BY OF"):find(w)and""or w:sub(0,1))end)

C #, 134 bytes

Golfe

class P{static void Main(string[] a){foreach (var s in a){if(!"AND OR BY OF".Contains(s.ToUpper())){Console.Write(s.ToUpper()[0]);}}}}

Legível

class P
{
    static void Main(string[] a)
    {
        foreach (var s in a)
        {
            if (!"AND OR BY OF".Contains(s.ToUpper()))
            {
                Console.Write(s.ToUpper()[0]);
            }
        }
    }
}

Executar a partir da linha de comando

Amplificação da luz 75448.exe por estimulação da radiação emitida

LASER

75448.exe estados unidos da américa

EUA

IPOS - não concorrente, 27 bytes

uS`"AND|OR|BY|OF"ER`%S!h%S-

Isso funciona na versão atual (v0.2) do intérprete .

Exemplo de execução

python IPOS.py -i "Estados Unidos da América" ​​uS` \ "AND | OR | BY | OF \" ER`% S! h% S-
EUA

As barras invertidas existem apenas para escapar das aspas e não são necessárias para o programa.

Explicação

u # Tornar a entrada maiúscula
S # Empurre um espaço para a pilha
`" AND | OR | BY | OF "ER` # Empurra um comando para a pilha, que substitui correspondências da regex
                   # com uma string vazia
% # Divida a sequência de entrada em maiúsculas em espaços, aplique o comando e
                   # junte-se novamente nos espaços. Isso remove as palavras necessárias da entrada.
S # Empurre um espaço para a pilha
! h # Pressione um comando que seleciona apenas o primeiro caractere de uma string
% # Divida em espaços, aplique o comando e junte-se novamente em espaços
S- # Remova os espaços restantes (esqueceu de tornar isso utilizável
                   # com regexes, teria me poupado alguns bytes aqui :()

coreutils do bash / GNU, 60 bytes

sed -e's/\b'{and,o[rf],by}'\W*//Ig' -re's/(\w)\S* ?/\u\1/g'

Pylongolf2 , 14 bytes (UTF-8)

c| l1╨3♀~

Pylongolf2 possui muitos caracteres não-ASCII que contam como 2 bytes.

c| l1╨3♀~
c         read input
 |        split by space (note the space after |)
   l1     substring(0, 1)
     ╨3   convert to uppercase
       ♀~ pop the array into the stack and print it.

05AB1E , 19 bytes (não concorrente ...?)

lð¡“€ƒ€—€‹€‚“#K€нJu

Experimente online!

Uma versão certamente concorrente (21 bytes):

lð¡“€ƒ€—€‹€‚“#Kvy0èuJ

Experimente online!