Podstawowe dane ASCII

36

Alternatywny tytuł: Tally Your Prison Sentence on the Wall

Biorąc pod uwagę liczbę n, dane wyjściowe pogrupowane w tradycyjne 5-na-grupę i 50 na wiersz.


Przykłady

1

|
|
|
|

4

||||
||||
||||
||||

5

|||/
||/|
|/||
/|||

6

|||/ |
||/| |
|/|| |
/||| |

50

|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 

51

|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 

|
|
|
|

256

|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 

|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 

|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 

|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 

|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 

|||/ |
||/| |
|/|| |
/||| |

Zasady

  • 5 słupków na grupę, 50 łącznych słupków na wiersz.
  • Pierwsze 4 słupki są pionowe, piąta suma przecina wszystkie pozostałe słupki.
    • Każda z pierwszych czterech składa się z 4 pionowych |znaków.
    • Ostatnie 5 podsumowanie obejmuje wszystkie 4 pierwsze z /postacią po przekątnej.
  • Każda grupa powinna być oddzielona spacją, a każdy wiersz pustą nową linią.
  • Ograniczenia nsą następujące: 0 <= n <= 1000(dla uproszczenia).
  • Końcowe spacje i znaki nowej linii są w porządku, poprzednie nie.
  • Jest to , wygrywa najmniej bajtów.

Ocenione przez ~ 4 osoby w piaskownicy .


PS trochę zabawy, średnia liczba haseł w rzędzie w więzieniu wynosiła 50, stąd alt. tytuł.

Urna Magicznej Ośmiornicy
źródło
Powiązane
Magic Octopus Urn
Wielkie wyzwanie, złożone, ale proste.
ATaco,
@ATaco Naprawdę chcę znaleźć rozwiązanie, które agreguje ukośniki na „dużym obrazie” i bierze pod uwagę, że wzór cięcia można wywnioskować na podstawie wiersza (to łatwa wygrana).
Magic Octopus Urn
2
Dziękuję bardzo za zrobienie ich w przód zamiast w przód.
całkowicie ludzki,
1
@ totalniehuman O Boże, facet na obrazie, który zamieściłem, robi ... CO TO JEST WSZECHŚWIAT? To znowu niedźwiedzie Bernsteina ... Czy moneta wylądowała na głowach lub ogonach, aby zdecydować o ostatnich wyborach w USA ?!
Magic Octopus Urn

Odpowiedzi:

11

Węgiel drzewny , 30 25 bajtów

FN«J﹪ι⁵⁰×⁵÷ι⁵⁰¿﹪⊕ι⁵↓⁴«←↙⁴

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

 N                          Input number
F «                         Loop over implicit range
     ι     ι                Loop index
      ⁵⁰    ⁵⁰              Literal 50
    ﹪                       Modulo
          ÷                 Integer divide
         ⁵                  Literal 5
        ×                   Multiply
   J                        Jump to column, row
                 ι          Loop index
                ⊕           Incremented
                  ⁵         Literal 5
               ﹪            Modulo
              ¿             If
                   ↓⁴       Print 4 `|`s downwards
                     «      Implicit else
                      ←     Move left
                       ↙⁴   Print 4 `/`s down and left
Neil
źródło
6

Funky , 156 132 133 bajtów

