Dígitos nas faixas

32

Entrada:

Uma lista de números inteiros

Saída:

Coloque cada dígito (e o sinal de menos) em sua própria pista, na ordem -0123456789, ignorando os dígitos duplicados.

Exemplo:

Entrada: [1,729,4728510,-3832,748129321,89842,-938744,0,11111]

Saída:

-0123456789  <- Added as clarification only, it's not part of the output

  1         
   2    7 9
 012 45 78 
-  23    8 
  1234  789
   2 4   89
-   34  789
 0         
  1

Regras do desafio:

  • Quaisquer dígitos duplicados no número são ignorados.
  • A E / S pode estar em qualquer formato razoável. A entrada pode ser como uma lista / matriz de cadeias ou matriz de caracteres. A saída pode ser como uma lista de strings, caracteres, matriz de caracteres etc.
  • Os espaços à direita são opcionais.
  • Qualquer quantidade de novas linhas iniciais ou finais é opcional (mas não entre linhas).
  • A entrada sempre conterá pelo menos um número inteiro
  • Você vai ter que suportar um intervalo inteiro de pelo menos -2,147,483,648embora 2,147,483,647(32-bit).
  • A lista de entrada nunca conterá -0, 00(ou mais do que dois zeros), ou números inteiros com zeros (ou seja 012).
  • Se o seu idioma usa um símbolo diferente para números negativos (como um superior ¯), você também pode usá-lo, desde que seja consistente.
  • Você pode ter um delimitador de espaço entre os dígitos (para que uma linha sem 5 ou 8 possa ser - 0 1 2 3 4 6 7 9substituída por -01234 67 9), desde que seja consistente (e, portanto, também deve haver um espaço entre -e 0).

Regras gerais:

  • Isso é código-golfe , então a resposta mais curta em bytes vence.
    Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
  • As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
  • As brechas padrão são proibidas.
  • Se possível, adicione um link com um teste para o seu código.
  • Além disso, adicione uma explicação, se necessário.

Casos de teste:

Input: [1,729,4728510,-3832,748129321,89842,-938744,0,11111]
Output:
  1         
   2    7 9
 012 45 78 
-  23    8 
  1234  789
   2 4   89
-   34  789
 0         
  1        

Input: [4,534,4,4,53,26,71,835044,-3559534,-1027849356,-9,-99,-3459,-3459,-94593,-10234567859]
Output:
      4     
     345    
      4     
      4     
     3 5    
    2   6   
   1     7  
  0  345  8 
 -   345   9
 -0123456789
 -         9
 -         9
 -   345   9
 -   345   9
 -   345   9
 -0123456789

Input: [112,379,-3,409817,239087123,-96,0,895127308,-97140,923,-748]
Output:
  12       
   3    7 9
-  3       
 01 4   789
 0123   789
-      6  9
 0         
  123 5 789
-01  4  7 9
   23     9
-    4  78 

Input: [-15,-14,-13,-12,-11,10,-9,-8,-7,-5,-4,-3,-1,0,9,100,101,102,1103,104,105,106,116,-12345690]
Output:
- 1   5    
- 1  4     
- 1 3      
- 12       
- 1        
-01        
-         9
-        8 
-       7  
-     5    
-    4     
-   3      
- 1        
 0         
          9
 01        
 01        
 012       
 01 3      
 01  4     
 01   5    
 01    6   
  1    6   
-0123456  9

Input: [99,88,77,66,55,44,33,22,11,10,0,0,0,-941]
Output:
          9
         8 
        7  
       6   
      5    
     4     
    3      
   2       
  1        
 01        
 0         
 0         
 0         
- 1  4    9
code-golf  ascii-art  number  integer 
— Kevin Cruijssen
fonte
Seriam permitidos espaços entre os dígitos na saída?
— Salsicha
Podemos usar menos superior em ¯vez de -?
— Uriel
Os dígitos ausentes ainda seriam substituídos por espaços, portanto, no seu exemplo, haveria 3 espaços entre 4 e 6 e 7 e 9: "-0 1 2 3 4 <space> 6 7 <space> 9"(Vários espaços são recolhidos nos comentários, por algum motivo)
— Shaggy
11
Eu estava esperando esgueirar aquele passado por você! : D Bem manchado!
— Salsicha
11
— streetster 28/03

