Quanto sono alti i monoliti?

29

Ecco un esempio di un input di monoliti . Ce ne sono 4 in questo esempio.

  _
 | |        _
 | |  _    | |
 | | | |   | |     _
_| |_| |___| |____| |_

Il primo monolite è alto 4 unità, il secondo è 2, il terzo è 3 e l'ultimo è 1.

L'obiettivo

Il tuo programma dovrebbe produrre le altezze dei monoliti in ordine da sinistra a destra. Il formato di output può essere in qualsiasi tipo di elenco o matrice.

Gli appunti

  • L'input può essere preso come qualsiasi stringa dimensionale, elenco di stringhe o elenco di caratteri.
  • Questo è code-golf , quindi vince il byte più basso .
  • Devi presumere che i monoliti abbiano sempre la stessa larghezza e siano sempre ad almeno 1 di _distanza da un altro.
  • Possono venire in qualsiasi altezza e in qualsiasi quantità.

I / O

  _
 | |        _
 | |  _    | |
 | | | |   | |     _
_| |_| |___| |____| |_   >> [4,2,3,1]

           _
          | |
  _       | |
 | |  _   | |  _
_| |_| |__| |_| |_   >> [2,1,4,1]


 _   _   _ 
| |_| |_| |_____   >> [1,1,1]

____________________   >> undefined behavior

 _
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |   >> [11]

     _       _       _       _       _
 _  | |  _  | |  _  | |  _  | |  _  | |
| |_| |_| |_| |_| |_| |_| |_| |_| |_| |  >> [1,2,1,2,1,2,1,2,1,2]
code-golf  ascii-art 
— Graviton
fonte
2
Posso supporre che l'ingresso sia correttamente riempito di spazi?
— Isaacg,
17
Il tuo [10]monolite no [11]?
— Tessellating Heckler,
Quello indefinito non sarebbe solo un array vuoto?
— Solomon Ucko,
@isaacg sì, sarebbe okay
— Graviton,
@SolomonUcko tecnicamente sì, anche se per renderlo più semplice per tutte le lingue ho deciso di non farne fronte.
— Graviton,

Risposte:

15

Jelly , (8?) 9 byte

Ỵ=”|Sḟ0m2

Un collegamento monadico che accetta un elenco di caratteri come specificato e restituisce un elenco di numeri interi.

Nota: 8 byte se un elenco di stringhe, uno per riga, era realmente destinato a essere un formato di input consentito - è sufficiente rimuovere il Ỵ.

Provalo online!

Come?

Ỵ=”|Sḟ0m2 - Link: list of characters, s
Ỵ         - split at newlines
  ”|      - literal '|'
 =        - equals (vectorises)
    S     - sum (vectorises, hence counts the number of '|' in every column)
     ḟ0   - filter out zeros (only keep the results from the sides of the towers)
       m2 - modulo index with 2 (keep only the left side measurements)
— Jonathan Allan
fonte
Non lo so, ma è questo va bene?
— V. Courtois,
1
@ V.Courtois Non vedo perché no, dal momento che probabilmente non avremo mai tale input.
— Erik the Outgolfer,
Ok, è perché ho visto che alcune altre risposte la prendono in considerazione
— V. Courtois,
2
@ V. Courto: l'input che hai suggerito non rientra nelle specifiche, allo stesso modo l'aggiunta di sottolineature nel cielo, i monoliti in parte o sotterranei probabilmente interromperebbe molte altre osservazioni.
— Jonathan Allan,
Down-voter - ti andrebbe di spiegare le tue ragioni?
— Jonathan Allan,
6

JavaScript (ES6), 79 78 byte

-1 byte grazie a @Shaggy

a=>a.map((b,i)=>b.replace(/_/g,(_,j)=>o[j]=a.length-i-1),o=[])&&o.filter(x=>x)

Accetta input come una matrice di stringhe.

Test dello snippet

