X segna il punto

18

X Segna il punto

Il tuo obiettivo è quello di aggiungere un mirino attorno alla X maiuscola:

Esempio di input / output

Ingresso: 

                mdhyyyyyyyhhhddmmm                
            mdyyssoo  oooosyyyhhhdmm              
          hsso     oossoooooyyhhdhhdmmm           
        yoooooo     oo ssysssyhhdyyyhmmmm         
      myso oso  o  oyo    hhhdhhyhyhhm mm m       
     mhsyhhys  oss      yyyhhhsosyhhmmmmdmmm
    mhyhhhy y         ssyhoho o shhdmmmmdmmmm        
    hhyyyh   s   oo syysyyhhdysso oyhdhhhmmmmm     
   dhysyys      sdysoXoyyyyhhso     syshm  mmm    
   hhyhyo       o      osss y   shhyyhd mmmmmm    
   yyhyyyss           o  oyyyydmmdmmmmmmmmm mm    
   ysyhyhhho   s     osy  sdm m  mddmmddhydmmm   
   h  oshhhyyyddhoo  ooyysshdmdohdmmdmddsshmmm    
    y   oyhhhdhhsyhsssshdddsss    hdddyyyhddm     
    dyyshyyhssyyhyyyyddhhmmdmmmdy syssoosyhdm     
     hsyyhhhhsoo sooyyhhdoohdhhyhyysoo  osdm      
      doyhhhyyyyhhhysyyy oossyyssso   osydm       
        soyhyyhhhhhhyhyyyooos       ohdddm        
         msoyyyyyyyhyyyyo ooo       syyd          
            ho oyyysooo    osso   osyd            
               dhyyysssyyyyyysoosdm               
                    mmdddddmmm

Produzione:

                mdhyyyyyyyhhhddmmm                
            mdyyssoo  oooosyyyhhhdmm              
          hsso     oossoooooyyhhdhhdmmm           
        yoooooo     oo ssysssyhhdyyyhmmmm         
      myso oso  o  oyo    hhhdhhyhyhhm mm m       
     mhsyhhys  oss   |  yyyhhhsosyhhmmmmdmmm
    mhyhhhy y        |ssyhoho o shhdmmmmdmmmm        
    hhyyyh   s   oo s|ysyyhhdysso oyhdhhhmmmmm     
   dhysyys      -----X-----hhso     syshm  mmm    
   hhyhyo       o    | osss y   shhyyhd mmmmmm    
   yyhyyyss          |o  oyyyydmmdmmmmmmmmm mm    
   ysyhyhhho   s     |sy  sdm m  mddmmddhydmmm   
   h  oshhhyyyddhoo  ooyysshdmdohdmmdmddsshmmm    
    y   oyhhhdhhsyhsssshdddsss    hdddyyyhddm     
    dyyshyyhssyyhyyyyddhhmmdmmmdy syssoosyhdm     
     hsyyhhhhsoo sooyyhhdoohdhhyhyysoo  osdm      
      doyhhhyyyyhhhysyyy oossyyssso   osydm       
        soyhyyhhhhhhyhyyyooos       ohdddm        
         msoyyyyyyyhyyyyo ooo       syyd          
            ho oyyysooo    osso   osyd            
               dhyyysssyyyyyysoosdm               
                    mmdddddmmm

Ingresso:

000000000000
000000000000
0000X0000000
0000000X0000
000000000000
000000000000
000000000000
000000000000
000000000000
000000000000
000000000000
000000000000

Produzione:

     |
 0000|00|0000
 0000|00|0000
-----X--+--00
 00--+--X-----
 0000|00|0000
 0000|00|0000
 0000000|0000
 000000000000
 000000000000
 000000000000
 000000000000
 000000000000

Ingresso:

00000000000000000
00000000000000000
00000000000000000
00000X000X0000000
00000000000000000
00000000000000000
00000000000000000
00000000000000000
00000000000000000
00000000000000000
00000000000000000
00000000000000000

Produzione:

00000|000|0000000
00000|000|0000000
00000|000|0000000
----+#+++#+----00
00000|000|0000000
00000|000|0000000
00000|000|0000000
00000000000000000
00000000000000000
00000000000000000
00000000000000000
00000000000000000

Crosshair

Il mirino dovrebbe essere alto 3 e largo 5:

     |
     |
     |
-----X-----
     |
     |
     |

Ingresso

L'input avrà una dimensione di almeno 12x12 caratteri e sarà composto solo da caratteri ASCII. Può essere accettato tramite STDIN o argomento della funzione. L'input non conterrà sempre una X. L'input avrà qualsiasi forma e avrà una quantità arbitraria di spazi bianchi. L'ingresso non conterrà alcuna di: +, -,# , e|

Produzione

L'output può essere tramite STDOUT o il valore restituito di una funzione. L'output dovrebbe essere l'immagine di input con il mirino disegnato. Se non c'è abbastanza spazio per disegnare il mirino, è necessario aggiungere linee / spazi per disegnarlo. I punti sovrapposti devono essere sostituiti con a +. Se il |o -del mirino si sovrappone a X, anziché a +, #dovrebbe apparire un.

