Grundlegende ASCII-Werte

36

Alternativer Titel: Zählen Sie Ihre Gefängnisstrafe an der Wand

Bei einer bestimmten Anzahl nwerden die Ausgabesummen in die traditionellen 5er-Gruppen und 50er-Reihen eingeteilt.


Beispiele

1

|
|
|
|

4

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

5

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

6

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

50

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

51

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

|
|
|
|

256

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

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

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

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

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

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

Regeln

  • 5 Tallies pro Gruppe, insgesamt 50 Tallies pro Reihe.
  • Die ersten 4 Tallies sind vertikal, die 5. Tally kreuzt alle anderen Tallies.
    • Die ersten vier |Zeichen bestehen jeweils aus 4 vertikalen Zeichen.
    • Die letzte fünfte Tally umfasst alle vier der ersten mit einem /diagonalen Charakter.
  • Jede Gruppe sollte durch ein Leerzeichen getrennt sein, jede Zeile eine Leerzeile.
  • Die Einschränkungen nsind: 0 <= n <= 1000(der Einfachheit halber).
  • Nachgestellte Leerzeichen und Zeilenumbrüche sind in Ordnung, vorangestellte nicht.
  • Dies ist , die niedrigste Anzahl an Bytes gewinnt.

Bewertet von ~ 4 Personen im Sandkasten .


PS Spaß, kleines bisschen, die durchschnittliche Anzahl der Tallies pro Reihe im Gefängnis war 50, daher der Alt. Titel.

Magische Kraken-Urne
quelle
Related
Magic Octopus Urn
Große Herausforderung, komplex und doch einfach.
ATaco
@ATaco Ich möchte unbedingt die Lösung finden, die die Schrägstriche im "Gesamtbild" zusammenfasst und berücksichtigt, dass das Schrägstrichmuster zeilenweise abgeleitet werden kann (das ist der einfache Gewinn).
Magic Octopus Urn
2
Vielen Dank so viel für sie vorwärts Schrägstriche statt rückwärts Schrägstriche zu machen.
Totalhuman
1
@totallyhuman Oh Gott, der Typ in dem Bild, das ich gepostet habe, macht ... WAS IST DAS UNIVERSUM? Es sind wieder die Bernsteinbären ... Ist die Münze auf Kopf oder Zahl gelandet, um die letzten US-Wahlen zu entscheiden ?!
Magic Octopus Urn

Antworten:

11

Kohle , 30 25 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

 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
quelle
6

Funky , 156 132 133 Bytes

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)}

Probieren Sie es online!

Ein Taco
quelle
1
Funky is a ... Was jetzt? Interessant. Ich habe diese Sprache noch nie bei einer meiner Herausforderungen gesehen.
Magic Octopus Urn
1
@MagicOctopusUrn Wahrscheinlich, weil ich es geschrieben habe: P
ATaco
1
Eine JavaScript-basierte Sprache? Gefährlich. Aber das ist okay, ich liebe die Gefahr.
Magic Octopus Urn
1
fori=0i<4i++p(f())forc=0c<n//50c++was ist das unheilige Tier den Namen Syntax unter
totallyhuman
5

Jelly , 37 Bytes

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

Probieren Sie es online!

Erläuterung

: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

wheee das ist zu lang

HyperNeutrino
quelle
@FrownyFrog behoben, danke!
HyperNeutrino
4

Schale , 29 Bytes

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

Probieren Sie es online!

Ich fühle mich wie die erste 5ist redundant, aber das Entfernen gibt einen Tippfehler ...

Erläuterung

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
quelle
4

SOGL V0.12 , 33 Bytes

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

Probieren Sie es hier aus!

Golfen am Telefon ist schwer ..

Erläuterung:

ā                                  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
quelle
4

JavaScript (ES6), 139 137 Bytes

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')

Gibt eine Zeichenfolge mit einer nachgestellten Zeile zurück, wenn nes sich nicht um ein Vielfaches von 50 handelt, und eine Zeichenfolge mit mehreren nachgestellten Zeilen, wenn n es sich um ein Vielfaches von 50 handelt.

Ungolfed

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
}

Testschnipsel

Nicht- evalLösung, 150 Bytes

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)?"|":"/":" ")``)`
`)`

`

Möglicherweise in der Lage, dieses weiter zu spielen, aber die evalMethode war bisher kürzer.

Justin Mariner
quelle
Ich habe solide 10 Minuten gebraucht, um die ungolfed Version durchzuarbeiten und zu verstehen. = ^ P Du hast ein paar nette Tricks dabei.
DLosc
ziemlich sicher, dass Sie für (i = 0; ++ i <n / 50; s + = N) tun können, was ein
Zeichen
@DanielIndie Das schlägt fehl, weil die äußere Schleife zu selten ausgeführt wird: Probieren Sie es online aus!
Justin Mariner
4

