Dada uma lista ordenada de números (possivelmente com zeros à esquerda), organize os números verticalmente e deixe todos os zeros caírem até o fundo e todas as saliências caírem no slot mais aberto. Produza os números inteiros resultantes, removendo os zeros à esquerda.

Exemplo Trabalhado

Digamos que recebemos o seguinte como entrada:

['0000312941295', '239124000124581598', '32852353800451258', '10235923505185190', '1491359102149']

Primeiro, organizamos verticalmente:

0000312941295
239124000124581598
32852353800451258
10235923505185190
1491359102149

Em seguida, coluna a coluna, solte os zeros "através" dos outros números para que eles fiquem embaixo e "empurre" os outros números para cima. Isso resultaria nos dois primeiros passos da seguinte maneira:

2000312941295
339124000124581598
12852353800451258
10235923505185190
0491359102149
^

2300312941295
329124000124581598
14852353800451258
10235923505185190
0091359102149
 ^

2390312941295
328124000124581598
14252353800451258
10935923505185190
0001359102149
  ^

...

2391312941295
328524538124581598
14232323525451258
10915991001185190
0000350000049
                ^

Em seguida, solte todas as saliências como se a gravidade as estivesse puxando para baixo como areia.

2391312941295
3285245381245 1598
14232323525458258
10915991001181190
00003500000495
             ^

2391312941295
3285245381245  598
14232323525458158
10915991001181290
000035000004951
              ^

...

2391312941295
3285245381245
14232323525458159
10915991001181258
000035000004951908
                 ^

Finalmente, produza esses números, removendo os zeros à esquerda. Para o nosso exemplo trabalhado, output:

[2391312941295, 3285245381245, 14232323525458159, 10915991001181258, 35000004951908]

Para outro exemplo, suponha a entrada de [1234000,12345678,1234,12340608,12341234].

Solte os zeros:

Solte os demais dígitos pendentes:

Saída é [1234, 1234567, 12341638, 12340208, 12340004].

Regras

A entrada pode conter zeros à esquerda. A saída não deve conter zeros à esquerda.
Se aplicável, você pode supor que a entrada / saída caiba no tipo Inteiro nativo do seu idioma.
A entrada e saída podem ser fornecidas por qualquer método conveniente .
Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
As brechas padrão são proibidas.
Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

code-golf array-manipulation AdmBorkBork
fonte

2

Podemos assumir que os números de saída não excederão a precisão de nossa linguagem? (JS arredonda 14232323525458159para 14232323525458160)

ETHproductions 21/02

@ETHproductions Eu acho que é um padrão PPCG.

Erik the Outgolfer

and all overhangs drop to the bottom-most open slotfoi uma boa solução para o meu desafio quebrado :).

Magic Octopus Urn

1

@PeterCordes Sim, a entrada pode conter zeros à esquerda, por isso deve ser capaz de lidar com isso. Eu imagino que para a maioria dos idiomas, isso significa receber entrada como uma string.

AdmBorkBork 22/02

1

@PeterCordes A entrada e a saída não precisam necessariamente estar na base 10 (que é nos métodos de E / S padrão permitidos), desde que o uso de uma base diferente não trivialize a tarefa (essa é uma brecha padrão). Em segundo lugar, acho que não especifiquei que os zeros à esquerda devam ser removidos completamente , embora essa fosse a intenção. Vou decidir que a substituição de zeros por espaços não é permitida, pois a saída . 1234é muito diferente da saída 1234.

AdmBorkBork 23/02

10

Gelatina , 8 bytes

Z¬Þ€UZṚḌ

Experimente online!

Como funciona

Z¬Þ€UZṚḌ  Main link. Argument: M (2D array / matrix)

Z         Zip; transpose M by reading columns as rows.
 ¬Þ€      Sort each row of the transpose by logical NOT, pushing 0's to the end.
    U     Upend; reverse all sorted rows of the transpose.
     Z    Zip again, restoring rows from columns. Overhangs rise to the top.
      Ṛ   Reverse the order of the rows.
       Ḍ  Decimal; convert the rows from base 10 to integer.

Dennis
fonte

4

O QUE? Enquanto lia a pergunta, pensava: "Finalmente, não há como alguém extrair menos de 20 bytes para isso". Madness

Cruncher

1

Sort each row of the transpose by logical NOT, pushing 0's to the end.Isso é garantido para ser um tipo estável?

triturador

1

Sim, o Jelly usa o Python sorted, que é garantido como estável.

Dennis

Eu meio que gosto desta versão procurando comutativa: ṚZẸÞ€ZṚḌ:)

Jonathan Allan

5

05AB1E , 11 bytes

