Напишіть програму, яка містить непорожній рядок цифр від 0 до 9 і друкує, як вони відображалися б на семисегментному дисплеї за допомогою косої риски ( /, \).

Це точні цифри цифр:

/\  
\ \
 \/

 \
  \


/\
 /
 \/

/\
 /\
  /

 \
\/\

/
\/\
  /

/
\/\
 \/

/\
  \

/\
\/\
 \/

/\
\/\
  /

Коли одна цифра виникає за іншою, вони прикуті діагонально вгору та праворуч, з діагональним проміжком між ними. Так, наприклад, 203це стане:

    /\
     /\
  /\  /
  \ \
/\ \/
 / 
 \/

Зауважте, що 1персонаж займає таку ж кількість місця, що й інші. Два рядки 1екрана знаходяться в правій частині дисплея, а не лівій.

Так 159114би стало це:

           \
          \/\
         \
          \
       \
        \
    /\
    \/\
  /   /
  \/\
 \  /
  \

У виході може бути будь-яка кількість та комбінація провідних / зворотних нових рядків або пробілів, якщо цифри знаходяться у правильному положенні відносно один одного.

Отже 159114, це також було б дійсним:

          \        
         \/\     
        \
         \
      \    
       \          
   /\     
   \/\
 /   /
 \/\         
\  /
 \    

Візьміть вхід з stdin або командного рядка або напишіть функцію, яка бере в рядку. Виведіть результат у stdout або можете повернути його як рядок, якщо ви пишете функцію.

Будь-яка непорожній рядок з цифр від 0 до 9 повинна працювати, в тому числі окремих цифр рядків (наприклад 8) і рядки з провідними нулями (наприклад, 007нулі цього повинні бути надруковані).

Виграє найкоротший код у байтах.

CJam, 77 71 70 69 63 62 байт

r_,5*_Sa*a*\{~"÷Ðëúܾ¿ðÿþ"=i2bS"\/"4*W<+.*3/..e>2fm>2m>}/Wf%N*

Усі символи для друку, тому копіювання та вставка повинні працювати чудово.

Спробуйте його в Інтернеті в інтерпретаторі CJam .

Ідея

Почнемо з вивчення кількості цифр n на вході та висунення квадрата пробілів, достатнього для покриття результатів. У реалізації цей квадрат буде закодований як двовимірний масив односимвольних рядків.

Квадрат довжиною 2n + 1 був би абсолютно правильним (тобто немає навколишнього пробілу) для прямої реалізації, але ми будемо використовувати один довжиною 5n, щоб зберегти пару байтів. На щастя, навколишній пробіл дозволений.

Якщо ми перевернемо рядки семи похилих зображень 8 , отримаємо таке:

 \/
\/\
/\

Представлення всіх цифр може бути кодоване як 8-бітове ціле число, де i- ^й біт дорівнює 0, якщо i- ^й символ повинен бути замінений пробілом. Для цифр від 0 до 9 отримані цілі числа

247 208 235 250 220 190 191 240 255 254

які відповідають наступним символам ISO-8559-1:

÷Ðëúܾ¿ðÿþ

Для кожної цифри на вході, після вибору відповідного 8-бітного цілого числа, ми повторюємо i- ^й символ подання 8 рівно a _i разів, де a _i - i- ^й біт цілого числа. Це висуває масив рядків або одного, або нульового символів. Розбивши цей масив на шматки довжиною 3, ми отримуємо масив, де кожному елементу відповідає рядок подання.

Тепер ми обчислюємо векторний максимум рядків, що представляють квадрат, і рядки, які представляють цифру. Рядки /і \більше, ніж рядок  , тому вони замінять пробіли в квадраті. Однак порожній рядок менший, ніж рядок  , тому порожні рядки в цифровому зображенні збережуть пробіли у квадраті.

Тепер обертаємо рядки та стовпці на дві одиниці, щоб розмістити наступне цифрне представлення у потрібній частині квадрата та повторити процес для решти цифр у введенні.

Нарешті, перевертаємо кожен ряд і вставляємо між окремими рядками підводку рядків.

Код