f=
a=>a.map((b,i)=>b.replace(/_/g,(_,j)=>o[j]=a.length-i-1),o=[])&&o.filter(x=>x)
I.value="           _\n          | |\n  _       | |\n | |  _   | |  _\n_| |_| |__| |_| |_"
<textarea id=I rows=7 cols=30></textarea><br><button onclick="O.value=`[${f(I.value.split`\n`).join`, `}]`">Run</button> <input id=O disabled>
Espandi frammento

— Justin Mariner
fonte
1
78 byte:a=>a.map((x,y)=>x.replace(/_/g,(_,z)=>c[z]=a.length-y-1),c=[])&&c.filter(n=>n)
— Shaggy,
@Shaggy Nice, non pensavo assolutamente di usarlo replace. Grazie!
— Justin Mariner,
6

C ++, 171 169 byte

#import<vector>
#import<iostream>
int f(std::vector<std::string>s){for(int a,j,i=0,k=s.size()-1;a=s[k][i];++i)if(a==32){for(j=0;(a=s[k-++j][i])-95;);std::cout<<j<<" ";}}

Provalo online!

C ++ (GCC), 150 byte

Grazie a @aschepler!

#import<vector>
#import<iostream>
int f(auto s){for(int a,j,i=0,k=s.size()-1;a=s[k][i];++i)if(a==32){for(j=0;(a=s[k-++j][i])-95;);std::cout<<j<<" ";}}

Provalo online!

— Steadybox
fonte
1
Se si utilizza g ++, è possibile utilizzare il non standard f(auto s)e specificare che accetta qualsiasi contenitore ad accesso casuale di contenitori ad accesso casuale di char.
— aschepler,
5

Dyalog APL, 29 byte

{0~⍨↑+/(⌈/⍴¨⍵)↑¨(⍳≢⍵)×⌽⍵='_'}

Corri con ⎕IO←0.

Provalo online!

Come?

⌽⍵='_'- dove ⍵è '_', linee superiore per primo

×- moltiplicato per ...

(⍳≢⍵)- l'intervallo di ⍵(zero indicizzato)

↑¨ - per ogni riga, pad con zeri di ...

(⌈/⍴¨⍵) - la lunghezza massima

↑+/ - sommare le file compresse e appiattite

0~⍨ - rimuove gli zeri

— Uriel
fonte
5

PowerShell, 133 byte

param($s)$r=,0*($l=($s=$s-replace'\| \|',' 1 ')[0].Length);1..$s.Count|%{$z=$_-1;0..($l-1)|%{$r[$_]+=(''+$s[$z][$_]-as[int])}};$r-ne0

Sembra che non sia molto competitivo; sostituisce una regex per trasformare le torri in colonne di 1, crea una matrice di 0 la lunghezza della stringa di input, quindi passa attraverso le linee sommando gli 1.

Test pronti per l'esecuzione:

$s1 = @'
  _                   
 | |        _         
 | |  _    | |        
 | | | |   | |     _  
_| |_| |___| |____| |_
'@-split"`r?`n"


$s2 = @'
 _
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| | 
'@-split"`r?`n"

$s3 = @'
           _      
          | |       
  _       | |           
 | |  _   | |  _   
_| |_| |__| |_| |_ 
'@-split"`r?`n"


$s4 = @'
 _   _   _      
| |_| |_| |_____ 
'@-split"`r?`n"

$s5 = @'
     _       _       _       _       _ 
 _  | |  _  | |  _  | |  _  | |  _  | |
| |_| |_| |_| |_| |_| |_| |_| |_| |_| | 
'@-split"`r?`n"
— TessellatingHeckler
fonte
4

Japt , 11 byte

z ·mb'_ fw0

Provalo online!

Spiegazione

z ·mb'_ fw0   : Implicit input
z             : Rotate the input clockwise. This puts the "floor" against the left side.
  ·           : Split the 2D string into lines.
   m          : Replace each column (now row) X with
    b'_       :   the index of '_' in X (0-indexed). This gives us the output list, with
              :   0's and -1's mixed in representing the columns that are not monoliths.
        f     : Take only the items X where
         w0   :   max(X, 0) is truthy. Since 0 is falsy, this removes anything <= 0.
              : Implicit: output result of last expression
