Das Gewicht einer Null

21

Ordnen Sie die Zahlen in einer geordneten Liste (möglicherweise mit führenden Nullen) vertikal an, und lassen Sie alle Nullen ganz nach unten und alle Überhänge ganz nach unten fallen. Geben Sie die resultierenden Ganzzahlen aus, wobei Sie führende Nullen entfernen.

Gearbeitetes Beispiel

Angenommen, wir erhielten als Eingabe Folgendes:

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

Zuerst ordnen wir es vertikal an:

0000312941295
239124000124581598
32852353800451258
10235923505185190
1491359102149

Dann lassen Sie die Nullen Spalte für Spalte "durch" die anderen Zahlen fallen, so dass sie unten liegen, und "drücken" Sie die anderen Zahlen nach oben. Dies würde dazu führen, dass die ersten paar Schritte wie folgt aussehen:

2000312941295
339124000124581598
12852353800451258
10235923505185190
0491359102149
^

2300312941295
329124000124581598
14852353800451258
10235923505185190
0091359102149
 ^

2390312941295
328124000124581598
14252353800451258
10935923505185190
0001359102149
  ^

...

2391312941295
328524538124581598
14232323525451258
10915991001185190
0000350000049
                ^

Lassen Sie als nächstes alle Überhänge fallen, als würde die Schwerkraft sie wie Sand nach unten ziehen.

2391312941295
3285245381245 1598
14232323525458258
10915991001181190
00003500000495
             ^

2391312941295
3285245381245  598
14232323525458158
10915991001181290
000035000004951
              ^

...

2391312941295
3285245381245
14232323525458159
10915991001181258
000035000004951908
                 ^

Geben Sie zum Schluss diese Zahlen aus und entfernen Sie die führenden Nullen. In unserem Beispiel geben Sie Folgendes aus:

[2391312941295, 3285245381245, 14232323525458159, 10915991001181258, 35000004951908]

Nehmen wir für ein anderes Beispiel die Eingabe von an [1234000,12345678,1234,12340608,12341234].

1234000
12345678
1234
12340608
12341234

Lass die Nullen fallen:

1234  
12345678
1234163
12340208
12340004

Löschen Sie die verbleibenden überhängenden Ziffern:

1234  
1234567
12341638
12340208
12340004

Ausgabe ist [1234, 1234567, 12341638, 12340208, 12340004].

Regeln

  • Die Eingabe kann führende Nullen enthalten. Die Ausgabe darf keine führenden Nullen enthalten.
  • Gegebenenfalls können Sie davon ausgehen, dass die Eingabe / Ausgabe in den systemeigenen Integer-Typ Ihrer Sprache passt.
  • Die Eingabe und Ausgabe kann durch jede bequeme Methode erfolgen .
  • Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
  • Standardlücken sind verboten.
  • Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.
code-golf  array-manipulation 
— AdmBorkBork
quelle
2
Dürfen wir davon ausgehen, dass die Ausgabenummern die Genauigkeit unserer Sprache nicht überschreiten? (JS rundet 14232323525458159um 14232323525458160)
— ETHproductions
@ETHproductions Ich denke, das ist ein PPCG-Standard.
— Erik der Outgolfer
and all overhangs drop to the bottom-most open slotwar eine gute Lösung für meine kaputte Herausforderung :).
— Magic Octopus Urn
1
@PeterCordes Ja, die Eingabe kann führende Nullen enthalten, daher sollte sie damit umgehen können. Ich stelle mir für die meisten Sprachen vor, das heißt, man nimmt die Eingabe als Zeichenkette.
— AdmBorkBork
1
@PeterCordes Eingabe und Ausgabe müssen nicht unbedingt zur Basis 10 gehören (das ist die zulässige Standard-E / A-Methode), solange die Verwendung einer anderen Basis die Aufgabe nicht trivialisiert (das ist eine Standardlücke). Zweitens, ich glaube ich nicht angeben , dass die führenden Nullen entfernt werden müssen vollständig , wenn auch , dass die Absicht war. Ich werde regeln, dass das Ersetzen der Nullen durch Leerzeichen nicht zulässig ist, da die Ausgabe . 1234sich stark von der Ausgabe unterscheidet 1234.
— AdmBorkBork

Antworten:

10

Gelee , 8 Bytes

Z¬Þ€UZṚḌ

Probieren Sie es online!

Wie es funktioniert

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
quelle
4
WAS? Als ich die Frage las, dachte ich: "Schließlich gibt es keine Möglichkeit, dass jemand weniger als 20 Bytes dafür herausholt." Madness
— Cruncher
1
Sort each row of the transpose by logical NOT, pushing 0's to the end.Ist dies garantiert eine stabile Sorte?
— Cruncher
1
Ja, Jelly verwendet Pythons sorted, die garantiert stabil sind.
— Dennis
Ich mag diese kommutativ aussehende Version: ṚZẸÞ€ZṚḌ:)
— Jonathan Allan
4

