Inspirado por el C- director #define.

Desafío

Dada una frase con un alias y una matriz con cada texto de alias. Salida de la frase inicial reemplazando cada alias con su texto respectivo.

Un alias se define por una nitidez #seguida de su índice en la matriz (el índice puede comenzar en cero o uno). Alias ​​puede contener otro alias dentro de su texto, y debe resolverlos todos (tal vez de forma recursiva). Puede suponer que el alias nunca se ejecutará en un bucle infinito. El alias no tendrá ceros a la izquierda ( #02no es un alias en el índice 2, es un alias en el índice 0seguido del texto 2).

Puede suponer que la matriz no pasará 20 elementos de longitud.

Puedes escribir un programa, o una función o incluso un #define- sería bueno :)

También puede usar otro método de entrada que se ajuste mejor a su idioma.

Ejemplo

phrase: "#0 & #3"
array: [
    "Programming #1",
    "Puzzles",
    "Code",
    "#2 Golf"
]
output: "Programming Puzzles & Code Golf"

Paso a paso:

0> "#0 & #3"
1> "Programming #1 & #2 Golf"
2> "Programming Puzzles & Code Golf"

Como se trata de código de golf , ¡la respuesta más corta en bytes gana!

Otras muestras

phrase: "#0!"
array: [
    "We are #1",
    "#2",
    "#3",
    "#4 !",
    "graduating"
]
output: "We are graduating !!"

phrase: "##0#1#0#21#3#4"
array: [
    "a",
    "m",
    "z",
    "n",
    "g"
]
output: "#amaz1ng"

phrase: "##1#23"
array: [
    "WEIRD",
    "0 C",
    "AS"
]
output: "WEIRD CAS3"

phrase: "#1#7#6y#4#7#10s#7b#11#0#0#11r#7#0h#6#5#2#5#9#4."
array: [
    "t",
    "#12#3",
    "#11ga#3",
    "#0#10v#11",
    "#0h#10#8g",
    "#7#8",
    "a#8",
    " ",
    "n",
    "o",
    "i",
    "e",
    "P#9s#10"
]
output: "Positive anything is better than negative nothing."

Los ejemplos anteriores utilizan Array con índice que comienza en cero.

JavaScript (ES6) 58

Función recursiva

f=(s,h,r=s.replace(/#(1?\d)/g,(_,x)=>h[x]))=>r==s?r:f(r,h)

Prueba

f=(s,h,r=s.replace(/#(1?\d)/g,(_,x)=>h[x]))=>r==s?r:f(r,h)

// Version without default parameters, same length but using a global
// f=(s,h)=>(r=s.replace(/#(1?\d)/g,(_,x)=>h[x]))==s?r:f(r,h)

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

;[
  ['##1#23',['WEIRD','0 C','AS']],
  ["#0!",["We are #1","#2","#3","#4 !","graduating"]],
  ["##0#1#0#21#3#4",["a","m","z","n","g"]],
  ["##0#1#0#21#13#4",["a","m","z","","g","","","","","","","","","n"]],
  ["#1#7#6y#4#7#10s#7b#11#0#0#11r#7#0h#6#5#2#5#9#4.",
    ["t","#12#3","#11ga#3","#0#10v#11","#0h#10#8g","#7#8","a#8"," ","n","o","i","e","P#9s#10"]
  ],
  ["#0 & #3",["Programming #1","Puzzles","Code","#2 Golf"]]
].forEach(t=>{
  var a=t[0],b=t[1]
  console.log(a+' ['+b+']\n -> '+f(a,b))
})

<pre id=O></pre>

Mathematica, 74 bytes

FixedPoint[#~StringReplace~a&,a=0;a=Reverse["#"<>ToString@a++->#&/@#2];#]&

No muy complicado La mayor parte está dedicada a crear los índices.

Julia, 112 107 66 bytes

f(s,x)=(r=replace(s,r"#1?\d",m->x[1+parse(m[2:end])]))==s?s:f(r,x)

Esta es una función recursiva que acepta una cadena y una matriz y devuelve una cadena. Utiliza indexación basada en 0.

Comenzamos construyendo una cadena r como la cadena de entrada s con todas las coincidencias de la expresión regular #1?\dreemplazadas por el elemento de x correspondiente a 1 + el entero analizado fuera de la coincidencia. Si esto es igual a s , devolvemos s , de lo contrario repetimos, pasando r como la cadena.

C, 269 232

#define f(p,a,l)char*n,o[999],i=0,c,x;for(strcpy(o,p);o[i];)o[i]==35&isdigit(o[i+1])?c=o[i+1]-48,c=isdigit(o[i+2])&c?10*c+o[i+2]-48:c,n=a[c<l?c:c/10],x=strlen(n),memmove(o+i+x,o+i+2+c/10,strlen(o+i)),i=!memmove(o+i,n,x):++i;puts(o);

Según lo solicitado, ¡una sola #definesolución al problema! Las macros C no pueden ser recursivas, por lo que el problema tuvo que resolverse de forma iterativa. La macro toma 3 argumentos; la frase p, la matriz ay la longitud de la matriz l. Solo eliminé los espacios en blanco de mi solución no reflejada; Sé que hay algunos personajes más que puedo guardar, pero no creo que me pongan por debajo de 200. Esto definitivamente no será una solución competitiva. La solución está totalmente desarrollada. Solución sin golf en forma de una función a continuación:

f(char*p,char**a,int l){
  char o[999]={0},i=0;
  strcpy(o,p);
  while(o[i]){
    if(o[i]=='#'&&isdigit(o[i+1])){
      int c = o[i+1]-'0';
      if(isdigit(o[i+2])&&c)
        c=10*c+o[i+2]-'0';
      if(c>=l)
        c/=10;
      char *n=a[c];
      memmove(o+i+strlen(n),o+i+2+c/10,strlen(o+i));
      memmove(o+i,n,strlen(n));
      i=0;
    }else{
      i++;
    }
  }
  puts(o);
}

Y código de prueba:

void test(char *phrase, char **array, int length) {
  f(phrase, array, length);
}

main() {
  const char *t1[] = {
    "Programming #1","Puzzles","Code","#2 Golf"
  };
  test("#0 & #3", t1, 4);

  const char *t2[] = {
    "We are #1","#2","#3","#4 !","graduating"
  };
  test("#0!", t2, 5);

  const char *t3[] = {
    "a","m","z", "n","g"
  };
  test("##0#1#0#21#3#4", t3, 5);

  const char *t4[] = {
    "WEIRD","0 C","AS"
  };
  test("##1#23", t4, 3);

  const char *t5[] = {
    "t","#12#3","#11ga#3","#0#10v#11","#0h#10#8g","#7#8","a#8"," ","n","o","i","e","P#9s#10"
  };
  test("#1#7#6y#4#7#10s#7b#11#0#0#11r#7#0h#6#5#2#5#9#4.", t5, 13);
}

EDITAR: Trabajó un poco de magia de golf. Es tan corto e ilegible como creo que puede llegar a ser.