¿Quieres hacer una cadena donde el ( 1-indexada caracteres) en el índice nes n. Cuando nes menor de 10, esto es fácil: "123456789". Cuando nes 12, por ejemplo, se vuelve imposible, ya que los números mayores que 9 (en la base 10) ocupan más de un carácter. Podemos poner en peligro al dividir la cadena en subcadenas de dos caracteres: "020406081012". Ahora el índice del final de cada subcadena n es n.

Esto se puede generalizar para cualquier dnúmero de dígitos. Aquí hay una explicación para la parte "0991021" de la cadena para un número de tres dígitos:

Index:     ... * 97  98  99*100 101 102*103 ...
               *           *           *
               *---+---+---*---+---+---*---+
Character: ... * 0 | 9 | 9 * 1 | 0 | 2 * 1 | ...
               *---+---+---*---+---+---*---+

Si aún no lo ha descubierto, debe escribir un programa / función que tome una cadena o un entero y genere su cadena autorreferencial como se especificó anteriormente. También puede generar una matriz de números de un solo dígito, caracteres o cadenas de un solo carácter.

El entero dado siempre será positivo y divisible por su longitud (por ejemplo, 126 es divisible por 3; 4928 es divisible por 4). Teóricamente, su programa debería funcionar para una entrada arbitrariamente grande, pero puede suponer que es más pequeña que el entero máximo y / o la longitud de cadena de su idioma.

Algunas observaciones si aún no lo entiende: la longitud de la salida siempre será la entrada en sí, y los números que aparecen en la salida serán divisibles por el número de dígitos en la entrada.

Este es el código de golf , por lo que la respuesta más corta en bytes gana.

Casos de prueba

1    => 1
9    => 123456789
10   => 0204060810
105  => 003006009012015018021024027030033036039042045048051054057060063066069072075078081084087090093096099102105
1004 => 00040008001200160020002400280032003600400044004800520056006000640068007200760080008400880092009601000104010801120116012001240128013201360140014401480152015601600164016801720176018001840188019201960200020402080212021602200224022802320236024002440248025202560260026402680272027602800284028802920296030003040308031203160320032403280332033603400344034803520356036003640368037203760380038403880392039604000404040804120416042004240428043204360440044404480452045604600464046804720476048004840488049204960500050405080512051605200524052805320536054005440548055205560560056405680572057605800584058805920596060006040608061206160620062406280632063606400644064806520656066006640668067206760680068406880692069607000704070807120716072007240728073207360740074407480752075607600764076807720776078007840788079207960800080408080812081608200824082808320836084008440848085208560860086408680872087608800884088808920896090009040908091209160920092409280932093609400944094809520956096009640968097209760980098409880992099610001004

Jalea , 12 bytes

VRUmLDUz0ZFU

La E / S está en forma de matrices de dígitos. Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

VRUmLDUz0ZFU  Main link. Argument: A (digit array)

V             Eval; turn the digits in A into an integer n.
 R            Range; yield [1, ..., n].
  U           Upend; reverse to yield [n, ..., 1].
    L         Yield the length (l) of A.
   m          Modular; keep every l-th integer in A.
     D        Decimal; convert each kept integer into the array of its digits.
      U       Upend; reverse the digits of each integer.
       z0     Zip/transpose with fill value 0.
         Z    Zip again.
              This right-pads all digit arrays with zeroes.
          F   Flatten the resulting 2D array.
           U  Upend/reverse it.

C, 64 bytes

l,i;main(n){for(scanf("%d%n",&n,&l);i<n;)printf("%0*d",l,i+=l);}

Toma un solo entero como entrada en stdin.

JavaScript (ES6), 83 bytes

n=>[...Array(n/(l=`${n}`.length))].map((_,i)=>`${+`1e${l}`+l*++i}`.slice(1)).join``

Sí, esa es una cadena de plantilla anidada. 79 bytes en ES7:

n=>[...Array(n/(l=`${n}`.length))].map((_,i)=>`${10**l+l*++i}`.slice(1)).join``