Respostas:

4

Stax , 8 bytes

║V≡u╝─é╢

Execute e depure

É necessário um número por linha na entrada padrão. Ele funciona localizando o índice de destino de cada personagem e atribuindo-o ao índice do resultado. Se o índice estiver fora dos limites, a matriz será expandida com zeros até que caiba. Durante a saída, 0torna-se um espaço. O resto são códigos de caracteres.

Descompactado, não jogado e comentado, é assim que parece.

m       for each line of input, execute the rest of the program and print the result
 zs     put an empty array under the line of input
 F      for each character code in the line of input, run the rest of the program
  Vd    "0123456789"
  I^    get the index of the character in this string and increment
  _&    assign this character to that index in the original string

Execute este

— recursivo
fonte
Como se pretende inserir uma lista de comprimento um? (Se é apenas o valor ou o valor e uma nova linha que não funciona.)
— Jonathan Allan
11
Oh sim, bom argumento. Uma forma alternativa de entrada que também funciona para valores únicos é ["7"]. Este formato também pode lidar com vários valores, como ["34", "43"].
— recursivo
6

05AB1E , 13 bytes

Código:

v'-žh«DyмSð:,

Usa a codificação 05AB1E . Experimente online!

Explicação:

v               # For each element in the input..
 '-žh«          #   Push -0123456789
      D         #   Duplicate this string
       yм       #   String subtraction with the current element
                    e.g. "-0123456789" "456" м  →  "-0123789"
         Sð:    #   Replace all remaining elements with spaces
                    e.g. "-0123456789" "-0123789" Sð:  →  "     456   "
            ,   #   Pop and print with a newline
— Adnan
fonte
11
Agradável! Indo a rota substituir foi menor do que a inserção do caminho eu vejo :)
— Emigna
2
@ Emigna A rota de inserção também é uma abordagem muito interessante. Na verdade, acho que você pode salvar 4 bytes com vðTúyvyÐd+ǝ},;).
— Adnan
11
Brilhante! Eu não sabia ǝque funcionaria assim -0. Mas agora que eu acho isso, na verdade é um número e não uma string, como eu li pela primeira vez: P
— Emigna 27/03/18
Ooooof ... eu tinha 23 bytes. O 05AB1E (trocadilho com a humanidade).
— Urna de polvo mágico
4

JavaScript, 59 58 bytes

Entrada e saída como uma matriz de strings.

a=>a.map(x=>`-0123456789`.replace(eval(`/[^${x}]/g`),` `))

Tente

o.innerText=(g=s=>(f=
a=>a.map(x=>`-0123456789`.replace(eval(`/[^${x}]/g`),` `))
)(s.split`,`).join`\n`)(i.value="1,729,4728510,-3832,748129321,89842,-938744,0,11111");oninput=_=>o.innerText=g(i.value)
input{width:100%;}
<input id=i><pre id=o></pre>
Expandir snippet

Original

Recebe entrada como uma matriz de seqüências de caracteres e gera uma matriz de matrizes de caracteres

a=>a.map(x=>[...`-0123456789`].map(y=>-~x.search(y)?y:` `))

Mostrar snippet de código

— Shaggy
fonte
11
uma solução tão elegante, eu realmente gosto.
— 27718 Brian H.
3

05AB1E , 17 13 bytes

Guardado 4 bytes graças a Adnan

vðTúyvyÐd+ǝ},

Experimente online!

Explicação

v               # loop over elements y in input
 ðTú            # push a space prepended by 10 spaces
    yv          # for each element y in the outer y
      y         # push y
       Ðd+      # push y+isdigit(y)
          ǝ     # insert y at this position in the space-string
           }    # end inner loop
            ,   # print
— Emigna
fonte
3

Ruby , 42 bytes

Lambda anônimo processando a matriz de números:

->a{a.map{|n|"-0123456789".tr"^#{n}",?\s}}

Experimente online!

Como alternativa, um programa completo completamente semelhante ao Perl é muito mais curto. Eu diria que os -plswitches parecem bem engraçados nesse contexto:

