Resumen

Se le dijo a un maestro que preparara problemas de palabras para los estudiantes. Le dan una lista de ecuaciones y le dicen que las escriba como el problema verbal correspondiente. Sin embargo, ella es muy perezosa, por lo que no le pone mucha creatividad. En cambio, ella simplemente lo escribe literalmente. Por ejemplo, cuando lee 1+1, escribe one plus one, 47 * 2se convertiría forty seven times twoy 56.2 / 7.4se convertiría fifty six point two divided by seven point four.

Escribe un código para ayudar a este maestro perezoso.

Detalles

• Los números pueden incluir un punto decimal y un signo negativo.
• Los números deben escribirse en la escala corta. (es decir, 1,000,000,000es one billion)
• Los números pueden ir hasta 999,999,999,999,999,999 ( nine hundred ninety nine quadrillion...nine hundred ninety nine).
• Los grupos de ceros deben quedar fuera. por ejemplo no lo 1,000,000es .one millionone million zero thousand zero hundred
• Puede haber arbitrariamente muchos dígitos más allá del punto decimal.
• Los dígitos después del punto decimal se deben enumerar dígito a dígito. por ejemplo no lo 12.34es .twelve point three fourtwelve point thirty four
• Dos números siempre están separados por un operador.
• Los operadores válidos son más ( +), menos ( -), veces ( *) y divididos por ( /).
• No hay paréntesis.
• Los números como 1234pueden incluir opcionalmente un anden su salida, como en one thousand two hundred *and* thirty four.
• Se pueden ignorar las comas y los espacios en blanco en la entrada.

Ejemplos

Entrada: 24 + 65
Salida:twenty four plus sixty five

Entrada: 3.33333 - 0
Salida:three point three three three three three minus zero

Entrada: 3.6 * 18.18 / 999.0
Salida:three point six times eighteen point one eight divided by nine hundred ninety nine point zero

Entrada: 1-1
Salida:one minus one

Entrada: 1+-1
Salida:one plus negative one

Entrada: 1,000,000,000 + 0.2
Salida:one billion plus zero point two

Entrada: 123,000,456,789,012,345.6789
Salida:one hundred twenty three quadrillion four hundred fifty six billion seven hundred eighty nine million twelve thousand three hundred forty five point six seven eight nine

Entrada: -4.3 * 7
Salida:negative four point three times seven

Entrada: -1-1--1
Salida:negative one minus one minus negative one

JavaScript (ES6), 552 532 bytes

Este monstruo sucio viene directamente de las profundidades del infierno de golf de códigos.

Espera una cadena de entrada sin espacios en blanco.

S=>S[R='replace'](/[\d.,]+|./g,s=>1/s[0]?a(+s[S=0]&&14)+s[R](/(\D?)(\d+)/g,(_,s,n)=>s>','?' point'+n[R](/./g,a):j--*n?(u=a(n%10||14),n>99?a(n[0])+' hundred':'')+((n%=100)<13?a(n||14):n<20?(a(n)||u)+'teen':(a(n/10+18)||a(n/10))+'ty'+u)+a(j+27)+(j>1?'illion':''):'',j=s.split`,`.length):a(S='+-*/'.indexOf(s=='-'&&S||s)+34),a=n=>(s='zero0one0two0three0four0five0six0seven0eight0nine0ten0eleven0twelve0thir00fif000eigh00twen0thir0for0fif000eigh00thousand0m0b0tr0quadr0negative0plus0minus0times0divided by'.split`0`[n|0])&&' '+s).trim()

Pruébalo en línea!

Perl 6 , 434 401 387 359 bytes