Gli spazi bianchi finali non sono consentiti ad eccezione di una nuova riga alla fine.

Questo è code-golf, quindi vince il codice più breve in byte!

code-golf  ascii-art 
— Downgoat
fonte
1
1. se l'input è un argomento, deve essere una stringa con linee separate da newline o può essere una matrice di stringhe? 2. è accettabile aggiungere spazi bianchi attorno al disegno anche se non necessario (cioè aggiungere sempre 3 righe sopra / sotto e 5 colonne a sinistra / destra)? 3. L'ingresso è mancante per il 3o caso di prova.
— Level River St
@steveverrill 1. Sarà una stringa separata da nuova riga, non una matrice di stringhe 2. No, non è consentito. Puoi usarlo nel tuo codice ma non dovrebbe apparire nell'output
— Downgoat
3
La +sovrapposizione si applica -e si |applica solo quando quei personaggi fanno parte del mirino o influisce letteralmente -e si |trova anche nell'input?
— DLosc
1
@DLosc quelli non saranno nell'input. Ho aggiornato la domanda
— Downgoat
1
Cosa succede se un valore letterale #nell'input viene rilevato da un mirino? Verrà sovrascritto?
— Kodos Johnson,

Risposte:

3

CoffeeScript, 345 336   327 byte

Z=(s,c)->s in'X#'&&'#'||s in'-|+'&&'+'||c
X=(s)->l=u=0;o=(r.split ''for r in s.split '\n');c in'X#'&&(i-x&&(o[y][i]=Z o[y][i],'-';i<l&&l=i)for i in[x-5..x+5];i-y&&((o[i]?=[])[x]=Z o[i][x],'|';i<u&&u=i)for i in[y-3..y+3])for c,x in r for r,y in o;((o[y][x]||' 'for x in[l...o[y].length]).join ''for y in[u...o.length]).join '\n'

X è la funzione da chiamare.

Ha spiegato:

# get new char. s - old char. c - '|' or '-'
Z=(s,c)->s in'X#'&&'#'||s in'-|+'&&'+'||c

X=(s)->

  # leftmost and upmost positions
  l=u=0

  # split input into 2D array
  o=(r.split ''for r in s.split '\n')

  # for every 'X' or '#'
  c in'X#'&&(

    # for positions to left and right
    i-x&&(

        # draw horisontal line
      o[y][i]=Z o[y][i],'-'

      # update leftmost position
      i<l&&l=i

    )for i in[x-5..x+5]

    # for positions above and below
    i-y&&(

      # add row if necessary and draw vertical line
      (o[i]?=[])[x]=Z o[i][x],'|'

      # update upmost position
      i<u&&u=i

    )for i in[y-3..y+3]

  )for c,x in r for r,y in o

  # concatenate into string, replacing empty chars with spaces
  ((o[y][x]||' 'for x in[l...o[y].length]).join ''for y in[u...o.length]).join '\n'

eseguibile:

Mostra snippet di codice

— Metalim
fonte
1
345 è troppo bello! Sto cercando di avvicinarmi, ma finora sei molto avanti! Non so se posso fare molto di più senza cambiare completamente il mio approccio ... Hmm :)
— Dom Hastings
Fino a quando qualcuno non arriva con CJam / Pyth / GolfScript e fa sub-100. Ma grazie.
— metalim,
Hah ... Troppo vero ... Mi chiedo se questo dovrebbe essere l'incoraggiamento di cui ho bisogno per imparare Pyth ...
— Dom Hastings
4

Python 3, 577 519 515 490 475 467 454 byte

def c(g,d):
 R,L,V,e,b=range,list,len,'-|+','#';t,g=(lambda g,d:sum([[(i,j)for j in R(V(L(g.split('\n')[i])))if g.split('\n')[i][j]==d]for i in R(V(g.split('\n')))],[]))(g,d),[L(i)for i in g.split('\n')]
 for a,r in t:
  for j in R(a-3,a+4):
   if V(g)>j>-1:n=g[j][r];g[j][r]='+'if n in e else'#'if n in(d,b)else'|'
  for j in R(r-5,r+6):
   if V(g[a])>j>-1:n=g[a][j];g[a][j]='+'if n in e else'#'if n in(d,b)else'-'
 return'\n'.join(''.join(l)for l in g)

Non sono sicuro di quanto più posso giocare a golf.

Uso:

c(g, d)

Dov'è gla griglia di input ed dè il carattere di marcatura a mirino.

— Zach Gates
fonte
3

Perl, 370 byte