ζεð†R0†R}øï

Experimente online!

Erik, o Outgolfer
fonte

Nunca visto †antes, bom.

Magic Octopus Urn

4

Casca , 12 bytes

md↔TmoÖ±miT↔

Experimente online!

Explicação

md↔Tm(Ö±mi)T↔  -- input as list of strings, example: ["103","32","258"]
            ↔  -- reverse: ["258","32","103"]
           T   -- transpose: ["231","520","83"]
    m(    )    -- with each line do (example with "520")
        mi     -- | convert each char to digit: [5,2,0]
      Ö±       -- | sort by signum (stable): [0,5,2]
               -- : [[2,3,1],[0,5,2],[8,3]]
   T           -- transpose: [[2,0,8],[3,5,3],[1,2]]
  ↔            -- reverse: [[1,2],[3,5,3],[2,0,8]]%
md             -- convert each to integer: [12,353,208]

ბიმო
fonte

4

Python 2 , 118 bytes

lambda l:[int(''.join(z))for z in zip(*map(lambda*a:['']*a.count(None)+[e for e in a if'0'<e]+['0']*a.count('0'),*l))]

Experimente online!

Versão ungolfed

def f(list_):
 max_len = max(len(x) for x in list_)
 transposed_list = zip(*[list(row)+(max_len-len(row))*[None] for row in list_])
 weighted_list = [['']*column.count(None)+[cell for cell in column if cell != '0' and cell != None]+['0']*column.count('0') for column in transposed_list]
 return [int(''.join(row)) for row in zip(*weighted_list)]

As duas primeiras linhas são equivalentes a map(lambda*a...), o comportamento padrão se for mappreencher com Nones se uma lista for mais curta que a outra.
e>'0'é equivalente a cell != '0' and cell != None, porque se for qualquer dígito (1 a 9), ele terá um ponto de código mais alto e a string (qualquer) será maior que None.

Cajado
fonte

Importa-se de publicar uma versão não destruída?

Peter Cordes

@PeterCordes adicionado a versão ungolfed e uma breve explicação de alguns pontos obscuros

Rod

2

Pitão , 11 bytes

iRT_C_M!DMC

Experimente online!

Mr. Xcoder
fonte

2

Retina 0.8.2 , 95 92 bytes

