Paralelogramo de un número

18

Ahora que sabemos cómo cuadrar y hacer un triángulo correctamente un número, vamos a aprender a ponerlo en paralelo. Para un paralelogramo de un número, primero lo organizamos como un paralelogramo apilándolo encima de sí mismo varias veces igual al número de dígitos que tiene, y agregando espacios para convertirlo en un paralelogramo. Así 123se formaría:

   123
  123
 123

Ahora tomamos cada número horizontal y vertical y los sumamos 123+123+123+1+12+123+23+3, que es igual 531, que es el paralelogramo de 123.

Tu tarea:

Escriba un programa o función que, cuando se le da un número como entrada, devuelve el paralelogramo del número.

Entrada:

Un entero no negativo o un entero no negativo representado por una cadena.

Salida:

El paralelogramo del entero.

Casos de prueba:

1234567 -> 10288049
123     -> 531
101     -> 417
12      -> 39

Puntuación:

Este es el , ¡el puntaje más bajo en bytes gana!

Gryphon - Restablece a Monica
fuente
Sandbox Post
Gryphon - Restablece a Mónica el
¿Por qué el voto negativo?
Gryphon - Restablece a Mónica el

Respuestas:

9

MATL , 12 bytes

tnEXyPY+c!Us

La entrada es una cadena. Pruébalo en línea!

Explicación

Considere la entrada '123'como un ejemplo.

El código duplica la entrada ( t) y crea una matriz de identidad ( Xy) de tamaño dos veces la longitud de entrada ( nE):

1 0 0 0 0 0
0 1 0 0 0 0
0 0 1 0 0 0
0 0 0 1 0 0
0 0 0 0 1 0
0 0 0 0 0 1

luego lo voltea ( P):

0 0 0 0 0 1
0 0 0 0 1 0
0 0 0 1 0 0
0 0 1 0 0 0
0 1 0 0 0 0
1 0 0 0 0 0

La cadena de entrada, interpretada como códigos ASCII de los dígitos, es equivalente al vector de fila numérico

49 50 51

La convolución bidimensional de tamaño completo ( Y+) del vector y la matriz anteriores da

 0  0  0  0  0 49 50 51
 0  0  0  0 49 50 51  0
 0  0  0 49 50 51  0  0
 0  0 49 50 51  0  0  0
 0 49 50 51  0  0  0  0
49 50 51  0  0  0  0  0

La interpretación de esos números como códigos ASCII ( c) da la siguiente matriz de caracteres, con el carácter 0 representado como espacio:

     123
    123 
   123  
  123   
 123    
123

Transposición ( !) transforma esto en

     1
    12
   123
  123 
 123  
123   
23    
3     

Interpretar cada fila como un número ( U) da el vector de columna numérica

  1
 12
123
123
123
123
 23
  3

y sumando que ( s) da el resultado final, 531.

Luis Mendo
fuente
1
Huelo ... convolución
Adnan
1
@Adnan ¿Qué más? :-D
Luis Mendo
6

Retina , 22 bytes