MATL , 15 14 bytes

VntG3$:10YA!1e

Pruébalo en línea!

V        % Implicitly input number, n. Convert to string
n        % Length of that string, s
t        % Duplicate s
G        % Push n again
3$:      % 3-input range (s,s,n): generates [s, 2*s, ... ] up to <=n
10YA     % Convert each number to base 10. This gives a 2D array of char, with each
         % number on a row, left-padded with zeros if needed
!1e      % Reshape into a string, reading in row-major order. Implicitly display

05AB1E , 15 bytes

Código:

LD¹gÖÏvy0¹g×0ñ?

Explicación:

L                # Get the array [1, ..., input].
 D               # Duplicate this array.
  ¹g             # Get the length of the first input.
    Ö            # Check if it's divisible by input length.
     Ï           # Keep those elements.
      vy         # For each...
         ¹g      # Get the length of the first input.
        0  ×     # String multiply that with "0".
            0ñ   # Merge with the number.
              ?  # Pop and print without a newline.

La fusión se realiza así:

A partir de estos:

000
 12

Resulta en esto:

012

Utiliza la codificación CP-1252 . Pruébalo en línea! .

Python 2, 78 70 68 64 63 bytes

En realidad, basarse en la idea de Sandía Destructible lo hace aún más pequeño (usar inputes aún mejor) (llenar la cadena hacia atrás ahorra 4 bytes) (no ()en while):

n,s=input(),''
l=len(`n`)
while n:s=`n`.zfill(l)+s;n-=l
print s

Aquí está el viejo enfoque de 70 bytes (Ahorro de 8 bytes usando comillas inversas en lugar de stry soltando los corchetes alrededor del generador gracias a Dennis):

def f(n):l=len(`n`);print"".join(`x`.zfill(l)for x in range(l,n+l,l))

Python 2, 63 bytes

def f(n):l=len(`n`);print'%%0%dd'%l*(n/l)%tuple(range(l,n+1,l))

Pruébalo en Ideone .

JavaScript (ES6), 66

Recursivo, ingrese ncomo una cadena (no un número) y limite el tamaño de la cadena de salida a 2 GB (que está por encima del límite de la cadena de la mayoría de los motores javascript)

f=(n,i=1e9,s='',l=n.length)=>s[n-1]?s:f(n,i+=l,s+(i+'').slice(-l))

Prueba

f=(n,i=1e9,s='',l=n.length)=>s[n-1]?s:f(n,i+=l,s+(i+'').slice(-l))

function test() {
  var v=I.value;
  Alert.textContent=v % v.length ?
    'Warning: input value is not divisible by its string length':'\n';
  Result.textContent=f(v);
}  

test()

<input type=number id=I value=105 oninput='test()' max=500000>
<pre id=Alert></pre>
<pre id=Result></pre>

R, 66 64 62 bytes

editar:

x=nchar(n<-scan());paste0(str_pad(1:(n/x)*x,x,,0),collapse="")

primer intento de golf ...

2sable , 13 bytes

Código:

g©÷F®N>*0®×0ñ

Utiliza la codificación CP-1252 .

Brachylog , 53 45 42 37 28 bytes

lB,? ybeN: B% 0, N: ef: {, "0": "9" y:? m.} acAl: Br -: "0" rjb: Acw \ 
lB,? ybeN: B% 0,10 : B ^: N +: ef: {, "0": "9" y:? M.} Acbw \ 
lB,? YbeN: B% 0,10: B ^: N +: ef: {: 16 +: @ Prm .} acbw \ 
lB,? ybeN: B% 0,10: B ^: N +: efbe: 16 +: @ Prmw \
lB,? ybeN: B% 0,10: B ^: N +: efbew \

Pruébalo en línea!

Bash, 31 22 bytes

