Implementare un giocatore di golf spazi bianchi

15

Alcuni esolang bidimensionali, come Forked , e alcuni non esolang, come Python , possono talvolta richiedere spazi prima delle righe di codice. Questo non è molto da golf. Inoltre, sono pigro e scrivo una seconda lingua che ha bisogno di molti spazi prima del codice. Il tuo compito è quello di scrivere uno strumento che renda queste lingue più golfistiche.

Certo, questo non sarà perfetto; non può essere utilizzato, ad esempio, quando un numero è il primo carattere su una linea di origine. Tuttavia, sarà generalmente utile.

Sfida

Scriverai un programma o una funzione che o ...

  • ... accetta un argomento, un nome file o una stringa oppure ...
  • ... legge dallo standard input.

Il tuo programma funzionerà come cat, tranne:

  • Se il primo carattere su una riga è un numero, il codice stamperà x spazi, dove x è quel numero.
  • Altrimenti, verrà semplicemente stampato.
  • Come ogni altro personaggio nell'input.

Casi test

Ingresso:

foo bar foo bar
1foo bar foo bar foo bar
2foo bar foo bar foo bar foo bar

Produzione:

foo bar foo bar
 foo bar foo bar foo bar
  foo bar foo bar foo bar foo bar

Ingresso:

--------v
8|
8|
80
8,
7&

Produzione:

--------v
        |
        |
        0
        ,
       &

Ingresso:

foo bar
bar foo
foo bar

Produzione:

foo bar
bar foo
foo bar

Ingresso:

0123456789
1234567890
2345678901
3456789012
4567890123

Produzione:

123456789
 234567890
  345678901
   456789012
    567890123

Regole

  • L'output deve essere esattamente come input, ad eccezione delle righe in cui il primo carattere è un numero.
  • Il tuo programma non può aggiungere / anteporre nulla al file, tranne una nuova riga finale se lo desideri.
  • Il tuo programma potrebbe non fare ipotesi sull'input. Può contenere righe vuote, nessun numero, caratteri Unicode, qualunque cosa.
  • Se un numero con più di una cifra inizia una riga (ad es. 523abcdefg), Solo la prima cifra (nell'esempio, 5) dovrebbe trasformarsi in spazi.

Vincitore

Vince il codice più corto in ogni lingua. Buon divertimento e buona fortuna!

code-golf  number  whitespace 
— MD XF
fonte
— MD XF
6
Of course, this will not be perfect; it cannot be used, for instance, when a number is the first character on a line of source.Non è vero, basta rendere il primo carattere uno 0 (ehm, il tuo ultimo caso di test)
— HyperNeutrino
Possiamo leggere un elenco di stringhe da stdin ( è valido )?
— Riley,

Risposte:

10

Cubicamente , 69 byte

R1B1R3B1~(+50<7?6{+54>7?6{-002+7~?6{(@5*1-1/1)6}}}(-6>7?6&@7+70-4~)6)

Provalo online!

Spiegazione:

Innanzitutto eseguiamo questa inizializzazione:

R1B1R3B1

Per configurare questo cubo:

   533
   004
   000
411223455441
311222331440
311222331440
   555
   555
   200

La cosa più importante di questo cubo è che la faccia si 5somma a 32, che è il valore richiesto per stampare gli spazi. Per coincidenza, sembra anche essere abbastanza breve per tutti gli altri calcoli. Fatto ciò:

~( . . . )                                    Takes the first input, then loops indefinitely

  +50<7?6{+54>7?6{-002+7~?6{(@5*1-1/1)6}}}    Handle leading digit:
  +50<7?6{                               }    If input is greater than 47 ('0' is 48)
          +54>7?6{                      }     And input is less than 58 ('9' is 57)
                                              Then input is a digit
                  -002+7                      Set notepad equal to value of input digit
                        ~                     Take next input (only convenient place for it)
                         ?6{           }      If the notepad isn't 0
                            (        )6       While the notepad isn't 0:
                             @5                 Print a space
                               *1-1/1           Decrement the notepad by one
                                              Leading digit handled

     (-6>7?6&@7+70-4~)6                       Handle rest of line:
     (               )6                       While the notepad isn't 0:
      -6>7?6&                                   Exit if End of Input
             @7                                 Print the next character
               +70-4                            Set notepad to 0 if it was a newline
                    ~                           Take the next character
— Kamil Drakari
fonte
1
Wow, è un buon uso del nidificato ... tutto. +1
— MD XF
6

Buccia , 15 13 byte

-2 byte grazie a @Zgarb

mΓo+?oR' i;±¶

Provalo online!

Utilizza la stessa tecnica di @Jonathan Allan

Spiegazione

             ¶  -- split input into a list of lines
m               -- apply the following function to each line
 Γ              --   deconstruct the string into a head and a tail
  o+            --   prepend to the tail of the string ...
    ?      ±    --     if the head is a digit (n)
     oR' i      --       the string of n spaces
                --     else
          ;     --       the head of the string
                -- implicitly print list of strings line-by-line
— H.PWiz
fonte
2
13 byte con l'uso di Γ.
— Zgarb,
5

JavaScript (ES8), 38 37 byte

a=>a.replace(/^\d/gm,a=>''.padEnd(a))

Non penso che possa essere migliorato molto di più.
Salvato 1 byte grazie a Shaggy - Usa le funzionalità ES8.

" Non credo che possa essere migliorato molto di più. " - Potresti salvare un byte usando ES8 in questo padEndmodo:s=>s.replace(/^\d/gm,m=>"".padEnd(m))
— Shaggy
@Shaggy. Non sapevo già che ES8 fosse autorizzato. Grazie.
1
Se c'è un singolo interprete (cioè un browser) là fuori che supporta una funzione, quella funzione è un gioco equo qui :)
— Shaggy
4

Python 2 , 98 74 67 65 byte

-24 byte grazie a Jonathan Allan. -7 byte grazie a Mr. Xcoder.

for i in open('f'):print' '*int(i[0])+i[1:]if'/'<i[:1]<':'else i,

Provalo online!

Accetta l'input nel file denominato f.

— totallyhuman
fonte
Anche errori quando nessuna cifra nel primo carattere di una riga (quando si utilizza un elenco come modo per scegliere gli elementi, vengono valutati tutti gli elementi)
— Jonathan Allan
— Jonathan Allan l'
87 byte - L'intestazione del collegamento TIO è beffarda open; il codice si aspetta un file chiamato 'f'. Penso che sia OK?
— Jonathan Allan,
Ah, vero ' '*0è falso. L'uso [:1]è comunque un risparmio. Non readho bisogno di crederlo (e lo sarebbe readlines) dal momento che il comportamento predefinito di openè iterare attraverso le righe. Inoltre non è necessario per la modalità poiché 'r'è l'impostazione predefinita. Se ho ragione sono 73 !
— Jonathan Allan,
— Jonathan Allan,
3

05AB1E , 10 byte

v0y¬dićú},