r_,      e# Read a token from STDIN and push the length of a copy.
5*_      e# Multiply the length by 5 and push a copy.
Sa*      e# Repeat the array [" "] that many times.
a*       e# Repeat the array [[" " ... " "]] that many times.
\{       e# For each character C in the input:
  ~      e#   Push eval(C), i.e., the digit the character represents.

  "÷Ðëúܾ¿ðÿþ"

         e#   Push the encodings of all 10 seven slash representations.

  =      e#   Select the proper one.
  i2b    e#   Push the resulting characters code point in base 2, i.e., its bits.
  S      e#   Push " ".
  "\/"4* e#   Push "\/\/\/\/".
  +W<    e#   Concatenate and eliminate the last character.
  .*     e#   Vectorized repetition.

         e#   For the digit 5, e.g., we have [1 0 1 1 1 1 1 0] and  " \/\/\/\" on
         e#   the stack, so .* yields [" " "" "/" "\" "/" "\" "/" ""].

  3/     e#   Divide the representation into chunks of length 3, i.e., its lines.
  ..e>   e#   Compute the twofold vectorized maximum, as explained above.
  2fm>   e#   Rotate each line to characters to the right.
  2m>    e#   Rotate the lines two units down.
}/
Wf%      e# Reverse each line.
N*       e# Place linefeeds between them.

Останні обертання зіпсують вихід, якщо довжина сторони квадрата буде меншою за 2n + 3 . Оскільки 5n ≥ 2n + 3 для всіх натуральних чисел n , площа є достатньо великою, щоб не допустити цього.

Python 3, 189 183 174 байт

s="a%sa"%input()
while s[1:]:b,a,c,d,e,f,g=[c*(ord(n)>>int(s[~(n>"Ͱ")],16)&1)or" "for c,n in zip("\/"*4,"ΟϭŅͭͱͼϻ")];S=len(s)*"  ";print(S+a+b,c+d+"\n"+S+e+f+g);*s,_=s

Стиснення здається мені нормальним, але у мене виникають труднощі при розробці хорошого способу виривання семи змінних ...

На щастя, специфікація досить розслаблена за правилами пробілу, тому що є багато провідних / кінцевих пробілів.

Розширено:

s="a%sa"%input()
while s[1:]:
  b,a,c,d,e,f,g=[c*(ord(n)>>int(s[~(n>"Ͱ")],16)&1)or" "
                 for c,n in zip("\/"*4,"ΟϭŅͭͱͼϻ")]
  S=len(s)*"  "
  print(S+a+b,c+d+"\n"+S+e+f+g)
  *s,_=s

Пояснення

Позиції сегмента, представлені змінними, є:

    ab               /\
    efg               /\
  ab cd            /\  /
  efg              \ \
ab cd            /\ \/
efg               /
 cd               \/

Кожен сегмент кодується одним двобайтовим символом Unicode. Наприклад, ϻкодує gсегмент так:

bin(ord("ϻ")) = bin(1019) = "0b1111111011"
                               ^^^^^^^^^^
                               9876543210

Дійсно, 2це єдина цифра, яка не використовує нижній правий сегмент семисегментного дисплея.

C, 1098 345 323 319 байт

Перша друга Третя спроба. Нарешті вирішив скинути буфер екрану, щоб зберегти кілька байт. Ця програма бере параметр цифр і друкує цифри у 7-сегментному форматі.

Учасник першого разу. Задля розваги. Будь ніжним.

a[]={100489,2056,98569,67849,2440,67969,100737,2057,100745,67977},i,j,k,n,m;char*c=" /\\";
#define f(q,r) for(q=0;q<(r);q++)
#define P(w) putchar(w)
#define Q(d,i,j) P(c[a[v[1][d]-48]>>(i*3+j)*2&3])
main(w,char**v){f(i,n=strlen(v[1]))f(k,(m=n-i-1)?2:3){f(j,m*2)P(32);f(w,3)Q(m,k,w);if(!k&&i)f(w,2)Q(m+1,2,w+1);P(10);}}

