Cuadra un número a mi manera

32

La gente sigue diciéndome que el cuadrado de un número es el número multiplicado por sí mismo. Esto es obviamente falso. La forma correcta de cuadrar un número es convertirlo en un cuadrado, apilándolo encima de sí mismo una cantidad de veces igual al número de dígitos que tiene, y luego leyendo todos los números del cuadrado resultante, ambos horizontalmente (de solo de izquierda a derecha) y verticalmente (solo de arriba a abajo), y luego sumarlos. Entonces, para el número 123, primero creas el cuadrado:

123
123
123

Luego, toma todas las filas y columnas del cuadrado y las agrega:

123+123+123+111+222+333

Lo que nos da un resultado de 1035.

Para los números negativos, usted apila normalmente (recuerde que solo cuenta el número de dígitos , por lo que el signo negativo no está incluido en la longitud), y luego lee los números horizontales normalmente (con signos negativos), y luego ignora los signos negativos para Los números verticales. Entonces, para el número -144obtenemos el cuadrado:

-144
-144
-144

Lo que nos da -144-144-144+111+444+444, lo que es igual567

Para números con solo un dígito, el cuadrado siempre es igual al número duplicado (leído una vez horizontalmente y una vez verticalmente). Entonces 4nos da

4

Lo que nos da 4+4, lo que es igual8 .

Para números con partes decimales, apile normalmente (recuerde que solo se cuentan los dígitos en la cantidad de veces que apila el número y, por lo tanto, no se cuenta el punto decimal), e ignore los símbolos decimales al leer los números verticales. Por ejemplo, el número 244.2nos da

244.2
244.2
244.2
244.2

Lo que nos da 244.2+244.2+244.2+244.2+2222+4444+4444+2222, lo que es igual14308.8 .

Los números fraccionales o complejos no pueden ser cuadrados.

Tu tarea:

Estoy cansado de cuadrar los números a mano, así que decidí automatizar el proceso. Escríbame un programa o función que tome un flotante o una cadena, lo que prefiera, como entrada y devuelva el resultado de cuadrarlo a mi manera.

Ejemplos:

123    -> 1035
388    -> 3273
9999   -> 79992
0      -> 0
8      -> 16
-6     -> 0
-25    -> 27
-144   -> 567
123.45 -> 167282.25
244.2  -> 14308.8
2      -> 4
-0.45  -> 997.65
0.45   -> 1000.35

Tanteo:

Mis manos se están apretando por escribir todos esos cuadrados, y mi computadora no admite copiar / pegar, por lo que gana la entrada con la menor cantidad de código para escribir (¿medido en bytes por alguna razón?).

Gryphon - Restablece a Monica
fuente
1
"123.45" y "244.2" no son flotantes válidos en sí mismos porque la computadora almacena el número en binario. Esto normalmente no es un problema hasta que el problema se basa en la representación decimal.
Leaky Nun
@LeakyNun, realmente no sé qué quieres decir con eso. El problema no es irresoluble (al menos en python), estoy bastante seguro de que podría hacerlo con bastante facilidad, aunque en una gran cantidad de bytes. Sin embargo, requeriría algo de manipulación de cadenas.
Gryphon - Restablece a Monica el
@Gryphon ¿Entonces debemos tomar la entrada como una cadena?
Leaky Nun
3
@Gryphon Aquí es donde falla. 244.2No es un número flotante. No se puede convertir a la cadena "244.2".
Leaky Nun
3
@Gryphon Pero comportamientos como este lo hacen muy inconveniente.
Leaky Nun

Respuestas:

8

05AB1E , 7 bytes

þSDg×+O

Pruébalo en línea!

Explicación

þSDg×+O Implicit input
þ       Keep digits
 S      Get chars
  D     Duplicate
   g    Length
    ×   Repeat string(s)
     +  Add (implicit input added to all elements)
      O Sum
Erik el Outgolfer
fuente
3
Ooo explicación cuando puedas por favor
Jonathan Allan
1
También me gustaría señalar que el cero inicial simple es un requisito en la entrada para -1 <input <1 (es decir, 0.45 y .45 son entradas diferentes pero el mismo número, solo el primero es aceptable)
Jonathan Allan
@JonathanAllan El último no se maneja de todos modos.
Erik the Outgolfer
@JonathanAllan Hecho.
Erik the Outgolfer
7

Jalea ,  13  12 bytes

fØDẋ€L$ŒV+VS

