Un numéronyme (également connu sous le nom de «contraction numérique») est lorsqu'un mot est raccourci à l'aide de chiffres. Une méthode de contraction courante consiste à utiliser la longueur de la sous-chaîne remplacée pour remplacer tous les caractères sauf le premier et le dernier. Par exemple, utilisez i18nau lieu de internationalizationou L10nau lieu delocalization . (Le Lest en majuscule car un minuscule ressemble trop au 1.)

Bien sûr, plusieurs mots dans la même phrase peuvent avoir la même forme abrégée, donc votre travail consiste à convertir un groupe de mots en leurs noms, ou dans le cas où il existe des mots différents avec le même numéro, votre programme devrait donner un résultat de A7s R4t, abréviation de Ambiguous Result(oui, je sais que ce résultat est lui-même un résultat ambigu.)

Règles:

• Utilisez un programme ou une fonction et imprimez ou renvoyez le résultat.
• L'entrée est prise comme une seule chaîne.
• La sortie est une seule chaîne de mots séparés par des espaces.
• Votre programme n'a pas besoin de convertir des mots de longueur 3 et ne doit pas convertir des mots plus courts.
• Si un l(ell minuscule) se produisait avant un 1(un), il devrait être mis en majuscule.
• Si un I(œil majuscule) se produisait avant un 1(un), il devrait être mis en minuscule.
• L'entrée sera ASCII imprimable et des espaces. Les mots sont séparés par des espaces.
• Le code le plus court gagne.

Exemples:

A7s R4t -> A7s R4t (OR: A1s R1t, etc)
Ambiguous Result -> A7s R4t
Billy goats gruff -> B3y g3s g3f
Thanks for the Memories -> T4s f1r the M6s (one possible answer, NOT: Thnks fr th Mmrs)
Programming Puzzles & Code Golf -> P9g P5s & C2e G2f
globalization -> g11n
localizability -> L12y
Internationalization or antidisestablishmentarianism -> i18n or a26m
Internationalization or InternXXXXXalization -> A7s R4t
what is this fiddle and faddle -> A7s R4t
A be see -> A be s1e (OR: A be see)
see sea -> s1e s1a (OR: see sea)
2B or not 2B -> 2B or not 2B (OR: 2B or n1t 2B. 2 letters, don't change, don't count as ambiguous)
this example is this example -> t2s e5e is t2s e5e (same words aren't ambiguous)
l1 -> l1 (2 letters, don't change.)
I1 -> I1 (2 letters, don't change.)

Edit: Si quelqu'un n'a pas obtenu la référence: Merci à Mmrs

J, 92 octets

(' 'joinstring(<&(]`(rplc&('I1';'i1')&(rplc&('l1';'L1'))&({.,([:":#-2:),{:))@.(#>3:))&>&;:))

Une longue chaîne d'appels composés. La première partie est juste un fork: un littéral joinstring, et une fonction (dans J, 1 (10 + +) 2is (10 + (1 + 2))). La deuxième partie est la fonction. Les deux rplcappels doivent remplacer les I / l lorsqu'ils pourraient être confondus. &est la composition et la composition d'un opérateur avec une valeur currys. ( 3&+donne donc une fonction qui s'attend à ce que le 2e argument soit ajouté). Enfin, la dernière partie est la fonction qui prend la première, la longueur-2 (composée avec stringification) et la dernière. le &>&;:bit à la fin compose cette fonction (qui doit être appliquée à chaque argument) à >(unboxing), car ;:(mots fractionnés) renvoie une liste encadrée (de sorte que chaque élément puisse avoir une longueur différente).

exemple:

     (' 'joinstring(<&(]`(rplc&('I1';'i1')&(rplc&('l1';'L1'))&({.,([:":#-2:),{:))@.(#>3:))&>&;:)) 'hey you baby Iooooooooneey I1'
hey you b2y i11y I1

Caché ObjectScript , 231 octets

r(a,b) s o=$REPLACE(o,a,b) q
z(s) f i=1:1:$L(s," ") s u=$P(s," ",i),l=$L(u),o=$S(l<4:u,1:$E(u)_(l-2)_$E(u,l)) d:l>3 r("I1","i1"),r("l1","L1") d  g:r z+4
    . i '(l<4!(v(o)=u!'$D(v(o)))) s r=1 q
    . s v(o)=u,t=t_o_" "
    q t
    q "A7s R4t"

Ce serait un bon MUMPS conforme aux normes s'il n'y avait pas cet $REPLACEappel embêtant , qui ne fait pas partie de la norme. La réimplémentation en M pur prend 80 bons octets, donc je n'ai pas suivi cette voie.

Le point d'entrée est $$z("your string here"), qui revient "y2r s4g h2e", et ainsi de suite.

C #, 280 274 octets

Golfeur pour la première fois ici! J'ai apprécié lire ces derniers temps et j'ai donc pensé que je pourrais en essayer moi-même! Probablement pas la meilleure solution, mais bon!

class B{static void Main(string[] a){string[] n=Console.ReadLine().Split(' ');string o="";int j,i=j=0;for(;j<n.Length;j++){int s=n[j].Length;n[j]=((s<4)?n[j]:""+n[j][0]+(s-2)+n[j][s-1])+" ";o+=n[j];for(;i<j;i++)if(n[j]==n[i]){o="A7s R4t";j=n.Length;}}Console.WriteLine(o);}}

Même chose sans golf:

class B
{
    static void Main(string[] a)
    {            
        string[] n = Console.ReadLine().Split(' ');
        string o = "";
        int j, i = j = 0;
        for(; j < n.Length;j++)
        {
            int s = n[j].Length;

            n[j] = ((s<4) ? n[j] : "" + n[j][0] + (s - 2) + n[j][s - 1]) + " ";
            o += n[j];
            for (; i < j; i++)
            {
                if (n[j] == n[i]) { o = "A7s R4t"; j=n.Length;}
            }                              
        }
        Console.WriteLine(o);
    }
}

Merci les gars!

Perl, 131 120 octets

J'ai ajouté un octet pour utiliser le -pcommutateur:

s/\B(\w+)(\w)/length($1)."$2_$1"/ge;$_="A7s R4t\n"if/(\w\d+\w)(\w+)\b.*\1(?!\2)/;s/_\w+//g;s/I1\w/\l$&/g;s/l1\w/\u$&/g;

Explication

# Replace internal letters with count, but keep them around for the next test.
s/\B(\w+)(\w)/length($1)."$2_$1"/ge;
# Detect ambiguous result
$_ = "A7s R4t\n" if
    # Use negative look-ahead assertion to find conflicts
    /(\w\d+\w)(\w+)\b.*\1(?!\2)/;
# We're done with the internal letters now
s/_\w+//g;
# Transform case of initial 'I' and 'l', but only before '1'
s/I1\w/\l$&/g;
s/l1\w/\u$&/g;

JavaScript (ES6), 165 octets

s=>(r=s.replace(/\S+/g,w=>(m=w.length-2)<2?w:(i=d.indexOf(n=((m+s)[0]<2&&{I:"i",l:"L"}[w[0]]||w[0])+m+w[m+1]))>=0&d[i+1]!=w?v=0:d.push(n,w)&&n,v=d=[]),v?r:"A7s R4t")

Explication

s=>(                         // s = input string
  r=s.replace(               // r = result of s with words replaced by numeronyms
    /\S+/g,                  // match each word
    w=>                      // w = matched word
      (m=w.length-2)         // m = number of characters in the middle of the word
        <2?w:                // if the word length is less than 4 leave it as it is
      (i=d.indexOf(          // check if this numeronym has been used before
        n=                   // n = numeronymified word
          ((m+s)[0]<2&&      // if the number starts with 1 we may need to replace
            {I:"i",l:"L"}    //     the first character with one of these
              [w[0]]||w[0])+ // return the replaced or original character
          m+w[m+1]
      ))>=0&d[i+1]!=w?       // set result as invalid if the same numeronym has been
        v=0:                 //     used before with a different word
      d.push(n,w)&&n,        // if everything is fine return n and add it to the list
    v=                       // v = true if result is valid
      d=[]                   // d = array of numeronyms used followed by their original word
  ),
  v?r:"A7s R4t"              // return the result
)

Tester

<input type="text" id="input" value="lnternationalization or antidisestablishmentarianism" />
<button onclick='result.textContent=(

s=>(r=s.replace(/\S+/g,w=>(m=w.length-2)<2?w:(i=d.indexOf(n=((m+s)[0]<2&&{I:"i",l:"L"}[w[0]]||w[0])+m+w[m+1]))>=0&d[i+1]!=w?v=0:d.push(n,w)&&n,v=d=[]),v?r:"A7s R4t")

)(input.value)'>Go</button>
<pre id="result"></pre>

JavaScript ES6, 162

w=>(v=(w=w.split` `).map(x=>(l=x.length-2+'')>1?((l[0]>1||{I:'i',l:'L'})[x[0]]||x[0])+l+x[-~l]:x)).some((a,i)=>v.some((b,j)=>a==b&w[i]!=w[j]))?'A7s R4t':v.join` `

Moins golfé

// Less golfed
f=w=>{
  w = w.split` ` // original text splitted in words
  v = w.map(x=> { // build modified words in array v

    l = x.length - 2 // word length - 2
    if (l > 1) // if word length is 4 or more
    {
      a = x[0] // get first char of word
      l = l+'' // convert to string to get the first digit
      m = l[0] > 1 || {I:'i', l:'L'} // only if first digit is 1, prepare to remap I to i and l to L
      a = m[a] || a // remap
      return a + l + x[-~l] // note: -~ convert back to number and add 1
    }
    else
      return x // word unchanged
  })
  return v.some((a,i)=>v.some((b,j)=>a==b&w[i]!=w[j])) // look for equals Numeronyms on different words
  ? 'A7s R4t' 
  : v.join` `
}  

Tester

F=w=>(v=(w=w.split` `).map(x=>(l=x.length-2+'')>1?((l[0]>1||{I:'i',l:'L'})[x[0]]||x[0])+l+x[-~l]:x)).some((a,i)=>v.some((b,j)=>a==b&w[i]!=w[j]))?'A7s R4t':v.join` `

console.log=x=>O.innerHTML+=x+'\n'

;['A7s R4t','Ambiguous Result','Billy goats gruff','Thanks for the Memories',
'Programming Puzzles & Code Golf','globalization','localizability',
'Internationalization or antidisestablishmentarianism',  
'Internationalization or InternXXXXXalization','what is this fiddle and faddle',
'A be see','see sea','2B or not 2B','this example is this example','l1','I1']
.forEach(t=>console.log(t+' -> '+F(t)))

<pre id=O></pre>

Python 2, 185 octets

d={}
r=''
for w in input().split():
 l=len(w);x=(w[0]+`l-2`+w[-1]).replace('l1','L1').replace('I1','i1')
 if l<4:x=w
 if d.get(x,w)!=w:r='A7s R4t';break
 d[x]=w;r+=x+' '
print r.strip()

Python 3, 160

J'adorerais trouver un bon moyen de remplacer ces appels de remplacement.

def f(a):y=[(x,(x[0]+str(len(x)-2)+x[-1]).replace('l1','L1').replace('I1','i1'))[len(x)>3]for x in a.split()];return('A7s R4t',' '.join(y))[len(set(y))==len(y)]

Avec quelques cas de test:

assert f('Billy goats gruff') == 'B3y g3s g3f'
assert f('Programming Puzzles & Code Golf') == 'P9g P5s & C2e G2f'
assert f('Internationalization or InternXXXXXalization') == 'A7s R4t'

Facteur, 48 35 octets, sans concurrence

C'est une lambda qui va sur la pile, qui ne répond pas techniquement aux exigences vraiment énervantes que j'ai réussi à ignorer à l'origine.

[ " " split [ a10n ] map " " join ]

Utilise le englishvocabulaire.

Ou, si nous alignons le a10n mot de bibliothèque, alors 131 octets (avec les importations automatiques):

: a ( b -- c ) " " split [ dup length 3 > [ [ 1 head ] [ length 2 - number>string ] [ 1 tail* ] tri 3append ] when ] map " " join ;