Розширено, без попередження:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int a[]={100489,2056,98569,67849,2440,67969,100737,2057,100745,67977};
char *c=" /\\";
#define f(q,r) for(q=0;q<(r);q++)
#define P(w) putchar(w)
#define Q(d,i,j) P(c[a[v[1][d]-48]>>(i*3+j)*2&3])
int main(int w, char **v)
{
    int i,j,k,n,m;
    f(i,n=strlen(v[1])) {
        m=n-i-1;
        f(k,m?2:3) {
            f(j,m*2) P(32);
            f(w,3) Q(m,k,w);
            if (!k&&i) f(w,2) Q(m+1,2,w+1);
            P(10);
        }
    }
}

JavaScript, 192 178 167 162 байт

f=x=>{n=b="\n";for(k in x)for(i=0;i<8;)b+=("î\xA0Öô¸|~àþü".charCodeAt(x[k])>>i++&1?i%2?"/":"\\":" ")+(i%3?"":n+"  ".repeat(k));return b.split(n).reverse().join(n)}

Використання: f("1337");повернеться

      /\
        \
    /\   
     /\
  /\  /
   /\
 \  /
  \

Він використовує функції ES6 і може мати певну поведінку, що залежить від впровадження через пропуски крапки з комою та круглими дужками, і таке інше, але це працює у Firefox.

Розширено:

f=x=>
{
    n = b = "\n";

    for (k in x)
        for (i=0; i<8;)
            b += ("î\xA0Öô¸|~àþü".charCodeAt(x[k]) >> i++ & 1? i%2? "/" : "\\" : " ") + (i%3? "" : n+"  ".repeat(k));

    return b.split(n).reverse().join(n)
}

Пояснення:

lце масив, що містить 10 однобайтових символів, які відповідають формі кожної цифри. Наприклад, цифра 0 представлена ​​символом î:

/\        11
\ \  -->  101  --> 11 101 110 = î
 \/       011

Символи введення використовуються як ключі до масиву, що тримає їх форму, представляючи аналоги, які читаються по черзі.

Perl - 103 байти

#!perl -n
print$i+$%2?U^(u,$i--%2?v9:z)[$i<4+$%2&vec$_,4*$-3-$i,1]:$/.!($i=$--)
while$+=2*y/0-9/wPkz\\>?p~/

Наведене вище містить 6 недрукованих символів (джерело можна завантажити в Ideone ) і еквівалентно наступному:

#!perl -n
print$i+$^F%2?U^(u,$i--%2?v9:z)[$i<4+$^F%2&vec$_,4*$^F-3-$i,1]:$/.!($i=$^F--)
while$^F+=2*y/0-9/wPkz\\>?p\177~/

Кожен ^Fможе бути замінений буквальним символом 6 (ACK) і \177замінений символом 127 (DEL).

Шебанг рахується як 1, другий новий рядок не потрібен. Введення взято з stdin.

Використання зразка

$ echo 0123 | perl seven-slash.pl

      /\
       /\
    /\  /
     /
   \ \/
    \
/\
\ \
 \/

$ echo 456789 | perl seven-slash.pl

          /\
          \/\
        /\  /
        \/\
      /\ \/
        \
    /
    \/\
  /  \/
  \/\
 \  /
\/\

Пояснення

Вихід генерується по одному байту. Кожен символ транслітерується, і він інтерпретується як бітовий масив з використанням vec. Біти зберігаються таким чином:

   /\           56 
   \/\          234
 /\ \/   ->   56 01
 \/\          234 
  \/           01

Виводить чергування між 3 та 5 косою рисою, так що біти 56переливаються на 01наступну цифру. Біт 7не використовується.

C #, 360 355 331 байт

Привіт, перша спроба коду-гольфу. Сподіваємось, це не дуже погано оцінюється для C # -entry.

string p(string n){var l=new string[n.Length*2+1];var i=l.Length-1;for(;i>0;){var x=@"/\\ \\/ \  \  /\ / \//\ /\ / \\/\  / \/\ // \/\\//\  \  /\\/\\//\\/\ /".Substring((n[0]-48)*7,7);for(var j=i-3;j>=0;){l[j--]+="  ";}l[i--]+=" "+x[5]+x[6];l[i--]+=""+x[2]+x[3]+x[4];l[i]+=""+x[0]+x[1];n=n.Remove(0, 1);}return string.Join("\n",l);}