Un enlace monádico que acepta una lista de caracteres (un número decimal bien formado, el único cero inicial es un requisito para -1 <n <1 ) y devuelve un número.

Pruébalo en línea!

14 bytes para aceptar y números de retorno (entrada limitada a +/- 10 -5 por ŒṘ): ŒṘfØDẋ€L$ŒV+⁸S.

¿Cómo?

fØDẋ€L$ŒV+VS - Link: list of characters         e.g. "-0.45"
 ØD          - yield digit characters                "0123456789"
f            - filter keep                           "045"
      $      - last two links as a monad:
     L       -   length (number of digit characters) 3
   ẋ€        -   repeat list for €ach digit          ["000","444","555"]
       ŒV    - evaluate as Python code (vectorises)  [0,444,555]
          V  - evaluate (the input) as Jelly code    -0.45
         +   - addition (vectorises)                 [-0.45,443.55,554.55]
           S - sum                                   997.65
Jonathan Allan
fuente
Umm, se puede reemplazar +€con +la versión de 15 bytes para -1.
Erik the Outgolfer
Ya lo hice, aunque gracias!
Jonathan Allan
Umm no en la versión de 15 bytes. EDITAR: 3 segundos demasiado temprano, supongo ...
Erik the Outgolfer
Sí, acabo de notar que dijiste una versión de 15 bytes, ¡gracias de nuevo!
Jonathan Allan
6

Haskell, 59 56 bytes

f s|l<-filter(>'.')s=0.0+sum(read<$>(s<$l)++[c<$l|c<-l])

La entrada se toma como una cadena.

Pruébalo en línea!

Cómo funciona

l<-filter(>'.')s      -- let l be the string of all the numbers of the input string
f s   = 0.0 + sum     -- the result is the sum of (add 0.0 to fix the type to float)
   read<$>            -- turn every string of the following list into a number
   s<$l               -- length of l times the input string followed by
   [c<$l|c<-l]        -- length of l times c for each c in l   
nimi
fuente
5

Japt v2 , 16 bytes

o\d
l
¬xpV +V*Ng

¡Pruébelo en línea!

Explicación

o\d    First line: Set U to the result.
o      Keep only the chars in the input that are
 \d      digits. (literally /\d/g)

l    Second line: Set V to the result.
l    U.length

¬xpV +V*Ng    Last line: implicitly output the result.
¬             Split U into chars.
 x            Sum after
  pV            repeating each V times.
     +V*Ng    Add V * first input (the sum of the horizontals) to the result.
ETHproducciones
fuente
4

C # (.NET Core), 150 141 133 bytes

Guardado 9 bytes gracias a @TheLethalCoder
Guardado otros 8 bytes gracias a @TheLethalCoder

a=>{var c=(a+"").Replace(".","").Replace("-","");int i=0,l=c.Length;var r=a*l;for(;i<l;)r+=int.Parse(new string(c[i++],l));return r;}

Pruébalo en línea!

Toma una cadena como entrada y genera el número 'cuadrado' como flotante.


Este código sigue el siguiente algoritmo:

  1. Cree una nueva cadena a partir de la entrada, pero sin los puntos decimales y los símbolos, para que podamos obtener nuestra longitud y los números de las columnas desde allí.

  2. Calcule la entrada multiplicada por la longitud de la cadena que creamos en el punto 1.

  3. Para cada columna en nuestro 'cuadrado', cree una nueva cadena con el número de columna y la longitud de la fila y agréguela a nuestro resultado.

Ejemplo:

Entrada: -135.5

  1. Si reemplazamos los puntos decimales y los símbolos, obtenemos la cadena 1355, que tiene una longitud de 4.
  2. Los tiempos de entrada 4: -135.5 * 4 = -542.
  3. Ahora vamos a crear nuevas cadenas para cada columna, analizarlos y añadirlos a nuestro resultado:
    1111, 3333, 5555, 5555.

Si sumamos estos números, obtenemos 15012, que es exactamente lo que generará nuestro programa.