m(+`^((.)*)(.+)(¶(?<-2>.)*)(?(2)_)$
$1$4$3
+`^((.)*)0(.*¶(?>(?<-2>.)*))([^0])
$1$4${3}0
^0+

Experimente online! Explicação: O primeiro estágio elimina os dígitos pendentes, pois isso facilita (editar: ainda mais fácil para economizar 3 bytes) que o segundo estágio elimine os zeros. O terceiro estágio remove os zeros à esquerda.

Neil
fonte

2

Ruby , 104 bytes

->a{a.map{|x|x.ljust(99).chars}.transpose.map{|x|x.sort_by{|x|x<?1?x:?!}}.transpose.map{|x|x.join.to_i}}

Experimente online!

Explicação

->a{
  a.map{|x|x.ljust(99).chars}  # Fill spaces to make this rectangular
    .transpose.map{|x|
       x.sort_by{|x|x<?1?x:?!} # Treat all chars but " 1" as ! (see ascii table)
    }.transpose.map{|x|x.join.to_i} # Convert back to numbers
                       # note: if no leading 0s, eval x*'' , doesn't work here
}

Unihedron
fonte

1

APL (Dyalog Unicode) , ^{SBCS de} 26 bytes

Função de prefixo tácito anônimo, tomando uma matriz de caracteres como argumento e retornando uma lista de números.

⍎⍤1∘⍉' 0'(∩∘⊃,~,∩∘⊃∘⌽)⍤1⍨⍉

Experimente online!

⍉ transponha a entrada (como precisamos trabalhar nas colunas)

' 0'(... )⍤1⍨ aplicar a seguinte função tácito para cada linha (sub-conjunto de tensor rank 1) com ' 0'como direito argumento ( ⍨swaps os argumentos):

∩ intersecção da linha e
∘ e
⊃ o primeiro de ' 0'
(ou seja row∩' ', todos os espaços de cada linha)

, Seguido por…

~ a diferença definida
(ou seja row~' 0', a linha, mas sem espaços e zeros)

, Seguido por…

∩ intersecção da linha e
∘ e
⊃ o primeiro
∘ de
⌽ ser revertidas ' 0'
(ou sejarow∩'0' , todos os zeros de cada linha)

⍎⍤1 avaliar cada linha (sub-matriz do tensor rank 1)
∘ da
⍉ transposição (ou seja, cada coluna; as linhas de entrada agora modificadas)

Adão
fonte

O bit entre parênteses é inteligente. Demorei um pouco para entender a intenção, embora eu saiba o que os rabiscos individuais fazem. Quando entendi isso, é fácil de bater: ⍎⍤1∘⍉{⍵[⍋3|2×' 0'⍳⍵]}⍤1∘⍉( ⎕io←0) Pode ser golfable mais, por exemplo, eu não explorar dyadic⍋

NGN

na verdade, o acima é mais curto como um programa completo (não um trem):⍎⍤1⍉{⍵[⍋3|2×' 0'⍳⍵]}⍤1⍉⎕

ngn 22/02

@ngn Um método tão diferente merece uma publicação própria. O pré e o pós-processamento são óbvios.

Adám 22/02

1

Perl 5 , -p0 77 bytes

Contagem de estilos antigos: 79 bytes ( +2para p0)

Forneça entrada como linhas no STDIN sem nova linha final (caso contrário, tudo será visto como saliência e a nova linha final aumentará para o topo conforme a cadeia de entrada trava). Por exemplo:

0000312941295
239124000124581598
32852353800451258
10235923505185190
1491359102149

Foi um pouco complicado fazer com que o excesso caísse e o 0caísse em uma regex

#!/usr/bin/perl -p0
s/^.{@{+}}\K((0)|.+$)(.*
.{@{+}})((?(2)[1-9]|$))/$4$3$1/m while/|/g;s/^0+//mg

Experimente online!

Ton Hospel
fonte

0

Ruby , 203 bytes

->a{t=->b{b[0].zip(*b[1..-1])}
m=a.map{|s|s.size}.max
a.map!{|s|(s+" "*m)[0...m].chars}
a=t[a].map{|c|c.size.times{|i|" 0"[c[i]]&&(c.slice!(i)==?0?c.push(?0):c.unshift(" "))}
c}
t[a].map{|r|r.join.to_i}}

Experimente online!

Um lambda aceitando uma matriz de seqüências de caracteres e retornando uma matriz de ints. Sinto como se estivesse perdendo alguma coisa; isso parece enorme: /

->a{
  t = -> b { b[0].zip(*b[1..-1]) }     # t is a lambda that transposes 2D arrays
  m = a.map{ |s| s.size }.max          # m is the maximum input string length
  a.map!{ |s| (s+" "*m)[0...m].chars } # Right-pad every string to the same length
  a = t[a].map{ |c|                    # Transpose a, and for every row (column)
    c.size.times{ |i|                  # For every character in the column
      " 0"[c[i]] && (                  # If the character is 0 or space
        c.slice!(i) == ?0 ?            # Remove it from the column, and if it was 0,
          c.push(?0) :                 # Push a 0 to the end (bottom) of the column, else
          c.unshift(" ")               # Add a space to the top of the column
      )
    }
    c
  }
  t[a].map{ |r| r.join.to_i }          # Transpose a back, and parse each row to int
}

benj2240
fonte

Eu superei isso (por enquanto) #

Unihedron 22/02

@Unihedron Uau, você me venceu em 50%. Você tem o meu +1 com certeza.

benj2240

0

APL (Dyalog Classic) , 24 23 22 bytes

⍎⍤1⍉{⍵[⍒⌈9÷⍨⎕d⍳⍵]}⍤1⍉⎕

Experimente online!

com base na solução de Adam

ngn
fonte

O peso de um zero

Exemplo Trabalhado

Regras

Respostas:

Gelatina , 8 bytes

Como funciona

05AB1E , 11 bytes

Casca , 12 bytes

Explicação

Python 2 , 118 bytes

Versão ungolfed

Pitão , 11 bytes

Retina 0.8.2 , 95 92 bytes

Ruby , 104 bytes

Explicação

APL (Dyalog Unicode) , ^{SBCS de} 26 bytes

Perl 5 , -p0 77 bytes

Ruby , 203 bytes

APL (Dyalog Classic) , 24 23 22 bytes

O peso de um zero

Exemplo Trabalhado

Regras

Respostas:

Gelatina , 8 bytes

Como funciona

05AB1E , 11 bytes

Casca , 12 bytes

Explicação

Python 2 , 118 bytes

Versão ungolfed

Pitão , 11 bytes

Retina 0.8.2 , 95 92 bytes

Ruby , 104 bytes

Explicação

APL (Dyalog Unicode) , SBCS de 26 bytes

Perl 5 , -p0 77 bytes

Ruby , 203 bytes

APL (Dyalog Classic) , 24 23 22 bytes

APL (Dyalog Unicode) , ^{SBCS de} 26 bytes