Використання: p("159114");повернеться

          \
         \/\
        \
         \
      \
       \
   /\
   \/\
 /   /
 \/\
\  /
 \

Розширено:

string p(string n)
    {
        var l = new string[n.Length * 2 + 1];
        var i = l.Length - 1;
        for (; i > 0; )
        {
            var x = @"/\\ \\/ \  \  /\ / \//\ /\ / \\/\  / \/\ // \/\\//\  \  /\\/\\//\\/\ /".Substring((n[0] - 48) * 7, 7);

            for (var j = i - 3; j >= 0; )
            {
                l[j--] += "  ";
            }
            l[i--] += " " + x[5] + x[6];
            l[i--] += "" + x[2] + x[3] + x[4];
            l[i] += "" + x[0] + x[1];

            n = n.Remove(0, 1);
        }

        return string.Join("\n", l);
    }

пітон 2, 317 298 278 273.15

def f(s):
    r=range;n=len(s)*2;l=[[' ']*-~n for x in r(-~n)]
    for x in r(0,n,2):
        for i,[d,y,c]in enumerate(zip('0112012','1021012',r'\\\\///')):l[n-2-x+int(y)][x+int(d)]=[' ',c][('%7s'%(bin(ord('}(7/jO_,\x7fo'[map(int,s)[x/2]])))[2:])[i]=='1']
    for x in l:print''.join(x)

Я вважав 4-пробіли вкладками під час підрахунку.
Нестиснений і читабельний:

def f(s):
    r=['1111101','0101000','0110111','0101111','1101010','1001111','1011111','0101100','1111111','1101111']
    ''.join(map(lambda x:chr(eval('0b'+x)),r))
    n=len(s)*2
    l=[[' ']*(n+1) for x in xrange(n+1)]
    shifts=[(0,1,'\\'),(1,0,'\\'),(1,2,'\\'),(2,1,'\\'),(0,0,'/'),(1,1,'/'),(2,2,'/')]
    for x in xrange(0,n,2):
        y=n-2-x
        for i,[dx,dy,c] in enumerate(shifts):
            l[y+dy][x+dx]=c if r[map(int,s)[x/2]][i]=='1' else ' '
    return '\n'.join(''.join(x) for x in l)

КДБ (Q), 172 136 байт

{d:(9#1 2 0 2)*/:-9#'0b vs'427 136 403 409 184 313 315 392 443 441;
 -1" /\\"{m+(c,/:y),c:(count[m:0 0,x,\:0 0]-3)#0}/[3 3#/:d"J"$'(),x];}

Пояснення

1) Створіть dкарту з усіма цифрами фігур.

2) Прокладіть матрицю додатковими нулями та додайте їх разом. тобто "01"

0           0 0 0 2 0   
0           0 0 0 0 2
1 2 0 0 0 + 0 0 0 0 0
2 0 2 0 0   0
0 2 1 0 0   0

3) Використовуйте індекс для картографування " /\"та друку -1.

Тест