Ruby -pl , 29 bytes

$_="-0123456789".tr"^#$_"," "

Experimente online!

Finalmente, é possível o seguinte, se for aceitável que as seqüências de saída sejam citadas:

Ruby -n , 27 bytes

p"-0123456789".tr ?^+$_,?\s

Experimente online!

— Kirill L.
fonte
3

JavaScript (Node.js) , 60 bytes

  • Obrigado a @Andrew Taylor por reduzir a junção (8 caracteres)
  • Obrigado a @Yair Rand pelo X.match (8 caracteres)
a=>a.map(X=>"-0123456789".replace(/./g,x=>X.match(x)?x:" "))

Experimente online!

— DanielIndie
fonte
Ah, esse jointruque é adorável - mas a pergunta é como uma matriz de seqüências de caracteres é uma saída OK, então talvez você possa raspar 8 bytes removendo-o?
— Andrew Taylor
Certeza que você pode salvar outro, substituindo (X+"").includes(x)comRegExp(x).test(X)
— Andrew Taylor
(X+"").match(x)seria ainda mais curto. A questão também permite que a entrada seja uma matriz de seqüências de caracteres, podendo até ser X.match(x).
— Yair Rand
2

Japt , 16 bytes

Entrada e saída como uma matriz de strings.

£Ao ¬i- ®iS gXøZ

Tente

Explicação

£                    :Map over each element X
 Ao                  :  Range [0,10)
    ¬                :  Join to a string
     i-              :  Prepend "-"
        ®            :  Map over each character Z
         iS          :    Prepend a space
            g        :    Get the character at index
             XøZ     :      X contains Z? (true=1, false=0)
— Shaggy
fonte
2

Python 3 , 77 64 bytes

-12 bytes graças a @Rod

lambda x:[[[" ",z][z in str(y)]for z in"-0123456789"]for y in x]

Experimente online!

Minha primeira tentativa adequada de jogar golfe em Python. Conselho bem-vindo!

Retorna uma matriz 2D de caracteres.

— Brincadeira
fonte
11
Você pode usar em '-0123456789'vez disso, range(10)largar o primeiro bloco e trocar str(z)com z, você também pode alternar para python2 e usar em `y`vez disso str(y)( ``é + - equivalente a repr) #
— Rod
Espaço supérfluo em in "-.
— Jonathan Frech 27/03
2

Haskell , 47 bytes

map(\s->do d<-"-0123456789";max" "[d|elem d s])

Experimente online!

Usa maxpara inserir um espaço onde nenhum elemento existe, pois um espaço é menor que qualquer dígito ou sinal de menos.

Se um número ímpio de espaços à direita estiver OK, dois bytes poderão ser salvos:

45 bytes

map(\s->do d<-'-':['0'..];max" "[d|elem d s])

Experimente online!

— xnor
fonte
2

MATL , 13 bytes

"45KY2ht@gm*c

Entrada é uma matriz de células de cadeias. Experimente online! Ou verifique todos os casos de teste .

Explicação

         % Implicit input: cell array of strings, for example {'1','729',...,'11111'}
"        % For each cell
  45     %   Push 45 (ASCII code of '-')
  KY2    %   Push predefined literal '0123456789'
  h      %   Concatenate horizontally: gives '-0123456789'
  t      %   Duplicate
  @      %   Push current cell, for example {'729'}
  g      %   Convert cell to matrix. This effectively gives the cell's contents, '729'
  m      %   Ismember: gives an array of zeros and ones indicating membership of each
         %   char from '-0123456789' in '729'. The result in the example is
         %   [0 0 0 1 0 0 0 0 1 0 1]
  *      %   Multiply, element-wise. Chars are implicity converted to ASCII 
         %   Gives the array [0 0 0 50 0 0 0 0 55 0 57] 
  c      %   Convert ASCII codes to chars. 0 is displayed as space. Gives the string
         %   '   2    7 9'
         % Implicit end
         % Implicilly display each string on a different line
— Luis Mendo
fonte
2

J , 32 27 bytes

-5 bytes graças ao FrownyFrog!

10|.":(10<."."0@[)}11$' '"0

