Objectif

Votre objectif est de créer un programme qui convertit une entrée en son acronyme. Votre saisie est garantie d'avoir uniquement des lettres et des espaces. L'entrée aura exactement un espace entre les mots. Vous devez sortir l'acronyme de l'entrée.

Règles

• Votre code ne peut pas être sensible à la casse (par exemple fooet Foosont les mêmes)
• Votre code doit ignorer les mots suivants et ne pas les mettre dans l'acronyme: and or by of
• Vous ne pouvez pas supposer que les mots sont tous en minuscules.
• La sortie doit être entièrement en majuscule, sans séparation entre les caractères.
• Une nouvelle ligne de fin est acceptée mais pas nécessaire.
• Si votre langue a une fonction d'acronyme intégrée, vous ne pouvez pas l' utiliser.

Exemples

(entrées / sorties regroupées)

United States of America
USA

Light Amplification by Stimulation of Emitted Radiation
LASER

united states of america
USA

Jordan Of the World
JTW

Notation

Il s'agit d'un défi de code-golf , donc le code le plus court l'emporte.

Classement

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 octets

shM-crz1dc4."@YK½¼

Essayez-le ici!

Merci à @Jakube d'avoir enregistré un octet!

Explication

shM-crz1dc4. "@ YK½¼ # z = entrée

     rz1 # convertir l'entrée en majuscules
    entrée cd # split sur les espaces
         c4. "@ YK½¼ # créer une liste de mots à partir d'une chaîne compressée qui doit être ignorée
   - # filtre ces mots
 hM # ne prend que la première lettre de tous les mots
s # les joindre en une seule chaîne

La chaîne emballée devient ANDBYOROF

Gelée , 21 20 octets

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

Essayez-le en ligne!