Provalo online!

— Oliver Ni
fonte
1
Come si fa un input con righe vuote?
— Jonathan Allan,
Nessuna idea lol ... Ci penserò su
— Oliver Ni
|vy¬dićú},funziona per 10 byte.
— Riley,
OK, non è possibile inserire una riga vuota, è che il codice non funziona per una riga vuota : se si utilizza un singolo zero funziona, quindi deve essere qualcosa sulla testa inesistente (lo stesso vale per il suggerimento di @ Riley 10 a proposito).
— Jonathan Allan,
@JonathanAllan Ha qualcosa a che fare con il modo in cui |funziona. Dovrebbe push the rest of input as an array with strings, ma si ferma a linee vuote ( TIO ). L'ho menzionato nella chat room 05AB1E se vuoi saperne di più.
— Riley,
2

Gelatina , 19 byte

V⁶ẋ
Ḣǹe?ØD;
ỴÇ€Yḟ0

Un collegamento monadico che cattura e restituisce elenchi di caratteri o un programma completo che stampa il risultato.

Provalo online!

Come?

V⁶ẋ - Link 1, make spaces: character (a digit)
V   - evaluate as Jelly code (get the number the character represents)
 ⁶  - a space character
  ẋ - repeat

Ḣǹe?ØD; - Link 2, process a line: list of characters
Ḣ        - head (get the first character and modify the line)
         -   Note: yields zero for empty lines
     ØD  - digit characters = "0123456789"
    ?    - if:
   e     - ...condition: exists in? (is the head a digit?)
 Ç       - ...then: call the last link as a monad (with the head as an argument)
  ¹      - ...else: identity (do nothing; yields the head)
       ; - concatenate with the beheaded line

ỴÇ€Yḟ0 - Main link: list of characters
Ỵ      - split at newlines
 Ç€    - call the last link (1) as a monad for €ach
   Y   - join with newlines
    ḟ0 - filter out any zeros (the results of empty lines)