Experimente online!

Solução original:

J , 32 bytes

(('_0123456789'i.[)}11$' '"0)@":

Explicação:

@": converter para caracteres e

}11$' '"0 alterar o conteúdo de uma matriz de 11 espaços para esses caracteres

'_0123456789'i.[ nos locais, indicados pelos índices dos caracteres nesta lista

Experimente online!

— Galen Ivanov
fonte
11
10|.":(10<."."0@[)}11$' '"0
— FrownyFrog
@FrownyFrog Boa solução, obrigado!
— Galen Ivanov
2

Planilhas Google , 124 bytes

=Transpose(ArrayFormula(If(IsError(Find(Mid("-0123456789",Row($1:$11),1),Split(A1,",")))," ",Mid("-0123456789",Row($1:$11),1

Entrada é uma lista separada por vírgula na célula A1. A saída está no intervalo em B1:L?que ?há, no entanto, muitas entradas. (Você pode colocar a fórmula onde quiser, apenas escolhi B1por conveniência.) Observe que o Planilhas adicionará automaticamente quatro parênteses de fechamento ao final da fórmula, economizando esses quatro bytes.

Screenshot

Outro caso de teste e outro caso de teste

Explicação:

  • Mid("-0123456789",Row($1:$11),1) escolhe cada um dos 11 caracteres por vez.
  • Find(Mid(~),Split(A1,","))procura esses caracteres em cada um dos elementos de entrada. Isso retorna um valor numérico ou, se não for encontrado, um erro.
  • If(IsError(Find(~)," ",Mid(~))retornará um espaço se o personagem não foi encontrado ou se foi. (Gostaria que houvesse uma maneira de evitar duplicar a Mid(~)parte, mas não conheço uma.)
  • ArrayFormula(If(~))é o que faz as referências multicelulares Mid(~)eFind(~) trabalho. É também o que faz com que uma fórmula em uma célula retorne valores em várias células.
  • Transpose(ArrayFormula(~)) transponha a matriz retornada porque ela inicia lateralmente.
— Engenheiro Toast
fonte
1

Perl 6 , 35 bytes

{.map:{map {m/$^a/||' '},'-',|^10}}

Experimente online!

Saída é uma matriz de caracteres que contém correspondências de expressão regular ou caracteres de espaço.

— Nwellnhof
fonte
Se 'input pode estar em qualquer formato razoável' puder ser stdin, presumivelmente -pepermitiria que você dispensasse o inicial .map, chaves e troque $^apor #$_
— Phil H
@ PhilH -pe de -nalguma forma parecem com erros, pelo menos no TIO. Por alguma razão, $_não é passado para blocos. Veja o exemplo 1 , exemplo 2 .
— Nwellnhof 27/03
1

Java 8, 53 bytes

a->a.map(i->"-0123456789".replaceAll("[^"+i+"]"," "))

Meu próprio desafio é mais fácil do que eu pensava quando o fiz.

Entrada e saída como a java.util.stream.Stream<String>.

Explicação:

Experimente online.

a->                              // Method with String-Stream as both input and return-type
  a.map(i->                      //  For every String in the input:
    "-0123456789"                //   Replace it with "-0123456789",
    .replaceAll("[^"+i+"]"," ")) //   with every character not in `i` replaced with a space
— Kevin Cruijssen
fonte
1

R , 96 75 bytes

for(i in scan())cat(paste(gsub(paste0("[^",i,"]")," ","-0123456789"),"\n"))

Experimente online!

Agradecemos a Kevin Cruijssen por sugerir essa abordagem regex!

Pega a entrada do stdin como números inteiros separados por espaço em branco e imprime o ascii-art no stdout.

— Giuseppe
fonte
Não sei R muito bem, então eu tenho certeza que ele pode ser golfed mais, mas esta abordagem diferente é 12 bytes mais curto: function(N)for(i in N)cat(paste(gsub(paste("[^","]",sep=i)," ","-0123456789"),"\n")). (Digite como string-array em vez de número inteiro.) Experimente online.
— Kevin Cruijssen 27/03
@KevinCruijssen ah, bom, sim, eu também posso jogar golfe.
— Giuseppe
1

SOGL V0.12 , 14 13 bytes

{ø,{²²⁴WI1ž}P

Experimente aqui!

Explicação:

{ø,{²²⁴WI1ž}P

{            repeat input times
 ø,            push an empty string and the next input above that
   {       }   for each character in the input
    ²²           push "0123456789"
      ⁴          copy the character on top
       W         and get it's index in that string (1-indexed, 0 for the non-existent "-")
        I        increment that (SOGL is 1-indexed, so this is required)
         1ž      at coordinates (index; 1) in the string pushed earlier, insert that original copy of the character
            P  print the current line
— dzaima
fonte
1

SNOBOL4 (CSNOBOL4), 85 bytes

I	X =INPUT	:F(END)
	S ='-0123456789'
R	S NOTANY(X ' ') =' '	:S(R)
	OUTPUT =S	:(I)
END

Try it online!

I	X =INPUT	:F(END)		;* read input, if none, goto end
	S ='-0123456789'		;* set the string
R	S NOTANY(X ' ') =' '	:S(R)	;* replace characters of S not in X + space with space
	OUTPUT =S	:(I)		;* print S, goto I
END
— Giuseppe
fonte
1

Pyth, 14 bytes

VQm*d}dNs+\-UT

Takes input as list of strings and outputs a list of strings for each line.
Try it here

Explanation

VQm*d}dNs+\-UT
VQ                For each string in the input...
  m     s+\-UT    ... and each character in "-0123456789"...
     }dN          ... check if the character is in the string...
   *d             ... and get that character or an empty string.
1

Retina, 26 bytes

%"-0123456789"~`.+
[^$&]¶

Try it online! Note: Trailing space. Explanation: % executes its child stage ~ once for each line of input. ~ first executes its child stage, which wraps the line in [^ and ]<CR><SP>, producing a program that replaces characters not in the line with spaces. The "-0123456789" specifies that the input to that program is the given string ($ substitutions are allowed but I don't need them).

— Neil
fonte
1

Perl 5 -n, 30 bytes

Wouldn't work if - could appear anywhere else than in the first position

#!/usr/bin/perl -n
say"-0123456789"=~s/[^$_]/ /gr

Try it online!

— Ton Hospel
fonte
Wouldn't work if - could appear anywhere else than in the first position if that can be true then you are not answering this challenge, since they wouldn't be integers anymore. :P
— Erik the Outgolfer
1

CJam, 20 bytes

qS%{'-10,+s_@-SerN}/

Try it online!

Accepts input as space separated list of integers. Pretty much the same approach as @adnans answer.

— Marcos
fonte
1

C (gcc), 95 94 bytes

c,d;f(l,n)char**l;{for(;n--;l++)for(c=0;c<12;)putchar(strchr(*l,d=c++?c+46:45)?d:d^58?32:10);}

Try it online!

Input in the form of a list of strings. Output to STDOUT.

— gastropner
fonte
You can golf a byte by removing the c++, and changing d=c?c+47: to d=c++?c+46:.
— Kevin Cruijssen
1

K4, 30 27 bytes

Solution:

{?[a in$x;a:"-",.Q.n;" "]}'

Example:

q)k){?[a in$x;a:"-",.Q.n;" "]}'1 729 4728510 -3832 748129321 89842 -938744 0 11111
"  1        "
"   2    7 9"
" 012 45 78 "
"-  23    8 "
"  1234  789"
"   2 4   89"
"-   34  789"
" 0         "
"  1        "

Explanation:

Return "-0123..." or " " based on the input. Interpreted right-to-left. No competition for the APL answer :(

{?[a in$x;a:"-",.Q.n;" "]}' / the solution
{                        }' / lambda for each
 ?[      ;          ;   ]   / if[cond;true;false]
                .Q.n        / string "0123456789"
            "-",            / join with "-"
          a:                / save as a
       $x                   / convert input to string
   a in                     / return boolean list where each a in x
                     " "    / whitespace (return when false)
— streetster
fonte
0

APL+WIN, 33 bytes

Prompts for screen input as a string

n←11⍴' '⋄n['-0123456789'⍳s]←s←⎕⋄n
— Graham
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.