(-1 grâce à @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

Le dictionnaire de Jelly est un peu bizarre en ce qu'il a ANDen majuscule mais byen minuscule ...

Rétine, 29 31 36 octets

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

Nouvelle ligne prévue à la fin.

Merci à Martin Büttner pour avoir économisé 5 octets

Essayez-le en ligne

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 octets

Enregistré un octet grâce à @ edc65.

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

Explication

Le code est explicite, je vais juste expliquer l'expression régulière:

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

Il a supprimé tous ces caractères assortis et majuscule le mot

JavaScript, 61 64 66 63 octets

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

Il utilise une expression régulière pour rechercher des mots qui ne sont pas dans la liste: and, or, of, byet capture la première lettre. Il met ensuite en majuscule la chaîne de lettres résultante.

EDIT: 64 octets - corrigé pour les mots commençant parof,or,by,and

EDIT: 66 octets - Correction pour vérifier tous les mots, y compris le dernier mot.

EDIT: 63 octets - 3 octets enregistrés grâce à @ edc65 et @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

J'aime particulièrement ce dernier morceau. Le premier .de l'expression régulière correspond au premier caractère de la ligne. Ensuite, nous utilisons \zspour démarrer la partie "en cours de remplacement", sans remplacer le caractère initial. .*correspond au reste de la ligne et \ncorrespond à la nouvelle ligne de fin. Puisque nous ne spécifions pas de chaîne de remplacement, vim supprime simplement tout ce qui se trouve dans la correspondance, ne laissant que les initiales.

CJam, 28 24 22 octets

qeuS/"AOBONRYFD"4/z-:c

Essayez-le en ligne . Merci à Sp3000 d'avoir signalé un bug et suggéré un correctif, et à Dennis d'avoir économisé 4 6 (!) Octets.

Explication

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 a suggéré cette astuce pour raccourcir la liste de mots: en se divisant AOBONRYFDen morceaux de quatre, nous obtenons

AOBO
NRYF
D

En transposant les colonnes en lignes avec l' zopérateur, on obtient les bons mots!

Julia, 72 63 61 55 octets

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

Il s'agit d'une fonction anonyme qui accepte une chaîne et renvoie une chaîne. Pour l'appeler, affectez-le à une variable.

Nous convertissons la chaîne en uppercase, sélectionnons chaque correspondance de l'expression régulière \b(?!AND|OR|OF|BY)\Ssous forme de tableau et la jointransformons en chaîne.

8 octets enregistrés grâce à Dennis!

Perl, 32 octets

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

+1 octet pour le -ndrapeau.

Algorithme volé dans la réponse Julia d'Alexa .

Rubis, 45 43 octets

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

Il s'agit d'une fonction lambda qui accepte une chaîne et renvoie une chaîne. Pour l'appeler, affectez-le à une variable et faites f.call(input).

Il utilise la même approche que ma réponse Julia , à savoir convertir en majuscules, obtenir des correspondances de l'expression régulière \b(?!AND|OR|OF|BY)\Set se joindre à une chaîne.

Essayez-le ici

Enregistré 2 octets grâce à la manœuvre!

PHP, 92 octets

Première tentative de code golf.

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

La variable $sest l'expression à convertir: $s = "United States of America".

Nécessite PHP 5.4 ou supérieur pour que la syntaxe du tableau court fonctionne.

Bash + GNU coreutils, 103 76 octets

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

Courir avec

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

soit avec un seul argument cité ou avec plusieurs arguments.

(J'ai déformé le dernier mot à contenir de ).

60 octets

Merci à @manatwork.

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

JavaScript, 104 85 octets

19 octets enregistrés grâce à @ Aplet123 .

Fractionne la chaîne par des espaces puis vérifie s'il s'agit des mots de, ou, et, ou de. S'il l'est, il l'ignore, sinon il en prend la première lettre. Il rejoint ensuite le tableau et rend la chaîne en majuscules.

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

Non 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 octets

1 octet de moins grâce à @AandN

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

Essayez-le en ligne!

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 octets

Code:

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

Utilise l' encodage CP-1252 .

Python, 81 octets

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 octets

Je suis sûr que cela peut être raccourci beaucoup plus car je continue à utiliser $, .etc. donc je continue à utiliser ()insted =)

Merci @nimi pour votre aide magique!

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

Exemple:

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

Python, 103 96 octets

Ceci est ma première tentative de golf de code, et cela pourrait probablement être joué beaucoup plus. Merci à DenkerAffe d'avoir enregistré sept caractères.

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

Il prend l'entrée, la transforme en une liste de mots et prend sa première lettre si ce n'est pas l'un des mots interdits, puis transforme tout en majuscules.

JavaScript, 80 72 55 53 octets

Code

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

Je viens de lire sur les fonctions des flèches et j'ai réalisé que je pouvais raccourcir encore plus.

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

Selon cela , vous ne comptez pas l'affectation dans la longueur, donc -2 octets.

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

C'est mon premier golf, donc ce n'est pas très bon.

PHP, 68 61 58 octets

Utilise le codage ISO-8859-1.

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

Courez comme ceci ( -dajouté pour l'esthétique uniquement):

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

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

• Enregistré 7 octets en utilisant AND au niveau du bit au lieu d'utiliser ucwords.
• Enregistré 3 octets en utilisant le codage ISO-8859-1 et en utilisant ß(binaire 11011111) pour binaire ANDau lieu d'un espace annulé (binaire 00100000).

Mathematica, 132 117 octets

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

15 octets enregistrés grâce à @CatsAreFluffy.

PowerShell, 81 octets

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

Explication

Séparez les espaces en créant un tableau. Supprimez les membres incriminés. Tirez le premier caractère et réunissez-vous. Utiliser ToUpper()sur la chaîne résultante.

Lua, 122 octets

J'aurais adoré utiliser un modèle pour se débarrasser des mots interdits, mais malheureusement, lua n'est pas fait pour correspondre à des groupes de caractères ... J'ai donc dû utiliser une boucle for à la place, ce qui est beaucoup plus cher.

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

Non 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

Facteur, 175 octets

J'ai beaucoup appris en écrivant ceci.

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 

En un mot:

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

Tests unitaires:

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

Passer!

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 octets

Golfé

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

Lisible

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

Exécuter à partir de la ligne de commande

75448.exe Amplification de la lumière par stimulation du rayonnement émis

LASER

75448.exe États-Unis d'Amérique

Etats-Unis

IPOS - non concurrent, 27 octets

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

Cela fonctionne dans la version actuelle (v0.2) de l'interpréteur .

Exemple d'exécution

python IPOS.py -i "États-Unis d'Amérique" uS` \ "ET | OU | BY | OF \" ER`% S! h% S-
Etats-Unis

Les barres obliques inverses ne servent qu'à échapper les guillemets et ne sont pas nécessaires pour le programme.

Explication

u # Mettre l'entrée en majuscule
S # Poussez un espace vers la pile
`" AND | OR | BY | OF "ER` # Poussez une commande dans la pile, qui remplace les correspondances de l'expression régulière
                   # avec une chaîne vide
% # Fractionnez la chaîne d'entrée en majuscules sur les espaces, appliquez la commande et
                   # Rejoignez les espaces. Cela supprime les mots requis de l'entrée.
S # Poussez un espace vers la pile
! h # Appuyez sur une commande qui ne sélectionne que le premier caractère d'une chaîne
% # Fractionner sur les espaces, appliquer la commande et rejoindre à nouveau sur les espaces
S- # Supprimer les espaces restants (oublié de rendre cela utilisable
                   # avec des expressions rationnelles, cela m'aurait fait économiser quelques octets ici :()

bash / GNU coreutils, 60 octets

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

Pylongolf2 , 14 octets (UTF-8)

c| l1╨3♀~

Pylongolf2 possède de nombreux caractères non ASCII qui comptent pour 2 octets.

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 octets (non concurrent ...?)

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

Essayez-le en ligne!

Une version sûrement concurrente (21 octets):

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

Essayez-le en ligne!