— Jonathan Allan
fonte
beheaded lineÈ questo il termine vero? xD
— HyperNeutrino
1
Bene, ora è :)
— Jonathan Allan l'
Ahahaha ho provato a superarti e ho trovato una soluzione sostanzialmente identica alla tua xD
— HyperNeutrino
2

Haskell , 63 byte

unlines.map g.lines
g(x:r)|x<';',x>'/'=(' '<$['1'..x])++r
g s=s

Provalo online! La prima riga è una funzione anonima che divide una determinata stringa in righe, applica la funzione ga ciascuna riga e unisce le righe risultanti con le nuove righe. In gesso viene verificato se il primo carattere xdi una riga è una cifra. In questo caso, ['1'..x]produce una stringa di lunghezza uguale al valore della cifra xe ' '<$converte la stringa in altrettanti spazi. Alla fine rviene aggiunto il resto della linea . Se xnon è una cifra, siamo nella seconda equazione g s=se restituiamo la riga non modificata.

— Laikoni
fonte
2

Python 2 , 76 72 68 byte

-4 byte grazie a @ovs !

@DeadPossum ha suggerito di passare a Python 2, risparmiando anche 4 byte.

Ho pensato che fosse bello avere un programma completo competitivo in Python 2 che non controlla esplicitamente se il primo carattere è una cifra. Questa legge l'input da un file, f.

for i in open('f'):
 try:r=int(i[0])*" "+i[1:]
 except:r=i
 print r,

Provalo online! (per gentile concessione di @ovs )

— Mr. Xcoder
fonte
@ovs Grazie per questo
— Mr. Xcoder
@ovs Cosa hai cambiato (lo farò a mano)? Mi dice che il permalink non può essere decodificato
— Mr. Xcoder
Invece di stampare in ogni iterazione ho assegnato l'output a una variabile e l'ho stampato alla fine.
— Ovs
@ovs Sono riuscito a ottenere 72 byte stampando ogni iterazione, grazie per l'idea variabile!
— Mr. Xcoder
La versione di Python 2 printti darà 68 byte
— Dead Possum
2

Java 8 , 105 99 97 93 byte

Risparmiato qualche altro byte grazie al suggerimento di Nevay,

s->{int i=s.charAt(0);if(i>47&i<58)s=s.substring(1);while(i-->48)s=" "+s;System.out.print(s);}
— CoderCroc
fonte
1
Hai due bug nella tua versione golfata: il controllo delle cifre deve usare e invece di o; Mancano le parentesi dopo il controllo delle cifre. Inoltre puoi salvare alcuni byte usando s->{int i=s.charAt(0);if(i>47&i<58)for(s=s.substring(1);i-->48;s=" "+s);System.out.print(s);}(93 byte).
— Nevay,
@Nevay Hai ragione. Grazie. Aggiornerò la mia risposta.
— CoderCroc
2

R , 138 128 byte

-9 byte grazie a CriminallyVulgar

n=readLines();for(d in grep("^[0-9]",n))n[d]=gsub('^.?',paste0(rep(' ',eval(substr(n[d],1,1))),collapse=''),n[d]);cat(n,sep='
')

Questo è piuttosto male, ma ora è un po 'meglio ... R è, ancora una volta, terribile nelle corde.

Provalo online!

— Giuseppe
fonte
2
Sto commentando per conto di CriminallyVulgar , che suggerisce una versione a 129 byte , ma non ha abbastanza reputazione per commentare.
— Mr. Xcoder,
@ Mr.Xcoder Grazie e @CriminallyVulgar!
— Giuseppe,
123 byte Apparentemente rep può prendere una stringa di un int per il secondo argomento ???
— CriminalmenteVolgar
@CriminallyVulgar huh. è proprio lì nei documenti per rappresentante , ora che li ricontrollo: "altri input sono costretti a un numero intero o doppio vettore".
— Giuseppe,
2

Japt (v2.0a0), 11 10 byte

Japt batte Jelly e 05AB1E? Non sembra giusto!

r/^\d/m_°ç

Provalo

Spiegazione

Immissione implicita della stringa U

r/^\d/m

Usa Regex sostituisci ( r) tutte le occorrenze di una cifra all'inizio di una riga ( mè il flag multilinea - ilg flag è abilitato di default in Japt).

_

Passa ogni partita attraverso una funzione, dove Z trova l'elemento corrente.

°

L'operatore di incremento postfix ( ++). Ciò converte Zin un numero intero senza aumentarlo per l'operazione seguente.

ç

Ripeti un carattere spaziale Z volte.

Emette implicitamente la stringa risultante.

— ispido
fonte
Può m@essere abbreviato?
— Oliver
Non in questo caso, @Oliver; il mecco il flag multi-linea per la regex, non il metodo map.
— Shaggy
1
@Oliver: r/^\d/m_î(o r/^\d/m_ç) sarebbe più corto di 2 byte ma Zè una stringa quindi, sfortunatamente, non funzionerebbe. r/^\d/m_°ç, Per un risparmio di 1 byte, fa il lavoro, però :)
— Shaggy
°çè un trucco di incredibile :-) avrei suggerito solo \dper la regex, ma che lascia fuori la bandiera ... forse dovrei aggiungere il supporto per le bandiere a regex singola classe, come \dm(oh sì, e che lascia fuori il ^troppo ...)
— ETHproductions
@ETHproductions, sarebbe possibile / possibile rendere l'apertura /facoltativa in RegExes?
— Shaggy,
1

