Objetivo

Su objetivo es hacer un programa que convierta una entrada a su acrónimo. Su entrada está garantizada para tener solo letras y espacios. La entrada tendrá exactamente un espacio entre palabras. Debe generar el acrónimo de la entrada.

Reglas

• Su código no puede distinguir entre mayúsculas y minúsculas (por ejemplo, fooy Fooson iguales)
• Su código debe ignorar las siguientes palabras y no ponerlas en el acrónimo: and or by of
• No puede asumir que las palabras son todas minúsculas.
• La salida debe estar totalmente en mayúscula, sin separación entre caracteres.
• Se acepta una nueva línea final pero no es necesaria.
• Si el lenguaje tiene una función incorporada siglas, es posible que no lo utilizan.

Ejemplos

(entradas / salidas agrupadas)

United States of America
USA

Light Amplification by Stimulation of Emitted Radiation
LASER

united states of america
USA

Jordan Of the World
JTW

Tanteo

Este es un desafío de código de golf , por lo que gana el código más corto.

Tabla de clasificación

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>

Pyth, 25 21 20 bytes

shM-crz1dc4."@YK½¼

Pruébalo aquí!

¡Gracias a @Jakube por guardar un byte!

Explicación

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

     rz1 # convierte la entrada a mayúsculas
    cd # entrada dividida en espacios
         c4. "@ YK½¼ # crea una lista de las palabras de una cadena empaquetada que se ignorará
   - # filtra esas palabras
 hM # solo toma la primera letra de todas las palabras
s # únelos en una cadena

La cadena empaquetada se convierte ANDBYOROF

Jalea , 21 20 bytes

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

Pruébalo en línea!

(-1 gracias 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

El diccionario de Jelly es un poco extraño porque tiene ANDmayúsculas y byminúsculas ...

Retina, 29 31 36 bytes

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

Nueva línea prevista al final.

Gracias a Martin Büttner por guardar 5 bytes.

Pruébalo en línea

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

Guardado un byte gracias a @ edc65.

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

Explicación

El código se explica por sí mismo, solo explicaré la expresión regular:

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

Eliminó todos estos caracteres coincidentes y mayúsculas la palabra

JavaScript, 61 64 66 63 bytes

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

Utiliza una expresión regular para buscar palabras que no pertenecen a la lista: and, or, of, byy captura la primera letra. Luego capitaliza la cadena de letras resultante.

EDITAR: 64 Bytes - Corregido para palabras que comienzan conof,or,by,and

EDITAR: 66 Bytes - Se corrigió para verificar todas las palabras, incluida la última palabra.

EDITAR: 63 Bytes - ¡Guardado 3 Bytes gracias a @ edc65 y @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

Particularmente me gusta esa última parte. El primero .en la expresión regular coincide con el primer carácter de la línea. Luego, usamos \zspara comenzar la parte "en realidad siendo reemplazado", efectivamente no reemplazando el carácter inicial. .*coincide con el resto de la línea y \ncoincide con la nueva línea final. Como no especificamos una cadena de reemplazo, vim simplemente elimina todo en la coincidencia, dejando solo las iniciales.

CJam, 28 24 22 bytes

qeuS/"AOBONRYFD"4/z-:c

Pruébalo en línea . Gracias a Sp3000 por señalar un error y sugerir una solución, y a Dennis por guardar 4 6 (!) Bytes.

Explicación

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 sugirió este truco para acortar la lista de palabras: dividiéndonos AOBONRYFDen trozos de cuatro, obtenemos

AOBO
NRYF
D

Transponiendo columnas en filas con el zoperador, ¡obtenemos las palabras adecuadas!

Julia, 72 63 61 55 bytes

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

Esta es una función anónima que acepta una cadena y devuelve una cadena. Para llamarlo, asígnelo a una variable.

Convertimos la cadena a uppercase, seleccionamos cada coincidencia de la expresión regular \b(?!AND|OR|OF|BY)\Scomo una matriz y la joinconvertimos en una cadena.

¡Guardado 8 bytes gracias a Dennis!

Perl, 32 bytes

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

+1 byte para la -nbandera.

Algoritmo robado de la respuesta de Julia de @AlexA .

Ruby, 45 43 bytes

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

Esta es una función lambda que acepta una cadena y devuelve una cadena. Para llamarlo, asígnelo a una variable y haga f.call(input).

Utiliza el mismo enfoque que mi respuesta de Julia , es decir, convertir a mayúsculas, obtener coincidencias de la expresión regular \b(?!AND|OR|OF|BY)\Sy unir en una cadena.

Pruébalo aquí

¡Guardado 2 bytes gracias a manatwork!

PHP, 92 bytes

Primer intento de código de golf.

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

La variable $ses la frase que ser convertidos: $s = "United States of America".

Requiere PHP 5.4 o superior para que funcione la sintaxis de matriz corta.

Bash + GNU coreutils, 103 76 bytes

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

Corre con

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

ya sea con un solo argumento citado o con múltiples argumentos.

(I distorsionado la última palabra para contener de ).

60 bytes

Gracias a @manatwork.

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

JavaScript, 104 85 bytes

Guardado 19 bytes gracias a @ Aplet123 .

Divide la cadena por espacios y luego comprueba si son las palabras de, o, y, o por. Si es así, lo ignora, de lo contrario toma la primera letra. Luego se une a la matriz y hace que la cadena sea mayúscula.

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

Sin golf:

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 gracias a @AandN

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

Pruébalo en línea!

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¬?

Utiliza la codificación CP-1252 .

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

Estoy bastante seguro de que se puede acortar mucho más, ya que sigo siendo un asco en el uso $, .etc. , así que sigo usando ()insted =)