{~S:g/\d+/{n($//100+64184)x($/>100),$/%100>19&&(n($//10%10+64175),n($!=$/%10)x?$!)||n($/%100+7679),[$,"thousand",|(<m b tr quadr>X~"illion")][+$/.postmatch.words[0].comb(',')]if +$/} /.trans("+,-/*"=><<plus''minus"divided by"times>>).words}o{S:g/\.(\d)+/ point {$0>>.&n}/}o{S:g/[\s|^]0/ zero/}o{S:g/\-(\d)/negative $0/}
my&n=(*+1632+|0).uniname.lc.words[2..*]

Pruébalo en línea!

Definitivamente margen de mejora aquí. Digo eso, pero sigo notando casos extremos que no he manejado :(. Asume que la entrada tiene operadores separados por espacios en blanco y que el negativo de un número no está separado.

Explicación:

my&n=(*+1632+|0).uniname.lc.words[2..*]  # Define a helper function
           # This gets the unicode name, e.g ARABIC-INDIC DIGIT ZERO
           #                              or AEGEAN NUMBER ONE HUNDRED
           # And returns the 3rd word onwards in lowercase e.g. 'zero' or 'one hundred'
{S:g/\-(\d)/negative $0/}  # Turn dashes before numbers to negative
{S:g/[\s|^]0/ zero/}       # Handle zeros
{S:g/\.(\d)+/ point {$0>>.&n}/}  # Replace decimals
{~S:g/\d+/        # Replace series of numbers with
    n($//100+64184)x($/>100)  # The hundreds if the num is bigger than 100
    $/%100>19&&               # If the number is bigger than 19
      (
      n($//10%10+64175),         # The tens number
      n($!=$/%10)x?$!            # And the singles number (if it's not zero)
      )
    ||                        # Else
      n($/%100+7679)             # The name of the number below 20
    ,                      # Then
    [$,"thousand",|(<m b tr quadr>X~"illion")][   # Index into the list of postfixes
      +                         .comb(',')   # The number of commas
       $/.postmatch.words[0]  # in the rest of the number
  if +$/           # All if the number is not 0
.trans("+,-/*"=><<plus''minus"divided by"times>>)  # Translate operators
                                                   # And remove commas
.words}     # And remove all the excess spaces between words

Ruby + Swift 4, 283 279 270 bytes

$_=gsub(/(?<=\d)-/,"minus ").gsub(/[*-\/]/,?.=>"point ",?-=>"negative ",?+=>"plus ",?*=>"times ",?/=>"divided by ").gsub(/(?<=^|[^t] )\d+|\d/){`echo "import Foundation
var f=NumberFormatter()
f.numberStyle = .spellOut
print(f.string(from:#$&)!)">.a
swift .a`.tr'-
',' '}

Pruébalo en línea!

Debo estar loco para proponer tal solución de Frankenstein, pero por un lado, es muy tentador usar la funcionalidad incorporada de Swift para esta tarea, y por otro lado, procesar cadenas con Regexes en Swift parece ser una catástrofe de golf.

Por lo tanto, decidí hacer el procesamiento básico de cadenas en Ruby, pero para deletrear los números, los almaceno en un archivo fuente Swift, ejecuto Swift en un comando de shell y recopilo la salida.

Resulta que el formateador de números "spellOut" de Swift hace casi exactamente lo que necesitamos, excepto insertar guiones innecesarios para números de dos dígitos, como en twenty-two. De hecho, incluso la salida de coma flotante en el formato de integer part point digit digit...es buena, pero aquí viene la advertencia: no hay precisión infinita, y con números lo suficientemente grandes o una gran cantidad de dígitos decimales, los resultados salen mal. Por lo tanto, tuve que separar las partes enteras y fraccionarias y alimentar la fracción dígito por dígito.

sfk , 853 bytes

xed -i
"_*_ [part1]_"
+xed
_+_plus_
_\*_times_
"_/_divided by_"
"_- _minus _"
"_-_negative _"
+xed
"_,[keep][19 chars of 0-9,]_quadr@ _"
"_,[keep][15 chars of 0-9,]_tr@ _"
"_,[keep][11 chars of 0-9,]_b@ _"
"_,[keep][digits],[digits],_b@ _"
"_,[keep][digits],_m@ _"
"_,_ thousand _"
+xed
"_ 000[chars]@__"
"_ 000__"
"_ 00[keep][digit]_ _"
"_ 0[keep][2 digits]_ @_"
"_ [digit][keep][2 digits]_[part2]hundred @_"
"_ [ortext] 0[digit]0_ @[part2]_"
"_ [keep][2 digits]_ @_"
"_@_illion _"
+xed
_@11_eleven_
_@12_twelve_
_@1[digit]_@[part2]teen_
_@1_ten_
_@4_forty_
_@[digit]_@[part2]ty_
+xed
_@2_twen_
_@3_thir_
_@4_four_
_@5_fif_
_@6_six_
_@7_seven_
_@8_eigh_
_@9_nine_
+xed
"_0_ zero _"
"_1_ one _"
"_2_ two _"
"_3_ three _"
"_4_ four _"
"_5_ five _"
"_6_ six _"
"_7_ seven _"
"_8_ eight _"
"_9_ nine _"
"_._ point _"
+xed
"_[white]_ _"
+xed
"_[lstart] __"

Pruébalo en línea!

Requiere que los operadores y los números estén separados por al menos un carácter de espacio.

Limpio , 766 ... 687 bytes

import StdEnv,Text
m=""
z="zero"
@ =digitToInt
r=reverse
l k=(!!)k o@
^s=l[s:split" ""one two three four five six seven eight nine"]
g s=l[m,m,"twen","thir",s,"fif","six","seven","eigh","nine"]
~['0':t]= ~t
~[a,b,c]= ^""a+" hundred "+ ~[b,c]
~[b,c]|b>'1'=g"for"b+"ty "+ ^""c|c>'2'=g"four"c+"teen"=["ten","eleven","twelve"]!!(@c)
~[c]= ^""c
~_=m
$[]=m
$[x:y]#(h,t)=span(\e=e>'/'||e==',')if(x<'1')y[x:y]
=trim(join" "((case x of'0'=[z];'-'=["negative",$h];'.'=["point":map(^z)h];_=(r[u+v\\u<-r(map~(split[',']h))&v<-[m," thousand":[" "+k+"illion"\\k<-["m","b","tr","quadr"]]]|u>m]))++[?t]))
?['-':t]="minus "+ $t
?['+':t]="plus "+ $t
?['/':t]="divided by "+ $t
?['*':t]="times "+ $t
?t= $t

Pruébalo en línea!

Espera una cadena sin espacios en blanco.

05AB1E , 315 295 282 276 bytes

"+-*/"DˆS¡εDõQi'¢…ë'.¡VYнD_i\'¡×ðë',¡DgUε0›i.•6b©•ð“†ìˆÈŒšï¿Ÿ¯¥Š“©'tKJ#'…§«…€µ‚•„í#®#«…—¿áÓÁÏ#«ìD9£©.•4º»Ÿć'Rþн•ŽH$S£“Œšï¿Ÿ¯¥Š“'tK#«„ty«sõšâðý«õšD®'°¡ðì«sâðý«yèð.•cG3₅¦„¥F•8ô'¾ß«…¡›‡È±°#«õªRXN-<èJëõ}}ðý}Yg<i®'¡×šYθSè'…®šðý}}J}s¯`Ã哉´Øè„ƺߓ#¤… by«¸s¨ì¯`ykè}.ιðý„  ð:„¢…Øè'¢…:

Toma entrada sin espacios.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

"+-*/"                    # Push string "+-*/"
Dˆ                        # Duplicate it, pop the copy, and push it to the global array
S¡                        # Split the input by any "+", "-", "*", or "/"
ε                         # Map each number to:
 DõQi                     #  If the item is empty (happens for negative numbers)
     '¢…                 '#   Push string "negative"
 ë                        #  Else:
  '.¡                    '#   Split by "."
  VY                      #   Store it in variable `Y`
  н                       #   Take the first number (the integer part)
  D                       #   Duplicate this integer part
  _i                      #   If the integer part is exactly 0:
    \                     #    Discard the duplicated integer part
    '¡×                  '#    Push string "zero"
    ð                     #    Push a space " "
  ë                       #   Else:
   ',¡                   '#    Split by ","
   DgU                    #    Pop and store the amount of items in variable `X`
      ε                   #    Map each part to:
       0›i                #     If it's larger than 0:
          .•6b©•          #      Push string "thir"
          ð               #      Push a space " "
          “†ìˆÈŒšï¿Ÿ¯¥Š“  #      Push string "four five six seven eight nine"
          ©               #      Store it in the register (without popping)
           'tK           '#      Remove all "t" (so "eight" becomes "eigh")
          J               #      Join it together with the "thir" and space
          #               #      Split by spaces
          '…§            '#      Push string "teen"
             «            #      And append it to every string in the list
                          #      (We now have ["thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"])
          …€µ‚•„í         #      Push string "one two three"
                 #        #      Split by spaces
          ®               #      Push the string from the register ("four" through "nine")
           #«             #      Split by spaces, and merge both lists together
          …—¿áÓÁÏ         #      Push string "ten eleven twelve"
                 #«       #      Split by spaces, and also merge both lists together
          ì               #      Prepend "one" through "twelve" before "thirteen" through "nineteen"
          D9£             #      Duplicate it, and take the first nine ("one" through "nine")
             ©            #      Store it in the register (without popping)
          .•4º»Ÿć'Rþн•   '#      Push string "twenthirforfif"
          ŽH$             #      Push integer 4433
             S            #      Split to digits: [4,4,3,3]
              £           #      And split the to parts of that size: ["twen","thir","for","fif"]
          “Œšï¿Ÿ¯¥Š“      #      Push string "six seven eight nine"
                    'tK  '#      Remove all "t" (so "eight" becomes "eigh")
                       #« #      Split by spaces, and merge both lists together
          „ty             #      Push string "ty"
             «            #      And append it to every string in the list
                          #      (We now have ["twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety"])
          s               #      Swap so the list "one" through "nine" is at the top again
           õš             #      Prepend an empty string to that list
             â            #      Create every possible pair of "one" through "nine" with "twenty" through "ninety"
              ðý          #      Join each pair with a space delimiter
          «               #      Merge the "twenty" through "ninety nine" list with "one" through "nineteen"
           õš             #      Prepend an empty string to that list
          D               #      Duplicate the entire list
          ®               #      Push the string from the register ("one" through "nine")
          '°¡            '#      Push string "hundred"
             ðì           #      Prepend it with a space " "
               «          #      Append it to every string in the list
                          #      (We now have ["one hundred","two hundred",...,"nine hundred"])
          s               #      Swap the two lists
           â              #      Create every possible pair of "one hundred" through "nine hundred" with "" through "ninety nine"
            ðý            #      Join each pair with a space delimiter
              «           #      Merge the "one" through "ninety nine" with "one hundred " through "nine hundred ninety nine"
                          #      (We now have ["","one",...,"nine hundred ninety nine"])
          y               #      Get the current number of the map
           è              #      And index it into this list
          ð               #      Push a space " "
          .•cG3₅¦„¥F•     #      Push string "quadrilltrill"
                     8ô   #      Split into pieces of size 8: ["quadrill","trill"]
          '¾ß            '#      Push string "ion"
             «            #      Append it to every string in the list
          …¡›‡È±°         #      Push string "billion million thousand"
                 #        #      Split by spaces
                  «       #      And merge both lists together
          õª              #      Append an empty string
            R             #      Reverse the list
                          #      (We now have ["","thousand","million","billion","trillion","quadrillion"])
          X               #      Push variable `X`
           N-             #      Subtract the map-index from it
             <            #      Subtract an additional 1
              è           #      And index it into the list
          J               #      Join the stack together
       ë                  #     Else:
        õ                 #      Push an empty string ""
       }                  #     Close the if-else
      }                   #    Close the map
      ðý                  #    Join the mapped values with space delimiter
  }                       #   Close the if-else
  Y                       #   Push variable `Y`
  g<i                     #   If its length is exactly 2:
     ®                    #    Push the string from the register ("one" through "nine")
     '¡×                 '#    Push "zero"
        š                 #    Prepend it to the list
      Yθ                  #    Push variable `Y` again, and leave the second number (the decimal part)
        S                 #    Split it to digits
         è                #    And index each into the list
      '…®                '#    Push string "point"
         š                #    Prepend it in front of that list
      ðý                  #    Join the list with space delimiter
  }                       #   Close the if
 }                        #  Close the if-else
 J                        #  Join the stack together
}                         # Close the map
s                         # Swap to take the (implicit) input again
¯`                        # Push the global array, and dump it's content (string "+-*/")
  Ã                       # Only keep all "+", "-", "*", and "/", and remove everything else
ε                         # Map each to:
 “‰´Øè„ƺߓ               #  Push string "plus minus times divided"
           #              #  Split by spaces
 ¤                        #  Take the last item (without popping the list)
  … by«                   #  Append it with string " by"
       ¸                  #  Wrap it to a list: ["divided by"]
 s                        #  Swap to take the list again
  ¨                       #  Remove the last item
   ì                      #  Prepend it in front of the list: ["plus","minus","times","divided by"]
 ¯`                       # Push the global array, and dump it's content (string "+-*/")
   yk                     #  Push the index in this string for the current map-value `y`
     è                    #  And use that index to index into the string-list
}                         # Close the map
.ι                        # Interweave the list of numbers and list of operators
  ðý                      # Join everything with space delimiter
„  ð:                     # Replace every two spaces for a single space
„¢…Øè'¢…:                '# And replace every "negative minus" with "negative"
                          # (and output the result implicitly)

Consulte esta sugerencia mía 05AB1E (secciones ¿Cómo usar el diccionario ? , ¿Cómo comprimir cadenas que no forman parte del diccionario? Y ¿Cómo comprimir enteros grandes? ) Para comprender por qué:

• ( ¿Cómo usar el diccionario? ) - '¢…es "negative"; '¡×es "zero"; “†ìˆÈŒšï¿Ÿ¯¥Š“es "four five six seven eight nine"; '…§es "teen"; …€µ‚•„íes "one two three"; …—¿áÓÁÏes "ten eleven twelve"; '°¡es "hundred"; '¾ßes "ion"; …¡›‡È±°es "billion million thousand"; '…®es "point"; y “‰´Øè„ƺߓes "plus minus times divided".
• ( ¿Cómo comprimir cadenas que no forman parte del diccionario? ) - .•6b©•es "thir"; .•4º»Ÿć'Rþн•es "twenthirforfif"; y .•cG3₅¦„¥F•es "quadrilltrill".
• ( ¿Cómo comprimir enteros grandes? ) - ŽH$es 4433.

Python 2 , 790 774 bytes

lambda T:B("([+/*-])",lambda m:dict(zip("+/*-",S("z"," plus z divided by z times z minus ")))[m.group(0)],B("([+/*-]|^)-",r"\1negative ",B("[^+/*-]+","{}",T))).format(*[J([g[int(S("\.",j)[0])]+S("z",B("y","illion","z thousandz myz byz tryz quadry"))[len(S(",",m))+~i]+(" point "+J(s[int(c)]for c in S("\.",j)[-1]))*("."in j)for i,j in E(S(",",m))if 0<float(j)+(m<"1")])for m in S("[+/*-]+",T)[T[0]=='-':]])
from re import*
E,S,B,P=enumerate,split,sub," ";J=P.join
s,e=S(P,"zero one two three four five six seven eight nine"),[B("urty","rty",j)for i,j in E(c+d for d in S(P,"teen ty")for c in S(P,"twen thir four fif six seven eigh nine"))]
g=s+S(P,"ten eleven twelve")+e[1:8]+[a+(P+b)*(i>0)for a in e[8:]for i,b in E(s)]
g=[(j+" hundred ")*(i>0)+k for i,j in E(s)for k in g]

Pruébalo en línea!

Tantas malas prácticas. Esto casi duele al escribir ...

Espera una cadena no unicode sin espacios en blanco como entrada.

Explicación:

# import all functions from re (python regex library)
from re import*

# rename some repeatedly-used functions/variables for reduced bytecount
E,S,B,P=enumerate,split,sub," ";J=P.join

# list the names of 0-9
s=S(P,"zero one two three four five six seven eight nine")
# generate "twenteen" through nineteen and twenty though ninety, changing "fourty" to forty
# using enumerate (E) even though i is not required b/c it's shorter than range(len(x))
# using re.split (S) instead of string.split since it's shorter
e=[B("urty","rty",j)for i,j in E(c+d for d in S(P,"teen ty")for c in S(P,"twen thir four fif six seven eigh nine"))]
# generate 0-999
# 0-9
g=s+
   # 10, 11, 12
   +S(P,"ten eleven twelve")+
                            # remove "twenteen", 13-19
                            +e[1:8]+
                                   # tens' place + ones' place, if ones' place is not zero
                                   +[a+(P+b)*(i>0)                               ]
                                                   # for each tens' place in 20-90
                                                   for a in e[8:]
                                                                  # for each index, value in ones' places 0-9
                                                                  for i,b in E(s)


# hundreds' place if at least 100, plus tens' and ones' place (already calculated and stored in g from before)
g=[(j+" hundred ")*(i>0)+k                          ]
                           # (s) stores names for 0-9, need index to avoid "zero hundred"
                           for i,j in E(s)
                                          # for each hundred, iterate over all values (0-99) already in g
                                          for k in g

# actual function to call. uses previously declared global variable g.
def f(T):
    # gets the numbers in the supplied string (T) by splitting (T) on any operator character
    # remove first item if blank (only happens when staring with a - for negative numbers)
    n=S("[+/*-]+",T)[T[0]=='-':]

    # triply-nested set of re.subs to convert (T) to a sting of where the operators are replaced by their names and numbers are replaced by "{}"
    # EX: "-1-1--1" -> "-{}-{}--{}" -> "negative {}-{}-negative {}" -> "negative {} minus {} minus negative {}"
    # this sub happens last
    # re.sub (B) any operator, with the operators in a group "()" so that they return in match.group
    T=B("([+/*-])",                                                                                                                                        )
                  # an anonymous function to accept match objects (m) from re.sub's search.
                  ,lambda m:
                            # create a dictionary from the combination of operators and their names
                            # like {"+":" plus ",...}
                            # operator names are surrounded by spaces since number names are NOT
                            dict(zip("+/*-",S("z"," plus z divided by z times z minus ")))
                                                                                          # from the constructed dictionary, select the operator matched by re.sub's search and return it for replacement
                                                                                          [m.group(0)],
                                                                                                      # this substitution is second
                                                                                                      # re.sub (B) any operator followed by a minus (-), OR a minus at the beginning of the string
                                                                                                      # operators/start are grouped, trailing minus is not
                                                                                                      ,B("([+/*-]|^)-",                                    )
                                                                                                                      # replace match with the grouped items plus the word "negative"
                                                                                                                      # EX: "-1-1--1" -> "-{}-{}--{}" -> "negative {}-{}-negative {}"
                                                                                                                      ,r"\1negative ",
                                                                                                                                     # this substitution is done first
                                                                                                                                     # replace any sequence of NON-operators with "{}"
                                                                                                                                     # this removes numbers so the names can be inserted later
                                                                                                                                     # EX: "-1-1--1" -> "-{}-{}--{}"
                                                                                                                                     ,B("[^+/*-]+","{}",T))

    # technically the previous construction of (T) and (n) can be placed here to save 5 bytes but my poor eyes can't handle that.
    # insert constructed names back into original string.
    # EX: "-1-1--1" -> "negative {} minus {} minus negative {}" -> "negative one minus one minus negative one"
    print T.format(                                                                                                                                                                                                                     )
                   # string.format needs items in array unpacked, or it will attempt to insert the string representation of the array itself
                   *[                                                                                                                                                                                                                  ]
                     # for each number pulled from (T), generate names and join generated items back together with spaces
                     # EX: "1,456" -> ["1", "456"] -> ["one thousand", "four hundred fifty six"] -> "one thousand four hundred fifty six"
                     J(                                                                                                                                                                                                     )for m in n
                       # split j on periods (.) and take the first item
                       # convert that item into an integer and find the item at that index in g (0-999)
                       [g[int(S("\.",j)[0])]+                                                                                                                                                                              ]
                                            # insert prefix for millions +, split string on "z" (spaces must be preserved for proper separation)
                                            +S("z",B("y","illion","z thousandz myz byz tryz quadry"))
                                                                                                     # left is largest, so take the item at index (total # of groups - current place - 1)
                                                                                                     [len(S(",",m))+~i]+
                                                                                                                       # if group had a period, split string on period and take last item
                                                                                                                       # replace every character in group with number 0-9 name
                                                                                                                       # join them with spaces and add back to rest of group
                                                                                                                       +(" point "+J(s[int(c)]for c in S("\.",j)[-1]))*("."in j)
                                                                                                                                                                                # split number into groups by comma
                                                                                                                                                                                # EX: "123,456" -> ["123","456"]
                                                                                                                                                                                # only return item if j != 0 (avoids returning empty string which will result in too many joined spaces)
                                                                                                                                                                                # OR if m == 0 (avoids not returning anything when should return "zero")
                                                                                                                                                                                for i,j in E(S(",",m))if 0

_{Reduje unos 150 bytes mientras escribía la explicación. ¡Que nunca se diga que comentar / revisar su código no es útil!}