n=>{k=n=>((l="|"::rep)(3-i)+"/"+l(i)+" ")::rep(n)p=print L=f=>fori=0i<4i++p(f())forc=0c<n//50c++{L@k(10);p()}L@k((m=n%50)//5)+l(m%5)}

Wypróbuj online!

ATaco
źródło
1
Funky to ... Co teraz? Ciekawy. Nigdy wcześniej nie widziałem tego języka na żadnym z moich wyzwań.
Magic Octopus Urn
1
@MagicOctopusUrn Prawdopodobnie dlatego, że to napisałem: P
ATaco
1
Język oparty na JavaScript? Niebezpieczny. Ale to dobrze, uwielbiam niebezpieczeństwo.
Magic Octopus Urn
1
fori=0i<4i++p(f())forc=0c<n//50c++czym jest ta bezbożna bestia, która nazywa się składnią
totalnie ludzki
6

Haskell , 117 bajtów

f m|m<1=""|n<-min 50 m=unlines[[last$"| "!!(0^c%5):['/'|r+c%5==4,n-n%5>c]|c<-[1..n]]|r<-[0..3]]++'\n':f(m-50)
(%)=mod

Wypróbuj online!

Laikoni
źródło
5

Galaretka , 37 bajtów

:5[“|||/”]ẋ;”|ẋ⁸%5¤¤W¤ṙ€4Ḷ¤s⁵Z€G€j⁾¶¶

Wypróbuj online!

Wyjaśnienie

:5[“|||/”]ẋ;”|ẋ⁸%5¤¤W¤ṙ€4Ḷ¤s⁵Z€G€j⁾¶¶  Main Link
:5                                     Floordiv by 5
  [“|||/”]ẋ                            Repeat ["|||/"] by this number
           ;                           Append
            ”|ẋ    ¤                   "|" repeated by
               ⁸%5¤                    The argument modulo 5
                    W¤                 Then wrapped to prevent weirdness
                      ṙ€               Rotate each tally segment by
                        4Ḷ¤            (each) [0, 1, 2, 3]
                           s⁵          Slice into pieces of length 10 (to get 50 per row)
                             Z€        Transpose each
                               G€      Convert each into a grid
                                 j⁾¶¶  Join these grids by a double newline

gdzie to jest za długie

HyperNeutrino
źródło
@FrownyFrog naprawiono, dziękuję!
HyperNeutrino,
4

Łuska , 29 bajtów

J;øṀṪṙŀ4C10§:oR"|||/"÷5oR'|%5

Wypróbuj online!

Wydaje mi się, że pierwszy 5jest zbędny, ale usunięcie go powoduje błąd typu ...

Wyjaśnienie

J;øṀṪṙŀ4C10§:oR"|||/"÷5oR'|%5  Implicit input, an integer n.
                       oR'|    Repeat the character '|'
                           %5  n mod 5 times.
             oR"|||/"          Repeat the string "|||/"
                     ÷5        n/5 times.
           §:                  Tack the '|'-string to the end of that list.
        C10                    Cut the list of strings into pieces of length 10.
   Ṁ                           For each piece,
    Ṫ ŀ4                       for each k in [0,1,2,3],
     ṙ                         rotate each string k steps to the left
                               and collect the results into a list.
                               Now we have a list of lists of lists of strings.
J;ø                            Join them with the list [[]].
                               Implicitly join each list of strings by spaces,
                               then join the resulting list of strings by newlines,
                               and print the result.
Zgarb
źródło
4

SOGL V0.12 , 33 bajty

ā.{┐4∙F5\?X1w⁄3-14╚╬5@}┼FM»\?O¶oā

Wypróbuj tutaj!

Gra w golfa na telefonie jest trudna ..

Wyjaśnienie:

ā                                  push an empty array
 .{                                repeat input times
   ┐4∙                               push a 4 tall line
      F5\?            }              if the counter (1-indexed) divides by 5
          X                            pop that vertical line
           1w⁄                         get the width of the main array
              3-                       subtract 3 from that width - X position
                1                      push 1 - Y position
                 4╚                    push a 4 long diagonal
                   ╬5                  place that in the main array at [width-3; 1]
                     @                 push a space - for the below to add spacing
                       ┼             append horizontally
                        FM»\?        if the counter divides by 50
                             O         output the main array
                              ¶o       output a newline
                                ā      push a new array
                                       (note that the outputting here doesn't disable
                                       implicit outputting)
dzaima
źródło
4

JavaScript (ES6), 139 137 bajtów

n=>eval('s="";for(i=0;i++<=n/50;s+=N)for(j=5;--j;s+=N=`\n`)for(k=0;k<(x=(y=n-i*50)<0?50+y:50);)s+=++k%5?k%5-j|k>5*(x/5|0)?"|":"/":" ";s')

Zwraca ciąg z jednym końcowym znakiem nowej linii, gdy nnie jest wielokrotnością 50, i jeden z kilkoma końcowymi znakami nowej linii, gdy n jest wielokrotnością 50.

Bez golfa

n=>{
    s=""
    for(i=0; i++ <= n/50; s+=N)
        for(j=5; --j; s+=N=`\n`)
            for(k=0; k < (x = (y = n-i*50) < 0 ? 50+y : 50);)
                s += ++k%5 ?
                    k%5-j|k>5*(x/5|0) ?
                        "|"
                    : "/"
                : " "
    return s
}

Test Snippet

Nierozwiązanie eval, 150 bajtów

n=>(A=(v,m)=>j=>[...Array(v).keys()].map(m).join(j))(n/50+1|0,i=>A(4,j=>A(x=(y=n+~i*50)<0?50+y:50,k=>++k%5?k%5-4+j|k>5*(x/5|0)?"|":"/":" ")``)`
`)`

`

Być może jest w stanie zagrać w tę grę dalej, ale evalmetoda była jak dotąd krótsza.

Justin Mariner
źródło
Zajęło mi to 10 minut, aby przejść przez wersję bez golfa i zrozumieć ją. = ^ P Masz tam kilka fajnych sztuczek.
DLosc
całkiem pewne, że możesz to zrobić dla (i = 0; ++ i <n / 50; s + = N), co oszczędza jeden znak
DanielIndie
@DanielIndie To się nie udaje, ponieważ zewnętrzna pętla działa zbyt wiele razy: Wypróbuj online!
Justin Mariner,
4

J , 50 48 45 35 33 bajtów

_50|:\'|/ '{~[{.(|.2,=i.4)$~]-5|]

Wypróbuj online!

                (    =i.4)          Identity matrix of size 4.
                (  2,    )          Prepend a row of 2s.
                (|.      )          Upside down.
                          $~        Take __ rows.
                            ]-5|]   Input rounded down to a multiple of 5.
             [{.                    Pad with rows of zeroes to [input] rows.
      '|/ '{~                       Get the characters.
_50|:\                              Transpose and fit to width.
FrownyFrog
źródło
Podoba mi się pomysł używania w tej części 4,&' '\7$'|||/'
poprawek
@Jonah musiało iść :(
FrownyFrog,
3

C (gcc), 170 bajtów

char*s="|||/ \0||/| \0|/|| \0/||| \0";h;k;g(x){for(h=0;h<5;h++){for(k=x;k>4;k-=5)printf(s+6*h);for(;k&&h-4;k--)printf("|");putchar(10);}}f(x){for(;x>49;x-=50)g(50);g(x);}

Wypróbuj online!

fto funkcja przyjmująca nieujemną liczbę całkowitą ( x) i wypisująca na standardowe wyjście wiele wartości pogrupowanych według specyfikacji

gto funkcja pomocnicza, która drukuje wartości x, pogrupowane według 5, bez podziału linii.

fwywołań g(50)i dekrecji xo 50, aż będzie mniejsza niż 50, a następnie wywoła, g(x)aby wydrukować pozostałe wartości na jednej linii.

sjest char*taki, że jako ciągi, sjest pierwszym rzędem pakietu, s+6jest drugim, s+12trzecim i s+18czwartym, i s+24jest pustym ciągiem.

g(x)drukuje pakiety i zmniejsza x x 5, aż x jest mniejsze niż 5, a następnie drukuje xpojedyncze wartości.

pizzapanty184
źródło
135 bajtów
ceilingcat
2

Python 2 , 142 bajty

n=input()
while n>0:print"\n".join("".join("|/ "[2*(j%5>3)+(n/(5*(j/5+1))and 3-i==j%5)]for j in range(min(50,n)))for i in range(4)),"\n";n-=50

Wypróbuj online!

Halvard Hummel
źródło
1
142 bajty w 18 minut? Nie jest zły :).
Magic Octopus Urn
3
Muszę pracować szybko, kiedy naprawdę powinieneś iść spać godzinę temu
Halvard Hummel
Quick ~= Quality;). Dobra robota.
Magic Octopus Urn
3
Errr ... to może być źle zinterpretowane. Mówiąc, że zrobiłeś jakość pracujesz szybko ... Nie odwrotnie.
Magic Octopus Urn
2
138 bajtów
ovs
2

Perl 5 , 103 bajtów

$a=<>;do{$_=$a<50?"|||/ "x($a/5).'|'x($a%5):"|||/ "x10;for$i(1..4){say;s%\|/%/|%g}say""}while($a-=50)>0

Wypróbuj online!

Xcali
źródło
2

Haskell , 134 bajty

f#n=unlines$(concat.f.(<$[1..n`div`5]))<$>["|||/ ","||/| ","|/|| ","/||| "]
f n|n>50=id#50++'\n':f(n-50)|1>0=(++['|'<$[1..n`mod`5]])#n

Wypróbuj online!

asdfghjkl-- Tak, pracuję nad tym.

całkowicie ludzki
źródło
2

PHP, 138 141 + 1 bajtów

prawdopodobnie nie najkrótsze możliwe rozwiązanie

for(;0<$z=50+min($n=$x=$y=0,$argn-=50);print"
")while($n++<$z||!$x=+(3<$y+=$n=print"
"))echo"/| "[$n%5?($y+$x++)%4<3|$n%5+$y<4|$z-$z%5<$n:2];

Uruchom jako potok z -nRlub spróbuj online .

Tytus
źródło
Schludny! Ale od drugiej linii liczebności statystyki nie zostały całkowicie przekroczone.
SpazzMarticus
Podczas uruchamiania przykładu „spróbuj online” od wersji 5.5, lokalnie 5.6.31 i 7.1.9.
SpazzMarticus
1
$xjest niezdefiniowany tylko w pierwszej pętli, to miesza wynik dla Tally powyżej 54. Naprawiono, ale nie gra w
SpazzMarticus
@SpazzMarticus naprawiono
Tytus
Fajne! To był mój pierwszy raz debugowanie kodu golfowego, sprawiłeś mi trudność! :) Myślę, że jestem uzależniony!
SpazzMarticus
2

Pyton, 129 113 112 bajtów

f=lambda n:n>50and f(50)+"\n\n"+f(n-50)or"\n".join(("|||/|||"[k:k+4]+" ")*(n//5)+" "+"|"*(n%5)for k in range(4))

Wyjaśnienie

def p(n):
  if n > 50:
    return p(50) + "\n\n" + p(n-50) # Handle 50-groups recursively
  else:
    # For each of the 4 lines:
    rows = []
    for row in range(4):
      #  - Build the "|||/"-blocks by slicing the correct part of "|||/|||".
      #  - Do that n/5 times
      #  - Then add "|" n%5 times
      rows += [("|||/|||"[row:row+4]+" ")*(n//5) + " " + "|"*(n%5)]

    # Join the four rows together
    return "\n".join(rows)

Działa w Python 2 i 3.

Wypróbuj online

Lukas Boersma
źródło
1

Java (OpenJDK 8) , 188 bajtów

i->{int j=0,l,k;String r="";for(;j<~-i/50+1;j++,r+="\n")for(l=0;l<4;l++,r+="\n")for(k=0;k<(j*50+50>i?i-j*50:50);k++)r+=k%5>3?" ":k%5==3-l?"/":"|";return r.replaceAll("/(?=(\\|*\n))","|");}

Wypróbuj online!

Roberto Graham
źródło
179 bajtów
ceilingcat
1

Rubinowy , 100 bajtów

->n{(n/-50*-4).times{|i|j=[n-i/4*50,50].min
$><<("|||/|||"[i%4,4]+" ")*(j/5)+?|*(j%5)+$/*(1+i%4/3)}}

Skomentował

->n{(n/-50*-4).times{|i|              #Calculate rows of tallies (Ruby rounds division towards negative infinity. Multiply by 4 lines per tally and iterate through them.)
  j=[n-i/4*50,50].min                 #Number of strokes printed in current row is either the number remaining, or 50, whichever is less
    $><<("|||/|||"[i%4,4]+" ")*(j/5)+ #Send to stdout the correct 4 chars selected from "|||/|||" plus a space, j/5 times (rounded down, which eliminates odd strokes.) 
    ?|*(j%5)+                         #If there are any odd strokes, add them to the output
    $/*(1+i%4/3)                      #followed by a newline (2 for the final line of each row of tallies.)
  }
}

Wypróbuj online!

Level River St
źródło
1

Pip , 47 46 bajtów

Wa-:yP('|X4.sRA3-_'/M,4)X(YMN[a50])/5.'|Xy%5.n

Wypróbuj online!

Wyjaśnienie

        Implicit: a is 1st cmdline arg, y is "", s is space, n is newline
W       While loop:
 a-:y   Each iteration, subtract y from a and check if a is still nonzero
        (Since "" is 0 in numeric contexts, this does nothing the first time through)
     P  Print the following:

('|X4.sRA3-_'/M,4)X(YMN[a50])/5.'|Xy%5.n
              M                           Map this function to each number in
               ,4                         range(4):
 '|X4                                      String of four pipe characters
     .s                                    Concatenate a space
       RA                                  Replace the character at index
         3-_                                (3 minus function argument)
            '/                              with forward slash

                                          We now have a list of four strings representing
                                           the rows of a group of 5 tally marks; the
                                           following operations apply to the list
                                           element-wise:

                       [a50]              List of a (number of remaining tallies) and 50
                     MN                   Get the min (number of tallies on this row)
                    Y                     Yank it into y
                   (        )/5           Divide by 5 (number of groups on this row)
(                )X                       String-multiply by that amount
                                   y%5    Number of leftover tallies on this row
                                '|X       String-multiply that many pipes
                               .          Concatenate
                                      .n  Concatenate a newline

Wynikowa lista będzie wyglądać mniej więcej tak:

["|||/ ||\n" "||/| ||\n" "|/|| ||\n" "/||| ||\n"]

Domyślnie Pkonkatenuje zawartość listy i wysyła je z końcowym znakiem nowej linii. Tak otrzymujemy

|||/ ||
||/| ||
|/|| ||
/||| ||

z dwoma końcowymi znakami nowej linii (jedną z zawartości listy i jedną dodaną przez P). Jeśli ma zostać wydrukowany inny wiersz, oznacza to wymaganą pustą linię między nimi.

DLosc
źródło
0

Befunge, 125 105 bajtów

$&:!#@_:::"2"v>*\5%4\`+1g1-,1+:14g\`#v_55+,$:#v_55+,
!}0:+*`"2"\-\<^!-g01%5\!`g41+5*5/5:::<0p01:-1<<<4-p4

Wypróbuj online!

James Holderness
źródło
0

05AB1E , 28 bajtów

5‰"|||/"¬‚×J4ôTôεε3Ý._}ø»¶«,

Wypróbuj online.

Wyjaśnienie:

5              # Divmod the (implicit) input-integer by 5
                #  i.e. 111 → [22,1]
  "|||/"        # Push string "|||/"
        ¬       # Push its first character (without popping the string itself): "|"
               # Pair them together: ["|||/","|"]
          ×     # Repeat it based on the divmod
                #  i.e. [22,1] → ["|||/|||/|||/...|||/|||/|||/","|"]
           J    # Join everything together to a single string
                #  → "|||/|||/|||/...|||/|||/|||/|"
            4ô  # Which is then split into block of size 4
                #  → ["|||/","|||/","|||/",...,"|||/","|||/","|||/","|"]
Tô              # Then split this list into sublists of size 10
                #  → ["|||/","|||/","|||/",...],[...,"|||/"],["|||/","|||/","|"]]
  ε             # For-each over the sublists:
   ε            #  Map over the strings in the sublist:
    3Ý          #   Push list [0,1,2,3]
      ._        #   For each: rotate the string that many times
                #    ("|||/" → ["|||/","||/|","|/||","/|||"])
              #  After the map: zip/transpose; swapping rows/columns
     »          #  Join each inner list by spaces, and then the strings by newlines
      ¶«        #  Append a newline to each string
        ,       #  And print with trailing newline

¶«,ma oczywiście kilka alternatywnych alternatywnych bajtów, takich jak ,¶?lub ,õ,.

Kevin Cruijssen
źródło
0

C (gcc) , 107 106 bajtów

i,j;f(n){for(;n>50;f(50))n-=50;for(i=5;--i;)for(j=0;putchar(++j+~n?j%5?(j-i)%5|n-j<n%5?'|':47:32:10)%5;);}

Wypróbuj online!

-1 dzięki pułapkowi cat

attinat
źródło