seq -ws '' ${#1}{,} $1

Pruébalo en Ideone .

¡Gracias a @izabera por jugar golf en 6 bytes!

Ruby, 52 48 + nbandera = 49 bytes

((l= ~/$/)..$_.to_i).step(l){|j|$><<"%0#{l}d"%j}

Python 3 2, 79 74 69 65 68 67 bytes

Gracias Dennis!

def f(n):i=l=len(`n`);s='';exec n/l*"s+=`i`.zfill(l);i+=l;";print s

aumento del recuento de bytes del método de salida incorrecto

zsh, 28 bytes

printf %0$#1d {$#1..$1..$#1}

zsh + seq, 21 20 bytes

Esta es la misma respuesta que Dennis pero en 20 bytes porque zsh

seq -ws '' $#1{,} $1

Haskell, 51 bytes

f n|k<-length$show n=[k,2*k..n]>>=tail.show.(+10^k)

Perl, 40 bytes

Código de 39 bytes + 1 para -n.

$}=y///c;printf"%0$}d",$i+=$}while$i<$_

Uso

echo -n 9 | perl -ne '$}=y///c;printf"%0$}d",$i+=$}while$i<$_'
123456789
echo -n 10 | perl -ne '$}=y///c;printf"%0$}d",$i+=$}while$i<$_'
0204060810
echo -n 102 | perl -ne '$}=y///c;printf"%0$}d",$i+=$}while$i<$_'
003006009012015018021024027030033036039042045048051054057060063066069072075078081084087090093096099102
echo -n 1000 | perl -ne '$}=y///c;printf"%0$}d",$i+=$}while$i<$_'
0004000800120016002000240028003200360040004400480052005600600064006800720076008000840088009200960100010401080112011601200124012801320136014001440148015201560160016401680172017601800184018801920196020002040208021202160220022402280232023602400244024802520256026002640268027202760280028402880292029603000304030803120316032003240328033203360340034403480352035603600364036803720376038003840388039203960400040404080412041604200424042804320436044004440448045204560460046404680472047604800484048804920496050005040508051205160520052405280532053605400544054805520556056005640568057205760580058405880592059606000604060806120616062006240628063206360640064406480652065606600664066806720676068006840688069206960700070407080712071607200724072807320736074007440748075207560760076407680772077607800784078807920796080008040808081208160820082408280832083608400844084808520856086008640868087208760880088408880892089609000904090809120916092009240928093209360940094409480952095609600964096809720976098009840988099209961000

k4, 27

