Le cifre a 7 segmenti possono essere rappresentate in ASCII usando _|caratteri. Ecco le 1cifre delle dimensioni :

   _  _       _   _   _   _   _   _ 
|  _| _| |_| |_  |_    | |_| |_| | |
| |_  _|   |  _| |_|   | |_|  _| |_|

Le dimensioni più grandi si formano rendendo ogni segmento proporzionalmente più lungo. Ecco una coppia di 3 cifre.

 ___    ___    ___    ___    ___    ___    ___ 
|   |  |          |  |          |  |   |  |   |
|   |  |          |  |          |  |   |  |   |
|___|  |___       |  |___    ___|  |   |  |___|
|   |  |   |      |      |      |  |   |      |
|   |  |   |      |      |      |  |   |      |
|___|  |___|      |   ___|   ___|  |___|   ___|

Obbiettivo

In questa sfida, devi scrivere un programma / funzione che può prendere una singola cifra come input e identificarne le dimensioni. Il problema: se l'input non è una cifra valida, il tuo programma dovrebbe essere emesso 0.

Questo è code-golf , vince meno byte.

È possibile scrivere un programma o una funzione, che può ricevere la cifra come STDIN o un argomento e stampare / restituire il valore.

Le cifre saranno fornite come una stringa a più righe, imbottita con la minima quantità di spazio bianco finale necessario per renderlo un rettangolo perfetto. La nuova riga finale è una parte facoltativa dell'input. Non ci saranno spazi iniziali non necessari.

Quando viene passata una non cifra, sarà comunque composta da _|caratteri, imbottiti in un rettangolo e non avranno spazi iniziali non necessari. Non ci saranno righe vuote. Non dovrai occuparti di input vuoti.

L'output dovrebbe essere un singolo intero non negativo, con una nuova riga finale facoltativa. Se l'input non è una cifra corretta di qualsiasi dimensione, output 0. Altrimenti, visualizza la dimensione.

Ecco una guida pratica per le larghezze e altezze di ogni cifra per una determinata dimensione N.

Digit  Height  Width (not counting newlines)
1      2N      1
2      2N+1    N+2
3      2N+1    N+1
4      2N      N+2
5      2N+1    N+2
6      2N+1    N+2
7      2N+1    N+1
8      2N+1    N+2
9      2N+1    N+2
0      2N+1    N+2

Esempi di I / O

Nel:

__ 
  |
__|
  |
__|

Su:

2

Nel:

|
|
|

Su:

0  //because it is of an invalid height.  Either 1 char too short or tall.

Nel:

|    |
|    |
|    |
|____|
     |
     |
     |
     |

Su:

4

Nel:

 ___ 
|    
|___ 
|   |
|___|

Su:

0 //1 char too wide

Nel:

 _ 
|_|
| |

Su:

0 //it's not a digit

Nel:

 __ 
|   
|__ 
   |
 __|

Su:

2

Nel:

 _  _ 
 _| _|
|_  _|

Su:

0  //both would be valid individually, but input should be a *single* digit

Nel:

 _ 
|_|
|_|

Su:

1

Nel:

|
|

Su:

1

Nel:

__|_
 |  
 _ |
  _ 
|__ 

Su:

0

Questo è approssimativamente l' inverso del numero Transform in un modello di visualizzazione a 7 segmenti , a partire da 3 anni fa.

Ruby, 250

->x{d=y=0
x.size.downto(0){|n|y=n
a=["|
"*2*n]
"XNRDqpm@A".bytes{|z|p=[?|,' ','']
h=s=""
(n*2).times{|i|
i%n<1&&(d=z>>i/n*3&7)&&h=[?_,' '][d/3%2]*n
s=p[d%3]+h+p[d/6]+"
"+s
h=' '*n}
z!=68&&s=' '*(1-d%3/2)+?_*n+" 
"+s
a<<s};puts a
a.index(x)&&break}
y}

Dato che ci sono così tanti possibili input non validi, l'unico modo per farlo era generare tutte le cifre corrette e verificare se l'input corrisponde.

Costruisco ogni cifra dal basso verso l'alto, in 2 metà più la linea superiore. Sebbene ci siano 12 possibilità (considerando che il segmento sinistro può essere acceso, spento, o nel caso di 3e 7completamente assente) solo 7 sono effettivamente presenti e un'attenta scelta della codifica consente di codificare tutte le informazioni (eccetto la riga superiore) in un personaggio unico.

la cifra 1non si adatta al modello e viene gestita separatamente, utilizzata per inizializzare l'array.

Non registrato nel programma di test

Questa versione utilizza .invece gli spazi per motivi diagnostici.

#Encoding used for half-digits (radix 3,2,2 most significant digit at right)

#000    |_|  0

#100    ._|  1  . = space

#200    X_|  2  X = no space (for digits 3 and 7)  

#010    |.|  3

#110    ..|  4

#210    X.|  5

#001    |_.  6


f=->x{d=y=0                                        #d and y required to be intialized for scoping reasons
  x.size.downto(0){|n|y=n                          #Assume max possible size of character = length of input and iterate down through all possible sizes n   
    a=["|\n"*2*n]                                  #Make an array containing the digit 1 (different shape to others)
    "XNRDqpm@A".bytes{|z|                          #Each character encodes the pattern for a digit. Iterate through them
      p=['|','.','']                               #Possible components for left and right of digit
      h=s=""                                       #h initialized for scoping reasons. s will contain the digit string 
      (n*2).times{|i|                              #For each row
        i%n<1&&                                    #If i%n==1 we are at the bottom of a half digit
        (d=z>>i/n*3&7)&&                           #so extract info from z and store in d
        h=[?_,'.'][d/3%2]*n                        #h is the horizontal part of the half digit, either _ or spaces 
        s=p[d%3]+h+p[d/6]+"\n"+s                   #Build one row of digit, working upwards: left,middle,right
        h='.'*n                                    #If row i%n!=0 (not bottom row of half digit)the middle section must contain spaces
      }                                            #We now have both halves of the digit, only the top segment missing 
      z!=68&&s='.'*(1-d%3/2)+?_*n+".\n"+s          #If z!=68 (digit 4) add a top to the digit, with appropriate leading and trailing spaces        
      a<<s                                         #Add the completed digit of size n to a
    }
    #puts a                                        #Diagnostic: uncomment to print all the strings checked
    a.index(x)&&break                              #If string x is in a, break

  }
y                                                  #and return last value of n 
}


# digit 7, size 2. Trailing newline required. Outputs 2
puts f[
"__.
..|
..|
..|
..|
"]