¡Gracias @nimi por tu ayuda mágica!

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

Ejemplo:

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

Pitón, 103 96 bytes

Este es mi primer intento de código de golf, y esto probablemente podría jugarse mucho más. Gracias a DenkerAffe por salvar siete caracteres.

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

Toma la entrada, la convierte en una lista de palabras y toma su primera letra si no es una de las palabras prohibidas, luego convierte todo en mayú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,"")}

Acabo de leer sobre las funciones de flecha y me di cuenta de que podría acortar esto aún más.

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

De acuerdo con esto , no cuenta la asignación en la longitud, entonces -2 bytes.

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

Este es mi primer golf, así que no es muy bueno.

PHP, 68 61 58 bytes

Utiliza la codificación ISO-8859-1.

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

Ejecutar así ( -dagregado solo 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

Sin golf:

// 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 & "ß";

• Guardado 7 bytes usando bit a bit Y en lugar de usar ucwords.
• Ahorró 3 bytes usando la codificación ISO-8859-1 y usando ß(binario 11011111) para binario en ANDlugar de un espacio negado (binario 00100000).

Mathematica, 132117 bytes

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

15 bytes guardados gracias a @CatsAreFluffy.

PowerShell, 81 bytes

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

Explicación

Dividir en los espacios creando una matriz. Suelta a los miembros infractores. Tira del primer personaje y únete. Usar ToUpper()en la cadena resultante.

Lua, 122 bytes

Me encantaría usar un patrón para deshacerme de las palabras prohibidas, pero lamentablemente, lua no está hecho para unir grupos de caracteres ... Entonces tuve que usar un bucle for, que es mucho más costoso.

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","").."")

Sin golf

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

Factor, 175 bytes

Aprendí mucho escribiendo esto.

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 una palabra:

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

Pruebas unitarias:

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

¡Pasar!

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

Golfed

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]);}}}}

Legible

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]);
            }
        }
    }
}

Ejecutar desde la línea de comando

75448.exe Amplificación de luz por estimulación de radiación emitida

LÁSER

75448.exe estados unidos de américa

Estados Unidos

IPOS - no competidor, 27 bytes

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

Esto funciona en la versión actual (v0.2) del intérprete .

Ejecución de ejemplo

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

Las barras invertidas solo existen para escapar de las comillas y no son necesarias para el programa.

Explicación

u # Hacer la entrada en mayúscula
S # Empuja un espacio a la pila
`" AND | OR | BY | OF "ER` # Empuja un comando a la pila, que reemplaza las coincidencias de la expresión regular
                   # con una cadena vacía
% # Divide la cadena de entrada en mayúsculas en los espacios, aplica el comando y
                   # unirse de nuevo en los espacios. Esto elimina las palabras requeridas de la entrada.
S # Empuja un espacio a la pila
! h # Presione un comando que solo selecciona el primer carácter de una cadena
% # Dividir en espacios, aplicar el comando y volver a unir en espacios
S- # Eliminar los espacios restantes (olvidé hacer esto útil
                   # con expresiones regulares, me habría ahorrado algunos bytes aquí :()

bash / GNU coreutils, 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 tiene muchos caracteres no ASCII que cuentan 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 (¿no compite ...?)

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

Pruébalo en línea!

Una versión seguramente competidora (21 bytes):

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

Pruébalo en línea!