sub r{$h=pop;($=[$n=pop].=$"x(1+"@_"-length$=[$n]))=~s!(.{@_})(.)!"$1".($2=~/[-|+]/?'+':$2=~/[X#]/?'#':$h)!e}map{chop;push@c,[$-,pos]while/X/g;$-++}@==<>;($x,$y)=@$_,3-$x>$a?$a=3-$x:0,$x+5-@=>$b?$b=$x+5-@=:0,6-$y>$c?$c=6-$y:0 for@c;@==($",@=)for 1..$a;$_=$"x$c.$_ for@=;map{($x,$y)=@$_;$_&&r$y+$c+$_-1,$x+$a,'-'for-5..5;$_&&r$y+$c-1,$x+$_+$a,'|'for-3..3}@c;print@=,$,=$/

Utilizzo, salva sopra come xmarks.pl:

perl xmarks.pl <<< 'X'

Non sono sicuro di quanto più piccolo posso farlo, ma sono sicuro che ci tornerò più tardi! Potrei pubblicare una spiegazione se anche qualcuno fosse interessato.

Gestisce anche input di input Xe non quadrati.

— Dom Hastings
fonte
2

Python 2, 755 706 699 694 678 626 byte

Prevede input su stdin, con una nuova riga finale. La fine dell'input viene attivata con cmd+d.

import sys;a=sys.stdin.readlines();b=max;c=len;d=enumerate;e=c(b(a,key=lambda x:c(x)))-1;a=[list(line.replace('\n','').ljust(e))for line in a];R=range;f=lambda:[[i for i,x in d(h)if x=='X']for h in a+[[]]*4];q=lambda y,z:'#'if z=='X'else'+'if z in'|-+'else y;g=f();h=j=k=l=0
for m,n in d(g):
 if n:h=b(3-m,h);l=b(abs(n[0]-5),l);j=b(m-c(a)+4,j);k=b(n[-1]-e+6,k)
o=[' ']*(l+k+e);a=[o for _ in R(h)]+[[' ']*l+p+[' ']*k for p in a]+[o for _ in R(j)];g=f()
for m,x in d(a):
 for i in[3,2,1,-1,-2,-3]:
    for r in g[m+i]:x[r]=q('|',x[r])
 for r in g[m]:
    for i in R(5,0,-1)+R(-1,-6,-1):x[r+i]=q('-',x[r+i])
for s in a:print''.join(s)

Programma completo:

import sys

lines = sys.stdin.readlines()

# pad all lines with spaces on the right
maxLength = len(max(lines, key=lambda x:len(x))) - 1 # Subtract the newline
lines = [list(line.replace('\n', '').ljust(maxLength)) for line in lines]


def findX():
    global xs
    xs = [[i for i, ltr in enumerate(line) if ltr == 'X'] for line in lines+[[]]*4]

# add sufficient padding to the edges to prevent wrap
findX()
top,bottom,right,left=0,0,0,0
for ind, item in enumerate(xs):
    if item:
        top = max(3-ind, top)
        left = max(abs(item[0]-5), left)
        bottom = max(ind-len(lines)+4, bottom)
        right = max(item[-1]-maxLength+6, right)
clear = [' '] * (left+right+maxLength)
lines = [clear for _ in range(top)] + [[' ']*left + line + [' ']*right for line in lines] + [clear for _ in range(bottom)]



findX()
def chooseChar(expected, curr):
    return '#' if curr == 'X' else ('+' if curr in '|-+' else expected)

for ind, x in enumerate(lines):
    # try:
        for i in [3, 2, 1, -1, -2, -3]:
            for elem in xs[ind+i]:
                x[elem] = chooseChar('|', x[elem])
        for elem in xs[ind]:
            for i in [5, 4, 3, 2, 1, -1, -2, -3, -4, -5]:
                x[elem+i] = chooseChar('-', x[elem+i])
    # except:f



for line in lines: print(''.join(line))

Sono sicuro che si potrebbe fare molto più golf su questo (dal momento che sto ancora imparando Python), quindi ogni aiuto è apprezzato.

Le modifiche

  1. Rasato a circa 50 byte findXda usando per la comprensione
  2. Salvato 7 byte grazie al suggerimento di @ mbomb007 sull'uso rangeinvece di un array letterale
  3. Rimossi 5 byte cambiando findX in lambda
  4. Salvato 15 byte estendendo xsdi 4 ed eliminando iltry-except blocco
  5. Altri 2 rasati usando le schede anziché gli spazi
  6. Rimossi 5 byte usando h=i=j=k=l=0invece dih,j,k,l=0,0,0,0
  7. Grazie a @ mbomb007, ho rimosso circa 40 byte in più da chooseChar
— J Atkin
fonte
1
È necessario definire R=rangeper ridurre gli intervalli. Quindi puoi anche cambiare for i in[5,4,3,2,1,-1,-2,-3,-4,-5]:infor i in R(5,0,-1)+R(-1,-6,-1):
— mbomb007 il
Grazie! Ci avevo pensato, ma sembrava che sarebbe stato più lungo.
— J Atkin,
Ottimo lavoro per tagliare! Non sono sicuro che tu abbia visto i thread dei suggerimenti, ma potrebbero esserci alcuni accorciatori che puoi ottenere da qui: codegolf.stackexchange.com/questions/54/…
— Dom Hastings,
L'ho fatto qualche giorno fa, ma mi sono dimenticato di alcune cose.
— J Atkin,
Inoltre, la tua qlambda mi sembra molto inefficiente. Può essere abbreviato? Per lo meno, non penso che le parentesi siano necessarie, ma penso che anche la logica booleana e il confronto delle stringhe possano essere abbreviati.
— mbomb007,
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.