Schale , 12 Bytes

md↔TmoÖ±miT↔

Probieren Sie es online!

Erläuterung

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]
— ბიმო
quelle
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))]

Probieren Sie es online!

Ungolfed-Version

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

Die ersten beiden Zeilen entsprechen map(lambda*a...)dem Standardverhalten, wenn mapzum Füllen mit Nones eine Liste kürzer als die andere ist.
e>'0'ist äquivalent zu cell != '0' and cell != None, denn wenn es sich um eine Ziffer (1 ~ 9) handelt, hat sie einen höheren Codepunkt und (eine) Zeichenfolge ist höher als None.

— Stange
quelle
Möchtest du eine ungolfed Version davon posten?
— Peter Cordes
@PeterCordes fügte die ungolfed Version und eine kurze Erklärung für einige dunkle Punkte hinzu
— Rod
2

Retina 0.8.2 , 95 92 Bytes

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

Probieren Sie es online! Erläuterung: In der ersten Stufe werden die überhängenden Ziffern gelöscht, da in der zweiten Stufe die Nullen leichter gelöscht werden können (Bearbeitung: noch einfacher beim Speichern von 3 Byte). Die dritte Stufe entfernt dann führende Nullen.

— Neil
quelle
2

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

Probieren Sie es online!

Erläuterung

->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
}
— Eineder
quelle
1

APL (Dyalog Unicode) , 26 Byte SBCS

Anonyme implizite Präfixfunktion, die eine Zeichenmatrix als Argument verwendet und eine Liste von Zahlen zurückgibt.

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

Probieren Sie es online!

⍉ transponiere die Eingabe (da wir an den Spalten arbeiten müssen)

' 0'(… )⍤1⍨ Wende die folgende implizite Funktion auf jede Zeile (Unterarray von Tensorrang 1) mit ' 0'dem richtigen Argument an ( ⍨vertauscht die Argumente):

 ∩ Schnittpunkt der Reihe und
 ∘ und
 ⊃ des ersten von ' 0'
 (dh row∩' 'alle Leerzeichen aus jeder Reihe)

 , gefolgt von…

 ~ die eingestellte Differenz
 (dh row~' 0'die Zeile aber ohne Leerzeichen und Nullen)

 , gefolgt von…

 ∩ Schnittpunkt der Reihe und
 ∘ und
 ⊃ die erste
 ∘ von
 ⌽ der umgekehrt ' 0'
 (dhrow∩'0' , alle Nullen von jeder Reihe)

⍎⍤1 auswerten jede Zeile (sub-Array von Tensor mit Rang 1)
∘ der
⍉ die Transponierte daß (dh jede Spalte, die nun modifizierte Eingang Zeilen)

— Adam
quelle
Das in Klammern gesetzte Bit ist clever. Ich habe eine Weile gebraucht, um die Absicht dort zu verstehen, obwohl ich weiß, was einzelne Kringel tun. Sobald ich es verstanden habe, ist es leicht zu schlagen:⍎⍤1∘⍉{⍵[⍋3|2×' 0'⍳⍵]}⍤1∘⍉ ( ⎕io←0) Es ist möglicherweise weiter golfbar, z. B. habe ich ⍋
— dyadic
⍎⍤1⍉{⍵[⍋3|2×' 0'⍳⍵]}⍤1⍉⎕
— Tatsächlich
@ngn Solch eine andere Methode verdient einen eigenen Beitrag. Die Vor- und Nachbearbeitung ist selbstverständlich.
— Adám
1

Perl 5 , -p0 77 Bytes

Zählung nach alter Art: 79 Bytes ( +2für p0)

Geben Sie die Eingabe als Zeilen in STDIN ohne abschließende neue Zeile ein (andernfalls wird alles als Überhang angesehen und die abschließende neue Zeile steigt nach oben, wenn die Eingabezeichenfolge abstürzt). Z.B:

0000312941295
239124000124581598
32852353800451258
10235923505185190
1491359102149

Es war ein bisschen schwierig, den Überhang fallen zu lassen und 0in eine Regex zu fallen

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

Probieren Sie es online!

— Tonne Hospel
quelle
0

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

Probieren Sie es online!

Ein Lambda, das eine Reihe von Zeichenfolgen akzeptiert und eine Reihe von Ints zurückgibt. Ich habe das Gefühl, etwas zu vermissen. das fühlt sich enorm an: /

->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
quelle
Ich habe dies ( vorerst )
— übertroffen
@Unihedron Wow, du hast mich um 50% geschlagen. Du hast mit Sicherheit meine +1.
— benj2240
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.