Ian H.
fuente
1
¡Bienvenido al sitio y una buena primera respuesta (se agradecen las explicaciones en particular!)!
Dada
@Dada Gracias! Incluso difícil, estoy bastante desagradable por los bytes que obtuve de cosas como string.Replace(), pero supongo que esa es la única forma en que funciona.
Ian H.
Es posible que pueda guardar algunos bytes configurando iy len flotantes.
TheLethalCoder
@TheLethalCoder Pensado en eso también, lamentablemente la indexación no funciona con flotantes y .Lengthno puede convertirse implícitamente en flotante.
Ian H.
1
a=>{var c=a.Replace(".","").Replace("-","");int i=0,l=c.Length;var r=float.Parse(a)*l;for(;i<l;)r+=int.Parse(new string(c[i++],l));return r;}141 bytes. Podría ahorrar guardando la entrada como a floaty convirtiéndola en una cadena con n+""pero no lo he verificado.
TheLethalCoder
3

Brachylog , 23 bytes

{∋ịṫ}ᶠ⟨≡zl⟩j₎ᵐ;[?]zcịᵐ+

Pruébalo en línea!

Brachylog no va bien con carrozas ...

Explicación:

{∋ịṫ}ᶠ⟨≡zl⟩j₎ᵐ;[?]zcịᵐ+ Takes string (quoted) input, with '-' for the negative sign
     ᶠ                  Return all outputs (digit filter)
{   }                    Predicate (is digit?)
 ∋                        An element of ? (input)
  ị                       Convert to number (fails if '-' or '.')
   ṫ                      Convert back to string (needed later on)
      ⟨   ⟩             Fork
       ≡                 Identity
         l               Length
                        with
        z                Zip
             ᵐ          Map
            ₎            Subscript (optional argument)
           j              Juxtapose (repeat) (this is where we need strings)
              ;         Pair with literal
               [ ]       List
                ?         ?
                  z     Zip
                   c    Concatenate (concatenate elements)
                     ᵐ  Map
                    ị    Convert to number
                      + Add (sum elements)
Erik el Outgolfer
fuente
3

Casco , 15 bytes

§+ȯṁrfΛ±TṁrSR#±

Toma una cadena y devuelve un número. Pruébalo en línea!

Explicación

Es un poco molesto que la función de análisis incorporada rdé errores de análisis en las entradas no válidas en lugar de devolver un valor predeterminado, lo que significa que tengo que filtrar explícitamente las columnas que consisten en no dígitos. Si devuelve 0 en entradas mal formadas, podría soltar fΛ±y guardar 3 bytes.

§+ȯṁrfΛ±TṁrSR#±  Implicit input, e.g. "-23"
             #±  Count of digits: 2
           SR    Repeat that many times: ["-23","-23"]
         ṁr      Read each row (parse as number) and take sum of results: -46
  ȯṁrfΛ±T        This part is also applied to the result of SR.
        T        Transpose: ["--","22","33"]
     fΛ±         Keep the rows that contain only digits: ["22","33"]
   ṁr            Parse each row as number and take sum: 55
§+               Add the two sums: 9
Zgarb
fuente
3

Python 3 , 95 94 87 85 84 bytes

def f(i):l=[x for x in i if"/"<x];k=len(l);print(k*float(i)+sum(int(x*k)for x in l))

Test Suite .

Python 3 , 78 bytes

lambda x:sum(float(i*len(z))for z in[[i for i in str(x)if"/"<i]]for i in[x]+z)

Banco de pruebas.

El segundo enfoque es un puerto para Python 3 inspirado en la solución de @ officialaimm.

Sr. Xcoder
fuente
3

Python 2 , 81 74 bytes

-7 bytes gracias a @Mr. Xcoder :'/'<i

  • Toma entero o flotante, devuelve flotante.
lambda x:sum(float(i*len(z))for z in[[i for i in`x`if"/"<i]]for i in[x]+z)

Pruébalo en línea!

Explicación:

Say 123.45se da como entrada. [i for i in`x`if"/"<x]da una lista de enteros stringified ['1','2','3','4','5'](que también es z). Ahora iteramos , [x]+zes decir [123.45,'1','2','3','4','5'], multiplicamos cada elemento por len(z)aquí 5y los convertimos en un flotante (para que las cadenas también se conviertan en consecuencia), produciendo [617.25,11111.0,22222.0,33333.0,44444.0,55555.0]. Finalmente calculamos sum(...)y obtenemos 167282.25.

officialaimm
fuente
78 bytes . Reemplazar i.isdigit()con"/"<i<":"
Sr. Xcoder
1
74 bytes . Puede reemplazar i.isdigit()con "/"<i, de hecho, porque ambos .y -tienen códigos ASCII más bajos que los dígitos, y se /encuentra entre ellos
Sr. Xcoder
De nada. Lo porté a Python 3 como una alternativa a mi respuesta
Sr. Xcoder el
3