— ETHproductions
fonte
4

Retina , 48 38 byte

^
¶
{`(¶.*)*¶_(.*¶)+
$#2 $&
}`¶.
¶
G`.

Provalo online! Il link include il primo esempio. Spiegazione: È stata prefissata una riga che raccoglierà i risultati. Poiché ogni colonna viene ripetutamente eliminata a sua volta, quelle che contengono un _livello fuori terra hanno il numero di righe rimanenti nella colonna conteggiata. Alla fine vengono eliminate le righe vuote. Modifica: salvato 10 byte grazie all'ispirazione di @FryAmTheEggman.

— Neil
fonte
Bene, avevo una soluzione leggermente più breve , ma non avrebbe funzionato su input di grandi dimensioni poiché avrebbe incasinato la mia capacità di ordinarli. Andare colonna per colonna è un bel modo per evitarlo!
— FryAmTheEggman,
@FryAmTheEggman Sono passato al tuo metodo di conteggio delle linee usando la _s che ha molto più senso che provare a usare la |s, grazie!
— Neil,
@FryAmTheEggman Non risolve il problema, ma la fase di smistamento può essere semplificata rilasciando il lookbehind e l'ordinamento per $.%`, e la fase finale può essere !`\d+. E se cambi il primo stadio in un lookahead, non è necessario eseguire il loop.
— Martin Ender,
@FryAmTheEggman Ed ecco una soluzione al tuo approccio, ma finisce con 46 byte.
— Martin Ender,
@MartinEnder 45 forse? Provalo online!
— Neil,
4

Java 8, 133 117 116 114 byte

a->{for(int l=a.length-1,i=0,j;i<a[0].length;i++)if(a[l][i]<33){for(j=0;a[j][i]<33;j++);System.out.print(l-j+",");}}

Prende l'input come a (← salva 16 byte). -2 byte in cambio di output meno leggibile grazie a @ OlivierGrégoire passando a .String[] char[][]
print(l-j+",")println(l-j)

Spiegazione:

Provalo qui.

a->{                         // Method with character 2D-array parameter and no return-type
  for(int l=a.length-1,      //  Length of the 2D char-array - 1
      i=0,j;                 //  Index-integers
    i<a[0].length;i++)       //  Loop (1) over the 2D char-array
    if(a[l][i]<33){          //   If the base of the current column is a space
      for(j=0;a[j][i]<33;    //    Loop (2) over the cells in this column as long as
                             //    we encounter spaces (from top to bottom)
        j++                  //     And increase `j` every time, to go down the column
      );                     //    End of loop (2)
      System.out.println(l-j);
                             //    Print the amount of rows - `j`
    }                        //   End of if-block
                             //  End of loop (1) (implicit / single-line body)
}                            // End of method
— Kevin Cruijssen
fonte
Non l'ho ancora provato, ma la mia idea per questa sfida è stata quella di andare dall'alto verso il basso e cercare _se si trova il negozio in cui si trova la posizione, quindi ordinare su quello, ignorando ovviamente la riga in basso. Potrebbe aiutare a salvare byte ...
— TheLethalCoder
@TheLethalCoder Anche quello era il mio pensiero iniziale, ma dove vuoi memorizzarlo / ordinarlo? Inizialmente ho pensato a una mappa, ma quelli non sono ordinati, quindi avrai bisogno di una mappa collegata. Nella mia testa sembrava un po 'troppo byte, ma se riesci a trovare un modo per farlo più breve di questo, sentiti libero di postare una risposta e la +1. :)
— Kevin Cruijssen il
Sono riuscito a portarlo a 150 solo usando Linq, ma dovrebbe esserci ancora spazio per giocare a golf.
— TheLethalCoder
In C # abbiamo array multidimensionali come: new[,]invece dell'array frastagliato che stai usando come new[][]. Se lo hai in Java, potresti risparmiare qualche byte.
— TheLethalCoder
1
System.out.println(l-j);mi sembra abbastanza faticoso per risparmiare 2 byte. Inoltre, nella spiegazione, hai dimenticato di cambiare length()in length(nessuna incidenza sul conteggio dei byte poiché è corretta nell'invio).
— Olivier Grégoire,
3

Haskell, 75 74 byte

import Data.List;f=filter(>0).map(length.fst.span(<'!').reverse).transpose

L'input è previsto come un elenco di stringhe (a righe).

— siracusa
fonte
Perché usare un punto e virgola dopo l'importazione, quando una nuova riga ha la stessa lunghezza e più idiomatica?
— Jules,
@Jules: Sì, di solito lo faccio
— siracusa il
3

C #, 150 144 137 byte

using System.Linq;a=>a.SelectMany((i,h)=>i.Select((c,w)=>new{c,w,d=a.Length-1-h}).Where(o=>o.c==95&o.d>0)).OrderBy(o=>o.w).Select(o=>o.d)

Versione completa / formattata:

using System;
using System.Collections.Generic;
using System.Linq;

class P
{
    static void Main()
    {
        Func<char[][], IEnumerable<int>> f = a =>
            a.SelectMany((i, h) => i.Select((c, w) => new { c, w, d = a.Length - 1 - h })
                                    .Where(o => o.c == 95 & o.d > 0))
             .OrderBy(o => o.w)
             .Select(o => o.d);

        Console.WriteLine(string.Concat(f(new char[][]
        {
            "  _                 ".ToArray(),
            " | |       _        ".ToArray(),
            " | |  _   | |       ".ToArray(),
            " | | | |  | |    _  ".ToArray(),
            "_| |_| |__| |___| |_".ToArray(),
        })));

        Console.ReadLine();
    }
}
— TheLethalCoder
fonte
3

Java 8 - 229 byte 213 byte

s->{Map<Integer,Integer> m=new TreeMap();String[] l=s.split("\n");for(int i=0,j=-1;i<l.length-1;++i){s=l[i];while((j=s.indexOf("_",j+1))>=0){m.put(j,i);}}for(int i:m.values()){System.out.print(l.length-i-1+",");}}

Provalo online!

Ungolfed:

public static void foo(String input)
{
    Map<Integer, Integer> map = new TreeMap(); // Raw types!!
    String[] lines = input.split("\n");

    for (int i = 0, j = -1; i < lines.length - 1; ++i)
    {
        input = lines[i];

        while ((j = input.indexOf("_", j + 1)) >= 0)
        {
            map.put(j, i);
        }
    }

    for(int i:map.values())
    {
        System.out.print(lines.length - i - 1 + ",");
    }
}

Woo, primo post. Qualsiasi aiuto per migliorarlo sarebbe fantastico. Io so che posso sbarazzarsi di quella indexOfscritta due volte. Lo sapevo! Ho giocato con l'idea di cambiare i tipi nella mappa da Integer a Long ma penso che sia un vicolo cieco.

So che esiste già una soluzione Java 8 molto, molto migliore , ma che accetta char[][]come input che penso sia più facile lavorare in questo caso rispetto a String.

— Michael
fonte
1
Non hai incluso le importazioni (sono richieste per le risposte Java). Non usare un Mapma un int[](forse inizializzato a new int[99]?). Non c'è bisogno di uno spazio dopo String[] l: String[]lfunziona allo stesso modo ed è più corto. Usa println(l.length-i-1)invece di println(l.length-i-1+","). Non inizializzare j: basta scrivere: ,j;. Se si utilizza un int[]come suggerito in precedenza, dichiarare in questo modo: int m[]=new int[99],i=0,j;e rimuovere la dichiarazione da for-loop.
— Olivier Grégoire,
1
OlivierGrégoire ha davvero ragione sull'importazione richiesta per Map. Per quanto riguarda alcuni campi da golf del codice corrente con la mappa, è possibile modificarlo a questo: import java.util.*;s->{Map m=new TreeMap();String[]a=s.split("\n");int l=a.length-1,j=-1,i=j;for(;++i<l;)for(s=a[i];(j=s.indexOf("_",j+1))>=0;m.put(j,i));for(Object o:m.values())System.out.println(l-(int)o);}. Non è necessario per la <Integer,Integer>mappa quando è possibile eseguire il cast int; a.length-1viene utilizzato due volte, quindi è possibile utilizzare una variabile per esso; mettendo tutto dentro i for-loop, puoi sbarazzarti di tutte le parentesi. Oh, e benvenuto in PPCG! :)
— Kevin Cruijssen,
@KevinCruijssen Grazie! Convertire i contenuti di quel primo per loop in un bodyless per loop è stato stimolante! Super intelligente.
— Michael,
@Michael Prego. :) Oh, e se non l'hai ancora visto: suggerimenti per giocare a golf in Java e suggerimenti per giocare a golf in <tutte le lingue> potrebbero essere interessanti da leggere. Mi ha aiutato molto quando ho iniziato (e lo fa ancora a volte).
— Kevin Cruijssen,
2

Mathematica, 48 47 39 byte

Last/@(Reverse@Most@#~Position~"_")&

Provalo online!

Functionche prevede una matrice rettangolare di caratteri. Prende Mostl'array (tutti tranne l'ultima riga), Reverselo fa, quindi prende lo Transpose*, quindi trova tutti gli Positions in cui _appare il personaggio. Le altezze pertinenti sono gli Lastelementi di ciascuno Position.

* è il 3carattere di utilizzo privato byte U+F3C7che rappresenta \[Transpose]in Mathematica. Nota che questo non funziona in Matematica , quindi utilizza solo il collegamento TIOTranspose .

— ngenisis
fonte
2

SOGL V0.12 , 9 byte

I{ _WH╥?O

Provalo qui!
Accetta l'input come una matrice di matrici di stringhe (caratteri).

Spiegazione:

I          rotate the array clockwise
 {         for each element
   _       push "_"
    W      get its index in the array (0 if not found, 1 if its the ground, >1 if its what we need)
     H     decrease that
      ╥    palindromize (duplicates the number, if it's <0, then errors and pushes 0, if =0, pushes 0, if >0, then pushes the number palindromized (always truthy))
       ?   if that, then
        T  output in a new line the original decreased index
— dzaima
fonte
2

JavaScript (ES6), 108 104 88 byte

Risparmiato 16 byte grazie a @JustinMariner

i=>i.map((s,h)=>{while(t=r.exec(s))m[t.index]=i.length-h-1},m=[],r=/_/g)&&m.filter(e=>e)

Input preso come una matrice di stringhe

let input = [
'  _',
' | |           _',
' | |  _   _   | |',
' | | | | | |  | |     _',
'_| |_| |_| |__| |____| |_'
]

let anonymousFunction =
i=>i.map((s,h)=>{while(t=r.exec(s))m[t.index]=i.length-h-1},m=[],r=/_/g)&&m.filter(e=>e)

console.log(anonymousFunction(input))
Espandi frammento

— alexanderbird
fonte
88 byte qui
— Justin Mariner il
Grazie @JustinMariner! Sono entusiasta dell'inizializzazione variabile come parametri inutilizzati dati Array.map, è un bel trucco.
— alexanderbird,
Hai davvero bisogno di assegnare RegEx a una variabile? È possibile utilizzarlo direttamente in exece salvare alcuni byte.
— Shaggy,
In realtà, è necessario: il ciclo while scorre su ogni corrispondenza su una riga e senza lo stato interno della regex nella variabile corrisponderebbe ogni volta al primo evento e si ripeterà all'infinito. Ogni iterazione creerebbe un nuovo regex in modo execche corrisponda al primo. In realtà arresta in modo anomalo l'editor dello snippet di scambio di stack se si incorpora il regex. A meno che non mi manchi qualcosa?
— alexanderbird,
@shaggy Ho dimenticato di taggarti nel mio ultimo commento
— alexanderbird,
2

CJam, 15 14 byte

1 byte salvato grazie a @BusinessCat

{W%z'_f#{0>},}

Questo è un blocco che accetta una matrice di stringhe nello stack e genera una matrice.

Spiegazione:

W%    e# Reverse
z     e# Zip
'_f#  e# Get the index of '_' in each element (-1 if not found)
{0>}, e# Filter where positive
— Esolanging Fruit
fonte
È possibile salvare 1 byte invertendo l'intero array prima della trasposizione.
— Business Cat,
1

Pip , 18 17 byte

15 byte di codice, +2 per i -rpflag.

_FI_@?'_MRVgZDs

Riceve input dallo stdin. Provalo online!

Spiegazione

                 g is list of lines from stdin (-r flag); s is space
         RVg     Reverse g
            ZDs  Zip (transpose), filling gaps with a default char of space
        M        Map this function:
   _@?'_          Index of _ in each line (or nil if it doesn't appear)
_FI              Filter, keeping only the truthy (nonzero, non-nil) values
                 Autoprint in repr format (-p flag)
— DLosc
fonte
1

Pyth , 19 15 14 byte

f>T0mx_d\_.tQd

Provalo online!L'input è un elenco di righe.

spiegazioni

          .tQd     # Transpose, pad with spaces
    mx_d\_         # For each line, reverse it, find the position of "_" (-1 if not found)
f>T0               # Filter on positions greater than zero
— Jim
fonte
1

Perl 6 , 65 byte

{m:ex/^^(\N+)_([\N*\n]+:)/.sort(*[0].chars).map(+*[1].comb("
"))}

Provalo online!

  • m:exhaustive/^^(\N+)_([\N*\n]+:)/cerca la stringa di input per tutti i caratteri di sottolineatura e restituisce un oggetto di corrispondenza per ciascuno, in cui le prime parentesi di cattura contengono la parte precedente della riga su cui si trova il carattere di sottolineatura e le seconde parentesi di cattura contengono l'intero resto della stringa. Il resto della stringa deve contenere almeno una nuova riga, quindi non contiamo i caratteri di sottolineatura a livello del suolo. La :exhaustivebandiera consente a queste partite di sovrapporsi.
  • .sort(*[0].chars)ordina questi oggetti corrispondenti in base al numero di caratteri nella parte della riga che precede ciascun carattere di sottolineatura. Questo li ordina da sinistra a destra.
  • .map(+*[1].comb("\n"))associa ciascun oggetto corrispondente al numero di caratteri di nuova riga nella parte della stringa di input che segue ciascun carattere di sottolineatura, ovvero l'altezza. Il \nè un personaggio vero e proprio ritorno a capo, risparmiando un byte.
— Sean
fonte
0

PHP, 119 byte

function($s){$r=array_map(null,...$s);foreach($r as$k=>&$v)if($v=array_count_values($v)['|'])echo($v+$r[$k+2]=0)." ";};

Analizziamolo! Il nostro input qui è un array 2D di caratteri.

$r=array_map(null,...$s) // Neat little snippet to transpose the array

foreach($r as$k=>&$v)    // Loop through the array, grabbing each row of our 2D array 
(which is now each column of the monolith)

if($v=array_count_values($v)['|']) // Count the number of '|' characters in the column 
(which is the height of our monolith), and if it's greater than 0 (truthy in PHP)...

echo($v+$r[$k+2]=0)." "; // Output that number, and simultaneously set the row 2 indices
                            down to null (to remove duplicate values)
— Xanderhall
fonte
-1

Accetta una stringa multilinea. Il credito per l'installazione (intestazione e piè di pagina) va a @GarethPW

Python 2 , 29 byte

lambda s:len(s.split('\n'))-1

Provalo online!

Questo semplicemente dividerà l'array per newline e restituirà length-1.

— emtree
fonte
Questo non soddisfa l'intera sfida. È necessario restituire un array o un elenco con tutte le altezze, non solo il più alto.
— Scott Milner,
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.