Gelatina , 19 byte

Ḣ⁶ẋ;µ¹µḣ1ẇØDµ?
ỴÇ€Y

Provalo online!

-5 byte in totale grazie ai commenti di Jonathan Allan e guardando il suo post

Spiegazione

Ḣ⁶ẋ;µ¹µḣ1ẇØDµ?  Main link
             ?  Ternary if
                if:
       ḣ1       the first 1 element(s) (`Head` would modify the list which is not wanted)
         ẇ      is a sublist of (essentially "is an element of")
          ØD    "0123456789"
                then:
  ẋ             repeat
 ⁶              ' '
Ḣ               n times where n is the first character of the line (head)
   ;            concatenate the "beheaded" string (wording choice credited to Jonathan Allan)
                else:
     ¹          Identity (do nothing)
    µ µ     µ   Link separators
ỴÇ€Y            Executed Link
Ỵ               Split by newlines
  €             For each element,
 Ç              call the last link on it
   Y            Join by newlines
— HyperNeutrino
fonte
non c'è bisogno di scambiare argomenti:Ḣ⁶ẋ;
— Jonathan Allan
Il trucco pop quindi head non funzionerà se esiste una riga contenente solo un carattere a una sola cifra :( - ;0Ḣfunzionerebbe per un byte, forse c'è un singolo atomo, ho anche provato ¹, nessuna gioia lì
— Jonathan Allan
1
@JonathanAllan Ah, giusto. Grazie. ḣ1ẇØDfunziona per lo stesso bytecount \ o /
— HyperNeutrino
ṚṪfunzionerà :)
— Jonathan Allan l'
@JonathanAllan Funziona troppo :) Ma ho già fatto una spiegazione per il mio metodo, quindi sono troppo pigro per cambiarlo: P Ma grazie comunque :)
— HyperNeutrino
1

Pyth ,  16  15 byte

jm.x+*;shdtdd.z

Provalo online!

Spiegazione

jm.x + *; shdtdd.z - Programma completo che funziona leggendo tutto da STDIN.

             .z: leggi tutto STDIN e suddividilo per avanzamenti di riga.
 m - Mappa con una variabile d.
  .x - Prova:
     *; shd - Per convertire il primo carattere in un numero intero e moltiplicarlo per uno spazio.
    + td - E aggiungi tutto tranne il primo carattere
            d - Se quanto sopra fallisce, basta aggiungere l'intera stringa.
j - Partecipa per newline.

Facciamo un esempio che dovrebbe essere più semplice da elaborare. Supponiamo che il nostro input sia:

foo bar foo bar
1foo bar foo bar foo bar
2foo bar foo bar foo bar foo bar

Il programma sopra farà quanto segue:

  • .z- Legge tutto e lo divide per newline, quindi otteniamo ['foo bar foo bar', '1foo bar foo bar foo bar', '2foo bar foo bar foo bar foo bar'].

  • Otteniamo il primo carattere di ogni: ['f', '1', '2'].

  • Se è convertibile in un numero intero, ripetiamo uno spazio di volte intero e aggiungiamo il resto della stringa. Altrimenti, posizioniamo semplicemente l'intera stringa. Quindi, abbiamo ['foo bar foo bar', ' foo bar foo bar foo bar', ' foo bar foo bar foo bar foo bar'].

  • Infine, ci uniamo a nuove linee, quindi il nostro risultato è:

    foo bar foo bar
 foo bar foo bar foo bar
  foo bar foo bar foo bar foo bar
— Mr. Xcoder
fonte
1
Haha, abbiamo battuto Jelly :)
— Mr. Xcoder
1