.
$`;$&$';$_;
\d+
$*
1

Pruébalo en línea! El enlace incluye casos de prueba. Explicación: La primera etapa divide el número de entrada en cada dígito e incluye todos los prefijos exclusivos y sufijos inclusivos, dando los números verticales, además del número de entrada original repetido para cada dígito, dando los números horizontales. Las etapas restantes simplemente suman los números resultantes.

Neil
fuente
6

05AB1E ,  12 11  8 bytes

Estoy seguro de que esto se puede jugar más golf, ¡consejos bienvenidos!

-1 byte gracias a Erik the Outgolfer (evita envolturas pero usando una concatenación)
y luego ...
-3 bytes más gracias a Adnan (evita la multiplicación por longitud-1 vectorizando la suma y restando la entrada al final)

.s¹η++Oα

Pruébalo en línea!

¿Cómo?

.s¹η++Oα - implicit input, say i      e.g.  123
.s       - suffixes                         [3,23,123]
  ¹      - push i                           123
   η     - prefixes                         [1,12,123]
    +    - addition of top two              [4,35,246]
     +   - addition (vectorises)            [127,158,369]
      O  - sum                              654
       α - absolute difference abs(123-654) 531
         - implicit print
Jonathan Allan
fuente
Puede utilizar «para concatenar los sufijos y los prefijos:g<*¹.s¹η«O+
Erik the Outgolfer
1
.s¹η++Oαdebería funcionar para 8 bytes
Adnan
¡Gracias @EriktheOutgolfer las dos envolturas me parecieron extrañas!
Jonathan Allan
@Adnan - ¡eso es muy dulce!
Jonathan Allan
@JonathanAllan "consejos bienvenidos!" no estoy seguro si obtendrás más ...
Erik the Outgolfer
5

Haskell , 90 78 76 71 64 63 59 57 bytes

g x=sum[x+div x(10^a)+mod x(10^a)|(a,_)<-zip[1..]$show x]

Pruébalo en línea!

Asistente de trigo
fuente
g x=sum[x+div x a+mod x a|(a,_)<-zip((10^)<$>[1..])$show x].
nimi
g x=sum[x+div x(10^a)+mod x(10^a)|(a,_)<-zip[1..]$show x]Es un pelo más corto aún.
Lynn
g x=sum[x+x`div`10^a+x`mod`10^a|(a,_)<-zip[1..]$show x].
Laikoni
4

Casco , 13 12 bytes

ṁit§+SRL§+ḣṫ

Pruébalo en línea!

Explicación

              -- implicit input, say "123"
   §+         -- concatenate the results of the following two functions
     SR       --  ¹repeat the input n times, where n is the result of the next function
       L      --   length                                                  ["123","123"]
        §+   --  ²concatenate the results of the following two functions
          ḣ  --     prefixes                                              ["","1","12","123"]
           ṫ --     suffixes                                              ["123","23","3",""]
              -- inner concatenation                                      ["","1","13","123","123","23","3",""]
              -- outer concatenation                                      ["123","123","","1","13","123","123","23","3",""]
  t           -- all but the first element                                ["123","","1","13","123","123","23","3",""]
ṁ             -- map then sum
 i            --   convert to integer (where "" converts to 0)
H.PWiz
fuente
4

Neim , 7 bytes

𝐱S𝐗𝔻𝔻𝐬𝕤

Tener cuidado. Contiene serpientes:S𝐬𝕤

Pruébalo en línea!

Okx
fuente
1
" Cuidado. Contiene serpientes:S𝐬𝕤 " Lol ..𝐗𝔻
Kevin Cruijssen
4

Python 3 , 85 70 bytes

f=lambda n,r=1,i=int:n[r:]and i(n[r:])+i(n[:r])+f(n,r+1)+i(n)or i(n)*2

Para la entrada 12345:

Resume las porciones de entrada 1 + 2345 + 12345, 12 + 345 + 12345, 123 + 45 + 12345, 1234 + 5 + 12345, utilizando la indexación de cadenas al índice (r) = 1,2,3,4 antes de convertir a entero y se agrega a 12345 * 2

Agradecimientos especiales a:

-14 Bytes @Jonathan Allen

-1 Byte @ovs

Pruébalo en línea!

Conner Johnston
fuente
TIO se vincula a un código incorrecto. (len(n)+1)se puede jugar a -~len(n)( ~xes -1-x), y luego eso puede guardar otro byte usando -i(n)*~len(n). Entonces puede convertirlo en una función anónima: lambda n,i=int:sum(i(n[:r])+i(n[r:])for r in range(1,len(n)))-i(n)*~len(n)(74 bytes)
Jonathan Allan
Aún mejor, haga que esa función sea recursiva para 71 bytes:f=lambda n,r=1,i=int:n[r:]and i(n[r:])+i(n[:r])+f(n,r+1)or-i(n)*~len(n)
Jonathan Allan
Arreglé tu enlace tio.
Sr. Xcoder
3

Japt , 15 11 bytes

-4 bytes gracias a @Shaggy.

¬£iYç
cUz)x

Toma la entrada como cadenas.

Pruébalo en línea!

Explicación

£

Divida la matriz de entrada en dígitos ( ¬) y asigne por ( £) la siguiente función, donde Y es el índice.
["1", "2", "3"]

iYç

El valor de entrada (implícito) con Yespacios ( ç) insertados ( i) al principio. Esto está asignado a U.
["123", " 123", " 123"]

cUz1)x

Concatene eso con sí mismo girado 90 ° a la derecha ( 1tiempo). Luego sum ( x).
["123", " 123", " 123", " 1", " 12", "123", "23 ", "1 "]-> 531.

Justin Mariner
fuente
Exactamente cómo estaba tratando de hacerlo, pero no pude llegar allí, por alguna razón, bien hecho :) Aquí hay una versión de 13 bytes .
Shaggy
11 bytes
Shaggy
@ Shaggy Awesome, sabía que tenía que haber una forma más corta de anteponer los espacios a cada línea. ¡Gracias!
Justin Mariner
3

Japt , 31 18 bytes

-13 bytes gracias a @ETHproductions

Este enfoque no funciona bien con Japt. La solución de Justin es mucho mejor.

[U*Ål U¬£tYÃUå+]xx

Explicación:

[U*Ål U¬£tYÃUå+]xx
[              ]    // Create a new array
 U*Ål               // Push: Input * Input.slice(1).length()
                    // Push:
      U¬            //   Input, split into chars
        £tY         //   Map; At each char: .substr(Index)
            Uå+     // Push: Cumulative reduce Input; with addition
                xx  // Sum all the items, twice

Pruébalo en línea!

Oliver
fuente
3
Eso es todo, estoy agregando un atajo para Ul : P
ETHproductions
Hmm ... no necesita ninguna de las Us en las funciones, y el elemento del medio en la matriz se puede condensar Uå+ x, lo que creo que lo reduce a 23 bytes.
ETHproductions
@ETHproductions ¡Gracias! Lo conseguí otro byte reorganizando los elementos de la matriz.
Oliver
¿Se puede cambiar mx xa xx? :-)
ETHproductions
@ETHproductions Estoy seguro, gracias de nuevo :)
Oliver
2

Ruby , 61 55 + 1 = 56 bytes

Usa la -nbandera. Entrada de STDIN.

p (1..~/$/).sum{|i|[$_[i,~/$/],$_[0,i],$_].sum &:to_i}

Pruébalo en línea!

Tinta de valor
fuente
Para ingresar 102033su programa imprime 728714mientras el valor correcto es 729702.
NOOOO! ¡MALDICITAN REPRESENTACIONES OCTALES! (la solución 02033fue el problema)
Value Ink
Supuse que los números octales son el problema, pero no estaba seguro (por cierto, no sé rubí). Gracias por la aclaración :)
@ThePirateBay no hay problema; Ya estaba trabajando en una solución alternativa más corta que tomaba entradas de cadena, e incluso con las correcciones necesarias, terminé guardando bytes de todos modos :)
Value Ink
2

JavaScript, 77 74 bytes

Guardado 3 bytes gracias a Value Ink

f=a=>[...a+a].map((_,b)=>a-=-z.substr((b-=n)>0?b:0,b+n),a*=n=(z=a).length)|a

console.log(f('123'));
console.log(f('101'));
console.log(f('12'));
console.log(f('1234567'));
console.log(f('102033'));


fuente
1

Pyth , 20 19 bytes

Mi enfoque actual de prefijo (con suerte jugaré más golf).

+*tlQsQssM+_M.__Q._

Pruebe Suite o pruebe un enfoque alternativo con el mismo número de bytes .

Explicación

+*tlQsQssM+_M.__Q._  - Full program that reads a String from STDIN, with implicit input.

  tlQ                - Length of the input - 1.
     sQ              - The input converted to an integer.
 *                   - Product of the above two elements. We will call this P.
                 ._  - Prefixes of the input.
          +          - Concatenated with:
           _M.__Q    - The prefixes of the reversed input, reversed.
        sM           - Convert each to an integer.
       s             - Sum.
+                    - Addition of the product P and the sum above.

Para entender mejor el concepto, tomaremos un ejemplo, digamos "123".

  • Primero obtenemos los prefijos de la entrada. Esos son ['1', '12', '123'].

  • Luego, obtenemos los prefijos de la entrada invertida, es decir: ['3', '32', '321']y revertimos cada uno, de ahí obtenemos ['3', '23', '123'].

  • Concatenamos las dos listas y convertimos cada elemento en un entero, por lo que obtenemos [3, 23, 123, 1, 12, 123].

  • Al sumar la lista, el resultado es 285.

  • El producto Pes la longitud de la entrada - 1 (es decir, 2multiplicada por la representación entera de este 2 * 123 = 246) ( ).

  • Al final, sumamos los dos resultados: 285 + 246por lo tanto, obtenemos 531cuál es el resultado correcto.


Pyth , 20 bytes

+*hlQsQsm+s>Qds<QdtU

Banco de pruebas.

Explicación

Explicación por venir después de más golf. No logré seguir jugando al golf por ahora (aunque tengo ideas).

+*hlQsQsm+s>Qds<QdtUQ  - Full program. Reads from STDIN. Q means input, and is implicit at the end.

  hlQ                  - Length of the input + 1.
     sQ                - The input converted to an integer.
 *                     - Multiply the above. We'll call the result P.
        m         tUQ  - Map over [1...length of the input)
          s>Qd         - input[currentItem:] casted to an integer.
              s<Qd     - input[:currentItem] casted to an integer.
         +             - Sum the above.
       s               - Sum the list.
+                      - Add the sum of the list and P.
Sr. Xcoder
fuente
1

q / kdb +, 34 bytes

Solución:

{sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}

Ejemplos:

q){sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}"1234567"
10288049
q){sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}"123"    
531
q){sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}"101"    
417
q){sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}"12"     
39

Explicación:

{sum"J"$((c#c),c-til 2*c:count x)#\:x} / ungolfed
{                                    } / lambda function
                                    x  / implicit input
                                 #\:   / apply take (#) to each-left element with the right element
        (                       )      / the left element
                       c:count x       / count length and save in variable c
                     2*                / multiply by 2 (e.g. 6)
                 til                   / range, so 0 1 2 3 4 5
               c-                      / vector subtraction, so 3 2 1 0 -1 -2
         (   )                         / do this together
          c#c                          / 3 take 3, so 3 3 3
              ,                        / join, so 3 3 3 3 2 1 0 - 1 -2          
    "J"$                               / cast this "123", "123", "123" .. "23" to longs
 sum                                   / sum them up and return result
callejero
fuente
1

Swift 3 , 213 bytes

func f(n:String){print((n.characters.count-1)*Int(n)!+(0..<n.characters.count).map{r in Int(n[n.index(n.startIndex,offsetBy:r)..<n.endIndex])!+Int(n[n.startIndex..<n.index(n.endIndex,offsetBy:-r)])!}.reduce(0,+))}

No se puede probar en línea, porque es lento y se agota el tiempo de espera. Puedes probarlo en Swift Playgrounds si deseas probarlo.

Ejecución de la muestra

Entrada:

f (n: "123")
f (n: "101")
f (n: "1234567")

Salida:

531
417
10288049
Sr. Xcoder
fuente
1

Jalea , 12 bytes

LḶṚ⁶ẋ;€µ;ZVS

Pruébalo en línea!

Toma la entrada como una cadena. Crea el "paralelogramo" como una matriz de caracteres, luego evalúa cada fila y columna para obtener los números para sumar.

Explicación

LḶṚ⁶ẋ;€µ;ZVS  Input: string S
L             Length
 Ḷ            Lowered range - [0, 1, ..., len(S)-1]
  Ṛ           Reverse
   ⁶          The char ' ' (space)
    ẋ         Create that many characters of each in the range
     ;€       Prepend each to S
       µ      Begin a new monadic chain
        ;     Concatenate with
         Z    Transpose
          V   Eval each string
           S  Sum
millas
fuente
1

C (gcc) ,95 8481 bytes (78 + -lmindicador del compilador)

¡Hola! Esta es mi primera presentación, espero no haber roto ninguna regla.

g,o,l;f(char*s){l=atoi(s);while(s[o++])g+=l/pow(10,o)+atoi(s+o);return g+l*o;}

Pruébalo en línea!

Sin golf, sin advertencias:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int g,o,l;

int f(char *s){
  l = atoi(s);

  while(s[o++]) {
    g+=l/pow(10,o)+atoi(s+o);
  }

  return g+l*o;
}

int main(void){
  printf("%d\n",f("1234567"));
  return 0;
}
scottinet
fuente
Parece válido para mí :)
Okx
Hmm, -lmpara funciones matemáticas sólo es necesario para algunos tiempos de ejecución C, como por ejemplo glibc. Compilando, por ejemplo, con MinGW (usando Microsoft msvcrt.dll), no sería necesario. Entonces, ¿no estás seguro de que es necesario agregarlo aquí? De todos modos, si lo agrega, generaría 3 bytes;)
Felix Palmen
Desafortunadamente, -lmes necesario para la pow()función con gcc. Traté de trabajar sin él, pero no pude encontrar una solución con menos de 6 bytes (pow + el indicador del compilador). No pude encontrar reglas sobre cómo incluir banderas en el bytecount, y sé darme cuenta de que hice una suposición falsa acerca de que el -personaje no se cuenta. Estoy agregando un byte +1 en este momento.
scottinet
-lmno es requerido por gccel hecho de que glibcno incluye las funciones matemáticas en la biblioteca principal. msvcrt.dlllo hace, por lo que compilar en Windows con gcctrabajos sin el -lm. Esto es una trampa y no estoy completamente seguro de lo que las reglas sobre esto realmente tienen que decir.
Felix Palmen
Gracias por el aviso :) No puedo probar su propuesta y tio tampoco parece ofrecer esa posibilidad, desafortunadamente
scottinet
1

Java 8, 147 137 126 116 114 bytes

n->{Integer l=(n+"").length(),r=n*l,i=0;for(;++i<l*2;)r+=l.valueOf((n+"").substring(i>l?i-l:0,i<l?i:l));return r;}

-13 bytes (137 → 126 y 116 → 114) gracias a @ OlivierGrégoire .

Explicación:

Pruébalo aquí

n->{                          // Method with integer as parameter and return-type
  Integer l=(n+"").length(),  //  Length of the input integer
      r=n*l,                  //  Result-integer (starting at `n*l`)
      i=0;                    //  Index-integer (starting at 0)
  for(;++i<l*2;               //  Loop from 0 through two times `l` (exclusive)
    r+=                       //   Add to the result-integer sum:
       l.valueOf((n+"").substring(
                              //    Substring of input, converted to integer:
        i>l?                  //     If `i` is larger than `l`:
         i-l                  //      Substring starting at `i-l`
        :                     //     Else:
         0,                   //      Substring starting at 0
        i<l?                  //     If `i` is smaller than `l`:
         i                    //      Substring ending at `i` (exclusive)
        :                     //     Else:
         l)                   //      Substring ending at `l` (exclusive)
  );                          //  End of loop
  return r;                   //  Return resulting sum
}                             // End of method
Kevin Cruijssen
fuente
1
114 bytes: n->{Integer l=(n+"").length(),s=n*l,i=0;for(;++i<l*2;)s+=l.valueOf((n+"").substring(l<i?i-l:0,i<l?i:l));return s;}. Es una ventana deslizante con min-max para reducir la cantidad de llamadas a los costososnew Integer(....substring(...))
Olivier Grégoire
1
@ OlivierGrégoire Gracias, e incluso puede acortar un poco más cambiando Math.max(0,i-l)a 0>i-l?0:i-ly Math.min(i,l)para i>l?l:i. Modificándolo ahora. Ah, veo que has editado tu comentario después de haber copiado la respuesta de 126 bytes. ;)
Kevin Cruijssen
Sí, perdón por la edición, pero no lo había comprobado;)
Olivier Grégoire
1

R , 168 162 103 bytes

-6 bytes al no usar c ()

-59 bytes gracias a @Giuseppe

function(n){k=nchar(n)
a=k*strtoi(n)
for(i in 1:k)for(j in i:k)a=a+(i==1|j==k)*strtoi(substr(n,i,j))
a}

Pruébalo en línea!

Toma la entrada como una cadena.

Estoy absolutamente seguro de que hay mejoras que hacer, principalmente para aprovechar cualquiera de las fortalezas de R ... pero en un desafío que es básicamente manipular cuerdas, estoy luchando por ver cómo.

Editar: ¡Mucho mejor ahora que no estoy iterando sobre una mala idea!

Criminalmente vulgar
fuente
1
103 bytes
Giuseppe
@Giuseppe Ah, gracias! Eso fue una gran cantidad de espacio desperdiciado de cuando todavía estaba usando una entrada entera. Me gusta la forma strtoi (substr ()), y el truco (a | b) es mucho más inteligente que yo. Gracias por las mejoras! Es casi una respuesta diferente en este momento ...
CriminallyVulgar
¡Eso sucede cuando se agrega otro enfoque! No pude entender los bucles yo mismo, pero creo que podrías construir los índices substrexplícitamente en lugar de bucles, lo que ahorraría unos pocos bytes.
Giuseppe
0

Mathematica, 77 bytes

(s=IntegerDigits@#;t=Length@s;Tr[FromDigits/@Table[s~Take~i,{i,-t,t}]]+t#-#)&
J42161217
fuente