q){d:(9#1 2 0 2)*/:-9#'0b vs'427 136 403 409 184 313 315 392 443 441;-1" /\\"{m+(c,/:y),c:(count[m:0 0,x,\:0 0]-3)#0}/[3 3#/:d"J"$'(),x];}"0123456789"
                  /\
                  \/\
                /\  /
                \/\
              /\ \/
                \
            /
            \/\
          /  \/
          \/\
         \  /
        \/\
      /\
       /\
    /\  /
     /
   \ \/
    \
/\
\ \
 \/

Я впевнений, що це може бути коротшим !!

Дякую @hjk

Піп, 122 + 1 = 123 байт

Використовує -nпрапор. Здійснює введення через аргумент командного рядка.

l:$.(J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Ma)z:2*#ap:sXz+2RLz+2Fi,5Fj,z{c:[4-ii]//2+j(pc@0c@1):(lij)}RVp

Символи в рядку UTF-8 мають наступні кодові точки: 11152, 19190, 12535, 12547, 17651, 11575, 11557, 12629, 11071, 11089.

Трохи незворушений:

t:[120022001 222022202 122012021 122012201 220012202 120212201 120212001 122022202 120012001 120012201]
l:$.({J"\/ "@^t@a.2<>2}Ma)
z:2*#a+2
p:sXzRLz
Fi,5
 Fj,2*#a {
  x:i//2+j
  y:(4-i)//2+j
  p@y@x:l@i@j
 }
P RVp

Основна стратегія полягає в тому, щоб знайти складові символи кожного номера, а потім їх перекосити відповідним чином. Наприклад, для 8, ми хочемо цього (пробіли, представлені крапками):

/.
\\
/.
\\
/.

що перетвориться на це:

 .  
/\. 
\/\.
 \/ 

Приємною особливістю цієї стратегії є те, що кілька попередньо перекошених чисел можна просто об'єднати поряд.

Тепер ми можемо кодувати /.\\/.\\/.в базі 3 як 1200120012. Тоді ми можемо перетворити це в десятковий і розглядати його як кодову точку UTF-8.

Вираз J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Maотримує попередньо перекосовані дані шляхом наступного процесу:

                            Ma   Map this lambda function to each character in input:
        (A_TB3M"...")            Create list of the code points of each character in UTF-8
                                   string, converted to base 3
                     @_          Index into that list using the input character
                       .2        Concatenate 2 to the end of the base-3 value (all of the
                                   pre-skewed number grids end in 2, i.e. space)
       ^                         Split the number into a list of its digits
 "\/ "@                          Index into this string with those digits, giving a list
                                   of slashes & spaces
J                                Join the list together into a string
                         <>2     Group string two characters at a time

Після того як ми з'єднали ці рядки поряд з використанням $., тоді створимо сітку пробілів (2 * n +2 квадратних), проведіть цикл за попередньо перекошеною сіткою та замінимо відповідні пробіли в сітці після перекосу на відповідні символи. Щоб побачити це, можна змінити код для друку кожного етапу та паузу для введення користувача:

Сітка насправді побудована догори дном, бо це, здавалося, полегшило математику.

Я впевнений, що краще використовувати алгоритми. Але я хотів придумати власну ідею, а не копіювати чужу.

Детальніше про Pip

Brainfuck - 719 байт

Лише для історичного контексту, кредити Данило Б Кристофані. Я не точно впевнений, коли це було створено, але це доступно в Інтернет-архіві вже 9 травня 2003 року.

Вихід для 9інший, ніж в описі проблеми.

>>>>+>+++>+++>>>>>+++[
  >,+>++++[>++++<-]>[<<[-[->]]>[<]>-]<<[
    >+>+>>+>+[<<<<]<+>>[+<]<[>]>+[[>>>]>>+[<<<<]>-]+<+>>>-[
      <<+[>]>>+<<<+<+<--------[
        <<-<<+[>]>+<<-<<-[
          <<<+<-[>>]<-<-<<<-<----[
            <<<->>>>+<-[
              <<<+[>]>+<<+<-<-[
                <<+<-<+[>>]<+<<<<+<-[
                  <<-[>]>>-<<<-<-<-[
                    <<<+<-[>>]<+<<<+<+<-[
                      <<<<+[>]<-<<-[
                        <<+[>]>>-<<<<-<-[
                          >>>>>+<-<<<+<-[
                            >>+<<-[
                              <<-<-[>]>+<<-<-<-[
                                <<+<+[>]<+<+<-[
                                  >>-<-<-[
                                    <<-[>]<+<++++[<-------->-]++<[
                                      <<+[>]>>-<-<<<<-[
                                        <<-<<->>>>-[
                                          <<<<+[>]>+<<<<-[
                                            <<+<<-[>>]<+<<<<<-[
                                              >>>>-<<<-<-
  ]]]]]]]]]]]]]]]]]]]]]]>[>[[[<<<<]>+>>[>>>>>]<-]<]>>>+>>>>>>>+>]<
]<[-]<<<<<<<++<+++<+++[
  [>]>>>>>>++++++++[<<++++>++++++>-]<-<<[-[<+>>.<-]]<<<<[
    -[-[>+<-]>]>>>>>[.[>]]<<[<+>-]>>>[<<++[<+>--]>>-]
    <<[->+<[<++>-]]<<<[<+>-]<<<<
  ]>>+>>>--[<+>---]<.>>[[-]<<]<
]
[Enter a number using ()-./0123456789abcdef and space, and hit return.
Daniel B Cristofani (cristofdathevanetdotcom)
http://www.hevanet.com/cristofd/brainfuck/]

Perl, 270 байт

Я дійсно не повинен був витрачати час на це.

$e="\\";$g=" ";$_=reverse<>;$l=length;push@a,(119,18,107,91,30,93,125,19,127,95)[$1]while/(.)/g;for($i=0;$i<=$l;$i++){$j=2*($l-$i);$b=$a[$i];$c=$i&&$a[$i-1];print" "x$j,$b&1?"/":$g,$b&2?$e:$g,$g,$c&32?$e:$g,$c&64?"/":$g,"
"," "x$j,$b&4?$e:$g,$b&8?"/":$g,$b&16?$e:$g,"
"}

JavaScript ( ES6 ), 191 206

Запустіть фрагмент у Firefox для тестування.

F=m=>(
  a='    \\/  /\\/\\ /  /\\  \\\\ \\'.match(/.../g),
  o=f='',r=' ',
  [for(d of m)(
    n=1e3+'¯B\x91ÿ$ê\x86A\x87ë'.charCodeAt(d)+'', // here there are 3 valid characters tha the evil stackoverflow editor just erase off, so I had to put them as hex escape
    o='\n'+f+' '+a[n[2]]+'\n'+r+a[n[1]]+o,
    r=f+a[n[3]],
    f+='  ')],
  r+o
)


//TEST

go=_=>O.innerHTML =(v=I.value)+'\n'+F(v)

go()

<input id=I value='0123456789'><button onclick='go()'>-></button>
<pre id=O></pre>

Java 8, 341 байт

n->{int i=n.length*2,j=i+1,k=0,t;String l[]=new String[j],x;for(;j-->0;l[j]="");for(;i>0;l[i--]+=" "+x.substring(5,7),l[i--]+=x.substring(2,5),l[i]+=x.substring(0,2))for(x="/~~ ~~/ ~  ~  /~ / ~//~ /~ / ~~/~  / ~/~ // ~/~~//~  ~  /~~/~~//~~/~ /".replace('~','\\').substring(t=(n[k++]-48)*7,t+7),j=i-2;j-->0;)l[j]+="  ";return"".join("\n",l);}

Відповідь C # .NET на порту @Shion , тому обов'язково підтримайте його!

Спробуйте в Інтернеті.

Пояснення:

n->{                       // Method with character-array parameter and String return-type
  int i=n.length*2,        //  Two times the length of the input array
      j=i+1,               //  Index integer, starting at `i+1`
      k=0,t;               //  Temp integers
  String l[]=new String[j],//  String-array for the rows, default filled with `null`
         x;                //  Temp-String
  for(;j-->0;l[j]="");     //  Replace all `null` with empty Strings
  for(;i>0                 //  Loop `i` downwards in the range [`n.length*2`, 0)
      ;                    //   After every iteration:
       l[i--]+=            //    Append the row at index `i` with:
                           //    (and decrease `i` by 1 afterwards with `i--`)
         " "               //     A space
         +x.substring(5,7),//     And the 6th and 7th characters of temp-String `x`
       l[i--]+=            //    Append the row at index `i` with:
                           //    (and decrease `i` by 1 afterwards with `i--`)
         x.substring(2,5), //     The 3rd, 4th and 5th characters of temp-String `x`
       l[i]+=              //    Append the row at index `i` with:
         x.substring(0,2)) //     The 1st and 2nd characters of the temp-String `x`
    for(x="/~~ ~~/ ~  ~  /~ / ~//~ /~ / ~~/~  / ~/~ // ~/~~//~  ~  /~~/~~//~~/~ /".replace('~','\\')
                           //   String containing all digit-parts
          .substring(t=(n[k++]-48)*7,t+7),
                           //   and take the substring of 7 characters at index
                           //   `n[k]` as integer multiplied by 7
        j=i-2;j-->0;)      //   Inner loop `j` in the range (`i`-2, 0]
      l[j]+="  ";          //    And append the rows at index `j` with two spaces
  return"".join("\n",l);}  //  Return the rows delimited with new-lines