JavaScript, 75 62 bytes

a=>(b=a.match(/\d/g)).map(b=>a+=+b.repeat(c),a*=c=b.length)&&a

Pruébalo en línea

-2 bytes gracias a Arnauld
-5 bytes gracias a Shaggy (aunque la función debe recibir un número, pero ahora veo que muchas otras respuestas también reciben cadena)


fuente
3

Perl 5 , 37 33 + 1 (-p) = 38 34 bytes

$_*=@n=/\d/g;for$\(@n){$_+=$\x@n}

Pruébalo en línea!

Usé algunos trucos del código de Dom para afeitar 4 bytes

Explicado:

@n=/\d/g;    # extract digits from input
$_*=@n;      # multiply input by number of digits
for$\(@n){   # for each digit:
  $_+=       # add to the input
  $\x@n}     # this digit, repeated as many times as there were digits
             # taking advantage of Perl's ability to switch between strings
             # and numbers at any point
Xcali
fuente
Se le ocurrió un enfoque muy similar, pero logró obtener un par de bytes usando $ \ y saliendo del ciclo: ¡ pruébelo en línea!
Dom Hastings
Usé un poco de inspiración tuya para afeitarme. ¿Cuál es la construcción "} {" al final de la tuya? No estoy familiarizado con eso.
Xcali
Es uno que aprendí de este sitio, básicamente -ny -pliteralmente envuelve un while(){...}código para que }{salga de eso. Esto se desarma, $_pero si lo usa $\ como su variable, todavía se imprimirá, ya que $\ se adjunta a cada impresión. Significa que puede almacenar un número o algo en eso y no tener en cuenta $_. No estoy seguro de que haya sido una gran explicación, pero echa un vistazo a los Consejos para jugar golf en el hilo de Perl , ¡estoy seguro de que lo explicará mejor! ¡Me alegro de haber ayudado a tu puntaje!
Dom Hastings
2

Pyth , 21 20 bytes

K@jkUTQ+smv*lKdK*lKv

Banco de pruebas.

Utiliza un enfoque completamente diferente de la respuesta de @ EriktheOutgolfer , que me ayudó a jugar golf 1 byte en el chat, del 22 al 21.


Explicación

K@jkUTQ+s.ev*lKbK*lKv

K @ jkUTQ: filtra los dígitos y los asigna a una variable K.
         m - Mapa. Iterado a través de los dígitos con una variable d
           v - Evaluar (convertir a flotante).
            * lKd: multiplica cada dígito de cadena por la longitud de K.
        s - Suma
       + - Suma
                 * lKvQ: multiplica el número por la longitud de los dígitos Cadena
Sr. Xcoder
fuente
2

Octava , 100 82 bytes

¡Muchas gracias @TomCarpenter por enseñarme que las tareas tienen un valor de retorno y ahorrarme 18bytes!

@(v)(n=nnz(s=strrep(num2str(abs(v)),'.','')-'0'))*v+sum(sum(s'*logspace(0,n-1,n)))

Pruébalo en línea!

Ungolfed / Explicación

function f=g(v)
  s=strrep(num2str(abs(v)),'.','')-'0';  % number to vector of digits (ignore . and -)
  n=nnz(s);                              % length of that vector
  f=n*v+sum(sum(s'*logspace(0,n-1,n)))   % add the number n times and sum the columns of the square
end

La forma en que esto funciona es que, básicamente, necesitamos sumar el número ny multiplicar la suma de las columnas. Sumar s' * logspace(0,n-1,n)logra la suma de columnas, por ejemplo, si v=-123.4esa matriz será:

[ 1     10    100   1000;
  2     20    200   2000;
  3     30    300   3000;
  4     40    400   4000 ]

Así que solo tenemos que sumhacerlo y listo.

ბიმო
fuente
1
Puede guardar 18 bytes introduciéndolo todo en una función anónima @(v)(n=nnz(s=strrep(num2str(abs(v)),'.','')-'0'))*v+sum(sum(s'*logspace(0,n-1,n))). Pruébalo en línea!
Tom Carpenter
1

Swift 4 , 139134 bytes

func f(s:String){let k=s.filter{"/"<$0};print(Float(s)!*Float(k.count)+k.map{Float(String(repeating:$0,count:k.count))!}.reduce(0,+))}

Banco de pruebas.


Explicación

  • func f(s:String)- Define una función fcon un parámetro de cadena explícito s.

  • let k=s.filter{"/"<$0}- Filtros de los dígitos: Me di cuenta de que tanto -y .tienen valores ASCII más pequeños que todos los dígitos, y /está entre ., -y 0. Por lo tanto, acabo de comprobar si "/"es más pequeño que el carácter actual, como lo hice en mi respuesta de Python.

  • print(...) - Imprime el resultado.

  • Float(s)!*Float(k.count)- Convierte la cadena y el número de dígitos en flotante y los multiplica (Swift no permite la multiplicación de flotación e int :()). Entonces agrega el número de xveces, dondex está el número de dígitos que contiene?

  • k.map{Int(String(repeating:$0,count:k.count))!- se k.map{}asigna kcon el valor actual $0. String(repeating:$0,count:k.count)toma cada dígito, crea una cadena de xdígitos idénticos y la Float(...)!convierte en un número de coma flotante.

  • .reduce(0,+) - Obtiene la suma de la lista anterior.

  • Y finalmente +suma los dos resultados.


¡Tomemos un ejemplo!

Digamos que nuestra cadena es "0.45". En primer lugar, filtramos los dígitos, por lo que nos queda 0, 4, 5. Convertimos "0.45"a flotar y se multiplica por el número de dígitos: 0.45 * 3 = 1.35. Luego tomamos cada dígito y convertirlo en una cadena de dígitos que repetir hasta que se llene la anchura de la plaza (cuántos dígitos hay): 0, 4, 5 -> 000, 444, 555. Sumamos esto, 000 + 444 + 555 = 999. Entonces sólo sumar los tiempos: 1.35 + 999 = 1000.35.

Sr. Xcoder
fuente
1

C #, 139 137 bytes

using System.Linq;n=>{var d=(n+"").Where(char.IsDigit);return d.Sum(i=>int.Parse(new string(i,d.Count())))+new int[d.Count()].Sum(_=>n);}

Guardado 2 bytes gracias a @Ian H.

Pruébalo en línea!

Versión completa / formateada:

namespace System.Linq
{
    class P
    {
        static void Main()
        {
            Func<double, double> f = n =>
            {
                var d = (n + "").Where(char.IsDigit);
                return d.Sum(i => int.Parse(new string(i, d.Count()))) + new int[d.Count()].Sum(_ => n);
            };

            Console.WriteLine(f(123));
            Console.WriteLine(f(-144));
            Console.WriteLine(f(4));
            Console.WriteLine(f(244.2));

            Console.ReadLine();
        }
    }
}
TheLethalCoder
fuente
Puede guardar 2 bytes al principio utilizando en var d=(n+ ...lugar de var d = (n ....
Ian H.
@IanH. Olvidé eliminar todos los espacios -_- Eso es lo que obtengo por responder mientras hago una llamada de soporte.
TheLethalCoder
1

Mathematica, 107 bytes

(t=Length[s=#&@@RealDigits[#]//.{a___, 0}:>{a}];If[IntegerPart@#==0,t++];t#+Tr[FromDigits@Table[#,t]&/@s])&
J42161217
fuente
1

PHP, 78 88 +1 bytes

for($e=preg_match_all("#\d#",$n=$argn);~$c=$n[$i++];)$s+=str_repeat($c,$e);echo$s+$n*$e;

Ejecutar como tubería con -nR.

Puede generar advertencias en PHP 7.1. Reparar $c,$econ $c>0?$c:0,$epara arreglar.

Titus
fuente
0

Python 3 , 68 70 73 77 bytes

lambda n:sum(float(n)+int(_*sum(x>"/"for x in n))for _ in n if"/"<_)

Pruébalo en línea!

Recorre cada carácter de dígitos y lo repite por el número total de caracteres de dígitos, lo convierte en un número entero y lo agrega a n. De esta forma se nobtienen dtiempos adicionales , la parte horizontal de la suma, junto con la repetición de dígitos, que es la parte vertical. Originalmente utilizado str.isdigitpero >"/", gracias a otros en este hilo, ahorró muchos bytes. Guarda dos bytes al tomarlos ncomo una cadena, pero el resultado es más desordenado.

lambda n:sum(n+int(_*sum(x>"/"for x in str(n)))for _ in str(n)if"/"<_)

Pruébalo en línea!

C McAvoy
fuente