J , 50 48 45 35 33 Bytes

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

Probieren Sie es 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
quelle
Ich liebe die Idee, für diesen Teil Infixe zu verwenden4,&' '\7$'|||/'
Jonah,
@Jonah es musste gehen :(
FrownyFrog
3

C (gcc), 170 Bytes

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);}

Probieren Sie es online!

fist eine Funktion, die eine nichtnegative Ganzzahl ( x) verwendet und so viele Zeichen, gruppiert wie angegeben, nach stdout ausgibt

gist eine xHilfsfunktion, mit der Tallies, gruppiert nach 5, gedruckt werden, ohne dass Linien geteilt werden müssen.

fRuft auf g(50)und dekrementiert xum 50, bis es weniger als 50 ist. g(x)Ruft dann auf, um die verbleibenden Zahlen in einer Zeile auszudrucken.

sist char*so, dass als Zeichenfolgen sdie erste Reihe eines Bündels, s+6die zweite, s+12die dritte und s+18die vierte und s+24eine leere Zeichenfolge ist.

g(x)druckt Bündel und dekrementiert x um 5, bis x kleiner als 5 ist, und druckt dann xeinzelne Zahlen.

Pizzapants184
quelle
135 Bytes
Ceilingcat
2

Python 2 , 142 Bytes

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

Probieren Sie es online!

Halvard Hummel
quelle
1
142 Bytes in 18 Minuten? Nicht schlecht :).
Magic Octopus Urn
3
Ich musste schnell arbeiten, als du eigentlich vor einer Stunde ins Bett gehen hättest sollen
Halvard Hummel,
Quick ~= Quality;). Gute Arbeit.
Magic Octopus Urn
3
Ähm ... das könnte falsch verstanden werden. Zu sagen, Sie haben Qualität schnell erledigt ... Nicht das Gegenteil.
Magic Octopus Urn
2
138 Bytes
Ovs
2

Haskell , 134 Bytes

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

Probieren Sie es online!

asdfghjkl-- Ja, ich arbeite daran.

total menschlich
quelle
2

PHP, 138 141 + 1 Bytes

wahrscheinlich nicht die kürzest mögliche Lösung

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];

Laufen Sie als Pipe mit -nRoder probieren Sie es online aus .

Titus
quelle
Ordentlich! Ab der zweiten Zähllinie sind die Tallies jedoch nicht mehr vollständig gekreuzt.
SpazzMarticus
Wenn Sie Ihr Beispiel "online ausprobieren" ab 5.5 ausführen, lokal 5.6.31 und 7.1.9.
SpazzMarticus
1
$xist nur in der ersten Schleife undefiniert, dies bringt die Ausgabe durcheinander, wenn die Tally größer als 54 ist. Behoben, aber nicht golfen: sandbox.onlinephpfunctions.com/code/…
SpazzMarticus
@SpazzMarticus behoben
Titus
Cool! Es war mein erstes Mal, dass ich Golf-Code debuggte. Du hast es mir schwer gemacht! :) Ich glaube ich bin süchtig!
SpazzMarticus
2

Python, 129 113 112 Bytes

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))

Erläuterung

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)

Funktioniert in Python 2 und 3.

Probieren Sie es online aus

Lukas Boersma
quelle
1

Java (OpenJDK 8) , 188 Byte

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))","|");}

Probieren Sie es online!

Roberto Graham
quelle
179 Bytes
Ceilingcat
1

Ruby , 100 Bytes

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

Kommentiert

->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.)
  }
}

Probieren Sie es online!

Level River St
quelle
1

Pip , 47 46 Bytes

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

Probieren Sie es online!

Erläuterung

        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

Die resultierende Liste sieht ungefähr so ​​aus:

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

PVerkettet standardmäßig den Inhalt der Liste und gibt ihn mit einer nachgestellten Newline aus. So bekommen wir

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

mit zwei nachgestellten Zeilenumbrüchen (einer aus dem Listeninhalt und einer von P). Wenn eine weitere Zeile gedruckt werden soll, wird die erforderliche Leerzeile dazwischen angezeigt.

DLosc
quelle
0

Befunge, 125 105 Bytes

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

Probieren Sie es online!

James Holderness
quelle
0

05AB1E , 28 Bytes

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

Probieren Sie es online aus.

Erläuterung:

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

¶«,hat natürlich ein paar mögliche gleichbyte Alternativen, wie ,¶?oder ,õ,.

Kevin Cruijssen
quelle
0

C (GCC) , 107 106 Bytes

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;);}

Probieren Sie es online!

-1 dank ceilingcat

attinat
quelle