Il peso di uno zero

21

Dato un elenco ordinato di numeri (possibilmente con zeri iniziali), disponi i numeri verticalmente, quindi lascia che tutti gli zeri scendano fino in fondo e tutti gli strapiombi cadano nello slot più in basso aperto. Emette gli interi risultanti, rimuovendo gli zeri iniziali.

Esempio lavorato

Supponiamo che ci sia stato dato quanto segue come input:

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

Per prima cosa lo sistemiamo verticalmente:

0000312941295
239124000124581598
32852353800451258
10235923505185190
1491359102149

Quindi, colonna per colonna, rilascia gli zeri "attraverso" gli altri numeri in modo che si appoggino sul fondo e "spingano" gli altri numeri verso l'alto. Ciò comporterebbe i primi due passi come segue:

2000312941295
339124000124581598
12852353800451258
10235923505185190
0491359102149
^

2300312941295
329124000124581598
14852353800451258
10235923505185190
0091359102149
 ^

2390312941295
328124000124581598
14252353800451258
10935923505185190
0001359102149
  ^

...

2391312941295
328524538124581598
14232323525451258
10915991001185190
0000350000049
                ^

Quindi, rilasciare tutte le sporgenze come se la gravità le stesse tirando giù come sabbia.

2391312941295
3285245381245 1598
14232323525458258
10915991001181190
00003500000495
             ^

2391312941295
3285245381245  598
14232323525458158
10915991001181290
000035000004951
              ^

...

2391312941295
3285245381245
14232323525458159
10915991001181258
000035000004951908
                 ^

Infine, genera questi numeri, rimuovendo gli zeri iniziali. Per il nostro esempio lavorato, output:

[2391312941295, 3285245381245, 14232323525458159, 10915991001181258, 35000004951908]

Per un altro esempio, supponiamo che input di [1234000,12345678,1234,12340608,12341234].

1234000
12345678
1234
12340608
12341234

Elimina gli zeri:

1234  
12345678
1234163
12340208
12340004

Rilascia le rimanenti cifre sporgenti:

1234  
1234567
12341638
12340208
12340004

L'output è [1234, 1234567, 12341638, 12340208, 12340004].

Regole

  • L'input può contenere zeri iniziali. L'output non deve contenere zeri iniziali.
  • Se applicabile, puoi supporre che l'input / output si adatti al tipo intero nativo della tua lingua.
  • L'input e l'output possono essere forniti con qualsiasi metodo conveniente .
  • È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
  • Sono vietate le scappatoie standard .
  • Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).
code-golf  array-manipulation 
— AdmBorkBork
fonte
2
Possiamo supporre che i numeri di output non supereranno la precisione della nostra lingua? (JS 1423232352545815914232323525458160
— arriva
@ETHproductions Penso che sia un valore predefinito di PPCG.
— Erik the Outgolfer,
and all overhangs drop to the bottom-most open slotè stata una buona soluzione alla mia sfida rotta :).
— Magic Octopus Urn,
1
@PeterCordes Sì, l'input può contenere zeri iniziali, quindi dovrebbe essere in grado di gestirlo. Immagino per la maggior parte delle lingue, ciò significa prendere input come stringa.
— AdmBorkBork,
1
@PeterCordes L'input e l'output non devono necessariamente essere nella base-10 (che è nei metodi I / O predefiniti consentiti), purché l'utilizzo di una base diversa non banalizzi l'attività (che è una scappatoia standard). In secondo luogo, suppongo di non aver specificato che gli zeri iniziali devono essere rimossi completamente , sebbene quello fosse l'intento. Ho intenzione di governare che la sostituzione degli zeri con spazi non è consentita, poiché l'output . 1234è molto diverso dall'output 1234.
— AdmBorkBork,

Risposte:

10

Gelatina , 8 byte

Z¬Þ€UZṚḌ

Provalo online!

Come funziona

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
CHE COSA? Mentre stavo leggendo la domanda, pensavo: "Infine, non è possibile che qualcuno riesca a ottenere meno di 20 byte per questo". Madness
— Cruncher,
1
Sort each row of the transpose by logical NOT, pushing 0's to the end.Questo è garantito per essere un tipo stabile?
— Cruncher,
1
Sì, Jelly utilizza Python's sorted, che è garantito per essere stabile.
— Dennis,
Mi piace un po 'questa versione dall'aspetto commutativo: ṚZẸÞ€ZṚḌ:)
— Jonathan Allan,
4