{,/"0"^(-c)$$c*1+!_x%c:#$x}

Realmente no se juega golf, solo una implementación directa de la especificación.

                        $ / string
                       #  / count
                     c:   / assign to c
                   x%     / divide x by
                  _       / floor
                 !        / range (0-based)
               1+         / convert to 1-based
             c*           / multiply by count
            $             / string
       (-c)               / negative count
           $              / pad (negative width -> right-aligned)
   "0"^                   / fill blanks with zeros
 ,/                       / raze (list of string -> string)

Javascript - 76

n=>eval('c="";for(a=b=(""+n).length;a<=n;a+=b)c+=`${+`1e${b}`+a}`.slice(1)')

o 71 si permite argumentos de cadena:

n=>eval('c="";for(a=b=n.length;a<=n;a+=b)c+=`${+`1e${b}`+a}`.slice(1)')

Gracias a @ user81655!

Sin golf:

function x(n)
{ 
   c = "", a = b = (""+n).length; 
   while(a<=n)
   {
       c=c+"0".repeat(b-(""+a).length)+a
       a+=b;
   }
   return c;
}

mucho lugar para mejorar, pero ahora estoy cansado

R, 149 142 138 bytes

x=rep(0,n);a=strtoi;b=nchar;for(i in 1:(n=scan()))if(!i%%b(a(n)))x[i:(i-b(a(i))+1)]=strsplit(paste(a(i)),"")[[1]][b(a(i)):1];cat(x,sep="")

Dejarlo ncharen el código le da a un programa el mismo número de bytes que reemplazarlo b, pero tener letras aleatorias deambulando por el código lo hace más ... misterioso

Sin golf:
cada uno nchar(strtoi(something))permite calcular el número de números en un número dado.

n=scan()   #Takes the integer 
x=rep(0,n) #Creates a vector of the length of this integer, full of zeros

for(i in 1:n)
    if(!i%%b(strtoi(n)))         #Divisibility check
        x[i:(i-nchar(as.integer(i))+1)]=strsplit(paste(a(i)),"")[[1]][nchar(as.integer(i)):1]; 
        #This part replace the zeros from a given position (the index that is divisible) by the numerals of this position, backward.

cat(x,sep="")

La strsplitfunción genera una lista de vectores que contienen los elementos divididos. Es por eso que tienes que llegar al 1elemento st de la lista, y luego al ielemento th del vector, escribiendostrsplit[[1]][i]

SQF - 164

Usando el formato de función como archivo:

#define Q String""
l=(ceil log _this)+1;s='';for[{a=l},{a<=_this},{a=a+l}]do{c=([a]joinQ)splitQ;reverse c;c=(c+['0'])select[0,l];reverse c;s=format[s+'%1',c joinQ]}

Llamar como INTEGER call NAME_OF_COMPILED_FUNCTION

PowerShell, 77 bytes

$x="$($args[0])";$l=$x.Length;-join(1..($x/$l)|%{"$($_*$l)".PadLeft($l,'0')})

Utiliza la interpolación de cadenas para acortar la conversión de cadenas. Las partes antes del segundo punto y coma acortan los nombres de las cosas reutilizadas. Luego, cada número entero hasta la entrada, y solo aquellos que son múltiplos de la longitud de la entrada, se rellenan para ser tan largos como la cadena de entrada y finalmente se unen en uno.

En realidad, 30 bytes

;╝R╛$l;)*@#"%0{}d"f╗`#╜%`MΣ╛@H

Pruébalo en línea!

No estoy satisfecho con la longitud de este código, pero no estoy seguro de que se pueda acortar mucho (si es que lo hay).

Explicación:

;╝R╛$l;)*@#"%0{}d"f╗`#╜%`MΣ╛@H
;╝                              duplicate input, push a copy to reg1
  R                             range(1, input+1)
   ╛$l                          push input from reg1, stringify, length
      ;)                        duplicate and move copy to bottom of stack
        *                       multiply range by length of input
         @#                     swap range with length, make length a 1-element list
           "%0{}d"f             "%0{}d".format(length) (old-style Python format string for zero-padding integers to length of input)
                   ╗            save format string in reg0
                    `#╜%`M      for each value in range:
                     #            make it a 1-element list
                      ╜%          format using the format string
                          Σ     concatenate
                           ╛@H  take only the first (input) characters in the resulting string

CJam, 19 bytes

q_,:V\i,%{V+sV0e[}/

Pruébalo en línea . Nadie ha publicado en CJam todavía, así que este es el script que utilicé para los casos de prueba.

Explicación

q_,:V  e# Store the length of the input as V
\i,    e# Push the range from 0 to the input
%      e# Keep only every V'th number in the array
{      e# Do this for each number:
  V+   e# Add V to get the right number of leading zeroes
  s    e# Convert to string for left padding
  V    e# Push V, the length to bring each string to, and...
  0    e# The character to add to the left
  e[   e# Left pad
}/

PHP, 83 78 bytes

<?$a=$argv[1];$i=$y=strlen($a);while($y<=$a){printf('%0'.$i.'d', $y);$y+=$i;}

Las propinas son más que bienvenidas. Me las arreglé para jugar al golf por un byte cambiándolo de un ciclo for a un ciclo while.

Este código supone que esto se está ejecutando desde la línea de comando y que $ argv [1] es el int.

Gracias a:

@AlexGittemeier Su sugerencia (ver comentarios) fue de 5 bytes a 78 bytes.

Perl 6, 69 59 46 bytes

{my \a=.chars;(a,2*a...$_).fmt("%0"~a~"s","")}