Cubicamente , 82 byte

R3D1R1D1+0(?6{?7@7~:1+2<7?6{+35>7?6{:7-120?6{(B3@5B1-0)6}:0}}}?6!@7~-60=7&6+4-3=7)

Nota: questo non funzionerà su TIO . Per verificarlo, usa l' interprete Lua con il flag sperimentale impostato su true (per abilitare i condizionali). Attualmente c'è un bug con blocchi condizionali sull'interprete TIO. Quando si utilizza l'interprete TIO, è necessario sostituire ?6!con !6e &6con ?6&, che mantiene il conteggio dei byte uguale.

R3D1R1D1          Set the cube so that face 0 has value 1 and the rest of the values are easy to calculate

+0                Set the notepad to 1 so that it enters the conditional below
(                 Do
  ?6{               If the notepad is 1 (last character was \n or start of input)
    ?7@7              Output the current character if it's \n
    ~                 Get the next character
    :1+2<7?6{         If the input is >= '0'
      +35>7?6{          If the input is <= '9'
        :7-120            Set the notepad to the input - '0'
        ?6{               If the notepad isn't 0
          (                 Do
            B3@5              Output a space
            B1-0              Subtract 1 from notepad
          )6                While notepad > 0
        }                 End if
        :0              Set notepad to 1
      }                 End if
    }                 End if
  }                 End if

  ?6!@7             If the notepad is 0 (did not attempt to print spaces), print current character

  ~                 Get next character
  -60=7&6           If there is no more input, exit the program
  +4-3=7            Check if current character is \n, setting notepad to result
)                 Repeat forever

Questa non è breve come l'altra risposta cubica, ma ho pensato di provarlo comunque: D

— TehPers
fonte
Cosa succede con i loop nell'interprete TIO?
— MD XF,
@MDXF )passa al più recente (anziché a quello corrispondente credo. EDIT: sono in chat.
— TehPers
@MDXF Forse erano i blocchi condizionali, in realtà. Ho dimenticato, aggiornerò la risposta. Indipendentemente da ciò, non stavano combaciando.
— TehPers,
1
Bene, lo vedrò più tardi. Attualmente sto finendo Cubically 2.
— MD XF
@MDXF Questo è ... davvero emozionante ascoltare effettivamente o_O
— TehPers
1

> <> , 60 byte

!^i:0(?;::"/")$":"(*0$.
v"0"-
>:?!v1-" "o
;>:o>a=&10&?.i:0(?

Provalo online!

Come funziona:

..i:0(?;... Gets input and ends if it is EOF
...
...
...

.^......::"/")$":"(*0$. If the inputted character is a digit go to the second line
...                     Else go to the fourth
...
...

....        If it was a digit
v"0"-       Subtract the character "0" from it to turn it into the corresponding integer
>:?!v1-" "o And print that many spaces before rejoining the fourth line
...

.^..               On the fourth line,
....               Copy and print the input (skip this if it was a digit)
....v              If the input is a newline, go back to the first line.
;>:o>a=&10&?.i:0(? Else get the input, ending on EOF
— Jo King
fonte
0

V , 9 byte

ç^ä/x@"é

Provalo online!

Spiegazione

ç  /      ' On lines matching
 ^ä       ' (Start)(digit)
    x     ' Delete the first character
     @"   ' (Copy Register) number of times
       é  ' Insert a space
— nmjcman101
fonte
0

Gema, 21 personaggi

\N<D1>=@repeat{$1;\ }

Esecuzione di esempio:

bash-4.4$ gema '\N<D1>=@repeat{$1;\ }' <<< 'foo bar foo bar
> 1foo bar foo bar foo bar
> 2foo bar foo bar foo bar foo bar
> 
> --------v
> 8|
> 8|
> 80
> 8,
> 7&'
foo bar foo bar
 foo bar foo bar foo bar
  foo bar foo bar foo bar foo bar

--------v
        |
        |
        0
        ,
       &
— uomo al lavoro
fonte
0

PHP, 83 caratteri

preg_replace_callback('/^\d/m',function($m){return str_repeat(' ',$m[0]);},$argv);
— Petah
fonte
Penso che il tuo codice non sia conforme alle regole di input di questa sfida, dovresti racchiuderlo in una funzione con un $s arg o popolarlo con l'input. E non stampa nulla
— LP154
@ LP154 sta usando argvaccettabile?
— Petah,
@Petah Se ho ragione nel dare per scontato che argvla riga di comando è args, allora sì.
— totalmente umano il
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.