Buccia , 12 byte

md↔TmoÖ±miT↔

Provalo online!

Spiegazione

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 byte

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))]

Provalo online!

Versione 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)]

Le prime due righe sono equivalenti al map(lambda*a...)comportamento predefinito se per mapriempire con Nones se un elenco è più corto dell'altro.
e>'0'è equivalente a cell != '0' and cell != None, perché se è una cifra (1 ~ 9) avrà un punto di codice più alto e (qualsiasi) stringa è maggiore di None.

— asta
fonte
Vuoi pubblicare una versione non giocata di questo?
— Peter Cordes,
@PeterCordes ha aggiunto la versione non golfata e una breve spiegazione per alcuni punti oscuri
— Rod
2

Retina 0.8.2 , 95 92 byte

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

Provalo online! Spiegazione: Il primo stadio elimina le cifre sporgenti in quanto ciò semplifica (modifica: ancora più facile per un salvataggio di 3 byte) per il secondo stadio di eliminare gli zeri. Il terzo stadio rimuove quindi gli zeri iniziali.

— Neil
fonte
2

Rubino , 104 byte

->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}}

Provalo online!

Spiegazione

->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) , 26 byte SBCS

Funzione di prefisso tacito anonimo che accetta una matrice di caratteri come argomento e restituisce un elenco di numeri.

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

Provalo online!

⍉ trasporre l'input (dato che dobbiamo lavorare sulle colonne)

' 0'(... )⍤1⍨ applica la seguente funzione tacita a ciascuna riga (sotto-matrice del grado tensore 1) con ' 0'l' argomento corretto (⍨ scambia gli argomenti):

 ∩ intersezione della riga e
 ∘ ed
 ⊃ il primo ' 0'
 (cioèrow∩' ' , tutti gli spazi di ogni riga)

 , seguito da…

 ~ la differenza impostata
 (esrow~' 0' ; la riga ma senza spazi e zeri)

 , seguito da…

 ∩ intersezione della riga e
 ∘ ed
 ⊃ il primo  della invertita  (cioè
 ∘
 ⌽' 0'
row∩'0' , tutti gli zeri di ogni riga)

⍎⍤1 valutare ogni riga (sotto-matrice del grado tensore 1)
∘ della
⍉ trasposizione di quella (cioè ogni colonna; le righe di input ora modificate)

— Adamo
fonte
La punta tra parentesi è intelligente. Mi ci è voluto un po 'per capire l'intenzione lì, anche se so cosa fanno i singoli squiggles. Una volta capito, è facile da battere: ⍎⍤1∘⍉{⍵[⍋3|2×' 0'⍳⍵]}⍤1∘⍉( ⎕io←0) Potrebbe essere ulteriormente giocabile a golf, ad esempio non ho esplorato la ⍋
— diade
in realtà, quanto sopra è più breve come programma completo (non un treno):⍎⍤1⍉{⍵[⍋3|2×' 0'⍳⍵]}⍤1⍉⎕
— ngn
@ngn Un metodo così diverso merita il proprio post. La pre e post elaborazione è ovvia.
— Adám,
1

Perl 5 , -p0 77 byte

Conteggio vecchio stile: 79 byte ( +2per p0)

Fornisci input come righe su STDIN senza newline finale (altrimenti tutto viene visto come sporgenza e la newline finale sale in cima quando la stringa di input si arresta in modo anomalo). Per esempio:

0000312941295
239124000124581598
32852353800451258
10235923505185190
1491359102149

È stato un po 'complicato far cadere lo sbalzo e farlo 0cadere in una regex

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

Provalo online!

— Ton Hospel
fonte
0

Rubino , 203 byte

->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}}

Provalo online!

Un lambda che accetta una matrice di stringhe e restituisce una matrice di ints. Sento che mi manca qualcosa; questo sembra 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
Ho superato questo (per ora)
— Unihedron il
@Unihedron Wow, mi hai battuto del 50%. Di sicuro hai il mio +1.
— benj2240,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.